revisium 2.2.0 → 2.4.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/docs/url-format.md

@@ -6,6 +6,8 @@ Revisium CLI uses a special URL format to specify project connections.
 
 ```text
 revisium://[user:password@]host[:port]/organization/project/branch[:revision][?params]
+revisium+http://[user:password@]host[:port]/organization/project/branch[:revision][?params]
+revisium+https://[user:password@]host[:port]/organization/project/branch[:revision][?params]
 ```
 
 ## URL Parts
@@ -44,6 +46,29 @@ revisium://[user:password@]host[:port]/organization/project/branch[:revision][?p
 | `127.0.0.1` | http | 8080 |
 | Other hosts | https | 443 |
 
+### Explicit Protocol Override
+
+Use `revisium+http://` or `revisium+https://` to force a specific protocol, bypassing the auto-detection logic. This is useful in Kubernetes or other environments where internal services use HTTP on non-localhost hostnames.
+
+```text
+revisium+http://[user:password@]host[:port]/organization/project/branch[:revision][?params]
+revisium+https://[user:password@]host[:port]/organization/project/branch[:revision][?params]
+```
+
+| Prefix | Behavior |
+|--------|----------|
+| `revisium://` | Auto-detect (localhost → http, others → https) |
+| `revisium+http://` | Force HTTP |
+| `revisium+https://` | Force HTTPS |
+
+```bash
+# Force HTTP for internal Kubernetes service
+revisium+http://admin:pass@payment-config-svc:80/org/proj/master?token=xxx
+
+# Force HTTPS explicitly
+revisium+https://admin:pass@my-host/org/proj/master
+```
+
 ## Authentication Examples
 
 ### Token Authentication (Recommended)

package/e2e/tests/01-auth.e2e-spec.ts

@@ -156,4 +156,23 @@ describe('CLI Authentication', () => {
       expect(result.exitCode).toBe(0);
     });
   });
+
+  describe('Protocol override (revisium+http://)', () => {
+    it('connects via explicit HTTP protocol', async () => {
+      const token = process.env.E2E_ADMIN_TOKEN!;
+
+      const result = await runCli([
+        'schema',
+        'save',
+        '--url',
+        buildUrl(projectName, { token, protocol: 'http' }),
+        '--folder',
+        tempDir,
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Authenticated as admin');
+      expect(result.stdout).toContain('Successfully saved');
+    });
+  });
 });

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/e2e/utils/cli-runner.ts

