Refact: move workspace specific logic to savedObjectWrapper

CHANGELOG.md

@@ -43,6 +43,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 - [Discover] Update embeddable for saved searches ([#5081](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5081))
 - [Workspace] Add core workspace service module to enable the implementation of workspace features within OSD plugins ([#5092](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5092))
 - [Workspace] Setup workspace skeleton and implement basic CRUD API ([#5075](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5075))
+- [Workspace] Optional workspaces params in repository ([#5162](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5162))
 
 ### 🐛 Bug Fixes
 

src/core/public/saved_objects/saved_objects_client.ts

@@ -345,6 +345,7 @@ export class SavedObjectsClient {
       filter: 'filter',
       namespaces: 'namespaces',
       preference: 'preference',
+      workspaces: 'workspaces',
     };
 
     const renamedQuery = renameKeys<SavedObjectsFindOptions, any>(renameMap, options);

src/core/server/saved_objects/export/get_sorted_objects_for_export.test.ts

@@ -857,4 +857,17 @@ describe('getSortedObjectsForExport()', () => {
       `Can't specify both "search" and "objects" properties when exporting`
     );
   });
+
+  test('rejects when both types and objecys are passed in', () => {
+    const exportOpts = {
+      exportSizeLimit: 1,
+      savedObjectsClient,
+      objects: [{ type: 'index-pattern', id: '1' }],
+      types: ['foo'],
+    };
+
+    expect(exportSavedObjectsToStream(exportOpts)).rejects.toThrowErrorMatchingInlineSnapshot(
+      `Can't specify both "types" and "objects" properties when exporting`
+    );
+  });
 });

src/core/server/saved_objects/export/get_sorted_objects_for_export.ts

@@ -60,6 +60,8 @@ export interface SavedObjectsExportOptions {
   excludeExportDetails?: boolean;
   /** optional namespace to override the namespace used by the savedObjectsClient. */
   namespace?: string;
+  /** optional workspaces to override the workspaces used by the savedObjectsClient. */
+  workspaces?: string[];
 }
 
 /**
@@ -87,13 +89,15 @@ async function fetchObjectsToExport({
   exportSizeLimit,
   savedObjectsClient,
   namespace,
+  workspaces,
 }: {
   objects?: SavedObjectsExportOptions['objects'];
   types?: string[];
   search?: string;
   exportSizeLimit: number;
   savedObjectsClient: SavedObjectsClientContract;
   namespace?: string;
+  workspaces?: string[];
 }) {
   if ((types?.length ?? 0) > 0 && (objects?.length ?? 0) > 0) {
     throw Boom.badRequest(`Can't specify both "types" and "objects" properties when exporting`);
@@ -105,7 +109,9 @@ async function fetchObjectsToExport({
     if (typeof search === 'string') {
       throw Boom.badRequest(`Can't specify both "search" and "objects" properties when exporting`);
     }
-    const bulkGetResult = await savedObjectsClient.bulkGet(objects, { namespace });
+    const bulkGetResult = await savedObjectsClient.bulkGet(objects, {
+      namespace,
+    });
     const erroredObjects = bulkGetResult.saved_objects.filter((obj) => !!obj.error);
     if (erroredObjects.length) {
       const err = Boom.badRequest();
@@ -121,6 +127,7 @@ async function fetchObjectsToExport({
       search,
       perPage: exportSizeLimit,
       namespaces: namespace ? [namespace] : undefined,
+      ...(workspaces ? { workspaces } : {}),
     });
     if (findResponse.total > exportSizeLimit) {
       throw Boom.badRequest(`Can't export more than ${exportSizeLimit} objects`);
@@ -153,6 +160,7 @@ export async function exportSavedObjectsToStream({
   includeReferencesDeep = false,
   excludeExportDetails = false,
   namespace,
+  workspaces,
 }: SavedObjectsExportOptions) {
   const rootObjects = await fetchObjectsToExport({
     types,
@@ -161,6 +169,7 @@ export async function exportSavedObjectsToStream({
     savedObjectsClient,
     exportSizeLimit,
     namespace,
+    workspaces,
   });
   let exportedObjects: Array<SavedObject<unknown>> = [];
   let missingReferences: SavedObjectsExportResultDetails['missingReferences'] = [];

src/core/server/saved_objects/import/check_conflicts.ts

@@ -44,6 +44,7 @@ interface CheckConflictsParams {
   ignoreRegularConflicts?: boolean;
   retries?: SavedObjectsImportRetry[];
   createNewCopies?: boolean;
+  workspaces?: string[];
 }
 
 const isUnresolvableConflict = (error: SavedObjectError) =>
@@ -56,6 +57,7 @@ export async function checkConflicts({
   ignoreRegularConflicts,
   retries = [],
   createNewCopies,
+  workspaces,
 }: CheckConflictsParams) {
   const filteredObjects: Array<SavedObject<{ title?: string }>> = [];
   const errors: SavedObjectsImportError[] = [];
@@ -77,6 +79,7 @@ export async function checkConflicts({
   });
   const checkConflictsResult = await savedObjectsClient.checkConflicts(objectsToCheck, {
     namespace,
+    workspaces,
   });
   const errorMap = checkConflictsResult.errors.reduce(
     (acc, { type, id, error }) => acc.set(`${type}:${id}`, error),

src/core/server/saved_objects/import/create_saved_objects.ts

@@ -39,6 +39,7 @@ interface CreateSavedObjectsParams<T> {
   importIdMap: Map<string, { id?: string; omitOriginId?: boolean }>;
   namespace?: string;
   overwrite?: boolean;
+  workspaces?: string[];
 }
 interface CreateSavedObjectsResult<T> {
   createdObjects: Array<CreatedObject<T>>;
@@ -56,6 +57,7 @@ export const createSavedObjects = async <T>({
   importIdMap,
   namespace,
   overwrite,
+  workspaces,
 }: CreateSavedObjectsParams<T>): Promise<CreateSavedObjectsResult<T>> => {
   // filter out any objects that resulted in errors
   const errorSet = accumulatedErrors.reduce(
@@ -103,6 +105,7 @@ export const createSavedObjects = async <T>({
     const bulkCreateResponse = await savedObjectsClient.bulkCreate(objectsToCreate, {
       namespace,
       overwrite,
+      workspaces,
     });
     expectedResults = bulkCreateResponse.saved_objects;
   }

src/core/server/saved_objects/import/import_saved_objects.test.ts

@@ -165,7 +165,9 @@ describe('#importSavedObjectsFromStream', () => {
       expect(validateReferences).toHaveBeenCalledWith(
         collectedObjects,
         savedObjectsClient,
-        namespace
+        namespace,
+        undefined,
+        undefined
       );
     });
 
@@ -268,6 +270,52 @@ describe('#importSavedObjectsFromStream', () => {
         };
         expect(createSavedObjects).toHaveBeenCalledWith(createSavedObjectsParams);
       });
+
+      test('creates saved objects when workspaces param is provided', async () => {
+        const options = setupOptions();
+        options.workspaces = ['foo'];
+        const collectedObjects = [createObject()];
+        const filteredObjects = [createObject()];
+        const errors = [createError(), createError(), createError(), createError()];
+        getMockFn(collectSavedObjects).mockResolvedValue({
+          errors: [errors[0]],
+          collectedObjects,
+          importIdMap: new Map([
+            ['foo', {}],
+            ['bar', {}],
+            ['baz', {}],
+          ]),
+        });
+        getMockFn(validateReferences).mockResolvedValue([errors[1]]);
+        getMockFn(checkConflicts).mockResolvedValue({
+          errors: [errors[2]],
+          filteredObjects,
+          importIdMap: new Map([['bar', { id: 'newId1' }]]),
+          pendingOverwrites: new Set(),
+        });
+        getMockFn(checkOriginConflicts).mockResolvedValue({
+          errors: [errors[3]],
+          importIdMap: new Map([['baz', { id: 'newId2' }]]),
+          pendingOverwrites: new Set(),
+        });
+
+        await importSavedObjectsFromStream(options);
+        const importIdMap = new Map([
+          ['foo', {}],
+          ['bar', { id: 'newId1' }],
+          ['baz', { id: 'newId2' }],
+        ]);
+        const createSavedObjectsParams = {
+          objects: collectedObjects,
+          accumulatedErrors: errors,
+          savedObjectsClient,
+          importIdMap,
+          overwrite,
+          namespace,
+          workspaces: options.workspaces,
+        };
+        expect(createSavedObjects).toHaveBeenCalledWith(createSavedObjectsParams);
+      });
     });
 
     describe('with createNewCopies enabled', () => {

src/core/server/saved_objects/import/import_saved_objects.ts

@@ -54,6 +54,7 @@ export async function importSavedObjectsFromStream({
   savedObjectsClient,
   typeRegistry,
   namespace,
+  workspaces,
 }: SavedObjectsImportOptions): Promise<SavedObjectsImportResponse> {
   let errorAccumulator: SavedObjectsImportError[] = [];
   const supportedTypes = typeRegistry.getImportableAndExportableTypes().map((type) => type.name);
@@ -73,19 +74,23 @@ export async function importSavedObjectsFromStream({
   const validateReferencesResult = await validateReferences(
     collectSavedObjectsResult.collectedObjects,
     savedObjectsClient,
-    namespace
+    namespace,
+    undefined,
+    workspaces
   );
   errorAccumulator = [...errorAccumulator, ...validateReferencesResult];
 
   if (createNewCopies) {
     importIdMap = regenerateIds(collectSavedObjectsResult.collectedObjects);
   } else {
     // Check single-namespace objects for conflicts in this namespace, and check multi-namespace objects for conflicts across all namespaces
+    // Check for conflicts across all workspaces
     const checkConflictsParams = {
       objects: collectSavedObjectsResult.collectedObjects,
       savedObjectsClient,
       namespace,
       ignoreRegularConflicts: overwrite,
+      workspaces,
     };
     const checkConflictsResult = await checkConflicts(checkConflictsParams);
     errorAccumulator = [...errorAccumulator, ...checkConflictsResult.errors];
@@ -118,6 +123,7 @@ export async function importSavedObjectsFromStream({
     importIdMap,
     overwrite,
     namespace,
+    ...(workspaces ? { workspaces } : {}),
   };
   const createSavedObjectsResult = await createSavedObjects(createSavedObjectsParams);
   errorAccumulator = [...errorAccumulator, ...createSavedObjectsResult.errors];

src/core/server/saved_objects/import/resolve_import_errors.ts

@@ -59,6 +59,7 @@ export async function resolveSavedObjectsImportErrors({
   typeRegistry,
   namespace,
   createNewCopies,
+  workspaces,
 }: SavedObjectsResolveImportErrorsOptions): Promise<SavedObjectsImportResponse> {
   // throw a BadRequest error if we see invalid retries
   validateRetries(retries);
@@ -157,6 +158,7 @@ export async function resolveSavedObjectsImportErrors({
       importIdMap,
       namespace,
       overwrite,
+      workspaces,
     };
     const { createdObjects, errors: bulkCreateErrors } = await createSavedObjects(
       createSavedObjectsParams

src/core/server/saved_objects/import/types.ts

@@ -187,6 +187,8 @@ export interface SavedObjectsImportOptions {
   namespace?: string;
   /** If true, will create new copies of import objects, each with a random `id` and undefined `originId`. */
   createNewCopies: boolean;
+  /** if specified, will import in given workspaces, else will import as global object */
+  workspaces?: string[];
 }
 
 /**
@@ -208,6 +210,8 @@ export interface SavedObjectsResolveImportErrorsOptions {
   namespace?: string;
   /** If true, will create new copies of import objects, each with a random `id` and undefined `originId`. */
   createNewCopies: boolean;
+  /** if specified, will import in given workspaces, else will import as global object */
+  workspaces?: string[];
 }
 
 export type CreatedObject<T> = SavedObject<T> & { destinationId?: string };

src/core/server/saved_objects/import/validate_references.test.ts

@@ -601,4 +601,100 @@ describe('validateReferences()', () => {
       validateReferences(savedObjects, savedObjectsClient)
     ).rejects.toThrowErrorMatchingInlineSnapshot(`Bad Request`);
   });
+
+  test('returns errors when references have conflict on workspaces', async () => {
+    savedObjectsClient.bulkGet.mockResolvedValue({
+      saved_objects: [
+        {
+          type: 'index-pattern',
+          id: '3',
+          error: SavedObjectsErrorHelpers.createGenericNotFoundError('index-pattern', '3').output
+            .payload,
+          attributes: {},
+          references: [],
+          workspaces: ['foo'],
+        },
+        {
+          type: 'index-pattern',
+          id: '5',
+          error: SavedObjectsErrorHelpers.createGenericNotFoundError('index-pattern', '5').output
+            .payload,
+          attributes: {},
+          references: [],
+          workspaces: ['bar'],
+        },
+      ],
+    });
+    const savedObjects = [
+      {
+        id: '5',
+        type: 'index-pattern',
+        attributes: {
+          title: 'My Visualization 2',
+        },
+        references: [
+          {
+            name: 'ref_0',
+            type: 'index-pattern',
+            id: '3',
+          },
+        ],
+      },
+    ];
+    const result = await validateReferences(
+      savedObjects,
+      savedObjectsClient,
+      undefined,
+      undefined,
+      ['bar']
+    );
+    expect(result).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          error: Object {
+            references: Array [
+              Object {
+                id: 3,
+                type: index-pattern,
+              },
+            ],
+            type: missing_references,
+          },
+          id: 5,
+          meta: Object {
+            title: My Visualization 2,
+          },
+          title: My Visualization 2,
+          type: index-pattern,
+        },
+      ]
+    `);
+    expect(savedObjectsClient.bulkGet).toMatchInlineSnapshot(`
+      [MockFunction] {
+        "calls": Array [
+          Array [
+            Array [
+              Object {
+                fields: Array [
+                  id,
+                  workspaces,
+                ],
+                id: 3,
+                type: index-pattern,
+              },
+            ],
+            Object {
+              namespace: undefined,
+            },
+          ],
+        ],
+        "results": Array [
+          Object {
+            type: return,
+            value: Promise {},
+          },
+        ],
+      }
+    `);
+  });
 });