@gabrielbryk/json-schema-to-zod 2.10.1 → 2.11.1

package/dist/cjs/parsers/parseObject.js

@@ -1,318 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseObject = parseObject;
-const parseAnyOf_js_1 = require("./parseAnyOf.js");
-const parseOneOf_js_1 = require("./parseOneOf.js");
-const parseSchema_js_1 = require("./parseSchema.js");
-const parseAllOf_js_1 = require("./parseAllOf.js");
-const parseIfThenElse_js_1 = require("./parseIfThenElse.js");
-const jsdocs_js_1 = require("../utils/jsdocs.js");
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-function parseObject(objectSchema, refs) {
-    let properties = undefined;
-    if (objectSchema.properties) {
-        if (!Object.keys(objectSchema.properties).length) {
-            properties = "z.object({})";
-        }
-        else {
-            properties = "z.object({ ";
-            properties += Object.keys(objectSchema.properties)
-                .map((key) => {
-                const propSchema = objectSchema.properties[key];
-                const parsedProp = (0, parseSchema_js_1.parseSchema)(propSchema, {
-                    ...refs,
-                    path: [...refs.path, "properties", key],
-                });
-                const hasDefault = typeof propSchema === "object" && propSchema.default !== undefined;
-                const required = Array.isArray(objectSchema.required)
-                    ? objectSchema.required.includes(key)
-                    : typeof propSchema === "object" && propSchema.required === true;
-                const optional = !hasDefault && !required;
-                const valueWithOptional = optional
-                    ? `${parsedProp}.optional()`
-                    : parsedProp;
-                let result = shouldUseGetter(valueWithOptional, refs)
-                    ? `get ${JSON.stringify(key)}(){ return ${valueWithOptional} }`
-                    : `${JSON.stringify(key)}: ${valueWithOptional}`;
-                if (refs.withJsdocs && typeof propSchema === "object") {
-                    result = (0, jsdocs_js_1.addJsdocs)(propSchema, result);
-                }
-                return result;
-            })
-                .join(", ");
-            properties += " })";
-        }
-    }
-    const additionalProperties = objectSchema.additionalProperties !== undefined
-        ? (0, parseSchema_js_1.parseSchema)(objectSchema.additionalProperties, {
-            ...refs,
-            path: [...refs.path, "additionalProperties"],
-        })
-        : undefined;
-    const unevaluated = objectSchema.unevaluatedProperties;
-    let patternProperties = undefined;
-    if (objectSchema.patternProperties) {
-        const parsedPatternProperties = Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => {
-            return [
-                key,
-                (0, parseSchema_js_1.parseSchema)(value, {
-                    ...refs,
-                    path: [...refs.path, "patternProperties", key],
-                }),
-            ];
-        }, {}));
-        patternProperties = "";
-        if (properties) {
-            if (additionalProperties) {
-                patternProperties += `.catchall(z.union([${[
-                    ...Object.values(parsedPatternProperties),
-                    additionalProperties,
-                ].join(", ")}]))`;
-            }
-            else if (Object.keys(parsedPatternProperties).length > 1) {
-                patternProperties += `.catchall(z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
-            }
-            else {
-                patternProperties += `.catchall(${Object.values(parsedPatternProperties)})`;
-            }
-        }
-        else {
-            if (additionalProperties) {
-                patternProperties += `z.record(z.string(), z.union([${[
-                    ...Object.values(parsedPatternProperties),
-                    additionalProperties,
-                ].join(", ")}]))`;
-            }
-            else if (Object.keys(parsedPatternProperties).length > 1) {
-                patternProperties += `z.record(z.string(), z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
-            }
-            else {
-                patternProperties += `z.record(z.string(), ${Object.values(parsedPatternProperties)})`;
-            }
-        }
-        patternProperties += ".superRefine((value, ctx) => {\n";
-        patternProperties += "for (const key in value) {\n";
-        if (additionalProperties) {
-            if (objectSchema.properties) {
-                patternProperties += `let evaluated = [${Object.keys(objectSchema.properties)
-                    .map((key) => JSON.stringify(key))
-                    .join(", ")}].includes(key)\n`;
-            }
-            else {
-                patternProperties += `let evaluated = false\n`;
-            }
-        }
-        for (const key in objectSchema.patternProperties) {
-            patternProperties +=
-                "if (key.match(new RegExp(" + JSON.stringify(key) + "))) {\n";
-            if (additionalProperties) {
-                patternProperties += "evaluated = true\n";
-            }
-            patternProperties +=
-                "const result = " +
-                    parsedPatternProperties[key] +
-                    ".safeParse(value[key])\n";
-            patternProperties += "if (!result.success) {\n";
-            patternProperties += `ctx.addIssue({
-          path: [...(ctx.path ?? []), key],
-          code: 'custom',
-          message: \`Invalid input: Key matching regex /\${key}/ must match schema\`,
-          params: {
-            issues: result.error.issues
-          }
-        })\n`;
-            patternProperties += "}\n";
-            patternProperties += "}\n";
-        }
-        if (additionalProperties) {
-            patternProperties += "if (!evaluated) {\n";
-            patternProperties +=
-                "const result = " + additionalProperties + ".safeParse(value[key])\n";
-            patternProperties += "if (!result.success) {\n";
-            patternProperties += `ctx.addIssue({
-          path: [...(ctx.path ?? []), key],
-          code: 'custom',
-          message: \`Invalid input: must match catchall schema\`,
-          params: {
-            issues: result.error.issues
-          }
-        })\n`;
-            patternProperties += "}\n";
-            patternProperties += "}\n";
-        }
-        patternProperties += "}\n";
-        patternProperties += "})";
-        // Store original patternProperties in meta for JSON Schema round-trip
-        if (refs.preserveJsonSchemaForRoundTrip) {
-            const patternPropsJson = JSON.stringify(Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([pattern, schema]) => [
-                pattern,
-                schema
-            ])));
-            patternProperties += `.meta({ __jsonSchema: { patternProperties: ${patternPropsJson} } })`;
-        }
-    }
-    // Check if there will be an .and() call that adds properties from oneOf/anyOf/allOf/if-then-else
-    // In that case, we should NOT use .strict() because it will reject the additional keys
-    // before the union gets a chance to validate them.
-    const hasCompositionKeywords = parseSchema_js_1.its.an.anyOf(objectSchema) || parseSchema_js_1.its.a.oneOf(objectSchema) || parseSchema_js_1.its.an.allOf(objectSchema) || parseSchema_js_1.its.a.conditional(objectSchema);
-    let output = properties
-        ? patternProperties
-            ? properties + patternProperties
-            : additionalProperties
-                ? additionalProperties === "z.never()"
-                    // Don't use .strict() if there are composition keywords that add properties
-                    ? hasCompositionKeywords
-                        ? properties
-                        : properties + ".strict()"
-                    : properties + `.catchall(${additionalProperties})`
-                : properties
-        : patternProperties
-            ? patternProperties
-            : additionalProperties
-                ? `z.record(z.string(), ${additionalProperties})`
-                : `z.record(z.string(), ${(0, anyOrUnknown_js_1.anyOrUnknown)(refs)})`;
-    if (unevaluated === false && properties && !hasCompositionKeywords) {
-        output += ".strict()";
-    }
-    else if (unevaluated && typeof unevaluated !== 'boolean') {
-        const unevaluatedSchema = (0, parseSchema_js_1.parseSchema)(unevaluated, {
-            ...refs,
-            path: [...refs.path, "unevaluatedProperties"],
-        });
-        const knownKeys = objectSchema.properties ? Object.keys(objectSchema.properties) : [];
-        const patterns = objectSchema.patternProperties
-            ? Object.keys(objectSchema.patternProperties).map((p) => new RegExp(p))
-            : [];
-        output += `.superRefine((value, ctx) => {
-  for (const key in value) {
-    const isKnown = ${JSON.stringify(knownKeys)}.includes(key);
-    const matchesPattern = ${patterns.length ? "[" + patterns.map((r) => r.toString()).join(",") + "]" : "[]"}.some((r) => r.test(key));
-    if (!isKnown && !matchesPattern) {
-      const result = ${unevaluatedSchema}.safeParse(value[key]);
-      if (!result.success) {
-        ctx.addIssue({ code: "custom", path: [key], message: "Invalid unevaluated property", params: { issues: result.error.issues } });
-      }
-    }
-  }
-})`;
-    }
-    if (parseSchema_js_1.its.an.anyOf(objectSchema)) {
-        output += `.and(${(0, parseAnyOf_js_1.parseAnyOf)({
-            ...objectSchema,
-            anyOf: objectSchema.anyOf.map((x) => typeof x === "object" &&
-                x !== null &&
-                !x.type &&
-                (x.properties || x.additionalProperties || x.patternProperties)
-                ? { ...x, type: "object" }
-                : x),
-        }, refs)})`;
-    }
-    if (parseSchema_js_1.its.a.oneOf(objectSchema)) {
-        output += `.and(${(0, parseOneOf_js_1.parseOneOf)({
-            ...objectSchema,
-            oneOf: objectSchema.oneOf.map((x) => typeof x === "object" &&
-                x !== null &&
-                !x.type &&
-                (x.properties || x.additionalProperties || x.patternProperties)
-                ? { ...x, type: "object" }
-                : x),
-        }, refs)})`;
-    }
-    if (parseSchema_js_1.its.an.allOf(objectSchema)) {
-        output += `.and(${(0, parseAllOf_js_1.parseAllOf)({
-            ...objectSchema,
-            allOf: objectSchema.allOf.map((x) => typeof x === "object" &&
-                x !== null &&
-                !x.type &&
-                (x.properties || x.additionalProperties || x.patternProperties)
-                ? { ...x, type: "object" }
-                : x),
-        }, refs)})`;
-    }
-    // Handle if/then/else conditionals on object schemas
-    if (parseSchema_js_1.its.a.conditional(objectSchema)) {
-        output += `.and(${(0, parseIfThenElse_js_1.parseIfThenElse)(objectSchema, refs)})`;
-    }
-    // propertyNames
-    if (objectSchema.propertyNames) {
-        const normalizedPropNames = typeof objectSchema.propertyNames === "object" &&
-            objectSchema.propertyNames !== null &&
-            !objectSchema.propertyNames.type &&
-            objectSchema.propertyNames.pattern
-            ? { ...objectSchema.propertyNames, type: "string" }
-            : objectSchema.propertyNames;
-        const propNameSchema = (0, parseSchema_js_1.parseSchema)(normalizedPropNames, {
-            ...refs,
-            path: [...refs.path, "propertyNames"],
-        });
-        output += `.superRefine((value, ctx) => {
-  for (const key in value) {
-    const result = ${propNameSchema}.safeParse(key);
-    if (!result.success) {
-      ctx.addIssue({
-        path: [key],
-        code: "custom",
-        message: "Invalid property name",
-        params: { issues: result.error.issues }
-      });
-    }
-  }
-})`;
-    }
-    // dependentSchemas
-    if (objectSchema.dependentSchemas && typeof objectSchema.dependentSchemas === "object") {
-        const entries = Object.entries(objectSchema.dependentSchemas);
-        if (entries.length) {
-            output += `.superRefine((obj, ctx) => {
-  ${entries
-                .map(([key, schema]) => {
-                const parsed = (0, parseSchema_js_1.parseSchema)(schema, { ...refs, path: [...refs.path, "dependentSchemas", key] });
-                return `if (Object.prototype.hasOwnProperty.call(obj, ${JSON.stringify(key)})) {
-    const result = ${parsed}.safeParse(obj);
-    if (!result.success) {
-      ctx.addIssue({ code: "custom", message: ${objectSchema.errorMessage?.dependentSchemas ?? JSON.stringify("Dependent schema failed")}, path: [], params: { issues: result.error.issues } });
-    }
-  }`;
-            })
-                .join("\n  ")}
-})`;
-        }
-    }
-    // dependentRequired
-    if (objectSchema.dependentRequired && typeof objectSchema.dependentRequired === "object") {
-        const entries = Object.entries(objectSchema.dependentRequired);
-        if (entries.length) {
-            const depRequiredMessage = objectSchema.errorMessage?.dependentRequired ??
-                "Dependent required properties missing";
-            output += `.superRefine((obj, ctx) => {
-  ${entries
-                .map(([prop, deps]) => {
-                const arr = Array.isArray(deps) ? deps : [];
-                if (!arr.length)
-                    return "";
-                const jsonDeps = JSON.stringify(arr);
-                return `if (Object.prototype.hasOwnProperty.call(obj, ${JSON.stringify(prop)})) {
-    const missing = ${jsonDeps}.filter((d) => !Object.prototype.hasOwnProperty.call(obj, d));
-    if (missing.length) {
-      ctx.addIssue({ code: "custom", message: ${JSON.stringify(depRequiredMessage)}, path: [], params: { missing } });
-    }
-  }`;
-            })
-                .filter(Boolean)
-                .join("\n  ")}
-})`;
-        }
-    }
-    return output;
-}
-const shouldUseGetter = (parsed, refs) => {
-    if (!parsed)
-        return false;
-    if (refs.currentSchemaName && parsed.includes(refs.currentSchemaName)) {
-        return true;
-    }
-    if (refs.cycleRefNames?.has(parsed)) {
-        return true;
-    }
-    return Boolean(refs.inProgress && refs.inProgress.has(parsed));
-};

