Create a workspace in the active space and filter dashboard for active space (Kong#3446)

develohpanda · web-flow · commit 4daa44e3708f · 2021-06-09T07:26:29.000-04:00
diff --git a/packages/insomnia-app/app/models/workspace.ts b/packages/insomnia-app/app/models/workspace.ts
@@ -7,13 +7,9 @@ import { ValueOf } from 'type-fest';
 import { isSpaceId } from './helpers/is-model';
 
 export const name = 'Workspace';
-
 export const type = 'Workspace';
-
 export const prefix = 'wrk';
-
 export const canDuplicate = true;
-
 export const canSync = true;
 
 export const WorkspaceScopeKeys = {
@@ -60,18 +56,18 @@ export async function create(patch: Partial<Workspace> = {}) {
 }
 
 export async function all() {
-  const workspaces = await db.all<Workspace>(type) || [];
+  const workspaces = await db.all<Workspace>(type);
 
-  if (workspaces.length === 0) {
-    // Create default workspace
-    await create({
-      name: getAppName(),
-      scope: WorkspaceScopeKeys.collection,
-    });
-    return all();
-  } else {
+  if (workspaces.length > 0) {
     return workspaces;
   }
+
+  // Create default workspace
+  await create({
+    name: getAppName(),
+    scope: WorkspaceScopeKeys.collection,
+  });
+  return db.all<Workspace>(type);
 }
 
 export function count() {
diff --git a/packages/insomnia-app/app/ui/components/wrapper-home.tsx b/packages/insomnia-app/app/ui/components/wrapper-home.tsx
@@ -48,8 +48,8 @@ import { strings } from '../../common/strings';
 import { descendingNumberSort } from '../../common/sorting';
 import { connect } from 'react-redux';
 import { bindActionCreators } from 'redux';
-import * as workspaceActions from '../redux/modules/workspace';
-import * as gitActions from '../redux/modules/git';
+import { createWorkspace } from '../redux/modules/workspace';
+import { cloneGitRepository } from '../redux/modules/git';
 import { MemClient } from '../../sync/git/mem-client';
 import { SpaceDropdown } from './dropdowns/space-dropdown';
 
@@ -58,13 +58,16 @@ interface RenderedCard {
   lastModifiedTimestamp?: number | null;
 }
 
-interface Props {
+interface ReduxDispatchProps {
+  handleCreateWorkspace: typeof createWorkspace;
+  handleGitCloneWorkspace: typeof cloneGitRepository;
+}
+
+interface Props extends ReduxDispatchProps {
   wrapperProps: WrapperProps;
   handleImportFile: HandleImportFileCallback;
   handleImportUri: HandleImportUriCallback;
   handleImportClipboard: HandleImportClipboardCallback;
-  handleCreateWorkspace: workspaceActions.CreateWorkspaceCallback;
-  handleGitCloneWorkspace: Function;
 }
 
 interface State {
@@ -415,11 +418,9 @@ class WrapperHome extends PureComponent<Props, State> {
   }
 }
 
-function mapDispatchToProps(dispatch) {
-  return {
-    handleCreateWorkspace: bindActionCreators(workspaceActions.createWorkspace, dispatch),
-    handleGitCloneWorkspace: bindActionCreators(gitActions.cloneGitRepository, dispatch),
-  };
-}
+const mapDispatchToProps = (dispatch): ReduxDispatchProps => ({
+  handleCreateWorkspace: bindActionCreators(createWorkspace, dispatch),
+  handleGitCloneWorkspace: bindActionCreators(cloneGitRepository, dispatch),
+});
 
 export default connect(null, mapDispatchToProps)(WrapperHome);
diff --git a/packages/insomnia-app/app/ui/containers/app.tsx b/packages/insomnia-app/app/ui/containers/app.tsx
@@ -55,6 +55,7 @@ import {
   selectSyncItems,
   selectUnseenWorkspaces,
   selectWorkspaceRequestsAndRequestGroups,
+  selectWorkspacesForActiveSpace,
 } from '../redux/selectors';
 import { selectSidebarChildren } from '../redux/sidebar-selectors';
 import RequestCreateModal from '../components/modals/request-create-modal';
@@ -1596,12 +1597,13 @@ function mapStateToProps(state, props) {
     requests,
     // @ts-expect-error -- TSCONVERSION
     workspaceMetas,
-    // @ts-expect-error -- TSCONVERSION
-    workspaces,
   } = entitiesLists;
   // @ts-expect-error -- TSCONVERSION
   const settings = entitiesLists.settings[0];
   // Workspace stuff
+
+  // @ts-expect-error -- TSCONVERSION https://github.com/reduxjs/reselect#accessing-react-props-in-selectors
+  const workspaces = selectWorkspacesForActiveSpace(state, props);
   // @ts-expect-error -- TSCONVERSION https://github.com/reduxjs/reselect#accessing-react-props-in-selectors
   const activeWorkspaceMeta = selectActiveWorkspaceMeta(state, props);
   // @ts-expect-error -- TSCONVERSION https://github.com/reduxjs/reselect#accessing-react-props-in-selectors
diff --git a/packages/insomnia-app/app/ui/redux/modules/__tests__/git.test.tsx b/packages/insomnia-app/app/ui/redux/modules/__tests__/git.test.tsx
@@ -31,7 +31,7 @@ describe('git', () => {
   let store;
   beforeEach(async () => {
     await globalBeforeEach();
-    store = mockStore();
+    store = mockStore({ entities: { spaces: [] }, global: {} });
   });
   // Check loading events
   afterEach(() => {
diff --git a/packages/insomnia-app/app/ui/redux/modules/__tests__/workspace.test.ts b/packages/insomnia-app/app/ui/redux/modules/__tests__/workspace.test.ts
@@ -15,27 +15,36 @@ jest.mock('../../../../common/analytics');
 const middlewares = [thunk];
 const mockStore = configureMockStore(middlewares);
 
+const createStoreWithSpace = async () => {
+  const space = await models.initModel(models.space.type);
+
+  const entities = { spaces: { [space._id]: space } };
+  const global = { activeSpaceId: space._id };
+  const store = mockStore({ entities, global });
+  return { store, space };
+};
+
 describe('workspace', () => {
   beforeEach(globalBeforeEach);
   describe('createWorkspace', () => {
     it('should create document', async () => {
-      const store = mockStore();
-      store.dispatch(
-        createWorkspace({
-          scope: WorkspaceScopeKeys.design,
-        }),
-      );
+      const { store, space } = await createStoreWithSpace();
+
+      // @ts-expect-error redux-thunk types
+      store.dispatch(createWorkspace({ scope: WorkspaceScopeKeys.design }));
+
       const { title, submitName, defaultValue, onComplete } = getAndClearShowPromptMockArgs();
       expect(title).toBe('Create New Design Document');
       expect(submitName).toBe('Create');
       expect(defaultValue).toBe('my-spec.yaml');
       const workspaceName = 'name';
-      await onComplete(workspaceName);
+      await onComplete?.(workspaceName);
       const workspaces = await models.workspace.all();
       expect(workspaces).toHaveLength(1);
       const workspace = workspaces[0];
       expect(workspace.name).toBe(workspaceName);
       expect(workspace.scope).toBe(WorkspaceScopeKeys.design);
+      expect(workspace.parentId).toBe(space._id);
       expect(trackSegmentEvent).toHaveBeenCalledWith('Document Created');
       expect(trackEvent).toHaveBeenCalledWith('Workspace', 'Create');
       expect(store.getActions()).toEqual([
@@ -51,23 +60,61 @@ describe('workspace', () => {
     });
 
     it('should create collection', async () => {
-      const store = mockStore();
-      store.dispatch(
-        createWorkspace({
-          scope: WorkspaceScopeKeys.collection,
-        }),
-      );
+      const { store, space } = await createStoreWithSpace();
+
+      // @ts-expect-error redux-thunk types
+      store.dispatch(createWorkspace({ scope: WorkspaceScopeKeys.collection }));
+
       const { title, submitName, defaultValue, onComplete } = getAndClearShowPromptMockArgs();
       expect(title).toBe('Create New Request Collection');
       expect(submitName).toBe('Create');
       expect(defaultValue).toBe('My Collection');
       const workspaceName = 'name';
-      await onComplete(workspaceName);
+      await onComplete?.(workspaceName);
       const workspaces = await models.workspace.all();
       expect(workspaces).toHaveLength(1);
       const workspace = workspaces[0];
-      expect(workspace.name).toBe(workspaceName);
-      expect(workspace.scope).toBe(WorkspaceScopeKeys.collection);
+      expect(workspace).toMatchObject({
+        name: workspaceName,
+        scope: WorkspaceScopeKeys.collection,
+        parentId: space._id,
+      });
+      expect(trackSegmentEvent).toHaveBeenCalledWith('Collection Created');
+      expect(trackEvent).toHaveBeenCalledWith('Workspace', 'Create');
+      expect(store.getActions()).toEqual([
+        {
+          type: SET_ACTIVE_WORKSPACE,
+          workspaceId: workspace._id,
+        },
+        {
+          type: SET_ACTIVE_ACTIVITY,
+          activity: ACTIVITY_DEBUG,
+        },
+      ]);
+    });
+
+    it('should create with no space', async () => {
+      const entities = { spaces: {} };
+      const global = { };
+      const store = mockStore({ entities, global });
+
+      // @ts-expect-error redux-thunk types
+      store.dispatch(createWorkspace({ scope: WorkspaceScopeKeys.collection }));
+
+      const { title, submitName, defaultValue, onComplete } = getAndClearShowPromptMockArgs();
+      expect(title).toBe('Create New Request Collection');
+      expect(submitName).toBe('Create');
+      expect(defaultValue).toBe('My Collection');
+      const workspaceName = 'name';
+      await onComplete?.(workspaceName);
+      const workspaces = await models.workspace.all();
+      expect(workspaces).toHaveLength(1);
+      const workspace = workspaces[0];
+      expect(workspace).toMatchObject({
+        name: workspaceName,
+        scope: WorkspaceScopeKeys.collection,
+        parentId: null,
+      });
       expect(trackSegmentEvent).toHaveBeenCalledWith('Collection Created');
       expect(trackEvent).toHaveBeenCalledWith('Workspace', 'Create');
       expect(store.getActions()).toEqual([
diff --git a/packages/insomnia-app/app/ui/redux/modules/git.tsx b/packages/insomnia-app/app/ui/redux/modules/git.tsx
@@ -135,14 +135,12 @@ const noDocumentFound = (gitRepo: GitRepository) => {
   };
 };
 
-export type CloneGitRepositoryCallback = (arg0: {
-  createFsClient: () => git.PromiseFsClient;
-}) => void;
-
 /**
  * Clone a git repository
  * */
-export const cloneGitRepository: CloneGitRepositoryCallback = ({ createFsClient }) => {
+export const cloneGitRepository = ({ createFsClient }: {
+  createFsClient: () => git.PromiseFsClient;
+}) => {
   return dispatch => {
     showModal(GitRepositorySettingsModal, {
       gitRepository: null,
diff --git a/packages/insomnia-app/app/ui/redux/modules/workspace.ts b/packages/insomnia-app/app/ui/redux/modules/workspace.ts
@@ -5,6 +5,7 @@ import { trackEvent, trackSegmentEvent } from '../../../common/analytics';
 import { isDesign } from '../../../models/helpers/is-model';
 import { showPrompt } from '../../components/modals';
 import { setActiveActivity, setActiveWorkspace } from './global';
+import { selectActiveSpace } from '../selectors';
 
 type OnWorkspaceCreateCallback = (arg0: Workspace) => Promise<void> | void;
 
@@ -22,13 +23,14 @@ const actuallyCreate = (patch: Partial<Workspace>, onCreate?: OnWorkspaceCreateC
   };
 };
 
-export type CreateWorkspaceCallback = (arg0: {
+export const createWorkspace = ({ scope, onCreate }: {
   scope: WorkspaceScope;
   onCreate?: OnWorkspaceCreateCallback;
-}) => void;
+}) => {
+  return (dispatch, getState) => {
+    const activeSpace = selectActiveSpace(getState());
+    const parentId = activeSpace?._id || null;
 
-export const createWorkspace: CreateWorkspaceCallback = ({ scope, onCreate }) => {
-  return dispatch => {
     const design = isDesign({
       scope,
     });
@@ -47,6 +49,8 @@ export const createWorkspace: CreateWorkspaceCallback = ({ scope, onCreate }) =>
             {
               name,
               scope,
+              // @ts-expect-error TSCONVERSION the common parentId isn't typed correctly
+              parentId,
             },
             onCreate,
           ),
diff --git a/packages/insomnia-app/app/ui/redux/selectors.ts b/packages/insomnia-app/app/ui/redux/selectors.ts
@@ -2,6 +2,7 @@ import { createSelector } from 'reselect';
 import * as models from '../../models';
 import { Space } from '../../models/space';
 import { UnitTestResult } from '../../models/unit-test-result';
+import { Workspace } from '../../models/workspace';
 // ~~~~~~~~~ //
 // Selectors //
 // ~~~~~~~~~ //
@@ -38,21 +39,52 @@ export const selectEntitiesChildrenMap = createSelector(selectEntitiesLists, ent
 
   return parentLookupMap;
 });
+
 export const selectSettings = createSelector(selectEntitiesLists, entities => {
   // @ts-expect-error -- TSCONVERSION
   return entities.settings[0] || models.settings.init();
 });
-export const selectActiveWorkspace = createSelector(
-  // @ts-expect-error -- TSCONVERSION
-  state => selectEntitiesLists(state).workspaces,
+
+export const selectSpaces = createSelector(
   // @ts-expect-error -- TSCONVERSION
+  state => selectEntitiesLists(state).spaces as Space[],
+  (spaces) => {
+    return spaces;
+  },
+);
+
+export const selectActiveSpace = createSelector<any, {}, string, Space | undefined>(
   state => state.entities,
+  state => state.global.activeSpaceId,
+  (entities, activeSpaceId) => {
+    // @ts-expect-error -- TSCONVERSION
+    return entities.spaces[activeSpaceId];
+  },
+);
+
+export const selectWorkspacesForActiveSpace = createSelector(
   // @ts-expect-error -- TSCONVERSION
+  state => selectEntitiesLists(state).workspaces as Workspace[],
+  selectActiveSpace,
+  (workspaces, activeSpace) => {
+    const parentId = activeSpace?._id || null;
+    return workspaces.filter(w => w.parentId === parentId);
+  },
+);
+
+export const selectActiveWorkspace = createSelector(
+  // @ts-expect-error -- TSCONVERSION
+  state => selectEntitiesLists(state).workspaces as Workspace[],
+  selectWorkspacesForActiveSpace,
   state => state.global.activeWorkspaceId,
-  (workspaces, entities, activeWorkspaceId) => {
-    return entities.workspaces[activeWorkspaceId] || workspaces[0];
+  (allWorkspaces, workspaces, activeWorkspaceId) => {
+    const activeWorkspace = workspaces.find(w => w._id === activeWorkspaceId) || workspaces[0];
+    // This fallback is needed because while a space may not have any workspaces
+    // The app still _needs_ an active workspace.
+    return activeWorkspace || allWorkspaces[0];
   },
 );
+
 export const selectActiveWorkspaceMeta = createSelector(
   selectActiveWorkspace,
   selectEntitiesLists,
@@ -299,25 +331,6 @@ export const selectActiveUnitTests = createSelector(
   },
 );
 
-// TODO(TSCONVERSION) type this properly when doing the rest of this file
-export const selectSpaces = createSelector<any, {}, Space[]>(
-  selectEntitiesLists,
-  (entities) => {
-    // @ts-expect-error -- TSCONVERSION
-    return entities.spaces;
-  },
-);
-
-// TODO(TSCONVERSION) type this properly when doing the rest of this file
-export const selectActiveSpace = createSelector<any, {}, {}, Space | undefined>(
-  state => state.entities,
-  state => state.global.activeSpaceId,
-  (entities, activeSpaceId) => {
-    // @ts-expect-error -- TSCONVERSION
-    return entities.spaces[activeSpaceId];
-  },
-);
-
 export const selectActiveUnitTestSuites = createSelector(
   selectEntitiesLists,
   selectActiveWorkspace,
