@gabrielbryk/json-schema-to-zod 2.7.2

package/dist/types/utils/cliTools.d.ts

@@ -0,0 +1,28 @@
+export type Param = {
+    shorthand?: string;
+    description?: string;
+    required?: boolean | string | undefined;
+} & ({
+    value?: "boolean";
+} | {
+    value: "number";
+} | {
+    value: "string";
+} | {
+    value: {
+        [key: number]: string;
+    };
+});
+export type Params = {
+    [name: string]: Param;
+};
+type InferReturnType<T extends Params> = {
+    [name in keyof T]: (T[name]["value"] extends "number" ? number : T[name]["value"] extends "string" ? string : T[name]["value"] extends {
+        [key: number]: string;
+    } ? T[name]["value"][number] : T[name]["value"] extends never ? boolean : boolean) | (T[name]["required"] extends string | true ? never : undefined);
+};
+export declare function parseArgs<T extends Params>(params: T, args: string[], help?: boolean | string): InferReturnType<T>;
+export declare function parseOrReadJSON(jsonOrPath: string): unknown;
+export declare function readPipe(): Promise<string>;
+export declare function printParams(params: Record<string, Param>): void;
+export {};

package/dist/types/utils/half.d.ts

@@ -0,0 +1 @@
+export declare const half: <T>(arr: T[]) => [T[], T[]];

package/dist/types/utils/jsdocs.d.ts

@@ -0,0 +1,3 @@
+import { JsonSchemaObject } from "../Types";
+export declare const expandJsdocs: (jsdocs: string) => string;
+export declare const addJsdocs: (schema: JsonSchemaObject, parsed: string) => string;

package/dist/types/utils/omit.d.ts

@@ -0,0 +1 @@
+export declare const omit: <T extends object, K extends keyof T>(obj: T, ...keys: K[]) => Omit<T, K>;

package/dist/types/utils/withMessage.d.ts

@@ -0,0 +1,10 @@
+import { JsonSchemaObject } from "../Types.js";
+type Opener = string;
+type MessagePrefix = string;
+type Closer = string;
+type Builder = [Opener, Closer] | [Opener, MessagePrefix, Closer];
+export declare function withMessage(schema: JsonSchemaObject, key: string, get: (props: {
+    value: unknown;
+    json: string;
+}) => Builder | void): string;
+export {};

package/dist/types/zodToJsonSchema.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Post-processor for Zod's z.toJSONSchema() output.
+ *
+ * When `preserveJsonSchemaForRoundTrip` was used during JSON Schema → Zod conversion,
+ * this function reconstructs the original JSON Schema features from the stored __jsonSchema meta.
+ *
+ * Usage:
+ * 1. Convert JSON Schema to Zod code with `preserveJsonSchemaForRoundTrip: true`
+ * 2. Evaluate the Zod code to get a schema instance
+ * 3. Call Zod's `z.toJSONSchema(schema)` to get JSON Schema output
+ * 4. Pass that output to `reconstructJsonSchema()` to restore preserved features
+ *
+ * Handles:
+ * - patternProperties (stored in __jsonSchema.patternProperties)
+ * - if/then/else conditionals (stored in __jsonSchema.conditional)
+ */
+type JsonSchemaObject = Record<string, unknown>;
+/**
+ * Recursively process a JSON Schema to reconstruct original features from __jsonSchema meta.
+ *
+ * Handles special cases:
+ * - allOf[object, {__jsonSchema: {conditional: ...}}] -> object with if/then/else at top level
+ * - patternProperties meta -> patternProperties at current level
+ */
+export declare function reconstructJsonSchema(schema: JsonSchemaObject): JsonSchemaObject;
+export {};

