@amritk/mjst 0.5.1 → 0.7.0

package/src/parse-cli-args.test.ts

@@ -43,6 +43,26 @@ describe('parse-cli-args', () => {
     })
   })
 
+  it('parses --schemaDir with space-separated and equals syntax', () => {
+    expect(parseCliArgs(['--schemaDir', './schemas', '--outDir', 'dist'])).toEqual({
+      schemaDir: './schemas',
+      outDir: 'dist',
+    })
+    expect(parseCliArgs(['--schemaDir=./schemas', '--outDir=dist'])).toEqual({
+      schemaDir: './schemas',
+      outDir: 'dist',
+    })
+  })
+
+  it('keeps --schema and --schemaDir distinct', () => {
+    const result = parseCliArgs(['--schema', 'a.json', '--schemaDir', './schemas'])
+
+    expect(result).toEqual({
+      schema: 'a.json',
+      schemaDir: './schemas',
+    })
+  })
+
   it('handles only --outDir without --schema', () => {
     const result = parseCliArgs(['--outDir', 'output'])
 
@@ -223,4 +243,32 @@ describe('parse-cli-args', () => {
     const result = parseCliArgs(['--helpers=foo', '--schema', 's.json'])
     expect(result).toEqual({ schema: 's.json' })
   })
+
+  it('accepts kebab-case flag names', () => {
+    const result = parseCliArgs(['--schema-dir', './schemas', '--out-dir', 'dist'])
+
+    expect(result).toEqual({
+      schemaDir: './schemas',
+      outDir: 'dist',
+    })
+  })
+
+  it('treats kebab-case and camelCase variants as equivalent', () => {
+    const kebab = parseCliArgs(['--out-dir', 'dist', '--types-only', '--log-warnings'])
+    const camel = parseCliArgs(['--outDir', 'dist', '--typesOnly', '--logWarnings'])
+
+    expect(kebab).toEqual(camel)
+    expect(camel).toEqual({ outDir: 'dist', typesOnly: true, logWarnings: true })
+  })
+
+  it('parses --out-file with space-separated and equals syntax', () => {
+    expect(parseCliArgs(['--out-file', './out/schema.ts'])).toEqual({ outFile: './out/schema.ts' })
+    expect(parseCliArgs(['--outFile=./out/schema.ts'])).toEqual({ outFile: './out/schema.ts' })
+  })
+
+  it('parses --readonly boolean flag and its equals forms', () => {
+    expect(parseCliArgs(['--readonly'])).toEqual({ readonly: true })
+    expect(parseCliArgs(['--readonly=true'])).toEqual({ readonly: true })
+    expect(parseCliArgs(['--readonly=false'])).toEqual({ readonly: false })
+  })
 })

package/src/parse-cli-args.ts

@@ -4,123 +4,152 @@ import type { CliConfig } from './cli-config'
 
 const SOURCE_FORMATS: readonly SourceFormat[] = ['json', 'typebox', 'zod', 'valibot', 'effect']
 
