@navios/commander 1.0.0 → 1.2.0

package/lib/cli-module.decorator-DVl8009Q.d.cts

@@ -0,0 +1,213 @@
+import { ClassType, ClassTypeWithInstance, InjectionToken, Registry } from "@navios/core";
+import { ZodObject } from "zod";
+
+//#region src/interfaces/command-handler.interface.d.mts
+
+/**
+ * Interface that all command classes must implement.
+ *
+ * Commands decorated with `@Command` must implement this interface.
+ * The `execute` method is called when the command is invoked.
+ *
+ * @template TOptions - The type of options that the command accepts
+ *
+ * @example
+ * ```typescript
+ * import { Command, CommandHandler } from '@navios/commander'
+ * import { z } from 'zod'
+ *
+ * const optionsSchema = z.object({
+ *   name: z.string()
+ * })
+ *
+ * type Options = z.infer<typeof optionsSchema>
+ *
+ * @Command({ path: 'greet', optionsSchema })
+ * export class GreetCommand implements CommandHandler<Options> {
+ *   async execute(options: Options) {
+ *     console.log(`Hello, ${options.name}!`)
+ *   }
+ * }
+ * ```
+ */
+interface CommandHandler<TOptions = any> {
+  /**
+   * Executes the command with the provided options.
+   *
+   * @param options - The validated command options (validated against the command's schema if provided)
+   * @returns A promise or void
+   */
+  execute(options: TOptions): void | Promise<void>;
+}
+//#endregion
+//#region src/decorators/command.decorator.d.mts
+/**
+ * Options for the `@Command` decorator.
+ *
+ * @public
+ */
+interface CommandOptions {
+  /**
+   * The token to use for the command.
+   * If provided, the command will be registered with this token.
+   */
+  token?: InjectionToken<ClassTypeWithInstance<CommandHandler<any>>>;
+  /**
+   * The command path that users will invoke from the CLI.
+   * Can be a single word (e.g., 'greet') or multi-word with colons (e.g., 'user:create', 'db:migrate').
+   */
+  path: string;
+  /**
+   * Optional description of the command for help text.
+   * Displayed when users run `help` or `--help`.
+   */
+  description?: string;
+  /**
+   * Optional Zod schema for validating command options.
+   * If provided, options will be validated and parsed according to this schema.
+   */
+  optionsSchema?: ZodObject;
+  /**
+   * Priority level for the command.
+   * Higher priority commands will be loaded first.
+   */
+  priority?: number;
+  /**
+   * Registry to use for the command.
+   * Registry is used to store the command and its options schema.
+   */
+  registry?: Registry;
+}
+/**
+ * Decorator that marks a class as a CLI command.
+ *
+ * The decorated class must implement the `CommandHandler` interface with an `execute` method.
+ * The command will be automatically registered when its module is loaded.
+ *
+ * @param options - Configuration options for the command
+ * @returns A class decorator function
+ *
+ * @example
+ * ```typescript
+ * import { Command, CommandHandler } from '@navios/commander'
+ * import { z } from 'zod'
+ *
+ * const optionsSchema = z.object({
+ *   name: z.string(),
+ *   greeting: z.string().optional().default('Hello')
+ * })
+ *
+ * @Command({
+ *   path: 'greet',
+ *   optionsSchema: optionsSchema
+ * })
+ * export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
+ *   async execute(options) {
+ *     console.log(`${options.greeting}, ${options.name}!`)
+ *   }
+ * }
+ * ```
+ */
+declare function Command({
+  path,
+  description,
+  token,
+  optionsSchema,
+  priority,
+  registry
+}: CommandOptions): (target: ClassType, context: ClassDecoratorContext) => any;
+//#endregion
+//#region src/decorators/cli-module.decorator.d.mts
+/**
+ * Options for the `@CliModule` decorator.
+ *
+ * @public
+ */
+interface CliModuleOptions {
+  /**
+   * Array or Set of command classes to register in this module.
+   * Commands must be decorated with `@Command`.
+   */
+  commands?: ClassType[] | Set<ClassType>;
+  /**
+   * Array or Set of controller classes for HTTP endpoints.
+   * Allows mixing HTTP and CLI functionality in the same module.
+   */
+  controllers?: ClassType[] | Set<ClassType>;
+  /**
+   * Array or Set of other modules to import.
+   * Imported modules' commands and controllers will be available.
+   */
+  imports?: ClassType[] | Set<ClassType>;
+  /**
+   * Guards to apply to all controllers in this module.
+   * Guards are executed in reverse order (last guard first).
+   */
+  guards?: ClassType[] | Set<ClassType>;
+  /**
+   * Service override classes to import for side effects.
+   * These classes are imported to ensure their @Injectable decorators execute,
+   * allowing them to register with the DI system. Overrides should use the same
+   * InjectionToken as the original service with a higher priority.
+   */
+  overrides?: ClassType[] | Set<ClassType>;
+  /**
+   * Priority level for the module.
+   * Higher priority modules will be loaded first.
+   */
+  priority?: number;
+  /**
+   * Registry to use for the module.
+   * Registry is used to store the module and its commands.
+   */
+  registry?: Registry;
+}
+/**
+ * Decorator that marks a class as a CLI module.
+ *
+ * This decorator extends the standard @Module decorator, adding support for
+ * CLI commands while maintaining full compatibility with HTTP controllers.
+ * Modules organize commands and can import other modules to compose larger
+ * CLI applications.
+ *
+ * The module can optionally implement `NaviosModule` interface for lifecycle hooks.
+ *
+ * @param options - Configuration options for the module
+ * @returns A class decorator function
+ *
+ * @example
+ * ```typescript
+ * import { CliModule } from '@navios/commander'
+ * import { GreetCommand } from './greet.command'
+ * import { UserModule } from './user.module'
+ *
+ * @CliModule({
+ *   commands: [GreetCommand],
+ *   imports: [UserModule]
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Mixed HTTP and CLI module
+ * @CliModule({
+ *   controllers: [HealthController],
+ *   commands: [MigrateCommand],
+ *   imports: [DatabaseModule],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare function CliModule({
+  commands,
+  controllers,
+  imports,
+  guards,
+  overrides,
+  priority,
+  registry
+}?: CliModuleOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+//#endregion
+export { CommandHandler as a, CommandOptions as i, CliModuleOptions as n, Command as r, CliModule as t };
+//# sourceMappingURL=cli-module.decorator-DVl8009Q.d.cts.map

package/lib/cli-module.decorator-DVl8009Q.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-module.decorator-DVl8009Q.d.cts","names":["CommandHandler","TOptions","Promise","InjectionToken","ClassType","ClassTypeWithInstance","Registry","ZodObject","CommandHandler","CommandOptions","Command","path","description","token","optionsSchema","priority","registry","ClassDecoratorContext","ClassType","Registry","CliModuleOptions","Set","CliModule","commands","controllers","imports","guards","overrides","priority","registry","ClassDecoratorContext"],"sources":["../src/interfaces/command-handler.interface.d.mts","../src/decorators/command.decorator.d.mts","../src/decorators/cli-module.decorator.d.mts"],"sourcesContent":["/**\n * Interface that all command classes must implement.\n *\n * Commands decorated with `@Command` must implement this interface.\n * The `execute` method is called when the command is invoked.\n *\n * @template TOptions - The type of options that the command accepts\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander'\n * import { z } from 'zod'\n *\n * const optionsSchema = z.object({\n *   name: z.string()\n * })\n *\n * type Options = z.infer<typeof optionsSchema>\n *\n * @Command({ path: 'greet', optionsSchema })\n * export class GreetCommand implements CommandHandler<Options> {\n *   async execute(options: Options) {\n *     console.log(`Hello, ${options.name}!`)\n *   }\n * }\n * ```\n */\nexport interface CommandHandler<TOptions = any> {\n    /**\n     * Executes the command with the provided options.\n     *\n     * @param options - The validated command options (validated against the command's schema if provided)\n     * @returns A promise or void\n     */\n    execute(options: TOptions): void | Promise<void>;\n}\n//# sourceMappingURL=command-handler.interface.d.mts.map","import { InjectionToken } from '@navios/core';\nimport type { ClassType, ClassTypeWithInstance, Registry } from '@navios/core';\nimport type { ZodObject } from 'zod';\nimport type { CommandHandler } from '../interfaces/index.mjs';\n/**\n * Options for the `@Command` decorator.\n *\n * @public\n */\nexport interface CommandOptions {\n    /**\n     * The token to use for the command.\n     * If provided, the command will be registered with this token.\n     */\n    token?: InjectionToken<ClassTypeWithInstance<CommandHandler<any>>>;\n    /**\n     * The command path that users will invoke from the CLI.\n     * Can be a single word (e.g., 'greet') or multi-word with colons (e.g., 'user:create', 'db:migrate').\n     */\n    path: string;\n    /**\n     * Optional description of the command for help text.\n     * Displayed when users run `help` or `--help`.\n     */\n    description?: string;\n    /**\n     * Optional Zod schema for validating command options.\n     * If provided, options will be validated and parsed according to this schema.\n     */\n    optionsSchema?: ZodObject;\n    /**\n     * Priority level for the command.\n     * Higher priority commands will be loaded first.\n     */\n    priority?: number;\n    /**\n     * Registry to use for the command.\n     * Registry is used to store the command and its options schema.\n     */\n    registry?: Registry;\n}\n/**\n * Decorator that marks a class as a CLI command.\n *\n * The decorated class must implement the `CommandHandler` interface with an `execute` method.\n * The command will be automatically registered when its module is loaded.\n *\n * @param options - Configuration options for the command\n * @returns A class decorator function\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander'\n * import { z } from 'zod'\n *\n * const optionsSchema = z.object({\n *   name: z.string(),\n *   greeting: z.string().optional().default('Hello')\n * })\n *\n * @Command({\n *   path: 'greet',\n *   optionsSchema: optionsSchema\n * })\n * export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {\n *   async execute(options) {\n *     console.log(`${options.greeting}, ${options.name}!`)\n *   }\n * }\n * ```\n */\nexport declare function Command({ path, description, token, optionsSchema, priority, registry, }: CommandOptions): (target: ClassType, context: ClassDecoratorContext) => any;\n//# sourceMappingURL=command.decorator.d.mts.map","import type { ClassType, Registry } from '@navios/core';\n/**\n * Options for the `@CliModule` decorator.\n *\n * @public\n */\nexport interface CliModuleOptions {\n    /**\n     * Array or Set of command classes to register in this module.\n     * Commands must be decorated with `@Command`.\n     */\n    commands?: ClassType[] | Set<ClassType>;\n    /**\n     * Array or Set of controller classes for HTTP endpoints.\n     * Allows mixing HTTP and CLI functionality in the same module.\n     */\n    controllers?: ClassType[] | Set<ClassType>;\n    /**\n     * Array or Set of other modules to import.\n     * Imported modules' commands and controllers will be available.\n     */\n    imports?: ClassType[] | Set<ClassType>;\n    /**\n     * Guards to apply to all controllers in this module.\n     * Guards are executed in reverse order (last guard first).\n     */\n    guards?: ClassType[] | Set<ClassType>;\n    /**\n     * Service override classes to import for side effects.\n     * These classes are imported to ensure their @Injectable decorators execute,\n     * allowing them to register with the DI system. Overrides should use the same\n     * InjectionToken as the original service with a higher priority.\n     */\n    overrides?: ClassType[] | Set<ClassType>;\n    /**\n     * Priority level for the module.\n     * Higher priority modules will be loaded first.\n     */\n    priority?: number;\n    /**\n     * Registry to use for the module.\n     * Registry is used to store the module and its commands.\n     */\n    registry?: Registry;\n}\n/**\n * Decorator that marks a class as a CLI module.\n *\n * This decorator extends the standard @Module decorator, adding support for\n * CLI commands while maintaining full compatibility with HTTP controllers.\n * Modules organize commands and can import other modules to compose larger\n * CLI applications.\n *\n * The module can optionally implement `NaviosModule` interface for lifecycle hooks.\n *\n * @param options - Configuration options for the module\n * @returns A class decorator function\n *\n * @example\n * ```typescript\n * import { CliModule } from '@navios/commander'\n * import { GreetCommand } from './greet.command'\n * import { UserModule } from './user.module'\n *\n * @CliModule({\n *   commands: [GreetCommand],\n *   imports: [UserModule]\n * })\n * export class AppModule {}\n * ```\n *\n * @example\n * ```typescript\n * // Mixed HTTP and CLI module\n * @CliModule({\n *   controllers: [HealthController],\n *   commands: [MigrateCommand],\n *   imports: [DatabaseModule],\n * })\n * export class AppModule {}\n * ```\n */\nexport declare function CliModule({ commands, controllers, imports, guards, overrides, priority, registry, }?: CliModuleOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;\n//# sourceMappingURL=cli-module.decorator.d.mts.map"],"mappings":";;;;;;;;;AA2BA;;;;AClBA;;;;;;;AA8DA;;;;;;;;;;;;UD5CiBA;;AErBjB;;;;;EAUoCkB,OAAAA,CAAAA,OAAAA,EFkBfjB,QElBeiB,CAAAA,EAAAA,IAAAA,GFkBGhB,OElBHgB,CAAAA,IAAAA,CAAAA;;;;AFWpC;;;;AClBA;AAKiDV,UALhCC,cAAAA,CAKgCD;EAAtBH;;;;EAyBJ,KAAA,CAAA,EAzBXF,cAyBW,CAzBIE,qBAyBJ,CAzB0BG,cAyB1B,CAAA,GAAA,CAAA,CAAA,CAAA;EAgCCE;;;;EAAoCI,IAAAA,EAAAA,MAAAA;EAAeC;;;;EAAqEE,WAAAA,CAAAA,EAAAA,MAAAA;EAAqB;;;;ECjEpJG,aAAAA,CAAAA,EDuBGb,SCvBa;EAKlBW;;;;EAKqBA,QAAAA,CAAAA,EAAAA,MAAAA;EAAJG;;;;EAUnBH,QAAAA,CAAAA,EDaEZ,QCbFY;;;;;;;;AAwDb;;;;;;;;;;;;;;;;;;;;;;;;iBDXwBR,OAAAA;;;;;;;GAA0ED,0BAA0BL,oBAAoBa;;;;;;AD5ChJ;;UErBiBG,gBAAAA;;ADGjB;;;EAKYjB,QAAAA,CAAAA,ECHGe,SDGHf,EAAAA,GCHiBkB,GDGjBlB,CCHqBe,SDGrBf,CAAAA;EAeQI;;;AA0CpB;EAAkCI,WAAAA,CAAAA,ECvDhBO,SDuDgBP,EAAAA,GCvDFU,GDuDEV,CCvDEO,SDuDFP,CAAAA;EAAMC;;;;EAA6CI,OAAAA,CAAAA,EClDvEE,SDkDuEF,EAAAA,GClDzDK,GDkDyDL,CClDrDE,SDkDqDF,CAAAA;EAAaP;;;;WC7CrFS,cAAcG,IAAIH;;;AApB/B;;;;EAUkBA,SAAAA,CAAAA,EAiBFA,SAjBEA,EAAAA,GAiBYG,GAjBZH,CAiBgBA,SAjBhBA,CAAAA;EAAkBA;;;;EAKRG,QAAAA,CAAAA,EAAAA,MAAAA;EAKfH;;;;EAOqBA,QAAAA,CAAAA,EAUnBC,QAVmBD;;;;AAiDlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAwBI,SAAAA;;;;;;;;IAAuFF,4BAA4BF,oBAAoBY,0BAA0BZ"}

