feat: Using the AtlasUserData class to demo save user data project COMPASS-9565

packages/atlas-service/src/atlas-service.ts

@@ -78,6 +78,11 @@ export class AtlasService {
     // https://github.com/10gen/mms/blob/9f858bb987aac6aa80acfb86492dd74c89cbb862/client/packages/project/common/ajaxPrefilter.ts#L34-L49
     return this.cloudEndpoint(path);
   }
+  tempEndpoint(path?: string): string {
+    return `https://cluster-connection.cloud-dev.mongodb.com${normalizePath(
+      path
+    )}`;
+  }
   driverProxyEndpoint(path?: string): string {
     return `${this.config.ccsBaseUrl}${normalizePath(path)}`;
   }
@@ -91,13 +96,14 @@ export class AtlasService {
       { url }
     );
     try {
+      const headers = {
+        ...this.options?.defaultHeaders,
+        ...(shouldAddCSRFHeaders(init?.method) && getCSRFHeaders()),
+        ...init?.headers,
+      };
       const res = await fetch(url, {
         ...init,
-        headers: {
-          ...this.options?.defaultHeaders,
-          ...(shouldAddCSRFHeaders(init?.method) && getCSRFHeaders()),
-          ...init?.headers,
-        },
+        headers,
       });
       this.logger.log.info(
         this.logger.mongoLogId(1_001_000_309),

packages/atlas-service/src/provider.tsx

@@ -48,7 +48,7 @@ export const AtlasServiceProvider: React.FC<{
   );
 });
 
