revisium 2.2.0 → 2.3.0

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/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.2.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",

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/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 {