revisium 2.1.0 → 2.3.0

package/docs/authentication.md

@@ -8,8 +8,8 @@ JWT token from Revisium UI. Best for interactive use.
 
 ### Get Your Token
 
-- **Cloud:** <https://cloud.revisium.io/get-mcp-token>
-- **Self-hosted:** `https://your-host/get-mcp-token`
+- **Cloud:** <https://cloud.revisium.io/get-token>
+- **Self-hosted:** `https://your-host/get-token`
 
 ### Usage
 
@@ -57,7 +57,7 @@ If no credentials are provided, you'll be prompted:
 
 ```text
 Choose authentication method:
-  > Token (copy from https://cloud.revisium.io/get-mcp-token)
+  > Token (copy from https://cloud.revisium.io/get-token)
     API Key (for automated access)
     Username & Password
 

package/docs/migrate-commands.md

@@ -39,7 +39,7 @@ revisium migrate save --file ./migrations.json \
 Apply migrations from a JSON file to Revisium.
 
 ```bash
-revisium migrate apply --file <path> [--commit]
+revisium migrate apply --file <path> [--commit] [--create-project]
 ```
 
 ### Options
@@ -48,6 +48,7 @@ revisium migrate apply --file <path> [--commit]
 |--------|-------------|----------|
 | `-f, --file <path>` | Migrations file path | Yes |
 | `-c, --commit` | Create revision after applying | No |
+| `--create-project` | Auto-create project if it doesn't exist | No |
 | `--url <url>` | Revisium URL (see [URL Format](./url-format.md)) | No* |
 
 *If `--url` is not provided, uses `REVISIUM_URL` environment variable or prompts interactively.
@@ -165,6 +166,10 @@ git commit -m "Add user phone field migration"
 export REVISIUM_URL=revisium://cloud.revisium.io/myorg/myproject/master
 export REVISIUM_TOKEN=$DEPLOY_TOKEN
 revisium migrate apply --file ./migrations.json --commit
+
+# Apply in CI/CD with auto-create (fresh instance)
+revisium migrate apply --file ./migrations.json --commit --create-project \
+  --url revisium://admin:admin@localhost:8888/admin/billing/master:draft
 ```
 
 See [URL Format](./url-format.md) for complete URL syntax and [Authentication](./authentication.md) for auth options.

package/docs/url-format.md

