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

package/.turbo/turbo-build.log

@@ -1,11 +1,5 @@
 
 
-> @n8n/json-schema-to-zod@1.6.7 build /Users/Shared/Data/Syncthing/MyApp/n8n-solution/n8n/packages/@n8n/json-schema-to-zod
-> rimraf ./dist && pnpm run build:types && pnpm run build:cjs && pnpm run build:esm
+> @n8n/json-schema-to-zod@1.6.4 build /Users/Shared/Data/Syncthing/MyApp/n8n-solution/n8n/packages/@n8n/json-schema-to-zod
+> 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
 
-
-> @n8n/json-schema-to-zod@1.6.7 build:types /Users/Shared/Data/Syncthing/MyApp/n8n-solution/n8n/packages/@n8n/json-schema-to-zod
-> tsc -p tsconfig.types.json
-
- ELIFECYCLE  Command failed.
- ELIFECYCLE  Command failed.

package/dist/cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonSchemaToZod = void 0;
+var json_schema_to_zod_1 = require("./json-schema-to-zod");
+Object.defineProperty(exports, "jsonSchemaToZod", { enumerable: true, get: function () { return json_schema_to_zod_1.jsonSchemaToZod; } });

package/dist/cjs/json-schema-to-zod.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonSchemaToZod = void 0;
+const parse_schema_1 = require("./parsers/parse-schema");
+const jsonSchemaToZod = (schema, options = {}) => {
+    return (0, parse_schema_1.parseSchema)(schema, {
+        path: [],
+        seen: new Map(),
+        ...options,
+    });
+};
+exports.jsonSchemaToZod = jsonSchemaToZod;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/parsers/parse-all-of.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAllOf = parseAllOf;
+const zod_1 = require("zod");
+const parse_schema_1 = require("./parse-schema");
+const half_1 = require("../utils/half");
+const originalIndex = Symbol('Original index');
+const ensureOriginalIndex = (arr) => {
+    const newArr = [];
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        if (typeof item === 'boolean') {
+            newArr.push(item ? { [originalIndex]: i } : { [originalIndex]: i, not: {} });
+        }
+        else if (originalIndex in item) {
+            return arr;
+        }
+        else {
+            newArr.push({ ...item, [originalIndex]: i });
+        }
+    }
+    return newArr;
+};
+function parseAllOf(jsonSchema, refs) {
+    if (jsonSchema.allOf.length === 0) {
+        return zod_1.z.never();
+    }
+    if (jsonSchema.allOf.length === 1) {
+        const item = jsonSchema.allOf[0];
+        return (0, parse_schema_1.parseSchema)(item, {
+            ...refs,
+            path: [...refs.path, 'allOf', item[originalIndex]],
+        });
+    }
+    const [left, right] = (0, half_1.half)(ensureOriginalIndex(jsonSchema.allOf));
+    return zod_1.z.intersection(parseAllOf({ allOf: left }, refs), parseAllOf({ allOf: right }, refs));
+}

package/dist/cjs/parsers/parse-any-of.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAnyOf = void 0;
+const zod_1 = require("zod");
+const parse_schema_1 = require("./parse-schema");
+const parseAnyOf = (jsonSchema, refs) => {
+    return jsonSchema.anyOf.length
+        ? jsonSchema.anyOf.length === 1
+            ? (0, parse_schema_1.parseSchema)(jsonSchema.anyOf[0], {
+                ...refs,
+                path: [...refs.path, 'anyOf', 0],
+            })
+            : zod_1.z.union(jsonSchema.anyOf.map((schema, i) => (0, parse_schema_1.parseSchema)(schema, { ...refs, path: [...refs.path, 'anyOf', i] })))
+        : zod_1.z.any();
+};
+exports.parseAnyOf = parseAnyOf;

package/dist/cjs/parsers/parse-array.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArray = void 0;
+const zod_1 = require("zod");
+const parse_schema_1 = require("./parse-schema");
+const extend_schema_1 = require("../utils/extend-schema");
+const parseArray = (jsonSchema, refs) => {
+    if (Array.isArray(jsonSchema.items)) {
+        return zod_1.z.tuple(jsonSchema.items.map((v, i) => (0, parse_schema_1.parseSchema)(v, { ...refs, path: [...refs.path, 'items', i] })));
+    }
+    let zodSchema = !jsonSchema.items
+        ? zod_1.z.array(zod_1.z.any())
+        : zod_1.z.array((0, parse_schema_1.parseSchema)(jsonSchema.items, { ...refs, path: [...refs.path, 'items'] }));
+    zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'minItems', (zs, minItems, errorMessage) => zs.min(minItems, errorMessage));
+    zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'maxItems', (zs, maxItems, errorMessage) => zs.max(maxItems, errorMessage));
+    return zodSchema;
+};
+exports.parseArray = parseArray;

