@akanjs/devkit 1.0.20 → 2.1.0-rc.1

package/commandDecorators/command.ts

@@ -0,0 +1,351 @@
+import { confirm, input, select } from "@inquirer/prompts";
+import path from "node:path";
+import { Logger } from "akanjs/common";
+import chalk from "chalk";
+import { type Command, program } from "commander";
+
+import { FileSys, getDirname, type PackageJson } from "..";
+import { AppExecutor, Executor, LibExecutor, ModuleExecutor, PkgExecutor, WorkspaceExecutor } from "../executors";
+import {
+  type ArgMeta,
+  type CommandContext,
+  type EnumChoice,
+  type EnumChoices,
+  getArgMetas,
+  type InternalArgMeta,
+} from "./argMeta";
+import { CommandContainer } from "./dependencyBuilder";
+import { formatCommandHelp, formatHelp } from "./helpFormatter";
+import { type CommandCls, getTargetMetas } from "./targetMeta";
+
+const camelToKebabCase = (str: string) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
+
+const handleOption = (programCommand: Command, argMeta: ArgMeta) => {
+  const {
+    type,
+    flag = argMeta.name.slice(0, 1).toLowerCase(),
+    desc = argMeta.name,
+    example,
+    enum: enumChoices,
+    ask,
+  } = argMeta.argsOption;
+  const kebabName = camelToKebabCase(argMeta.name);
+  const choices = enumChoices && typeof enumChoices !== "function" ? normalizeEnumChoices(enumChoices) : null;
+  programCommand.option(
+    `-${flag}, --${kebabName}${type === "boolean" ? " [boolean]" : ` <${kebabName}>`}`,
+    `${desc}${ask ? ` (${ask})` : ""}${example ? ` (example: ${example})` : ""}${choices ? ` (choices: ${choices.map((choice) => choice.name).join(", ")})` : ""}`,
+  );
+  return programCommand;
+};
+const handleArgument = (programCommand: Command, argMeta: ArgMeta) => {
+  const kebabName = camelToKebabCase(argMeta.name);
+  programCommand.argument(
+    `[${kebabName}]`,
+    `${argMeta.argsOption.desc}${argMeta.argsOption.example ? ` (example: ${argMeta.argsOption.example})` : ""}`,
+  );
+  return programCommand;
+};
+
+const convertArgValue = (value: string | boolean, type: "string" | "number" | "boolean") => {
+  if (type === "string") return value as string;
+  else if (type === "number") return Number(value);
+  else return value === true || value === "true";
+};
+
+const normalizeEnumChoices = (enumChoices: EnumChoices) =>
+  enumChoices.map((choice: EnumChoice) =>
+    typeof choice === "object"
+      ? { value: choice.value, name: choice.label }
+      : { value: choice, name: choice.toString() },
+  );
+
+const resolveEnumChoices = async (argMeta: ArgMeta, context: CommandContext) => {
+  const enumChoices = argMeta.argsOption.enum;
+  if (!enumChoices) return null;
+  if (typeof enumChoices === "function") return await enumChoices(context);
+  return enumChoices;
+};
+
+const getOptionValue = async (argMeta: ArgMeta, opt: Record<string, unknown>, context: CommandContext) => {
+  const {
+    name,
+    argsOption: { enum: enumChoices, default: defaultValue, type, desc, nullable, example, ask },
+  } = argMeta;
+  if (opt[argMeta.name] !== undefined) return convertArgValue(opt[argMeta.name] as string, type ?? "string");
+  else if (defaultValue !== undefined) return defaultValue;
+
+  if (enumChoices) {
+    const choices = normalizeEnumChoices((await resolveEnumChoices(argMeta, context)) ?? []);
+    const choice = await select({ message: ask ?? desc ?? `Select the ${name} value`, choices });
+    return choice;
+  } else if (nullable) return null;
+  else if (type === "boolean") {
+    const message = ask ?? desc ?? `Do you want to set ${name}? ${desc ? ` (${desc})` : ""}: `;
+    return await confirm({ message });
+  } else {
+    const message = ask
+      ? `${ask}: `
+      : desc
+        ? `${desc}: `
+        : `Enter the ${name} value${example ? ` (example: ${example})` : ""}: `;
+    if (argMeta.argsOption.nullable) return await input({ message });
+    else return convertArgValue(await input({ message }), type ?? "string");
+  }
+};
+
+const getArgumentValue = async (argMeta: ArgMeta, value: string | undefined) => {
+  const {
+    name,
+    argsOption: { default: defaultValue, type, desc, nullable, example, ask },
+  } = argMeta;
+  if (value !== undefined) return convertArgValue(value, type ?? "string");
+  else if (defaultValue !== undefined) return defaultValue;
+  else if (nullable) return null;
+
+  const message = ask
+    ? `${ask}: `
+    : desc
+      ? `${desc}: `
+      : `Enter the ${name} value${example ? ` (example: ${example})` : ""}: `;
+  return convertArgValue(await input({ message }), type ?? "string");
+};
+
+const assignCommandContext = (context: CommandContext, argMeta: ArgMeta | InternalArgMeta, value: unknown) => {
+  if (value instanceof AppExecutor) context.app = value;
+  else if (value instanceof LibExecutor) context.lib = value;
+  else if (value instanceof PkgExecutor) context.pkg = value;
+  else if (value instanceof ModuleExecutor) context.module = value;
+  else if (value instanceof Executor) context.exec = value;
+  if (argMeta.type === "Argument" || argMeta.type === "Option") context.values[argMeta.name] = value;
+  else context.values[argMeta.type.toLowerCase()] = value;
+};
+
+const assertCurrentDirectoryIsWorkspaceRoot = async () => {
+  const cwd = process.cwd();
+  const [hasPackageJson, hasTsConfig, hasEnv] = await Promise.all([
+    FileSys.fileExists(`${cwd}/package.json`),
+    FileSys.fileExists(`${cwd}/tsconfig.json`),
+    FileSys.fileExists(`${cwd}/.env`),
+  ]);
+  if (hasPackageJson && hasTsConfig && hasEnv) return;
+
+  throw new Error(
+    [
+      "Akan CLI commands must be run from the workspace root.",
+      `Current directory: ${cwd}`,
+      "Move to the directory that contains package.json, tsconfig.json, and .env, then run the command again.",
+    ].join("\n"),
+  );
+};
+
+const getInternalArgumentValue = async (
+  argMeta: InternalArgMeta,
+  value: string | undefined,
+  workspace: WorkspaceExecutor,
+) => {
+  if (argMeta.type === "Workspace") return workspace;
+  const sysType = argMeta.type.toLowerCase();
+  const [appNames, libNames, pkgNames] = await workspace.getExecs();
+  if (sysType === "sys") {
+    if (value && appNames.includes(value)) return AppExecutor.from(workspace, value);
+    else if (value && libNames.includes(value)) return LibExecutor.from(workspace, value);
+    else {
+      const sysName = await select<string>({
+        message: `Select the App or Lib name`,
+        choices: [...appNames, ...libNames],
+      });
+      if (appNames.includes(sysName)) return AppExecutor.from(workspace, sysName);
+      else if (libNames.includes(sysName)) return LibExecutor.from(workspace, sysName);
+      else throw new Error(`Invalid system name: ${sysName}`);
+    }
+  } else if (sysType === "exec") {
+    if (value && appNames.includes(value)) return AppExecutor.from(workspace, value);
+    else if (value && libNames.includes(value)) return LibExecutor.from(workspace, value);
+    else if (value && pkgNames.includes(value)) return PkgExecutor.from(workspace, value);
+    else {
+      const execName = await select<string>({
+        message: `Select the App or Lib or Pkg name`,
+        choices: [...appNames, ...libNames, ...pkgNames],
+      });
+      if (appNames.includes(execName)) return AppExecutor.from(workspace, execName);
+      else if (libNames.includes(execName)) return LibExecutor.from(workspace, execName);
+      else if (pkgNames.includes(execName)) return PkgExecutor.from(workspace, execName);
+      else throw new Error(`Invalid system name: ${execName}`);
+    }
+  } else if (sysType === "app") {
+    if (value && appNames.includes(value)) return AppExecutor.from(workspace, value);
+    const appName = await select<string>({ message: `Select the ${sysType} name`, choices: appNames });
+    return AppExecutor.from(workspace, appName);
+  } else if (sysType === "lib") {
+    if (value && libNames.includes(value)) return LibExecutor.from(workspace, value);
+    const libName = await select<string>({ message: `Select the ${sysType} name`, choices: libNames });
+    return LibExecutor.from(workspace, libName);
+  } else if (sysType === "pkg") {
+    const pkgs = await workspace.getPkgs();
+    if (value && pkgs.includes(value)) return PkgExecutor.from(workspace, value);
+    const pkgName = await select<string>({ message: `Select the ${sysType} name`, choices: pkgs });
+    return PkgExecutor.from(workspace, pkgName);
+  } else if (sysType === "module") {
+    if (value) {
+      const [sysName, moduleName] = value.split(":");
+      if (!sysName || !moduleName) throw new Error(`Invalid module name: ${value}`);
+      if (appNames.includes(sysName)) {
+        const app = AppExecutor.from(workspace, sysName);
+        const modules = await app.getModules();
+        if (modules.includes(moduleName)) return ModuleExecutor.from(app, moduleName);
+        else throw new Error(`Invalid module name: ${moduleName}`);
+      } else if (libNames.includes(sysName)) {
+        const lib = LibExecutor.from(workspace, sysName);
+        const modules = await lib.getModules();
+        if (modules.includes(moduleName)) return ModuleExecutor.from(lib, moduleName);
+      } else throw new Error(`Invalid system name: ${sysName}`);
+    }
+    const { type, name } = await select<{ type: "app" | "lib"; name: string }>({
+      message: `select the App or Lib name`,
+      choices: [
+        ...appNames.map((name) => ({ name, value: { type: "app" as const, name } })),
+        ...libNames.map((name) => ({ name, value: { type: "lib" as const, name } })),
+      ],
+    });
+    const executor = type === "app" ? AppExecutor.from(workspace, name) : LibExecutor.from(workspace, name);
+    const modules = await executor.getModules();
+    const moduleName = await select<string>({
+      message: `Select the module name`,
+      choices: modules.map((name) => ({ name: `${executor.name}:${name}`, value: name })),
+    });
+    return ModuleExecutor.from(executor, moduleName);
+  } else throw new Error(`Invalid system type: ${argMeta.type}`);
+};
+
+export const runCommands = async (...commands: CommandCls[]) => {
+  process.on("unhandledRejection", (error) => {
+    process.exit(1);
+  });
+  const __dirname = getDirname(import.meta.url);
+  const packageJsonCandidates = [`${path.dirname(Bun.main)}/package.json`, `${__dirname}/../package.json`];
+  let cliPackageJson: PackageJson | null = null;
+  for (const packageJsonPath of packageJsonCandidates) {
+    if (!(await FileSys.fileExists(packageJsonPath))) continue;
+    const packageJson = await FileSys.readJson<PackageJson>(packageJsonPath);
+    if (packageJson.name === "@akanjs/cli" || packageJson.name === "@akanjs/devkit") {
+      cliPackageJson = packageJson;
+      break;
+    }
+  }
+  process.env.AKAN_VERSION = cliPackageJson?.version ?? "0.0.1";
+
+  // Custom help handling
+  const hasHelpFlag = process.argv.includes("--help") || process.argv.includes("-h");
+  const hasCommand = process.argv.length > 2 && !process.argv[2]?.startsWith("-");
+
+  // Show help if: 1) explicit --help flag, or 2) no command provided (just "akan")
+  if (hasHelpFlag || !hasCommand) {
+    if (process.argv.length === 2 || (process.argv.length === 3 && hasHelpFlag)) {
+      // Global help (no specific command)
+      Logger.rawLog(formatHelp(commands, process.env.AKAN_VERSION));
+      process.exit(0);
+    }
+  }
+
+  program.version(process.env.AKAN_VERSION).description("Akan CLI").configureHelp({
+    helpWidth: 100,
+  });
+  const installedAkanPackageJson = (await FileSys.fileExists("./node_modules/akanjs/package.json"))
+    ? await FileSys.readJson<PackageJson>("./node_modules/akanjs/package.json")
+    : null;
+  if (installedAkanPackageJson && installedAkanPackageJson.version !== process.env.AKAN_VERSION) {
+    Logger.rawLog(
+      chalk.yellow(
+        `
+Akan CLI version is mismatch with installed package. ${process.env.AKAN_VERSION} (global) vs ${installedAkanPackageJson.version} (akanjs)
+It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`,
+      ),
+    );
+  }
+
+  for (const command of commands) {
+    const targetMetas = getTargetMetas(command);
+    for (const targetMeta of targetMetas) {
+      const kebabKey = camelToKebabCase(targetMeta.key);
+      const commandNames =
+        targetMeta.targetOption.short === true
+          ? [
+              kebabKey,
+              typeof targetMeta.targetOption.short === "string"
+                ? targetMeta.targetOption.short
+                : kebabKey
+                    .split("-")
+                    .map((s) => s.slice(0, 1))
+                    .join(""),
+            ]
+          : [kebabKey];
+      for (const commandName of commandNames) {
+        let programCommand = program.command(commandName, {
+          hidden: targetMeta.targetOption.devOnly,
+        });
+        const [allArgMetas] = getArgMetas(command, targetMeta.key);
+        for (const argMeta of allArgMetas) {
+          if (argMeta.type === "Option") programCommand = handleOption(programCommand, argMeta);
+          else if (argMeta.type === "Argument") programCommand = handleArgument(programCommand, argMeta);
+          else if (argMeta.type === "Workspace") continue;
+          else if (argMeta.type === "Module") {
+            programCommand = programCommand.argument(
+              `[sys-name:module-name]`,
+              `${argMeta.type} in this workspace (apps|libs)/<sys-name>/lib/<module-name>`,
+            );
+          } else {
+            const sysType = argMeta.type.toLowerCase();
+            programCommand = programCommand.argument(
+              `[${sysType}]`,
+              `${sysType} in this workspace ${sysType}s/<${sysType}Name>`,
+            );
+          }
+        }
+        programCommand = programCommand.option(`-v, --verbose [boolean]`, `verbose output`);
+
+        // Override help completely for each command
+        programCommand.helpInformation = () => {
+          return formatCommandHelp(command, targetMeta.key);
+        };
+
+        programCommand.action(async (...args: unknown[]) => {
+          Logger.rawLog();
+          const cmdArgs = args.slice(0, args.length - 2);
+          const opt = args[args.length - 2] as Record<string, unknown>;
+          const commandArgs = [] as unknown[];
+          if (targetMeta.targetOption.runsOnWorkspaceRoot) await assertCurrentDirectoryIsWorkspaceRoot();
+          const workspace = WorkspaceExecutor.fromRoot();
+          const commandContext: CommandContext = { values: {} };
+          for (const argMeta of allArgMetas) {
+            if (argMeta.type === "Option")
+              commandArgs[argMeta.idx] = await getOptionValue(argMeta, opt, commandContext);
+            else if (argMeta.type === "Argument")
+              commandArgs[argMeta.idx] = await getArgumentValue(argMeta, cmdArgs[argMeta.idx] as string);
+            else
+              commandArgs[argMeta.idx] = await getInternalArgumentValue(
+                argMeta as InternalArgMeta,
+                cmdArgs[argMeta.idx] as string,
+                workspace,
+              );
+            // set app name to env
+            if (commandArgs[argMeta.idx] instanceof AppExecutor)
+              process.env.AKAN_PUBLIC_APP_NAME = (commandArgs[argMeta.idx] as AppExecutor).name;
+            assignCommandContext(commandContext, argMeta, commandArgs[argMeta.idx]);
+            if ((opt as { verbose?: boolean }).verbose) Executor.setVerbose(true);
+          }
+          const cmd = CommandContainer.get(command);
+
+          try {
+            await targetMeta.handler.call(cmd, ...commandArgs);
+            Logger.rawLog();
+          } catch (e) {
+            const errMsg = e instanceof Error ? e.message : typeof e === "string" ? e : JSON.stringify(e);
+            Logger.rawLog(`\n${chalk.red(errMsg)}`);
+            throw e;
+          }
+        });
+      }
+    }
+  }
+  await program.parseAsync(process.argv);
+};

