revisium 2.3.0 → 2.5.0-alpha.0

package/src/commands/endpoint/__tests__/endpoint-list.command.spec.ts

@@ -0,0 +1,59 @@
+import { EndpointListCommand } from '../endpoint-list.command';
+import { BootstrapService } from 'src/services/bootstrap';
+import { LoggerService } from 'src/services/common';
+
+describe('EndpointListCommand', () => {
+  let bootstrapService: { listEndpoints: jest.Mock };
+  let logger: { info: jest.Mock };
+  let command: EndpointListCommand;
+  let logSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    bootstrapService = { listEndpoints: jest.fn() };
+    logger = { info: jest.fn() };
+    command = new EndpointListCommand(
+      bootstrapService as unknown as BootstrapService,
+      logger as unknown as LoggerService,
+    );
+    logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+  });
+
+  it('logs each endpoint id and type', async () => {
+    bootstrapService.listEndpoints.mockResolvedValue([
+      { id: 'rest', type: 'REST_API' },
+      { id: 'graphql', type: 'GRAPHQL' },
+    ]);
+
+    await command.run([], {});
+
+    expect(logger.info).toHaveBeenCalledWith('rest\tREST_API');
+    expect(logger.info).toHaveBeenCalledWith('graphql\tGRAPHQL');
+  });
+
+  it('reports when no endpoints exist', async () => {
+    bootstrapService.listEndpoints.mockResolvedValue([]);
+
+    await command.run([], {});
+
+    expect(logger.info).toHaveBeenCalledWith('No generated endpoints found');
+  });
+
+  it('emits JSON when --json is set', async () => {
+    const endpoints = [{ id: 'rest', type: 'REST_API' }];
+    bootstrapService.listEndpoints.mockResolvedValue(endpoints);
+
+    await command.run([], { json: true });
+
+    expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ endpoints }, null, 2));
+    expect(logger.info).not.toHaveBeenCalled();
+  });
+
+  it('parses --json flag', () => {
+    expect(command.parseJson('true')).toBe(true);
+    expect(command.parseJson()).toBe(true);
+  });
+});

package/src/commands/endpoint/__tests__/endpoint.command.spec.ts

@@ -0,0 +1,14 @@
+import { EndpointCommand } from '../endpoint.command';
+
+describe('EndpointCommand', () => {
+  it('shows help when no endpoint subcommand is provided', async () => {
+    const command = new EndpointCommand();
+    const help = jest.fn();
+
+    Object.assign(command, { command: { help } });
+
+    await command.run();
+
+    expect(help).toHaveBeenCalled();
+  });
+});

package/src/commands/endpoint/endpoint-ensure.command.ts

@@ -0,0 +1,74 @@
+import { Option, SubCommand } from 'nest-commander';
+import { BaseCommand, BaseOptions } from 'src/commands/base.command';
+import { BootstrapService, EndpointType } from 'src/services/bootstrap';
+import { LoggerService } from 'src/services/common';
+import { parseBooleanOption } from 'src/utils/parse-boolean.utils';
+
+type Options = BaseOptions & {
+  type: EndpointType;
+  dryRun?: boolean;
+  json?: boolean;
+};
+
+@SubCommand({
+  name: 'ensure',
+  description: 'Ensure a generated endpoint exists on the selected revision',
+})
+export class EndpointEnsureCommand extends BaseCommand {
+  constructor(
+    private readonly bootstrapService: BootstrapService,
+    private readonly logger: LoggerService,
+  ) {
+    super();
+  }
+
+  async run(_inputs: string[], options: Options): Promise<void> {
+    if (!options.type) {
+      throw new Error('Error: --type option is required');
+    }
+
+    const result = await this.bootstrapService.ensureEndpoint(
+      options,
+      options.type,
+      options.dryRun,
+    );
+    const target = await this.bootstrapService.resolveTarget(options);
+    const endpointId = result.endpoint.id || '<dry-run>';
+    const action = result.status === 'created' ? 'Created' : 'Found';
+    const hint = this.bootstrapService.formatEndpointHint(target, options.type);
+
+    if (options.json) {
+      console.log(JSON.stringify({ ...result, hint }, null, 2));
+      return;
+    }
+
+    this.logger.success(`${action} endpoint ${endpointId} (${options.type})`);
+    this.logger.info(`Revision: ${result.revision}`);
+    this.logger.info(`Hint: ${hint}`);
+  }
+
+  @Option({
+    flags: '--type <type>',
+    description: 'Endpoint type: REST_API or GRAPHQL',
+    required: true,
+  })
+  parseType(value: string): EndpointType {
+    return this.bootstrapService.parseEndpointType(value);
+  }
+
+  @Option({
+    flags: '--dry-run [boolean]',
+    description: 'Plan changes without writing',
+  })
+  parseDryRun(value?: string): boolean {
+    return parseBooleanOption(value);
+  }
+
+  @Option({
+    flags: '--json [boolean]',
+    description: 'Print machine-readable JSON',
+  })
+  parseJson(value?: string): boolean {
+    return parseBooleanOption(value);
+  }
+}

