quicktype-core 23.3.21 → 23.3.23

package/dist/language/TypeScriptZod/TypeScriptZodRenderer.d.ts

@@ -8,6 +8,10 @@ import { type ClassProperty, type EnumType, ObjectType, type Type } from "../../
 import type { typeScriptZodOptions } from "./language";
 export declare class TypeScriptZodRenderer extends ConvenienceRenderer {
     protected readonly _options: OptionValues<typeof typeScriptZodOptions>;
+    /** TypeRefs of object types that participate in a reference cycle.
+     * These must be emitted as z.lazy() schemas with an explicit type
+     * annotation, since zod cannot infer recursive types. */
+    private _recursiveTypeRefs;
     constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, _options: OptionValues<typeof typeScriptZodOptions>);
     protected forbiddenNamesForGlobalNamespace(): string[];
     protected nameStyle(original: string, upper: boolean): string;
@@ -19,7 +23,23 @@ export declare class TypeScriptZodRenderer extends ConvenienceRenderer {
     protected emitImports(): void;
     protected typeMapTypeForProperty(p: ClassProperty): Sourcelike;
     protected typeMapTypeFor(t: Type, required?: boolean): Sourcelike;
+    /** TypeScript type for `t`, used to annotate recursive schemas for
+     * which zod cannot infer the type.
+     *
+     * This intentionally duplicates neither `typeMapTypeFor` above nor
+     * `sourceFor` in the plain TypeScript renderer
+     * (`TypeScriptFlowBaseRenderer`): it must mirror exactly what
+     * `z.infer` would derive from the schemas emitted by
+     * `typeMapTypeFor` (e.g. `z.coerce.date()` implies `Date`), while
+     * `sourceFor` is shaped by ts/flow-specific options like
+     * `preferConstValues` and `declareUnions` that don't exist here. */
+    protected underlyingTypeFor(t: Type): Sourcelike;
+    protected isRecursive(t: ObjectType): boolean;
     protected emitObject(name: Name, t: ObjectType): void;
+    /** Emit a recursive object type. zod cannot infer recursive types, so
+     * the type is declared explicitly and the schema is wrapped in
+     * z.lazy() with a z.ZodType annotation. */
+    protected emitLazyObject(name: Name, t: ObjectType): void;
     protected emitEnum(e: EnumType, enumName: Name): void;
     /** Static function that extracts underlying type refs for types that form part of the
      * definition of the passed type - used to ensure that these appear in generated source

package/dist/language/TypeScriptZod/TypeScriptZodRenderer.js

@@ -14,6 +14,10 @@ class TypeScriptZodRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     constructor(targetLanguage, renderContext, _options) {
         super(targetLanguage, renderContext);
         this._options = _options;
+        /** TypeRefs of object types that participate in a reference cycle.
+         * These must be emitted as z.lazy() schemas with an explicit type
+         * annotation, since zod cannot infer recursive types. */
+        this._recursiveTypeRefs = new Set();
     }
     forbiddenNamesForGlobalNamespace() {
         return ["Class", "Date", "Object", "String", "Array", "JSON", "Error"];
@@ -72,7 +76,46 @@ class TypeScriptZodRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         }
         return match;
     }
