[Workspace] Add workspace id in basePath

CHANGELOG.md

@@ -32,8 +32,8 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 - [Multiple Datasource] Test connection schema validation for registered auth types ([#6109](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/6109))
 - [Workspace] Consume workspace id in saved object client ([#6014](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/6014))
 - [Multiple Datasource] Export DataSourcePluginRequestContext at top level for plugins to use ([#6108](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/6108))
-
 - [Workspace] Add delete saved objects by workspace functionality([#6013](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/6013))
+- [Workspace] Add workspace id in basePath ([#6060](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/6060))
 
 ### 🐛 Bug Fixes
 

src/core/public/http/base_path.test.ts

@@ -110,4 +110,44 @@ describe('BasePath', () => {
       expect(new BasePath('/foo/bar', '/foo').serverBasePath).toEqual('/foo');
     });
   });
+
+  describe('clientBasePath', () => {
+    it('get path with workspace', () => {
+      expect(new BasePath('/foo/bar', '/foo/bar', '/workspace').get()).toEqual(
+        '/foo/bar/workspace'
+      );
+    });
+
+    it('getBasePath with workspace provided', () => {
+      expect(new BasePath('/foo/bar', '/foo/bar', '/workspace').getBasePath()).toEqual('/foo/bar');
+    });
+
+    it('prepend with workspace provided', () => {
+      expect(new BasePath('/foo/bar', '/foo/bar', '/workspace').prepend('/prepend')).toEqual(
+        '/foo/bar/workspace/prepend'
+      );
+    });
+
+    it('prepend with workspace provided but calls without workspace', () => {
+      expect(
+        new BasePath('/foo/bar', '/foo/bar', '/workspace').prepend('/prepend', {
+          withoutWorkspace: true,
+        })
+      ).toEqual('/foo/bar/prepend');
+    });
+
+    it('remove with workspace provided', () => {
+      expect(
+        new BasePath('/foo/bar', '/foo/bar', '/workspace').remove('/foo/bar/workspace/remove')
+      ).toEqual('/remove');
+    });
+
+    it('remove with workspace provided but calls without workspace', () => {
+      expect(
+        new BasePath('/foo/bar', '/foo/bar', '/workspace').remove('/foo/bar/workspace/remove', {
+          withoutWorkspace: true,
+        })
+      ).toEqual('/workspace/remove');
+    });
+  });
 });

src/core/public/http/base_path.ts

@@ -29,37 +29,47 @@
  */
 
 import { modifyUrl } from '@osd/std';
+import type { PrependOptions } from './types';
 
 export class BasePath {
   constructor(
     private readonly basePath: string = '',
-    public readonly serverBasePath: string = basePath
+    public readonly serverBasePath: string = basePath,
+    private readonly clientBasePath: string = ''
   ) {}
 
   public get = () => {
+    return `${this.basePath}${this.clientBasePath}`;
+  };
+
+  public getBasePath = () => {
     return this.basePath;
   };
 
-  public prepend = (path: string): string => {
-    if (!this.basePath) return path;
+  public prepend = (path: string, prependOptions?: PrependOptions): string => {
+    const { withoutWorkspace } = prependOptions || {};
+    const basePath = withoutWorkspace ? this.basePath : this.get();
+    if (!basePath) return path;
     return modifyUrl(path, (parts) => {
       if (!parts.hostname && parts.pathname && parts.pathname.startsWith('/')) {
-        parts.pathname = `${this.basePath}${parts.pathname}`;
+        parts.pathname = `${basePath}${parts.pathname}`;
       }
     });
   };
 
-  public remove = (path: string): string => {
-    if (!this.basePath) {
+  public remove = (path: string, prependOptions?: PrependOptions): string => {
+    const { withoutWorkspace } = prependOptions || {};
+    const basePath = withoutWorkspace ? this.basePath : this.get();
+    if (!basePath) {
       return path;
     }
 
-    if (path === this.basePath) {
+    if (path === basePath) {
       return '/';
     }
 
-    if (path.startsWith(`${this.basePath}/`)) {
-      return path.slice(this.basePath.length);
+    if (path.startsWith(`${basePath}/`)) {
+      return path.slice(basePath.length);
     }
 
     return path;

src/core/public/http/http_service.mock.ts

@@ -39,7 +39,7 @@ export type HttpSetupMock = jest.Mocked<HttpSetup> & {
   anonymousPaths: jest.Mocked<HttpSetup['anonymousPaths']>;
 };
 
-const createServiceMock = ({ basePath = '' } = {}): HttpSetupMock => ({
+const createServiceMock = ({ basePath = '', clientBasePath = '' } = {}): HttpSetupMock => ({
   fetch: jest.fn(),
   get: jest.fn(),
   head: jest.fn(),
@@ -48,7 +48,7 @@ const createServiceMock = ({ basePath = '' } = {}): HttpSetupMock => ({
   patch: jest.fn(),
   delete: jest.fn(),
   options: jest.fn(),
-  basePath: new BasePath(basePath),
+  basePath: new BasePath(basePath, undefined, clientBasePath),
   anonymousPaths: {
     register: jest.fn(),
     isAnonymous: jest.fn(),
@@ -58,14 +58,14 @@ const createServiceMock = ({ basePath = '' } = {}): HttpSetupMock => ({
   intercept: jest.fn(),
 });
 
-const createMock = ({ basePath = '' } = {}) => {
+const createMock = ({ basePath = '', clientBasePath = '' } = {}) => {
   const mocked: jest.Mocked<PublicMethodsOf<HttpService>> = {
     setup: jest.fn(),
     start: jest.fn(),
     stop: jest.fn(),
   };
-  mocked.setup.mockReturnValue(createServiceMock({ basePath }));
-  mocked.start.mockReturnValue(createServiceMock({ basePath }));
+  mocked.setup.mockReturnValue(createServiceMock({ basePath, clientBasePath }));
+  mocked.start.mockReturnValue(createServiceMock({ basePath, clientBasePath }));
   return mocked;
 };
 

src/core/public/http/http_service.test.ts

@@ -74,6 +74,63 @@ describe('#setup()', () => {
     // We don't verify that this Observable comes from Fetch#getLoadingCount$() to avoid complex mocking
     expect(loadingServiceSetup.addLoadingCountSource).toHaveBeenCalledWith(expect.any(Observable));
   });
+
+  it('setup basePath without workspaceId provided in window.location.href', () => {
+    const injectedMetadata = injectedMetadataServiceMock.createSetupContract();
+    const fatalErrors = fatalErrorsServiceMock.createSetupContract();
+    const httpService = new HttpService();
+    const setupResult = httpService.setup({ fatalErrors, injectedMetadata });
+    expect(setupResult.basePath.get()).toEqual('');
+  });
+
+  it('setup basePath with workspaceId provided in window.location.href and workspace feature enabled', () => {
+    const windowSpy = jest.spyOn(window, 'window', 'get');
+    windowSpy.mockImplementation(
+      () =>
+        ({
+          location: {
+            href: 'http://localhost/w/workspaceId/app',
+          },
+        } as any)
+    );
+    const injectedMetadata = injectedMetadataServiceMock.createSetupContract();
+    injectedMetadata.getPlugins.mockReturnValueOnce([
+      {
+        id: 'workspace',
+        plugin: {
+          id: 'workspace',
+          configPath: '',
+          requiredPlugins: [],
+          optionalPlugins: [],
+          requiredEnginePlugins: {},
+          requiredBundles: [],
+        },
+      },
+    ]);
+    const fatalErrors = fatalErrorsServiceMock.createSetupContract();
+    const httpService = new HttpService();
+    const setupResult = httpService.setup({ fatalErrors, injectedMetadata });
+    expect(setupResult.basePath.get()).toEqual('/w/workspaceId');
+    windowSpy.mockRestore();
+  });
+
+  it('setup basePath with workspaceId provided in window.location.href but workspace feature disabled', () => {
+    const windowSpy = jest.spyOn(window, 'window', 'get');
+    windowSpy.mockImplementation(
+      () =>
+        ({
+          location: {
+            href: 'http://localhost/w/workspaceId/app',
+          },
+        } as any)
+    );
+    const injectedMetadata = injectedMetadataServiceMock.createSetupContract();
+    const fatalErrors = fatalErrorsServiceMock.createSetupContract();
+    const httpService = new HttpService();
+    const setupResult = httpService.setup({ fatalErrors, injectedMetadata });
+    expect(setupResult.basePath.get()).toEqual('');
+    windowSpy.mockRestore();
+  });
 });
 
 describe('#stop()', () => {

src/core/public/http/http_service.ts

@@ -36,6 +36,8 @@ import { AnonymousPathsService } from './anonymous_paths_service';
 import { LoadingCountService } from './loading_count_service';
 import { Fetch } from './fetch';
 import { CoreService } from '../../types';
+import { getWorkspaceIdFromUrl } from '../utils';
+import { WORKSPACE_PATH_PREFIX } from '../../utils/constants';
 
 interface HttpDeps {
   injectedMetadata: InjectedMetadataSetup;
@@ -50,9 +52,23 @@ export class HttpService implements CoreService<HttpSetup, HttpStart> {
 
   public setup({ injectedMetadata, fatalErrors }: HttpDeps): HttpSetup {
     const opensearchDashboardsVersion = injectedMetadata.getOpenSearchDashboardsVersion();
+    let clientBasePath = '';
+    const plugins = injectedMetadata.getPlugins();
+    const findWorkspaceConfig = plugins.find((plugin) => plugin.id === 'workspace');
+    // Only try to get workspace id from url when workspace feature is enabled
+    if (findWorkspaceConfig) {
+      const workspaceId = getWorkspaceIdFromUrl(
+        window.location.href,
+        injectedMetadata.getBasePath()
+      );
+      if (workspaceId) {
+        clientBasePath = `${WORKSPACE_PATH_PREFIX}/${workspaceId}`;
+      }
+    }
     const basePath = new BasePath(
       injectedMetadata.getBasePath(),
-      injectedMetadata.getServerBasePath()
+      injectedMetadata.getServerBasePath(),
+      clientBasePath
     );
     const fetchService = new Fetch({ basePath, opensearchDashboardsVersion });
     const loadingCount = this.loadingCount.setup({ fatalErrors });