@@ -63,8 +63,8 @@ revisium migrate apply --file ./migrations.json \
 ```
 
 Get your token:
-- **Cloud:** https://cloud.revisium.io/get-mcp-token
-- **Self-hosted:** https://your-host/get-mcp-token
+- **Cloud:** https://cloud.revisium.io/get-token
+- **Self-hosted:** https://your-host/get-token
 
 ### API Key Authentication
 

package/e2e/tests/03-migrate.e2e-spec.ts

@@ -2,7 +2,11 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { runCli, buildUrl } from '../utils/cli-runner';
-import { createTestProject } from '../utils/test-project';
+import {
+  createTestProject,
+  deleteTestProject,
+  generateProjectName,
+} from '../utils/test-project';
 import { api } from '../utils/api-client';
 import { FIXTURES_PATH } from '../utils/constants';
 
@@ -88,6 +92,50 @@ describe('Migrate Commands', () => {
       expect(updatedProject.rootBranch.headRevisionId).not.toBe(beforeHeadId);
     });
 
+    it('creates project with --create-project when project does not exist', async () => {
+      const projectName = generateProjectName('e2e-create');
+
+      try {
+        const result = await runCli([
+          'migrate',
+          'apply',
+          '--url',
+          buildUrl(projectName, { token }),
+          '--file',
+          path.join(FIXTURES_PATH, 'migrations.json'),
+          '--create-project',
+        ]);
+
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toContain('creating automatically');
+        expect(result.stdout).toContain('Successfully applied');
+
+        const project = await api.getProject('admin', projectName);
+        expect(project.name).toBe(projectName);
+
+        const tables = await api.getTables(project.rootBranch.draftRevisionId);
+        expect(tables.length).toBe(14);
+      } finally {
+        await deleteTestProject(projectName);
+      }
+    });
+
+    it('fails with hint when project not found without --create-project', async () => {
+      const projectName = generateProjectName('e2e-no-create');
+
+      const result = await runCli([
+        'migrate',
+        'apply',
+        '--url',
+        buildUrl(projectName, { token }),
+        '--file',
+        path.join(FIXTURES_PATH, 'migrations.json'),
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stdout + result.stderr).toContain('--create-project');
+    });
+
     it('skips already applied migrations', async () => {
       const project = await createTestProject();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "revisium",
-  "version": "2.1.0",
+  "version": "2.3.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",
@@ -45,7 +45,7 @@
     "@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",
@@ -69,7 +69,7 @@
     "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",
@@ -83,6 +83,21 @@
     "typescript": "^5.7.3",
     "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": [
       "<rootDir>"

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

@@ -11,6 +11,7 @@ import { parseBooleanOption } from 'src/utils/parse-boolean.utils';
 type Options = BaseOptions & {
   file: string;
   commit?: boolean;
+  createProject?: boolean;
 };
 
 @SubCommand({
@@ -36,7 +37,10 @@ export class ApplyMigrationsCommand extends BaseCommand {
     const jsonData = await this.validateJsonFile(options.file);
     this.logger.success('Migration file validation passed');
 
-    await this.connectionService.connect(options);
+    await this.connectionService.connect({
+      url: options.url,
+      createProject: options.createProject,
+    });
 
     const countAppliedMigrations = await this.applyMigration(jsonData);
 
@@ -133,4 +137,13 @@ export class ApplyMigrationsCommand extends BaseCommand {
   parseCommit(value?: string): boolean {
     return parseBooleanOption(value);
   }
+
+  @Option({
+    flags: '--create-project [boolean]',
+    description:
+      'Automatically create the project if it does not exist (for CI/CD)',
+  })
+  parseCreateProject(value?: string): boolean {
+    return parseBooleanOption(value);
+  }
 }

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

@@ -12,6 +12,7 @@ describe('ConnectionFactoryService', () => {
     connecting: jest.Mock;
     connected: jest.Mock;
     authenticated: jest.Mock;
+    info: jest.Mock;
   };
 
   const mockDraftScope = {
@@ -55,6 +56,7 @@ describe('ConnectionFactoryService', () => {
       connecting: jest.fn(),
       connected: jest.fn(),
       authenticated: jest.fn(),
+      info: jest.fn(),
     };
 
     const MockApiClient = RevisiumApiClient as jest.MockedClass<
@@ -114,4 +116,143 @@ describe('ConnectionFactoryService', () => {
       expect(result.revisionScope).toBe(mockExplicitScope);
     });
   });
+
+  describe('createProject option', () => {
+    let mockOrgScope: { createProject: jest.Mock };
+
+    beforeEach(() => {
+      mockOrgScope = {
+        createProject: jest.fn().mockResolvedValue({ id: 'new-project-id' }),
+      };
+    });
+
+    it('creates project and retries when createProject is true and project not found', async () => {
+      const projectNotFoundError = new Error(
+        'A project with this name does not exist in the organization',
+      );
+
+      const MockApiClient = RevisiumApiClient as jest.MockedClass<
+        typeof RevisiumApiClient
+      >;
+      MockApiClient.mockImplementation(
+        () =>
+          ({
+            client: {
+              branch: jest
+                .fn()
+                .mockRejectedValueOnce(projectNotFoundError)
+                .mockResolvedValueOnce(mockBranchScope),
+              org: jest.fn().mockReturnValue(mockOrgScope),
+            },
+            authenticate: jest.fn().mockResolvedValue('test-user'),
+          }) as unknown as RevisiumApiClient,
+      );
+
+      service = new ConnectionFactoryService(
+        urlBuilderFake as unknown as UrlBuilderService,
+        loggerFake as unknown as LoggerService,
+      );
+
+      const result = await service.createConnection(baseUrl, {
+        createProject: true,
+      });
+
+      expect(mockOrgScope.createProject).toHaveBeenCalledWith({
+        projectName: 'test-project',
+      });
+      expect(result.revisionScope).toBe(mockDraftScope);
+      expect(loggerFake.info).toHaveBeenCalledWith(
+        'Project "test-project" not found — creating automatically',
+      );
+    });
+
+    it('throws with hint when createProject is false and project not found', async () => {
+      const projectNotFoundError = new Error(
+        'A project with this name does not exist in the organization',
+      );
+
+      const MockApiClient = RevisiumApiClient as jest.MockedClass<
+        typeof RevisiumApiClient
+      >;
+      MockApiClient.mockImplementation(
+        () =>
+          ({
+            client: {
+              branch: jest.fn().mockRejectedValue(projectNotFoundError),
+            },
+            authenticate: jest.fn().mockResolvedValue('test-user'),
+          }) as unknown as RevisiumApiClient,
+      );
+
+      service = new ConnectionFactoryService(
+        urlBuilderFake as unknown as UrlBuilderService,
+        loggerFake as unknown as LoggerService,
+      );
+
+      await expect(service.createConnection(baseUrl)).rejects.toThrow(
+        'Use --create-project to auto-create',
+      );
+    });
+
+    it('creates project on generic not-found error when createProject is true', async () => {
+      const notFoundError = new Error('Resource not found');
+
+      const MockApiClient = RevisiumApiClient as jest.MockedClass<
+        typeof RevisiumApiClient
+      >;
+      MockApiClient.mockImplementation(
+        () =>
+          ({
+            client: {
+              branch: jest
+                .fn()
+                .mockRejectedValueOnce(notFoundError)
+                .mockResolvedValueOnce(mockBranchScope),
+              org: jest.fn().mockReturnValue(mockOrgScope),
+            },
+            authenticate: jest.fn().mockResolvedValue('test-user'),
+          }) as unknown as RevisiumApiClient,
+      );
+
+      service = new ConnectionFactoryService(
+        urlBuilderFake as unknown as UrlBuilderService,
+        loggerFake as unknown as LoggerService,
+      );
+
+      const result = await service.createConnection(baseUrl, {
+        createProject: true,
+      });
+
+      expect(mockOrgScope.createProject).toHaveBeenCalledWith({
+        projectName: 'test-project',
+      });
+      expect(result.revisionScope).toBe(mockDraftScope);
+    });
+
+    it('rethrows non-project errors even with createProject', async () => {
+      const networkError = new Error('ECONNREFUSED');
+
+      const MockApiClient = RevisiumApiClient as jest.MockedClass<
+        typeof RevisiumApiClient
+      >;
+      MockApiClient.mockImplementation(
+        () =>
+          ({
+            client: {
+              branch: jest.fn().mockRejectedValue(networkError),
+            },
+            authenticate: jest.fn().mockResolvedValue('test-user'),
+          }) as unknown as RevisiumApiClient,
+      );
+
+      service = new ConnectionFactoryService(
+        urlBuilderFake as unknown as UrlBuilderService,
+        loggerFake as unknown as LoggerService,
+      );
+
+      await expect(
+        service.createConnection(baseUrl, { createProject: true }),
+      ).rejects.toThrow('ECONNREFUSED');
+    });
+  });
 });

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

@@ -157,6 +157,7 @@ describe('ConnectionService', () => {
 
       expect(connectionFactoryFake.createConnection).toHaveBeenCalledWith(
         mockUrl,
+        { createProject: undefined },
       );
     });
   });

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

@@ -13,6 +13,7 @@ export interface ConnectionInfo {
 
 export interface ConnectOptions {
   label?: string;
+  createProject?: boolean;
 }
 
 @Injectable()
@@ -33,11 +34,7 @@ export class ConnectionFactoryService {
 
     const client = await this.createAuthenticatedClient(url);
 
-    const branchScope = await client.client.branch({
-      org: url.organization,
-      project: url.project,
-      branch: url.branch || 'master',
-    });
+    const branchScope = await this.resolveBranchScope(client, url, options);
 
     const revisionScope = await this.resolveRevisionScope(
       url.revision,
@@ -74,6 +71,51 @@ export class ConnectionFactoryService {
     return client;
   }
 
+  private async resolveBranchScope(
+    client: RevisiumApiClient,
+    url: RevisiumUrlComplete,
+    options: ConnectOptions,
+  ): Promise<BranchScope> {
+    const branchOptions = {
+      org: url.organization,
+      project: url.project,
+      branch: url.branch || 'master',
+    };
+
+    try {
+      return await client.client.branch(branchOptions);
+    } catch (error) {
+      if (options.createProject && this.isProjectNotFoundError(error)) {
+        this.logger.info(
+          `Project "${url.project}" not found — creating automatically`,
+        );
+
+        await client.client
+          .org(url.organization)
+          .createProject({ projectName: url.project });
+
+        return client.client.branch(branchOptions);
+      }
+
+      if (!options.createProject && this.isProjectNotFoundError(error)) {
+        throw new Error(
+          `Project "${url.project}" not found in organization "${url.organization}". Use --create-project to auto-create`,
+        );
+      }
+
+      throw error;
+    }
+  }
+
+  private isProjectNotFoundError(error: unknown): boolean {
+    const message = error instanceof Error ? error.message : String(error);
+    return (
+      message.includes('does not exist') ||
+      message.includes('not found') ||
+      message.includes('Not Found')
+    );
+  }
+
   private async resolveRevisionScope(
     revision: string,
     branchScope: BranchScope,

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

@@ -11,6 +11,7 @@ export { ConnectionInfo } from './connection-factory.service';
 
 export interface ConnectionOptions {
   url?: string;
+  createProject?: boolean;
 }
 
 @Injectable()
@@ -38,7 +39,9 @@ export class ConnectionService {
     const env = this.getEnvConfig();
     const url = await this.urlBuilder.parseAndComplete(options.url, 'api', env);
 
-    this._connection = await this.connectionFactory.createConnection(url);
+    this._connection = await this.connectionFactory.createConnection(url, {
+      createProject: options.createProject,
+    });
   }
 
   private getEnvConfig(): UrlEnvConfig {

package/src/services/url/auth-prompt.service.ts

@@ -68,6 +68,6 @@ export class AuthPromptService {
     const normalizedUrl = baseUrl.endsWith('/')
       ? baseUrl.slice(0, -1)
       : baseUrl;
-    return `${normalizedUrl}/get-mcp-token`;
+    return `${normalizedUrl}/get-token`;
   }
 }