@amritk/mjst 0.7.6 → 0.7.8

package/src/detect-helpers-mode.test.ts

@@ -1,45 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-
-import { detectHelpersMode } from './detect-helpers-mode'
-
-describe('detect-helpers-mode', () => {
-  let tmpRoot: string
-
-  beforeAll(async () => {
-    tmpRoot = await mkdtemp(join(tmpdir(), 'mjst-detect-'))
-  })
-
-  afterAll(async () => {
-    await rm(tmpRoot, { recursive: true, force: true })
-  })
-
-  it("returns 'package' when @amritk/helpers is resolvable from outDir", async () => {
-    const outDir = join(tmpRoot, 'with-helpers/out')
-    const helpersPkgDir = join(tmpRoot, 'with-helpers/node_modules/@amritk/helpers')
-    await mkdir(outDir, { recursive: true })
-    await mkdir(helpersPkgDir, { recursive: true })
-    await writeFile(join(helpersPkgDir, 'is-object.js'), 'export const isObject = () => true\n', 'utf-8')
-    await writeFile(
-      join(helpersPkgDir, 'package.json'),
-      JSON.stringify({
-        name: '@amritk/helpers',
-        version: '0.0.0',
-        type: 'module',
-        exports: { './is-object': './is-object.js' },
-      }),
-      'utf-8',
-    )
-
-    expect(detectHelpersMode(outDir)).toBe('package')
-  })
-
-  it("returns 'embedded' when @amritk/helpers cannot be resolved from outDir", async () => {
-    const outDir = join(tmpRoot, 'no-helpers/out')
-    await mkdir(outDir, { recursive: true })
-
-    expect(detectHelpersMode(outDir)).toBe('embedded')
-  })
-})

package/src/detect-helpers-mode.ts

@@ -1,21 +0,0 @@
-import { createRequire } from 'node:module'
-import { resolve } from 'node:path'
-
-/**
- * Detects whether `@amritk/helpers` is resolvable from the consumer's output
- * directory using standard Node module resolution (walks up `node_modules`).
- *
- * Returns `'package'` when generated parsers can safely
- * `import { ... } from '@amritk/helpers/...'` at runtime, or `'embedded'`
- * when the helper sources need to be shipped alongside the generated files
- * for the output to be self-contained.
- */
-export const detectHelpersMode = (outputDir: string): 'package' | 'embedded' => {
-  const req = createRequire(resolve(outputDir, 'noop.js'))
-  try {
-    req.resolve('@amritk/helpers/is-object')
-    return 'package'
-  } catch {
-    return 'embedded'
-  }
-}

package/src/load-config.test.ts

