revisium 2.3.0 → 2.5.0-alpha.0

package/e2e/matrix/M11-target-resolution.e2e-spec.ts

@@ -0,0 +1,177 @@
+/**
+ * Matrix M11 — Target / auth resolution precedence on a single command
+ * (`project ensure`).
+ *
+ * Standalone: one `--auth` instance.
+ *
+ * Prep:
+ *  1. Spawn standalone, login, mint API key.
+ *  2. Workspace tempdir gets a config with two contexts and one
+ *     `currentContext`.
+ *  3. Project is created lazily per case so tests don't depend on each other.
+ */
+
+import { runCli } from '../utils/cli-runner';
+import {
+  CLEAR_REVISIUM_ENV,
+  createWorkspace,
+  removeWorkspace,
+  writeWorkspaceConfig,
+} from '../utils/matrix-workspace';
+import {
+  startStandalone,
+  StandaloneInstance,
+} from '../utils/standalone-runner';
+
+describe('M11 — target & auth resolution', () => {
+  let standalone: StandaloneInstance;
+  let apiKey: string;
+  let adminToken: string;
+  const workspaces: string[] = [];
+
+  beforeAll(async () => {
+    standalone = await startStandalone({
+      auth: true,
+      adminPassword: 'test-admin',
+    });
+    adminToken = await standalone.api.login('admin', 'test-admin');
+    apiKey = (
+      await standalone.api.mintApiKey('admin', { name: 'matrix-resolution' })
+    ).apiKey;
+  }, 180_000);
+
+  afterAll(async () => {
+    for (const workspace of workspaces) removeWorkspace(workspace);
+    workspaces.length = 0;
+    if (standalone) {
+      await standalone.stop();
+    }
+  });
+
+  function buildWorkspace(currentContext: string): string {
+    const workspace = createWorkspace('revisium-cli-matrix-resolution-');
+    workspaces.push(workspace);
+    writeWorkspaceConfig(workspace, {
+      currentContext,
+      instances: { local: { baseUrl: standalone.baseUrl, authMode: 'stored' } },
+      contexts: {
+        primary: {
+          instance: 'local',
+          organization: 'admin',
+          project: 'project-primary',
+        },
+        secondary: {
+          instance: 'local',
+          organization: 'admin',
+          project: 'project-secondary',
+        },
+      },
+    });
+    return workspace;
+  }
+
+  it('--url overrides --context', async () => {
+    const workspace = buildWorkspace('primary');
+    const projectFromUrl = `m11-url-${Date.now()}`;
+    const result = await runCli(
+      [
+        'project',
+        'ensure',
+        '--context',
+        'primary',
+        '--url',
+        standalone.url({ project: projectFromUrl }),
+        '--json',
+      ],
+      {
+        cwd: workspace,
+        env: { ...CLEAR_REVISIUM_ENV, REVISIUM_API_KEY: apiKey },
+      },
+    );
+    expect(result.exitCode).toBe(0);
+    const summary = JSON.parse(result.stdout) as { project: string };
+    expect(summary.project).toBe(projectFromUrl);
+  });
+
+  it('--context overrides REVISIUM_URL', async () => {
+    const workspace = buildWorkspace('primary');
+    const result = await runCli(
+      ['project', 'ensure', '--context', 'secondary', '--json'],
+      {
+        cwd: workspace,
+        env: {
+          ...CLEAR_REVISIUM_ENV,
+          REVISIUM_URL: standalone.url({ project: 'project-from-env' }),
+          REVISIUM_API_KEY: apiKey,
+        },
+      },
+    );
+    expect(result.exitCode).toBe(0);
+    const summary = JSON.parse(result.stdout) as { project: string };
+    expect(summary.project).toBe('project-secondary');
+  });
+
+  it('REVISIUM_URL overrides currentContext', async () => {
+    const workspace = buildWorkspace('primary');
+    const result = await runCli(['project', 'ensure', '--json'], {
+      cwd: workspace,
+      env: {
+        ...CLEAR_REVISIUM_ENV,
+        REVISIUM_URL: standalone.url({ project: 'project-from-env' }),
+        REVISIUM_API_KEY: apiKey,
+      },
+    });
+    expect(result.exitCode).toBe(0);
+    const summary = JSON.parse(result.stdout) as { project: string };
+    expect(summary.project).toBe('project-from-env');
+  });
+
+  it('falls back to currentContext when nothing else is set', async () => {
+    const workspace = buildWorkspace('secondary');
+    const result = await runCli(['project', 'ensure', '--json'], {
+      cwd: workspace,
+      env: { ...CLEAR_REVISIUM_ENV, REVISIUM_API_KEY: apiKey },
+    });
+    expect(result.exitCode).toBe(0);
+    const summary = JSON.parse(result.stdout) as { project: string };
+    expect(summary.project).toBe('project-secondary');
+  });
+
+  it('--token overrides REVISIUM_API_KEY', async () => {
+    const workspace = buildWorkspace('primary');
+    const project = `m11-token-${Date.now()}`;
+    const result = await runCli(
+      [
+        'project',
+        'ensure',
+        '--url',
+        standalone.url({ project }),
+        '--token',
+        adminToken,
+      ],
+      {
+        cwd: workspace,
+        env: { ...CLEAR_REVISIUM_ENV, REVISIUM_API_KEY: 'wrong-key' },
+      },
+    );
+    expect(result.exitCode).toBe(0);
+  });
+
+  it('?token=... in URL overrides REVISIUM_TOKEN', async () => {
+    const workspace = buildWorkspace('primary');
+    const project = `m11-url-token-${Date.now()}`;
+    const result = await runCli(
+      [
+        'project',
+        'ensure',
+        '--url',
+        `${standalone.url({ project })}?token=${adminToken}`,
+      ],
+      {
+        cwd: workspace,
+        env: { ...CLEAR_REVISIUM_ENV, REVISIUM_TOKEN: 'wrong-token' },
+      },
+    );
+    expect(result.exitCode).toBe(0);
+  });
+});

