@navios/commander 0.5.0 → 0.5.2

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

@@ -401,4 +401,255 @@ describe('CliParserService', () => {
       expect(result.positionals).toEqual(['-'])
     })
   })
+
+  describe('array option parsing', () => {
+    it('should accumulate multiple values for array options', () => {
+      const schema = z.object({
+        tags: z.array(z.string()),
+      })
+
+      const result = parser.parse(
+        [
+          'node',
+          'script.js',
+          'test',
+          '--tags',
+          'foo',
+          '--tags',
+          'bar',
+          '--tags',
+          'baz',
+        ],
+        schema,
+      )
+
+      expect(result.options).toEqual({
+        tags: ['foo', 'bar', 'baz'],
+      })
+    })
+
+    it('should handle array options with equal sign syntax', () => {
+      const schema = z.object({
+        tags: z.array(z.string()),
+      })
+
+      const result = parser.parse(
+        [
+          'node',
+          'script.js',
+          'test',
+          '--tags=foo',
+          '--tags=bar',
+          '--tags=baz',
+        ],
+        schema,
+      )
+
+      expect(result.options).toEqual({
+        tags: ['foo', 'bar', 'baz'],
+      })
+    })
+
+    it('should handle array options with kebab-case', () => {
+      const schema = z.object({
+        excludePaths: z.array(z.string()),
+      })
+
+      const result = parser.parse(
+        [
+          'node',
+          'script.js',
+          'test',
+          '--exclude-paths',
+          'node_modules',
+          '--exclude-paths',
+          'dist',
+        ],
+        schema,
+      )
+
+      expect(result.options).toEqual({
+        excludePaths: ['node_modules', 'dist'],
+      })
+    })
+
+    it('should handle optional array options', () => {
+      const schema = z.object({
+        tags: z.array(z.string()).optional(),
+        verbose: z.boolean(),
+      })
+
+      const result = parser.parse(
+        [
+          'node',
+          'script.js',
+          'test',
+          '--tags',
+          'foo',
+          '--tags',
+          'bar',
+          '--verbose',
+        ],
+        schema,
+      )
+
+      expect(result.options).toEqual({
+        tags: ['foo', 'bar'],
+        verbose: true,
+      })
+    })
+
+    it('should handle array options with default values', () => {
+      const schema = z.object({
+        tags: z.array(z.string()).default([]),
+      })
+
+      const result = parser.parse(
+        ['node', 'script.js', 'test', '--tags', 'foo', '--tags', 'bar'],
+        schema,
+      )
+
+      expect(result.options).toEqual({
+        tags: ['foo', 'bar'],
+      })
+    })
+
+    it('should handle mixed array, boolean, and string options', () => {
+      const schema = z.object({
+        tags: z.array(z.string()),
+        verbose: z.boolean(),
+        config: z.string(),
+        ports: z.array(z.number()),
+      })
+
+      const result = parser.parse(
+        [
+          'node',
+          'script.js',
+          'test',
+          '--tags',
+          'foo',
+          '--verbose',
+          '--config',
+          'prod',
+          '--tags',
+          'bar',
+          '--ports',
+          '3000',
+          '--ports',
+          '4000',
+        ],
+        schema,
+      )
+
+      expect(result.options).toEqual({
+        tags: ['foo', 'bar'],
+        verbose: true,
+        config: 'prod',
+        ports: [3000, 4000],
+      })
+    })
+
+    it('should handle short array options', () => {
+      const schema = z.object({
+        t: z.array(z.string()),
+      })
+
+      const result = parser.parse(
+        ['node', 'script.js', 'test', '-t', 'foo', '-t', 'bar'],
+        schema,
+      )
+
+      expect(result.options).toEqual({
+        t: ['foo', 'bar'],
+      })
+    })
+
+    it('should parse array option values with correct types', () => {
+      const schema = z.object({
+        ports: z.array(z.number()),
+        flags: z.array(z.boolean()),
+      })
+
+      const result = parser.parse(
+        [
+          'node',
+          'script.js',
+          'test',
+          '--ports',
+          '3000',
+          '--ports',
+          '4000',
+          '--flags',
+          'true',
+          '--flags',
+          'false',
+        ],
+        schema,
+      )
+
+      expect(result.options).toEqual({
+        ports: [3000, 4000],
+        flags: [true, false],
+      })
+    })
+
+    it('should handle JSON array values for array options', () => {
+      const schema = z.object({
+        items: z.array(z.any()),
+      })
+
+      const result = parser.parse(
+        ['node', 'script.js', 'test', '--items', '[1,2,3]', '--items', '["a","b"]'],
+        schema,
+      )
+
+      expect(result.options).toEqual({
+        items: [[1, 2, 3], ['a', 'b']],
+      })
+    })
+
+    it('should handle array options with positionals', () => {
+      const schema = z.object({
+        tags: z.array(z.string()),
+      })
+
+      const result = parser.parse(
+        [
+          'node',
+          'script.js',
+          'test',
+          '--tags',
+          'foo',
+          'file1.txt',
+          '--tags',
+          'bar',
+          'file2.txt',
+        ],
+        schema,
+      )
+
+      expect(result.options).toEqual({
+        tags: ['foo', 'bar'],
+      })
+      expect(result.positionals).toEqual(['file1.txt', 'file2.txt'])
+    })
+
+    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',
+      ])
+
+      expect(result.options).toEqual({
+        tag: 'bar', // Last value wins without schema
+      })
+    })
+  })
 })

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

