@atom8n/json-schema-to-zod 1.6.8 → 1.7.0

package/dist/esm/parsers/parse-one-of.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { parseSchema } from './parse-schema';
+export const parseOneOf = (jsonSchema, refs) => {
+    if (!jsonSchema.oneOf.length) {
+        return z.any();
+    }
+    if (jsonSchema.oneOf.length === 1) {
+        return parseSchema(jsonSchema.oneOf[0], {
+            ...refs,
+            path: [...refs.path, 'oneOf', 0],
+        });
+    }
+    return z.any().superRefine((x, ctx) => {
+        const schemas = jsonSchema.oneOf.map((schema, i) => parseSchema(schema, {
+            ...refs,
+            path: [...refs.path, 'oneOf', i],
+        }));
+        const unionErrors = schemas.reduce((errors, schema) => ((result) => (result.error ? [...errors, result.error] : errors))(schema.safeParse(x)), []);
+        if (schemas.length - unionErrors.length !== 1) {
+            ctx.addIssue({
+                path: ctx.path,
+                code: 'invalid_union',
+                unionErrors,
+                message: 'Invalid input: Should pass single schema',
+            });
+        }
+    });
+};

package/dist/esm/parsers/parse-schema.js

@@ -0,0 +1,122 @@
+import * as z from 'zod';
+import { parseAllOf } from './parse-all-of';
+import { parseAnyOf } from './parse-any-of';
+import { parseArray } from './parse-array';
+import { parseBoolean } from './parse-boolean';
+import { parseConst } from './parse-const';
+import { parseDefault } from './parse-default';
+import { parseEnum } from './parse-enum';
+import { parseIfThenElse } from './parse-if-then-else';
+import { parseMultipleType } from './parse-multiple-type';
+import { parseNot } from './parse-not';
+import { parseNull } from './parse-null';
+import { parseNullable } from './parse-nullable';
+import { parseNumber } from './parse-number';
+import { parseObject } from './parse-object';
+import { parseOneOf } from './parse-one-of';
+import { parseString } from './parse-string';
+import { its } from '../utils/its';
+const addDescribes = (jsonSchema, zodSchema) => {
+    if (jsonSchema.description) {
+        zodSchema = zodSchema.describe(jsonSchema.description);
+    }
+    return zodSchema;
+};
+const addDefaults = (jsonSchema, zodSchema) => {
+    if (jsonSchema.default !== undefined) {
+        zodSchema = zodSchema.default(jsonSchema.default);
+    }
+    return zodSchema;
+};
+const addAnnotations = (jsonSchema, zodSchema) => {
+    if (jsonSchema.readOnly) {
+        zodSchema = zodSchema.readonly();
+    }
+    return zodSchema;
+};
+const selectParser = (schema, refs) => {
+    if (its.a.nullable(schema)) {
+        return parseNullable(schema, refs);
+    }
+    else if (its.an.object(schema)) {
+        return parseObject(schema, refs);
+    }
+    else if (its.an.array(schema)) {
+        return parseArray(schema, refs);
+    }
+    else if (its.an.anyOf(schema)) {
+        return parseAnyOf(schema, refs);
+    }
+    else if (its.an.allOf(schema)) {
+        return parseAllOf(schema, refs);
+    }
+    else if (its.a.oneOf(schema)) {
+        return parseOneOf(schema, refs);
+    }
+    else if (its.a.not(schema)) {
+        return parseNot(schema, refs);
+    }
+    else if (its.an.enum(schema)) {
+        return parseEnum(schema); //<-- needs to come before primitives
+    }
+    else if (its.a.const(schema)) {
+        return parseConst(schema);
+    }
+    else if (its.a.multipleType(schema)) {
+        return parseMultipleType(schema, refs);
+    }
+    else if (its.a.primitive(schema, 'string')) {
+        return parseString(schema);
+    }
+    else if (its.a.primitive(schema, 'number') || its.a.primitive(schema, 'integer')) {
+        return parseNumber(schema);
+    }
+    else if (its.a.primitive(schema, 'boolean')) {
+        return parseBoolean(schema);
+    }
+    else if (its.a.primitive(schema, 'null')) {
+        return parseNull(schema);
+    }
+    else if (its.a.conditional(schema)) {
+        return parseIfThenElse(schema, refs);
+    }
+    else {
+        return parseDefault(schema);
+    }
+};
+export const parseSchema = (jsonSchema, refs = { seen: new Map(), path: [] }, blockMeta) => {
+    if (typeof jsonSchema !== 'object')
+        return jsonSchema ? z.any() : z.never();
+    if (refs.parserOverride) {
+        const custom = refs.parserOverride(jsonSchema, refs);
+        if (custom instanceof z.ZodType) {
+            return custom;
+        }
+    }
+    let seen = refs.seen.get(jsonSchema);
+    if (seen) {
+        if (seen.r !== undefined) {
+            return seen.r;
+        }
+        if (refs.depth === undefined || seen.n >= refs.depth) {
+            return z.any();
+        }
+        seen.n += 1;
+    }
+    else {
+        seen = { r: undefined, n: 0 };
+        refs.seen.set(jsonSchema, seen);
+    }
+    let parsedZodSchema = selectParser(jsonSchema, refs);
+    if (!blockMeta) {
+        if (!refs.withoutDescribes) {
+            parsedZodSchema = addDescribes(jsonSchema, parsedZodSchema);
+        }
+        if (!refs.withoutDefaults) {
+            parsedZodSchema = addDefaults(jsonSchema, parsedZodSchema);
+        }
+        parsedZodSchema = addAnnotations(jsonSchema, parsedZodSchema);
+    }
+    seen.r = parsedZodSchema;
+    return parsedZodSchema;
+};

