feat(save-user-data): extend user data abstract class for api backend COMPASS-9558

packages/atlas-service/package.json

@@ -28,11 +28,13 @@
   ],
   "license": "SSPL",
   "exports": {
+    "./atlas-service": "./dist/atlas-service.js",
     "./main": "./main.js",
     "./renderer": "./renderer.js",
     "./provider": "./dist/provider.js"
   },
   "compass:exports": {
+    "./atlas-service": "./src/atlas-service.ts",
     "./main": "./src/main.ts",
     "./renderer": "./src/renderer.ts",
     "./provider": "./src/provider.tsx"

packages/compass-global-writes/src/index.ts

@@ -8,6 +8,7 @@ import { createLoggerLocator } from '@mongodb-js/compass-logging/provider';
 import { telemetryLocator } from '@mongodb-js/compass-telemetry/provider';
 import { connectionInfoRefLocator } from '@mongodb-js/compass-connections/provider';
 import { atlasServiceLocator } from '@mongodb-js/atlas-service/provider';
+export { AtlasGlobalWritesService } from './services/atlas-global-writes-service';
 
 const CompassGlobalWritesPluginProvider = registerCompassPlugin(
   {

packages/compass-user-data/package.json

@@ -49,8 +49,11 @@
     "reformat": "npm run eslint . -- --fix && npm run prettier -- --write ."
   },
   "dependencies": {
-    "@mongodb-js/compass-logging": "^1.7.6",
-    "@mongodb-js/compass-utils": "^0.9.5",
+    "@mongodb-js/compass-logging": "^1.7.5",
+    "@mongodb-js/compass-utils": "^0.9.4",
+    "@mongodb-js/atlas-service": "^0.49.0",
+    "@mongodb-js/compass-connections": "^1.64.0",
+    "compass-preferences-model": "^2.44.0",
     "write-file-atomic": "^5.0.1",
     "zod": "^3.25.17"
   },

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

@@ -1,3 +1,3 @@
 export type { Stats, ReadAllResult, ReadAllWithStatsResult } from './user-data';
-export { IUserData, FileUserData } from './user-data';
+export { IUserData, FileUserData, AtlasUserData } from './user-data';
 export { z } from 'zod';

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

@@ -418,3 +418,112 @@ describe('user-data', function () {
     });
   });
 });