package/jest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+};

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@gabrielbryk/json-schema-to-zod",
+  "version": "2.7.2",
+  "description": "Converts JSON schema objects or files into Zod schemas",
+  "types": "./dist/types/index.d.ts",
+  "bin": "./dist/cjs/cli.js",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "exports": {
+    "import": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/esm/index.js"
+    },
+    "require": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "c8": {
+    "exclude": [
+      "dist",
+      "createIndex.ts",
+      "jest.config.js",
+      "postcjs.js",
+      "postesm.js",
+      "test"
+    ]
+  },
+  "keywords": [
+    "zod",
+    "json",
+    "schema",
+    "converter",
+    "cli"
+  ],
+  "author": "Stefan Terdell",
+  "contributors": [
+    "Chen (https://github.com/werifu)",
+    "Nuno Carduso (https://github.com/ncardoso-barracuda)",
+    "Lars Strojny (https://github.com/lstrojny)",
+    "Navtoj Chahal (https://github.com/navtoj)",
+    "Ben McCann (https://github.com/benmccann)",
+    "Dmitry Zakharov (https://github.com/DZakh)",
+    "Michel Turpin (https://github.com/grimly)",
+    "David Barratt (https://github.com/davidbarratt)",
+    "pevisscher (https://github.com/pevisscher)",
+    "Aidin Abedi (https://github.com/aidinabedi)",
+    "Brett Zamir (https://github.com/brettz9)",
+    "vForgeOne (https://github.com/vforgeone)",
+    "Adrian Ordonez (https://github.com/adrianord)",
+    "Jonas Reucher (https://github.com/Mantls)",
+    "Nicolas Forstner (https://github.com/nlsfnr)",
+    "Jordyn https://github.com/ColourfulMelon"
+  ],
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gabrielbryk/json-schema-to-zod"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/json-schema": "^7.0.15",
+    "@types/node": "^20.9.0",
+    "fast-diff": "^1.3.0",
+    "js-yaml": "^4.1.0",
+    "rimraf": "^5.0.5",
+    "tsx": "^4.1.1",
+    "typescript": "^5.2.2",
+    "zod": "^4.1.13"
+  },
+  "scripts": {
+    "build:types": "tsc -p tsconfig.types.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json && node postcjs.js",
+    "build:esm": "tsc -p tsconfig.esm.json && node postesm.js",
+    "build": "pnpm gen && pnpm test && rimraf ./dist && pnpm build:types && pnpm build:cjs && pnpm build:esm",
+    "dry": "pnpm build && pnpm publish --dry-run",
+    "dev": "tsx watch test/index.ts",
+    "gen": "tsx ./createIndex.ts",
+    "test": "tsx test/index.ts"
+  }
+}

package/postcjs.js

@@ -0,0 +1 @@
+require("fs").writeFileSync("./dist/cjs/package.json", '{"type":"commonjs"}', "utf-8")

package/postesm.js

@@ -0,0 +1 @@
+require("fs").writeFileSync("./dist/esm/package.json", '{"type":"module"}', "utf-8")

package/scripts/generateWorkflowSchema.ts

@@ -0,0 +1,82 @@
+import { readFileSync, mkdirSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import yaml from "js-yaml";
+import jsonSchemaToZod from "../src/index.js";
+
+const WORKFLOW_SOURCE = "test/fixtures/workflow.yaml";
+const OUTPUT_DIR = "test/output/workflow";
+const SCHEMA_DIR = join(OUTPUT_DIR, "schemas");
+const OUTPUT_INDEX = join(OUTPUT_DIR, "index.ts");
+
+function main() {
+  const schema = yaml.load(readFileSync(WORKFLOW_SOURCE, "utf8")) as any;
+
+  const generated = jsonSchemaToZod(schema, {
+    module: "esm",
+    name: "workflowSchema",
+    exportRefs: true,
+  });
+
+  const lines = generated
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .filter((line, idx, arr) => !(line === "" && arr[idx - 1] === ""));
+
+  const importLines = lines.filter((line) => line.startsWith("import "));
+
+  // Extract blocks: export const Name = ... (until next export const or end)
+  const blocks: { name: string; lines: string[]; exported: boolean }[] = [];
+  let current: { name: string; lines: string[]; exported: boolean } | null = null;
+
+  for (const line of lines) {
+    const match = line.match(/^(export\s+)?const ([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(.*)/);
+    if (match) {
+      if (current) blocks.push(current);
+      const [, expKeyword, name] = match;
+      current = { name, exported: Boolean(expKeyword), lines: [line] };
+    } else if (current) {
+      current.lines.push(line);
+    }
+  }
+  if (current) blocks.push(current);
+
+  const names = new Set(blocks.map((b) => b.name));
+
+  mkdirSync(SCHEMA_DIR, { recursive: true });
+
+  for (const block of blocks) {
+    const normalizedLines = block.lines.map((l, idx) =>
+      idx === 0 ? l.replace(/^\s*(export\s+)?const\s+/, "export const ") : l,
+    );
+    const content = normalizedLines.join("\n");
+    const deps = Array.from(names)
+      .filter((n) => n !== block.name)
+      .filter((n) => new RegExp(`\\b${n}\\b`).test(content));
+
+    const importDepLines = deps.map(
+      (dep) => `import { ${dep} } from "./${dep}.js"`,
+    );
+
+    const fileContent = [
+      ...importLines,
+      ...importDepLines,
+      content,
+      "",
+    ].join("\n");
+
+    writeFileSync(join(SCHEMA_DIR, `${block.name}.ts`), fileContent);
+  }
+
+  // index exports all and the root schema
+  const exportLines = Array.from(
+    new Set(
+      blocks.map((b) => `export { ${b.name} } from "./schemas/${b.name}.js"`),
+    ),
+  );
+
+  writeFileSync(OUTPUT_INDEX, exportLines.join("\n") + "\n");
+
+  console.log(`Generated per-schema files in ${SCHEMA_DIR} and index at ${OUTPUT_INDEX}`);
+}
+
+main();