package/src/commands/endpoint/endpoint-list.command.ts

@@ -0,0 +1,48 @@
+import { Option, SubCommand } from 'nest-commander';
+import { BaseCommand, BaseOptions } from 'src/commands/base.command';
+import { BootstrapService } from 'src/services/bootstrap';
+import { LoggerService } from 'src/services/common';
+import { parseBooleanOption } from 'src/utils/parse-boolean.utils';
+
+type Options = BaseOptions & {
+  json?: boolean;
+};
+
+@SubCommand({
+  name: 'list',
+  description: 'List generated endpoints on the selected revision',
+})
+export class EndpointListCommand extends BaseCommand {
+  constructor(
+    private readonly bootstrapService: BootstrapService,
+    private readonly logger: LoggerService,
+  ) {
+    super();
+  }
+
+  async run(_inputs: string[], options: Options): Promise<void> {
+    const endpoints = await this.bootstrapService.listEndpoints(options);
+
+    if (options.json) {
+      console.log(JSON.stringify({ endpoints }, null, 2));
+      return;
+    }
+
+    if (endpoints.length === 0) {
+      this.logger.info('No generated endpoints found');
+      return;
+    }
+
+    for (const endpoint of endpoints) {
+      this.logger.info(`${endpoint.id}\t${endpoint.type}`);
+    }
+  }
+
+  @Option({
+    flags: '--json [boolean]',
+    description: 'Print machine-readable JSON',
+  })
+  parseJson(value?: string): boolean {
+    return parseBooleanOption(value);
+  }
+}

package/src/commands/endpoint/endpoint.command.ts

@@ -0,0 +1,19 @@
+import { Command, CommandRunner } from 'nest-commander';
+import { EndpointEnsureCommand } from './endpoint-ensure.command';
+import { EndpointListCommand } from './endpoint-list.command';
+
+@Command({
+  name: 'endpoint',
+  description: 'Manage generated Revisium endpoints',
+  subCommands: [EndpointEnsureCommand, EndpointListCommand],
+})
+export class EndpointCommand extends CommandRunner {
+  constructor() {
+    super();
+  }
+
+  run(): Promise<void> {
+    this.command.help();
+    return Promise.resolve();
+  }
+}

package/src/commands/example/__tests__/example-bootstrap.command.spec.ts

