revisium 2.0.1 → 2.2.0

package/src/services/connection/__tests__/connection.service.spec.ts

@@ -61,26 +61,8 @@ describe('ConnectionService', () => {
       );
     });
 
-    it('throws error when accessing api before connect', () => {
-      expect(() => service.api).toThrow(
-        'Connection not established. Call connect() first.',
-      );
-    });
-
-    it('throws error when accessing revisionId before connect', () => {
-      expect(() => service.revisionId).toThrow(
-        'Connection not established. Call connect() first.',
-      );
-    });
-
-    it('throws error when accessing draftRevisionId before connect', () => {
-      expect(() => service.draftRevisionId).toThrow(
-        'Connection not established. Call connect() first.',
-      );
-    });
-
-    it('throws error when accessing headRevisionId before connect', () => {
-      expect(() => service.headRevisionId).toThrow(
+    it('throws error when accessing revisionScope before connect', () => {
+      expect(() => service.revisionScope).toThrow(
         'Connection not established. Call connect() first.',
       );
     });
@@ -179,114 +161,42 @@ describe('ConnectionService', () => {
     });
   });
 
-  describe('revision resolution', () => {
-    it('uses draft revision when revision is draft', async () => {
-      const url = { ...mockUrl, revision: 'draft' };
-      setupSuccessfulConnection(url, {
-        headId: 'head-123',
-        draftId: 'draft-456',
-      });
-
-      await service.connect();
-
-      expect(service.revisionId).toBe('draft-456');
-    });
-
-    it('uses head revision when revision is head', async () => {
-      const url = { ...mockUrl, revision: 'head' };
-      setupSuccessfulConnection(url, {
-        headId: 'head-123',
-        draftId: 'draft-456',
-      });
-
-      await service.connect();
-
-      expect(service.revisionId).toBe('head-123');
-    });
-
-    it('uses specific revision ID when provided', async () => {
-      const url = { ...mockUrl, revision: 'specific-rev-id' };
-      setupSuccessfulConnection(url, {
-        headId: 'head-123',
-        draftId: 'draft-456',
-      });
-
-      await service.connect();
-
-      expect(service.revisionId).toBe('specific-rev-id');
-    });
-  });
-
-  describe('connection properties after connect', () => {
-    it('provides access to headRevisionId', async () => {
-      setupSuccessfulConnection(mockUrl, {
-        headId: 'test-head-id',
-        draftId: 'test-draft-id',
-      });
-
-      await service.connect();
-
-      expect(service.headRevisionId).toBe('test-head-id');
-    });
-
-    it('provides access to draftRevisionId', async () => {
-      setupSuccessfulConnection(mockUrl, {
-        headId: 'test-head-id',
-        draftId: 'test-draft-id',
-      });
-
-      await service.connect();
-
-      expect(service.draftRevisionId).toBe('test-draft-id');
-    });
-  });
-
-  function setupSuccessfulConnection(
-    url: RevisiumUrlComplete,
-    revisions: { headId: string; draftId: string },
-  ) {
-    urlBuilderServiceFake.parseAndComplete.mockResolvedValue(url);
-
-    const resolveRevisionId = (): string => {
-      if (url.revision === 'head') {
-        return revisions.headId;
-      }
-      if (url.revision === 'draft') {
-        return revisions.draftId;
-      }
-      return url.revision;
-    };
-
-    connectionFactoryFake.createConnection.mockResolvedValue({
-      url,
-      client: createMockApiClient(),
-      revisionId: resolveRevisionId(),
-      headRevisionId: revisions.headId,
-      draftRevisionId: revisions.draftId,
-    });
-  }
-
   function createMockConnectionInfo(url: RevisiumUrlComplete) {
     return {
       url,
       client: createMockApiClient(),
-      revisionId: 'draft-id',
-      headRevisionId: 'head-id',
-      draftRevisionId: 'draft-id',
+      branchScope: createMockBranchScope(),
+      revisionScope: createMockRevisionScope(),
     };
   }
 
   function createMockApiClient() {
     return {
-      api: {
-        me: jest.fn().mockResolvedValue({ data: { username: 'test-user' } }),
-        project: jest.fn().mockResolvedValue({ data: { id: 'project-id' } }),
-        headRevision: jest.fn().mockResolvedValue({ data: { id: 'head-id' } }),
-        draftRevision: jest
-          .fn()
-          .mockResolvedValue({ data: { id: 'draft-id' } }),
+      client: {
+        me: jest.fn().mockResolvedValue({ username: 'test-user' }),
+        branch: jest.fn(),
       },
       authenticate: jest.fn().mockResolvedValue('test-user'),
     };
   }
+
+  function createMockBranchScope() {
+    return {
+      draft: jest.fn(),
+      head: jest.fn(),
+      headRevisionId: 'head-id',
+      draftRevisionId: 'draft-id',
+    };
+  }
+
+  function createMockRevisionScope() {
+    return {
+      getTables: jest.fn(),
+      getRows: jest.fn(),
+      getMigrations: jest.fn(),
+      commit: jest.fn(),
+      revisionId: 'draft-id',
+      isDraft: true,
+    };
+  }
 });

