ts-procedures 5.9.0 → 5.10.0

package/src/codegen/bin/cli.ts

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { createHash } from 'node:crypto'
+import { generateClient, type GenerateClientOptions } from '../index.js'
+import type { AjscOptions } from '../emit-types.js'
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface CodegenConfig {
+  url?: string
+  file?: string
+  outDir?: string
+  watch?: boolean
+  interval?: number
+  ajsc?: AjscOptions
+  clientImportPath?: string
+  dryRun?: boolean
+  namespaceTypes?: boolean
+  selfContained?: boolean
+  serviceName?: string
+}
+
+export interface ParsedArgs {
+  url?: string
+  file?: string
+  outDir: string
+  watch: boolean
+  interval: number
+  ajsc?: AjscOptions
+  clientImportPath?: string
+  dryRun: boolean
+  namespaceTypes: boolean
+  selfContained: boolean
+  serviceName?: string
+}
+
+// ---------------------------------------------------------------------------
+// Config file loading
+// ---------------------------------------------------------------------------
+
+const DEFAULT_CONFIG_NAME = 'ts-procedures-codegen.config.json'
+
+/**
+ * Loads a JSON config file. Returns undefined if the file doesn't exist.
+ * Throws on parse errors.
+ */
+export async function loadConfigFile(configPath?: string): Promise<CodegenConfig | undefined> {
+  const filePath = resolve(configPath ?? DEFAULT_CONFIG_NAME)
+  try {
+    const raw = await readFile(filePath, 'utf8')
+    return JSON.parse(raw) as CodegenConfig
+  } catch (err) {
+    if (configPath !== undefined) {
+      // Explicit path — always throw
+      throw new Error(`[ts-procedures-codegen] Failed to load config from ${filePath}: ${err instanceof Error ? err.message : err}`)
+    }
+    // Default path — silently ignore if not found
+    return undefined
+  }
+}
+
+// ---------------------------------------------------------------------------
+// parseArgs
+// ---------------------------------------------------------------------------
+
+/**
+ * Parses CLI argv (pass process.argv.slice(2)).
+ * Throws with a descriptive message on validation errors.
+ *
+ * When a config object is provided, its values are used as defaults
+ * and CLI flags override them.
+ */
+export function parseArgs(argv: string[], config?: CodegenConfig): ParsedArgs {
+  let url: string | undefined = config?.url
+  let file: string | undefined = config?.file
+  let outDir: string | undefined = config?.outDir
+  let watch = config?.watch ?? false
+  let interval = config?.interval ?? 3000
+  const ajsc: AjscOptions = { jsdoc: true, ...config?.ajsc }
+  let clientImportPath: string | undefined = config?.clientImportPath
+  let dryRun = config?.dryRun ?? false
+  let namespaceTypes = config?.namespaceTypes ?? true
+  let selfContained = config?.selfContained ?? true
+  let serviceName: string | undefined = config?.serviceName
+  let configPath: string | undefined
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+
+    if (arg === '--url') {
+      url = argv[++i]
+    } else if (arg === '--file') {
+      file = argv[++i]
+    } else if (arg === '--out') {
+      outDir = argv[++i]
+    } else if (arg === '--watch') {
+      watch = true
+    } else if (arg === '--interval') {
+      interval = parseInt(argv[++i] ?? '3000', 10)
+    } else if (arg === '--enum-style') {
+      const val = argv[++i]
+      if (val === 'union' || val === 'enum') {
+        ajsc.enumStyle = val
+      }
+    } else if (arg === '--depluralize') {
+      ajsc.depluralize = true
+    } else if (arg === '--array-item-naming') {
+      const val = argv[++i]
+      ajsc.arrayItemNaming = val === 'false' ? false : val
+    } else if (arg === '--uncountable-words') {
+      ajsc.uncountableWords = (argv[++i] ?? '').split(',').map((w) => w.trim()).filter(Boolean)
+    } else if (arg === '--jsdoc') {
+      ajsc.jsdoc = true
+    } else if (arg === '--no-jsdoc') {
+      ajsc.jsdoc = false
+    } else if (arg === '--client-import-path') {
+      clientImportPath = argv[++i]
+    } else if (arg === '--dry-run') {
+      dryRun = true
+    } else if (arg === '--namespace-types') {
+      namespaceTypes = true
+    } else if (arg === '--no-namespace-types') {
+      namespaceTypes = false
+    } else if (arg === '--self-contained') {
+      selfContained = true
+    } else if (arg === '--no-self-contained') {
+      selfContained = false
+    } else if (arg === '--service-name') {
+      serviceName = argv[++i]
+    } else if (arg === '--config') {
+      configPath = argv[++i]
+    }
+  }
+
+  // configPath is consumed by the caller (main) before parseArgs is called with the loaded config.
+  // When called from main, config is already loaded. When called directly (tests), configPath is ignored.
+
+  if (outDir === undefined) {
+    throw new Error('Missing required argument: --out <dir>')
+  }
+
+  if (url === undefined && file === undefined) {
+    throw new Error('Missing required input source: provide --url <url> or --file <path>')
+  }
+
+  return {
+    url,
+    file,
+    outDir,
+    watch,
+    interval,
+    ajsc,
+    ...(clientImportPath !== undefined ? { clientImportPath } : {}),
+    dryRun,
+    namespaceTypes,
+    selfContained,
+    ...(serviceName !== undefined ? { serviceName } : {}),
+  }
+}
+
+/**
+ * Extracts the --config value from argv without full parsing.
+ */
+export function extractConfigPath(argv: string[]): string | undefined {
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--config') return argv[i + 1]
+  }
+  return undefined
+}
+
+// ---------------------------------------------------------------------------
+// Watch mode
+// ---------------------------------------------------------------------------
+
+function hashEnvelope(envelope: unknown): string {
+  return createHash('md5').update(JSON.stringify(envelope)).digest('hex')
+}
+
+async function runWithWatch(parsed: ParsedArgs): Promise<void> {
+  const opts: GenerateClientOptions = {
+    url: parsed.url,
+    file: parsed.file,
+    outDir: parsed.outDir,
+    ajsc: parsed.ajsc,
+    clientImportPath: parsed.clientImportPath,
+    dryRun: parsed.dryRun,
+    namespaceTypes: parsed.namespaceTypes,
+    selfContained: parsed.selfContained,
+    serviceName: parsed.serviceName,
+  }
+
+  let lastHash: string | undefined
+
+  const run = async (): Promise<void> => {
+    try {
+      // Resolve envelope separately so we can hash it
+      const { resolveEnvelope } = await import('../resolve-envelope.js')
+      const envelope = await resolveEnvelope(opts)
+      const hash = hashEnvelope(envelope)
+
+      if (hash === lastHash) {
+        return
+      }
+
+      lastHash = hash
+      const { runPipeline } = await import('../pipeline.js')
+      await runPipeline({
+        envelope,
+        outDir: parsed.outDir,
+        ajsc: parsed.ajsc,
+        clientImportPath: parsed.clientImportPath,
+        dryRun: parsed.dryRun,
+        namespaceTypes: parsed.namespaceTypes,
+        selfContained: parsed.selfContained,
+        serviceName: parsed.serviceName,
+      })
+      console.log(`[ts-procedures-codegen] Generated client files → ${parsed.outDir}`)
+    } catch (err) {
+      console.error('[ts-procedures-codegen] Error:', err instanceof Error ? err.message : err)
+    }
+  }
+
+  await run()
+  setInterval(() => {
+    void run()
+  }, parsed.interval)
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  const argv = process.argv.slice(2)
+  const configPath = extractConfigPath(argv)
+  const config = await loadConfigFile(configPath)
+  if (config != null) {
+    console.log(`[ts-procedures-codegen] Loaded config from ${configPath ?? DEFAULT_CONFIG_NAME}`)
+  }
+  const parsed = parseArgs(argv, config)
+
+  const source = parsed.url ?? parsed.file!
+  console.log(`[ts-procedures-codegen] Reading docs from ${source}...`)
+
+  if (parsed.watch) {
+    await runWithWatch(parsed)
+  } else {
+    const result = await generateClient({
+      url: parsed.url,
+      file: parsed.file,
+      outDir: parsed.outDir,
+      ajsc: parsed.ajsc,
+      clientImportPath: parsed.clientImportPath,
+      dryRun: parsed.dryRun,
+      namespaceTypes: parsed.namespaceTypes,
+      selfContained: parsed.selfContained,
+      serviceName: parsed.serviceName,
+    })
+    if (parsed.dryRun) {
+      console.log(`[ts-procedures-codegen] Dry run complete — ${result.length} files would be generated`)
+    } else {
+      console.log(`[ts-procedures-codegen] Generated ${result.length} files → ${parsed.outDir}`)
+    }
+  }
+}
+
+// Run when this file is the entry point (direct execution or via npx bin symlink)
+const isMain =
+  typeof process !== 'undefined' &&
+  process.argv[1] !== undefined &&
+  !process.argv[1].includes('vitest') &&
+  !process.argv[1].includes('jest')
+
+if (isMain) {
+  main().catch((err: unknown) => {
+    console.error('[ts-procedures-codegen] Fatal error:', err instanceof Error ? err.message : err)
+    process.exit(1)
+  })
+}

package/src/codegen/constants.ts

@@ -0,0 +1 @@
+export const CODEGEN_HEADER = '// Auto-generated by ts-procedures-codegen — do not edit'