@@ -0,0 +1,145 @@
+import { ExampleBootstrapCommand } from '../example-bootstrap.command';
+import {
+  BootstrapService,
+  ExampleBootstrapSummary,
+} from 'src/services/bootstrap';
+import { LoggerService } from 'src/services/common';
+
+describe('ExampleBootstrapCommand', () => {
+  let bootstrapService: {
+    bootstrapExample: jest.Mock;
+    parseEndpointType: jest.Mock;
+  };
+  let logger: { info: jest.Mock; success: jest.Mock; summary: jest.Mock };
+  let command: ExampleBootstrapCommand;
+  let logSpy: jest.SpyInstance;
+  let summary: ExampleBootstrapSummary;
+
+  beforeEach(() => {
+    summary = {
+      dryRun: false,
+      target: {
+        organization: 'admin',
+        project: 'dictionary',
+        branch: 'master',
+        revision: 'draft',
+      },
+      project: {
+        organization: 'admin',
+        project: 'dictionary',
+        branch: 'master',
+        projectStatus: 'created',
+        branchStatus: 'created',
+        dryRun: false,
+      },
+      tables: { created: ['Faq'], skipped: [], conflicts: [] },
+      rows: { created: [], skipped: ['x/y'], conflicts: [] },
+      endpoints: { created: ['REST_API'], skipped: [], conflicts: [] },
+      commit: { status: 'created', revisionId: 'rev-1' },
+    };
+    bootstrapService = {
+      bootstrapExample: jest.fn().mockResolvedValue(summary),
+      parseEndpointType: jest.fn((value: string) => value),
+    };
+    logger = {
+      info: jest.fn(),
+      success: jest.fn(),
+      summary: jest.fn(),
+    };
+    command = new ExampleBootstrapCommand(
+      bootstrapService as unknown as BootstrapService,
+      logger as unknown as LoggerService,
+    );
+    logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+  });
+
+  it('rejects when --config is missing', async () => {
+    await expect(
+      command.run([], { config: undefined as never }),
+    ).rejects.toThrow('--config option is required');
+  });
+
+  it('forwards options to BootstrapService.bootstrapExample', async () => {
+    await command.run([], {
+      config: './bootstrap.json',
+      url: 'revisium://local',
+      context: 'ctx',
+      commit: true,
+      dryRun: false,
+      endpoint: ['REST_API'],
+    });
+
+    expect(bootstrapService.bootstrapExample).toHaveBeenCalledWith({
+      url: 'revisium://local',
+      context: 'ctx',
+      configPath: './bootstrap.json',
+      commit: true,
+      dryRun: false,
+      endpointOverrides: ['REST_API'],
+    });
+  });
+
+  it('prints a human-readable summary by default', async () => {
+    await command.run([], { config: './bootstrap.json' });
+
+    expect(logger.summary).toHaveBeenCalledWith(
+      'Bootstrap admin/dictionary/master:draft',
+    );
+    expect(logger.info).toHaveBeenCalledWith(
+      'Project: created, branch: created',
+    );
+    expect(logger.info).toHaveBeenCalledWith(
+      'Tables: created 1, skipped 0, conflicts 0',
+    );
+    expect(logger.info).toHaveBeenCalledWith(
+      'Rows: created 0, skipped 1, conflicts 0',
+    );
+    expect(logger.info).toHaveBeenCalledWith(
+      'Endpoints: created 1, skipped 0, conflicts 0',
+    );
+    expect(logger.info).toHaveBeenCalledWith('Commit: created');
+    expect(logger.info).toHaveBeenCalledWith('Revision: rev-1');
+  });
+
+  it('prefixes the summary with "Dry run: " when dry-run', async () => {
+    summary.dryRun = true;
+    summary.commit = { status: 'dry-run', message: 'm' };
+    delete (summary.commit as { revisionId?: string }).revisionId;
+
+    await command.run([], { config: './bootstrap.json' });
+
+    expect(logger.summary).toHaveBeenCalledWith(
+      'Dry run: Bootstrap admin/dictionary/master:draft',
+    );
+    expect(logger.info).not.toHaveBeenCalledWith(
+      expect.stringContaining('Revision:'),
+    );
+  });
+
+  it('emits JSON when --json is set', async () => {
+    await command.run([], { config: './bootstrap.json', json: true });
+
+    expect(logSpy).toHaveBeenCalledWith(JSON.stringify(summary, null, 2));
+    expect(logger.summary).not.toHaveBeenCalled();
+  });
+
+  it('parses --endpoint repeatedly via BootstrapService.parseEndpointType', () => {
+    const first = command.parseEndpoint('REST_API');
+    expect(first).toEqual(['REST_API']);
+    const second = command.parseEndpoint('GRAPHQL', first);
+    expect(second).toEqual(['REST_API', 'GRAPHQL']);
+    expect(bootstrapService.parseEndpointType).toHaveBeenCalledTimes(2);
+  });
+
+  it('parses boolean and string flags', () => {
+    expect(command.parseConfig('./bootstrap.json')).toBe('./bootstrap.json');
+    expect(command.parseCommit('true')).toBe(true);
+    expect(command.parseCommit()).toBe(true);
+    expect(command.parseDryRun()).toBe(true);
+    expect(command.parseJson()).toBe(true);
+  });
+});

package/src/commands/example/__tests__/example.command.spec.ts

@@ -0,0 +1,14 @@
+import { ExampleCommand } from '../example.command';
+
+describe('ExampleCommand', () => {
+  it('shows help when no example subcommand is provided', async () => {
+    const command = new ExampleCommand();
+    const help = jest.fn();
+
+    Object.assign(command, { command: { help } });
+
+    await command.run();
+
+    expect(help).toHaveBeenCalled();
+  });
+});

package/src/commands/example/example-bootstrap.command.ts

