revisium 2.3.0 → 2.4.0

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/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.3.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/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',
+      );
+    });
+  });
+});

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

@@ -27,6 +27,14 @@ function validatePort(port: number, context: string): void {
 @Injectable()
 export class UrlParserService {
   parse(input: string): RevisiumUrl {
+    if (input.startsWith('revisium+http://')) {
+      return this.parseRevisiumUrl(input, 'http');
+    }
+
+    if (input.startsWith('revisium+https://')) {
+      return this.parseRevisiumUrl(input, 'https');
+    }
+
     if (input.startsWith('revisium://')) {
       return this.parseRevisiumUrl(input);
     }
@@ -39,7 +47,10 @@ export class UrlParserService {
     return `${protocol}://${host}${portSuffix}`;
   }
 
-  buildBaseUrlFromHost(hostWithPort: string): string {
+  buildBaseUrlFromHost(
+    hostWithPort: string,
+    protocolOverride?: 'http' | 'https',
+  ): string {
     const [host, portStr] = hostWithPort.split(':');
     const port = portStr ? Number.parseInt(portStr, 10) : undefined;
 
@@ -47,8 +58,9 @@ export class UrlParserService {
       validatePort(port, `in "${hostWithPort}"`);
     }
 
-    const isLocalhost = LOCALHOST_HOSTS.has(host.toLowerCase());
-    const protocol = isLocalhost ? 'http' : 'https';
+    const protocol =
+      protocolOverride ??
+      (LOCALHOST_HOSTS.has(host.toLowerCase()) ? 'http' : 'https');
 
     if (port) {
       return this.buildBaseUrl(protocol, host, port);
@@ -65,8 +77,11 @@ export class UrlParserService {
     validatePort(port, context);
   }
 
-  private parseRevisiumUrl(url: string): RevisiumUrl {
-    const withoutProtocol = url.replace('revisium://', '');
+  private parseRevisiumUrl(
+    url: string,
+    forceProtocol?: 'http' | 'https',
+  ): RevisiumUrl {
+    const withoutProtocol = url.replace(/^revisium(\+https?)?:\/\//, '');
 
     const [mainPart, queryString] = withoutProtocol.split('?');
     const queryParams = this.parseQueryParams(queryString);
@@ -104,7 +119,7 @@ export class UrlParserService {
     const pathParts = hostAndPath.split('/');
     const hostWithPort = pathParts[0];
 
-    const baseUrl = this.buildBaseUrlFromHost(hostWithPort);
+    const baseUrl = this.buildBaseUrlFromHost(hostWithPort, forceProtocol);
 
     const branchWithRevision = pathParts[3] || undefined;
     let branch: string | undefined;