+// Mutable shape used while building, returned as Partial<CliConfig>.
+type MutableConfig = {
+  schema?: string
+  schemaDir?: string
+  outDir?: string
+  outFile?: string
+  input?: SourceFormat
+  export?: string
+  typesOnly?: boolean
+  build?: boolean
+  logWarnings?: boolean
+  strict?: boolean
+  readonly?: boolean
+  helpers?: 'package' | 'embedded'
+  typeSuffix?: string
+}
+
+// Boolean flags toggle on by presence and accept `--flag=false` to opt out.
+const BOOLEAN_KEYS = new Set<keyof MutableConfig>(['typesOnly', 'build', 'logWarnings', 'strict', 'readonly'])
+// Value flags consume the following argument (or `--flag=value`).
+const VALUE_KEYS = new Set<keyof MutableConfig>([
+  'schema',
+  'schemaDir',
+  'outDir',
+  'outFile',
+  'input',
+  'export',
+  'helpers',
+  'typeSuffix',
+])
+
+/** Normalizes a CLI flag name to its camelCase config key so both `--out-dir` and `--outDir` map to `outDir`. */
+const toCamelCase = (key: string): string => key.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase())
+
+const parseHelpersValue = (value: string): 'package' | 'embedded' | undefined => {
+  if (value === 'package' || value === 'embedded') return value
+  return undefined
+}
+
+const parseInputValue = (value: string): SourceFormat | undefined =>
+  (SOURCE_FORMATS as readonly string[]).includes(value) ? (value as SourceFormat) : undefined
+
+/** Assigns a value-flag onto the config. Returns false for unknown keys. */
+const assignValue = (config: MutableConfig, key: string, value: string): boolean => {
+  switch (key) {
+    case 'schema':
+      config.schema = value
+      return true
+    case 'schemaDir':
+      config.schemaDir = value
+      return true
+    case 'outDir':
+      config.outDir = value
+      return true
+    case 'outFile':
+      config.outFile = value
+      return true
+    case 'export':
+      config.export = value
+      return true
+    case 'typeSuffix':
+      config.typeSuffix = value
+      return true
+    case 'input': {
+      const parsed = parseInputValue(value)
+      if (parsed) config.input = parsed
+      return true
+    }
+    case 'helpers': {
+      const parsed = parseHelpersValue(value)
+      if (parsed) config.helpers = parsed
+      return true
+    }
+    default:
+      return false
+  }
+}
+
+/** Assigns a boolean flag onto the config. Returns false for unknown keys. */
+const assignBoolean = (config: MutableConfig, key: string, value: boolean): boolean => {
+  switch (key) {
+    case 'typesOnly':
+      config.typesOnly = value
+      return true
+    case 'build':
+      config.build = value
+      return true
+    case 'logWarnings':
+      config.logWarnings = value
+      return true
+    case 'strict':
+      config.strict = value
+      return true
+    case 'readonly':
+      config.readonly = value
+      return true
+    default:
+      return false
+  }
+}
+
 /**
  * Parses command-line arguments into a partial CLI config.
- * Supports --schema, --outDir, and --types-only flags with either `--flag value` or `--flag=value` syntax.
- * Only returns the flags that were explicitly provided so we can layer them on top of config file values.
+ * Every flag accepts both kebab-case and camelCase (e.g. `--out-dir` and `--outDir`)
+ * and supports either `--flag value` or `--flag=value` syntax. Boolean flags toggle
+ * on by presence and accept `--flag=false` to opt out. Only flags that were explicitly
+ * provided are returned so they can be layered on top of config file values.
  */
 export const parseCliArgs = (args: readonly string[]): Partial<CliConfig> => {
-  // Use a mutable local type for building, then return as Partial<CliConfig>
-  const config: {
-    schema?: string
-    outDir?: string
-    input?: SourceFormat
-    export?: string
-    typesOnly?: boolean
-    build?: boolean
-    logWarnings?: boolean
-    strict?: boolean
-    helpers?: 'package' | 'embedded'
-  } = {}
-
-  const parseHelpersValue = (value: string): 'package' | 'embedded' | undefined => {
-    if (value === 'package' || value === 'embedded') return value
-    return undefined
-  }
-
-  const parseInputValue = (value: string): SourceFormat | undefined =>
-    (SOURCE_FORMATS as readonly string[]).includes(value) ? (value as SourceFormat) : undefined
+  const config: MutableConfig = {}
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i]
 