+    /** TypeScript type for `t`, used to annotate recursive schemas for
+     * which zod cannot infer the type.
+     *
+     * This intentionally duplicates neither `typeMapTypeFor` above nor
+     * `sourceFor` in the plain TypeScript renderer
+     * (`TypeScriptFlowBaseRenderer`): it must mirror exactly what
+     * `z.infer` would derive from the schemas emitted by
+     * `typeMapTypeFor` (e.g. `z.coerce.date()` implies `Date`), while
+     * `sourceFor` is shaped by ts/flow-specific options like
+     * `preferConstValues` and `declareUnions` that don't exist here. */
+    underlyingTypeFor(t) {
+        if (["class", "object", "enum"].includes(t.kind)) {
+            return this.nameForNamedType(t);
+        }
+        return (0, TypeUtils_1.matchType)(t, (_anyType) => "any", (_nullType) => "null", (_boolType) => "boolean", (_integerType) => "number", (_doubleType) => "number", (_stringType) => "string", (arrayType) => [
+            "Array<",
+            this.underlyingTypeFor(arrayType.items),
+            ">",
+        ], (_classType) => (0, Support_1.panic)("Should already be handled."), (mapType) => [
+            "Record<string, ",
+            this.underlyingTypeFor(mapType.values),
+            ">",
+        ], (_enumType) => (0, Support_1.panic)("Should already be handled."), (unionType) => {
+            const children = Array.from(unionType.getChildren()).map((type) => this.underlyingTypeFor(type));
+            return (0, collection_utils_1.arrayIntercalate)(" | ", children);
+        }, (_transformedStringType) => {
+            if (_transformedStringType.kind === "date-time") {
+                return "Date";
+            }
+            return "string";
+        });
+    }
+    isRecursive(t) {
+        return this._recursiveTypeRefs.has(t.typeRef);
+    }
     emitObject(name, t) {
+        if (this.isRecursive(t)) {
+            this.emitLazyObject(name, t);
+            return;
+        }
         this.ensureBlankLine();
         this.emitLine("\nexport const ", name, "Schema = ", "z.object({");
         this.indent(() => {
@@ -85,6 +128,35 @@ class TypeScriptZodRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("export type ", name, " = z.infer<typeof ", name, "Schema>;");
         }
     }
+    /** Emit a recursive object type. zod cannot infer recursive types, so
+     * the type is declared explicitly and the schema is wrapped in
+     * z.lazy() with a z.ZodType annotation. */
+    emitLazyObject(name, t) {
+        this.ensureBlankLine();
+        if (this._options.justSchema) {
+            this.emitLine("\nexport const ", name, "Schema: z.ZodType<any> = z.lazy(() =>");
+        }
+        else {
+            this.emitLine("\nexport type ", name, " = {");
+            this.indent(() => {
+                this.forEachClassProperty(t, "none", (_, jsonName, property) => {
+                    this.emitLine(`"${(0, Strings_1.utf16StringEscape)(jsonName)}"`, property.isOptional ? "?" : "", ": ", this.underlyingTypeFor(property.type), ";");
+                });
+            });
+            this.emitLine("};");
+            this.emitLine("export const ", name, "Schema: z.ZodType<", name, "> = z.lazy(() =>");
+        }
+        this.indent(() => {
+            this.emitLine("z.object({");
+            this.indent(() => {
+                this.forEachClassProperty(t, "none", (_, jsonName, property) => {
+                    this.emitLine(`"${(0, Strings_1.utf16StringEscape)(jsonName)}"`, ": ", this.typeMapTypeForProperty(property), ",");
+                });
+            });
+            this.emitLine("})");
+        });
+        this.emitLine(");");
+    }
     emitEnum(e, enumName) {
         this.ensureBlankLine();
         this.emitDescription(this.descriptionForType(e));
@@ -164,10 +236,44 @@ class TypeScriptZodRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             });
             mapChildTypeRefs.push(childTypeRefs);
         });
+        // Find types that participate in a reference cycle: types from
+        // which we can get back to the same type by following child type
+        // references. Those can never be topologically ordered.
+        const indexForTypeRef = new Map();
+        mapTypeRef.forEach((typeRef, index) => indexForTypeRef.set(typeRef, index));
+        this._recursiveTypeRefs = new Set();
+        mapType.forEach((_, startIndex) => {
+            const visited = new Set();
+            const stack = [...mapChildTypeRefs[startIndex]];
+            while (stack.length > 0) {
+                const childRef = stack.pop();
+                const childIndex = indexForTypeRef.get(childRef);
+                if (childIndex === undefined)
+                    continue;
+                if (childIndex === startIndex) {
+                    this._recursiveTypeRefs.add(mapTypeRef[startIndex]);
+                    break;
+                }
+                if (visited.has(childIndex))
+                    continue;
+                visited.add(childIndex);
+                stack.push(...mapChildTypeRefs[childIndex]);
+            }
+        });
         // Items to process on this pass
         let indices = [];
         mapType.forEach((_, index) => {
-            indices.push(index);
+            if (this._recursiveTypeRefs.has(mapTypeRef[index])) {
+                // Recursive types are emitted first: they are wrapped in
+                // z.lazy(), so all their references to other schemas are
+                // deferred until parse time and don't constrain the
+                // output order, while other schemas can reference them
+                // directly.
+                order.push(index);
+            }
+            else {
+                indices.push(index);
+            }
         });
         // items to process on the next pass
         let deferredIndices = [];
@@ -214,8 +320,9 @@ class TypeScriptZodRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             deferredIndices = [];
             passNum++;
             if (passNum > MAX_PASSES) {
-                // giving up
-                order.push(...deferredIndices);
+                // giving up: emit the stuck items anyway rather than
+                // silently dropping them
+                order.push(...indices);
                 console.warn("Exceeded maximum number of passes when determining output order, output may contain forward references");
             }
         } while (indices.length > 0 && passNum <= MAX_PASSES);