@@ -1,78 +0,0 @@
-import { writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-
-import { loadConfig } from './load-config'
-
-describe('load-config', () => {
-  it('loads schema and outDir from a JSON config file', async () => {
-    const configPath = join(tmpdir(), `test-config-${Date.now()}.json`)
-    await writeFile(configPath, JSON.stringify({ schema: 'my-schema.json', outDir: 'output' }))
-
-    const result = await loadConfig(configPath)
-
-    expect(result).toEqual({
-      schema: 'my-schema.json',
-      outDir: 'output',
-    })
-  })
-
-  it('returns partial config when only some keys are present', async () => {
-    const configPath = join(tmpdir(), `test-config-${Date.now()}.json`)
-    await writeFile(configPath, JSON.stringify({ schema: 'my-schema.json' }))
-
-    const result = await loadConfig(configPath)
-
-    expect(result).toEqual({
-      schema: 'my-schema.json',
-    })
-  })
-
-  it('ignores non-string values for known keys', async () => {
-    const configPath = join(tmpdir(), `test-config-${Date.now()}.json`)
-    await writeFile(configPath, JSON.stringify({ schema: 123, outDir: true }))
-
-    const result = await loadConfig(configPath)
-
-    expect(result).toEqual({})
-  })
-
-  it('throws for non-object config files', async () => {
-    const configPath = join(tmpdir(), `test-config-${Date.now()}.json`)
-    await writeFile(configPath, JSON.stringify([1, 2, 3]))
-
-    await expect(loadConfig(configPath)).rejects.toThrow('Config file must be a JSON object')
-  })
-
-  it('throws for missing config files', async () => {
-    await expect(loadConfig('/nonexistent/config.json')).rejects.toThrow()
-  })
-
-  it('loads strict boolean from config file', async () => {
-    const configPath = join(tmpdir(), `test-config-${Date.now()}.json`)
-    await writeFile(configPath, JSON.stringify({ schema: 's.json', outDir: 'o', strict: true }))
-
-    const result = await loadConfig(configPath)
-
-    expect(result).toEqual({ schema: 's.json', outDir: 'o', strict: true })
-  })
-
-  it('loads schemaDir from a config file', async () => {
-    const configPath = join(tmpdir(), `test-config-${Date.now()}.json`)
-    await writeFile(configPath, JSON.stringify({ schemaDir: './schemas', outDir: 'output' }))
-
-    const result = await loadConfig(configPath)
-
-    expect(result).toEqual({ schemaDir: './schemas', outDir: 'output' })
-  })
-
-  it('ignores non-boolean strict value', async () => {
-    const configPath = join(tmpdir(), `test-config-${Date.now()}.json`)
-    await writeFile(configPath, JSON.stringify({ schema: 's.json', strict: 'yes' }))
-
-    const result = await loadConfig(configPath)
-
-    expect(result).toEqual({ schema: 's.json' })
-  })
-})

package/src/load-config.ts

@@ -1,40 +0,0 @@
-import { readFile } from 'node:fs/promises'
-import { resolve } from 'node:path'
-import type { SourceFormat } from '@amritk/adapters/source-format'
-
-import type { CliConfig } from './cli-config'
-
-const SOURCE_FORMATS: readonly string[] = ['json', 'typebox', 'zod', 'valibot', 'effect']
-
-const isSourceFormat = (value: unknown): value is SourceFormat =>
-  typeof value === 'string' && SOURCE_FORMATS.includes(value)
-
-/**
- * Loads a JSON config file and returns the relevant CLI config properties.
- * The config file should have the same keys as the CLI flags (schema, outDir).
- */
-export const loadConfig = async (configPath: string): Promise<Partial<CliConfig>> => {
-  const absolutePath = resolve(configPath)
-  const raw = await readFile(absolutePath, 'utf-8')
-  const parsed: unknown = JSON.parse(raw)
-
-  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-    throw new Error(`Config file must be a JSON object: ${configPath}`)
-  }
-
-  const obj = parsed as Record<string, unknown>
-
-  return {
-    ...(typeof obj['schema'] === 'string' && { schema: obj['schema'] }),
-    ...(typeof obj['schemaDir'] === 'string' && { schemaDir: obj['schemaDir'] }),
-    ...(typeof obj['outDir'] === 'string' && { outDir: obj['outDir'] }),
-    ...(typeof obj['outFile'] === 'string' && { outFile: obj['outFile'] }),
-    ...(isSourceFormat(obj['input']) && { input: obj['input'] }),
-    ...(typeof obj['export'] === 'string' && { export: obj['export'] }),
-    ...(typeof obj['typesOnly'] === 'boolean' && { typesOnly: obj['typesOnly'] }),
-    ...(typeof obj['build'] === 'boolean' && { build: obj['build'] }),
-    ...(typeof obj['logWarnings'] === 'boolean' && { logWarnings: obj['logWarnings'] }),
-    ...(typeof obj['strict'] === 'boolean' && { strict: obj['strict'] }),
-    ...(typeof obj['readonly'] === 'boolean' && { readonly: obj['readonly'] }),
-  }
-}

package/src/load-schema-module.test.ts

