quicktype-core 23.3.21 → 23.3.22

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

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