package/dist/cjs/parsers/parse-boolean.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBoolean = void 0;
+const zod_1 = require("zod");
+const parseBoolean = (_jsonSchema) => {
+    return zod_1.z.boolean();
+};
+exports.parseBoolean = parseBoolean;

package/dist/cjs/parsers/parse-const.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConst = void 0;
+const zod_1 = require("zod");
+const parseConst = (jsonSchema) => {
+    return zod_1.z.literal(jsonSchema.const);
+};
+exports.parseConst = parseConst;

package/dist/cjs/parsers/parse-default.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDefault = void 0;
+const zod_1 = require("zod");
+const parseDefault = (_jsonSchema) => {
+    return zod_1.z.any();
+};
+exports.parseDefault = parseDefault;

package/dist/cjs/parsers/parse-enum.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnum = void 0;
+const zod_1 = require("zod");
+const parseEnum = (jsonSchema) => {
+    if (jsonSchema.enum.length === 0) {
+        return zod_1.z.never();
+    }
+    if (jsonSchema.enum.length === 1) {
+        // union does not work when there is only one element
+        return zod_1.z.literal(jsonSchema.enum[0]);
+    }
+    if (jsonSchema.enum.every((x) => typeof x === 'string')) {
+        return zod_1.z.enum(jsonSchema.enum);
+    }
+    return zod_1.z.union(jsonSchema.enum.map((x) => zod_1.z.literal(x)));
+};
+exports.parseEnum = parseEnum;

package/dist/cjs/parsers/parse-if-then-else.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIfThenElse = void 0;
+const zod_1 = require("zod");
+const parse_schema_1 = require("./parse-schema");
+const parseIfThenElse = (jsonSchema, refs) => {
+    const $if = (0, parse_schema_1.parseSchema)(jsonSchema.if, { ...refs, path: [...refs.path, 'if'] });
+    const $then = (0, parse_schema_1.parseSchema)(jsonSchema.then, {
+        ...refs,
+        path: [...refs.path, 'then'],
+    });
+    const $else = (0, parse_schema_1.parseSchema)(jsonSchema.else, {
+        ...refs,
+        path: [...refs.path, 'else'],
+    });
+    return zod_1.z.union([$then, $else]).superRefine((value, ctx) => {
+        const result = $if.safeParse(value).success ? $then.safeParse(value) : $else.safeParse(value);
+        if (!result.success) {
+            result.error.errors.forEach((error) => ctx.addIssue(error));
+        }
+    });
+};
+exports.parseIfThenElse = parseIfThenElse;

package/dist/cjs/parsers/parse-multiple-type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMultipleType = void 0;
+const zod_1 = require("zod");
+const parse_schema_1 = require("./parse-schema");
+const parseMultipleType = (jsonSchema, refs) => {
+    return zod_1.z.union(jsonSchema.type.map((type) => (0, parse_schema_1.parseSchema)({ ...jsonSchema, type }, refs)));
+};
+exports.parseMultipleType = parseMultipleType;

package/dist/cjs/parsers/parse-not.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNot = void 0;
+const zod_1 = require("zod");
+const parse_schema_1 = require("./parse-schema");
+const parseNot = (jsonSchema, refs) => {
+    return zod_1.z.any().refine((value) => !(0, parse_schema_1.parseSchema)(jsonSchema.not, {
+        ...refs,
+        path: [...refs.path, 'not'],
+    }).safeParse(value).success, 'Invalid input: Should NOT be valid against schema');
+};
+exports.parseNot = parseNot;

package/dist/cjs/parsers/parse-null.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNull = void 0;
+const zod_1 = require("zod");
+const parseNull = (_jsonSchema) => {
+    return zod_1.z.null();
+};
+exports.parseNull = parseNull;

package/dist/cjs/parsers/parse-nullable.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNullable = void 0;
+const parse_schema_1 = require("./parse-schema");
+const omit_1 = require("../utils/omit");
+/**
+ * For compatibility with open api 3.0 nullable
+ */
+const parseNullable = (jsonSchema, refs) => {
+    return (0, parse_schema_1.parseSchema)((0, omit_1.omit)(jsonSchema, 'nullable'), refs, true).nullable();
+};
+exports.parseNullable = parseNullable;