@@ -1,49 +0,0 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-
-import { loadSchemaModule } from './load-schema-module'
-
-describe('loadSchemaModule', () => {
-  let dir: string
-
-  beforeAll(async () => {
-    dir = await mkdtemp(join(tmpdir(), 'mjst-load-module-'))
-  })
-
-  afterAll(async () => {
-    await rm(dir, { recursive: true, force: true })
-  })
-
-  const write = async (name: string, contents: string): Promise<string> => {
-    const path = join(dir, name)
-    await writeFile(path, contents, 'utf-8')
-    return path
-  }
-
-  it('returns the default export when no export name is given', async () => {
-    const path = await write('default.mjs', 'export default { type: "string" }')
-    expect(await loadSchemaModule(path)).toEqual({ type: 'string' })
-  })
-
-  it('returns the sole named export when there is no default', async () => {
-    const path = await write('single.mjs', 'export const Schema = { type: "number" }')
-    expect(await loadSchemaModule(path)).toEqual({ type: 'number' })
-  })
-
-  it('returns the requested named export', async () => {
-    const path = await write('named.mjs', 'export const A = { type: "boolean" }; export const B = { type: "string" }')
-    expect(await loadSchemaModule(path, 'B')).toEqual({ type: 'string' })
-  })
-
-  it('throws when the requested export is missing', async () => {
-    const path = await write('missing.mjs', 'export const A = { type: "boolean" }')
-    await expect(loadSchemaModule(path, 'Nope')).rejects.toThrow(/no export named 'Nope'/)
-  })
-
-  it('throws when multiple exports are ambiguous', async () => {
-    const path = await write('ambiguous.mjs', 'export const A = {}; export const B = {}')
-    await expect(loadSchemaModule(path)).rejects.toThrow(/Specify which one to use with --export/)
-  })
-})

package/src/load-schema-module.ts

@@ -1,52 +0,0 @@
-import { pathToFileURL } from 'node:url'
-
-/**
- * Loads a schema authored as a JS/TS module and returns the exported schema value.
- *
- * Export selection, in order of preference:
- * 1. The export named by `exportName`, when provided (`--export <name>`).
- * 2. The module's default export.
- * 3. The sole named export, when there is exactly one.
- *
- * Anything else is ambiguous and throws, so the user can disambiguate explicitly
- * rather than have mjst guess wrong.
- *
- * Importing a `.ts` module requires a TypeScript-capable runtime (Bun, or Node
- * with a loader such as `tsx`). We surface a friendly hint when the import fails
- * for a `.ts` path so the cause is not a cryptic module-resolution error.
- */
-export const loadSchemaModule = async (modulePath: string, exportName?: string): Promise<unknown> => {
-  let mod: Record<string, unknown>
-
-  try {
-    mod = (await import(pathToFileURL(modulePath).href)) as Record<string, unknown>
-  } catch (error) {
-    const hint = modulePath.endsWith('.ts')
-      ? ' Importing a .ts schema requires a TypeScript-capable runtime — run mjst via `bunx`, or install `tsx` and run Node with `--import tsx`.'
-      : ''
-    throw new Error(`Failed to load schema module at ${modulePath}.${hint}\n${String(error)}`)
-  }
-
-  if (exportName) {
-    if (!(exportName in mod)) {
-      throw new Error(`Schema module ${modulePath} has no export named '${exportName}'.`)
-    }
-    return mod[exportName]
-  }
-
-  if ('default' in mod && mod['default'] !== undefined) {
-    return mod['default']
-  }
-
-  const namedKeys = Object.keys(mod).filter((key) => key !== 'default')
-
-  if (namedKeys.length === 1) {
-    const key = namedKeys[0]
-    if (key) return mod[key]
-  }
-
-  throw new Error(
-    `Schema module ${modulePath} exports ${namedKeys.length} values (${namedKeys.join(', ') || 'none'}). ` +
-      `Specify which one to use with --export <name>.`,
-  )
-}

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