package/dist/cjs/parsers/parseOneOf.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOneOf = void 0;
-const parseSchema_js_1 = require("./parseSchema.js");
-const anyOrUnknown_js_1 = require("../utils/anyOrUnknown.js");
-const parseOneOf = (schema, refs) => {
-    if (!schema.oneOf.length) {
-        return (0, anyOrUnknown_js_1.anyOrUnknown)(refs);
-    }
-    if (schema.oneOf.length === 1) {
-        return (0, parseSchema_js_1.parseSchema)(schema.oneOf[0], {
-            ...refs,
-            path: [...refs.path, "oneOf", 0],
-        });
-    }
-    // Generate parsed schemas for each oneOf option
-    const parsedSchemas = schema.oneOf.map((s, i) => (0, parseSchema_js_1.parseSchema)(s, {
-        ...refs,
-        path: [...refs.path, "oneOf", i],
-    }));
-    // JSON Schema oneOf = exactly one must match (exclusive OR)
-    // Zod union = at least one must match (inclusive OR)
-    //
-    // By default, use simple z.union() which provides "at least one must match".
-    // This is more practical for most use cases, as strict oneOf enforcement
-    // often fails when schemas have overlapping base types.
-    //
-    // If strictOneOf is enabled, add superRefine to enforce "exactly one" constraint.
-    if (refs.strictOneOf) {
-        return `z.union([${parsedSchemas.join(", ")}]).superRefine((x, ctx) => {
-    const schemas = [${parsedSchemas.join(", ")}];
-    const errors = schemas.reduce<z.ZodError[]>(
-      (errors, schema) =>
-        ((result) =>
-          result.error ? [...errors, result.error] : errors)(
-          schema.safeParse(x),
-        ),
-      [],
-    );
-    if (schemas.length - errors.length !== 1) {
-      ctx.addIssue({
-        path: [],
-        code: "invalid_union",
-        errors: errors.map(e => e.issues),
-        message: "Invalid input: Should pass single schema",
-      });
-    }
-  })`;
-    }
-    // Default: use simple z.union() (at least one must match)
-    return `z.union([${parsedSchemas.join(", ")}])`;
-};
-exports.parseOneOf = parseOneOf;