revisium 2.3.0 → 2.5.0-alpha.0

package/src/commands/auth/auth-status.command.ts

@@ -0,0 +1,89 @@
+import { CommandRunner, Option, SubCommand } from 'nest-commander';
+import {
+  CredentialStoreService,
+  CredentialTargetService,
+} from 'src/services/credentials';
+import { LoggerService } from 'src/services/common';
+import { formatAuthLoginHint } from './auth-command.utils';
+
+interface Options {
+  url?: string;
+  instance?: string;
+  credential?: string;
+}
+
+@SubCommand({
+  name: 'status',
+  description: 'Show saved Revisium credential status',
+})
+export class AuthStatusCommand extends CommandRunner {
+  constructor(
+    private readonly credentialTargets: CredentialTargetService,
+    private readonly credentialStore: CredentialStoreService,
+    private readonly logger: LoggerService,
+  ) {
+    super();
+  }
+
+  async run(_inputs: string[], options: Options): Promise<void> {
+    const target =
+      await this.credentialTargets.resolveOrCurrentContext(options);
+    const ref = {
+      baseUrl: target.baseUrl,
+      credential: target.credential,
+    };
+
+    if (target.contextName) {
+      this.logger.info(`Context: ${target.contextName}`);
+    }
+    if (target.instanceName) {
+      this.logger.info(`Instance: ${target.instanceName}`);
+    }
+    this.logger.info(`Base URL: ${target.baseUrl}`);
+    this.logger.info(`Credential: ${target.credential}`);
+    this.logger.info(`Auth mode: ${target.authMode || 'stored'}`);
+
+    if ((target.authMode || 'stored') === 'none') {
+      this.logger.info('Saved credentials are bypassed for authMode "none".');
+      return;
+    }
+
+    const hasCredential = this.credentialStore.hasCredential(ref);
+
+    if (hasCredential) {
+      this.logger.success('Saved credential found');
+      this.logger.info(
+        'API key identity verification is limited until auth principal introspection is available.',
+      );
+      return;
+    }
+
+    this.logger.warn(
+      `No saved credential found. Run: revisium auth login ${formatAuthLoginHint(target)}`,
+    );
+  }
+
+  @Option({
+    flags: '--url <url>',
+    description: 'Revisium server or target URL',
+  })
+  parseUrl(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--instance <name>',
+    description: 'Instance name from workspace config',
+  })
+  parseInstance(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--credential <name>',
+    description: 'Credential name',
+  })
+  parseCredential(value: string) {
+    return value;
+  }
+}

package/src/commands/auth/auth.command.ts

@@ -0,0 +1,20 @@
+import { Command, CommandRunner } from 'nest-commander';
+import { AuthLoginCommand } from './auth-login.command';
+import { AuthLogoutCommand } from './auth-logout.command';
+import { AuthStatusCommand } from './auth-status.command';
+
+@Command({
+  name: 'auth',
+  description: 'Manage saved Revisium credentials',
+  subCommands: [AuthLoginCommand, AuthStatusCommand, AuthLogoutCommand],
+})
+export class AuthCommand extends CommandRunner {
+  constructor() {
+    super();
+  }
+
+  run(): Promise<void> {
+    this.command.help();
+    return Promise.resolve();
+  }
+}

package/src/commands/base-sync.command.ts

@@ -1,6 +1,5 @@
-import { Option } from 'nest-commander';
+import { CommandRunner, Option } from 'nest-commander';
 import { ConfigService } from '@nestjs/config';
