@amritk/mjst 0.4.0 → 0.5.1

package/dist/load-schema-module.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 declare const loadSchemaModule: (modulePath: string, exportName?: string) => Promise<unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/mjst",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "type": "module",
   "license": "MIT",
@@ -42,11 +42,12 @@
     "generate-readme": "bun run ./scripts/generate-readme.ts"
   },
   "dependencies": {
-    "@amritk/generate-parsers": "workspace:*",
-    "@amritk/generate-markdown": "workspace:*",
-    "@amritk/helpers": "workspace:*"
+    "@amritk/adapters": "0.2.1",
+    "@amritk/generate-parsers": "0.4.0",
+    "@amritk/generate-markdown": "0.2.1",
+    "@amritk/helpers": "0.4.0"
   },
   "devDependencies": {
-    "json-schema-typed": "catalog:"
+    "json-schema-typed": "^8.0.1"
   }
 }

package/src/cli-config.ts

@@ -1,10 +1,22 @@
+import type { SourceFormat } from '@amritk/adapters/source-format'
+
 /**
  * Configuration for the CLI tool.
  * These properties map 1:1 with CLI flags and config file keys.
  */
 export type CliConfig = {
-  /** Path to the JSON Schema file to process. */
+  /** Path to the schema to process — a JSON Schema file, or a JS/TS module when `input` is set. */
   readonly schema: string
+  /**
+   * The source format of the schema. Defaults to `'json'` (a plain JSON Schema file).
+   * Any other format loads `schema` as a module and converts it via the matching adapter.
+   */
+  readonly input?: SourceFormat
+  /**
+   * Which export of the schema module to use when `input` is not `'json'`.
+   * Defaults to the default export, or the sole named export when there is exactly one.
+   */
+  readonly export?: string
   /** Output directory for generated TypeScript files. */
   readonly outDir: string
   /**

package/src/cli.ts

@@ -3,6 +3,7 @@ import { execFile } from 'node:child_process'
 import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises'
 import { dirname, join, resolve } from 'node:path'
 import { promisify } from 'node:util'
+import { getAdapter } from '@amritk/adapters/get-adapter'
 import { buildSchema } from '@amritk/generate-parsers'
 import { deriveRootTypeName } from '@amritk/helpers/derive-root-type-name'
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
@@ -11,6 +12,7 @@ const execFileAsync = promisify(execFile)
 
 import { detectHelpersMode } from './detect-helpers-mode'
 import { loadConfig } from './load-config'
+import { loadSchemaModule } from './load-schema-module'
 import { parseCliArgs } from './parse-cli-args'
 
 /**
@@ -55,8 +57,18 @@ const run = async (): Promise<void> => {
   }
 
   const schemaPath = resolve(config.schema)
-  const raw = await readFile(schemaPath, 'utf-8')
-  const schema: unknown = JSON.parse(raw)
+  const inputFormat = config.input ?? 'json'
+
+  // 'json' is read straight off disk; every other format loads the schema as a
+  // module and runs it through its adapter to produce a JSON Schema.
+  let schema: unknown
+  if (inputFormat === 'json') {
+    schema = JSON.parse(await readFile(schemaPath, 'utf-8'))
+  } else {
+    console.log(`Input format: ${inputFormat}`)
+    const source = await loadSchemaModule(schemaPath, config.export)
+    schema = await getAdapter(inputFormat).toJSONSchema(source)
+  }
 
   const outputDir = resolve(config.outDir)
   await mkdir(outputDir, { recursive: true })

package/src/load-config.ts

@@ -1,8 +1,14 @@
 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).
@@ -21,6 +27,8 @@ export const loadConfig = async (configPath: string): Promise<Partial<CliConfig>
   return {
     ...(typeof obj['schema'] === 'string' && { schema: obj['schema'] }),
     ...(typeof obj['outDir'] === 'string' && { outDir: obj['outDir'] }),
+    ...(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'] }),

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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,52 @@
+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.ts

@@ -1,5 +1,9 @@
+import type { SourceFormat } from '@amritk/adapters/source-format'
+
 import type { CliConfig } from './cli-config'
 
+const SOURCE_FORMATS: readonly SourceFormat[] = ['json', 'typebox', 'zod', 'valibot', 'effect']
+
 /**
  * Parses command-line arguments into a partial CLI config.
  * Supports --schema, --outDir, and --types-only flags with either `--flag value` or `--flag=value` syntax.
@@ -10,6 +14,8 @@ export const parseCliArgs = (args: readonly string[]): Partial<CliConfig> => {
   const config: {
     schema?: string
     outDir?: string
+    input?: SourceFormat
+    export?: string
     typesOnly?: boolean
     build?: boolean
     logWarnings?: boolean
@@ -22,6 +28,9 @@ export const parseCliArgs = (args: readonly string[]): Partial<CliConfig> => {
     return undefined
   }
 
+  const parseInputValue = (value: string): SourceFormat | undefined =>
+    (SOURCE_FORMATS as readonly string[]).includes(value) ? (value as SourceFormat) : undefined
+
   for (let i = 0; i < args.length; i++) {
     const arg = args[i]
 
@@ -39,6 +48,11 @@ export const parseCliArgs = (args: readonly string[]): Partial<CliConfig> => {
         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'
@@ -71,6 +85,23 @@ export const parseCliArgs = (args: readonly string[]): Partial<CliConfig> => {
         config.outDir = value
         i++
       }
+    } else if (arg === '--input') {
+      const value = args[i + 1]
+
+      if (value && !value.startsWith('--')) {
+        const parsed = parseInputValue(value)
+        if (parsed) {
+          config.input = parsed
+          i++
+        }
+      }
+    } else if (arg === '--export') {
+      const value = args[i + 1]
+
+      if (value && !value.startsWith('--')) {
+        config.export = value
+        i++
+      }
     } else if (arg === '--types-only') {
       // Boolean flag: presence alone enables it, no value needed
       config.typesOnly = true