package/dist/rewrites/FlattenUnions.js

@@ -11,16 +11,67 @@ const TypeUtils_1 = require("../Type/TypeUtils");
 const UnifyClasses_1 = require("../UnifyClasses");
 function flattenUnions(graph, stringTypeMapping, conflateNumbers, makeObjectTypes, debugPrintReconstitution) {
     let needsRepeat = false;
+    // During flattening, recursive unions can appear again while their replacement
+    // is still being built.  For example, flattening `A | M` can later ask for
+    // `A | (A | M)` through an array item or object property.  Those are the same
+    // union by associativity/idempotence, so remember each in-progress flattened
+    // union by a normalized key of its non-union member refs.  Looking up that key
+    // lets recursive occurrences reuse the replacement's forwarding ref instead
+    // of allocating another finite unrolling of the same cycle.
+    const unionKeyToRef = new Map();
+    function addUnionKeyAtoms(t, atoms, seen) {
+        const index = t.index;
+        if (seen.has(index))
+            return;
+        seen.add(index);
+        if (t instanceof Type_1.UnionType) {
+            for (const m of t.members) {
+                addUnionKeyAtoms(m, atoms, seen);
+            }
+        }
+        else {
+            atoms.add((0, TypeRef_1.typeRefIndex)(t.typeRef));
+        }
+    }
+    function unionKeyForTypes(types) {
+        const atoms = new Set();
+        const seen = new Set();
+        for (const t of types) {
+            addUnionKeyAtoms(t, atoms, seen);
+        }
+        return Array.from(atoms)
+            .sort((a, b) => a - b)
+            .join(",");
+    }
     function replace(types, builder, forwardingRef) {
-        const unionBuilder = new UnifyClasses_1.UnifyUnionBuilder(builder, makeObjectTypes, true, (trefs) => {
+        unionKeyToRef.set(unionKeyForTypes(types), forwardingRef);
+        let unionBuilder;
+        const unifyTypeRefs = (trefs) => {
             (0, Support_1.assert)(trefs.length > 0, "Must have at least one type to build union");
-            trefs = trefs.map((tref) => builder.reconstituteType((0, TypeRef_1.derefTypeRef)(tref, graph)));
-            if (trefs.length === 1) {
-                return trefs[0];
+            const maybeReconstituted = builder.lookupTypeRefs(trefs, undefined, false);
+            if (maybeReconstituted !== undefined) {
+                return maybeReconstituted;
+            }
+            const typesToUnify = new Set(trefs.map((tref) => (0, TypeRef_1.derefTypeRef)(tref, graph)));
+            if ((0, collection_utils_1.iterableSome)(typesToUnify, (t) => t instanceof Type_1.IntersectionType)) {
+                trefs = trefs.map((tref) => builder.reconstituteType((0, TypeRef_1.derefTypeRef)(tref, graph)));
+                if (trefs.length === 1) {
+                    return trefs[0];
+                }
+                needsRepeat = true;
+                return builder.getUnionType(TypeAttributes_1.emptyTypeAttributes, new Set(trefs));
+            }
+            const key = unionKeyForTypes(typesToUnify);
+            const maybeRef = unionKeyToRef.get(key);
+            if (maybeRef !== undefined) {
+                return maybeRef;
             }
-            needsRepeat = true;
-            return builder.getUnionType(TypeAttributes_1.emptyTypeAttributes, new Set(trefs));
-        });
+            return builder.withForwardingRef(undefined, (nestedForwardingRef) => {
+                unionKeyToRef.set(key, nestedForwardingRef);
+                return (0, UnifyClasses_1.unifyTypes)(typesToUnify, TypeAttributes_1.emptyTypeAttributes, builder, unionBuilder, conflateNumbers, nestedForwardingRef);
+            });
+        };
+        unionBuilder = new UnifyClasses_1.UnifyUnionBuilder(builder, makeObjectTypes, true, unifyTypeRefs);
         return (0, UnifyClasses_1.unifyTypes)(types, TypeAttributes_1.emptyTypeAttributes, builder, unionBuilder, conflateNumbers, forwardingRef);
     }
     const allUnions = (0, collection_utils_1.setFilter)(graph.allTypesUnordered(), (t) => t instanceof Type_1.UnionType);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "23.3.21",
+    "version": "23.3.23",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",