@@ -27,10 +27,13 @@ export class CliParserService {
       throw new Error('[Navios Commander] No command provided')
     }
 
-    // Extract boolean field names from schema for accurate parsing
+    // Extract boolean and array field names from schema for accurate parsing
     const booleanFields = optionsSchema
       ? this.extractBooleanFields(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[] = []
@@ -59,19 +62,38 @@ export class CliParserService {
           // Format: --key=value
           const optionName = key.slice(0, equalIndex)
           const optionValue = key.slice(equalIndex + 1)
-          options[this.camelCase(optionName)] = this.parseValue(optionValue)
+          const camelCaseKey = this.camelCase(optionName)
+          const isArray = arrayFields.has(camelCaseKey) || arrayFields.has(optionName)
+
+          if (isArray) {
+            // For array fields, accumulate values
+            if (!options[camelCaseKey]) {
+              options[camelCaseKey] = []
+            }
+            options[camelCaseKey].push(this.parseValue(optionValue))
+          } else {
+            options[camelCaseKey] = this.parseValue(optionValue)
+          }
           i++
         } else {
           // Format: --key value or --boolean-flag
           const camelCaseKey = this.camelCase(key)
           const isBoolean =
             booleanFields.has(camelCaseKey) || booleanFields.has(key)
+          const isArray = arrayFields.has(camelCaseKey) || arrayFields.has(key)
           const nextArg = args[i + 1]
 
           if (isBoolean) {
             // Known boolean flag from schema
             options[camelCaseKey] = true
             i++
+          } else if (isArray && nextArg && !nextArg.startsWith('-')) {
+            // Known array field from schema - accumulate values
+            if (!options[camelCaseKey]) {
+              options[camelCaseKey] = []
+            }
+            options[camelCaseKey].push(this.parseValue(nextArg))
+            i += 2
           } else if (nextArg && !nextArg.startsWith('-')) {
             // Has a value
             options[camelCaseKey] = this.parseValue(nextArg)
@@ -89,12 +111,20 @@ export class CliParserService {
         if (flags.length === 1) {
           // Single short flag: -k value or -k
           const isBoolean = booleanFields.has(flags)
+          const isArray = arrayFields.has(flags)
           const nextArg = args[i + 1]
 
           if (isBoolean) {
             // Known boolean flag from schema
             options[flags] = true
             i++
+          } else if (isArray && nextArg && !nextArg.startsWith('-')) {
+            // Known array field from schema - accumulate values
+            if (!options[flags]) {
+              options[flags] = []
+            }
+            options[flags].push(this.parseValue(nextArg))
+            i += 2
           } else if (nextArg && !nextArg.startsWith('-')) {
             options[flags] = this.parseValue(nextArg)
             i += 2
@@ -197,6 +227,34 @@ export class CliParserService {
     return booleanFields
   }
 
+  /**
+   * Extracts array field names from a Zod schema
+   * Handles ZodObject, ZodOptional, and ZodDefault wrappers
+   */
+  private extractArrayFields(schema: ZodObject): Set<string> {
+    const arrayFields = new Set<string>()
+
+    try {
+      const typeName = schema.def.type
+
+      if (typeName === 'object') {
+        const shape = schema.def.shape
+
+        if (shape && typeof shape === 'object') {
+          for (const [key, fieldSchema] of Object.entries(shape)) {
+            if (this.isSchemaArray(fieldSchema as any)) {
+              arrayFields.add(key)
+            }
+          }
+        }
+      }
+    } catch {
+      // Silently fail if schema introspection fails
+    }
+
+    return arrayFields
+  }
+
   /**
    * Checks if a Zod schema represents a boolean type
    * Unwraps ZodOptional and ZodDefault
@@ -218,6 +276,27 @@ export class CliParserService {
     }
   }
 
+  /**
+   * Checks if a Zod schema represents an array type
+   * Unwraps ZodOptional and ZodDefault
+   */
+  private isSchemaArray(schema: ZodType): boolean {
+    try {
+      let currentSchema = schema
+      const typeName = currentSchema.def.type
+
+      // Unwrap ZodOptional and ZodDefault
+      if (typeName === 'optional' || typeName === 'default') {
+        currentSchema = (currentSchema as any)?._def?.innerType || currentSchema
+      }
+
+      const innerTypeName = currentSchema.def.type
+      return innerTypeName === 'array'
+    } catch {
+      return false
+    }
+  }
+
   /**
    * Formats help text for available commands
    */

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

@@ -0,0 +1,10 @@
+import { InjectionToken } from '@navios/di'
+
+import type { CommanderExecutionContext } from '../interfaces/index.mjs'
+
+export const ExecutionContextInjectionToken =
+  'CommanderExecutionContextInjectionToken'
+
+export const ExecutionContext = InjectionToken.create<CommanderExecutionContext>(
+  ExecutionContextInjectionToken,
+)

package/src/tokens/index.mts

@@ -0,0 +1 @@
+export * from './execution-context.token.mjs'