package/dist/esm/parsers/parse-string.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { extendSchemaWithMessage } from '../utils/extend-schema';
+export const parseString = (jsonSchema) => {
+    let zodSchema = z.string();
+    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'format', (zs, format, errorMsg) => {
+        switch (format) {
+            case 'email':
+                return zs.email(errorMsg);
+            case 'ip':
+                return zs.ip(errorMsg);
+            case 'ipv4':
+                return zs.ip({ version: 'v4', message: errorMsg });
+            case 'ipv6':
+                return zs.ip({ version: 'v6', message: errorMsg });
+            case 'uri':
+                return zs.url(errorMsg);
+            case 'uuid':
+                return zs.uuid(errorMsg);
+            case 'date-time':
+                return zs.datetime({ offset: true, message: errorMsg });
+            case 'time':
+                return zs.time(errorMsg);
+            case 'date':
+                return zs.date(errorMsg);
+            case 'binary':
+                return zs.base64(errorMsg);
+            case 'duration':
+                return zs.duration(errorMsg);
+            default:
+                return zs;
+        }
+    });
+    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'contentEncoding', (zs, _, errorMsg) => zs.base64(errorMsg));
+    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'pattern', (zs, pattern, errorMsg) => zs.regex(new RegExp(pattern), errorMsg));
+    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'minLength', (zs, minLength, errorMsg) => zs.min(minLength, errorMsg));
+    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'maxLength', (zs, maxLength, errorMsg) => zs.max(maxLength, errorMsg));
+    return zodSchema;
+};

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils/extend-schema.js

@@ -0,0 +1,8 @@
+export function extendSchemaWithMessage(zodSchema, jsonSchema, key, extend) {
+    const value = jsonSchema[key];
+    if (value !== undefined) {
+        const errorMessage = jsonSchema.errorMessage?.[key];
+        return extend(zodSchema, value, errorMessage);
+    }
+    return zodSchema;
+}

package/dist/esm/utils/half.js

@@ -0,0 +1,3 @@
+export const half = (arr) => {
+    return [arr.slice(0, arr.length / 2), arr.slice(arr.length / 2)];
+};

package/dist/esm/utils/its.js

@@ -0,0 +1,20 @@
+export const its = {
+    an: {
+        object: (x) => x.type === 'object',
+        array: (x) => x.type === 'array',
+        anyOf: (x) => x.anyOf !== undefined,
+        allOf: (x) => x.allOf !== undefined,
+        enum: (x) => x.enum !== undefined,
+    },
+    a: {
+        nullable: (x) => 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        x.nullable === true,
+        multipleType: (x) => Array.isArray(x.type),
+        not: (x) => x.not !== undefined,
+        const: (x) => x.const !== undefined,
+        primitive: (x, p) => x.type === p,
+        conditional: (x) => Boolean('if' in x && x.if && 'then' in x && 'else' in x && x.then && x.else),
+        oneOf: (x) => x.oneOf !== undefined,
+    },
+};

package/dist/esm/utils/omit.js

@@ -0,0 +1,6 @@
+export const omit = (obj, ...keys) => Object.keys(obj).reduce((acc, key) => {
+    if (!keys.includes(key)) {
+        acc[key] = obj[key];
+    }
+    return acc;
+}, {});

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './types';
+export { jsonSchemaToZod } from './json-schema-to-zod';

package/dist/types/json-schema-to-zod.d.ts

@@ -0,0 +1,3 @@
+import type { z } from 'zod';
+import type { JsonSchemaToZodOptions, JsonSchema } from './types';
+export declare const jsonSchemaToZod: <T extends z.ZodTypeAny = z.ZodTypeAny>(schema: JsonSchema, options?: JsonSchemaToZodOptions) => T;