package/lib/cli-module.decorator-UGbtkRYc.mjs

@@ -0,0 +1,66 @@
+import { n as CommandEntryKey } from "./command.decorator-DVLSAqYZ.mjs";
+import { Module, getModuleCustomEntry, getModuleMetadata } from "@navios/core";
+
+//#region src/decorators/cli-module.decorator.mts
+/**
+* Decorator that marks a class as a CLI module.
+*
+* This decorator extends the standard @Module decorator, adding support for
+* CLI commands while maintaining full compatibility with HTTP controllers.
+* Modules organize commands and can import other modules to compose larger
+* CLI applications.
+*
+* The module can optionally implement `NaviosModule` interface for lifecycle hooks.
+*
+* @param options - Configuration options for the module
+* @returns A class decorator function
+*
+* @example
+* ```typescript
+* import { CliModule } from '@navios/commander'
+* import { GreetCommand } from './greet.command'
+* import { UserModule } from './user.module'
+*
+* @CliModule({
+*   commands: [GreetCommand],
+*   imports: [UserModule]
+* })
+* export class AppModule {}
+* ```
+*
+* @example
+* ```typescript
+* // Mixed HTTP and CLI module
+* @CliModule({
+*   controllers: [HealthController],
+*   commands: [MigrateCommand],
+*   imports: [DatabaseModule],
+* })
+* export class AppModule {}
+* ```
+*/ function CliModule({ commands = [], controllers = [], imports = [], guards = [], overrides = [], priority, registry } = {
+	commands: [],
+	controllers: [],
+	imports: [],
+	guards: [],
+	overrides: []
+}) {
+	return (target, context) => {
+		if (context.kind !== "class") throw new Error("[Navios Commander] @CliModule decorator can only be used on classes.");
+		const result = Module({
+			controllers,
+			imports,
+			guards,
+			overrides,
+			priority,
+			registry
+		})(target, context);
+		const commandSet = getModuleCustomEntry(getModuleMetadata(target, context), CommandEntryKey, () => /* @__PURE__ */ new Set());
+		for (const command of commands) commandSet.add(command);
+		return result;
+	};
+}
+
+//#endregion
+export { CliModule as t };
+//# sourceMappingURL=cli-module.decorator-UGbtkRYc.mjs.map