@@ -81,11 +81,19 @@ export function buildUrl(
     branch?: string;
     revision?: 'draft' | 'head';
     token?: string;
+    protocol?: 'http' | 'https';
   } = {},
 ): string {
-  const { orgId = 'admin', branch = 'master', revision, token } = options;
-
-  let url = `revisium://localhost:8082/${orgId}/${projectName}/${branch}`;
+  const {
+    orgId = 'admin',
+    branch = 'master',
+    revision,
+    token,
+    protocol,
+  } = options;
+
+  const scheme = protocol ? `revisium+${protocol}` : 'revisium';
+  let url = `${scheme}://localhost:8082/${orgId}/${projectName}/${branch}`;
 
   if (revision) {
     url += `:${revision}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "revisium",
-  "version": "2.2.0",
+  "version": "2.4.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 {

package/src/services/url/__tests__/url-parser.service.spec.ts

@@ -0,0 +1,162 @@
+import { UrlParserService } from '../url-parser.service';
+
+describe('UrlParserService', () => {
+  let service: UrlParserService;
+
+  beforeEach(() => {
+    service = new UrlParserService();
+  });
+
+  describe('parse - revisium+http://', () => {
+    it('forces HTTP for non-localhost host', () => {
+      const result = service.parse(
+        'revisium+http://admin:pass@my-service:80/org/proj/branch',
+      );
+
+      expect(result).toEqual({
+        baseUrl: 'http://my-service:80',
+        username: 'admin',
+        password: 'pass',
+        token: undefined,
+        apikey: undefined,
+        organization: 'org',
+        project: 'proj',
+        branch: 'branch',
+        revision: undefined,
+      });
+    });
+
+    it('forces HTTP for non-localhost host with draft revision', () => {
+      const result = service.parse(
+        'revisium+http://admin:pass@my-service:80/org/proj/branch:draft',
+      );
+
+      expect(result).toEqual({
+        baseUrl: 'http://my-service:80',
+        username: 'admin',
+        password: 'pass',
+        token: undefined,
+        apikey: undefined,
+        organization: 'org',
+        project: 'proj',
+        branch: 'branch',
+        revision: 'draft',
+      });
+    });
+
+    it('forces HTTP without port', () => {
+      const result = service.parse(
+        'revisium+http://admin:pass@my-service/org/proj/branch',
+      );
+
+      expect(result).toEqual({
+        baseUrl: 'http://my-service',
+        username: 'admin',
+        password: 'pass',
+        token: undefined,
+        apikey: undefined,
+        organization: 'org',
+        project: 'proj',
+        branch: 'branch',
+        revision: undefined,
+      });
+    });
+
+    it('forces HTTP with token auth', () => {
+      const result = service.parse(
+        'revisium+http://payment-svc:80/org/proj/master?token=abc123',
+      );
+
+      expect(result).toEqual({
+        baseUrl: 'http://payment-svc:80',
+        username: undefined,
+        password: undefined,
+        token: 'abc123',
+        apikey: undefined,
+        organization: 'org',
+        project: 'proj',
+        branch: 'master',
+        revision: undefined,
+      });
+    });
+  });
+
+  describe('parse - revisium+https://', () => {
+    it('forces HTTPS for any host', () => {
+      const result = service.parse(
+        'revisium+https://admin:pass@my-service/org/proj/branch',
+      );
+
+      expect(result).toEqual({
+        baseUrl: 'https://my-service',
+        username: 'admin',
+        password: 'pass',
+        token: undefined,
+        apikey: undefined,
+        organization: 'org',
+        project: 'proj',
+        branch: 'branch',
+        revision: undefined,
+      });
+    });
+
+    it('forces HTTPS even for localhost', () => {
+      const result = service.parse(
+        'revisium+https://admin:pass@localhost:8443/org/proj/main',
+      );
+
+      expect(result).toEqual({
+        baseUrl: 'https://localhost:8443',
+        username: 'admin',
+        password: 'pass',
+        token: undefined,
+        apikey: undefined,
+        organization: 'org',
+        project: 'proj',
+        branch: 'main',
+        revision: undefined,
+      });
+    });
+  });
+
+  describe('parse - revisium:// (unchanged behavior)', () => {
+    it('auto-detects http for localhost', () => {
+      const result = service.parse(
+        'revisium://admin:pass@localhost:8888/org/proj/branch',
+      );
+
+      expect(result.baseUrl).toBe('http://localhost:8888');
+    });
+
+    it('auto-detects https for remote host', () => {
+      const result = service.parse(
+        'revisium://admin:pass@cloud.revisium.io/org/proj/branch',
+      );
+
+      expect(result.baseUrl).toBe('https://cloud.revisium.io');
+    });
+  });
+
+  describe('buildBaseUrlFromHost - protocolOverride', () => {
+    it('uses override when provided', () => {
+      expect(service.buildBaseUrlFromHost('my-service:80', 'http')).toBe(
+        'http://my-service:80',
+      );
+    });
+
+    it('override takes precedence over localhost auto-detect', () => {
+      expect(service.buildBaseUrlFromHost('localhost:8080', 'https')).toBe(
+        'https://localhost:8080',
+      );
+    });
+
+    it('falls back to auto-detect when no override', () => {
+      expect(service.buildBaseUrlFromHost('localhost:8080')).toBe(
+        'http://localhost:8080',
+      );
+      expect(service.buildBaseUrlFromHost('cloud.revisium.io')).toBe(
+        'https://cloud.revisium.io',
+      );
+    });
+  });
+});