@@ -0,0 +1,122 @@
+import { Option, SubCommand } from 'nest-commander';
+import { BaseCommand, BaseOptions } from 'src/commands/base.command';
+import {
+  BootstrapResourceSummary,
+  BootstrapService,
+  EndpointType,
+  ExampleBootstrapSummary,
+} from 'src/services/bootstrap';
+import { LoggerService } from 'src/services/common';
+import { parseBooleanOption } from 'src/utils/parse-boolean.utils';
+
+type Options = BaseOptions & {
+  config: string;
+  commit?: boolean;
+  dryRun?: boolean;
+  json?: boolean;
+  endpoint?: EndpointType[];
+};
+
+@SubCommand({
+  name: 'bootstrap',
+  description: 'Bootstrap an example project from a config file',
+})
+export class ExampleBootstrapCommand extends BaseCommand {
+  constructor(
+    private readonly bootstrapService: BootstrapService,
+    private readonly logger: LoggerService,
+  ) {
+    super();
+  }
+
+  async run(_inputs: string[], options: Options): Promise<void> {
+    if (!options.config) {
+      throw new Error('Error: --config option is required');
+    }
+
+    const summary = await this.bootstrapService.bootstrapExample({
+      url: options.url,
+      context: options.context,
+      configPath: options.config,
+      commit: options.commit,
+      dryRun: options.dryRun,
+      endpointOverrides: options.endpoint,
+    });
+
+    if (options.json) {
+      console.log(JSON.stringify(summary, null, 2));
+      return;
+    }
+
+    this.printSummary(summary);
+  }
+
+  private printSummary(summary: ExampleBootstrapSummary): void {
+    const mode = summary.dryRun ? 'Dry run: ' : '';
+    this.logger.summary(
+      `${mode}Bootstrap ${summary.target.organization}/${summary.target.project}/${summary.target.branch}:${summary.target.revision}`,
+    );
+    this.logger.info(
+      `Project: ${summary.project.projectStatus}, branch: ${summary.project.branchStatus}`,
+    );
+    this.logger.info(this.formatSummary('Tables', summary.tables));
+    this.logger.info(this.formatSummary('Rows', summary.rows));
+    this.logger.info(this.formatSummary('Endpoints', summary.endpoints));
+    this.logger.info(`Commit: ${summary.commit.status}`);
+    if (summary.commit.revisionId) {
+      this.logger.info(`Revision: ${summary.commit.revisionId}`);
+    }
+  }
+
+  private formatSummary<T extends string>(
+    label: string,
+    summary: BootstrapResourceSummary<T>,
+  ): string {
+    return `${label}: created ${summary.created.length}, skipped ${summary.skipped.length}, conflicts ${summary.conflicts.length}`;
+  }
+
+  @Option({
+    flags: '--config <path>',
+    description: 'Bootstrap config JSON file',
+    required: true,
+  })
+  parseConfig(value: string): string {
+    return value;
+  }
+
+  @Option({
+    flags: '-c, --commit [boolean]',
+    description: 'Create a revision after bootstrap changes',
+  })
+  parseCommit(value?: string): boolean {
+    return parseBooleanOption(value);
+  }
+
+  @Option({
+    flags: '--dry-run [boolean]',
+    description: 'Plan changes without writing',
+  })
+  parseDryRun(value?: string): boolean {
+    return parseBooleanOption(value);
+  }
+
+  @Option({
+    flags: '--json [boolean]',
+    description: 'Print machine-readable JSON',
+  })
+  parseJson(value?: string): boolean {
+    return parseBooleanOption(value);
+  }
+
+  @Option({
+    flags: '--endpoint <type>',
+    description:
+      'Endpoint type override. Repeat for multiple values. Replaces config endpoints when provided.',
+  })
+  parseEndpoint(value: string, previous?: EndpointType[]): EndpointType[] {
+    return [
+      ...(previous || []),
+      this.bootstrapService.parseEndpointType(value),
+    ];
+  }
+}

package/src/commands/example/example.command.ts

@@ -0,0 +1,18 @@
+import { Command, CommandRunner } from 'nest-commander';
+import { ExampleBootstrapCommand } from './example-bootstrap.command';
+
+@Command({
+  name: 'example',
+  description: 'Bootstrap Revisium example projects',
+  subCommands: [ExampleBootstrapCommand],
+})
+export class ExampleCommand extends CommandRunner {
+  constructor() {
+    super();
+  }
+
+  run(): Promise<void> {
+    this.command.help();
+    return Promise.resolve();
+  }
+}

package/src/commands/instance/instance-add.command.ts

