feat: workspace level ui settings

src/core/types/workspace.ts

@@ -13,6 +13,7 @@ export interface WorkspaceAttribute {
   color?: string;
   icon?: string;
   reserved?: boolean;
+  uiSettings?: Record<string, any>;
   defaultVISTheme?: string;
 }
 

src/plugins/workspace/common/constants.ts

@@ -13,6 +13,7 @@ export const WORKSPACE_FATAL_ERROR_APP_ID = 'workspace_fatal_error';
 export const WORKSPACE_SAVED_OBJECTS_CLIENT_WRAPPER_ID = 'workspace';
 export const WORKSPACE_CONFLICT_CONTROL_SAVED_OBJECTS_CLIENT_WRAPPER_ID =
   'workspace_conflict_control';
+export const WORKSPACE_UI_SETTINGS_CLIENT_WRAPPER_ID = 'workspace_ui_settings';
 
 export enum WorkspacePermissionMode {
   Read = 'read',
@@ -25,10 +26,11 @@ export const WORKSPACE_ID_CONSUMER_WRAPPER_ID = 'workspace_id_consumer';
 
 /**
  * The priority for these wrappers matters:
- * 1. WORKSPACE_ID_CONSUMER should be placed before the other two wrappers(smaller than the other two wrappers) as it cost little
- *    and will append the essential workspaces field into the options, which will be honored by permission control wrapper and conflict wrapper.
+ * 1. WORKSPACE_ID_CONSUMER wrapper should be the first wrapper to execute, as it will add the `workspaces` field
+ * to `options` based on the request, which will be honored by permission control wrapper and conflict wrapper.
  * 2. The order of permission wrapper and conflict wrapper does not matter as no dependency between these two wrappers.
  */
-export const PRIORITY_FOR_WORKSPACE_ID_CONSUMER_WRAPPER = -2;
-export const PRIORITY_FOR_PERMISSION_CONTROL_WRAPPER = 0;
+export const PRIORITY_FOR_WORKSPACE_ID_CONSUMER_WRAPPER = -3;
+export const PRIORITY_FOR_WORKSPACE_UI_SETTINGS_WRAPPER = -2;
 export const PRIORITY_FOR_WORKSPACE_CONFLICT_CONTROL_WRAPPER = -1;
+export const PRIORITY_FOR_PERMISSION_CONTROL_WRAPPER = 0;

src/plugins/workspace/server/plugin.ts

@@ -20,6 +20,8 @@ import {
   PRIORITY_FOR_WORKSPACE_CONFLICT_CONTROL_WRAPPER,
   PRIORITY_FOR_WORKSPACE_ID_CONSUMER_WRAPPER,
   PRIORITY_FOR_PERMISSION_CONTROL_WRAPPER,
+  WORKSPACE_UI_SETTINGS_CLIENT_WRAPPER_ID,
+  PRIORITY_FOR_WORKSPACE_UI_SETTINGS_WRAPPER,
 } from '../common/constants';
 import {
   IWorkspaceClientImpl,
@@ -46,6 +48,7 @@ import {
   updateDashboardAdminStateForRequest,
 } from './utils';
 import { WorkspaceIdConsumerWrapper } from './saved_objects/workspace_id_consumer_wrapper';
+import { WorkspaceUiSettingsClientWrapper } from './saved_objects/workspace_ui_settings_client_wrapper';
 
 export class WorkspacePlugin implements Plugin<WorkspacePluginSetup, WorkspacePluginStart> {
   private readonly logger: Logger;
@@ -54,6 +57,7 @@ export class WorkspacePlugin implements Plugin<WorkspacePluginSetup, WorkspacePl
   private permissionControl?: SavedObjectsPermissionControlContract;
   private readonly globalConfig$: Observable<SharedGlobalConfig>;
   private workspaceSavedObjectsClientWrapper?: WorkspaceSavedObjectsClientWrapper;
+  private workspaceUiSettingsClientWrapper?: WorkspaceUiSettingsClientWrapper;
 
   private proxyWorkspaceTrafficToRealHandler(setupDeps: CoreSetup) {
     /**
@@ -131,6 +135,7 @@ export class WorkspacePlugin implements Plugin<WorkspacePluginSetup, WorkspacePl
     await this.client.setup(core);
 
     this.proxyWorkspaceTrafficToRealHandler(core);
+
     this.workspaceConflictControl = new WorkspaceConflictSavedObjectsClientWrapper();
 
     core.savedObjects.addClientWrapper(
@@ -139,6 +144,14 @@ export class WorkspacePlugin implements Plugin<WorkspacePluginSetup, WorkspacePl
       this.workspaceConflictControl.wrapperFactory
     );
 
+    const workspaceUiSettingsClientWrapper = new WorkspaceUiSettingsClientWrapper();
+    this.workspaceUiSettingsClientWrapper = workspaceUiSettingsClientWrapper;
+    core.savedObjects.addClientWrapper(
+      PRIORITY_FOR_WORKSPACE_UI_SETTINGS_WRAPPER,
+      WORKSPACE_UI_SETTINGS_CLIENT_WRAPPER_ID,
+      workspaceUiSettingsClientWrapper.wrapperFactory
+    );
+
     core.savedObjects.addClientWrapper(
       PRIORITY_FOR_WORKSPACE_ID_CONSUMER_WRAPPER,
       WORKSPACE_ID_CONSUMER_WRAPPER_ID,
@@ -176,6 +189,7 @@ export class WorkspacePlugin implements Plugin<WorkspacePluginSetup, WorkspacePl
     this.client?.setSavedObjects(core.savedObjects);
     this.workspaceConflictControl?.setSerializer(core.savedObjects.createSerializer());
     this.workspaceSavedObjectsClientWrapper?.setScopedClient(core.savedObjects.getScopedClient);
+    this.workspaceUiSettingsClientWrapper?.setScopedClient(core.savedObjects.getScopedClient);
 
     return {
       client: this.client as IWorkspaceClientImpl,

src/plugins/workspace/server/saved_objects/workspace.ts

@@ -39,6 +39,10 @@ export const workspace: SavedObjectsType = {
       reserved: {
         type: 'boolean',
       },
+      uiSettings: {
+        dynamic: false,
+        properties: {},
+      },
     },
   },
 };

src/plugins/workspace/server/saved_objects/workspace_ui_settings_client_wrapper.test.ts

@@ -0,0 +1,134 @@
+import { httpServerMock, savedObjectsClientMock, coreMock } from '../../../../core/server/mocks';
+import { WorkspaceUiSettingsClientWrapper } from './workspace_ui_settings_client_wrapper';
+import { WORKSPACE_TYPE } from '../../../../core/server';
+
+import * as utils from '../../../../core/server/utils';
+
+jest.mock('../../../../core/server/utils');
+
+describe('WorkspaceUiSettingsClientWrapper', () => {
+  const createWrappedClient = () => {
+    const clientMock = savedObjectsClientMock.create();
+    const getClientMock = jest.fn().mockReturnValue(clientMock);
+    const requestHandlerContext = coreMock.createRequestHandlerContext();
+    const requestMock = httpServerMock.createOpenSearchDashboardsRequest();
+
+    clientMock.get.mockImplementation(async (type, id) => {
+      if (type === 'config') {
+        return Promise.resolve({
+          id,
+          references: [],
+          type: 'config',
+          attributes: {
+            defaultIndex: 'default-index-global',
+          },
+        });
+      } else if (type === WORKSPACE_TYPE) {
+        return Promise.resolve({
+          id,
+          references: [],
+          type: WORKSPACE_TYPE,
+          attributes: {
+            uiSettings: {
+              defaultIndex: 'default-index-workspace',
+            },
+          },
+        });
+      }
+      return Promise.reject();
+    });
+
+    const wrapper = new WorkspaceUiSettingsClientWrapper();
+    wrapper.setScopedClient(getClientMock);
+
+    return {
+      wrappedClient: wrapper.wrapperFactory({
+        client: clientMock,
+        request: requestMock,
+        typeRegistry: requestHandlerContext.savedObjects.typeRegistry,
+      }),
+      clientMock,
+    };
+  };
+
+  it('should return workspace ui settings if in a workspace', async () => {
+    // Currently in a workspace
+    jest.spyOn(utils, 'getWorkspaceState').mockReturnValue({ requestWorkspaceId: 'workspace-id' });
+
+    const { wrappedClient } = createWrappedClient();
+
+    const result = await wrappedClient.get('config', '3.0.0');
+    expect(result).toEqual({
+      id: '3.0.0',
+      references: [],
+      type: 'config',
+      attributes: {
+        defaultIndex: 'default-index-workspace',
+      },
+    });
+  });
+
+  it('should return global ui settings if NOT in a workspace', async () => {
+    // Currently NOT in a workspace
+    jest.spyOn(utils, 'getWorkspaceState').mockReturnValue({});
+
+    const { wrappedClient } = createWrappedClient();
+
+    const result = await wrappedClient.get('config', '3.0.0');
+    expect(result).toEqual({
+      id: '3.0.0',
+      references: [],
+      type: 'config',
+      attributes: {
+        defaultIndex: 'default-index-global',
+      },
+    });
+  });
+
+  it('should update workspace ui settings', async () => {
+    // Currently in a workspace
+    jest.spyOn(utils, 'getWorkspaceState').mockReturnValue({ requestWorkspaceId: 'workspace-id' });
+
+    const { wrappedClient, clientMock } = createWrappedClient();
+
+    clientMock.update.mockResolvedValue({
+      id: 'workspace-id',
+      references: [],
+      type: WORKSPACE_TYPE,
+      attributes: {
+        uiSettings: {
+          defaultIndex: 'new-index-id',
+        },
+      },
+    });
+
+    await wrappedClient.update('config', '3.0.0', { defaultIndex: 'new-index-id' });
+
+    expect(clientMock.update).toHaveBeenCalledWith(
+      WORKSPACE_TYPE,
+      'workspace-id',
+      {
+        uiSettings: { defaultIndex: 'new-index-id' },
+      },
+      {}
+    );
+  });
+
+  it('should update global ui settings', async () => {
+    // Currently NOT in a workspace
+    jest.spyOn(utils, 'getWorkspaceState').mockReturnValue({});
+
+    const { wrappedClient, clientMock } = createWrappedClient();
+
+    await wrappedClient.update('config', '3.0.0', { defaultIndex: 'new-index-id' });
+
+    expect(clientMock.update).toHaveBeenCalledWith(
+      'config',
+      '3.0.0',
+      {
+        defaultIndex: 'new-index-id',
+      },
+      {}
+    );
+  });
+});

src/plugins/workspace/server/saved_objects/workspace_ui_settings_client_wrapper.ts

@@ -0,0 +1,133 @@
+import { getWorkspaceState } from '../../../../core/server/utils';
+import {
+  SavedObject,
+  SavedObjectsBaseOptions,
+  SavedObjectsClientWrapperFactory,
+  SavedObjectsUpdateOptions,
+  SavedObjectsUpdateResponse,
+  SavedObjectsServiceStart,
+  WORKSPACE_TYPE,
+  WorkspaceAttribute,
+  OpenSearchDashboardsRequest,
+  SavedObjectsClientContract,
+} from '../../../../core/server';
+import { WORKSPACE_UI_SETTINGS_CLIENT_WRAPPER_ID } from '../../common/constants';
+
+/**
+ * This saved object client wrapper offers methods to get and update UI settings considering
+ * the context of the current workspace.
+ */
+export class WorkspaceUiSettingsClientWrapper {
+  private getScopedClient?: SavedObjectsServiceStart['getScopedClient'];
+
+  /**
+   * WORKSPACE_TYPE is a hidden type, regular saved object client won't return hidden types.
+   * To access workspace uiSettings which is defined as a property of workspace object, the
+   * WORKSPACE_TYPE needs to be excluded.
+   */
+  private getWorkspaceTypeEnabledClient(request: OpenSearchDashboardsRequest) {
+    return this.getScopedClient?.(request, {
+      includedHiddenTypes: [WORKSPACE_TYPE],
+      excludedWrappers: [WORKSPACE_UI_SETTINGS_CLIENT_WRAPPER_ID],
+    }) as SavedObjectsClientContract;
+  }
+
+  public setScopedClient(getScopedClient: SavedObjectsServiceStart['getScopedClient']) {
+    this.getScopedClient = getScopedClient;
+  }
+
+  public wrapperFactory: SavedObjectsClientWrapperFactory = (wrapperOptions) => {
+    const getUiSettingsWithWorkspace = async <T = unknown>(
+      type: string,
+      id: string,
+      options: SavedObjectsBaseOptions = {}
+    ): Promise<SavedObject<T>> => {
+      const { requestWorkspaceId } = getWorkspaceState(wrapperOptions.request);
+
+      /**
+       * When getting ui settings within a workspace, it will combine the workspace ui settings with
+       * the global ui settings and workspace ui settings have higher priority if the same setting
+       * was defined in both places
+       */
+      if (type === 'config' && requestWorkspaceId) {
+        const configObject = await wrapperOptions.client.get<Record<string, any>>(
+          'config',
+          id,
+          options
+        );
+
+        const workspaceObject = await this.getWorkspaceTypeEnabledClient(
+          wrapperOptions.request
+        ).get<WorkspaceAttribute>(WORKSPACE_TYPE, requestWorkspaceId);
+
+        configObject.attributes = {
+          ...configObject.attributes,
+          ...workspaceObject.attributes.uiSettings,
+        };
+
+        return configObject as SavedObject<T>;
+      }
+
+      return wrapperOptions.client.get(type, id, options);
+    };
+
+    const updateUiSettingsWithWorkspace = async <T = unknown>(
+      type: string,
+      id: string,
+      attributes: Partial<T>,
+      options: SavedObjectsUpdateOptions = {}
+    ): Promise<SavedObjectsUpdateResponse<T>> => {
+      const { requestWorkspaceId } = getWorkspaceState(wrapperOptions.request);
+
+      /**
+       * When updating ui settings within a workspace, it will update the workspace ui settings,
+       * the global ui settings will remain unchanged.
+       */
+      if (type === 'config' && requestWorkspaceId) {
+        const configObject = await wrapperOptions.client.get<Record<string, any>>(
+          'config',
+          id,
+          options
+        );
+        const savedObjectsClient = this.getWorkspaceTypeEnabledClient(wrapperOptions.request);
+
+        const workspaceObject = await savedObjectsClient.get<WorkspaceAttribute>(
+          WORKSPACE_TYPE,
+          requestWorkspaceId
+        );
+
+        const workspaceUpdateResult = await savedObjectsClient.update<WorkspaceAttribute>(
+          WORKSPACE_TYPE,
+          requestWorkspaceId,
+          {
+            ...workspaceObject.attributes,
+            uiSettings: { ...workspaceObject.attributes.uiSettings, ...attributes },
+          },
+          options
+        );
+
+        configObject.attributes = { ...workspaceUpdateResult.attributes.uiSettings };
+
+        return configObject as SavedObjectsUpdateResponse<T>;
+      }
+      return wrapperOptions.client.update(type, id, attributes, options);
+    };
+
+    return {
+      ...wrapperOptions.client,
+      checkConflicts: wrapperOptions.client.checkConflicts,
+      errors: wrapperOptions.client.errors,
+      addToNamespaces: wrapperOptions.client.addToNamespaces,
+      deleteFromNamespaces: wrapperOptions.client.deleteFromNamespaces,
+      find: wrapperOptions.client.find,
+      bulkGet: wrapperOptions.client.bulkGet,
+      create: wrapperOptions.client.create,
+      bulkCreate: wrapperOptions.client.bulkCreate,
+      delete: wrapperOptions.client.delete,
+      bulkUpdate: wrapperOptions.client.bulkUpdate,
+      deleteByWorkspace: wrapperOptions.client.deleteByWorkspace,
+      get: getUiSettingsWithWorkspace,
+      update: updateUiSettingsWithWorkspace,
+    };
+  };
+}