add dekstop storage

Author: syn-zhu

packages/compass-workspaces/src/provider/index.tsx

@@ -0,0 +1,108 @@
+import React, { useContext, useEffect, useMemo, useRef, useState } from 'react';
+import type {
+  WorkspacesStorage,
+  WorkspacesStateData,
+} from '../services/workspaces-storage';
+import { createServiceLocator } from '@mongodb-js/compass-app-registry';
+
+export type WorkspacesStorageServiceState = {
+  status: 'INITIAL' | 'LOADING' | 'READY' | 'ERROR';
+  error: Error | null;
+  workspaces: WorkspacesStateData | null;
+};
+
+export const noopWorkspacesStorageService: WorkspacesStorageServiceState &
+  WorkspacesStorage = {
+  status: 'INITIAL',
+  error: null,
+  workspaces: null,
+  save: () => {
+    return Promise.resolve(false);
+  },
+  load: () => {
+    return Promise.resolve(null);
+  },
+};
+
+const WorkspacesStorageServiceContext = React.createContext<
+  WorkspacesStorageServiceState & WorkspacesStorage
+>(noopWorkspacesStorageService);
+
+export const WorkspacesStorageServiceProvider: React.FunctionComponent<{
+  storage: WorkspacesStorage;
+}> = ({ storage, children }) => {
+  const storageRef = useRef(storage);
+  const [serviceState, setServiceState] =
+    useState<WorkspacesStorageServiceState>({
+      status: 'INITIAL',
+      error: null,
+      workspaces: null,
+    });
+  const service = useMemo(() => {
+    return {
+      ...serviceState,
+      async save(toSave: WorkspacesStateData) {
+        setServiceState((prevState) => {
+          return {
+            ...prevState,
+            workspaces: toSave,
+          };
+        });
+        return storageRef.current.save(toSave);
+      },
+      async load() {
+        setServiceState((prevState) => {
+          return {
+            ...prevState,
+            status: 'LOADING',
+          };
+        });
+        try {
+          const workspaces = await storageRef.current.load();
+          setServiceState((prevState) => {
+            return { ...prevState, workspaces, error: null, status: 'READY' };
+          });
+          return workspaces;
+        } catch (err) {
+          setServiceState((prevState) => {
+            return { ...prevState, error: err as Error, status: 'ERROR' };
+          });
+          throw err;
+        }
+      },
+    };
+  }, [serviceState]);
+
+  const serviceRef = useRef(service);
+
+  useEffect(() => {
+    void serviceRef.current.load().catch(() => {
+      // handled by the method
+    });
+  }, []);
+
+  return (
+    <WorkspacesStorageServiceContext.Provider value={service}>
+      {children}
+    </WorkspacesStorageServiceContext.Provider>
+  );
+};
+
+export function useSavedWorkspaces() {
+  const { status, error, workspaces } = useContext(
+    WorkspacesStorageServiceContext
+  );
+  return { status, error, workspaces };
+}
+
+export const workspacesStorageServiceLocator = createServiceLocator(() => {
+  const service = useContext(WorkspacesStorageServiceContext);
+  return {
+    save: service.save.bind(service),
+    load: service.load.bind(service),
+  };
+}, 'workspacesStorageServiceLocator');
+
+export type WorkspacesStorageService = ReturnType<
+  typeof workspacesStorageServiceLocator
+>;

packages/compass-workspaces/src/services/workspaces-storage-desktop.tsx

@@ -0,0 +1,43 @@
+import React from 'react';
+import type {
+  WorkspacesStateData,
+  WorkspacesStorage,
+} from './workspaces-storage';
+import { FileUserData } from '@mongodb-js/compass-user-data';
+import { WorkspacesStateSchema } from './workspaces-storage';
+import { EJSON } from 'bson';
+import { WorkspacesStorageServiceProvider } from '../provider';
+
+class WorkspacesStorageDesktop implements WorkspacesStorage {
+  private userData = new FileUserData(
+    WorkspacesStateSchema,
+    'WorkspacesState',
+    {
+      serialize: (content) => EJSON.stringify(content, undefined, 2),
+      deserialize: (content: string) => EJSON.parse(content),
+    }
+  );
+  save(state: WorkspacesStateData): Promise<boolean> {
+    return this.userData.write('current-workspace', state);
+  }
+  load(): Promise<WorkspacesStateData | null> {
+    return this.userData
+      .readOne('current-workspace', {
+        ignoreErrors: true,
+      })
+      .then((data) => data ?? null);
+  }
+}
+
+const storage = new WorkspacesStorageDesktop();
+
+export const WorkspacesStorageServiceProviderDesktop: React.FunctionComponent =
+  ({ children }) => {
+    return (
+      <WorkspacesStorageServiceProvider storage={storage}>
+        {children}
+      </WorkspacesStorageServiceProvider>
+    );
+  };
+
+export default storage;

packages/compass-workspaces/src/services/workspaces-storage-web.tsx

@@ -0,0 +1,59 @@
+import { z } from '@mongodb-js/compass-user-data';
+
+/**
+ * Schema for saving workspace tab state to user data
+ */
+
+// Define schema for collection subtab
+const CollectionSubtabSchema = z.enum([
+  'Documents',
+  'Aggregations',
+  'Schema',
+  'Indexes',
+  'Validation',
+  'GlobalWrites',
+]);
+
+// Define schema for workspace tab type
+const WorkspaceTabTypeSchema = z.enum([
+  'Welcome',
+  'My Queries',
+  'Data Modeling',
+  'Shell',
+  'Databases',
+  'Performance',
+  'Collections',
+  'Collection',
+]);
+
+// Define schema for a workspace tab
+export const WorkspaceTabSchema = z.object({
+  id: z.string(),
+  type: WorkspaceTabTypeSchema,
+  connectionId: z.string().optional(),
+  namespace: z.string().optional(),
+  initialQuery: z.record(z.any()).optional(),
+  initialAggregation: z.record(z.any()).optional(),
+  initialPipeline: z.array(z.record(z.any())).optional(),
+  initialPipelineText: z.string().optional(),
+  editViewName: z.string().optional(),
+  initialEvaluate: z.union([z.string(), z.array(z.string())]).optional(),
+  initialInput: z.string().optional(),
+  subTab: CollectionSubtabSchema.optional(),
+});
+
+// Define schema for the complete workspaces state
+export const WorkspacesStateSchema = z.object({
+  tabs: z.array(WorkspaceTabSchema),
+  activeTabId: z.string().nullable(),
+  timestamp: z.number(),
+});
+
+// TypeScript types derived from the schemas
+export type WorkspaceTabData = z.output<typeof WorkspaceTabSchema>;
+export type WorkspacesStateData = z.output<typeof WorkspacesStateSchema>;
+
+export interface WorkspacesStorage {
+  save(state: WorkspacesStateData): Promise<boolean>;
+  load(): Promise<WorkspacesStateData | null>;
+}