@@ -1,303 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { parseCliArgs } from './parse-cli-args'
-
-describe('parse-cli-args', () => {
-  it('parses --schema and --outDir with space-separated values', () => {
-    const result = parseCliArgs(['--schema', 'path/to/schema.json', '--outDir', 'dist'])
-
-    expect(result).toEqual({
-      schema: 'path/to/schema.json',
-      outDir: 'dist',
-    })
-  })
-
-  it('parses --schema and --outDir with equals syntax', () => {
-    const result = parseCliArgs(['--schema=path/to/schema.json', '--outDir=dist'])
-
-    expect(result).toEqual({
-      schema: 'path/to/schema.json',
-      outDir: 'dist',
-    })
-  })
-
-  it('returns empty object when no flags are provided', () => {
-    const result = parseCliArgs([])
-
-    expect(result).toEqual({})
-  })
-
-  it('ignores unknown flags', () => {
-    const result = parseCliArgs(['--unknown', 'value', '--schema', 'schema.json'])
-
-    expect(result).toEqual({
-      schema: 'schema.json',
-    })
-  })
-
-  it('handles only --schema without --outDir', () => {
-    const result = parseCliArgs(['--schema', 'schema.json'])
-
-    expect(result).toEqual({
-      schema: 'schema.json',
-    })
-  })
-
-  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'])
-
-    expect(result).toEqual({
-      outDir: 'output',
-    })
-  })
-
-  it('does not treat a flag as a value for the previous flag', () => {
-    const result = parseCliArgs(['--schema', '--outDir', 'output'])
-
-    expect(result).toEqual({
-      outDir: 'output',
-    })
-  })
-
-  it('handles equals syntax with empty value', () => {
-    const result = parseCliArgs(['--schema=', '--outDir=dist'])
-
-    expect(result).toEqual({
-      schema: '',
-      outDir: 'dist',
-    })
-  })
-
-  it('parses --types-only boolean flag', () => {
-    const result = parseCliArgs(['--types-only'])
-
-    expect(result).toEqual({
-      typesOnly: true,
-    })
-  })
-
-  it('parses --types-only=true with equals syntax', () => {
-    const result = parseCliArgs(['--types-only=true'])
-
-    expect(result).toEqual({
-      typesOnly: true,
-    })
-  })
-
-  it('parses --types-only=false with equals syntax', () => {
-    const result = parseCliArgs(['--types-only=false'])
-
-    expect(result).toEqual({
-      typesOnly: false,
-    })
-  })
-
-  it('parses --types-only alongside other flags', () => {
-    const result = parseCliArgs(['--schema', 'schema.json', '--outDir', 'dist', '--types-only'])
-
-    expect(result).toEqual({
-      schema: 'schema.json',
-      outDir: 'dist',
-      typesOnly: true,
-    })
-  })
-
-  it('parses --build boolean flag', () => {
-    const result = parseCliArgs(['--build'])
-
-    expect(result).toEqual({
-      build: true,
-    })
-  })
-
-  it('parses --build=true with equals syntax', () => {
-    const result = parseCliArgs(['--build=true'])
-
-    expect(result).toEqual({
-      build: true,
-    })
-  })
-
-  it('parses --build=false with equals syntax', () => {
-    const result = parseCliArgs(['--build=false'])
-
-    expect(result).toEqual({
-      build: false,
-    })
-  })
-
-  it('parses --build alongside other flags', () => {
-    const result = parseCliArgs(['--schema', 'schema.json', '--outDir', 'dist', '--build'])
-
-    expect(result).toEqual({
-      schema: 'schema.json',
-      outDir: 'dist',
-      build: true,
-    })
-  })
-
-  it('parses --log-warnings boolean flag', () => {
-    const result = parseCliArgs(['--log-warnings'])
-
-    expect(result).toEqual({
-      logWarnings: true,
-    })
-  })
-
-  it('parses --log-warnings=true with equals syntax', () => {
-    const result = parseCliArgs(['--log-warnings=true'])
-
-    expect(result).toEqual({
-      logWarnings: true,
-    })
-  })
-
-  it('parses --log-warnings=false with equals syntax', () => {
-    const result = parseCliArgs(['--log-warnings=false'])
-
-    expect(result).toEqual({
-      logWarnings: false,
-    })
-  })
-
-  it('parses --log-warnings alongside other flags', () => {
-    const result = parseCliArgs(['--schema', 'schema.json', '--outDir', 'dist', '--log-warnings'])
-
-    expect(result).toEqual({
-      schema: 'schema.json',
-      outDir: 'dist',
-      logWarnings: true,
-    })
-  })
-
-  it('parses --strict boolean flag', () => {
-    const result = parseCliArgs(['--strict'])
-
-    expect(result).toEqual({
-      strict: true,
-    })
-  })
-
-  it('parses --strict=true with equals syntax', () => {
-    const result = parseCliArgs(['--strict=true'])
-
-    expect(result).toEqual({
-      strict: true,
-    })
-  })
-
-  it('parses --strict=false with equals syntax', () => {
-    const result = parseCliArgs(['--strict=false'])
-
-    expect(result).toEqual({
-      strict: false,
-    })
-  })
-
-  it('parses --strict alongside other flags', () => {
-    const result = parseCliArgs(['--schema', 'schema.json', '--outDir', 'dist', '--strict'])
-
-    expect(result).toEqual({
-      schema: 'schema.json',
-      outDir: 'dist',
-      strict: true,
-    })
-  })
-
-  it('parses --helpers package with space-separated value', () => {
-    const result = parseCliArgs(['--helpers', 'package'])
-    expect(result).toEqual({ helpers: 'package' })
-  })
-
-  it('parses --helpers=embedded with equals syntax', () => {
-    const result = parseCliArgs(['--helpers=embedded'])
-    expect(result).toEqual({ helpers: 'embedded' })
-  })
-
-  it('throws on an invalid --helpers value instead of silently ignoring it', () => {
-    expect(() => parseCliArgs(['--helpers', 'bogus', '--schema', 's.json'])).toThrow(/Invalid --helpers value "bogus"/)
-  })
-
-  it('throws on an invalid --helpers=foo value', () => {
-    expect(() => parseCliArgs(['--helpers=foo', '--schema', 's.json'])).toThrow(/package, embedded/)
-  })
-
-  it('parses a valid --input value', () => {
-    expect(parseCliArgs(['--input', 'zod'])).toEqual({ input: 'zod' })
-  })
-
-  it('throws on an invalid --input value, listing the valid formats', () => {
-    expect(() => parseCliArgs(['--input', 'typscript'])).toThrow(
-      /Invalid --input value "typscript".*json, typebox, zod, valibot, effect/,
-    )
-  })
-
-  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 })
-  })
-
-  it('parses --banner with no value as true (default message)', () => {
-    expect(parseCliArgs(['--banner'])).toEqual({ banner: true })
-  })
-
-  it('parses --banner=true and --banner=false', () => {
-    expect(parseCliArgs(['--banner=true'])).toEqual({ banner: true })
-    expect(parseCliArgs(['--banner=false'])).toEqual({ banner: false })
-  })
-
-  it('parses --banner=<text> as a custom message string', () => {
-    expect(parseCliArgs(['--banner=Do not edit this file.'])).toEqual({ banner: 'Do not edit this file.' })
-  })
-
-  it('parses --banner <text> (space-separated) as a custom message string', () => {
-    expect(parseCliArgs(['--banner', 'Do not edit this file.'])).toEqual({ banner: 'Do not edit this file.' })
-  })
-
-  it('parses --banner followed by a flag as true (default message)', () => {
-    expect(parseCliArgs(['--banner', '--out-dir', 'dist'])).toEqual({ banner: true, outDir: 'dist' })
-  })
-})