+
+describe('AtlasUserData', function () {
+  let AtlasUserData: any;
+  let atlasServiceMock: any;
+  let validator: any;
+  let instance: any;
+
+  before(async function () {
+    // Dynamically import AtlasUserData to avoid circular deps
+    const module = await import('./user-data');
+    AtlasUserData = module.AtlasUserData;
+    validator = getTestSchema();
+  });
+
+  beforeEach(function () {
+    atlasServiceMock = {
+      authenticatedFetch: sinon.stub(),
+    };
+    instance = new AtlasUserData(validator, atlasServiceMock, {
+      groupId: 'test-group',
+      projectId: 'test-project',
+      endpoint: '/api/user-data',
+    });
+  });
+
+  it('constructs with dependencies', function () {
+    expect(instance).to.have.property('atlasService', atlasServiceMock);
+    expect(instance).to.have.property('groupId', 'test-group');
+    expect(instance).to.have.property('projectId', 'test-project');
+    expect(instance).to.have.property('endpoint', '/api/user-data');
+  });
+
+  it('write: calls authenticatedFetch and validates response', async function () {
+    const item = { name: 'Atlas', hasDarkMode: false };
+    atlasServiceMock.authenticatedFetch.resolves({
+      ok: true,
+      json: async () => await Promise.resolve(item),
+    });
+    const result = await instance.write('id1', item);
+    expect(result).to.be.true;
+    expect(atlasServiceMock.authenticatedFetch.calledOnce).to.be.true;
+  });
+
+  it('write: handles API error', async function () {
+    atlasServiceMock.authenticatedFetch.resolves({ ok: false, status: 500 });
+    const result = await instance.write('id1', { name: 'Atlas' });
+    expect(result).to.be.false;
+  });
+
+  it('delete: calls authenticatedFetch and returns true on success', async function () {
+    atlasServiceMock.authenticatedFetch.resolves({ ok: true });
+    const result = await instance.delete('id1');
+    expect(result).to.be.true;
+  });
+
+  it('delete: returns false on API failure', async function () {
+    atlasServiceMock.authenticatedFetch.resolves({ ok: false });
+    const result = await instance.delete('id1');
+    expect(result).to.be.false;
+  });
+
+  it('readAll: returns validated items from API', async function () {
+    const items = [
+      { name: 'Atlas', hasDarkMode: true },
+      { name: 'Compass', hasDarkMode: false },
+    ];
+    atlasServiceMock.authenticatedFetch.resolves({
+      ok: true,
+      json: async () => await Promise.resolve(items),
+    });
+    const result = await instance.readAll();
+    expect(result.data).to.have.lengthOf(2);
+    expect(result.errors).to.have.lengthOf(0);
+    expect(result.data[0]).to.have.property('name');
+  });
+
+  it('readAll: returns errors for invalid items', async function () {
+    const items = [
+      { name: 'Atlas', hasDarkMode: 'not-a-bool' },
+      { name: 'Compass', hasDarkMode: false },
+    ];
+    atlasServiceMock.authenticatedFetch.resolves({
+      ok: true,
+      json: async () => await Promise.resolve(items),
+    });
+    const result = await instance.readAll();
+    expect(result.data).to.have.lengthOf(1);
+    expect(result.errors).to.have.lengthOf(1);
+  });
+
+  it('updateAttributes: calls authenticatedFetch and validates response', async function () {
+    const attrs = { hasDarkMode: false };
+    atlasServiceMock.authenticatedFetch.resolves({
+      ok: true,
+      json: async () =>
+        await Promise.resolve({ name: 'Atlas', hasDarkMode: false }),
+    });
+    const result = await instance.updateAttributes('id1', attrs);
+    expect(result).to.deep.equal({ name: 'Atlas', hasDarkMode: false });
+  });
+
+  it('updateAttributes: returns undefined on API error', async function () {
+    atlasServiceMock.authenticatedFetch.resolves({ ok: false });
+    const result = await instance.updateAttributes('id1', {
+      hasDarkMode: true,
+    });
+    expect(result).to.be.undefined;
+  });
+});

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

@@ -5,6 +5,10 @@ import { getStoragePath } from '@mongodb-js/compass-utils';
 import type { z } from 'zod';
 import writeFile from 'write-file-atomic';
 import { Semaphore } from './semaphore';
+import { AtlasService } from '@mongodb-js/atlas-service/atlas-service';
+import { atlasAuthServiceLocator } from '@mongodb-js/atlas-service/provider';
+import { preferencesLocator } from 'compass-preferences-model/provider';
+import { connectionInfoRefLocator } from '@mongodb-js/compass-connections/provider';
 
 const { log, mongoLogId } = createLogger('COMPASS-USER-STORAGE');
 
@@ -333,3 +337,143 @@ export class FileUserData<T extends z.Schema> extends IUserData<T> {
     return await this.readOne(id);
   }
 }
