@navios/commander 1.4.0 → 1.5.1

package/src/services/__tests__/cli-parser.service.spec.mts

@@ -1,7 +1,6 @@
 import { Container } from '@navios/core'
-
 import { beforeEach, describe, expect, it } from 'vitest'
-import { z } from 'zod'
+import { z } from 'zod/v4'
 
 import { CliParserService } from '../cli-parser.service.mjs'
 
@@ -34,13 +33,7 @@ describe('CliParserService', () => {
     })
 
     it('should parse command with long options and values', () => {
-      const result = parser.parse([
-        'node',
-        'script.js',
-        'test',
-        '--config',
-        'prod',
-      ])
+      const result = parser.parse(['node', 'script.js', 'test', '--config', 'prod'])
       expect(result.command).toBe('test')
       expect(result.options).toEqual({ config: 'prod' })
     })
@@ -71,16 +64,7 @@ describe('CliParserService', () => {
 
     it('should parse mixed options and positionals', () => {
       const result = parser.parse(
-        [
-          'node',
-          'script.js',
-          'test',
-          '--verbose',
-          'file1',
-          '-c',
-          'prod',
-          'file2',
-        ],
+        ['node', 'script.js', 'test', '--verbose', 'file1', '-c', 'prod', 'file2'],
         z.object({
           verbose: z.boolean(),
           c: z.string(),
@@ -92,13 +76,7 @@ describe('CliParserService', () => {
     })
 
     it('should parse options with equal sign syntax', () => {
-      const result = parser.parse([
-        'node',
-        'script.js',
-        'test',
-        '--config=prod',
-        '--port=3000',
-      ])
+      const result = parser.parse(['node', 'script.js', 'test', '--config=prod', '--port=3000'])
       expect(result.command).toBe('test')
       expect(result.options).toEqual({ config: 'prod', port: 3000 })
     })
@@ -125,68 +103,32 @@ describe('CliParserService', () => {
     })
 
     it('should parse integer values', () => {
-      const result = parser.parse([
-        'node',
-        'script.js',
-        'test',
-        '--port',
-        '3000',
-      ])
+      const result = parser.parse(['node', 'script.js', 'test', '--port', '3000'])
       expect(result.options).toEqual({ port: 3000 })
     })
 
     it('should parse negative integer values', () => {
-      const result = parser.parse([
-        'node',
-        'script.js',
-        'test',
-        '--offset',
-        '"-10"',
-      ])
+      const result = parser.parse(['node', 'script.js', 'test', '--offset', '"-10"'])
       expect(result.options).toEqual({ offset: '"-10"' })
     })
 
     it('should parse float values', () => {
-      const result = parser.parse([
-        'node',
-        'script.js',
-        'test',
-        '--ratio',
-        '3.14',
-      ])
+      const result = parser.parse(['node', 'script.js', 'test', '--ratio', '3.14'])
       expect(result.options).toEqual({ ratio: 3.14 })
     })
 
     it('should parse null value', () => {
-      const result = parser.parse([
-        'node',
-        'script.js',
-        'test',
-        '--value',
-        'null',
-      ])
+      const result = parser.parse(['node', 'script.js', 'test', '--value', 'null'])
       expect(result.options).toEqual({ value: null })
     })
 
     it('should parse JSON object', () => {
-      const result = parser.parse([
-        'node',
-        'script.js',
-        'test',
-        '--data',
-        '{"key":"value"}',
-      ])
+      const result = parser.parse(['node', 'script.js', 'test', '--data', '{"key":"value"}'])
       expect(result.options).toEqual({ data: { key: 'value' } })
     })
 
     it('should parse JSON array', () => {
-      const result = parser.parse([
-        'node',
-        'script.js',
-        'test',
-        '--items',
-        '[1,2,3]',
-      ])
+      const result = parser.parse(['node', 'script.js', 'test', '--items', '[1,2,3]'])
       expect(result.options).toEqual({ items: [1, 2, 3] })
     })
   })
@@ -217,15 +159,7 @@ describe('CliParserService', () => {
       })
 
       const result = parser.parse(
-        [
-          'node',
-          'script.js',
-          'test',
-          '--verbose',
-          '--dry-run',
-          '--config',
-          'prod',
-        ],
+        ['node', 'script.js', 'test', '--verbose', '--dry-run', '--config', 'prod'],
         schema,
       )
 
@@ -262,15 +196,7 @@ describe('CliParserService', () => {
 
       // Without schema, --verbose would incorrectly consume '--debug' as its value
       const result = parser.parse(
-        [
-          'node',
-          'script.js',
-          'test',
-          '--verbose',
-          '--debug',
-          '--config',
-          'prod',
-        ],
+        ['node', 'script.js', 'test', '--verbose', '--debug', '--config', 'prod'],
         schema,
       )
 
@@ -313,14 +239,7 @@ describe('CliParserService', () => {
     })
 
     it('should work without schema (fallback behavior)', () => {
-      const result = parser.parse([
-        'node',
-        'script.js',
-        'test',
-        '--verbose',
-        '--config',
-        'prod',
-      ])
+      const result = parser.parse(['node', 'script.js', 'test', '--verbose', '--config', 'prod'])
 
       // Without schema, parser uses heuristics
       expect(result.options).toEqual({
@@ -335,10 +254,7 @@ describe('CliParserService', () => {
         c: z.string(),
       })
 
-      const result = parser.parse(
-        ['node', 'script.js', 'test', '-v', '-c', 'prod'],
-        schema,
-      )
+      const result = parser.parse(['node', 'script.js', 'test', '-v', '-c', 'prod'], schema)
 
       expect(result.options).toEqual({
         v: true,
@@ -356,16 +272,7 @@ describe('CliParserService', () => {
       })
 
       const result = parser.parse(
-        [
-          'node',
-          'script.js',
-          'test',
-          '--verbose',
-          '--debug',
-          '--quiet',
-          '--config',
-          'production',
-        ],
+        ['node', 'script.js', 'test', '--verbose', '--debug', '--quiet', '--config', 'production'],
         schema,
       )
 
@@ -386,13 +293,7 @@ describe('CliParserService', () => {
     })
 
     it('should handle options with dashes in values', () => {
-      const result = parser.parse([
-        'node',
-        'script.js',
-        'test',
-        '--branch',
-        'feature-test',
-      ])
+      const result = parser.parse(['node', 'script.js', 'test', '--branch', 'feature-test'])
       expect(result.options).toEqual({ branch: 'feature-test' })
     })
 
@@ -409,17 +310,7 @@ describe('CliParserService', () => {
       })
 
       const result = parser.parse(
-        [
-          'node',
-          'script.js',
-          'test',
-          '--tags',
-          'foo',
-          '--tags',
-          'bar',
-          '--tags',
-          'baz',
-        ],
+        ['node', 'script.js', 'test', '--tags', 'foo', '--tags', 'bar', '--tags', 'baz'],
         schema,
       )
 
@@ -449,15 +340,7 @@ describe('CliParserService', () => {
       })
 
       const result = parser.parse(
-        [
-          'node',
-          'script.js',
-          'test',
-          '--exclude-paths',
-          'node_modules',
-          '--exclude-paths',
-          'dist',
-        ],
+        ['node', 'script.js', 'test', '--exclude-paths', 'node_modules', '--exclude-paths', 'dist'],
         schema,
       )
 
@@ -473,16 +356,7 @@ describe('CliParserService', () => {
       })
 
       const result = parser.parse(
-        [
-          'node',
-          'script.js',
-          'test',
-          '--tags',
-          'foo',
-          '--tags',
-          'bar',
-          '--verbose',
-        ],
+        ['node', 'script.js', 'test', '--tags', 'foo', '--tags', 'bar', '--verbose'],
         schema,
       )
 
@@ -548,10 +422,7 @@ describe('CliParserService', () => {
         t: z.array(z.string()),
       })
 
-      const result = parser.parse(
-        ['node', 'script.js', 'test', '-t', 'foo', '-t', 'bar'],
-        schema,
-      )
+      const result = parser.parse(['node', 'script.js', 'test', '-t', 'foo', '-t', 'bar'], schema)
 
       expect(result.options).toEqual({
         t: ['foo', 'bar'],
@@ -593,15 +464,7 @@ describe('CliParserService', () => {
       })
 
       const result = parser.parse(
-        [
-          'node',
-          'script.js',
-          'test',
-          '--items',
-          '[1,2,3]',
-          '--items',
-          '["a","b"]',
-        ],
+        ['node', 'script.js', 'test', '--items', '[1,2,3]', '--items', '["a","b"]'],
         schema,
       )
 
@@ -619,17 +482,7 @@ describe('CliParserService', () => {
       })
 
       const result = parser.parse(
-        [
-          'node',
-          'script.js',
-          'test',
-          '--tags',
-          'foo',
-          'file1.txt',
-          '--tags',
-          'bar',
-          'file2.txt',
-        ],
+        ['node', 'script.js', 'test', '--tags', 'foo', 'file1.txt', '--tags', 'bar', 'file2.txt'],
         schema,
       )
 
@@ -641,15 +494,7 @@ describe('CliParserService', () => {
 
     it('should not treat non-array options as arrays without schema', () => {
       // Without schema, multiple values should overwrite
-      const result = parser.parse([
-        'node',
-        'script.js',
-        'test',
-        '--tag',
-        'foo',
-        '--tag',
-        'bar',
-      ])
+      const result = parser.parse(['node', 'script.js', 'test', '--tag', 'foo', '--tag', 'bar'])
 
       expect(result.options).toEqual({
         tag: 'bar', // Last value wins without schema

package/src/services/cli-parser.service.mts

@@ -1,7 +1,7 @@
-import type { ZodObject, ZodType } from 'zod'
-
 import { Injectable } from '@navios/core'
 
+import type { z } from 'zod/v4'
+
 /**
  * Result of parsing command-line arguments.
  *
@@ -44,10 +44,10 @@ export class CliParserService {
    * Expected format: node script.js command [subcommand...] --flag value --boolean-flag positional1 positional2
    *
    * @param argv - Array of command-line arguments (typically process.argv)
-   * @param optionsSchema - Optional Zod schema to determine boolean flags and option types
+   * @param optionsSchema - Optional zod/v4 schema to determine boolean flags and option types
    * @returns Parsed command (space-separated if multi-word), options, and positional arguments
    */
-  parse(argv: string[], optionsSchema?: ZodObject): ParsedCliArgs {
+  parse(argv: string[], optionsSchema?: z.ZodObject): ParsedCliArgs {
     // Skip first two args (node and script path)
     const args = argv.slice(2)
 
@@ -59,9 +59,7 @@ export class CliParserService {
     const booleanFields = optionsSchema
       ? this.extractBooleanFields(optionsSchema)
       : new Set<string>()
-    const arrayFields = optionsSchema
-      ? this.extractArrayFields(optionsSchema)
-      : new Set<string>()
+    const arrayFields = optionsSchema ? this.extractArrayFields(optionsSchema) : new Set<string>()
 
     // Collect command words until we hit an argument that starts with '-' or '--'
     const commandParts: string[] = []
@@ -91,8 +89,7 @@ export class CliParserService {
           const optionName = key.slice(0, equalIndex)
           const optionValue = key.slice(equalIndex + 1)
           const camelCaseKey = this.camelCase(optionName)
-          const isArray =
-            arrayFields.has(camelCaseKey) || arrayFields.has(optionName)
+          const isArray = arrayFields.has(camelCaseKey) || arrayFields.has(optionName)
 
           if (isArray) {
             // For array fields, accumulate values
@@ -107,8 +104,7 @@ export class CliParserService {
         } else {
           // Format: --key value or --boolean-flag
           const camelCaseKey = this.camelCase(key)
-          const isBoolean =
-            booleanFields.has(camelCaseKey) || booleanFields.has(key)
+          const isBoolean = booleanFields.has(camelCaseKey) || booleanFields.has(key)
           const isArray = arrayFields.has(camelCaseKey) || arrayFields.has(key)
           const nextArg = args[i + 1]
 
@@ -227,18 +223,18 @@ export class CliParserService {
   }
 
   /**
-   * Extracts boolean field names from a Zod schema
-   * Handles ZodObject, ZodOptional, and ZodDefault wrappers
+   * Extracts boolean field names from a zod/v4 schema
+   * Handles z.ZodObject, zod/v4Optional, and zod/v4Default wrappers
    */
-  private extractBooleanFields(schema: ZodObject): Set<string> {
+  private extractBooleanFields(schema: z.ZodObject): Set<string> {
     const booleanFields = new Set<string>()
 
     try {
-      // Check if schema has _def.typeName (Zod schema structure)
+      // Check if schema has _def.typeName (zod/v4 schema structure)
       const typeName = schema.def.type
 
       if (typeName === 'object') {
-        // Extract shape from ZodObject
+        // Extract shape from z.ZodObject
         const shape = schema.def.shape
 
         if (shape && typeof shape === 'object') {
@@ -257,10 +253,10 @@ export class CliParserService {
   }
 
   /**
-   * Extracts array field names from a Zod schema
-   * Handles ZodObject, ZodOptional, and ZodDefault wrappers
+   * Extracts array field names from a zod/v4 schema
+   * Handles z.ZodObject, zod/v4Optional, and zod/v4Default wrappers
    */
-  private extractArrayFields(schema: ZodObject): Set<string> {
+  private extractArrayFields(schema: z.ZodObject): Set<string> {
     const arrayFields = new Set<string>()
 
     try {
@@ -285,15 +281,15 @@ export class CliParserService {
   }
 
   /**
-   * Checks if a Zod schema represents a boolean type
-   * Unwraps ZodOptional and ZodDefault using Zod v4 API
+   * Checks if a zod/v4 schema represents a boolean type
+   * Unwraps zod/v4Optional and zod/v4Default using zod/v4 v4 API
    */
-  private isSchemaBoolean(schema: ZodType): boolean {
+  private isSchemaBoolean(schema: z.ZodType): boolean {
     try {
       let currentSchema = schema
       let typeName = currentSchema.def.type
 
-      // Unwrap ZodOptional and ZodDefault using Zod v4's def.innerType
+      // Unwrap zod/v4Optional and zod/v4Default using zod/v4 v4's def.innerType
       while (typeName === 'optional' || typeName === 'default') {
         currentSchema = (currentSchema as any)?.def?.innerType || currentSchema
         typeName = currentSchema.def.type
@@ -306,15 +302,15 @@ export class CliParserService {
   }
 
   /**
-   * Checks if a Zod schema represents an array type
-   * Unwraps ZodOptional and ZodDefault using Zod v4 API
+   * Checks if a zod/v4 schema represents an array type
+   * Unwraps zod/v4Optional and zod/v4Default using zod/v4 v4 API
    */
-  private isSchemaArray(schema: ZodType): boolean {
+  private isSchemaArray(schema: z.ZodType): boolean {
     try {
       let currentSchema = schema
       let typeName = currentSchema.def.type
 
-      // Unwrap ZodOptional and ZodDefault using Zod v4's def.innerType
+      // Unwrap zod/v4Optional and zod/v4Default using zod/v4 v4's def.innerType
       while (typeName === 'optional' || typeName === 'default') {
         currentSchema = (currentSchema as any)?.def?.innerType || currentSchema
         typeName = currentSchema.def.type

package/src/services/command-registry.service.mts

@@ -1,7 +1,7 @@
-import type { ClassType } from '@navios/core'
-
 import { Injectable } from '@navios/core'
 
+import type { ClassType } from '@navios/core'
+
 import type { CommandMetadata } from '../metadata/index.mjs'
 
 /**
@@ -144,7 +144,7 @@ export class CommandRegistryService {
   }
 
   /**
-   * Gets a human-readable type name from a Zod schema.
+   * Gets a human-readable type name from a zod/v4 schema.
    */
   private getSchemaTypeName(schema: any): string {
     try {
@@ -186,8 +186,8 @@ export class CommandRegistryService {
   }
 
   /**
-   * Gets metadata from a Zod schema, traversing innerType if needed.
-   * Zod v4 stores meta at the outermost layer when .meta() is called last,
+   * Gets metadata from a zod/v4 schema, traversing innerType if needed.
+   * zod/v4 v4 stores meta at the outermost layer when .meta() is called last,
    * or in innerType when .meta() is called before .optional()/.default().
    */
   private getSchemaMeta(schema: any): Record<string, unknown> | undefined {

package/src/services/commander-adapter.service.mts

@@ -1,26 +1,18 @@
+import { Container, inject, Injectable, InjectionToken, Logger } from '@navios/core'
+
 import type { ClassType, ModuleMetadata } from '@navios/core'
 
-import {
-  Container,
-  inject,
-  Injectable,
-  InjectionToken,
-  Logger,
-} from '@navios/core'
+import { HelpCommand } from '../commands/help.command.mjs'
+import { CommanderExecutionContext } from '../interfaces/commander-execution-context.interface.mjs'
+import { CommandEntryKey } from '../metadata/command-entry.metadata.mjs'
+import { extractCommandMetadata, hasCommandMetadata } from '../metadata/index.mjs'
+import { CommandExecutionContext } from '../tokens/index.mjs'
 
 import type { AbstractCliAdapterInterface } from '../interfaces/abstract-cli-adapter.interface.mjs'
 import type { CommandHandler } from '../interfaces/command-handler.interface.mjs'
 import type { CliAdapterOptions } from '../interfaces/environment.interface.mjs'
 import type { CommandEntryValue } from '../metadata/command-entry.metadata.mjs'
 
-import { HelpCommand } from '../commands/help.command.mjs'
-import { CommanderExecutionContext } from '../interfaces/commander-execution-context.interface.mjs'
-import { CommandEntryKey } from '../metadata/command-entry.metadata.mjs'
-import {
-  extractCommandMetadata,
-  hasCommandMetadata,
-} from '../metadata/index.mjs'
-import { CommandExecutionContext } from '../tokens/index.mjs'
 import { CliParserService } from './cli-parser.service.mjs'
 import { CommandRegistryService } from './command-registry.service.mjs'
 
@@ -57,9 +49,7 @@ export class CommanderAdapterService implements AbstractCliAdapterInterface {
     this.registerBuiltInCommands()
 
     for (const [moduleName, metadata] of modules) {
-      const commands = metadata.customEntries.get(CommandEntryKey) as
-        | CommandEntryValue
-        | undefined
+      const commands = metadata.customEntries.get(CommandEntryKey) as CommandEntryValue | undefined
       if (!commands) continue
 
       for (const commandClass of commands) {
@@ -156,10 +146,7 @@ export class CommanderAdapterService implements AbstractCliAdapterInterface {
   /**
    * Execute a command programmatically with the provided options.
    */
-  async executeCommand(
-    path: string,
-    options: Record<string, unknown> = {},
-  ): Promise<void> {
+  async executeCommand(path: string, options: Record<string, unknown> = {}): Promise<void> {
     const command = this.commandRegistry.getByPath(path)
     if (!command) {
       throw new Error(`[Navios Commander] Command not found: ${path}`)
@@ -174,11 +161,7 @@ export class CommanderAdapterService implements AbstractCliAdapterInterface {
     }
 
     // Create execution context
-    const executionContext = new CommanderExecutionContext(
-      metadata,
-      path,
-      validatedOptions,
-    )
+    const executionContext = new CommanderExecutionContext(metadata, path, validatedOptions)
 
     // Begin request scope
     const requestId = `cmd-${Date.now()}-${Math.random().toString(36).substring(7)}`

package/src/tokens/execution-context.token.mts

@@ -2,8 +2,7 @@ import { InjectionToken } from '@navios/core'
 
 import type { CommanderExecutionContext } from '../interfaces/index.mjs'
 
-const CommandExecutionContextInjectionToken =
-  'CommanderExecutionContextInjectionToken'
+const CommandExecutionContextInjectionToken = 'CommanderExecutionContextInjectionToken'
 
 /**
  * Injection token for accessing the current command execution context.
@@ -28,7 +27,6 @@ const CommandExecutionContextInjectionToken =
  * }
  * ```
  */
-export const CommandExecutionContext =
-  InjectionToken.create<CommanderExecutionContext>(
-    CommandExecutionContextInjectionToken,
-  )
+export const CommandExecutionContext = InjectionToken.create<CommanderExecutionContext>(
+  CommandExecutionContextInjectionToken,
+)

package/tsconfig.json

@@ -10,6 +10,9 @@
     },
     {
       "path": "./tsconfig.spec.json"
+    },
+    {
+      "path": "../commander-tui"
     }
   ]
 }

package/lib/cli-module.decorator-CkP22084.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-module.decorator-CkP22084.cjs","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,kCAAgB;GACpBV;GACAC;GACAC;GACAC;GACAC;GACAC;GACF,CAAA,CAAGC,QAAQC,QAAAA;EAMX,MAAMK,wFAH6BN,QAAQC,QAAAA,EAKzCV,iEACM,IAAIgB,KAAAA,CAAAA;AAEZ,OAAK,MAAMC,WAAWf,SACpBa,YAAWG,IAAID,QAAAA;AAGjB,SAAOJ"}

package/lib/cli-module.decorator-DGuGfpex.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-module.decorator-DGuGfpex.d.mts","names":["CommandHandler","TOptions","Promise","AbstractAdapterInterface","AbstractCliAdapterInterface","Promise","Record","Array","AdapterEnvironment","AbstractCliAdapterInterface","CliAdapterOptions","CliEnvironment","ClassType","ZodObject","CommandMetadataKey","CommandMetadata","Map","getCommandMetadata","ClassDecoratorContext","extractCommandMetadata","hasCommandMetadata","CommandMetadata","CommanderExecutionContext","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/interfaces/abstract-cli-adapter.interface.d.mts","../src/interfaces/environment.interface.d.mts","../src/metadata/command.metadata.d.mts","../src/interfaces/commander-execution-context.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 type { AbstractAdapterInterface } from '@navios/core';\n/**\n * Interface for CLI adapters.\n * Extends the base adapter interface with CLI-specific methods.\n *\n * @public\n */\nexport interface AbstractCliAdapterInterface extends AbstractAdapterInterface {\n    /**\n     * Run the CLI application with the given arguments.\n     * Parses arguments and executes the matching command.\n     *\n     * @param argv - Command-line arguments array (defaults to `process.argv`)\n     *\n     * @example\n     * ```typescript\n     * const adapter = app.getAdapter() as AbstractCliAdapterInterface\n     * await adapter.run(process.argv)\n     * ```\n     */\n    run(argv?: string[]): Promise<void>;\n    /**\n     * Execute a command programmatically with the provided options.\n     *\n     * @param path - The command path (e.g., 'greet', 'user:create')\n     * @param options - The command options object\n     *\n     * @example\n     * ```typescript\n     * await adapter.executeCommand('user:create', {\n     *   name: 'John',\n     *   email: 'john@example.com',\n     * })\n     * ```\n     */\n    executeCommand(path: string, options: Record<string, unknown>): Promise<void>;\n    /**\n     * Get all registered command paths and their class references.\n     *\n     * @returns Array of objects containing path and class\n     *\n     * @example\n     * ```typescript\n     * const commands = adapter.getAllCommands()\n     * commands.forEach(({ path }) => console.log(path))\n     * ```\n     */\n    getAllCommands(): Array<{\n        path: string;\n        class: unknown;\n    }>;\n}\n//# sourceMappingURL=abstract-cli-adapter.interface.d.mts.map","import type { AdapterEnvironment } from '@navios/core';\nimport type { AbstractCliAdapterInterface } from './abstract-cli-adapter.interface.mjs';\n/**\n * Options for configuring the CLI adapter.\n *\n * @public\n */\nexport interface CliAdapterOptions {\n}\n/**\n * Environment type definition for CLI adapters.\n * Used with NaviosFactory.create<CliEnvironment>() for type-safe CLI applications.\n *\n * @public\n *\n * @example\n * ```typescript\n * import { NaviosFactory } from '@navios/core'\n * import { defineCliEnvironment, type CliEnvironment } from '@navios/commander'\n *\n * const app = await NaviosFactory.create<CliEnvironment>(AppModule, {\n *   adapter: defineCliEnvironment(),\n * })\n * ```\n */\nexport interface CliEnvironment extends AdapterEnvironment {\n    options: CliAdapterOptions;\n    adapter: AbstractCliAdapterInterface;\n}\n//# sourceMappingURL=environment.interface.d.mts.map","import type { ClassType } from '@navios/core';\nimport type { ZodObject } from 'zod';\n/**\n * @internal\n * Symbol key used to store command metadata on classes.\n */\nexport declare const CommandMetadataKey: unique symbol;\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 * 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 declare function getCommandMetadata(target: ClassType, context: ClassDecoratorContext, path: string, description?: string, optionsSchema?: ZodObject): CommandMetadata;\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 declare function extractCommandMetadata(target: ClassType): CommandMetadata;\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 declare function hasCommandMetadata(target: ClassType): boolean;\n//# sourceMappingURL=command.metadata.d.mts.map","import type { CommandMetadata } from '../metadata/command.metadata.mjs';\n/**\n * Execution context for a command execution.\n *\n * Provides access to command metadata, path, and validated options during command execution.\n * This context is automatically injected and available via the `CommandExecutionContext` token.\n *\n * @example\n * ```typescript\n * import { inject, Injectable } from '@navios/core'\n * import { CommandExecutionContext } from '@navios/commander'\n *\n * @Injectable()\n * class CommandLogger {\n *   private ctx = inject(CommandExecutionContext)\n *\n *   log() {\n *     console.log('Command:', this.ctx.getCommandPath())\n *     console.log('Options:', this.ctx.getOptions())\n *   }\n * }\n * ```\n */\nexport declare class CommanderExecutionContext {\n    private readonly command;\n    private readonly commandPath;\n    private readonly options;\n    /**\n     * @internal\n     * Creates a new execution context.\n     */\n    constructor(command: CommandMetadata, commandPath: string, options: any);\n    /**\n     * Gets the command metadata.\n     *\n     * @returns The command metadata including path and options schema\n     */\n    getCommand(): CommandMetadata;\n    /**\n     * Gets the command path that was invoked.\n     *\n     * @returns The command path (e.g., 'greet', 'user:create')\n     */\n    getCommandPath(): string;\n    /**\n     * Gets the validated command options.\n     *\n     * Options are validated against the command's Zod schema if one was provided.\n     *\n     * @returns The validated options object\n     */\n    getOptions(): any;\n}\n//# sourceMappingURL=commander-execution-context.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":"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"}