@travetto/cli 6.0.1 → 7.0.0-rc.0

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,154 +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`
- * @schemaMethods `main`
- */
-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();