-import { BaseCommand } from 'src/commands/base.command';
 import { SyncApiService, CommitRevisionService } from 'src/services/sync';
 import {
   RevisiumUrlComplete,
@@ -21,7 +20,7 @@ export interface DataSyncOptions extends BaseSyncOptions {
   batchSize?: number;
 }
 
-export abstract class BaseSyncCommand extends BaseCommand {
+export abstract class BaseSyncCommand extends CommandRunner {
   constructor(
     protected readonly configService: ConfigService,
     protected readonly urlBuilder: UrlBuilderService,

package/src/commands/base.command.ts

@@ -2,6 +2,7 @@ import { CommandRunner, Option } from 'nest-commander';
 
 export type BaseOptions = {
   url?: string;
+  context?: string;
 };
 
 export abstract class BaseCommand extends CommandRunner {
@@ -14,4 +15,14 @@ export abstract class BaseCommand extends CommandRunner {
   public parseUrl(value: string) {
     return value;
   }
+
+  @Option({
+    flags: '--context <name>',
+    description:
+      'Named workspace context from .revisium/revisium-cli.config.json (single-target commands)',
+    required: false,
+  })
+  public parseContext(value: string) {
+    return value;
+  }
 }

package/src/commands/context/context-create.command.ts

@@ -0,0 +1,173 @@
+import { CommandRunner, Option, SubCommand } from 'nest-commander';
+import { LoggerService } from 'src/services/common';
+import {
+  DEFAULT_BRANCH,
+  DEFAULT_REVISION,
+  WorkspaceConfigService,
+  WorkspaceConfig,
+  WorkspaceContextConfig,
+} from 'src/services/workspace';
+
+interface Options {
+  url?: string;
+  instance?: string;
+  credential?: string;
+  org?: string;
+  project?: string;
+  branch?: string;
+  revision?: string;
+}
+
+@SubCommand({
+  name: 'create',
+  arguments: '<name>',
+  description: 'Create or update a workspace Revisium context',
+})
+export class ContextCreateCommand 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: context name is required');
+    }
+
+    const loaded = await this.workspaceConfig.loadOrCreate();
+    const context = this.buildContext(loaded.config, options);
+    const existed = Boolean(loaded.config.contexts[name]);
+
+    loaded.config.contexts[name] = context;
+    if (!loaded.config.currentContext) {
+      loaded.config.currentContext = name;
+    }
+
+    await this.workspaceConfig.save(loaded.path, loaded.config);
+
+    this.logger.success(
+      `${existed ? 'Updated' : 'Created'} context "${name}" (${context.organization}/${context.project}/${context.branch || DEFAULT_BRANCH}:${context.revision || DEFAULT_REVISION})`,
+    );
+    this.logger.info(`Instance: ${context.instance}`);
+    this.logger.info(`Config: ${loaded.path}`);
+  }
+
+  private buildContext(
+    config: WorkspaceConfig,
+    options: Options,
+  ): WorkspaceContextConfig {
+    if (options.url) {
+      const parsed = this.workspaceConfig.parseContextUrl(options.url);
+      const instanceName =
+        options.instance ||
+        this.workspaceConfig.findInstanceNameByBaseUrl(config, parsed.baseUrl);
+
+      if (!instanceName || !config.instances[instanceName]) {
+        throw new Error(
+          `No instance found for ${parsed.baseUrl}. Run: revisium instance add <name> --url ${options.url}`,
+        );
+      }
+
+      return this.withCredential(
+        {
+          instance: instanceName,
+          organization: parsed.organization,
+          project: parsed.project,
+          branch: parsed.branch,
+          revision: parsed.revision,
+        },
+        options.credential,
+      );
+    }
+
+    if (!options.instance || !options.org || !options.project) {
+      throw new Error(
+        'Error: provide --url, or provide --instance, --org, and --project',
+      );
+    }
+
+    if (!config.instances[options.instance]) {
+      throw new Error(`Revisium instance "${options.instance}" was not found`);
+    }
+
+    return this.withCredential(
+      {
+        instance: options.instance,
+        organization: options.org,
+        project: options.project,
+        branch: options.branch || DEFAULT_BRANCH,
+        revision: options.revision || DEFAULT_REVISION,
+      },
+      options.credential,
+    );
+  }
+
+  private withCredential(
+    context: WorkspaceContextConfig,
+    credential: string | undefined,
+  ): WorkspaceContextConfig {
+    if (credential) {
+      return { ...context, credential };
+    }
+    return context;
+  }
+
+  @Option({
+    flags: '--url <url>',
+    description: 'Revisium target URL: revisium://host/org/project/branch',
+  })
+  parseUrl(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--instance <name>',
+    description: 'Instance name from workspace config',
+  })
+  parseInstance(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--credential <name>',
+    description: 'Named saved credential selector for stored auth',
+  })
+  parseCredential(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--org <organization>',
+    description: 'Organization id',
+  })
+  parseOrg(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--project <project>',
+    description: 'Project name',
+  })
+  parseProject(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--branch <branch>',
+    description: 'Branch name (default: master)',
+  })
+  parseBranch(value: string) {
+    return value;
+  }
+
+  @Option({
+    flags: '--revision <revision>',
+    description: 'Revision target (default: draft)',
+  })
+  parseRevision(value: string) {
+    return value;
+  }
+}

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