package/e2e/matrix/M12-error-paths.e2e-spec.ts

@@ -0,0 +1,162 @@
+/**
+ * Matrix M12 — Error paths and remediation messages.
+ *
+ * Standalone: one `--auth` instance.
+ *
+ * Prep: spawn standalone, login, mint a key. Tests deliberately send the
+ * wrong credentials, missing files, malformed config, etc., and assert on
+ * non-zero exit codes + helpful stderr.
+ */
+
+import * as fs from 'node:fs';
+import { runCli } from '../utils/cli-runner';
+import {
+  CLEAR_REVISIUM_ENV,
+  createWorkspace,
+  removeWorkspace,
+  writeWorkspaceConfig,
+  workspaceFile,
+} from '../utils/matrix-workspace';
+import {
+  startStandalone,
+  StandaloneInstance,
+} from '../utils/standalone-runner';
+
+describe('M12 — error paths', () => {
+  let standalone: StandaloneInstance;
+  let apiKey: string;
+  const workspaces: string[] = [];
+
+  beforeAll(async () => {
+    standalone = await startStandalone({
+      auth: true,
+      adminPassword: 'test-admin',
+    });
+    await standalone.api.login('admin', 'test-admin');
+    apiKey = (
+      await standalone.api.mintApiKey('admin', { name: 'matrix-errors' })
+    ).apiKey;
+  }, 180_000);
+
+  afterAll(async () => {
+    for (const workspace of workspaces) removeWorkspace(workspace);
+    workspaces.length = 0;
+    if (standalone) {
+      await standalone.stop();
+    }
+  });
+
+  function newWorkspace(): string {
+    const ws = createWorkspace('revisium-cli-matrix-errors-');
+    workspaces.push(ws);
+    return ws;
+  }
+
+  it('unauthenticated request to --auth standalone surfaces an auth error', async () => {
+    const workspace = newWorkspace();
+    const result = await runCli(
+      ['project', 'ensure', '--url', standalone.url({ project: 'whatever' })],
+      { cwd: workspace, env: { ...CLEAR_REVISIUM_ENV } },
+    );
+    expect(result.exitCode).not.toBe(0);
+    expect(result.stderr.toLowerCase()).toMatch(
+      /auth|credential|unauthorized|api key|401/,
+    );
+  });
+
+  it('wrong API key surfaces a credential error', async () => {
+    const workspace = newWorkspace();
+    const result = await runCli(
+      ['project', 'ensure', '--url', standalone.url({ project: 'whatever' })],
+      {
+        cwd: workspace,
+        env: { ...CLEAR_REVISIUM_ENV, REVISIUM_API_KEY: 'invalid-key' },
+      },
+    );
+    expect(result.exitCode).not.toBe(0);
+    expect(result.stderr.toLowerCase()).toMatch(
+      /unauthorized|forbidden|invalid|credential|api key|401|403/,
+    );
+  });
+
+  it('broken workspace config surfaces a parse error with the file path', async () => {
+    const workspace = newWorkspace();
+    const path = workspaceFile(
+      workspace,
+      '.revisium',
+      'revisium-cli.config.json',
+    );
+    fs.mkdirSync(workspaceFile(workspace, '.revisium'), { recursive: true });
+    fs.writeFileSync(path, '{ broken json');
+    const result = await runCli(['instance', 'list'], {
+      cwd: workspace,
+      env: CLEAR_REVISIUM_ENV,
+    });
+    expect(result.exitCode).not.toBe(0);
+    expect(result.stderr).toContain('revisium-cli.config.json');
+  });
+
+  it('instance remove against an unknown name fails fast', async () => {
+    const workspace = newWorkspace();
+    writeWorkspaceConfig(workspace, { instances: {} });
+    const result = await runCli(['instance', 'remove', 'unknown'], {
+      cwd: workspace,
+      env: CLEAR_REVISIUM_ENV,
+    });
+    expect(result.exitCode).not.toBe(0);
+  });
+
+  it('context use against an unknown name fails fast', async () => {
+    const workspace = newWorkspace();
+    writeWorkspaceConfig(workspace, {
+      instances: { local: { baseUrl: standalone.baseUrl } },
+      contexts: {},
+    });
+    const result = await runCli(['context', 'use', 'unknown'], {
+      cwd: workspace,
+      env: CLEAR_REVISIUM_ENV,
+    });
+    expect(result.exitCode).not.toBe(0);
+  });
+
+  it('migrate apply with a missing file surfaces ENOENT-like error', async () => {
+    const workspace = newWorkspace();
+    const result = await runCli(
+      [
+        'migrate',
+        'apply',
+        '--file',
+        workspaceFile(workspace, 'absent.json'),
+        '--commit',
+        '--url',
+        standalone.url({ project: 'whatever' }),
+      ],
+      {
+        cwd: workspace,
+        env: { ...CLEAR_REVISIUM_ENV, REVISIUM_API_KEY: apiKey },
+      },
+    );
+    expect(result.exitCode).not.toBe(0);
+    expect(result.stderr.toLowerCase()).toMatch(/file|not found|enoent/);
+  });
+
+  it('example bootstrap with a missing config fails before contacting the server', async () => {
+    const workspace = newWorkspace();
+    const result = await runCli(
+      [
+        'example',
+        'bootstrap',
+        '--config',
+        workspaceFile(workspace, 'absent.json'),
+        '--url',
+        standalone.url({ project: 'whatever' }),
+      ],
+      {
+        cwd: workspace,
+        env: { ...CLEAR_REVISIUM_ENV, REVISIUM_API_KEY: apiKey },
+      },
+    );
+    expect(result.exitCode).not.toBe(0);
+    expect(result.stderr).toMatch(/Could not read bootstrap config/);
+  });
+});

