[Saved Objects] Adds managed to import options

packages/core/saved-objects/core-saved-objects-api-server-internal/src/lib/internal_utils.ts

@@ -293,11 +293,5 @@ export function setManaged({
   optionsManaged?: boolean;
   objectManaged?: boolean;
 }): boolean {
-  if (optionsManaged !== undefined) {
-    return optionsManaged;
-  } else if (optionsManaged === undefined && objectManaged !== undefined) {
-    return objectManaged;
-  } else {
-    return false;
-  }
+  return optionsManaged ?? objectManaged ?? false;
 }

packages/core/saved-objects/core-saved-objects-api-server-internal/src/lib/repository.ts

@@ -615,7 +615,7 @@ export class SavedObjectsRepository implements ISavedObjectsRepository {
           typeMigrationVersion: object.typeMigrationVersion,
           ...(savedObjectNamespace && { namespace: savedObjectNamespace }),
           ...(savedObjectNamespaces && { namespaces: savedObjectNamespaces }),
-          managed: setManaged({ optionsManaged, objectManaged: object.managed }),
+          managed: setManaged({ optionsManaged, objectManaged: object.managed }), // managed: optionsManaged ?? object.managed ?? false,
           updated_at: time,
           created_at: time,
           references: object.references || [],

packages/core/saved-objects/core-saved-objects-base-server-internal/src/legacy_alias/types.ts

@@ -59,4 +59,10 @@ export interface LegacyUrlAlias {
    * created because of saved object conversion, then we will display a toast telling the user that the object has a new URL.
    */
   purpose?: 'savedObjectConversion' | 'savedObjectImport';
+  /**
+   * Flag indicating if a saved object is managed by Kibana (default=false).
+   * Only used when upserting a saved object. If the saved object already
+   * exist this option has no effect.
+   */
+  managed?: boolean;
 }

packages/core/saved-objects/core-saved-objects-common/src/saved_objects_imports.ts

@@ -91,6 +91,7 @@ export interface SavedObjectsImportFailure {
    * If `overwrite` is specified, an attempt was made to overwrite an existing object.
    */
   overwrite?: boolean;
+  managed?: boolean;
   error:
     | SavedObjectsImportConflictError
     | SavedObjectsImportAmbiguousConflictError
@@ -125,6 +126,14 @@ export interface SavedObjectsImportSuccess {
    * If `overwrite` is specified, this object overwrote an existing one (or will do so, in the case of a pending resolution).
    */
   overwrite?: boolean;
+  /**
+   * Flag indicating if a saved object is managed by Kibana (default=false)
+   *
+   * This can be leveraged by applications to e.g. prevent edits to a managed
+   * saved object. Instead, users can be guided to create a copy first and
+   * make their edits to the copy.
+   */
+  managed?: boolean;
 }
 
 /**

packages/core/saved-objects/core-saved-objects-import-export-server-internal/src/import/import_saved_objects.test.ts

@@ -80,10 +80,12 @@ describe('#importSavedObjectsFromStream', () => {
         management: { icon: `${type}-icon` },
       } as any),
     importHooks = {},
+    managed,
   }: {
     createNewCopies?: boolean;
     getTypeImpl?: (name: string) => any;
     importHooks?: Record<string, SavedObjectsImportHook[]>;
+    managed?: boolean;
   } = {}): ImportSavedObjectsOptions => {
     readStream = new Readable();
     savedObjectsClient = savedObjectsClientMock.create();
@@ -98,19 +100,23 @@ describe('#importSavedObjectsFromStream', () => {
       namespace,
       createNewCopies,
       importHooks,
+      managed,
     };
   };
   const createObject = ({
     type = 'foo-type',
     title = 'some-title',
-  }: { type?: string; title?: string } = {}): SavedObject<{
+    managed = undefined, // yea, explicitly declare this as not set to test against existing objects
+  }: { type?: string; title?: string; managed?: boolean } = {}): SavedObject<{
     title: string;
+    managed?: boolean;
   }> => {
     return {
       type,
       id: uuidv4(),
       references: [],
       attributes: { title },
+      managed,
     };
   };
   const createError = (): SavedObjectsImportFailure => {
@@ -320,6 +326,55 @@ describe('#importSavedObjectsFromStream', () => {
           importStateMap,
           overwrite,
           namespace,
+          managed: options.managed,
+        };
+        expect(mockCreateSavedObjects).toHaveBeenCalledWith(createSavedObjectsParams);
+      });
+
+      test('creates managed saved objects', async () => {
+        const options = setupOptions({ managed: true });
+        const collectedObjects = [createObject({ managed: true })];
+        const filteredObjects = [createObject({ managed: false })];
+        const errors = [createError(), createError(), createError(), createError()];
+        mockCollectSavedObjects.mockResolvedValue({
+          errors: [errors[0]],
+          collectedObjects,
+          importStateMap: new Map([
+            ['foo', {}],
+            ['bar', {}],
+            ['baz', { isOnlyReference: true }],
+          ]),
+        });
+        mockCheckReferenceOrigins.mockResolvedValue({
+          importStateMap: new Map([['baz', { isOnlyReference: true, destinationId: 'newId1' }]]),
+        });
+        mockValidateReferences.mockResolvedValue([errors[1]]);
+        mockCheckConflicts.mockResolvedValue({
+          errors: [errors[2]],
+          filteredObjects,
+          importStateMap: new Map([['foo', { destinationId: 'newId2' }]]),
+          pendingOverwrites: new Set(),
+        });
+        mockCheckOriginConflicts.mockResolvedValue({
+          errors: [errors[3]],
+          importStateMap: new Map([['bar', { destinationId: 'newId3' }]]),
+          pendingOverwrites: new Set(),
+        });
+
+        await importSavedObjectsFromStream(options);
+        const importStateMap = new Map([
+          ['foo', { destinationId: 'newId2' }],
+          ['bar', { destinationId: 'newId3' }],
+          ['baz', { isOnlyReference: true, destinationId: 'newId1' }],
+        ]);
+        const createSavedObjectsParams = {
+          objects: collectedObjects,
+          accumulatedErrors: errors,
+          savedObjectsClient,
+          importStateMap,
+          overwrite,
+          namespace,
+          managed: options.managed,
         };
         expect(mockCreateSavedObjects).toHaveBeenCalledWith(createSavedObjectsParams);
       });
@@ -382,6 +437,214 @@ describe('#importSavedObjectsFromStream', () => {
         };
         expect(mockCreateSavedObjects).toHaveBeenCalledWith(createSavedObjectsParams);
       });
+
+      test('creates managed saved objects', async () => {
+        const options = setupOptions({ createNewCopies: true, managed: true });
+        const collectedObjects = [createObject({ managed: true })];
+        const errors = [createError(), createError()];
+        mockCollectSavedObjects.mockResolvedValue({
+          errors: [errors[0]],
+          collectedObjects,
+          importStateMap: new Map([
+            ['foo', {}],
+            ['bar', { isOnlyReference: true }],
+          ]),
+        });
+        mockCheckReferenceOrigins.mockResolvedValue({
+          importStateMap: new Map([['bar', { isOnlyReference: true, destinationId: 'newId' }]]),
+        });
+        mockValidateReferences.mockResolvedValue([errors[1]]);
+        mockRegenerateIds.mockReturnValue(new Map([['foo', { destinationId: `randomId1` }]]));
+
+        await importSavedObjectsFromStream(options);
+        // assert that the importStateMap is correctly composed of the results from the three modules
+        const importStateMap: ImportStateMap = new Map([
+          ['foo', { destinationId: `randomId1` }],
+          ['bar', { isOnlyReference: true, destinationId: 'newId' }],
+        ]);
+        const createSavedObjectsParams = {
+          objects: collectedObjects,
+          accumulatedErrors: errors,
+          savedObjectsClient,
+          importStateMap,
+          overwrite,
+          namespace,
+          managed: options.managed,
+        };
+        expect(mockCreateSavedObjects).toHaveBeenCalledWith(createSavedObjectsParams);
+      });
+    });
+
+    describe('managed option', () => {
+      test('if not provided, does not override existing property when already present, defaults to false for others', async () => {
+        const obj1 = createObject({ type: 'foo', managed: true });
+        const obj2 = createObject({ type: 'bar', title: 'bar-title', managed: false });
+
+        const options = setupOptions({
+          createNewCopies: false,
+          getTypeImpl: (type) => {
+            if (type === 'foo') {
+              return {
+                management: { getTitle: () => 'getTitle-foo', icon: `${type}-icon` },
+              };
+            }
+            return {
+              management: { icon: `${type}-icon` },
+            };
+          },
+        });
+
+        mockCheckConflicts.mockResolvedValue({
+          errors: [],
+          filteredObjects: [],
+          importStateMap: new Map(),
+          pendingOverwrites: new Set(),
+        });
+        mockCreateSavedObjects.mockResolvedValue({
+          errors: [],
+          createdObjects: [obj1, { ...obj2, managed: false }], // default applied in createSavedObjects
+        });
+
+        const result = await importSavedObjectsFromStream(options);
+        // successResults only includes the imported object's type, id, and destinationId (if a new one was generated)
+        const successResults = [
+          {
+            type: obj1.type,
+            id: obj1.id,
+            meta: { title: 'getTitle-foo', icon: `${obj1.type}-icon` },
+            managed: true,
+          },
+          {
+            type: obj2.type,
+            id: obj2.id,
+            meta: { title: 'bar-title', icon: `${obj2.type}-icon` },
+            managed: false,
+          },
+        ];
+
+        expect(result).toEqual({
+          success: true,
+          successCount: 2,
+          successResults,
+          warnings: [],
+        });
+      }); // assert that the documents being imported retain their prop or have the default applied
+
+      test('creates and converts objects from unmanaged to managed', async () => {
+        const obj1 = createObject({ type: 'foo', managed: false });
+        const obj2 = createObject({ type: 'bar', title: 'bar-title' });
+
+        const options = setupOptions({
+          createNewCopies: false,
+          managed: true,
+          getTypeImpl: (type) => {
+            if (type === 'foo') {
+              return {
+                management: { getTitle: () => 'getTitle-foo', icon: `${type}-icon` },
+              };
+            }
+            return {
+              management: { icon: `${type}-icon` },
+            };
+          },
+        });
+
+        mockCheckConflicts.mockResolvedValue({
+          errors: [],
+          filteredObjects: [],
+          importStateMap: new Map(),
+          pendingOverwrites: new Set(),
+        });
+        mockCreateSavedObjects.mockResolvedValue({
+          errors: [],
+          createdObjects: [
+            { ...obj1, managed: true },
+            { ...obj2, managed: true },
+          ], // default applied in createSavedObjects
+        });
+
+        const result = await importSavedObjectsFromStream(options);
+        // successResults only includes the imported object's type, id, and destinationId (if a new one was generated)
+        const successResults = [
+          {
+            type: obj1.type,
+            id: obj1.id,
+            meta: { title: 'getTitle-foo', icon: `${obj1.type}-icon` },
+            managed: true,
+          },
+          {
+            type: obj2.type,
+            id: obj2.id,
+            meta: { title: 'bar-title', icon: `${obj2.type}-icon` },
+            managed: true,
+          },
+        ];
+
+        expect(result).toEqual({
+          success: true,
+          successCount: 2,
+          successResults,
+          warnings: [],
+        });
+      }); // assert that the documents being imported retain their prop or have the default applied
+
+      test('creates and converts objects from managed to unmanaged', async () => {
+        const obj1 = createObject({ type: 'foo', managed: true });
+        const obj2 = createObject({ type: 'bar', title: 'bar-title' });
+
+        const options = setupOptions({
+          createNewCopies: false,
+          managed: false,
+          getTypeImpl: (type) => {
+            if (type === 'foo') {
+              return {
+                management: { getTitle: () => 'getTitle-foo', icon: `${type}-icon` },
+              };
+            }
+            return {
+              management: { icon: `${type}-icon` },
+            };
+          },
+        });
+
+        mockCheckConflicts.mockResolvedValue({
+          errors: [],
+          filteredObjects: [],
+          importStateMap: new Map(),
+          pendingOverwrites: new Set(),
+        });
+        mockCreateSavedObjects.mockResolvedValue({
+          errors: [],
+          createdObjects: [
+            { ...obj1, managed: false },
+            { ...obj2, managed: false },
+          ],
+        });
+
+        const result = await importSavedObjectsFromStream(options);
+        // successResults only includes the imported object's type, id, destinationId (if a new one was generated) and managed
+        const successResults = [
+          {
+            type: obj1.type,
+            id: obj1.id,
+            meta: { title: 'getTitle-foo', icon: `${obj1.type}-icon` },
+            managed: false,
+          },
+          {
+            type: obj2.type,
+            id: obj2.id,
+            meta: { title: 'bar-title', icon: `${obj2.type}-icon` },
+            managed: false,
+          },
+        ];
+
+        expect(result).toEqual({
+          success: true,
+          successCount: 2,
+          successResults,
+          warnings: [],
+        });
+      }); // assert that the documents being imported retain their prop or have the default applied
     });
   });