package/dist/cjs/parsers/parse-number.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNumber = void 0;
+const zod_1 = require("zod");
+const extend_schema_1 = require("../utils/extend-schema");
+const parseNumber = (jsonSchema) => {
+    let zodSchema = zod_1.z.number();
+    let isInteger = false;
+    if (jsonSchema.type === 'integer') {
+        isInteger = true;
+        zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'type', (zs, _, errorMsg) => zs.int(errorMsg));
+    }
+    else if (jsonSchema.format === 'int64') {
+        isInteger = true;
+        zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'format', (zs, _, errorMsg) => zs.int(errorMsg));
+    }
+    zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'multipleOf', (zs, multipleOf, errorMsg) => {
+        if (multipleOf === 1) {
+            if (isInteger)
+                return zs;
+            return zs.int(errorMsg);
+        }
+        return zs.multipleOf(multipleOf, errorMsg);
+    });
+    if (typeof jsonSchema.minimum === 'number') {
+        if (jsonSchema.exclusiveMinimum === true) {
+            zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'minimum', (zs, minimum, errorMsg) => zs.gt(minimum, errorMsg));
+        }
+        else {
+            zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'minimum', (zs, minimum, errorMsg) => zs.gte(minimum, errorMsg));
+        }
+    }
+    else if (typeof jsonSchema.exclusiveMinimum === 'number') {
+        zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'exclusiveMinimum', (zs, exclusiveMinimum, errorMsg) => zs.gt(exclusiveMinimum, errorMsg));
+    }
+    if (typeof jsonSchema.maximum === 'number') {
+        if (jsonSchema.exclusiveMaximum === true) {
+            zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'maximum', (zs, maximum, errorMsg) => zs.lt(maximum, errorMsg));
+        }
+        else {
+            zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'maximum', (zs, maximum, errorMsg) => zs.lte(maximum, errorMsg));
+        }
+    }
+    else if (typeof jsonSchema.exclusiveMaximum === 'number') {
+        zodSchema = (0, extend_schema_1.extendSchemaWithMessage)(zodSchema, jsonSchema, 'exclusiveMaximum', (zs, exclusiveMaximum, errorMsg) => zs.lt(exclusiveMaximum, errorMsg));
+    }
+    return zodSchema;
+};
+exports.parseNumber = parseNumber;

package/dist/cjs/parsers/parse-object.js