@@ -0,0 +1,72 @@
+import { CommandRunner, Option, SubCommand } from 'nest-commander';
+import { LoggerService } from 'src/services/common';
+import {
+  WorkspaceAuthMode,
+  WorkspaceConfigService,
+} from 'src/services/workspace';
+
+interface Options {
+  url?: string;
+  auth?: WorkspaceAuthMode;
+}
+
+@SubCommand({
+  name: 'add',
+  arguments: '<name>',
+  description: 'Add or update a workspace Revisium instance',
+})
+export class InstanceAddCommand extends CommandRunner {
+  constructor(
+    private readonly workspaceConfig: WorkspaceConfigService,
+    private readonly logger: LoggerService,
+  ) {
+    super();
+  }
+
+  async run(inputs: string[], options: Options): Promise<void> {
+    const name = inputs[0];
+    if (!name) {
+      throw new Error('Error: instance name is required');
+    }
+    if (!options.url) {
+      throw new Error('Error: --url option is required');
+    }
+
+    const loaded = await this.workspaceConfig.loadOrCreate();
+    const baseUrl = this.workspaceConfig.normalizeBaseUrl(options.url);
+    const authMode = options.auth || 'stored';
+    const existed = Boolean(loaded.config.instances[name]);
+
+    loaded.config.instances[name] = {
+      baseUrl,
+      authMode,
+    };
+
+    await this.workspaceConfig.save(loaded.path, loaded.config);
+
+    this.logger.success(
+      `${existed ? 'Updated' : 'Added'} instance "${name}" (${baseUrl}, auth: ${authMode})`,
+    );
+    this.logger.info(`Config: ${loaded.path}`);
+  }
+
+  @Option({
+    flags: '--url <url>',
+    description: 'Revisium server URL, for example revisium://localhost:9222',
+    required: true,
+  })
+  parseUrl(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--auth <mode>',
+    description: 'Authentication mode: stored or none',
+  })
+  parseAuth(value: string): WorkspaceAuthMode {
+    if (value !== 'stored' && value !== 'none') {
+      throw new Error('Auth mode must be "stored" or "none"');
+    }
+    return value;
+  }
+}

package/src/commands/instance/instance-list.command.ts

@@ -0,0 +1,31 @@
+import { CommandRunner, SubCommand } from 'nest-commander';
+import { LoggerService } from 'src/services/common';
+import { WorkspaceConfigService } from 'src/services/workspace';
+
+@SubCommand({
+  name: 'list',
+  description: 'List workspace Revisium instances',
+})
+export class InstanceListCommand extends CommandRunner {
+  constructor(
+    private readonly workspaceConfig: WorkspaceConfigService,
+    private readonly logger: LoggerService,
+  ) {
+    super();
+  }
+
+  async run(): Promise<void> {
+    const loaded = await this.workspaceConfig.load();
+    if (!loaded || Object.keys(loaded.config.instances).length === 0) {
+      this.logger.info('No Revisium instances configured in this workspace.');
+      return;
+    }
+
+    this.logger.info(`Config: ${loaded.path}`);
+    for (const [name, instance] of Object.entries(loaded.config.instances)) {
+      this.logger.info(
+        `${name}\t${instance.baseUrl}\tauth:${instance.authMode || 'stored'}`,
+      );
+    }
+  }
+}

package/src/commands/instance/instance-remove.command.ts

@@ -0,0 +1,44 @@
+import { CommandRunner, SubCommand } from 'nest-commander';
+import { LoggerService } from 'src/services/common';
+import { WorkspaceConfigService } from 'src/services/workspace';
+
+@SubCommand({
+  name: 'remove',
+  arguments: '<name>',
+  description: 'Remove a workspace Revisium instance',
+})
+export class InstanceRemoveCommand extends CommandRunner {
+  constructor(
+    private readonly workspaceConfig: WorkspaceConfigService,
+    private readonly logger: LoggerService,
+  ) {
+    super();
+  }
+
+  async run(inputs: string[]): Promise<void> {
+    const name = inputs[0];
+    if (!name) {
+      throw new Error('Error: instance name is required');
+    }
+
+    const loaded = await this.workspaceConfig.load();
+    if (!loaded || !Object.hasOwn(loaded.config.instances, name)) {
+      throw new Error(`Revisium instance "${name}" was not found`);
+    }
+
+    const usedByContexts = Object.entries(loaded.config.contexts)
+      .filter(([, context]) => context.instance === name)
+      .map(([contextName]) => contextName);
+
+    if (usedByContexts.length > 0) {
+      throw new Error(
+        `Cannot remove instance "${name}" because it is used by contexts: ${usedByContexts.join(', ')}`,
+      );
+    }
+
+    delete loaded.config.instances[name];
+    await this.workspaceConfig.save(loaded.path, loaded.config);
+
+    this.logger.success(`Removed instance "${name}"`);
+  }
+}