package/dist/types/parsers/parse-all-of.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonSchemaObject, JsonSchema, Refs } from '../types';
+export declare function parseAllOf(jsonSchema: JsonSchemaObject & {
+    allOf: JsonSchema[];
+}, refs: Refs): z.ZodTypeAny;

package/dist/types/parsers/parse-any-of.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonSchemaObject, JsonSchema, Refs } from '../types';
+export declare const parseAnyOf: (jsonSchema: JsonSchemaObject & {
+    anyOf: JsonSchema[];
+}, refs: Refs) => z.ZodTypeAny;

package/dist/types/parsers/parse-array.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonSchemaObject, Refs } from '../types';
+export declare const parseArray: (jsonSchema: JsonSchemaObject & {
+    type: "array";
+}, refs: Refs) => z.ZodArray<z.ZodTypeAny, "many"> | z.ZodTuple<[z.ZodTypeAny], null>;

package/dist/types/parsers/parse-boolean.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonSchemaObject } from '../types';
+export declare const parseBoolean: (_jsonSchema: JsonSchemaObject & {
+    type: "boolean";
+}) => z.ZodBoolean;

package/dist/types/parsers/parse-const.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonSchemaObject, Serializable } from '../types';
+export declare const parseConst: (jsonSchema: JsonSchemaObject & {
+    const: Serializable;
+}) => z.ZodLiteral<z.Primitive>;

package/dist/types/parsers/parse-default.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { JsonSchemaObject } from '../types';
+export declare const parseDefault: (_jsonSchema: JsonSchemaObject) => z.ZodAny;

package/dist/types/parsers/parse-enum.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonSchemaObject, Serializable } from '../types';
+export declare const parseEnum: (jsonSchema: JsonSchemaObject & {
+    enum: Serializable[];
+}) => z.ZodNever | z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny]> | z.ZodLiteral<z.Primitive> | z.ZodEnum<[string]>;

package/dist/types/parsers/parse-if-then-else.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import type { JsonSchemaObject, JsonSchema, Refs } from '../types';
+export declare const parseIfThenElse: (jsonSchema: JsonSchemaObject & {
+    if: JsonSchema;
+    then: JsonSchema;
+    else: JsonSchema;
+}, refs: Refs) => z.ZodEffects<z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny]>, any, any>;

package/dist/types/parsers/parse-multiple-type.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonSchemaObject, Refs } from '../types';
+export declare const parseMultipleType: (jsonSchema: JsonSchemaObject & {
+    type: string[];
+}, refs: Refs) => z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny]>;

package/dist/types/parsers/parse-not.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonSchemaObject, JsonSchema, Refs } from '../types';
+export declare const parseNot: (jsonSchema: JsonSchemaObject & {
+    not: JsonSchema;
+}, refs: Refs) => z.ZodEffects<z.ZodAny, any, any>;

package/dist/types/parsers/parse-null.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonSchemaObject } from '../types';
+export declare const parseNull: (_jsonSchema: JsonSchemaObject & {
+    type: "null";
+}) => z.ZodNull;

package/dist/types/parsers/parse-nullable.d.ts

@@ -0,0 +1,7 @@
+import type { JsonSchemaObject, Refs } from '../types';
+/**
+ * For compatibility with open api 3.0 nullable
+ */
+export declare const parseNullable: (jsonSchema: JsonSchemaObject & {
+    nullable: true;
+}, refs: Refs) => import("zod").ZodNullable<import("zod").ZodTypeAny>;

package/dist/types/parsers/parse-number.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonSchemaObject } from '../types';
+export declare const parseNumber: (jsonSchema: JsonSchemaObject & {
+    type: "number" | "integer";
+}) => z.ZodNumber;

package/dist/types/parsers/parse-object.d.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod';
+import type { JsonSchemaObject, Refs } from '../types';
+export declare function parseObject(objectSchema: JsonSchemaObject & {
+    type: 'object';
+}, refs: Refs): z.ZodTypeAny;

package/dist/types/parsers/parse-one-of.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonSchemaObject, JsonSchema, Refs } from '../types';
+export declare const parseOneOf: (jsonSchema: JsonSchemaObject & {
+    oneOf: JsonSchema[];
+}, refs: Refs) => z.ZodTypeAny;

package/dist/types/parsers/parse-schema.d.ts

@@ -0,0 +1,3 @@
+import * as z from 'zod';
+import type { Refs, JsonSchema } from '../types';
+export declare const parseSchema: (jsonSchema: JsonSchema, refs?: Refs, blockMeta?: boolean) => z.ZodTypeAny;

package/dist/types/parsers/parse-string.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonSchemaObject } from '../types';
+export declare const parseString: (jsonSchema: JsonSchemaObject & {
+    type: "string";
+}) => z.ZodString;

package/dist/types/types.d.ts