package/e2e/matrix/M13-no-auth-mode.e2e-spec.ts

@@ -0,0 +1,119 @@
+/**
+ * Matrix M13 — `authMode: "none"` flow against an unauthenticated standalone.
+ *
+ * Standalone: one instance WITHOUT `--auth`.
+ *
+ * Prep:
+ *  1. Spawn standalone without --auth (no admin credentials needed).
+ *  2. Use REST API directly to create projects (no auth required).
+ *  3. Per-test workspace tempdir.
+ */
+
+import { runCli } from '../utils/cli-runner';
+import {
+  CLEAR_REVISIUM_ENV,
+  createWorkspace,
+  removeWorkspace,
+  uniqueCredentialStoreService,
+  writeWorkspaceConfig,
+} from '../utils/matrix-workspace';
+import {
+  startStandalone,
+  StandaloneInstance,
+} from '../utils/standalone-runner';
+
+describe('M13 — authMode none', () => {
+  let standalone: StandaloneInstance;
+  const credentialStoreService = uniqueCredentialStoreService();
+  const workspaces: string[] = [];
+
+  beforeAll(async () => {
+    standalone = await startStandalone({ auth: false });
+  }, 180_000);
+
+  afterAll(async () => {
+    for (const workspace of workspaces) removeWorkspace(workspace);
+    workspaces.length = 0;
+    if (standalone) {
+      await standalone.stop();
+    }
+  });
+
+  function newWorkspace(): string {
+    const ws = createWorkspace('revisium-cli-matrix-noauth-');
+    workspaces.push(ws);
+    return ws;
+  }
+
+  function buildEnv(): Record<string, string> {
+    return {
+      ...CLEAR_REVISIUM_ENV,
+      REVISIUM_CREDENTIAL_STORE_SERVICE: credentialStoreService,
+    };
+  }
+
+  it('project ensure works against an authMode "none" instance without credentials', async () => {
+    const workspace = newWorkspace();
+    writeWorkspaceConfig(workspace, {
+      currentContext: 'local-default',
+      instances: { local: { baseUrl: standalone.baseUrl, authMode: 'none' } },
+      contexts: {
+        'local-default': {
+          instance: 'local',
+          organization: 'admin',
+          project: `m13-${Date.now()}`,
+        },
+      },
+    });
+    const result = await runCli(['project', 'ensure', '--json'], {
+      cwd: workspace,
+      env: buildEnv(),
+    });
+    expect(result.exitCode).toBe(0);
+  });
+
+  it('auth login refuses to save a credential for authMode "none" without --force', async () => {
+    const workspace = newWorkspace();
+    writeWorkspaceConfig(workspace, {
+      instances: { local: { baseUrl: standalone.baseUrl, authMode: 'none' } },
+    });
+    const result = await runCli(
+      ['auth', 'login', '--instance', 'local', '--api-key-stdin'],
+      { cwd: workspace, env: buildEnv(), stdin: 'rev_dummy\n' },
+    );
+    expect(result.exitCode).not.toBe(0);
+  });
+
+  it('example bootstrap works without any credential', async () => {
+    const workspace = newWorkspace();
+    const project = `m13-bootstrap-${Date.now()}`;
+    writeWorkspaceConfig(workspace, {
+      currentContext: 'local-default',
+      instances: { local: { baseUrl: standalone.baseUrl, authMode: 'none' } },
+      contexts: {
+        'local-default': {
+          instance: 'local',
+          organization: 'admin',
+          project,
+        },
+      },
+    });
+    const configPath = `${workspace}/bootstrap.config.json`;
+    const fs = await import('node:fs');
+    fs.writeFileSync(
+      configPath,
+      JSON.stringify({
+        projectName: project,
+        endpoints: ['REST_API'],
+        tables: [],
+        rows: [],
+      }),
+      'utf-8',
+    );
+    const result = await runCli(
+      ['example', 'bootstrap', '--config', configPath, '--json'],
+      { cwd: workspace, env: buildEnv(), timeout: 120_000 },
+    );
+    expect(result.exitCode).toBe(0);
+  });
+});

