@amritk/mjst 0.14.8 → 0.15.0

package/AI.md

@@ -36,8 +36,11 @@ mjst compile-api ./routes.ts --out ./dist/handler.ts
 4. **The root type name comes from the schema `title`/filename**, not
    `Document`. Override with `--root-type <name>` (single-schema only; rejected
    with `--schema-dir`).
-5. **Non-JSON input** (`--input typebox|zod|valibot|effect`) works for a single
-   `--schema`; `--schema-dir` only accepts `json`.
+5. **Non-JSON input** (`--input typebox|zod|valibot|effect|avro`) works for a
+   single `--schema`; `--schema-dir` only accepts `json`. The library formats
+   point `--schema` at a JS/TS **module**; `avro` points it at a `.avsc` JSON
+   document, which is read as data (no `import()`, so `--export` does not
+   apply).
 
 ## Common flags
 

package/README.md

@@ -295,7 +295,7 @@ The exit code is `0` on success, `1` when compilation fails (unloadable module,
 <td align="center"><code>"json"</code></td>
 </tr>
 <tr>
-<td colspan="4">Source format of the schema. 'json' (default) reads a JSON Schema file directly. Any other format loads 'schema' as a module and converts it to JSON Schema with the matching adapter. Supported: 'typebox', 'zod' (zod v4+), 'valibot' (with @valibot/to-json-schema), and 'effect' — each requires the corresponding library installed in your project.<br><strong>Allowed:</strong> <code>"json"</code>, <code>"typebox"</code>, <code>"zod"</code>, <code>"valibot"</code>, <code>"effect"</code></td>
+<td colspan="4">Source format of the schema. 'json' (default) reads a JSON Schema file directly. 'avro' reads an Apache Avro '.avsc' JSON document and converts it, needing no extra library. Any other format loads 'schema' as a module and converts it to JSON Schema with the matching adapter. Supported: 'typebox', 'zod' (zod v4+), 'valibot' (with @valibot/to-json-schema), and 'effect' — each requires the corresponding library installed in your project.<br><strong>Allowed:</strong> <code>"json"</code>, <code>"typebox"</code>, <code>"zod"</code>, <code>"valibot"</code>, <code>"effect"</code>, <code>"avro"</code></td>
 </tr>
 <tr>
 <td>📦 <code>export</code></td>
@@ -304,7 +304,7 @@ The exit code is `0` on success, `1` when compilation fails (unloadable module,
 <td align="center"></td>
 </tr>
 <tr>
-<td colspan="4">Which export of the schema module to use when 'input' is not 'json'. Defaults to the default export, or the sole named export when the module has exactly one.</td>
+<td colspan="4">Which export of the schema module to use when 'input' names a module format (anything but 'json' and 'avro', which are read as data). Defaults to the default export, or the sole named export when the module has exactly one.</td>
 </tr>
 <tr>
 <td>📁 <code>outDir</code></td>

package/dist/cli-config.d.ts

@@ -16,11 +16,15 @@ export type CliConfig = {
     readonly schemaDir?: 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.
+     *
+     * `'avro'` reads `schema` as a `.avsc` JSON document and converts it — no module
+     * is loaded, so `export` does not apply. Every other format loads `schema` as a
+     * module and converts the exported value via the matching adapter.
      */
     readonly input?: SourceFormat;
     /**
-     * Which export of the schema module to use when `input` is not `'json'`.
+     * Which export of the schema module to use when `input` names a module format
+     * (anything but `'json'` and `'avro'`, which are parsed as data).
      * Defaults to the default export, or the sole named export when there is exactly one.
      */
     readonly export?: string;

package/dist/help-text.d.ts

@@ -4,4 +4,4 @@
  * documents these flags (config.schema.json) is not shipped in the published
  * package; the help-text test cross-checks that every flag is listed.
  */
-export declare const HELP_TEXT = "mjst \u2014 generate TypeScript parsers and type definitions from JSON Schemas\n\nUsage:\n  mjst --schema <path> --out-dir <dir> [options]\n  mjst --schema-dir <dir> --out-dir <dir> [options]\n  mjst --schema <path> --out-file <file> --types-only [options]\n\nSubcommands (each with its own flags and --help):\n  mjst lint <files>                       Lint JSON/YAML documents against a ruleset\n  mjst compile-api <module> --out <file>  Compile @amritk/api route contracts into a fetch-handler module\n\nInput:\n  --schema <path>       Schema to process: a JSON Schema file, or a module when --input is set\n  --schema-dir <dir>    Directory of JSON Schemas, processed recursively (instead of --schema)\n  --input <format>      Schema source format: json (default), typebox, zod, valibot, effect\n  --export <name>       Which export of the schema module to use when --input is not json\n\nOutput:\n  --out-dir <dir>       Output directory for the generated files\n  --out-file <file>     Single-file output instead of a directory (requires --types-only)\n  --types-only          Generate type definitions only, without parser functions\n  --validators          Also emit validateX/isX validators into a validators/ subdir\n  --examples            Also emit fast-check arbitraries + example values under examples/\n  --build               Compile the generated files to .js/.d.ts (implies --import-ext js)\n  --force               Overwrite pre-existing files in the output destination\n  --import-ext <ext>    Extension on generated relative imports: ts (default) or js\n  --helpers <mode>      Runtime helpers: package or embedded (default: auto-detect from package.json)\n  --root-type <name>    Root type name for a single --schema run (default: schema title or filename)\n  --type-suffix <s>     Suffix appended to every $ref-derived type name\n  --banner [text]       Prepend a header comment to every generated file\n  --readonly            Emit deeply readonly type definitions\n\nValidation:\n  --strict              Throw on type/shape mismatches instead of coercing to defaults\n  --strip-unknown       Silently drop undeclared input keys at every nesting level\n  --case-insensitive    Normalize mis-cased enum/const strings to their exact casing\n  --log-warnings        console.warn on input keys not declared in the schema\n\nReference resolution:\n  --resolve-remote      Fetch http(s) $refs while resolving cross-file/remote refs (off by default)\n  --allowed-hosts <h>   Restrict remote $ref fetches to these hosts (comma-separated; implies --resolve-remote)\n  --allow-private-hosts Permit remote $refs to private/loopback hosts (SSRF guard, off by default)\n  --allowed-roots <d>   Extra directories a local $ref may resolve into, on top of the schema's own\n                        (comma-separated; relative to the current directory)\n\nMisc:\n  --config <path>       JSON config file with the same keys; CLI flags take precedence\n  --version, -v         Print the CLI version\n  --help, -h            Print this help\n\nDocs: https://github.com/amritk/mjst/tree/main/packages/cli#readme\n";
+export declare const HELP_TEXT = "mjst \u2014 generate TypeScript parsers and type definitions from JSON Schemas\n\nUsage:\n  mjst --schema <path> --out-dir <dir> [options]\n  mjst --schema-dir <dir> --out-dir <dir> [options]\n  mjst --schema <path> --out-file <file> --types-only [options]\n\nSubcommands (each with its own flags and --help):\n  mjst lint <files>                       Lint JSON/YAML documents against a ruleset\n  mjst compile-api <module> --out <file>  Compile @amritk/api route contracts into a fetch-handler module\n\nInput:\n  --schema <path>       Schema to process: a JSON Schema file, or a module when --input is set\n  --schema-dir <dir>    Directory of JSON Schemas, processed recursively (instead of --schema)\n  --input <format>      Schema source format: json (default), typebox, zod, valibot, effect, avro\n  --export <name>       Which export of the schema module to use when --input names a module format\n\nOutput:\n  --out-dir <dir>       Output directory for the generated files\n  --out-file <file>     Single-file output instead of a directory (requires --types-only)\n  --types-only          Generate type definitions only, without parser functions\n  --validators          Also emit validateX/isX validators into a validators/ subdir\n  --examples            Also emit fast-check arbitraries + example values under examples/\n  --build               Compile the generated files to .js/.d.ts (implies --import-ext js)\n  --force               Overwrite pre-existing files in the output destination\n  --import-ext <ext>    Extension on generated relative imports: ts (default) or js\n  --helpers <mode>      Runtime helpers: package or embedded (default: auto-detect from package.json)\n  --root-type <name>    Root type name for a single --schema run (default: schema title or filename)\n  --type-suffix <s>     Suffix appended to every $ref-derived type name\n  --banner [text]       Prepend a header comment to every generated file\n  --readonly            Emit deeply readonly type definitions\n\nValidation:\n  --strict              Throw on type/shape mismatches instead of coercing to defaults\n  --strip-unknown       Silently drop undeclared input keys at every nesting level\n  --case-insensitive    Normalize mis-cased enum/const strings to their exact casing\n  --log-warnings        console.warn on input keys not declared in the schema\n\nReference resolution:\n  --resolve-remote      Fetch http(s) $refs while resolving cross-file/remote refs (off by default)\n  --allowed-hosts <h>   Restrict remote $ref fetches to these hosts (comma-separated; implies --resolve-remote)\n  --allow-private-hosts Permit remote $refs to private/loopback hosts (SSRF guard, off by default)\n  --allowed-roots <d>   Extra directories a local $ref may resolve into, on top of the schema's own\n                        (comma-separated; relative to the current directory)\n\nMisc:\n  --config <path>       JSON config file with the same keys; CLI flags take precedence\n  --version, -v         Print the CLI version\n  --help, -h            Print this help\n\nDocs: https://github.com/amritk/mjst/tree/main/packages/cli#readme\n";

package/dist/help-text.js

@@ -12,8 +12,8 @@ Subcommands (each with its own flags and --help):
 Input:
   --schema <path>       Schema to process: a JSON Schema file, or a module when --input is set
   --schema-dir <dir>    Directory of JSON Schemas, processed recursively (instead of --schema)
-  --input <format>      Schema source format: json (default), typebox, zod, valibot, effect
-  --export <name>       Which export of the schema module to use when --input is not json
+  --input <format>      Schema source format: json (default), typebox, zod, valibot, effect, avro
+  --export <name>       Which export of the schema module to use when --input names a module format
 
 Output:
   --out-dir <dir>       Output directory for the generated files

package/dist/load-config.js

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { validateConfig } from "./validate-config.js";
-const SOURCE_FORMATS = ["json", "typebox", "zod", "valibot", "effect"];
+const SOURCE_FORMATS = ["json", "typebox", "zod", "valibot", "effect", "avro"];
 const isSourceFormat = (value) => typeof value === "string" && SOURCE_FORMATS.includes(value);
 const isHelpersMode = (value) => value === "package" || value === "embedded";
 const isImportExt = (value) => value === "js" || value === "ts";

package/dist/load-schema.d.ts

@@ -10,5 +10,13 @@ import type { CliConfig } from './cli-config.js';
  * `@amritk/resolve-refs`, inlining every external target into a single document.
  * Any resolve failures are surfaced as a CLI error rather than silently yielding
  * a half-resolved schema.
+ *
+ * Avro splits the difference, and is the reason this is not a plain
+ * json/not-json branch: a `.avsc` is a JSON *document*, not a module exporting a
+ * value, so it is read and parsed like a JSON Schema and only the conversion is
+ * delegated to the adapter. Nothing is imported, which also means an Avro schema
+ * — unlike a Zod or TypeBox one — never reaches module evaluation. Its `$ref`s
+ * are Avro names resolved by the adapter, not JSON Pointers, so the resolver
+ * does not run over it either.
  */
 export declare const loadSchema: (config: Partial<CliConfig>, schemaPath: string) => Promise<unknown>;

package/dist/load-schema.js

@@ -32,6 +32,10 @@ const loadSchema = async (config, schemaPath) => {
     return resolved;
   }
   console.log(`Input format: ${inputFormat}`);
+  if (inputFormat === "avro") {
+    const source2 = JSON.parse(await readFile(schemaPath, "utf-8"));
+    return getAdapter(inputFormat).toJSONSchema(source2);
+  }
   const source = await loadSchemaModule(schemaPath, config.export);
   return getAdapter(inputFormat).toJSONSchema(source);
 };

package/dist/parse-cli-args.js

@@ -1,4 +1,4 @@
-const SOURCE_FORMATS = ["json", "typebox", "zod", "valibot", "effect"];
+const SOURCE_FORMATS = ["json", "typebox", "zod", "valibot", "effect", "avro"];
 const LIST_KEYS = /* @__PURE__ */ new Set(["allowedHosts", "allowedRoots"]);
 const BOOLEAN_KEYS = /* @__PURE__ */ new Set([
   "typesOnly",

package/dist/validate-config.d.ts

@@ -30,7 +30,8 @@ export declare const CONFIG_KEYS: Record<string, ConfigKeySpec>;
  * file has to be at least as strict as the flags it stands in for.
  *
  * Note what this does *not* buy: a config is still trusted code. `schema` plus a
- * non-`json` `input` makes `load-schema-module.ts` `import()` whatever path the
+ * module-loading `input` (every format except `json` and `avro`, both of which
+ * are parsed as data) makes `load-schema-module.ts` `import()` whatever path the
  * config names, so an untrusted `mjst.config.json` still reaches arbitrary module
  * evaluation. Validating the shape does not change that — do not run mjst against
  * a config file you would not run as a script.

package/dist/validate-config.js

@@ -1,7 +1,8 @@
+import { readKey } from "@amritk/helpers/read-key";
 const CONFIG_KEYS = {
   schema: { type: "string" },
   schemaDir: { type: "string" },
-  input: { type: "string", enum: ["json", "typebox", "zod", "valibot", "effect"] },
+  input: { type: "string", enum: ["json", "typebox", "zod", "valibot", "effect", "avro"] },
   export: { type: "string" },
   outDir: { type: "string" },
   outFile: { type: "string" },
@@ -49,7 +50,7 @@ const validateConfig = (parsed, configPath) => {
   const problems = [];
   const knownKeys = Object.keys(CONFIG_KEYS);
   for (const [key, value] of Object.entries(parsed)) {
-    const spec = CONFIG_KEYS[key];
+    const spec = readKey(CONFIG_KEYS, key);
     if (!spec) {
       if (key === "$schema")
         continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/mjst",
-  "version": "0.14.8",
+  "version": "0.15.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "type": "module",
   "engines": {
@@ -49,21 +49,21 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@amritk/adapters": "^0.4.3",
-    "@amritk/api": "^0.15.1",
-    "@amritk/generate-examples": "^0.6.3",
-    "@amritk/generate-parsers": "^0.19.3",
-    "@amritk/generate-validators": "^0.13.0",
-    "@amritk/helpers": "^0.15.3",
-    "@amritk/lint": "^0.4.7",
-    "@amritk/resolve-refs": "^0.6.0",
-    "@amritk/yaml": "^0.7.1",
+    "@amritk/adapters": "^0.5.0",
+    "@amritk/api": "^0.16.0",
+    "@amritk/generate-examples": "^0.7.0",
+    "@amritk/generate-parsers": "^0.19.5",
+    "@amritk/generate-validators": "^0.14.0",
+    "@amritk/helpers": "^0.16.0",
+    "@amritk/lint": "^0.5.0",
+    "@amritk/resolve-refs": "^0.7.1",
+    "@amritk/yaml": "^0.7.2",
     "fast-glob": "^3.3.2",
     "json-schema-typed": "^8.0.1",
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@amritk/generate-markdown": "^0.4.8",
+    "@amritk/generate-markdown": "^0.5.0",
     "@types/yargs": "^17.0.33"
   }
 }