package/src/services/connection/api-client-adapter.ts

@@ -1,58 +1,54 @@
-import { Api } from 'src/__generated__/api';
+import { RevisionScope } from '@revisium/client';
 import { ApiClient } from '../sync/row-sync.service';
 
-type GeneratedApi = Api<unknown>['api'];
-
-export function createApiClientAdapter(api: GeneratedApi): ApiClient {
+export function createApiClientAdapter(
+  revisionScope: RevisionScope,
+): ApiClient {
   return {
-    async rows(revisionId, tableId, options) {
-      const result = await api.rows(revisionId, tableId, {
-        first: options.first,
-        after: options.after,
-        orderBy: options.orderBy,
-      });
-
-      if (result.error) {
-        return { error: result.error };
-      }
-
-      return {
-        data: {
-          edges: result.data.edges.map((edge) => ({
-            node: { id: edge.node.id, data: edge.node.data },
-          })),
-          pageInfo: {
-            hasNextPage: result.data.pageInfo.hasNextPage,
-            endCursor: result.data.pageInfo.endCursor ?? '',
+    async rows(tableId, options) {
+      try {
+        const data = await revisionScope.getRows(tableId, {
+          first: options.first,
+          after: options.after,
+          orderBy: options.orderBy,
+        });
+
+        return {
+          data: {
+            edges: data.edges.map((e) => ({
+              node: { id: e.node.id, data: e.node.data },
+            })),
+            pageInfo: {
+              hasNextPage: data.pageInfo.hasNextPage,
+              endCursor: data.pageInfo.endCursor ?? '',
+            },
           },
-        },
-      };
+        };
+      } catch (error) {
+        return { error };
+      }
     },
 
-    async createRows(revisionId, tableId, data) {
-      const result = await api.createRows(revisionId, tableId, {
-        rows: data.rows,
-        isRestore: data.isRestore,
-      });
-
-      if (result.error) {
-        return { error: result.error };
+    async createRows(tableId, data) {
+      try {
+        await revisionScope.createRows(tableId, data.rows, {
+          isRestore: data.isRestore,
+        });
+        return { data: true };
+      } catch (error) {
+        return { error };
       }
-
-      return { data: result.data };
     },
 
-    async updateRows(revisionId, tableId, data) {
-      const result = await api.updateRows(revisionId, tableId, {
-        rows: data.rows,
-        isRestore: data.isRestore,
-      });
-
-      if (result.error) {
-        return { error: result.error };
+    async updateRows(tableId, data) {
+      try {
+        await revisionScope.updateRows(tableId, data.rows, {
+          isRestore: data.isRestore,
+        });
+        return { data: true };
+      } catch (error) {
+        return { error };
       }
-
-      return { data: result.data };
     },
   };
 }

package/src/services/connection/api-client.ts

@@ -1,11 +1,11 @@
-import { Api, RequestParams } from 'src/__generated__/api';
+import { RevisiumClient } from '@revisium/client';
 import { AuthCredentials } from '../url';
 
-export class RevisiumApiClient extends Api<unknown> {
-  public authToken: string | undefined = undefined;
+export class RevisiumApiClient {
+  public readonly client: RevisiumClient;
 
   constructor(baseUrl: string) {
-    super({ baseUrl });
+    this.client = new RevisiumClient({ baseUrl });
   }
 
   public async authenticate(auth: AuthCredentials): Promise<string> {
@@ -32,61 +32,22 @@ export class RevisiumApiClient extends Api<unknown> {
   }
 
   private async authenticateWithToken(token: string): Promise<string> {
-    this.authToken = token;
-    const response = await this.api.me();
-
-    if (response.error) {
-      throw new Error(
-        `Token validation failed: ${JSON.stringify(response.error)}`,
-      );
-    }
-
-    return response.data.username || 'authenticated user';
+    this.client.loginWithToken(token);
+    const me = await this.client.me();
+    return me.username || 'authenticated user';
   }
 
   private async authenticateWithApiKey(apikey: string): Promise<string> {
-    this.authToken = apikey;
-    const response = await this.api.me();
-
-    if (response.error) {
-      throw new Error(
-        `API key validation failed: ${JSON.stringify(response.error)}`,
-      );
-    }
-
-    return response.data.username || 'authenticated user';
+    this.client.loginWithToken(apikey);
+    const me = await this.client.me();
+    return me.username || 'authenticated user';
   }
 
   private async authenticateWithPassword(
     username: string,
     password: string,
   ): Promise<string> {
-    const response = await this.api.login({
-      emailOrUsername: username,
-      password: password,
-    });
-
-    if (response.error) {
-      throw new Error(`Login failed: ${JSON.stringify(response.error)}`);
-    }
-
-    this.authToken = response.data.accessToken;
+    await this.client.login(username, password);
     return username;
   }
-
-  protected mergeRequestParams(
-    params1: RequestParams,
-    params2?: RequestParams,
-  ): RequestParams {
-    const params = super.mergeRequestParams(params1, params2);
-
-    params.headers ??= {};
-
-    if (this.authToken) {
-      (params.headers as Record<string, string>)['Authorization'] =
-        `Bearer ${this.authToken}`;
-    }
-
-    return params;
-  }
 }

package/src/services/connection/connection-factory.service.ts

@@ -1,4 +1,5 @@
 import { Injectable } from '@nestjs/common';
+import { BranchScope, RevisionScope } from '@revisium/client';
 import { RevisiumApiClient } from './api-client';
 import { LoggerService } from '../common';
 import { RevisiumUrlComplete, UrlBuilderService } from '../url';
@@ -6,9 +7,8 @@ import { RevisiumUrlComplete, UrlBuilderService } from '../url';
 export interface ConnectionInfo {
   url: RevisiumUrlComplete;
   client: RevisiumApiClient;
-  revisionId: string;
-  headRevisionId: string;
-  draftRevisionId: string;
+  branchScope: BranchScope;
+  revisionScope: RevisionScope;
 }
 
 export interface ConnectOptions {
@@ -32,11 +32,24 @@ export class ConnectionFactoryService {
     this.logger.connecting(label, formattedUrl);
 
     const client = await this.createAuthenticatedClient(url);
-    await this.validateProject(client, url);
-    const revisions = await this.fetchRevisions(client, url);
 
-    const revisionId = this.resolveRevisionId(url.revision, revisions);
-    const revisionLabel = this.formatRevisionLabel(url.revision, revisions);
+    const branchScope = await client.client.branch({
+      org: url.organization,
+      project: url.project,
+      branch: url.branch || 'master',
+    });
+
+    const revisionScope = await this.resolveRevisionScope(
+      url.revision,
+      branchScope,
+    );
+    const revisionId = revisionScope.revisionId;
+    const revisionLabel = this.formatRevisionLabel(
+      url.revision,
+      branchScope.headRevisionId,
+      branchScope.draftRevisionId,
+      revisionId,
+    );
 
     this.logger.connected(
       `Project: ${url.organization}/${url.project}, Branch: ${url.branch || 'master'}, Revision: ${revisionLabel}`,
@@ -45,9 +58,8 @@ export class ConnectionFactoryService {
     return {
       url,
       client,
-      revisionId,
-      headRevisionId: revisions.headRevisionId,
-      draftRevisionId: revisions.draftRevisionId,
+      branchScope,
+      revisionScope,
     };
   }
 
@@ -62,64 +74,24 @@ export class ConnectionFactoryService {
     return client;
   }
 
-  private async validateProject(
-    client: RevisiumApiClient,
-    url: RevisiumUrlComplete,
-  ): Promise<void> {
-    const response = await client.api.project(url.organization, url.project);
-
-    if (response.error) {
-      throw new Error(
-        `Failed to get project: ${JSON.stringify(response.error)}`,
-      );
-    }
-  }
-
-  private async fetchRevisions(
-    client: RevisiumApiClient,
-    url: RevisiumUrlComplete,
-  ): Promise<{ headRevisionId: string; draftRevisionId: string }> {
-    const branchName = url.branch || 'master';
-
-    const [headResponse, draftResponse] = await Promise.all([
-      client.api.headRevision(url.organization, url.project, branchName),
-      client.api.draftRevision(url.organization, url.project, branchName),
-    ]);
-
-    if (headResponse.error) {
-      throw new Error(
-        `Failed to get head revision: ${JSON.stringify(headResponse.error)}`,
-      );
-    }
-
-    if (draftResponse.error) {
-      throw new Error(
-        `Failed to get draft revision: ${JSON.stringify(draftResponse.error)}`,
-      );
-    }
-
-    return {
-      headRevisionId: headResponse.data.id,
-      draftRevisionId: draftResponse.data.id,
-    };
-  }
-
-  private resolveRevisionId(
+  private async resolveRevisionScope(
     revision: string,
-    revisions: { headRevisionId: string; draftRevisionId: string },
-  ): string {
-    if (revision === 'head') {
-      return revisions.headRevisionId;
-    }
+    branchScope: BranchScope,
+  ): Promise<RevisionScope> {
     if (revision === 'draft') {
-      return revisions.draftRevisionId;
+      return branchScope.draft();
     }
-    return revision;
+    if (revision === 'head') {
+      return branchScope.head();
+    }
+    return branchScope.revision(revision);
   }
 
   private formatRevisionLabel(
     revision: string,
-    revisions: { headRevisionId: string; draftRevisionId: string },
+    headRevisionId: string,
+    draftRevisionId: string,
+    resolvedId: string,
   ): string {
     if (revision === 'head') {
       return 'head';
@@ -128,12 +100,10 @@ export class ConnectionFactoryService {
       return 'draft';
     }
 
-    const resolvedId = this.resolveRevisionId(revision, revisions);
-
-    if (resolvedId === revisions.headRevisionId) {
+    if (resolvedId === headRevisionId) {
       return `${resolvedId} (head)`;
     }
-    if (resolvedId === revisions.draftRevisionId) {
+    if (resolvedId === draftRevisionId) {
       return `${resolvedId} (draft)`;
     }
 

package/src/services/connection/connection.service.ts

@@ -1,5 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
+import { RevisionScope } from '@revisium/client';
 import {
   ConnectionFactoryService,
   ConnectionInfo,
@@ -29,20 +30,8 @@ export class ConnectionService {
     return this._connection;
   }
 
-  public get api() {
-    return this.connection.client.api;
-  }
-
-  public get revisionId(): string {
-    return this.connection.revisionId;
-  }
-
-  public get draftRevisionId(): string {
-    return this.connection.draftRevisionId;
-  }
-
-  public get headRevisionId(): string {
-    return this.connection.headRevisionId;
+  public get revisionScope(): RevisionScope {
+    return this.connection.revisionScope;
   }
 
   public async connect(options: ConnectionOptions = {}): Promise<void> {

package/src/services/sync/__tests__/row-sync.service.spec.ts

@@ -97,7 +97,7 @@ describe('RowSyncService', () => {
         updateRows: jest.fn(),
       };
 
-      const result = await service.getExistingRows(mockApi, 'rev1', 'table1');
+      const result = await service.getExistingRows(mockApi, 'table1');
 
       expect(result.size).toBe(3);
       expect(result.get('row1')).toEqual({ name: 'A' });
@@ -113,7 +113,7 @@ describe('RowSyncService', () => {
         updateRows: jest.fn(),
       };
 
-      const result = await service.getExistingRows(mockApi, 'rev1', 'table1');
+      const result = await service.getExistingRows(mockApi, 'table1');
 
       expect(result.size).toBe(0);
     });
@@ -131,7 +131,7 @@ describe('RowSyncService', () => {
       };
       const onProgress = jest.fn();
 
-      await service.getExistingRows(mockApi, 'rev1', 'table1', onProgress);
+      await service.getExistingRows(mockApi, 'table1', onProgress);
 
       expect(onProgress).toHaveBeenCalledWith({
         operation: 'fetch',
@@ -160,7 +160,6 @@ describe('RowSyncService', () => {
 
       const stats = await service.syncTableRows(
         mockApi,
-        'rev1',
         'table1',
         sourceRows,
         100,
@@ -188,7 +187,6 @@ describe('RowSyncService', () => {
 
       const stats = await service.syncTableRows(
         mockApi,
-        'rev1',
         'table1',
         sourceRows,
         100,
@@ -217,7 +215,6 @@ describe('RowSyncService', () => {
 
       const stats = await service.syncTableRows(
         mockApi,
-        'rev1',
         'table1',
         sourceRows,
         100,

package/src/services/sync/commit-revision.service.ts

@@ -1,4 +1,5 @@
 import { Injectable } from '@nestjs/common';
+import { RevisionScope } from '@revisium/client';
 import { ConnectionInfo as SyncConnectionInfo } from './sync-api.service';
 import { ConnectionService } from '../connection';
 import { LoggerService } from '../common';
@@ -7,20 +8,6 @@ export interface CommitResult {
   revisionId: string;
 }
 
-interface CommitParams {
-  organization: string;
-  project: string;
-  branch: string;
-  api: {
-    createRevision: (
-      org: string,
-      proj: string,
-      branch: string,
-      data: { comment: string },
-    ) => Promise<{ data?: { id: string }; error?: unknown }>;
-  };
-}
-
 @Injectable()
 export class CommitRevisionService {
   constructor(
@@ -34,12 +21,7 @@ export class CommitRevisionService {
   ): Promise<CommitResult> {
     const connection = this.connectionService.connection;
     return this.doCommit(
-      {
-        organization: connection.url.organization,
-        project: connection.url.project,
-        branch: connection.url.branch,
-        api: connection.client.api,
-      },
+      connection.revisionScope,
       actionDescription,
       changeCount,
     );
@@ -69,19 +51,14 @@ export class CommitRevisionService {
     }
 
     await this.doCommit(
-      {
-        organization: connection.url.organization,
-        project: connection.url.project,
-        branch: connection.url.branch,
-        api: connection.client.api,
-      },
+      connection.revisionScope,
       actionDescription,
       changeCount,
     );
   }
 
   private async doCommit(
-    params: CommitParams,
+    revisionScope: RevisionScope,
     actionDescription: string,
     changeCount: number,
   ): Promise<CommitResult> {
@@ -89,37 +66,16 @@ export class CommitRevisionService {
 
     const comment = this.generateCommitComment(actionDescription, changeCount);
 
-    let result: { data?: { id: string }; error?: unknown };
     try {
-      result = await params.api.createRevision(
-        params.organization,
-        params.project,
-        params.branch,
-        { comment },
-      );
+      const revision = await revisionScope.commit(comment);
+      this.logger.commitSuccess(revision.id);
+      return { revisionId: revision.id };
     } catch (error) {
       const errorMessage =
         error instanceof Error ? error.message : String(error);
       this.logger.commitError(errorMessage);
       throw error;
     }
-
-    if (result.error) {
-      const errorMessage =
-        typeof result.error === 'string'
-          ? result.error
-          : JSON.stringify(result.error);
-      this.logger.commitError(errorMessage);
-      throw new Error(errorMessage);
-    }
-
-    if (result.data) {
-      this.logger.commitSuccess(result.data.id);
-      return { revisionId: result.data.id };
-    }
-
-    this.logger.commitError('No data returned');
-    throw new Error('Failed to create revision');
   }
 
   private generateCommitComment(