@@ -0,0 +1,36 @@
+import { CommandRunner, SubCommand } from 'nest-commander';
+import { LoggerService } from 'src/services/common';
+import {
+  DEFAULT_BRANCH,
+  DEFAULT_REVISION,
+  WorkspaceConfigService,
+} from 'src/services/workspace';
+
+@SubCommand({
+  name: 'list',
+  description: 'List workspace Revisium contexts',
+})
+export class ContextListCommand 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.contexts).length === 0) {
+      this.logger.info('No Revisium contexts configured in this workspace.');
+      return;
+    }
+
+    this.logger.info(`Config: ${loaded.path}`);
+    for (const [name, context] of Object.entries(loaded.config.contexts)) {
+      const marker = loaded.config.currentContext === name ? '*' : ' ';
+      this.logger.info(
+        `${marker} ${name}\t${context.instance}\t${context.organization}/${context.project}/${context.branch || DEFAULT_BRANCH}:${context.revision || DEFAULT_REVISION}`,
+      );
+    }
+  }
+}

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

@@ -0,0 +1,35 @@
+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 context',
+})
+export class ContextRemoveCommand 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: context name is required');
+    }
+
+    const { loaded } = await this.workspaceConfig.loadContext(name);
+
+    delete loaded.config.contexts[name];
+    if (loaded.config.currentContext === name) {
+      delete loaded.config.currentContext;
+    }
+
+    await this.workspaceConfig.save(loaded.path, loaded.config);
+
+    this.logger.success(`Removed context "${name}"`);
+  }
+}

package/src/commands/context/context-show.command.ts

@@ -0,0 +1,59 @@
+import { CommandRunner, SubCommand } from 'nest-commander';
+import { LoggerService } from 'src/services/common';
+import {
+  DEFAULT_BRANCH,
+  DEFAULT_CREDENTIAL,
+  DEFAULT_REVISION,
+  WorkspaceConfigService,
+} from 'src/services/workspace';
+
+@SubCommand({
+  name: 'show',
+  arguments: '[name]',
+  description: 'Show a workspace Revisium context',
+})
+export class ContextShowCommand extends CommandRunner {
+  constructor(
+    private readonly workspaceConfig: WorkspaceConfigService,
+    private readonly logger: LoggerService,
+  ) {
+    super();
+  }
+
+  async run(inputs: string[]): Promise<void> {
+    const loaded = await this.workspaceConfig.load();
+    if (!loaded) {
+      throw new Error('No Revisium workspace config found');
+    }
+
+    const name = inputs[0] || loaded.config.currentContext;
+    if (!name) {
+      throw new Error('No current Revisium context is configured');
+    }
+
+    const context = loaded.config.contexts[name];
+    if (!context) {
+      throw new Error(`Revisium context "${name}" was not found`);
+    }
+
+    const instance = loaded.config.instances[context.instance];
+
+    this.logger.info(`Name: ${name}`);
+    this.logger.info(`Instance: ${context.instance}`);
+    if (instance) {
+      this.logger.info(`Base URL: ${instance.baseUrl}`);
+      this.logger.info(`Auth mode: ${instance.authMode || 'stored'}`);
+    } else {
+      this.logger.warn(`Instance "${context.instance}" not found in config`);
+    }
+    this.logger.info(
+      `Target: ${context.organization}/${context.project}/${context.branch || DEFAULT_BRANCH}:${context.revision || DEFAULT_REVISION}`,
+    );
+    if ((instance?.authMode || 'stored') === 'stored') {
+      this.logger.info(
+        `Credential: ${context.credential || DEFAULT_CREDENTIAL}`,
+      );
+    }
+    this.logger.info(`Config: ${loaded.path}`);
+  }
+}

package/src/commands/context/context-use.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: 'use',
+  arguments: '<name>',
+  description: 'Set the current workspace Revisium context',
+})
+export class ContextUseCommand 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: context name is required');
+    }
+
+    const { loaded } = await this.workspaceConfig.loadContext(name);
+
+    loaded.config.currentContext = name;
+    await this.workspaceConfig.save(loaded.path, loaded.config);
+
+    this.logger.success(`Using context "${name}"`);
+  }
+}

package/src/commands/context/context.command.ts

@@ -0,0 +1,28 @@
+import { Command, CommandRunner } from 'nest-commander';
+import { ContextCreateCommand } from './context-create.command';
+import { ContextListCommand } from './context-list.command';
+import { ContextRemoveCommand } from './context-remove.command';
+import { ContextShowCommand } from './context-show.command';
+import { ContextUseCommand } from './context-use.command';
+
+@Command({
+  name: 'context',
+  description: 'Manage workspace Revisium contexts',
+  subCommands: [
+    ContextCreateCommand,
+    ContextListCommand,
+    ContextShowCommand,
+    ContextUseCommand,
+    ContextRemoveCommand,
+  ],
+})
+export class ContextCommand extends CommandRunner {
+  constructor() {
+    super();
+  }
+
+  run(): Promise<void> {
+    this.command.help();
+    return Promise.resolve();
+  }
+}

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

