@travetto/cli 6.0.0 → 7.0.0-rc.0

package/src/types.ts

@@ -6,18 +6,6 @@ type ParsedArg = { type: 'arg', input: string, array?: boolean, index: number };
 type ParsedUnknown = { type: 'unknown', input: string };
 type ParsedInput = ParsedUnknown | ParsedFlag | ParsedArg;
 
-/**
- * Command configuration
- */
-export type CliCommandConfig = {
-  name: string;
-  commandModule: string;
-  runTarget?: boolean;
-  cls: Class<CliCommandShape>;
-  hidden?: boolean;
-  preMain?: (cmd: CliCommandShape) => void | Promise<void>;
-};
-
 export type ParsedState = {
   inputs: string[];
   all: ParsedInput[];
@@ -45,7 +33,6 @@ export interface CliValidationError {
  * @concrete
  */
 export interface CliCommandShape<T extends unknown[] = unknown[]> {
-
   /**
    * Parsed state
    */
@@ -110,31 +97,12 @@ export type CliCommandShapeFields = {
   module?: string;
 };
 
-/**
- * CLI Command argument/flag shape
- */
-export type CliCommandInput<K extends string = string> = {
-  name: string;
-  description?: string;
-  type: 'string' | 'file' | 'number' | 'boolean' | 'date' | 'regex' | 'module';
-  fileExtensions?: string[];
-  choices?: unknown[];
-  required?: boolean;
-  array?: boolean;
-  default?: unknown;
-  flagNames?: K[];
-  envVars?: string[];
-};
-
 /**
  * CLI Command schema shape
  */
-export interface CliCommandSchema<K extends string = string> {
+export interface CliCommandConfig {
+  cls: Class<CliCommandShape>;
   name: string;
-  title: string;
-  commandModule: string;
   runTarget?: boolean;
-  description?: string;
-  args: CliCommandInput[];
-  flags: CliCommandInput<K>[];
-}
+  preMain?: (cmd: CliCommandShape) => void | Promise<void>;
+}

package/src/util.ts

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 
-import { Env, ExecUtil, Runtime } from '@travetto/runtime';
+import { describeFunction, Env, ExecUtil, Runtime } from '@travetto/runtime';
 
 import { CliCommandShape, CliCommandShapeFields } from './types.ts';
 
@@ -61,8 +61,10 @@ export class CliUtil {
     const req = {
       type: `@travetto/cli:${action}`,
       data: {
-        name: cmd._cfg!.name, env,
-        commandModule: cmd._cfg!.commandModule,
+        name: cmd._cfg!.name,
+        env,
+        // TODO: Is this needed?
+        commandModule: describeFunction(cmd.constructor).module,
         module: Runtime.main.name,
         args: process.argv.slice(3),
       }

package/support/cli.cli_schema.ts

@@ -1,30 +1,32 @@
 import { Env } from '@travetto/runtime';
+import { IsPrivate } from '@travetto/schema';
 
-import { CliCommand } from '../src/decorators.ts';
-import { CliCommandSchema, CliCommandShape, CliValidationError } from '../src/types.ts';
-import { CliCommandRegistry } from '../src/registry.ts';
-import { CliCommandSchemaUtil } from '../src/schema.ts';
+import { CliCommand } from '../src/registry/decorator.ts';
+import { CliCommandShape, CliValidationError } from '../src/types.ts';
+import { CliCommandRegistryIndex } from '../src/registry/registry-index.ts';
 import { CliUtil } from '../src/util.ts';
+import { CliSchemaExportUtil } from '../src/schema-export.ts';
+
 
 /**
  * Generates the schema for all CLI operations
  */
-@CliCommand({ hidden: true })
+@CliCommand()
+@IsPrivate()
 export class CliSchemaCommand implements CliCommandShape {
 
-  async #getSchema(name: string): Promise<CliCommandSchema> {
-    const inst = await CliCommandRegistry.getInstance(name);
-    return CliCommandSchemaUtil.getSchema(inst!);
-  }
+  async validate(names?: string[]): Promise<CliValidationError | undefined> {
+    if (!names || names.length === 0) {
+      return;
+    }
+    const resolved = await CliCommandRegistryIndex.load(names);
+    const invalid = names.find(x => !resolved.find(r => r.command === x));
 
-  async validate(names: string[]): Promise<CliValidationError | undefined> {
-    for (const name of names ?? []) {
-      if (name && !CliCommandRegistry.getCommandMapping().has(name)) {
-        return {
-          source: 'arg',
-          message: `name: ${name} is not a valid cli command`
-        };
-      }
+    if (invalid) {
+      return {
+        source: 'arg',
+        message: `name: ${invalid} is not a valid cli command`
+      };
     }
   }
 
@@ -33,10 +35,11 @@ export class CliSchemaCommand implements CliCommandShape {
   }
 
   async main(names?: string[]): Promise<void> {
-    if (!names?.length) {
-      names = [...CliCommandRegistry.getCommandMapping().keys()];
-    }
-    const resolved = await Promise.all(names.map(x => this.#getSchema(x)));
-    await CliUtil.writeAndEnsureComplete(resolved);
+    const resolved = await CliCommandRegistryIndex.load(names);
+
+    const output = resolved
+      .map(x => CliSchemaExportUtil.exportSchema(x.config.cls));
+
+    await CliUtil.writeAndEnsureComplete(output);
   }
 }

package/support/cli.main.ts

@@ -1,11 +1,12 @@
 import { Runtime } from '@travetto/runtime';
 import { CliCommandShape, CliCommand, CliValidationError, ParsedState } from '@travetto/cli';
-import { Ignore } from '@travetto/schema';
+import { Ignore, IsPrivate } from '@travetto/schema';
 
 /**
  * Allows for running of main entry points
  */
-@CliCommand({ hidden: true })
+@CliCommand()
+@IsPrivate()
 export class MainCommand implements CliCommandShape {
 
   @Ignore()

package/src/decorators.ts

@@ -1,153 +0,0 @@
-import { Class, ClassInstance, Env, Runtime, RuntimeIndex, describeFunction } from '@travetto/runtime';
-import { FieldConfig, SchemaRegistry } from '@travetto/schema';
-
-import { CliCommandShape, CliCommandShapeFields } from './types.ts';
-import { CliCommandRegistry } from './registry.ts';
-import { CliModuleUtil } from './module.ts';
-import { CliParseUtil } from './parse.ts';
-import { CliUtil } from './util.ts';
-
-type Cmd = CliCommandShape & { env?: string };
-
-type CliCommandConfigOptions = {
-  hidden?: boolean;
-  runTarget?: boolean;
-  runtimeModule?: 'current' | 'command';
-  with?: {
-    /** Application environment */
-    env?: boolean;
-    /** Module to run for */
-    module?: boolean;
-    /** Should debug invocation trigger via ipc */
-    debugIpc?: boolean;
-    /** Should the invocation automatically restart on exit */
-    canRestart?: boolean;
-  };
-};
-
-const FIELD_CONFIG: {
-  name: keyof Exclude<CliCommandConfigOptions['with'], undefined>;
-  field: Partial<FieldConfig>;
-  run: (cmd: Cmd) => (Promise<unknown> | unknown);
-}[] =
-  [
-    {
-      name: 'env',
-      run: cmd => Env.TRV_ENV.set(cmd.env || Runtime.env),
-      field: {
-        type: String,
-        aliases: ['e', CliParseUtil.toEnvField(Env.TRV_ENV.key)],
-        description: 'Application environment',
-        required: { active: false },
-      },
-    },
-    {
-      name: 'module',
-      run: (): void => { },
-      field: {
-        type: String,
-        aliases: ['m', CliParseUtil.toEnvField(Env.TRV_MODULE.key)],
-        description: 'Module to run for',
-        specifiers: ['module'],
-        required: { active: Runtime.monoRoot },
-      },
-    },
-    {
-      name: 'debugIpc',
-      run: cmd => CliUtil.debugIfIpc(cmd).then((v) => v && process.exit(0)),
-      field: {
-        type: Boolean,
-        aliases: ['di'],
-        description: 'Should debug invocation trigger via ipc',
-        default: true,
-        required: { active: false },
-      },
-    },
-    {
-      name: 'canRestart',
-      run: cmd => CliUtil.runWithRestart(cmd)?.then((v) => v && process.exit(0)),
-      field: {
-        type: Boolean,
-        aliases: ['cr'],
-        description: 'Should the invocation automatically restart on exit',
-        default: false,
-        required: { active: false },
-      },
-    }
-  ];
-
-/**
- * Decorator to register a CLI command
- * @augments `@travetto/schema:Schema`
- * @augments `@travetto/cli:CliCommand`
- */
-export function CliCommand(cfg: CliCommandConfigOptions = {}) {
-  return function <T extends CliCommandShape>(target: Class<T>): void {
-    if (!target.Ⲑid || describeFunction(target)?.abstract) {
-      return;
-    }
-
-    const VALID_FIELDS = FIELD_CONFIG.filter(f => !!cfg.with?.[f.name]);
-
-    const { commandModule } = CliCommandRegistry.registerClass(target, {
-      hidden: cfg.hidden,
-      runTarget: cfg.runTarget,
-      preMain: async (cmd: Cmd) => {
-        for (const field of VALID_FIELDS) {
-          await field.run(cmd);
-        }
-      }
-    });
-
-    const pendingCls = SchemaRegistry.getOrCreatePending(target);
-
-    for (const { name, field: { type, ...field } } of VALID_FIELDS) {
-      SchemaRegistry.registerPendingFieldConfig(target, name, type!, field);
-    }
-
-    const runtimeModule = cfg.runtimeModule ?? (cfg.with?.module ? 'current' : undefined);
-
-    if (runtimeModule) { // Validate module
-      (pendingCls.validators ??= []).push(async ({ module: mod }: Partial<CliCommandShapeFields>) => {
-        const runModule = (runtimeModule === 'command' ? commandModule : mod) || Runtime.main.name;
-
-        // If we need to run as a specific module
-        if (runModule !== Runtime.main.name) {
-          try {
-            RuntimeIndex.reinitForModule(runModule);
-          } catch {
-            return { source: 'flag', message: `${runModule} is an unknown module`, kind: 'custom', path: '.' };
-          }
-        }
-
-        if (!(await CliModuleUtil.moduleHasDependency(runModule, commandModule))) {
-          return { source: 'flag', message: `${runModule} does not have ${commandModule} as a dependency`, kind: 'custom', path: '.' };
-        }
-      });
-    }
-  };
-}
-
-/**
- * Decorator to register a CLI command flag
- */
-export function CliFlag(cfg: { name?: string, short?: string, desc?: string, fileExtensions?: string[], envVars?: string[] }) {
-  return function (target: ClassInstance, prop: string | symbol): void {
-    const aliases: string[] = [];
-    if (cfg.name) {
-      aliases.push(cfg.name.startsWith('-') ? cfg.name : `--${cfg.name}`);
-    }
-    if (cfg.short) {
-      aliases.push(cfg.short.startsWith('-') ? cfg.short : `-${cfg.short}`);
-    }
-    if (cfg.envVars) {
-      aliases.push(...cfg.envVars.map(CliParseUtil.toEnvField));
-    }
-    if (typeof prop === 'string') {
-      SchemaRegistry.registerPendingFieldFacet(target.constructor, prop, {
-        aliases, description: cfg.desc,
-        specifiers: cfg.fileExtensions?.length ? ['file', ...cfg.fileExtensions.map(x => `ext:${x.replace(/[*.]/g, '')}`)] : undefined
-      });
-    }
-  };
-}

package/src/registry.ts

@@ -1,96 +0,0 @@
-import { asConstructable, Class, classConstruct, describeFunction, Runtime, RuntimeIndex } from '@travetto/runtime';
-
-import { CliCommandConfig, CliCommandShape } from './types.ts';
-import { CliUnknownCommandError } from './error.ts';
-
-const CLI_FILE_REGEX = /\/cli[.](?<name>.{0,100}?)([.]tsx?)?$/;
-const getName = (s: string): string => (s.match(CLI_FILE_REGEX)?.groups?.name ?? s).replaceAll('_', ':');
-
-class $CliCommandRegistry {
-  #commands = new Map<Class, CliCommandConfig>();
-  #fileMapping: Map<string, string>;
-
-  getByClass(cls: Class): CliCommandConfig | undefined {
-    return this.#commands.get(cls);
-  }
-
-  getClass(cmd: CliCommandShape): Class<CliCommandShape> {
-    return asConstructable<CliCommandShape>(cmd).constructor;
-  }
-
-  /**
-   * Get list of all commands available
-   */
-  getCommandMapping(): Map<string, string> {
-    if (!this.#fileMapping) {
-      const all = new Map<string, string>();
-      for (const e of RuntimeIndex.find({
-        module: m => !Runtime.production || m.prod,
-        folder: f => f === 'support',
-        file: f => f.role === 'std' && CLI_FILE_REGEX.test(f.sourceFile)
-      })) {
-        all.set(getName(e.sourceFile), e.import);
-      }
-      this.#fileMapping = all;
-    }
-    return this.#fileMapping;
-  }
-
-  /**
-   * Registers a cli command
-   */
-  registerClass<T extends CliCommandShape>(cls: Class<T>, cfg: Partial<CliCommandConfig>): CliCommandConfig {
-    const meta = describeFunction(cls);
-    this.#commands.set(cls, {
-      cls,
-      name: getName(meta.import),
-      commandModule: meta.module,
-      ...cfg,
-    });
-    return this.#commands.get(cls)!;
-  }
-
-  /**
-   * Get config for a given instance
-   */
-  getConfig(cmd: CliCommandShape): CliCommandConfig {
-    return this.getByClass(this.getClass(cmd))!;
-  }
-
-  /**
-   * Get the name of a command from a given instance
-   */
-  getName(cmd: CliCommandShape, withModule = false): string | undefined {
-    const cfg = this.getConfig(cmd);
-    const prefix = withModule ? `${cfg.commandModule}:` : '';
-    return `${prefix}${cfg.name}`;
-  }
-
-  /**
-   * Import command into an instance
-   */
-  getInstance(name: string, failOnMissing: true): Promise<CliCommandShape>;
-  async getInstance(name: string): Promise<CliCommandShape | undefined>;
-  async getInstance(name: string, failOnMissing = false): Promise<CliCommandShape | undefined> {
-    const found = this.getCommandMapping().get(name);
-    if (found) {
-      const values = Object.values(await Runtime.importFrom<Record<string, Class>>(found));
-      for (const v of values) {
-        const cfg = this.getByClass(v);
-        if (cfg) {
-          const inst = classConstruct(cfg.cls);
-          if (!inst.isActive || inst.isActive()) {
-            inst._cfg = this.getConfig(inst);
-            return inst;
-          }
-        }
-      }
-      if (!failOnMissing) {
-        return undefined;
-      }
-    }
-    throw new CliUnknownCommandError(name);
-  }
-}
-
-export const CliCommandRegistry = new $CliCommandRegistry();

package/support/transformer.cli.ts

@@ -1,53 +0,0 @@
-import ts from 'typescript';
-
-import { TransformerState, DecoratorMeta, AfterClass } from '@travetto/transformer';
-import { SchemaTransformUtil } from '@travetto/schema/support/transformer/util.ts';
-
-/**
- * Converts classes with `@CliCommand` to `@Schema` and maps the main method
- */
-export class CliCommandTransformer {
-
-  /**
-   * On presence of `@CliCommand`
-   */
-  @AfterClass('CliCommand')
-  static registerMainMethod(state: TransformerState, node: ts.ClassDeclaration, dm?: DecoratorMeta): typeof node {
-    const dec = dm?.dec;
-
-    if (!dec || !ts.isCallExpression(dec.expression)) { // If not valid
-      return node;
-    }
-
-    // Find runnable method
-    const mainMethod = node.members
-      .find((x): x is ts.MethodDeclaration =>
-        ts.isMethodDeclaration(x) && x.name!.getText() === 'main'
-      );
-
-    if (!mainMethod) {
-      return node;
-    }
-
-    const members = node.members.map(x => ts.isMethodDeclaration(x) && x === mainMethod ?
-      state.factory.updateMethodDeclaration(
-        x,
-        x.modifiers,
-        x.asteriskToken,
-        x.name,
-        x.questionToken,
-        x.typeParameters,
-        x.parameters.map(y => SchemaTransformUtil.computeField(state, y)),
-        x.type,
-        x.body
-      ) : x);
-
-    return state.factory.updateClassDeclaration(node,
-      node.modifiers,
-      node.name,
-      node.typeParameters,
-      node.heritageClauses,
-      members
-    );
-  }
-}