package/commandDecorators/commandBuilder.ts

@@ -0,0 +1,224 @@
+import type {
+  App,
+  ArgMeta,
+  ArgsOption,
+  CommandContext,
+  Exec,
+  InternalArgMeta,
+  InternalArgToken,
+  Lib,
+  Module,
+  Pkg,
+  PrimitiveArgType,
+  Sys,
+} from "./argMeta";
+import { normalizePrimitiveArgType } from "./argMeta";
+import { assertUniqueDependencies, type DependencyInstanceMap, injectDependencies } from "./dependencyBuilder";
+import { COMMAND_META, type CommandCls, type TargetMeta, type TargetOption } from "./targetMeta";
+import type { DependencyCls, DependencyKey } from "./types";
+
+type PrimitiveValue<T extends PrimitiveArgType> = T extends StringConstructor
+  ? string
+  : T extends NumberConstructor
+    ? number
+    : boolean;
+type MaybeNullable<Value, Option> = Option extends { nullable: true } ? Value | null : Value;
+type AddArg<Params extends unknown[], Type extends PrimitiveArgType, Option> = [
+  ...Params,
+  MaybeNullable<PrimitiveValue<Type>, Option>,
+];
+type AddInternalArg<Params extends unknown[], Token extends InternalArgToken> = [...Params, Token["_value"]];
+type AddInternalArgs<Params extends unknown[], Tokens extends readonly InternalArgToken[]> = Tokens extends readonly [
+  infer Head extends InternalArgToken,
+  ...infer Rest extends InternalArgToken[],
+]
+  ? AddInternalArgs<AddInternalArg<Params, Head>, Rest>
+  : Params;
+type ContextFromToken<Token extends InternalArgToken> = Token["_value"] extends App
+  ? { app: App }
+  : Token["_value"] extends Lib
+    ? { lib: Lib }
+    : Token["_value"] extends Sys
+      ? { sys: Sys }
+      : Token["_value"] extends Pkg
+        ? { pkg: Pkg }
+        : Token["_value"] extends Module
+          ? { module: Module }
+          : Token["_value"] extends Exec
+            ? { exec: Exec }
+            : object;
+type AddInternalContext<Context, Tokens extends readonly InternalArgToken[]> = Tokens extends readonly [
+  infer Head extends InternalArgToken,
+  ...infer Rest extends InternalArgToken[],
+]
+  ? AddInternalContext<Context & ContextFromToken<Head>, Rest>
+  : Context;
+type CommandHandler<Deps extends readonly DependencyCls[], Params extends unknown[]> = (
+  this: DependencyInstanceMap<Deps>,
+  ...args: Params
+) => unknown | Promise<unknown>;
+
+class TargetBuilder<Deps extends readonly DependencyCls[], Params extends unknown[] = [], Context = object> {
+  readonly #args: (ArgMeta | InternalArgMeta)[];
+
+  constructor(
+    private readonly targetOption: TargetOption,
+    args: (ArgMeta | InternalArgMeta)[] = [],
+  ) {
+    this.#args = args;
+  }
+
+  arg<Type extends PrimitiveArgType, Option extends ArgsOption<Context> = ArgsOption<Context>>(
+    name: string,
+    type: Type,
+    argsOption: Option = {} as Option,
+  ): TargetBuilder<Deps, AddArg<Params, Type, Option>, Context> {
+    return new TargetBuilder<Deps, AddArg<Params, Type, Option>, Context>(this.targetOption, [
+      ...this.#args,
+      {
+        name,
+        argsOption: { ...argsOption, type: normalizePrimitiveArgType(type) },
+        key: "",
+        idx: this.#args.length,
+        type: "Argument",
+      } as ArgMeta<CommandContext>,
+    ]);
+  }
+
+  option<Type extends PrimitiveArgType, Option extends ArgsOption<Context> = ArgsOption<Context>>(
+    name: string,
+    type: Type,
+    argsOption: Option = {} as Option,
+  ): TargetBuilder<Deps, AddArg<Params, Type, Option>, Context> {
+    return new TargetBuilder<Deps, AddArg<Params, Type, Option>, Context>(this.targetOption, [
+      ...this.#args,
+      {
+        name,
+        argsOption: { ...argsOption, type: normalizePrimitiveArgType(type) },
+        key: "",
+        idx: this.#args.length,
+        type: "Option",
+      } as ArgMeta<CommandContext>,
+    ]);
+  }
+
+  with<const Tokens extends readonly InternalArgToken[]>(
+    ...tokens: Tokens
+  ): TargetBuilder<Deps, AddInternalArgs<Params, Tokens>, AddInternalContext<Context, Tokens>> {
+    return new TargetBuilder<Deps, AddInternalArgs<Params, Tokens>, AddInternalContext<Context, Tokens>>(
+      this.targetOption,
+      [
+        ...this.#args,
+        ...tokens.map(
+          (token, offset) =>
+            ({
+              key: "",
+              idx: this.#args.length + offset,
+              type: token.type,
+            }) satisfies InternalArgMeta,
+        ),
+      ],
+    );
+  }
+
+  exec(handler: CommandHandler<Deps, Params>) {
+    return {
+      args: this.#args,
+      handler: handler as TargetMeta["handler"],
+      targetOption: this.targetOption,
+    };
+  }
+}
+
+type TargetDefinition = ReturnType<TargetBuilder<readonly DependencyCls[], unknown[]>["exec"]>;
+type CommandBuilderContext<Deps extends readonly DependencyCls[]> = {
+  public: (targetOption?: Omit<TargetOption, "type">) => TargetBuilder<Deps>;
+  cloud: (targetOption?: Omit<TargetOption, "type">) => TargetBuilder<Deps>;
+  dev: (targetOption?: Omit<TargetOption, "type">) => TargetBuilder<Deps>;
+  arg: <Type extends PrimitiveArgType, Option extends ArgsOption<CommandContext> = ArgsOption<CommandContext>>(
+    name: string,
+    type: Type,
+    argsOption?: Option,
+  ) => ArgMeta;
+  option: <Type extends PrimitiveArgType, Option extends ArgsOption<CommandContext> = ArgsOption<CommandContext>>(
+    name: string,
+    type: Type,
+    argsOption?: Option,
+  ) => ArgMeta;
+};
+type CommandBuilder<Deps extends readonly DependencyCls[]> = (
+  context: CommandBuilderContext<Deps>,
+) => Record<string, TargetDefinition>;
+
+const createTarget =
+  <Deps extends readonly DependencyCls[]>(type: TargetOption["type"]) =>
+  (targetOption: Omit<TargetOption, "type"> = {}) =>
+    new TargetBuilder<Deps>({ runsOnWorkspaceRoot: true, ...targetOption, type });
+
+const createContext = <Deps extends readonly DependencyCls[]>(): CommandBuilderContext<Deps> => ({
+  public: createTarget<Deps>("public"),
+  cloud: createTarget<Deps>("cloud"),
+  dev: createTarget<Deps>("dev"),
+  arg: (name, type, argsOption) =>
+    ({
+      name,
+      argsOption: { ...(argsOption ?? {}), type: normalizePrimitiveArgType(type) },
+      key: "",
+      idx: -1,
+      type: "Argument",
+    }) as ArgMeta<CommandContext>,
+  option: (name, type, argsOption) =>
+    ({
+      name,
+      argsOption: { ...(argsOption ?? {}), type: normalizePrimitiveArgType(type) },
+      key: "",
+      idx: -1,
+      type: "Option",
+    }) as ArgMeta<CommandContext>,
+});
+
+const buildCommandMeta = (definitions: Record<string, TargetDefinition>) => {
+  const commandMeta = new Map<string, TargetMeta>();
+  for (const [key, definition] of Object.entries(definitions)) {
+    commandMeta.set(key, {
+      key,
+      args: definition.args.map((arg) => ({ ...arg, key })),
+      handler: definition.handler,
+      targetOption: definition.targetOption,
+    });
+  }
+  return commandMeta;
+};
+
+export function command<RefName extends string, Deps extends readonly DependencyCls[]>(
+  refName: RefName,
+  deps: Deps,
+  builder: CommandBuilder<Deps>,
+): CommandCls<DependencyInstanceMap<Deps>, DependencyKey<RefName, "command">>;
+export function command<RefName extends string>(
+  refName: RefName,
+  builder: CommandBuilder<[]>,
+): CommandCls<DependencyInstanceMap<[]>, DependencyKey<RefName, "command">>;
+export function command<RefName extends string, Deps extends readonly DependencyCls[]>(
+  refName: RefName,
+  depsOrBuilder: Deps | CommandBuilder<[]>,
+  builder?: CommandBuilder<Deps>,
+) {
+  const deps = (Array.isArray(depsOrBuilder) ? depsOrBuilder : []) as unknown as Deps;
+  const commandBuilder = (Array.isArray(depsOrBuilder) ? builder : depsOrBuilder) as CommandBuilder<Deps>;
+  assertUniqueDependencies(deps);
+  const commandMeta = buildCommandMeta(commandBuilder(createContext<Deps>()));
+
+  class CommandBase {
+    static readonly refName = refName;
+    static readonly dependencyKind = "command";
+    static readonly dependencyKey = `${refName}Command` as const;
+    static readonly [COMMAND_META] = commandMeta;
+
+    constructor() {
+      injectDependencies(this, deps);
+    }
+  }
+
+  return CommandBase as unknown as CommandCls<DependencyInstanceMap<Deps>, DependencyKey<RefName, "command">>;
+}