@@ -0,0 +1,206 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseObject = parseObject;
+const z = __importStar(require("zod"));
+const parse_all_of_1 = require("./parse-all-of");
+const parse_any_of_1 = require("./parse-any-of");
+const parse_one_of_1 = require("./parse-one-of");
+const parse_schema_1 = require("./parse-schema");
+const its_1 = require("../utils/its");
+function parseObjectProperties(objectSchema, refs) {
+    if (!objectSchema.properties) {
+        return undefined;
+    }
+    const propertyKeys = Object.keys(objectSchema.properties);
+    if (propertyKeys.length === 0) {
+        return z.object({});
+    }
+    const properties = {};
+    for (const key of propertyKeys) {
+        const propJsonSchema = objectSchema.properties[key];
+        const propZodSchema = (0, parse_schema_1.parseSchema)(propJsonSchema, {
+            ...refs,
+            path: [...refs.path, 'properties', key],
+        });
+        const hasDefault = typeof propJsonSchema === 'object' && propJsonSchema.default !== undefined;
+        const required = Array.isArray(objectSchema.required)
+            ? objectSchema.required.includes(key)
+            : typeof propJsonSchema === 'object' && propJsonSchema.required === true;
+        const isOptional = !hasDefault && !required;
+        properties[key] = isOptional ? propZodSchema.optional() : propZodSchema;
+    }
+    return z.object(properties);
+}
+function parseObject(objectSchema, refs) {
+    const hasPatternProperties = Object.keys(objectSchema.patternProperties ?? {}).length > 0;
+    const propertiesSchema = parseObjectProperties(objectSchema, refs);
+    let zodSchema = propertiesSchema;
+    const additionalProperties = objectSchema.additionalProperties !== undefined
+        ? (0, parse_schema_1.parseSchema)(objectSchema.additionalProperties, {
+            ...refs,
+            path: [...refs.path, 'additionalProperties'],
+        })
+        : undefined;
+    if (objectSchema.patternProperties) {
+        const parsedPatternProperties = Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => {
+            return [
+                key,
+                (0, parse_schema_1.parseSchema)(value, {
+                    ...refs,
+                    path: [...refs.path, 'patternProperties', key],
+                }),
+            ];
+        }));
+        const patternPropertyValues = Object.values(parsedPatternProperties);
+        if (propertiesSchema) {
+            if (additionalProperties) {
+                zodSchema = propertiesSchema.catchall(z.union([...patternPropertyValues, additionalProperties]));
+            }
+            else if (Object.keys(parsedPatternProperties).length > 1) {
+                zodSchema = propertiesSchema.catchall(z.union(patternPropertyValues));
+            }
+            else {
+                zodSchema = propertiesSchema.catchall(patternPropertyValues[0]);
+            }
+        }
+        else {
+            if (additionalProperties) {
+                zodSchema = z.record(z.union([...patternPropertyValues, additionalProperties]));
+            }
+            else if (patternPropertyValues.length > 1) {
+                zodSchema = z.record(z.union(patternPropertyValues));
+            }
+            else {
+                zodSchema = z.record(patternPropertyValues[0]);
+            }
+        }
+        const objectPropertyKeys = new Set(Object.keys(objectSchema.properties ?? {}));
+        zodSchema = zodSchema.superRefine((value, ctx) => {
+            for (const key in value) {
+                let wasMatched = objectPropertyKeys.has(key);
+                for (const patternPropertyKey in objectSchema.patternProperties) {
+                    const regex = new RegExp(patternPropertyKey);
+                    if (key.match(regex)) {
+                        wasMatched = true;
+                        const result = parsedPatternProperties[patternPropertyKey].safeParse(value[key]);
+                        if (!result.success) {
+                            ctx.addIssue({
+                                path: [...ctx.path, key],
+                                code: 'custom',
+                                message: `Invalid input: Key matching regex /${key}/ must match schema`,
+                                params: {
+                                    issues: result.error.issues,
+                                },
+                            });
+                        }
+                    }
+                }
+                if (!wasMatched && additionalProperties) {
+                    const result = additionalProperties.safeParse(value[key]);
+                    if (!result.success) {
+                        ctx.addIssue({
+                            path: [...ctx.path, key],
+                            code: 'custom',
+                            message: 'Invalid input: must match catchall schema',
+                            params: {
+                                issues: result.error.issues,
+                            },
+                        });
+                    }
+                }
+            }
+        });
+    }
+    let output;
+    if (propertiesSchema) {
+        if (hasPatternProperties) {
+            output = zodSchema;
+        }
+        else if (additionalProperties) {
+            if (additionalProperties instanceof z.ZodNever) {
+                output = propertiesSchema.strict();
+            }
+            else {
+                output = propertiesSchema.catchall(additionalProperties);
+            }
+        }
+        else {
+            output = zodSchema;
+        }
+    }
+    else {
+        if (hasPatternProperties) {
+            output = zodSchema;
+        }
+        else if (additionalProperties) {
+            output = z.record(additionalProperties);
+        }
+        else {
+            output = z.record(z.any());
+        }
+    }
+    if (its_1.its.an.anyOf(objectSchema)) {
+        output = output.and((0, parse_any_of_1.parseAnyOf)({
+            ...objectSchema,
+            anyOf: objectSchema.anyOf.map((x) => typeof x === 'object' &&
+                !x.type &&
+                (x.properties ?? x.additionalProperties ?? x.patternProperties)
+                ? { ...x, type: 'object' }
+                : x),
+        }, refs));
+    }
+    if (its_1.its.a.oneOf(objectSchema)) {
+        output = output.and((0, parse_one_of_1.parseOneOf)({
+            ...objectSchema,
+            oneOf: objectSchema.oneOf.map((x) => typeof x === 'object' &&
+                !x.type &&
+                (x.properties ?? x.additionalProperties ?? x.patternProperties)
+                ? { ...x, type: 'object' }
+                : x),
+        }, refs));
+    }
+    if (its_1.its.an.allOf(objectSchema)) {
+        output = output.and((0, parse_all_of_1.parseAllOf)({
+            ...objectSchema,
+            allOf: objectSchema.allOf.map((x) => typeof x === 'object' &&
+                !x.type &&
+                (x.properties ?? x.additionalProperties ?? x.patternProperties)
+                ? { ...x, type: 'object' }
+                : x),
+        }, refs));
+    }
+    return output;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOneOf = void 0;
+const zod_1 = require("zod");
+const parse_schema_1 = require("./parse-schema");
+const parseOneOf = (jsonSchema, refs) => {
+    if (!jsonSchema.oneOf.length) {
+        return zod_1.z.any();
+    }
+    if (jsonSchema.oneOf.length === 1) {
+        return (0, parse_schema_1.parseSchema)(jsonSchema.oneOf[0], {
+            ...refs,
+            path: [...refs.path, 'oneOf', 0],
+        });
+    }
+    return zod_1.z.any().superRefine((x, ctx) => {
+        const schemas = jsonSchema.oneOf.map((schema, i) => (0, parse_schema_1.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',
+            });
+        }
+    });
+};
+exports.parseOneOf = parseOneOf;