-    if (!arg) {
+    if (!arg || !arg.startsWith('--')) {
       continue
     }
 
     // Handle --flag=value syntax
-    if (arg.startsWith('--') && arg.includes('=')) {
-      const equalsIndex = arg.indexOf('=')
-      const key = arg.slice(2, equalsIndex)
+    const equalsIndex = arg.indexOf('=')
+    if (equalsIndex !== -1) {
+      const key = toCamelCase(arg.slice(2, equalsIndex))
       const value = arg.slice(equalsIndex + 1)
-
-      if (key === 'schema') {
-        config.schema = value
-      } else if (key === 'outDir') {
-        config.outDir = value
-      } else if (key === 'input') {
-        const parsed = parseInputValue(value)
-        if (parsed) config.input = parsed
-      } else if (key === 'export') {
-        config.export = value
-      } else if (key === 'types-only') {
-        // Accept --types-only=false to explicitly opt out, otherwise treat as true
-        config.typesOnly = value !== 'false'
-      } else if (key === 'build') {
-        config.build = value !== 'false'
-      } else if (key === 'log-warnings') {
-        config.logWarnings = value !== 'false'
-      } else if (key === 'strict') {
-        config.strict = value !== 'false'
-      } else if (key === 'helpers') {
-        const parsed = parseHelpersValue(value)
-        if (parsed) config.helpers = parsed
+      if (BOOLEAN_KEYS.has(key as keyof MutableConfig)) {
+        assignBoolean(config, key, value !== 'false')
+      } else {
+        assignValue(config, key, value)
       }
-
       continue
     }
 
-    // Handle --flag value syntax
-    if (arg === '--schema') {
-      const value = args[i + 1]
+    const key = toCamelCase(arg.slice(2))
 
-      if (value && !value.startsWith('--')) {
-        config.schema = value
-        i++
-      }
-    } else if (arg === '--outDir') {
-      const value = args[i + 1]
-
-      if (value && !value.startsWith('--')) {
-        config.outDir = value
-        i++
-      }
-    } else if (arg === '--input') {
-      const value = args[i + 1]
+    // Boolean flag: presence alone enables it, no value needed
+    if (BOOLEAN_KEYS.has(key as keyof MutableConfig)) {
+      assignBoolean(config, key, true)
+      continue
+    }
 
-      if (value && !value.startsWith('--')) {
-        const parsed = parseInputValue(value)
-        if (parsed) {
-          config.input = parsed
-          i++
-        }
-      }
-    } else if (arg === '--export') {
+    // Value flag: consume the next argument when it is not another flag
+    if (VALUE_KEYS.has(key as keyof MutableConfig)) {
       const value = args[i + 1]
-
       if (value && !value.startsWith('--')) {
-        config.export = value
+        assignValue(config, key, value)
         i++
       }
-    } else if (arg === '--types-only') {
-      // Boolean flag: presence alone enables it, no value needed
-      config.typesOnly = true
-    } else if (arg === '--build') {
-      config.build = true
-    } else if (arg === '--log-warnings') {
-      config.logWarnings = true
-    } else if (arg === '--strict') {
-      config.strict = true
-    } else if (arg === '--helpers') {
-      const value = args[i + 1]
-
-      if (value && !value.startsWith('--')) {
-        const parsed = parseHelpersValue(value)
-        if (parsed) {
-          config.helpers = parsed
-          i++
-        }
-      }
     }
   }
 

package/src/read-version.test.ts

@@ -0,0 +1,18 @@
+import { readFile } from 'node:fs/promises'
+import { describe, expect, it } from 'vitest'
+
+import { readVersion } from './read-version'
+
+describe('read-version', () => {
+  it('returns the version declared in the package.json', async () => {
+    const pkg = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf-8')) as {
+      version: string
+    }
+
+    expect(await readVersion()).toBe(pkg.version)
+  })
+
+  it('returns a semver-shaped string', async () => {
+    expect(await readVersion()).toMatch(/^\d+\.\d+\.\d+/)
+  })
+})

package/src/read-version.ts

@@ -0,0 +1,14 @@
+import { readFile } from 'node:fs/promises'
+
+/**
+ * Reads the CLI's own version from its `package.json`.
+ *
+ * Resolved relative to this module so it works whether the code runs from
+ * `src/` (dev) or the bundled `dist/cli.js` (published) — `package.json`
+ * sits one directory above both.
+ */
+export const readVersion = async (): Promise<string> => {
+  const pkgUrl = new URL('../package.json', import.meta.url)
+  const pkg = JSON.parse(await readFile(pkgUrl, 'utf-8')) as { version?: string }
+  return pkg.version ?? '0.0.0'
+}