@@ -0,0 +1,129 @@
+import { EndpointEnsureCommand } from '../endpoint-ensure.command';
+import { BootstrapService } from 'src/services/bootstrap';
+import { LoggerService } from 'src/services/common';
+
+describe('EndpointEnsureCommand', () => {
+  let bootstrapService: {
+    ensureEndpoint: jest.Mock;
+    resolveTarget: jest.Mock;
+    formatEndpointHint: jest.Mock;
+    parseEndpointType: jest.Mock;
+  };
+  let logger: { info: jest.Mock; success: jest.Mock };
+  let command: EndpointEnsureCommand;
+  let logSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    bootstrapService = {
+      ensureEndpoint: jest.fn().mockResolvedValue({
+        endpoint: { id: 'rest-id', type: 'REST_API' },
+        status: 'created',
+        revision: 'draft',
+        dryRun: false,
+      }),
+      resolveTarget: jest.fn().mockResolvedValue({
+        baseUrl: 'http://localhost:9222',
+        organization: 'admin',
+        project: 'dictionary',
+        branch: 'master',
+        revision: 'draft',
+      }),
+      formatEndpointHint: jest
+        .fn()
+        .mockReturnValue('http://localhost:9222/endpoint/rest/admin/x/y/draft'),
+      parseEndpointType: jest.fn().mockReturnValue('REST_API'),
+    };
+    logger = { info: jest.fn(), success: jest.fn() };
+    command = new EndpointEnsureCommand(
+      bootstrapService as unknown as BootstrapService,
+      logger as unknown as LoggerService,
+    );
+    logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+  });
+
+  it('rejects when --type is missing', async () => {
+    await expect(command.run([], { type: undefined as never })).rejects.toThrow(
+      '--type option is required',
+    );
+  });
+
+  it('logs created endpoint info with hint', async () => {
+    await command.run([], { type: 'REST_API' });
+
+    expect(bootstrapService.ensureEndpoint).toHaveBeenCalledWith(
+      { type: 'REST_API' },
+      'REST_API',
+      undefined,
+    );
+    expect(logger.success).toHaveBeenCalledWith(
+      'Created endpoint rest-id (REST_API)',
+    );
+    expect(logger.info).toHaveBeenCalledWith('Revision: draft');
+    expect(logger.info).toHaveBeenCalledWith(
+      'Hint: http://localhost:9222/endpoint/rest/admin/x/y/draft',
+    );
+  });
+
+  it('shows "Found" when endpoint already exists', async () => {
+    bootstrapService.ensureEndpoint.mockResolvedValue({
+      endpoint: { id: 'rest-id', type: 'REST_API' },
+      status: 'skipped',
+      revision: 'draft',
+      dryRun: false,
+    });
+
+    await command.run([], { type: 'REST_API' });
+
+    expect(logger.success).toHaveBeenCalledWith(
+      'Found endpoint rest-id (REST_API)',
+    );
+  });
+
+  it('uses <dry-run> placeholder when no endpoint id is returned', async () => {
+    bootstrapService.ensureEndpoint.mockResolvedValue({
+      endpoint: { type: 'GRAPHQL' },
+      status: 'created',
+      revision: 'draft',
+      dryRun: true,
+    });
+
+    await command.run([], { type: 'GRAPHQL', dryRun: true });
+
+    expect(logger.success).toHaveBeenCalledWith(
+      'Created endpoint <dry-run> (GRAPHQL)',
+    );
+  });
+
+  it('emits JSON when --json is set', async () => {
+    await command.run([], { type: 'REST_API', json: true });
+
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    const firstCall = logSpy.mock.calls[0] as unknown[];
+    const payload = JSON.parse(firstCall[0] as string) as Record<
+      string,
+      unknown
+    >;
+    expect(payload).toEqual({
+      endpoint: { id: 'rest-id', type: 'REST_API' },
+      status: 'created',
+      revision: 'draft',
+      dryRun: false,
+      hint: 'http://localhost:9222/endpoint/rest/admin/x/y/draft',
+    });
+    expect(logger.success).not.toHaveBeenCalled();
+  });
+
+  it('delegates option parsing to BootstrapService.parseEndpointType', () => {
+    expect(command.parseType('REST_API')).toBe('REST_API');
+    expect(bootstrapService.parseEndpointType).toHaveBeenCalledWith('REST_API');
+  });
+
+  it('parses boolean flags', () => {
+    expect(command.parseDryRun('true')).toBe(true);
+    expect(command.parseJson()).toBe(true);
+  });
+});