-function useAtlasServiceContext(): AtlasService {
+export function useAtlasServiceContext(): AtlasService {
   const service = useContext(AtlasServiceContext);
   if (!service) {
     throw new Error('No AtlasService available in this context');

packages/compass-data-modeling/src/services/data-model-storage-electron.tsx

@@ -11,6 +11,7 @@ class DataModelStorageElectron implements DataModelStorage {
   private readonly userData: FileUserData<
     typeof MongoDBDataModelDescriptionSchema
   >;
+
   constructor(basePath?: string) {
     this.userData = new FileUserData(
       MongoDBDataModelDescriptionSchema,
@@ -20,12 +21,15 @@ class DataModelStorageElectron implements DataModelStorage {
       }
     );
   }
+
   save(description: MongoDBDataModelDescription) {
     return this.userData.write(description.id, description);
   }
+
   delete(id: MongoDBDataModelDescription['id']) {
     return this.userData.delete(id);
   }
+
   async loadAll(): Promise<MongoDBDataModelDescription[]> {
     try {
       const res = await this.userData.readAll();
@@ -34,6 +38,7 @@ class DataModelStorageElectron implements DataModelStorage {
       return [];
     }
   }
+
   async load(id: string): Promise<MongoDBDataModelDescription | null> {
     return (
       (await this.loadAll()).find((item) => {

packages/compass-query-bar/src/stores/query-bar-reducer.ts

@@ -356,10 +356,7 @@ export const saveRecentAsFavorite = (
       };
 
       // add it in the favorite
-      await favoriteQueryStorage?.updateAttributes(
-        favoriteQuery._id,
-        favoriteQuery
-      );
+      await favoriteQueryStorage?.saveQuery(favoriteQuery, favoriteQuery._id);
 
       // update favorites
       void dispatch(fetchFavorites());

packages/compass-user-data/src/user-data.spec.ts

@@ -2,13 +2,14 @@ import fs from 'fs/promises';
 import os from 'os';
 import path from 'path';
 import { expect } from 'chai';
+import { z, type ZodError } from 'zod';
+import sinon from 'sinon';
+
 import {
-  FileUserData,
   AtlasUserData,
+  FileUserData,
   type FileUserDataOptions,
 } from './user-data';
-import { z, type ZodError } from 'zod';
-import sinon from 'sinon';
 
 type ValidatorOptions = {
   allowUnknownProps?: boolean;

packages/compass-user-data/src/user-data.ts

@@ -45,6 +45,7 @@ export abstract class IUserData<T extends z.Schema> {
   protected readonly dataType: string;
   protected readonly serialize: SerializeContent<z.input<T>>;
   protected readonly deserialize: DeserializeContent;
+
   constructor(
     validator: T,
     dataType: string,
@@ -63,17 +64,25 @@ export abstract class IUserData<T extends z.Schema> {
   }
 
   abstract write(id: string, content: z.input<T>): Promise<boolean>;
+
   abstract delete(id: string): Promise<boolean>;
+
   abstract readAll(options?: ReadOptions): Promise<ReadAllResult<T>>;
+
+  abstract readOne(
+    id: string,
+    options?: ReadOptions
+  ): Promise<z.output<T> | undefined>;
+
   abstract updateAttributes(
     id: string,
     data: Partial<z.input<T>>
   ): Promise<boolean>;
 }
 
 export class FileUserData<T extends z.Schema> extends IUserData<T> {
-  private readonly basePath?: string;
   protected readonly semaphore = new Semaphore(100);
+  private readonly basePath?: string;
 
   constructor(
     validator: T,
@@ -84,79 +93,9 @@ export class FileUserData<T extends z.Schema> extends IUserData<T> {
     this.basePath = basePath;
   }
 
-  private getFileName(id: string) {
-    return `${id}.json`;
-  }
-
-  private async getEnsuredBasePath(): Promise<string> {
-    const basepath = this.basePath ? this.basePath : getStoragePath();
-
-    const root = path.join(basepath, this.dataType);
-
-    await fs.mkdir(root, { recursive: true });
-
-    return root;
-  }
-
-  private async getFileAbsolutePath(filepath?: string): Promise<string> {
-    const root = await this.getEnsuredBasePath();
-    const pathRelativeToRoot = path.relative(
-      root,
-      path.join(root, filepath ?? '')
-    );
-
-    if (
-      pathRelativeToRoot.startsWith('..') ||
-      path.isAbsolute(pathRelativeToRoot)
-    ) {
-      throw new Error(
-        `Invalid file path: '${filepath}' is not a subpath of ${root}.`
-      );
-    }
-
-    return path.resolve(root, pathRelativeToRoot);
-  }
-
-  private async readAndParseFile(
-    absolutePath: string,
-    options: ReadOptions
-  ): Promise<z.output<T> | undefined> {
-    let data: string;
-    let release: (() => void) | undefined = undefined;
-    try {
-      release = await this.semaphore.waitForRelease();
-      data = await fs.readFile(absolutePath, 'utf-8');
-    } catch (error) {
-      log.error(mongoLogId(1_001_000_234), 'Filesystem', 'Error reading file', {
-        path: absolutePath,
-        error: (error as Error).message,
-      });
-      if (options.ignoreErrors) {
-        return undefined;
-      }
-      throw error;
-    } finally {
-      release?.();
-    }
-
-    try {
-      const content = this.deserialize(data);
-      return this.validator.parse(content);
-    } catch (error) {
-      log.error(mongoLogId(1_001_000_235), 'Filesystem', 'Error parsing data', {
-        path: absolutePath,
-        error: (error as Error).message,
-      });
-      if (options.ignoreErrors) {
-        return undefined;
-      }
-      throw error;
-    }
-  }
-
   async write(id: string, content: z.input<T>) {
     // Validate the input. Here we are not saving the parsed content
-    // because after reading we validate the data again and it parses
+    // because after reading we validate the data again, and it parses
     // the read content back to the expected output. This way we ensure
     // that we exactly save what we want without transforming it.
     this.validator.parse(content);
@@ -234,14 +173,17 @@ export class FileUserData<T extends z.Schema> extends IUserData<T> {
     id: string,
     options?: { ignoreErrors: false }
   ): Promise<z.output<T>>;
+
   async readOne(
     id: string,
     options?: { ignoreErrors: true }
   ): Promise<z.output<T> | undefined>;
+
   async readOne(
     id: string,
     options?: ReadOptions
   ): Promise<z.output<T> | undefined>;
+
   async readOne(
     id: string,
     options: ReadOptions = {
@@ -267,6 +209,76 @@ export class FileUserData<T extends z.Schema> extends IUserData<T> {
       return false;
     }
   }
+
+  private getFileName(id: string) {
+    return `${id}.json`;
+  }
+
+  private async getEnsuredBasePath(): Promise<string> {
+    const basepath = this.basePath ? this.basePath : getStoragePath();
+
+    const root = path.join(basepath, this.dataType);
+
+    await fs.mkdir(root, { recursive: true });
+
+    return root;
+  }
+
+  private async getFileAbsolutePath(filepath?: string): Promise<string> {
+    const root = await this.getEnsuredBasePath();
+    const pathRelativeToRoot = path.relative(
+      root,
+      path.join(root, filepath ?? '')
+    );
+
+    if (
+      pathRelativeToRoot.startsWith('..') ||
+      path.isAbsolute(pathRelativeToRoot)
+    ) {
+      throw new Error(
+        `Invalid file path: '${filepath}' is not a subpath of ${root}.`
+      );
+    }
+
+    return path.resolve(root, pathRelativeToRoot);
+  }
+
+  private async readAndParseFile(
+    absolutePath: string,
+    options: ReadOptions
+  ): Promise<z.output<T> | undefined> {
+    let data: string;
+    let release: (() => void) | undefined = undefined;
+    try {
+      release = await this.semaphore.waitForRelease();
+      data = await fs.readFile(absolutePath, 'utf-8');
+    } catch (error) {
+      log.error(mongoLogId(1_001_000_234), 'Filesystem', 'Error reading file', {
+        path: absolutePath,
+        error: (error as Error).message,
+      });
+      if (options.ignoreErrors) {
+        return undefined;
+      }
+      throw error;
+    } finally {
+      release?.();
+    }
+
+    try {
+      const content = this.deserialize(data);
+      return this.validator.parse(content);
+    } catch (error) {
+      log.error(mongoLogId(1_001_000_235), 'Filesystem', 'Error parsing data', {
+        path: absolutePath,
+        error: (error as Error).message,
+      });
+      if (options.ignoreErrors) {
+        return undefined;
+      }
+      throw error;
+    }
+  }
 }
 
 // TODO: update endpoints to reflect the merged api endpoints https://jira.mongodb.org/browse/CLOUDP-329716
@@ -275,6 +287,7 @@ export class AtlasUserData<T extends z.Schema> extends IUserData<T> {
   private readonly getResourceUrl;
   private orgId: string;
   private projectId: string;
+
   constructor(
     validator: T,
     dataType: string,