+
+// TODO: update endpoints to reflect the merged api endpoints
+export class AtlasUserData<T extends z.Schema> extends IUserData<T> {
+  private atlasService: AtlasService;
+  private readonly preferences = preferencesLocator();
+  // private readonly preferences = null;
+  private readonly connectionInfoRef = connectionInfoRefLocator();
+  // private readonly connectionInfoRef = null;
+  private readonly logger = createLogger('ATLAS-USER-STORAGE');
+  private readonly groupId =
+    this.connectionInfoRef?.current?.atlasMetadata?.projectId;
+  private readonly orgId =
+    this.connectionInfoRef?.current?.atlasMetadata?.orgId;
+  // should this BASE_URL be a parameter passed to the constructor?
+  // this might make future usage of this code easier, if we want to call a different endpoint
+  private readonly BASE_URL = 'cluster-connection.cloud-local.mongodb.com';
+  constructor(
+    validator: T,
+    { serialize, deserialize }: AtlasUserDataOptions<z.input<T>>
+  ) {
+    super(validator, { serialize, deserialize });
+    const authService = atlasAuthServiceLocator();
+    // const authService = null;
+    const options = {};
+
+    this.atlasService = new AtlasService(
+      authService,
+      this.preferences,
+      this.logger,
+      options
+    );
+    this.atlasService = null;
+  }
+
+  async write(id: string, content: z.input<T>): Promise<boolean> {
+    this.validator.parse(content);
+
+    // do not need to use id because content already contains the id
+    const response = await this.atlasService.authenticatedFetch(this.getUrl(), {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        id: id,
+        data: this.serialize(content),
+        createdAt: new Date(),
+        groupId: this.groupId,
+      }),
+    });
+    // TODO: fix this error handling, should fit current compass needs
+    if (!response.ok) {
+      throw new Error(
+        `Failed to post data: ${response.status} ${response.statusText}`
+      );
+    }
+    return true;
+  }
+
+  async delete(id: string): Promise<boolean> {
+    const response = await this.atlasService.authenticatedFetch(
+      this.getUrl() + `/${id}`,
+      {
+        method: 'DELETE',
+      }
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Failed to delete data: ${response.status} ${response.statusText}`
+      );
+    }
+    return true;
+  }
+
+  async readAll(): Promise<ReadAllResult<T>> {
+    try {
+      const response = await this.atlasService.authenticatedFetch(
+        this.getUrl(),
+        {
+          method: 'GET',
+          headers: {
+            accept: 'application/json',
+          },
+        }
+      );
+      // TODO: fix this error handling, should fit current compass needs
+      if (!response.ok) {
+        throw new Error(
+          `Failed to get data: ${response.status} ${response.statusText}`
+        );
+      }
+      const json = await response.json();
+      const data = Array.isArray(json)
+        ? json.map((item) =>
+            this.validator.parse(this.deserialize(item.data as string))
+          )
+        : [];
+      return { data, errors: [] };
+    } catch (error) {
+      return { data: [], errors: [error as Error] };
+    }
+  }
+
+  async updateAttributes(
+    id: string,
+    data: Partial<z.input<T>>
+  ): Promise<z.output<T>> {
+    const response = await this.atlasService.authenticatedFetch(
+      this.getUrl() + `/${id}`,
+      {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        // TODO: not sure whether currently compass sometimes adds to data or always replaces it
+        // figure out if we should get all data, find specific query by id, then update using JS
+        body: this.serialize(data),
+      }
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Failed to update data: ${response.status} ${response.statusText}`
+      );
+    }
+    const json = await response.json();
+    // TODO: fix this, currently endpoint does not return the updated data
+    // so we need to decide whether this is necessary
+    return this.validator.parse(json.data);
+  }
+
+  private getUrl() {
+    // if (endpoint.startsWith('/')) {
+    //   endpoint = endpoint.slice(1);
+    // }
+    // if (endpoint.endsWith('/')) {
+    //   endpoint = endpoint.slice(0, -1);
+    // }
+    return `${this.BASE_URL}/queries/favorites/${this.orgId}/${this.groupId}`;
+  }
+}

packages/compass-user-data/tsconfig.json

@@ -1,7 +1,8 @@
 {
   "extends": "@mongodb-js/tsconfig-compass/tsconfig.common.json",
   "compilerOptions": {
-    "outDir": "dist"
+    "outDir": "dist",
+    "skipLibCheck": true
   },
   "include": ["src/**/*"],
   "exclude": ["./src/**/*.spec.*"]