@@ -0,0 +1,66 @@
+import type { ZodTypeAny } from 'zod';
+export type Serializable = {
+    [key: string]: Serializable;
+} | Serializable[] | string | number | boolean | null;
+export type JsonSchema = JsonSchemaObject | boolean;
+export type JsonSchemaObject = {
+    type?: string | string[];
+    properties?: {
+        [key: string]: JsonSchema;
+    };
+    additionalProperties?: JsonSchema;
+    unevaluatedProperties?: JsonSchema;
+    patternProperties?: {
+        [key: string]: JsonSchema;
+    };
+    minProperties?: number;
+    maxProperties?: number;
+    required?: string[] | boolean;
+    propertyNames?: JsonSchema;
+    items?: JsonSchema | JsonSchema[];
+    additionalItems?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number | boolean;
+    exclusiveMaximum?: number | boolean;
+    multipleOf?: number;
+    anyOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    if?: JsonSchema;
+    then?: JsonSchema;
+    else?: JsonSchema;
+    const?: Serializable;
+    enum?: Serializable[];
+    errorMessage?: {
+        [key: string]: string | undefined;
+    };
+    description?: string;
+    default?: Serializable;
+    readOnly?: boolean;
+    not?: JsonSchema;
+    contentEncoding?: string;
+    nullable?: boolean;
+};
+export type ParserSelector = (schema: JsonSchemaObject, refs: Refs) => ZodTypeAny;
+export type ParserOverride = (schema: JsonSchemaObject, refs: Refs) => ZodTypeAny | undefined;
+export type JsonSchemaToZodOptions = {
+    withoutDefaults?: boolean;
+    withoutDescribes?: boolean;
+    parserOverride?: ParserOverride;
+    depth?: number;
+};
+export type Refs = JsonSchemaToZodOptions & {
+    path: Array<string | number>;
+    seen: Map<object | boolean, {
+        n: number;
+        r: ZodTypeAny | undefined;
+    }>;
+};

package/dist/types/utils/extend-schema.d.ts

@@ -0,0 +1,3 @@
+import type { z } from 'zod';
+import type { JsonSchemaObject } from '../types';
+export declare function extendSchemaWithMessage<TZod extends z.ZodTypeAny, TJson extends JsonSchemaObject, TKey extends keyof TJson>(zodSchema: TZod, jsonSchema: TJson, key: TKey, extend: (zodSchema: TZod, value: NonNullable<TJson[TKey]>, errorMessage?: string) => TZod): TZod;

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

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

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

@@ -0,0 +1,45 @@
+import type { JsonSchema, JsonSchemaObject, Serializable } from '../types';
+export declare const its: {
+    an: {
+        object: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            type: "object";
+        };
+        array: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            type: "array";
+        };
+        anyOf: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            anyOf: JsonSchema[];
+        };
+        allOf: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            allOf: JsonSchema[];
+        };
+        enum: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            enum: Serializable | Serializable[];
+        };
+    };
+    a: {
+        nullable: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            nullable: true;
+        };
+        multipleType: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            type: string[];
+        };
+        not: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            not: JsonSchema;
+        };
+        const: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            const: Serializable;
+        };
+        primitive: <T extends "string" | "number" | "integer" | "boolean" | "null">(x: JsonSchemaObject, p: T) => x is JsonSchemaObject & {
+            type: T;
+        };
+        conditional: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            if: JsonSchema;
+            then: JsonSchema;
+            else: JsonSchema;
+        };
+        oneOf: (x: JsonSchemaObject) => x is JsonSchemaObject & {
+            oneOf: JsonSchema[];
+        };
+    };
+};

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atom8n/json-schema-to-zod",
-  "version": "1.6.8",
+  "version": "1.7.0",
   "description": "Converts JSON schema objects into Zod schemas",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -26,7 +26,7 @@
     "build:types": "tsc -p tsconfig.types.json",
     "build:cjs": "tsc -p tsconfig.cjs.json && node postcjs.cjs",
     "build:esm": "tsc -p tsconfig.esm.json && node postesm.cjs",
-    "build": "rimraf ./dist && pnpm run build:types && pnpm run build:cjs && pnpm run build:esm",
+    "build": "rimraf ./dist && tsc -p tsconfig.types.json && sleep 2 && tsc -p tsconfig.cjs.json && node postcjs.cjs && sleep 2 && tsc -p tsconfig.esm.json && node postesm.cjs",
     "dry": "pnpm run build && pnpm pub --dry-run",
     "test": "jest",
     "test:unit": "jest",
@@ -63,7 +63,7 @@
     "zod": "^3.0.0"
   },
   "devDependencies": {
-    "@n8n/typescript-config": "npm:@atom8n/typescript-config@1.3.8",
+    "@n8n/typescript-config": "npm:@atom8n/typescript-config@1.4.0",
     "@types/json-schema": "^7.0.15",
     "zod": "3.25.67"
   }