package/lib/cli-module.decorator-UGbtkRYc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-module.decorator-UGbtkRYc.mjs","names":["Module","getModuleMetadata","getModuleCustomEntry","CommandEntryKey","CliModule","commands","controllers","imports","guards","overrides","priority","registry","target","context","kind","Error","result","metadata","commandSet","Set","command","add"],"sources":["../src/decorators/cli-module.decorator.mts"],"sourcesContent":["import type { ClassType, Registry } from '@navios/core'\n\nimport { Module, getModuleMetadata, getModuleCustomEntry } from '@navios/core'\n\nimport {\n  CommandEntryKey,\n  type CommandEntryValue,\n} from '../metadata/command-entry.metadata.mjs'\n\n/**\n * Options for the `@CliModule` decorator.\n *\n * @public\n */\nexport interface CliModuleOptions {\n  /**\n   * Array or Set of command classes to register in this module.\n   * Commands must be decorated with `@Command`.\n   */\n  commands?: ClassType[] | Set<ClassType>\n  /**\n   * Array or Set of controller classes for HTTP endpoints.\n   * Allows mixing HTTP and CLI functionality in the same module.\n   */\n  controllers?: ClassType[] | Set<ClassType>\n  /**\n   * Array or Set of other modules to import.\n   * Imported modules' commands and controllers will be available.\n   */\n  imports?: ClassType[] | Set<ClassType>\n  /**\n   * Guards to apply to all controllers in this module.\n   * Guards are executed in reverse order (last guard first).\n   */\n  guards?: ClassType[] | Set<ClassType>\n  /**\n   * Service override classes to import for side effects.\n   * These classes are imported to ensure their @Injectable decorators execute,\n   * allowing them to register with the DI system. Overrides should use the same\n   * InjectionToken as the original service with a higher priority.\n   */\n  overrides?: ClassType[] | Set<ClassType>\n  /**\n   * Priority level for the module.\n   * Higher priority modules will be loaded first.\n   */\n  priority?: number\n  /**\n   * Registry to use for the module.\n   * Registry is used to store the module and its commands.\n   */\n  registry?: Registry\n}\n\n/**\n * Decorator that marks a class as a CLI module.\n *\n * This decorator extends the standard @Module decorator, adding support for\n * CLI commands while maintaining full compatibility with HTTP controllers.\n * Modules organize commands and can import other modules to compose larger\n * CLI applications.\n *\n * The module can optionally implement `NaviosModule` interface for lifecycle hooks.\n *\n * @param options - Configuration options for the module\n * @returns A class decorator function\n *\n * @example\n * ```typescript\n * import { CliModule } from '@navios/commander'\n * import { GreetCommand } from './greet.command'\n * import { UserModule } from './user.module'\n *\n * @CliModule({\n *   commands: [GreetCommand],\n *   imports: [UserModule]\n * })\n * export class AppModule {}\n * ```\n *\n * @example\n * ```typescript\n * // Mixed HTTP and CLI module\n * @CliModule({\n *   controllers: [HealthController],\n *   commands: [MigrateCommand],\n *   imports: [DatabaseModule],\n * })\n * export class AppModule {}\n * ```\n */\nexport function CliModule(\n  {\n    commands = [],\n    controllers = [],\n    imports = [],\n    guards = [],\n    overrides = [],\n    priority,\n    registry,\n  }: CliModuleOptions = {\n    commands: [],\n    controllers: [],\n    imports: [],\n    guards: [],\n    overrides: [],\n  },\n) {\n  return (target: ClassType, context: ClassDecoratorContext) => {\n    if (context.kind !== 'class') {\n      throw new Error(\n        '[Navios Commander] @CliModule decorator can only be used on classes.',\n      )\n    }\n\n    // Apply standard @Module decorator first\n    const result = Module({\n      controllers,\n      imports,\n      guards,\n      overrides,\n      priority,\n      registry,\n    })(target, context)\n\n    // Get the module metadata that @Module just created\n    const metadata = getModuleMetadata(target, context)\n\n    // Store commands in customEntries\n    const commandSet = getModuleCustomEntry<CommandEntryValue>(\n      metadata,\n      CommandEntryKey,\n      () => new Set(),\n    )\n    for (const command of commands) {\n      commandSet.add(command)\n    }\n\n    return result\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FA,SAAgBI,UACd,EACEC,WAAW,EAAE,EACbC,cAAc,EAAE,EAChBC,UAAU,EAAE,EACZC,SAAS,EAAE,EACXC,YAAY,EAAE,EACdC,UACAC,aACoB;CACpBN,UAAU,EAAE;CACZC,aAAa,EAAE;CACfC,SAAS,EAAE;CACXC,QAAQ,EAAE;CACVC,WAAW,EAAE;CACd,EAAA;AAED,SAAQG,QAAmBC,YAAAA;AACzB,MAAIA,QAAQC,SAAS,QACnB,OAAM,IAAIC,MACR,uEAAA;EAKJ,MAAMC,SAAShB,OAAO;GACpBM;GACAC;GACAC;GACAC;GACAC;GACAC;GACF,CAAA,CAAGC,QAAQC,QAAAA;EAMX,MAAMK,aAAahB,qBAHFD,kBAAkBW,QAAQC,QAAAA,EAKzCV,uCACM,IAAIgB,KAAAA,CAAAA;AAEZ,OAAK,MAAMC,WAAWf,SACpBa,YAAWG,IAAID,QAAAA;AAGjB,SAAOJ"}

package/lib/command.decorator-DVLSAqYZ.mjs

@@ -0,0 +1,135 @@
+import { Injectable, InjectableScope, InjectionToken, extractModuleMetadata } from "@navios/core";
+
+//#region src/metadata/command.metadata.mts
+/**
+* @internal
+* Symbol key used to store command metadata on classes.
+*/ const CommandMetadataKey = Symbol("CommandMetadataKey");
+/**
+* Gets or creates command metadata for a class.
+*
+* @internal
+* @param target - The command class
+* @param context - The decorator context
+* @param path - The command path
+* @param description - Optional description for help text
+* @param optionsSchema - Optional Zod schema
+* @returns The command metadata
+*/ function getCommandMetadata(target, context, path, description, optionsSchema) {
+	if (context.metadata) {
+		const metadata = context.metadata[CommandMetadataKey];
+		if (metadata) return metadata;
+		else {
+			const newMetadata = {
+				path,
+				description,
+				optionsSchema,
+				customAttributes: /* @__PURE__ */ new Map()
+			};
+			context.metadata[CommandMetadataKey] = newMetadata;
+			target[CommandMetadataKey] = newMetadata;
+			return newMetadata;
+		}
+	}
+	throw new Error("[Navios Commander] Wrong environment.");
+}
+/**
+* Extracts command metadata from a class.
+*
+* @param target - The command class
+* @returns The command metadata
+* @throws {Error} If the class is not decorated with @Command
+*
+* @example
+* ```typescript
+* const metadata = extractCommandMetadata(GreetCommand)
+* console.log(metadata.path) // 'greet'
+* ```
+*/ function extractCommandMetadata(target) {
+	const metadata = target[CommandMetadataKey];
+	if (!metadata) throw new Error("[Navios Commander] Command metadata not found. Make sure to use @Command decorator.");
+	return metadata;
+}
+/**
+* Checks if a class has command metadata.
+*
+* @param target - The class to check
+* @returns `true` if the class is decorated with @Command, `false` otherwise
+*/ function hasCommandMetadata(target) {
+	return !!target[CommandMetadataKey];
+}
+
+//#endregion
+//#region src/metadata/command-entry.metadata.mts
+/**
+* Symbol key for storing commands in ModuleMetadata.customEntries.
+* Used by @CliModule to store command classes.
+*
+* @public
+*/ const CommandEntryKey = Symbol("CommandEntryKey");
+/**
+* Extracts commands from a module's metadata.
+* Returns empty set if no commands are defined.
+*
+* @param moduleClass - The module class decorated with @CliModule or @Module
+* @returns Set of command classes registered in the module
+*
+* @example
+* ```typescript
+* const commands = extractModuleCommands(AppModule)
+* for (const command of commands) {
+*   console.log(command.name)
+* }
+* ```
+*/ function extractModuleCommands(moduleClass) {
+	return extractModuleMetadata(moduleClass).customEntries.get(CommandEntryKey) ?? /* @__PURE__ */ new Set();
+}
+
+//#endregion
+//#region src/decorators/command.decorator.mts
+/**
+* Decorator that marks a class as a CLI command.
+*
+* The decorated class must implement the `CommandHandler` interface with an `execute` method.
+* The command will be automatically registered when its module is loaded.
+*
+* @param options - Configuration options for the command
+* @returns A class decorator function
+*
+* @example
+* ```typescript
+* import { Command, CommandHandler } from '@navios/commander'
+* import { z } from 'zod'
+*
+* const optionsSchema = z.object({
+*   name: z.string(),
+*   greeting: z.string().optional().default('Hello')
+* })
+*
+* @Command({
+*   path: 'greet',
+*   optionsSchema: optionsSchema
+* })
+* export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
+*   async execute(options) {
+*     console.log(`${options.greeting}, ${options.name}!`)
+*   }
+* }
+* ```
+*/ function Command({ path, description, token, optionsSchema, priority, registry }) {
+	return function(target, context) {
+		if (context.kind !== "class") throw new Error("[Navios Commander] @Command decorator can only be used on classes.");
+		const tokenToUse = token ?? InjectionToken.create(target);
+		if (context.metadata) getCommandMetadata(target, context, path, description, optionsSchema);
+		return Injectable({
+			token: tokenToUse,
+			scope: InjectableScope.Singleton,
+			priority,
+			registry
+		})(target, context);
+	};
+}
+
+//#endregion
+export { extractCommandMetadata as a, CommandMetadataKey as i, CommandEntryKey as n, getCommandMetadata as o, extractModuleCommands as r, hasCommandMetadata as s, Command as t };
+//# sourceMappingURL=command.decorator-DVLSAqYZ.mjs.map

package/lib/command.decorator-DVLSAqYZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.decorator-DVLSAqYZ.mjs","names":["CommandMetadataKey","Symbol","getCommandMetadata","target","context","path","description","optionsSchema","metadata","newMetadata","customAttributes","Map","Error","extractCommandMetadata","hasCommandMetadata","extractModuleMetadata","CommandEntryKey","Symbol","extractModuleCommands","moduleClass","metadata","customEntries","get","Set","Injectable","InjectableScope","InjectionToken","getCommandMetadata","Command","path","description","token","optionsSchema","priority","registry","target","context","kind","Error","tokenToUse","create","metadata","scope","Singleton"],"sources":["../src/metadata/command.metadata.mts","../src/metadata/command-entry.metadata.mts","../src/decorators/command.decorator.mts"],"sourcesContent":["import type { ClassType } from '@navios/core'\nimport type { ZodObject } from 'zod'\n\n/**\n * @internal\n * Symbol key used to store command metadata on classes.\n */\nexport const CommandMetadataKey = Symbol('CommandMetadataKey')\n\n/**\n * Metadata associated with a command.\n *\n * @public\n */\nexport interface CommandMetadata {\n  /**\n   * The command path (e.g., 'greet', 'user:create').\n   */\n  path: string\n  /**\n   * Optional description of the command for help text.\n   */\n  description?: string\n  /**\n   * Optional Zod schema for validating command options.\n   */\n  optionsSchema?: ZodObject\n  /**\n   * Map of custom attributes that can be attached to the command.\n   */\n  customAttributes: Map<string | symbol, any>\n}\n\n/**\n * Gets or creates command metadata for a class.\n *\n * @internal\n * @param target - The command class\n * @param context - The decorator context\n * @param path - The command path\n * @param description - Optional description for help text\n * @param optionsSchema - Optional Zod schema\n * @returns The command metadata\n */\nexport function getCommandMetadata(\n  target: ClassType,\n  context: ClassDecoratorContext,\n  path: string,\n  description?: string,\n  optionsSchema?: ZodObject,\n): CommandMetadata {\n  if (context.metadata) {\n    const metadata = context.metadata[CommandMetadataKey] as\n      | CommandMetadata\n      | undefined\n    if (metadata) {\n      return metadata\n    } else {\n      const newMetadata: CommandMetadata = {\n        path,\n        description,\n        optionsSchema,\n        customAttributes: new Map<string | symbol, any>(),\n      }\n      context.metadata[CommandMetadataKey] = newMetadata\n      // @ts-expect-error We add a custom metadata key to the target\n      target[CommandMetadataKey] = newMetadata\n      return newMetadata\n    }\n  }\n  throw new Error('[Navios Commander] Wrong environment.')\n}\n\n/**\n * Extracts command metadata from a class.\n *\n * @param target - The command class\n * @returns The command metadata\n * @throws {Error} If the class is not decorated with @Command\n *\n * @example\n * ```typescript\n * const metadata = extractCommandMetadata(GreetCommand)\n * console.log(metadata.path) // 'greet'\n * ```\n */\nexport function extractCommandMetadata(target: ClassType): CommandMetadata {\n  // @ts-expect-error We add a custom metadata key to the target\n  const metadata = target[CommandMetadataKey] as CommandMetadata | undefined\n  if (!metadata) {\n    throw new Error(\n      '[Navios Commander] Command metadata not found. Make sure to use @Command decorator.',\n    )\n  }\n  return metadata\n}\n\n/**\n * Checks if a class has command metadata.\n *\n * @param target - The class to check\n * @returns `true` if the class is decorated with @Command, `false` otherwise\n */\nexport function hasCommandMetadata(target: ClassType): boolean {\n  // @ts-expect-error We add a custom metadata key to the target\n  const metadata = target[CommandMetadataKey] as CommandMetadata | undefined\n  return !!metadata\n}\n","import type { ClassType } from '@navios/core'\n\nimport { extractModuleMetadata } from '@navios/core'\n\n/**\n * Symbol key for storing commands in ModuleMetadata.customEntries.\n * Used by @CliModule to store command classes.\n *\n * @public\n */\nexport const CommandEntryKey = Symbol('CommandEntryKey')\n\n/**\n * Type for the command entry value stored in customEntries.\n *\n * @public\n */\nexport type CommandEntryValue = Set<ClassType>\n\n/**\n * Extracts commands from a module's metadata.\n * Returns empty set if no commands are defined.\n *\n * @param moduleClass - The module class decorated with @CliModule or @Module\n * @returns Set of command classes registered in the module\n *\n * @example\n * ```typescript\n * const commands = extractModuleCommands(AppModule)\n * for (const command of commands) {\n *   console.log(command.name)\n * }\n * ```\n */\nexport function extractModuleCommands(moduleClass: ClassType): Set<ClassType> {\n  const metadata = extractModuleMetadata(moduleClass)\n  return (\n    (metadata.customEntries.get(CommandEntryKey) as CommandEntryValue) ??\n    new Set()\n  )\n}\n","import { Injectable, InjectableScope, InjectionToken } from '@navios/core'\n\nimport type { ClassType, ClassTypeWithInstance, Registry } from '@navios/core'\nimport type { ZodObject } from 'zod'\n\nimport { getCommandMetadata } from '../metadata/index.mjs'\n\nimport type { CommandHandler } from '../interfaces/index.mjs'\n\n/**\n * Options for the `@Command` decorator.\n *\n * @public\n */\nexport interface CommandOptions {\n  /**\n   * The token to use for the command.\n   * If provided, the command will be registered with this token.\n   */\n  token?: InjectionToken<ClassTypeWithInstance<CommandHandler<any>>>\n  /**\n   * The command path that users will invoke from the CLI.\n   * Can be a single word (e.g., 'greet') or multi-word with colons (e.g., 'user:create', 'db:migrate').\n   */\n  path: string\n  /**\n   * Optional description of the command for help text.\n   * Displayed when users run `help` or `--help`.\n   */\n  description?: string\n  /**\n   * Optional Zod schema for validating command options.\n   * If provided, options will be validated and parsed according to this schema.\n   */\n  optionsSchema?: ZodObject\n  /**\n   * Priority level for the command.\n   * Higher priority commands will be loaded first.\n   */\n  priority?: number\n  /**\n   * Registry to use for the command.\n   * Registry is used to store the command and its options schema.\n   */\n  registry?: Registry\n}\n\n/**\n * Decorator that marks a class as a CLI command.\n *\n * The decorated class must implement the `CommandHandler` interface with an `execute` method.\n * The command will be automatically registered when its module is loaded.\n *\n * @param options - Configuration options for the command\n * @returns A class decorator function\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander'\n * import { z } from 'zod'\n *\n * const optionsSchema = z.object({\n *   name: z.string(),\n *   greeting: z.string().optional().default('Hello')\n * })\n *\n * @Command({\n *   path: 'greet',\n *   optionsSchema: optionsSchema\n * })\n * export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {\n *   async execute(options) {\n *     console.log(`${options.greeting}, ${options.name}!`)\n *   }\n * }\n * ```\n */\nexport function Command({\n  path,\n  description,\n  token,\n  optionsSchema,\n  priority,\n  registry,\n}: CommandOptions) {\n  return function (target: ClassType, context: ClassDecoratorContext) {\n    if (context.kind !== 'class') {\n      throw new Error('[Navios Commander] @Command decorator can only be used on classes.')\n    }\n    const tokenToUse =\n      token ?? InjectionToken.create<ClassTypeWithInstance<CommandHandler<any>>>(target)\n\n    if (context.metadata) {\n      getCommandMetadata(target, context, path, description, optionsSchema)\n    }\n    // @ts-expect-error Injectable is callable\n    return Injectable({\n      token: tokenToUse,\n      scope: InjectableScope.Singleton,\n      priority,\n      registry,\n    })(target, context)\n  }\n}\n"],"mappings":";;;;;;GAOA,MAAaA,qBAAqBC,OAAO,qBAAA;;;;;;;;;;;GAqCzC,SAAgBC,mBACdC,QACAC,SACAC,MACAC,aACAC,eAAyB;AAEzB,KAAIH,QAAQI,UAAU;EACpB,MAAMA,WAAWJ,QAAQI,SAASR;AAGlC,MAAIQ,SACF,QAAOA;OACF;GACL,MAAMC,cAA+B;IACnCJ;IACAC;IACAC;IACAG,kCAAkB,IAAIC,KAAAA;IACxB;AACAP,WAAQI,SAASR,sBAAsBS;AAEvCN,UAAOH,sBAAsBS;AAC7B,UAAOA;;;AAGX,OAAM,IAAIG,MAAM,wCAAA;;;;;;;;;;;;;;GAgBlB,SAAgBC,uBAAuBV,QAAiB;CAEtD,MAAMK,WAAWL,OAAOH;AACxB,KAAI,CAACQ,SACH,OAAM,IAAII,MACR,sFAAA;AAGJ,QAAOJ;;;;;;;GAST,SAAgBM,mBAAmBX,QAAiB;AAGlD,QAAO,CAAC,CADSA,OAAOH;;;;;;;;;;GC/F1B,MAAagB,kBAAkBC,OAAO,kBAAA;;;;;;;;;;;;;;;GAwBtC,SAAgBC,sBAAsBC,aAAsB;AAE1D,QADiBJ,sBAAsBI,YAAAA,CAE3BE,cAAcC,IAAIN,gBAAAA,oBAC5B,IAAIO,KAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GCuCR,SAAgBK,QAAQ,EACtBC,MACAC,aACAC,OACAC,eACAC,UACAC,YACe;AACf,QAAO,SAAUC,QAAmBC,SAA8B;AAChE,MAAIA,QAAQC,SAAS,QACnB,OAAM,IAAIC,MAAM,qEAAA;EAElB,MAAMC,aACJR,SAASL,eAAec,OAAmDL,OAAAA;AAE7E,MAAIC,QAAQK,SACVd,oBAAmBQ,QAAQC,SAASP,MAAMC,aAAaE,cAAAA;AAGzD,SAAOR,WAAW;GAChBO,OAAOQ;GACPG,OAAOjB,gBAAgBkB;GACvBV;GACAC;GACF,CAAA,CAAGC,QAAQC,QAAAA"}

package/lib/command.decorator-UrNJmQN0.cjs

@@ -0,0 +1,176 @@
+let _navios_core = require("@navios/core");
+
+//#region src/metadata/command.metadata.mts
+/**
+* @internal
+* Symbol key used to store command metadata on classes.
+*/ const CommandMetadataKey = Symbol("CommandMetadataKey");
+/**
+* Gets or creates command metadata for a class.
+*
+* @internal
+* @param target - The command class
+* @param context - The decorator context
+* @param path - The command path
+* @param description - Optional description for help text
+* @param optionsSchema - Optional Zod schema
+* @returns The command metadata
+*/ function getCommandMetadata(target, context, path, description, optionsSchema) {
+	if (context.metadata) {
+		const metadata = context.metadata[CommandMetadataKey];
+		if (metadata) return metadata;
+		else {
+			const newMetadata = {
+				path,
+				description,
+				optionsSchema,
+				customAttributes: /* @__PURE__ */ new Map()
+			};
+			context.metadata[CommandMetadataKey] = newMetadata;
+			target[CommandMetadataKey] = newMetadata;
+			return newMetadata;
+		}
+	}
+	throw new Error("[Navios Commander] Wrong environment.");
+}
+/**
+* Extracts command metadata from a class.
+*
+* @param target - The command class
+* @returns The command metadata
+* @throws {Error} If the class is not decorated with @Command
+*
+* @example
+* ```typescript
+* const metadata = extractCommandMetadata(GreetCommand)
+* console.log(metadata.path) // 'greet'
+* ```
+*/ function extractCommandMetadata(target) {
+	const metadata = target[CommandMetadataKey];
+	if (!metadata) throw new Error("[Navios Commander] Command metadata not found. Make sure to use @Command decorator.");
+	return metadata;
+}
+/**
+* Checks if a class has command metadata.
+*
+* @param target - The class to check
+* @returns `true` if the class is decorated with @Command, `false` otherwise
+*/ function hasCommandMetadata(target) {
+	return !!target[CommandMetadataKey];
+}
+
+//#endregion
+//#region src/metadata/command-entry.metadata.mts
+/**
+* Symbol key for storing commands in ModuleMetadata.customEntries.
+* Used by @CliModule to store command classes.
+*
+* @public
+*/ const CommandEntryKey = Symbol("CommandEntryKey");
+/**
+* Extracts commands from a module's metadata.
+* Returns empty set if no commands are defined.
+*
+* @param moduleClass - The module class decorated with @CliModule or @Module
+* @returns Set of command classes registered in the module
+*
+* @example
+* ```typescript
+* const commands = extractModuleCommands(AppModule)
+* for (const command of commands) {
+*   console.log(command.name)
+* }
+* ```
+*/ function extractModuleCommands(moduleClass) {
+	return (0, _navios_core.extractModuleMetadata)(moduleClass).customEntries.get(CommandEntryKey) ?? /* @__PURE__ */ new Set();
+}
+
+//#endregion
+//#region src/decorators/command.decorator.mts
+/**
+* Decorator that marks a class as a CLI command.
+*
+* The decorated class must implement the `CommandHandler` interface with an `execute` method.
+* The command will be automatically registered when its module is loaded.
+*
+* @param options - Configuration options for the command
+* @returns A class decorator function
+*
+* @example
+* ```typescript
+* import { Command, CommandHandler } from '@navios/commander'
+* import { z } from 'zod'
+*
+* const optionsSchema = z.object({
+*   name: z.string(),
+*   greeting: z.string().optional().default('Hello')
+* })
+*
+* @Command({
+*   path: 'greet',
+*   optionsSchema: optionsSchema
+* })
+* export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
+*   async execute(options) {
+*     console.log(`${options.greeting}, ${options.name}!`)
+*   }
+* }
+* ```
+*/ function Command({ path, description, token, optionsSchema, priority, registry }) {
+	return function(target, context) {
+		if (context.kind !== "class") throw new Error("[Navios Commander] @Command decorator can only be used on classes.");
+		const tokenToUse = token ?? _navios_core.InjectionToken.create(target);
+		if (context.metadata) getCommandMetadata(target, context, path, description, optionsSchema);
+		return (0, _navios_core.Injectable)({
+			token: tokenToUse,
+			scope: _navios_core.InjectableScope.Singleton,
+			priority,
+			registry
+		})(target, context);
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'Command', {
+  enumerable: true,
+  get: function () {
+    return Command;
+  }
+});
+Object.defineProperty(exports, 'CommandEntryKey', {
+  enumerable: true,
+  get: function () {
+    return CommandEntryKey;
+  }
+});
+Object.defineProperty(exports, 'CommandMetadataKey', {
+  enumerable: true,
+  get: function () {
+    return CommandMetadataKey;
+  }
+});
+Object.defineProperty(exports, 'extractCommandMetadata', {
+  enumerable: true,
+  get: function () {
+    return extractCommandMetadata;
+  }
+});
+Object.defineProperty(exports, 'extractModuleCommands', {
+  enumerable: true,
+  get: function () {
+    return extractModuleCommands;
+  }
+});
+Object.defineProperty(exports, 'getCommandMetadata', {
+  enumerable: true,
+  get: function () {
+    return getCommandMetadata;
+  }
+});
+Object.defineProperty(exports, 'hasCommandMetadata', {
+  enumerable: true,
+  get: function () {
+    return hasCommandMetadata;
+  }
+});
+//# sourceMappingURL=command.decorator-UrNJmQN0.cjs.map

package/lib/command.decorator-UrNJmQN0.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.decorator-UrNJmQN0.cjs","names":["CommandMetadataKey","Symbol","getCommandMetadata","target","context","path","description","optionsSchema","metadata","newMetadata","customAttributes","Map","Error","extractCommandMetadata","hasCommandMetadata","extractModuleMetadata","CommandEntryKey","Symbol","extractModuleCommands","moduleClass","metadata","customEntries","get","Set","Injectable","InjectableScope","InjectionToken","getCommandMetadata","Command","path","description","token","optionsSchema","priority","registry","target","context","kind","Error","tokenToUse","create","metadata","scope","Singleton"],"sources":["../src/metadata/command.metadata.mts","../src/metadata/command-entry.metadata.mts","../src/decorators/command.decorator.mts"],"sourcesContent":["import type { ClassType } from '@navios/core'\nimport type { ZodObject } from 'zod'\n\n/**\n * @internal\n * Symbol key used to store command metadata on classes.\n */\nexport const CommandMetadataKey = Symbol('CommandMetadataKey')\n\n/**\n * Metadata associated with a command.\n *\n * @public\n */\nexport interface CommandMetadata {\n  /**\n   * The command path (e.g., 'greet', 'user:create').\n   */\n  path: string\n  /**\n   * Optional description of the command for help text.\n   */\n  description?: string\n  /**\n   * Optional Zod schema for validating command options.\n   */\n  optionsSchema?: ZodObject\n  /**\n   * Map of custom attributes that can be attached to the command.\n   */\n  customAttributes: Map<string | symbol, any>\n}\n\n/**\n * Gets or creates command metadata for a class.\n *\n * @internal\n * @param target - The command class\n * @param context - The decorator context\n * @param path - The command path\n * @param description - Optional description for help text\n * @param optionsSchema - Optional Zod schema\n * @returns The command metadata\n */\nexport function getCommandMetadata(\n  target: ClassType,\n  context: ClassDecoratorContext,\n  path: string,\n  description?: string,\n  optionsSchema?: ZodObject,\n): CommandMetadata {\n  if (context.metadata) {\n    const metadata = context.metadata[CommandMetadataKey] as\n      | CommandMetadata\n      | undefined\n    if (metadata) {\n      return metadata\n    } else {\n      const newMetadata: CommandMetadata = {\n        path,\n        description,\n        optionsSchema,\n        customAttributes: new Map<string | symbol, any>(),\n      }\n      context.metadata[CommandMetadataKey] = newMetadata\n      // @ts-expect-error We add a custom metadata key to the target\n      target[CommandMetadataKey] = newMetadata\n      return newMetadata\n    }\n  }\n  throw new Error('[Navios Commander] Wrong environment.')\n}\n\n/**\n * Extracts command metadata from a class.\n *\n * @param target - The command class\n * @returns The command metadata\n * @throws {Error} If the class is not decorated with @Command\n *\n * @example\n * ```typescript\n * const metadata = extractCommandMetadata(GreetCommand)\n * console.log(metadata.path) // 'greet'\n * ```\n */\nexport function extractCommandMetadata(target: ClassType): CommandMetadata {\n  // @ts-expect-error We add a custom metadata key to the target\n  const metadata = target[CommandMetadataKey] as CommandMetadata | undefined\n  if (!metadata) {\n    throw new Error(\n      '[Navios Commander] Command metadata not found. Make sure to use @Command decorator.',\n    )\n  }\n  return metadata\n}\n\n/**\n * Checks if a class has command metadata.\n *\n * @param target - The class to check\n * @returns `true` if the class is decorated with @Command, `false` otherwise\n */\nexport function hasCommandMetadata(target: ClassType): boolean {\n  // @ts-expect-error We add a custom metadata key to the target\n  const metadata = target[CommandMetadataKey] as CommandMetadata | undefined\n  return !!metadata\n}\n","import type { ClassType } from '@navios/core'\n\nimport { extractModuleMetadata } from '@navios/core'\n\n/**\n * Symbol key for storing commands in ModuleMetadata.customEntries.\n * Used by @CliModule to store command classes.\n *\n * @public\n */\nexport const CommandEntryKey = Symbol('CommandEntryKey')\n\n/**\n * Type for the command entry value stored in customEntries.\n *\n * @public\n */\nexport type CommandEntryValue = Set<ClassType>\n\n/**\n * Extracts commands from a module's metadata.\n * Returns empty set if no commands are defined.\n *\n * @param moduleClass - The module class decorated with @CliModule or @Module\n * @returns Set of command classes registered in the module\n *\n * @example\n * ```typescript\n * const commands = extractModuleCommands(AppModule)\n * for (const command of commands) {\n *   console.log(command.name)\n * }\n * ```\n */\nexport function extractModuleCommands(moduleClass: ClassType): Set<ClassType> {\n  const metadata = extractModuleMetadata(moduleClass)\n  return (\n    (metadata.customEntries.get(CommandEntryKey) as CommandEntryValue) ??\n    new Set()\n  )\n}\n","import { Injectable, InjectableScope, InjectionToken } from '@navios/core'\n\nimport type { ClassType, ClassTypeWithInstance, Registry } from '@navios/core'\nimport type { ZodObject } from 'zod'\n\nimport { getCommandMetadata } from '../metadata/index.mjs'\n\nimport type { CommandHandler } from '../interfaces/index.mjs'\n\n/**\n * Options for the `@Command` decorator.\n *\n * @public\n */\nexport interface CommandOptions {\n  /**\n   * The token to use for the command.\n   * If provided, the command will be registered with this token.\n   */\n  token?: InjectionToken<ClassTypeWithInstance<CommandHandler<any>>>\n  /**\n   * The command path that users will invoke from the CLI.\n   * Can be a single word (e.g., 'greet') or multi-word with colons (e.g., 'user:create', 'db:migrate').\n   */\n  path: string\n  /**\n   * Optional description of the command for help text.\n   * Displayed when users run `help` or `--help`.\n   */\n  description?: string\n  /**\n   * Optional Zod schema for validating command options.\n   * If provided, options will be validated and parsed according to this schema.\n   */\n  optionsSchema?: ZodObject\n  /**\n   * Priority level for the command.\n   * Higher priority commands will be loaded first.\n   */\n  priority?: number\n  /**\n   * Registry to use for the command.\n   * Registry is used to store the command and its options schema.\n   */\n  registry?: Registry\n}\n\n/**\n * Decorator that marks a class as a CLI command.\n *\n * The decorated class must implement the `CommandHandler` interface with an `execute` method.\n * The command will be automatically registered when its module is loaded.\n *\n * @param options - Configuration options for the command\n * @returns A class decorator function\n *\n * @example\n * ```typescript\n * import { Command, CommandHandler } from '@navios/commander'\n * import { z } from 'zod'\n *\n * const optionsSchema = z.object({\n *   name: z.string(),\n *   greeting: z.string().optional().default('Hello')\n * })\n *\n * @Command({\n *   path: 'greet',\n *   optionsSchema: optionsSchema\n * })\n * export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {\n *   async execute(options) {\n *     console.log(`${options.greeting}, ${options.name}!`)\n *   }\n * }\n * ```\n */\nexport function Command({\n  path,\n  description,\n  token,\n  optionsSchema,\n  priority,\n  registry,\n}: CommandOptions) {\n  return function (target: ClassType, context: ClassDecoratorContext) {\n    if (context.kind !== 'class') {\n      throw new Error('[Navios Commander] @Command decorator can only be used on classes.')\n    }\n    const tokenToUse =\n      token ?? InjectionToken.create<ClassTypeWithInstance<CommandHandler<any>>>(target)\n\n    if (context.metadata) {\n      getCommandMetadata(target, context, path, description, optionsSchema)\n    }\n    // @ts-expect-error Injectable is callable\n    return Injectable({\n      token: tokenToUse,\n      scope: InjectableScope.Singleton,\n      priority,\n      registry,\n    })(target, context)\n  }\n}\n"],"mappings":";;;;;;GAOA,MAAaA,qBAAqBC,OAAO,qBAAA;;;;;;;;;;;GAqCzC,SAAgBC,mBACdC,QACAC,SACAC,MACAC,aACAC,eAAyB;AAEzB,KAAIH,QAAQI,UAAU;EACpB,MAAMA,WAAWJ,QAAQI,SAASR;AAGlC,MAAIQ,SACF,QAAOA;OACF;GACL,MAAMC,cAA+B;IACnCJ;IACAC;IACAC;IACAG,kCAAkB,IAAIC,KAAAA;IACxB;AACAP,WAAQI,SAASR,sBAAsBS;AAEvCN,UAAOH,sBAAsBS;AAC7B,UAAOA;;;AAGX,OAAM,IAAIG,MAAM,wCAAA;;;;;;;;;;;;;;GAgBlB,SAAgBC,uBAAuBV,QAAiB;CAEtD,MAAMK,WAAWL,OAAOH;AACxB,KAAI,CAACQ,SACH,OAAM,IAAII,MACR,sFAAA;AAGJ,QAAOJ;;;;;;;GAST,SAAgBM,mBAAmBX,QAAiB;AAGlD,QAAO,CAAC,CADSA,OAAOH;;;;;;;;;;GC/F1B,MAAagB,kBAAkBC,OAAO,kBAAA;;;;;;;;;;;;;;;GAwBtC,SAAgBC,sBAAsBC,aAAsB;AAE1D,gDADuCA,YAAAA,CAE3BE,cAAcC,IAAIN,gBAAAA,oBAC5B,IAAIO,KAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GCuCR,SAAgBK,QAAQ,EACtBC,MACAC,aACAC,OACAC,eACAC,UACAC,YACe;AACf,QAAO,SAAUC,QAAmBC,SAA8B;AAChE,MAAIA,QAAQC,SAAS,QACnB,OAAM,IAAIC,MAAM,qEAAA;EAElB,MAAMC,aACJR,SAASL,4BAAec,OAAmDL,OAAAA;AAE7E,MAAIC,QAAQK,SACVd,oBAAmBQ,QAAQC,SAASP,MAAMC,aAAaE,cAAAA;AAGzD,sCAAkB;GAChBD,OAAOQ;GACPG,OAAOjB,6BAAgBkB;GACvBV;GACAC;GACF,CAAA,CAAGC,QAAQC,QAAAA"}