package/e2e/matrix/M14-multi-instance-workspace.e2e-spec.ts

@@ -0,0 +1,182 @@
+/**
+ * Matrix M14 — Two standalone instances driven from a single workspace.
+ *
+ * Prep:
+ *  1. Spawn `primary` and `secondary` standalone instances, both `--auth`.
+ *  2. Login + mint API key on each; per-suite credential-store service so
+ *     saved creds for `primary` and `secondary` are isolated from the host
+ *     keyring.
+ *  3. Workspace tempdir holds two instances + two contexts (one per).
+ */
+
+import { runCli } from '../utils/cli-runner';
+import {
+  CLEAR_REVISIUM_ENV,
+  createWorkspace,
+  removeWorkspace,
+  uniqueCredentialStoreService,
+  writeWorkspaceConfig,
+} from '../utils/matrix-workspace';
+import {
+  startStandalone,
+  StandaloneInstance,
+} from '../utils/standalone-runner';
+
+describe('M14 — multi-instance workspace', () => {
+  let primary: StandaloneInstance;
+  let secondary: StandaloneInstance;
+  let primaryKey: string;
+  let secondaryKey: string;
+  const credentialStoreService = uniqueCredentialStoreService();
+  const workspaces: string[] = [];
+
+  beforeAll(async () => {
+    primary = await startStandalone({
+      auth: true,
+      adminPassword: 'test-admin-primary',
+    });
+    secondary = await startStandalone({
+      auth: true,
+      adminPassword: 'test-admin-secondary',
+    });
+
+    await primary.api.login('admin', 'test-admin-primary');
+    await secondary.api.login('admin', 'test-admin-secondary');
+    primaryKey = (
+      await primary.api.mintApiKey('admin', { name: 'matrix-primary' })
+    ).apiKey;
+    secondaryKey = (
+      await secondary.api.mintApiKey('admin', { name: 'matrix-secondary' })
+    ).apiKey;
+  }, 360_000);
+
+  afterAll(async () => {
+    for (const workspace of workspaces) removeWorkspace(workspace);
+    workspaces.length = 0;
+    await Promise.all([
+      primary ? primary.stop() : Promise.resolve(),
+      secondary ? secondary.stop() : Promise.resolve(),
+    ]);
+  });
+
+  function setup(): { workspace: string; env: Record<string, string> } {
+    const workspace = createWorkspace('revisium-cli-matrix-multi-');
+    workspaces.push(workspace);
+    writeWorkspaceConfig(workspace, {
+      instances: {
+        primary: { baseUrl: primary.baseUrl, authMode: 'stored' },
+        secondary: { baseUrl: secondary.baseUrl, authMode: 'stored' },
+      },
+      contexts: {
+        'primary-default': {
+          instance: 'primary',
+          organization: 'admin',
+          project: 'p',
+        },
+        'secondary-default': {
+          instance: 'secondary',
+          organization: 'admin',
+          project: 's',
+        },
+      },
+    });
+    const env: Record<string, string> = {
+      ...CLEAR_REVISIUM_ENV,
+      REVISIUM_CREDENTIAL_STORE_SERVICE: credentialStoreService,
+    };
+    return { workspace, env };
+  }
+
+  it('saves independent credentials per instance', async () => {
+    const { workspace, env } = setup();
+    const loginPrimary = await runCli(
+      ['auth', 'login', '--instance', 'primary', '--api-key-stdin'],
+      { cwd: workspace, env, stdin: primaryKey + '\n' },
+    );
+    expect(loginPrimary.exitCode).toBe(0);
+    const loginSecondary = await runCli(
+      ['auth', 'login', '--instance', 'secondary', '--api-key-stdin'],
+      { cwd: workspace, env, stdin: secondaryKey + '\n' },
+    );
+    expect(loginSecondary.exitCode).toBe(0);
+
+    const primaryStatus = await runCli(
+      ['auth', 'status', '--instance', 'primary'],
+      { cwd: workspace, env },
+    );
+    expect(primaryStatus.exitCode).toBe(0);
+    expect(primaryStatus.stdout).toContain('Saved credential found');
+
+    const secondaryStatus = await runCli(
+      ['auth', 'status', '--instance', 'secondary'],
+      { cwd: workspace, env },
+    );
+    expect(secondaryStatus.exitCode).toBe(0);
+    expect(secondaryStatus.stdout).toContain('Saved credential found');
+
+    // Independence: each instance points at its own baseUrl, so the two
+    // status outputs should differ on the host portion. Removing one
+    // credential must not affect the other.
+    expect(primaryStatus.stdout).not.toEqual(secondaryStatus.stdout);
+
+    const logoutPrimary = await runCli(
+      ['auth', 'logout', '--instance', 'primary'],
+      { cwd: workspace, env },
+    );
+    expect(logoutPrimary.exitCode).toBe(0);
+
+    const primaryAfter = await runCli(
+      ['auth', 'status', '--instance', 'primary'],
+      { cwd: workspace, env },
+    );
+    expect(primaryAfter.stdout).toContain('No saved credential found');
+
+    const secondaryAfter = await runCli(
+      ['auth', 'status', '--instance', 'secondary'],
+      { cwd: workspace, env },
+    );
+    expect(secondaryAfter.stdout).toContain('Saved credential found');
+  });
+
+  it('context switching flips the target between instances', async () => {
+    const { workspace, env } = setup();
+    await runCli(
+      ['auth', 'login', '--instance', 'primary', '--api-key-stdin'],
+      {
+        cwd: workspace,
+        env,
+        stdin: primaryKey + '\n',
+      },
+    );
+    await runCli(
+      ['auth', 'login', '--instance', 'secondary', '--api-key-stdin'],
+      {
+        cwd: workspace,
+        env,
+        stdin: secondaryKey + '\n',
+      },
+    );
+
+    await runCli(['context', 'use', 'primary-default'], {
+      cwd: workspace,
+      env,
+    });
+    const primaryEnsure = await runCli(['project', 'ensure', '--json'], {
+      cwd: workspace,
+      env,
+    });
+    expect(primaryEnsure.exitCode).toBe(0);
+    expect(await primary.api.projectExists('admin', 'p')).toBe(true);
+
+    await runCli(['context', 'use', 'secondary-default'], {
+      cwd: workspace,
+      env,
+    });
+    const secondaryEnsure = await runCli(['project', 'ensure', '--json'], {
+      cwd: workspace,
+      env,
+    });
+    expect(secondaryEnsure.exitCode).toBe(0);
+    expect(await secondary.api.projectExists('admin', 's')).toBe(true);
+  });
+});