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

package/dist/parsers/parseOneOf.js

@@ -0,0 +1,365 @@
+import { parseSchema } from "./parseSchema.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+import { extractInlineObject } from "../utils/extractInlineObject.js";
+import { resolveRef } from "../utils/resolveRef.js";
+/**
+ * Check if a schema is a "required-only" validation constraint.
+ * These are schemas that only specify `required` without defining types.
+ */
+const isRequiredOnlySchema = (schema) => {
+    if (typeof schema !== "object" || schema === null) {
+        return false;
+    }
+    const obj = schema;
+    // Must have required array
+    if (!Array.isArray(obj.required) || obj.required.length === 0) {
+        return false;
+    }
+    // Must NOT have type-defining keywords
+    if (obj.type || obj.properties || obj.additionalProperties || obj.patternProperties) {
+        return false;
+    }
+    // Must NOT have composition keywords
+    if (obj.allOf || obj.anyOf || obj.oneOf) {
+        return false;
+    }
+    // Must NOT be a reference
+    if (obj.$ref || obj.$dynamicRef) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Generate a superRefine expression that validates required field combinations.
+ * This handles the JSON Schema pattern where oneOf is used purely for validation.
+ *
+ * When isRefinementOnly is true, the expression is just the refinement function body
+ * that should be appended with .superRefine() directly to the parent schema.
+ */
+const generateRequiredFieldsRefinement = (requiredCombinations) => {
+    const conditions = requiredCombinations.map((fields) => {
+        const checks = fields.map((f) => `obj[${JSON.stringify(f)}] !== undefined`).join(" && ");
+        return `(${checks})`;
+    });
+    const message = `Must have one of the following required field combinations: ${requiredCombinations.map((r) => r.join(", ")).join(" | ")}`;
+    // The refinement function body (without the surrounding .superRefine())
+    const refinementBody = `(obj, ctx) => { if (!(${conditions.join(" || ")})) { ctx.addIssue({ code: "custom", message: ${JSON.stringify(message)} }); } }`;
+    // For standalone use, return z.any() with the refinement
+    const expression = `z.any().superRefine(${refinementBody})`;
+    return {
+        expression,
+        type: "z.ZodAny",
+        isRefinementOnly: true,
+        refinementBody,
+    };
+};
+/**
+ * Collects all properties from a schema, including properties defined in allOf members.
+ * Returns merged properties object and combined required array.
+ */
+const collectSchemaProperties = (schema, refs) => {
+    let properties = {};
+    let required = [];
+    // Collect direct properties
+    if (schema.properties) {
+        properties = { ...properties, ...schema.properties };
+    }
+    // Collect direct required
+    if (Array.isArray(schema.required)) {
+        required = [...required, ...schema.required];
+    }
+    // Collect from allOf members
+    if (Array.isArray(schema.allOf)) {
+        for (const member of schema.allOf) {
+            if (typeof member !== 'object' || member === null)
+                continue;
+            let resolvedMember = member;
+            // Resolve $ref if needed
+            if (resolvedMember.$ref || resolvedMember.$dynamicRef) {
+                const resolved = resolveRef(resolvedMember, (resolvedMember.$ref || resolvedMember.$dynamicRef), refs);
+                if (resolved && typeof resolved.schema === 'object' && resolved.schema !== null) {
+                    resolvedMember = resolved.schema;
+                }
+                else {
+                    continue;
+                }
+            }
+            // Merge properties from this allOf member
+            if (resolvedMember.properties) {
+                properties = { ...properties, ...resolvedMember.properties };
+            }
+            // Merge required from this allOf member
+            if (Array.isArray(resolvedMember.required)) {
+                required = [...required, ...resolvedMember.required];
+            }
+        }
+    }
+    // Return undefined if no properties found
+    if (Object.keys(properties).length === 0) {
+        return undefined;
+    }
+    return { properties, required: [...new Set(required)] };
+};
+/**
+ * Check if two sets contain the same elements.
+ */
+const setsEqual = (a, b) => {
+    if (a.size !== b.size)
+        return false;
+    for (const item of a) {
+        if (!b.has(item))
+            return false;
+    }
+    return true;
+};
+/**
+ * Extract the constant value from a property schema.
+ * Returns the string value if it's a const or single-element enum, undefined otherwise.
+ */
+const getConstValue = (prop) => {
+    if (prop.const !== undefined && typeof prop.const === 'string') {
+        return prop.const;
+    }
+    if (prop.enum &&
+        Array.isArray(prop.enum) &&
+        prop.enum.length === 1 &&
+        typeof prop.enum[0] === 'string') {
+        return prop.enum[0];
+    }
+    return undefined;
+};
+/**
+ * Extract the negated enum values from a property schema.
+ * Returns the enum values if the property has { not: { enum: [...] } }, undefined otherwise.
+ */
+const getNegatedEnumValues = (prop) => {
+    if (prop.not &&
+        typeof prop.not === 'object' &&
+        prop.not !== null &&
+        Array.isArray(prop.not.enum) &&
+        prop.not.enum.every((v) => typeof v === 'string')) {
+        return prop.not.enum;
+    }
+    return undefined;
+};
+/**
+ * Attempts to find a discriminator property common to all options.
+ * A discriminator must:
+ * 1. Be present in 'properties' of all options (resolving $refs and allOf if needed)
+ * 2. Be required in all options (checking both direct required and allOf required)
+ * 3. Have a constant string value (const or enum: [val]) in all options, OR
+ *    have constant values in all but one option which has not:{enum:[those values]}
+ * 4. Have unique values across all options (for const values)
+ */
+const findImplicitDiscriminator = (options, refs) => {
+    if (options.length < 2)
+        return undefined;
+    // Fully resolve schemas and collect their properties (including from allOf)
+    const resolvedOptions = [];
+    for (const opt of options) {
+        if (typeof opt !== 'object' || opt === null)
+            return undefined;
+        let schemaObj = opt;
+        // Resolve ref if needed
+        if (schemaObj.$ref || schemaObj.$dynamicRef) {
+            const resolved = resolveRef(schemaObj, (schemaObj.$ref || schemaObj.$dynamicRef), refs);
+            if (resolved && typeof resolved.schema === 'object' && resolved.schema !== null) {
+                schemaObj = resolved.schema;
+            }
+            else {
+                return undefined;
+            }
+        }
+        // Must be an object type
+        if (schemaObj.type !== 'object') {
+            return undefined;
+        }
+        // Collect all properties including from allOf
+        const collected = collectSchemaProperties(schemaObj, refs);
+        if (!collected) {
+            return undefined;
+        }
+        resolvedOptions.push(collected);
+    }
+    // Get all possible keys from the first option
+    const firstProps = resolvedOptions[0].properties;
+    const candidateKeys = Object.keys(firstProps);
+    for (const key of candidateKeys) {
+        const constValues = [];
+        const constValuesSet = new Set();
+        let defaultIndex;
+        let defaultEnumValues;
+        let isValidDiscriminator = true;
+        for (let i = 0; i < resolvedOptions.length; i++) {
+            const opt = resolvedOptions[i];
+            // Must be required
+            if (!opt.required.includes(key)) {
+                isValidDiscriminator = false;
+                break;
+            }
+            const propBeforeResolve = opt.properties[key];
+            if (!propBeforeResolve) {
+                isValidDiscriminator = false;
+                break;
+            }
+            // Resolve property schema ref if needed (e.g. definitions/kind -> const)
+            let prop = propBeforeResolve;
+            if (typeof prop === 'object' && prop !== null && (prop.$ref || prop.$dynamicRef)) {
+                const resolvedProp = resolveRef(prop, (prop.$ref || prop.$dynamicRef), refs);
+                if (resolvedProp) {
+                    prop = resolvedProp.schema;
+                }
+            }
+            if (typeof prop !== 'object' || prop === null) {
+                isValidDiscriminator = false;
+                break;
+            }
+            // Check for constant value
+            const constValue = getConstValue(prop);
+            if (constValue !== undefined) {
+                if (constValuesSet.has(constValue)) {
+                    isValidDiscriminator = false; // Duplicate value found
+                    break;
+                }
+                constValuesSet.add(constValue);
+                constValues.push(constValue);
+                continue;
+            }
+            // Check for negated enum (default case pattern)
+            const negatedEnum = getNegatedEnumValues(prop);
+            if (negatedEnum !== undefined) {
+                if (defaultIndex !== undefined) {
+                    // Multiple defaults - can't optimize
+                    isValidDiscriminator = false;
+                    break;
+                }
+                defaultIndex = i;
+                defaultEnumValues = negatedEnum;
+                continue;
+            }
+            // Neither const nor not.enum - can't use discriminated union
+            isValidDiscriminator = false;
+            break;
+        }
+        if (!isValidDiscriminator) {
+            continue;
+        }
+        // Check if all options have const values (full discriminated union)
+        if (constValues.length === resolvedOptions.length) {
+            return { type: 'full', key };
+        }
+        // Check if we have a valid default case pattern
+        if (defaultIndex !== undefined &&
+            defaultEnumValues !== undefined &&
+            constValues.length === resolvedOptions.length - 1) {
+            // Verify the negated enum exactly matches the const values
+            const enumSet = new Set(defaultEnumValues);
+            if (setsEqual(constValuesSet, enumSet)) {
+                return { type: 'withDefault', key, defaultIndex, constValues };
+            }
+        }
+    }
+    return undefined;
+};
+export const parseOneOf = (schema, refs) => {
+    if (!schema.oneOf.length) {
+        return anyOrUnknown(refs);
+    }
+    if (schema.oneOf.length === 1) {
+        return parseSchema(schema.oneOf[0], {
+            ...refs,
+            path: [...refs.path, "oneOf", 0],
+        });
+    }
+    // Check if ALL oneOf members are "required-only" schemas
+    const requiredOnlyMembers = schema.oneOf.filter(isRequiredOnlySchema);
+    if (requiredOnlyMembers.length === schema.oneOf.length) {
+        const requiredCombinations = requiredOnlyMembers.map((m) => m.required);
+        return generateRequiredFieldsRefinement(requiredCombinations);
+    }
+    // Optimize: Check for implicit discriminated union
+    const discriminator = findImplicitDiscriminator(schema.oneOf, refs);
+    if (discriminator?.type === 'full') {
+        // All options have constant discriminator values
+        const options = schema.oneOf.map((s, i) => parseSchema(s, {
+            ...refs,
+            path: [...refs.path, "oneOf", i],
+        }));
+        const expressions = options.map(o => o.expression).join(", ");
+        const types = options.map(o => o.type).join(", ");
+        return {
+            expression: `z.discriminatedUnion("${discriminator.key}", [${expressions}])`,
+            // Use readonly tuple for union type annotations (required for recursive type inference)
+            type: `z.ZodDiscriminatedUnion<"${discriminator.key}", readonly [${types}]>`,
+        };
+    }
+    // Note: 'withDefault' case (discriminated union with catch-all) cannot be optimized
+    // in Zod v4 because ZodDiscriminatedUnion cannot be nested inside ZodUnion at the type level.
+    // The runtime would work, but the types wouldn't match, causing compile errors.
+    // So we fall through to the regular union handling below.
+    // Fallback: Standard z.union
+    const parsedSchemas = schema.oneOf.map((s, i) => {
+        const extracted = extractInlineObject(s, refs, [...refs.path, "oneOf", i]);
+        if (extracted) {
+            // extractInlineObject returns a refName string
+            return { expression: extracted, type: `typeof ${extracted}` };
+        }
+        let parsed = parseSchema(s, {
+            ...refs,
+            path: [...refs.path, "oneOf", i],
+        });
+        // Make regular unions stricter: if it's an object, it shouldn't match emptiness.
+        // Ensure we only apply .strict() to actual z.object() calls.
+        if (typeof s === "object" &&
+            s !== null &&
+            (s.type === "object" || s.properties) &&
+            !s.$ref &&
+            parsed.expression.startsWith("z.object(") && // Critical check: Must be a Zod object
+            !parsed.expression.includes(".and(") &&
+            !parsed.expression.includes(".intersection(") &&
+            !parsed.expression.includes(".strict()") &&
+            !parsed.expression.includes(".catchall") &&
+            !parsed.expression.includes(".passthrough")) {
+            parsed = {
+                expression: parsed.expression + ".strict()",
+                type: parsed.type, // .strict() doesn't change the Zod type
+            };
+        }
+        return parsed;
+    });
+    // Build the union types for the SchemaRepresentation
+    const unionTypes = parsedSchemas.map(r => r.type).join(", ");
+    const unionExpression = `z.union([${parsedSchemas.map(r => r.expression).join(", ")}])`;
+    if (refs.strictOneOf) {
+        const schemasExpressions = parsedSchemas.map(r => r.expression).join(", ");
+        const expression = `${unionExpression}.superRefine((x, ctx) => {
+    const schemas = [${schemasExpressions}];
+    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",
+      });
+    }
+  })`;
+        return {
+            expression,
+            // In Zod v4, .superRefine() doesn't change the type
+            type: `z.ZodUnion<readonly [${unionTypes}]>`,
+        };
+    }
+    return {
+        expression: unionExpression,
+        // Use readonly tuple for union type annotations (required for recursive type inference)
+        type: `z.ZodUnion<readonly [${unionTypes}]>`,
+    };
+};

package/dist/{esm/parsers → parsers}/parseSchema.js

@@ -17,7 +17,7 @@ import { parseSimpleDiscriminatedOneOf } from "./parseSimpleDiscriminatedOneOf.j
 import { parseNullable } from "./parseNullable.js";
 import { anyOrUnknown } from "../utils/anyOrUnknown.js";
 import { resolveUri } from "../utils/resolveUri.js";
-import { buildRefRegistry } from "../utils/buildRefRegistry.js";
+import { resolveRef } from "../utils/resolveRef.js";
 export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockMeta) => {
     // Ensure ref bookkeeping exists so $ref declarations and getter-based recursion work
     refs.root = refs.root ?? schema;
@@ -27,8 +27,11 @@ export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockM
     refs.inProgress = refs.inProgress ?? new Set();
     refs.refNameByPointer = refs.refNameByPointer ?? new Map();
     refs.usedNames = refs.usedNames ?? new Set();
-    if (typeof schema !== "object")
-        return schema ? anyOrUnknown(refs) : "z.never()";
+    if (typeof schema !== "object") {
+        return schema
+            ? anyOrUnknown(refs)
+            : { expression: "z.never()", type: "z.ZodNever" };
+    }
     const parentBase = refs.currentBaseUri ?? refs.rootBaseUri ?? "root:///";
     const baseUri = typeof schema.$id === "string" ? resolveUri(parentBase, schema.$id) : parentBase;
     const dynamicAnchors = Array.isArray(refs.dynamicAnchors) ? [...refs.dynamicAnchors] : [];
@@ -42,7 +45,8 @@ export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockM
     if (refs.parserOverride) {
         const custom = refs.parserOverride(schema, { ...refs, currentBaseUri: baseUri, dynamicAnchors });
         if (typeof custom === "string") {
-            return custom;
+            // ParserOverride returns string for backward compatibility
+            return { expression: custom, type: "z.ZodTypeAny" };
         }
     }
     let seen = refs.seen.get(schema);
@@ -91,7 +95,7 @@ const parseRef = (schema, refs) => {
     const refName = getOrCreateRefName(pointerKey, path, refs);
     if (!refs.declarations.has(refName) && !refs.inProgress.has(refName)) {
         refs.inProgress.add(refName);
-        const declaration = parseSchema(target, {
+        const result = parseSchema(target, {
             ...refs,
             path,
             currentBaseUri: resolved.baseUri,
@@ -99,7 +103,7 @@ const parseRef = (schema, refs) => {
             root: refs.root,
         });
         refs.inProgress.delete(refName);
-        refs.declarations.set(refName, declaration);
+        refs.declarations.set(refName, result);
     }
     const current = refs.currentSchemaName;
     if (current) {
@@ -116,23 +120,43 @@ const parseRef = (schema, refs) => {
         targetComponent !== undefined &&
         currentComponent === targetComponent &&
         refs.cycleRefNames?.has(refName);
-    // Only lazy if the ref stays inside the current strongly-connected component
-    // (or is currently being resolved). This avoids TDZ on true cycles while
-    // letting ordered, acyclic refs stay direct.
-    if (isSameCycle || refs.inProgress.has(refName)) {
-        const inObjectProperty = refs.path.includes("properties") ||
-            refs.path.includes("patternProperties") ||
-            refs.path.includes("additionalProperties");
-        if (inObjectProperty && refName === refs.currentSchemaName) {
-            // Getter properties defer evaluation, so a direct reference avoids extra lazies
-            // for self-recursion.
-            return refName;
+    // Check if this is a true forward reference (target not yet declared)
+    // We only need z.lazy() for forward refs, not for back-refs to already-declared schemas
+    const isForwardRef = refs.inProgress.has(refName);
+    const refType = `typeof ${refName}`;
+    // For same-cycle refs, check if we need special handling
+    if (isSameCycle || isForwardRef) {
+        // Check context: are we inside an object property where getters work?
+        // IMPORTANT: additionalProperties becomes z.record() which does NOT support getters
+        // Only named properties (properties, patternProperties) can use getters
+        const inNamedProperty = refs.path.includes("properties") ||
+            refs.path.includes("patternProperties");
+        // additionalProperties becomes z.record() value - getters don't work there
+        // Per Zod issue #4881: z.record() with recursive values REQUIRES z.lazy()
+        const inRecordContext = refs.path.includes("additionalProperties");
+        // Self-recursion in named object properties: use direct ref (getter handles deferred eval)
+        const isSelfRecursion = refName === refs.currentSchemaName;
+        if (inNamedProperty && isSelfRecursion) {
+            return { expression: refName, type: refType };
+        }
+        // Cross-schema refs in named object properties within same cycle: use direct ref
+        // The getter in parseObject.ts will handle deferred evaluation
+        if (inNamedProperty && isSameCycle && !isForwardRef) {
+            return { expression: refName, type: refType };
+        }
+        // z.record() values with recursive refs MUST use z.lazy() (Colin confirmed in #4881)
+        // Also arrays, unions, and other non-object contexts with forward refs need z.lazy()
+        if (isForwardRef || inRecordContext) {
+            return {
+                expression: `z.lazy(() => ${refName})`,
+                type: `z.ZodLazy<${refType}>`
+            };
         }
-        return `z.lazy(() => ${refName})`;
     }
-    return refName;
+    return { expression: refName, type: refType };
 };
 const addDescribes = (schema, parsed, refs) => {
+    let { expression, type } = parsed;
     // Use .meta() for richer metadata when withMeta is enabled
     if (refs?.withMeta) {
         const meta = {};
@@ -147,103 +171,13 @@ const addDescribes = (schema, parsed, refs) => {
         if (schema.deprecated)
             meta.deprecated = schema.deprecated;
         if (Object.keys(meta).length > 0) {
-            parsed += `.meta(${JSON.stringify(meta)})`;
+            expression += `.meta(${JSON.stringify(meta)})`;
         }
     }
     else if (schema.description) {
-        parsed += `.describe(${JSON.stringify(schema.description)})`;
+        expression += `.describe(${JSON.stringify(schema.description)})`;
     }
-    return parsed;
-};
-const resolveRef = (schemaNode, ref, refs) => {
-    const base = refs.currentBaseUri ?? refs.rootBaseUri ?? "root:///";
-    // Handle dynamicRef lookup via dynamicAnchors stack
-    const isDynamic = typeof schemaNode.$dynamicRef === "string";
-    if (isDynamic && refs.dynamicAnchors && ref.startsWith("#")) {
-        const name = ref.slice(1);
-        for (let i = refs.dynamicAnchors.length - 1; i >= 0; i -= 1) {
-            const entry = refs.dynamicAnchors[i];
-            if (entry.name === name) {
-                const key = `${entry.uri}#${name}`;
-                const target = refs.refRegistry?.get(key);
-                if (target) {
-                    return { schema: target.schema, path: target.path, baseUri: target.baseUri, pointerKey: key };
-                }
-            }
-        }
-    }
-    // Resolve URI against base
-    const resolvedUri = resolveUri(base, ref);
-    const [uriBase, fragment] = resolvedUri.split("#");
-    const key = fragment ? `${uriBase}#${fragment}` : uriBase;
-    let regEntry = refs.refRegistry?.get(key);
-    if (regEntry) {
-        return { schema: regEntry.schema, path: regEntry.path, baseUri: regEntry.baseUri, pointerKey: key };
-    }
-    // Legacy recursive ref: treat as dynamic to __recursive__
-    if (schemaNode.$recursiveRef) {
-        const recursiveKey = `${base}#__recursive__`;
-        regEntry = refs.refRegistry?.get(recursiveKey);
-        if (regEntry) {
-            return {
-                schema: regEntry.schema,
-                path: regEntry.path,
-                baseUri: regEntry.baseUri,
-                pointerKey: recursiveKey,
-            };
-        }
-    }
-    // External resolver hook
-    const extBase = uriBaseFromRef(resolvedUri);
-    if (refs.resolveExternalRef && extBase && !isLocalBase(extBase, refs.rootBaseUri ?? "")) {
-        const loaded = refs.resolveExternalRef(extBase);
-        if (loaded) {
-            // If async resolver is used synchronously here, it will be ignored; keep simple sync for now
-            const maybePromise = loaded;
-            const schema = typeof maybePromise.then === "function"
-                ? undefined
-                : loaded;
-            if (schema) {
-                const { registry } = buildRefRegistry(schema, extBase);
-                registry.forEach((entry, k) => refs.refRegistry?.set(k, entry));
-                regEntry = refs.refRegistry?.get(key);
-                if (regEntry) {
-                    return {
-                        schema: regEntry.schema,
-                        path: regEntry.path,
-                        baseUri: regEntry.baseUri,
-                        pointerKey: key,
-                    };
-                }
-            }
-        }
-    }
-    // Backward compatibility: JSON Pointer into root
-    if (refs.root && ref.startsWith("#/")) {
-        const rawSegments = ref
-            .slice(2)
-            .split("/")
-            .filter((segment) => segment.length > 0)
-            .map(decodePointerSegment);
-        let current = refs.root;
-        for (const segment of rawSegments) {
-            if (typeof current !== "object" || current === null)
-                return undefined;
-            current = current[segment];
-        }
-        return { schema: current, path: rawSegments, baseUri: base, pointerKey: ref };
-    }
-    return undefined;
-};
-const decodePointerSegment = (segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~");
-const uriBaseFromRef = (resolvedUri) => {
-    const hashIdx = resolvedUri.indexOf("#");
-    return hashIdx === -1 ? resolvedUri : resolvedUri.slice(0, hashIdx);
-};
-const isLocalBase = (base, rootBase) => {
-    if (!rootBase)
-        return false;
-    return base === rootBase;
+    return { expression, type };
 };
 const getOrCreateRefName = (pointer, path, refs) => {
     if (refs.refNameByPointer?.has(pointer)) {
@@ -297,16 +231,20 @@ const sanitizeIdentifier = (value) => {
 };
 const capitalize = (value) => value.length ? value[0].toUpperCase() + value.slice(1) : value;
 const addDefaults = (schema, parsed) => {
+    let { expression, type } = parsed;
     if (schema.default !== undefined) {
-        parsed += `.default(${JSON.stringify(schema.default)})`;
+        expression += `.default(${JSON.stringify(schema.default)})`;
+        type = `z.ZodDefault<${type}>`;
     }
-    return parsed;
+    return { expression, type };
 };
 const addAnnotations = (schema, parsed) => {
+    let { expression, type } = parsed;
     if (schema.readOnly) {
-        parsed += ".readonly()";
+        expression += ".readonly()";
+        type = `z.ZodReadonly<${type}>`;
     }
-    return parsed;
+    return { expression, type };
 };
 const selectParser = (schema, refs) => {
     if (its.a.nullable(schema)) {
@@ -334,7 +272,7 @@ const selectParser = (schema, refs) => {
         return parseNot(schema, refs);
     }
     else if (its.an.enum(schema)) {
-        return parseEnum(schema); //<-- needs to come before primitives
+        return parseEnum(schema);
     }
     else if (its.a.const(schema)) {
         return parseConst(schema);

package/dist/parsers/parseSimpleDiscriminatedOneOf.js

@@ -0,0 +1,24 @@
+import { parseSchema } from "./parseSchema.js";
+import { anyOrUnknown } from "../utils/anyOrUnknown.js";
+export const parseSimpleDiscriminatedOneOf = (schema, refs) => {
+    const discriminator = schema.discriminator.propertyName;
+    const options = schema.oneOf.map((option, i) => parseSchema(option, {
+        ...refs,
+        path: [...refs.path, "oneOf", i],
+    }));
+    if (!schema.oneOf.length) {
+        return anyOrUnknown(refs);
+    }
+    if (schema.oneOf.length === 1) {
+        return parseSchema(schema.oneOf[0], {
+            ...refs,
+            path: [...refs.path, "oneOf", 0],
+        });
+    }
+    const expressions = options.map(o => o.expression).join(", ");
+    const types = options.map(o => o.type).join(", ");
+    return {
+        expression: `z.discriminatedUnion("${discriminator}", [${expressions}])`,
+        type: `z.ZodDiscriminatedUnion<"${discriminator}", [${types}]>`,
+    };
+};