Feature/move utils

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

@@ -110,4 +110,36 @@ describe('BasePath', () => {
       expect(new BasePath('/foo/bar', '/foo').serverBasePath).toEqual('/foo');
     });
   });
+
+  describe('workspaceBasePath', () => {
+    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');
+    });
+  });
 });

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 = '', workspaceBasePath = '' } = {}): 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, workspaceBasePath),
   anonymousPaths: {
     register: jest.fn(),
     isAnonymous: jest.fn(),
@@ -58,14 +58,14 @@ const createServiceMock = ({ basePath = '' } = {}): HttpSetupMock => ({
   intercept: jest.fn(),
 });
 
-const createMock = ({ basePath = '' } = {}) => {
+const createMock = ({ basePath = '', workspaceBasePath = '' } = {}) => {
   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, workspaceBasePath }));
+  mocked.start.mockReturnValue(createServiceMock({ basePath, workspaceBasePath }));
   return mocked;
 };
 

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

@@ -74,6 +74,32 @@ 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', () => {
+    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('/w/workspaceId');
+    windowSpy.mockRestore();
+  });
 });
 
 describe('#stop()', () => {

src/core/public/index.ts

@@ -358,5 +358,3 @@ export {
   MANAGEMENT_WORKSPACE_ID,
   WORKSPACE_TYPE,
 } from '../utils';
-
-export { getWorkspaceIdFromUrl } from './utils';

src/core/public/utils/index.ts

@@ -31,10 +31,11 @@
 export { shareWeakReplay } from './share_weak_replay';
 export { Sha256 } from './crypto';
 export { MountWrapper, mountReactNode } from './mount';
-export { getWorkspaceIdFromUrl } from './workspace';
 export {
   WORKSPACE_PATH_PREFIX,
+  WORKSPACE_TYPE,
+  formatUrlWithWorkspaceId,
+  getWorkspaceIdFromUrl,
   PUBLIC_WORKSPACE_ID,
   MANAGEMENT_WORKSPACE_ID,
-  WORKSPACE_TYPE,
 } from '../../utils';

src/core/public/workspace/index.ts

@@ -2,4 +2,5 @@
  * Copyright OpenSearch Contributors
  * SPDX-License-Identifier: Apache-2.0
  */
+
 export { WorkspacesStart, WorkspacesService, WorkspacesSetup } from './workspaces_service';

src/core/server/utils/index.ts

@@ -32,3 +32,4 @@ export * from './crypto';
 export * from './from_root';
 export * from './package_json';
 export * from './streams';
+export { getWorkspaceIdFromUrl, cleanWorkspaceId } from '../../utils';

src/core/utils/index.ts

@@ -45,3 +45,4 @@ export {
   WORKSPACE_TYPE,
   PERSONAL_WORKSPACE_ID_PREFIX,
 } from './constants';
+export { getWorkspaceIdFromUrl, formatUrlWithWorkspaceId, cleanWorkspaceId } from './workspace';

src/core/utils/workspace.test.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { getWorkspaceIdFromUrl, formatUrlWithWorkspaceId } from './workspace';
+import { httpServiceMock } from '../public/mocks';
+
+describe('#getWorkspaceIdFromUrl', () => {
+  it('return workspace when there is a match', () => {
+    expect(getWorkspaceIdFromUrl('http://localhost/w/foo')).toEqual('foo');
+  });
+
+  it('return empty when there is not a match', () => {
+    expect(getWorkspaceIdFromUrl('http://localhost/w2/foo')).toEqual('');
+  });
+});
+
+describe('#formatUrlWithWorkspaceId', () => {
+  const basePathWithoutWorkspaceBasePath = httpServiceMock.createSetupContract().basePath;
+  it('return url with workspace prefix when format with a id provided', () => {
+    expect(
+      formatUrlWithWorkspaceId('/app/dashboard', 'foo', basePathWithoutWorkspaceBasePath)
+    ).toEqual('http://localhost/w/foo/app/dashboard');
+  });
+
+  it('return url without workspace prefix when format without a id', () => {
+    expect(
+      formatUrlWithWorkspaceId('/w/foo/app/dashboard', '', basePathWithoutWorkspaceBasePath)
+    ).toEqual('http://localhost/app/dashboard');
+  });
+});

src/core/utils/workspace.ts

@@ -0,0 +1,42 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { WORKSPACE_PATH_PREFIX } from './constants';
+import { IBasePath } from '../public';
+
+export const getWorkspaceIdFromUrl = (url: string): string => {
+  const regexp = /\/w\/([^\/]*)/;
+  const urlObject = new URL(url);
+  const matchedResult = urlObject.pathname.match(regexp);
+  if (matchedResult) {
+    return matchedResult[1];
+  }
+
+  return '';
+};
+
+export const cleanWorkspaceId = (path: string) => {
+  return path.replace(/^\/w\/([^\/]*)/, '');
+};
+
+export const formatUrlWithWorkspaceId = (url: string, workspaceId: string, basePath: IBasePath) => {
+  const newUrl = new URL(url, window.location.href);
+  /**
+   * Patch workspace id into path
+   */
+  newUrl.pathname = basePath.remove(newUrl.pathname);
+
+  if (workspaceId) {
+    newUrl.pathname = `${WORKSPACE_PATH_PREFIX}/${workspaceId}${newUrl.pathname}`;
+  } else {
+    newUrl.pathname = cleanWorkspaceId(newUrl.pathname);
+  }
+
+  newUrl.pathname = basePath.prepend(newUrl.pathname, {
+    withoutWorkspace: true,
+  });
+
+  return newUrl.toString();
+};

src/plugins/saved_objects_management/public/management_section/objects_table/saved_objects_table.tsx

@@ -1075,10 +1075,7 @@ export class SavedObjectsTable extends Component<SavedObjectsTableProps, SavedOb
     const hideImport = workspaceEnabled && !workspaceId;
 
     return (
-      <EuiPageContent
-        horizontalPosition="center"
-        style={this.props.fullWidth ? {} : { maxWidth: '75%', marginTop: '40px' }}
-      >
+      <EuiPageContent horizontalPosition="center">
         {this.renderFlyout()}
         {this.renderRelationships()}
         {this.renderDeleteConfirmModal()}