revisium 2.0.1 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "revisium",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "homepage": "https://revisium.io",
   "description": "A CLI tool for interacting with Revisium instances, providing migration management, schema export, and data export capabilities.",
   "author": "Anton Kashirov",
@@ -27,13 +27,11 @@
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
     "test:e2e": "jest --config ./e2e/jest-e2e.json",
     "test:e2e:cov": "npm run build:instrumented && E2E_INSTRUMENTED=1 jest --config ./e2e/jest-e2e.json",
+    "test:e2e:up": "FILE_PLUGIN_PUBLIC_ENDPOINT=https://cdn.example.com npx @revisium/standalone --auth --port 8082 --data .e2e-test & echo $! > .e2e-test.pid",
+    "test:e2e:down": "if [ -f .e2e-test.pid ]; then kill $(cat .e2e-test.pid) 2>/dev/null; rm -f .e2e-test.pid; fi; rm -rf .e2e-test",
     "build:instrumented": "npm run build && rm -rf dist-instrumented && mkdir -p dist-instrumented && cp dist/package.json dist-instrumented/ && npx nyc instrument dist/src dist-instrumented/src --include='**/*.js'",
     "test:all": "npm run test:cov && npm run test:e2e:cov && npm run coverage:merge",
-    "coverage:merge": "node scripts/merge-coverage.js",
-    "docker:e2e:up": "docker-compose -f e2e/docker-compose.e2e.yml up -d",
-    "docker:e2e:down": "docker-compose -f e2e/docker-compose.e2e.yml down -v",
-    "docker:e2e:logs": "docker-compose -f e2e/docker-compose.e2e.yml logs -f",
-    "generate:api": "npx swagger-typescript-api generate -p https://cloud.revisium.io/api-json -o src/__generated__ -n api.ts --extract-request-params --disable-throw-on-error"
+    "coverage:merge": "node scripts/merge-coverage.js"
   },
   "bin": {
     "revisium": "dist/src/main.js"
@@ -44,22 +42,24 @@
     "@nestjs/config": "^4.0.2",
     "@nestjs/core": "^11.0.1",
     "@nestjs/platform-express": "^11.0.1",
+    "@revisium/client": "^0.4.0",
     "@revisium/schema-toolkit": "^0.4.1",
     "@types/object-hash": "^3.0.6",
-    "ajv": "^8.17.1",
+    "ajv": "^8.18.0",
     "ajv-formats": "^3.0.1",
     "nest-commander": "^3.18.0",
     "object-hash": "^3.0.0",
     "reflect-metadata": "^0.2.2",
-    "rxjs": "^7.8.1",
-    "swagger-typescript-api": "^13.2.7"
+    "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.18.0",
+    "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@nestjs/cli": "^11.0.0",
     "@nestjs/schematics": "^11.0.0",
     "@nestjs/testing": "^11.0.1",
+    "@revisium/standalone": "2.6.0",
     "@swc/cli": "^0.6.0",
     "@swc/core": "^1.10.7",
     "@types/express": "^5.0.0",
@@ -69,9 +69,10 @@
     "eslint": "^9.18.0",
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-prettier": "^5.2.2",
-    "eslint-plugin-sonarjs": "^3.0.5",
+    "eslint-plugin-sonarjs": "^4.0.2",
     "globals": "^16.0.0",
     "jest": "^29.7.0",
+    "nyc": "^17.1.0",
     "prettier": "^3.4.2",
     "source-map-support": "^0.5.21",
     "supertest": "^7.0.0",
@@ -80,9 +81,22 @@
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.7.3",
-    "typescript-eslint": "^8.20.0",
-    "nyc": "^17.1.0",
-    "@istanbuljs/nyc-config-typescript": "^1.0.2"
+    "typescript-eslint": "^8.20.0"
+  },
+  "overrides": {
+    "hono": "^4.12.7",
+    "@hono/node-server": "^1.19.10",
+    "lodash": "^4.17.23",
+    "@angular-devkit/core": {
+      "ajv": "^8.18.0"
+    },
+    "schema-utils@3": {
+      "ajv": "^6.14.0"
+    },
+    "schema-utils@4": {
+      "ajv": "^8.18.0"
+    },
+    "file-type": "^21.3.2"
   },
   "jest": {
     "modulePaths": [
@@ -102,7 +116,6 @@
       "<rootDir>/src/**/*.(t|j)s",
       "!<rootDir>/src/main.ts",
       "!<rootDir>/src/app.module.ts",
-      "!<rootDir>/src/__generated__/**",
       "!<rootDir>/src/**/__tests__/**",
       "!<rootDir>/src/**/index.ts"
     ],

package/src/commands/migration/apply-migrations.command.ts

@@ -1,5 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { Option, SubCommand } from 'nest-commander';
+import { RevisionScope } from '@revisium/client';
 import { BaseCommand, BaseOptions } from 'src/commands/base.command';
 import { ConnectionService } from 'src/services/connection';
 import { JsonValidatorService, LoggerService } from 'src/services/common';
@@ -61,8 +62,6 @@ export class ApplyMigrationsCommand extends BaseCommand {
   }
 
   private async applyMigration(migrations: Migration[]) {
-    const revisionId = this.connectionService.draftRevisionId;
-
     if (migrations.length === 0) {
       this.logger.success(
         'No migrations to apply - all migrations are up to date',
@@ -76,11 +75,11 @@ export class ApplyMigrationsCommand extends BaseCommand {
 
     try {
       for (const localMigration of migrations) {
-        const result = await this.api.applyMigrations(revisionId, [
+        const results = await this.revisionScope.applyMigrationsWithStatus([
           localMigration,
         ]);
 
-        const response = result.data[0];
+        const response = results[0];
 
         if (response.status === 'failed') {
           this.logger.migrationFailed(response);
@@ -114,8 +113,8 @@ export class ApplyMigrationsCommand extends BaseCommand {
     return countAppliedMigrations;
   }
 
-  private get api() {
-    return this.connectionService.api;
+  private get revisionScope(): RevisionScope {
+    return this.connectionService.revisionScope;
   }
 
   @Option({

package/src/commands/migration/save-migrations.command.ts

@@ -1,5 +1,6 @@
 import { writeFile } from 'node:fs/promises';
 import { Option, SubCommand } from 'nest-commander';
+import { RevisionScope } from '@revisium/client';
 import { BaseCommand, BaseOptions } from 'src/commands/base.command';
 import { ConnectionService } from 'src/services/connection';
 import { LoggerService } from 'src/services/common';
@@ -26,14 +27,14 @@ export class SaveMigrationsCommand extends BaseCommand {
     }
 
     await this.connectionService.connect(options);
-    await this.saveFile(this.connectionService.revisionId, options.file);
+    await this.saveFile(options.file);
   }
 
-  private async saveFile(revisionId: string, filePath: string) {
+  private async saveFile(filePath: string) {
     try {
-      const result = await this.api.migrations(revisionId);
+      const migrations = await this.revisionScope.getMigrations();
 
-      await writeFile(filePath, JSON.stringify(result.data, null, 2), 'utf-8');
+      await writeFile(filePath, JSON.stringify(migrations, null, 2), 'utf-8');
 
       this.logger.success(`Save migrations to: ${filePath}`);
     } catch (error) {
@@ -53,7 +54,7 @@ export class SaveMigrationsCommand extends BaseCommand {
     return value;
   }
 
-  private get api() {
-    return this.connectionService.api;
+  private get revisionScope(): RevisionScope {
+    return this.connectionService.revisionScope;
   }
 }

package/src/commands/rows/save-rows.command.ts

@@ -1,6 +1,7 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { Option, SubCommand } from 'nest-commander';
+import { RevisionScope } from '@revisium/client';
 import { BaseCommand, BaseOptions } from 'src/commands/base.command';
 import { ConnectionService } from 'src/services/connection';
 import { LoggerService } from 'src/services/common';
@@ -32,30 +33,19 @@ export class SaveRowsCommand extends BaseCommand {
     }
 
     await this.connectionService.connect(options);
-    await this.saveAllTableRows(
-      this.connectionService.revisionId,
-      options.folder,
-      options.tables,
-    );
+    await this.saveAllTableRows(options.folder, options.tables);
   }
 
-  private async saveAllTableRows(
-    revisionId: string,
-    folderPath: string,
-    tableFilter?: string,
-  ) {
+  private async saveAllTableRows(folderPath: string, tableFilter?: string) {
     try {
       await mkdir(folderPath, { recursive: true });
 
-      const tablesToProcess = await this.getTargetTables(
-        revisionId,
-        tableFilter,
-      );
+      const tablesToProcess = await this.getTargetTables(tableFilter);
 
       this.logger.foundItems(tablesToProcess.length, 'tables to process');
 
       for (const tableId of tablesToProcess) {
-        await this.saveRowsFromTable(revisionId, tableId, folderPath);
+        await this.saveRowsFromTable(tableId, folderPath);
       }
 
       this.logger.summary(
@@ -69,26 +59,19 @@ export class SaveRowsCommand extends BaseCommand {
     }
   }
 
-  private async getTargetTables(
-    revisionId: string,
-    tableFilter?: string,
-  ): Promise<string[]> {
+  private async getTargetTables(tableFilter?: string): Promise<string[]> {
     if (tableFilter) {
       return tableFilter.split(',').map((id) => id.trim());
     }
 
     const { items } = await fetchAllPages((params) =>
-      this.api.tables({ revisionId, ...params }),
+      this.revisionScope.getTables(params).then((data) => ({ data })),
     );
 
     return items.map((table) => table.id);
   }
 
-  private async saveRowsFromTable(
-    revisionId: string,
-    tableId: string,
-    folderPath: string,
-  ) {
+  private async saveRowsFromTable(tableId: string, folderPath: string) {
     try {
       this.logger.processingTable(tableId);
 
@@ -96,7 +79,10 @@ export class SaveRowsCommand extends BaseCommand {
       await mkdir(tableFolderPath, { recursive: true });
 
       const { processed, total } = await fetchAndProcessPages(
-        (params) => this.api.rows(revisionId, tableId, params),
+        (params) =>
+          this.revisionScope
+            .getRows(tableId, params)
+            .then((data) => ({ data })),
         async (row) => {
           const filePath = join(tableFolderPath, `${row.id}.json`);
           await writeFile(filePath, JSON.stringify(row, null, 2), 'utf-8');
@@ -119,8 +105,8 @@ export class SaveRowsCommand extends BaseCommand {
     }
   }
 
-  private get api() {
-    return this.connectionService.api;
+  private get revisionScope(): RevisionScope {
+    return this.connectionService.revisionScope;
   }
 
   @Option({

package/src/commands/rows/upload-rows.command.ts

@@ -1,4 +1,5 @@
 import { Option, SubCommand } from 'nest-commander';
+import { RevisionScope } from '@revisium/client';
 import { BaseCommand, BaseOptions } from 'src/commands/base.command';
 import {
   ConnectionService,
@@ -57,11 +58,9 @@ export class UploadRowsCommand extends BaseCommand {
     }
 
     await this.connectionService.connect(options);
-    const revisionId = this.connectionService.draftRevisionId;
     const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
 
     const totalStats = await this.uploadAllTableRows(
-      revisionId,
       options.folder,
       options.tables,
       batchSize,
@@ -76,7 +75,6 @@ export class UploadRowsCommand extends BaseCommand {
   }
 
   private async uploadAllTableRows(
-    revisionId: string,
     folderPath: string,
     tableFilter: string | undefined,
     batchSize: number,
@@ -87,7 +85,7 @@ export class UploadRowsCommand extends BaseCommand {
     );
     this.logger.foundItems(tableIds.length, 'tables to process');
 
-    const tableSchemas = await this.fetchTableSchemas(revisionId, tableIds);
+    const tableSchemas = await this.fetchTableSchemas(tableIds);
     const sortedTables = this.getSortedTables(tableSchemas, tableIds);
 
     const totalStats = createEmptyUploadStats();
@@ -95,7 +93,6 @@ export class UploadRowsCommand extends BaseCommand {
     for (const tableId of sortedTables) {
       try {
         const tableStats = await this.uploadTableRows(
-          revisionId,
           tableId,
           folderPath,
           tableSchemas[tableId],
@@ -114,17 +111,14 @@ export class UploadRowsCommand extends BaseCommand {
   }
 
   private async fetchTableSchemas(
-    revisionId: string,
     tables: string[],
   ): Promise<Record<string, JsonSchema>> {
     const schemas: Record<string, JsonSchema> = {};
 
     for (const tableId of tables) {
       try {
-        const result = await this.api.tableSchema(revisionId, tableId);
-        if (result.data) {
-          schemas[tableId] = result.data as JsonSchema;
-        }
+        const schema = await this.revisionScope.getTableSchema(tableId);
+        schemas[tableId] = schema as JsonSchema;
       } catch (error) {
         this.logger.warn(
           `Could not fetch schema for table ${tableId}: ${error instanceof Error ? error.message : String(error)}`,
@@ -153,7 +147,6 @@ export class UploadRowsCommand extends BaseCommand {
   }
 
   private async uploadTableRows(
-    revisionId: string,
     tableId: string,
     folderPath: string,
     schema: JsonSchema | undefined,
@@ -190,10 +183,9 @@ export class UploadRowsCommand extends BaseCommand {
       return stats;
     }
 
-    const apiClient = createApiClientAdapter(this.api);
+    const apiClient = createApiClientAdapter(this.revisionScope);
     const syncStats = await this.rowSyncService.syncTableRows(
       apiClient,
-      revisionId,
       tableId,
       loadResult.rows,
       batchSize,
@@ -235,8 +227,8 @@ export class UploadRowsCommand extends BaseCommand {
     }
   }
 
-  private get api() {
-    return this.connectionService.api;
+  private get revisionScope(): RevisionScope {
+    return this.connectionService.revisionScope;
   }
 
   @Option({

package/src/commands/schema/create-migrations.command.ts

@@ -1,10 +1,10 @@
 import { readdir, readFile, writeFile } from 'node:fs/promises';
 import { join, extname } from 'node:path';
 import { CommandRunner, Option, SubCommand } from 'nest-commander';
+import type { InitMigrationDto } from '@revisium/client';
 import { JsonValidatorService, LoggerService } from 'src/services/common';
 import { TableDependencyService } from 'src/services/sync';
 import { JsonSchema } from 'src/types/schema.types';
-import { InitMigrationDto } from 'src/__generated__/api';
 import * as objectHash from 'object-hash';
 
 type Options = {

package/src/commands/schema/save-schema.command.ts

@@ -1,6 +1,7 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { Option, SubCommand } from 'nest-commander';
+import { RevisionScope } from '@revisium/client';
 import { BaseCommand, BaseOptions } from 'src/commands/base.command';
 import { ConnectionService } from 'src/services/connection';
 import { LoggerService } from 'src/services/common';
@@ -28,13 +29,10 @@ export class SaveSchemaCommand extends BaseCommand {
     }
 
     await this.connectionService.connect(options);
-    await this.saveAllTableSchemas(
-      this.connectionService.revisionId,
-      options.folder,
-    );
+    await this.saveAllTableSchemas(options.folder);
   }
 
-  private async saveAllTableSchemas(revisionId: string, folderPath: string) {
+  private async saveAllTableSchemas(folderPath: string) {
     try {
       await mkdir(folderPath, { recursive: true });
 
@@ -43,19 +41,16 @@ export class SaveSchemaCommand extends BaseCommand {
       let totalTables = 0;
 
       const { processed } = await fetchAndProcessPages(
-        (params) => this.api.tables({ revisionId, ...params }),
+        (params) =>
+          this.revisionScope.getTables(params).then((data) => ({ data })),
         async (table, index) => {
           this.logger.processingTable(table.id);
 
-          const schemaResult = await this.api.tableSchema(revisionId, table.id);
+          const schema = await this.revisionScope.getTableSchema(table.id);
           const fileName = `${table.id}.json`;
           const filePath = join(folderPath, fileName);
 
-          await writeFile(
-            filePath,
-            JSON.stringify(schemaResult.data, null, 2),
-            'utf-8',
-          );
+          await writeFile(filePath, JSON.stringify(schema, null, 2), 'utf-8');
 
           this.logger.success(
             `Saved schema: ${fileName} (${index + 1}/${totalTables})`,
@@ -80,8 +75,8 @@ export class SaveSchemaCommand extends BaseCommand {
     }
   }
 
-  private get api() {
-    return this.connectionService.api;
+  private get revisionScope(): RevisionScope {
+    return this.connectionService.revisionScope;
   }
 
   @Option({

package/src/config/meta-schema.ts

@@ -3,6 +3,45 @@ import { sharedFields } from 'src/config/shared-fields';
 
 // https://json-schema.org/specification#single-vocabulary-meta-schemas
 
+export const xFormulaSchema: Schema = {
+  type: 'object',
+  properties: {
+    version: {
+      const: 1,
+    },
+    expression: {
+      type: 'string',
+      minLength: 1,
+      maxLength: 10000,
+    },
+  },
+  additionalProperties: false,
+  required: ['version', 'expression'],
+};
+
+// When x-formula is present, readOnly must be true
+export const xFormulaRequiresReadOnly: Schema = {
+  if: {
+    properties: { 'x-formula': { type: 'object' } },
+    required: ['x-formula'],
+  },
+  then: {
+    properties: { readOnly: { const: true } },
+    required: ['readOnly'],
+  },
+};
+
+// foreignKey and x-formula are mutually exclusive
+export const foreignKeyExcludesFormula: Schema = {
+  if: {
+    properties: { foreignKey: { type: 'string' } },
+    required: ['foreignKey'],
+  },
+  then: {
+    not: { required: ['x-formula'] },
+  },
+};
+
 export const refMetaSchema: Schema = {
   type: 'object',
   properties: {
@@ -60,18 +99,22 @@ export const stringMetaSchema: Schema = {
     foreignKey: {
       type: 'string',
     },
+    'x-formula': xFormulaSchema,
   },
   additionalProperties: false,
   required: ['type', 'default'],
+  allOf: [xFormulaRequiresReadOnly, foreignKeyExcludesFormula],
 };
 
 export const noForeignKeyStringMetaSchema: Schema = {
   type: 'object',
   properties: {
     ...baseStringFields,
+    'x-formula': xFormulaSchema,
   },
   additionalProperties: false,
   required: ['type', 'default'],
+  ...xFormulaRequiresReadOnly,
 };
 
 export const numberMetaSchema: Schema = {
@@ -87,9 +130,11 @@ export const numberMetaSchema: Schema = {
       type: 'boolean',
     },
     ...sharedFields,
+    'x-formula': xFormulaSchema,
   },
   additionalProperties: false,
   required: ['type', 'default'],
+  ...xFormulaRequiresReadOnly,
 };
 
 export const booleanMetaSchema: Schema = {
@@ -105,9 +150,11 @@ export const booleanMetaSchema: Schema = {
       type: 'boolean',
     },
     ...sharedFields,
+    'x-formula': xFormulaSchema,
   },
   additionalProperties: false,
   required: ['type', 'default'],
+  ...xFormulaRequiresReadOnly,
 };
 
 export const objectMetaSchema: Schema = {

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

@@ -0,0 +1,117 @@
+import { ConnectionFactoryService } from '../connection-factory.service';
+import { UrlBuilderService, RevisiumUrlComplete } from '../../url';
+import { LoggerService } from '../../common';
+import { RevisiumApiClient } from '../api-client';
+
+jest.mock('../api-client');
+
+describe('ConnectionFactoryService', () => {
+  let service: ConnectionFactoryService;
+  let urlBuilderFake: { formatAsRevisiumUrl: jest.Mock };
+  let loggerFake: {
+    connecting: jest.Mock;
+    connected: jest.Mock;
+    authenticated: jest.Mock;
+  };
+
+  const mockDraftScope = {
+    revisionId: 'draft-456',
+    isDraft: true,
+  };
+
+  const mockHeadScope = {
+    revisionId: 'head-123',
+    isDraft: false,
+  };
+
+  const mockExplicitScope = {
+    revisionId: 'specific-rev-id',
+    isDraft: false,
+  };
+
+  const mockBranchScope = {
+    draft: jest.fn().mockReturnValue(mockDraftScope),
+    head: jest.fn().mockReturnValue(mockHeadScope),
+    revision: jest.fn().mockResolvedValue(mockExplicitScope),
+    headRevisionId: 'head-123',
+    draftRevisionId: 'draft-456',
+  };
+
+  const baseUrl: RevisiumUrlComplete = {
+    baseUrl: 'https://cloud.revisium.io',
+    organization: 'test-org',
+    project: 'test-project',
+    branch: 'main',
+    revision: 'draft',
+    auth: { method: 'token', token: 'test-token' },
+  };
+
+  beforeEach(() => {
+    urlBuilderFake = {
+      formatAsRevisiumUrl: jest.fn().mockReturnValue('revisium://...'),
+    };
+
+    loggerFake = {
+      connecting: jest.fn(),
+      connected: jest.fn(),
+      authenticated: jest.fn(),
+    };
+
+    const MockApiClient = RevisiumApiClient as jest.MockedClass<
+      typeof RevisiumApiClient
+    >;
+    MockApiClient.mockImplementation(
+      () =>
+        ({
+          client: {
+            branch: jest.fn().mockResolvedValue(mockBranchScope),
+          },
+          authenticate: jest.fn().mockResolvedValue('test-user'),
+        }) as unknown as RevisiumApiClient,
+    );
+
+    service = new ConnectionFactoryService(
+      urlBuilderFake as unknown as UrlBuilderService,
+      loggerFake as unknown as LoggerService,
+    );
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('revision resolution', () => {
+    it('uses draft scope when revision is draft', async () => {
+      const url = { ...baseUrl, revision: 'draft' };
+
+      const result = await service.createConnection(url);
+
+      expect(mockBranchScope.draft).toHaveBeenCalled();
+      expect(mockBranchScope.head).not.toHaveBeenCalled();
+      expect(mockBranchScope.revision).not.toHaveBeenCalled();
+      expect(result.revisionScope).toBe(mockDraftScope);
+    });
+
+    it('uses head scope when revision is head', async () => {
+      const url = { ...baseUrl, revision: 'head' };
+
+      const result = await service.createConnection(url);
+
+      expect(mockBranchScope.head).toHaveBeenCalled();
+      expect(mockBranchScope.draft).not.toHaveBeenCalled();
+      expect(mockBranchScope.revision).not.toHaveBeenCalled();
+      expect(result.revisionScope).toBe(mockHeadScope);
+    });
+
+    it('uses explicit revision scope for specific revision ID', async () => {
+      const url = { ...baseUrl, revision: 'specific-rev-id' };
+
+      const result = await service.createConnection(url);
+
+      expect(mockBranchScope.revision).toHaveBeenCalledWith('specific-rev-id');
+      expect(mockBranchScope.draft).not.toHaveBeenCalled();
+      expect(mockBranchScope.head).not.toHaveBeenCalled();
+      expect(result.revisionScope).toBe(mockExplicitScope);
+    });
+  });
+});