quicktype-core 23.0.100 → 23.0.101

package/dist/language/TypeScriptZod.d.ts

@@ -33,6 +33,14 @@ export declare class TypeScriptZodRenderer extends ConvenienceRenderer {
     protected typeMapTypeFor(t: Type, required?: boolean): Sourcelike;
     protected emitObject(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
+     * before types that reference them.
+     *
+     * Primitive types don't need defining and enums are output before other types, hence,
+     * these are ignored.
+     */
+    static extractUnderlyingTyperefs(type: Type): number[];
     protected emitSchemas(): void;
     protected emitSourceStructure(): void;
 }

package/dist/language/TypeScriptZod.js

@@ -6,6 +6,7 @@ const ConvenienceRenderer_1 = require("../ConvenienceRenderer");
 const Naming_1 = require("../Naming");
 const RendererOptions_1 = require("../RendererOptions");
 const TargetLanguage_1 = require("../TargetLanguage");
+const Type_1 = require("../Type");
 const TypeUtils_1 = require("../TypeUtils");
 const Acronyms_1 = require("../support/Acronyms");
 const Strings_1 = require("../support/Strings");
@@ -114,41 +115,127 @@ class TypeScriptZodRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("export type ", enumName, " = z.infer<typeof ", enumName, "Schema>;");
         }
     }
+    /** 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
+     * before types that reference them.
+     *
+     * Primitive types don't need defining and enums are output before other types, hence,
+     * these are ignored.
+     */
+    static extractUnderlyingTyperefs(type) {
+        let typeRefs = [];
+        //Ignore enums and primitives
+        if (!type.isPrimitive() && type.kind != "enum") {
+            //need to extract constituent types for unions and intersections (which both extend SetOperationType)
+            //and can ignore the union/intersection itself
+            if (type instanceof Type_1.SetOperationType) {
+                type.members.forEach(member => {
+                    //recurse as the underlying type could itself be a union, instersection or array etc.
+                    typeRefs.push(...TypeScriptZodRenderer.extractUnderlyingTyperefs(member));
+                });
+            }
+            //need to extract additional properties for object, class and map types (which all extend ObjectType)
+            if (type instanceof Type_1.ObjectType) {
+                const addType = type.getAdditionalProperties();
+                if (addType) {
+                    //recurse as the underlying type could itself be a union, instersection or array etc.
+                    typeRefs.push(...TypeScriptZodRenderer.extractUnderlyingTyperefs(addType));
+                }
+            }
+            //need to extract items types for ArrayType
+            if (type instanceof Type_1.ArrayType) {
+                const itemsType = type.items;
+                if (itemsType) {
+                    //recurse as the underlying type could itself be a union, instersection or array etc.
+                    typeRefs.push(...TypeScriptZodRenderer.extractUnderlyingTyperefs(itemsType));
+                }
+            }
+            //Finally return the reference to a class as that will need to be defined (where objects, maps, unions, intersections and arrays do not)
+            if (type instanceof Type_1.ClassType) {
+                typeRefs.push(type.typeRef);
+            }
+        }
+        return typeRefs;
+    }
     emitSchemas() {
         this.ensureBlankLine();
         this.forEachEnum("leading-and-interposing", (u, enumName) => {
             this.emitEnum(u, enumName);
         });
+        // All children must be defined before this type to avoid forward references in generated code
+        // Build a model that will tell us if a referenced type has been defined then make multiple
+        // passes over the defined objects to put them into the correct order for output in the
+        // generated sourcecode
         const order = [];
-        const mapKey = [];
-        const mapValue = [];
+        const mapType = [];
+        const mapTypeRef = [];
+        const mapName = [];
+        const mapChildTypeRefs = [];
         this.forEachObject("none", (type, name) => {
-            mapKey.push(name);
-            mapValue.push(this.gatherSource(() => this.emitObject(name, type)));
+            mapType.push(type);
+            mapTypeRef.push(type.typeRef);
+            mapName.push(name);
+            const children = type.getChildren();
+            let childTypeRefs = [];
+            children.forEach(child => {
+                childTypeRefs = childTypeRefs.concat(TypeScriptZodRenderer.extractUnderlyingTyperefs(child));
+            });
+            mapChildTypeRefs.push(childTypeRefs);
         });
-        mapKey.forEach((_, index) => {
-            // assume first
-            let ordinal = 0;
-            // pull out all names
-            const source = mapValue[index];
-            const names = source.filter(value => value);
-            // must be behind all these names
-            for (let i = 0; i < names.length; i++) {
-                const depName = names[i];
-                // find this name's ordinal, if it has already been added
-                for (let j = 0; j < order.length; j++) {
-                    const depIndex = order[j];
-                    if (mapKey[depIndex] === depName) {
-                        // this is the index of the dependency, so make sure we come after it
-                        ordinal = Math.max(ordinal, depIndex + 1);
+        //Items to process on this pass
+        let indices = [];
+        mapType.forEach((_, index) => {
+            indices.push(index);
+        });
+        //items to process on the next pass
+        let deferredIndices = [];
+        //defensive: make sure we don't loop forever, even complex sets shouldn't require many passes
+        const MAX_PASSES = 999;
+        let passNum = 0;
+        do {
+            indices.forEach(index => {
+                // must be behind all these children
+                const childTypeRefs = mapChildTypeRefs[index];
+                let foundAllChildren = true;
+                childTypeRefs.forEach(childRef => {
+                    //defensive: first check if there is a definition for the referenced type (there should be)
+                    if (mapTypeRef.indexOf(childRef) > -1) {
+                        let found = false;
+                        // find this childs's ordinal, if it has already been added
+                        //faster to go through what we've defined so far than all definitions
+                        for (let j = 0; j < order.length; j++) {
+                            const childIndex = order[j];
+                            if (mapTypeRef[childIndex] === childRef) {
+                                found = true;
+                                break;
+                            }
+                        }
+                        foundAllChildren = foundAllChildren && found;
+                    }
+                    else {
+                        console.error("A child type reference was not found amongst all Object definitions! TypeRef: " + childRef);
                     }
+                });
+                if (foundAllChildren) {
+                    // insert index into order as we are safe to define this type
+                    order.push(index);
                 }
+                else {
+                    //defer to a subsequent pass as we need to define other types
+                    deferredIndices.push(index);
+                }
+            });
+            indices = deferredIndices;
+            deferredIndices = [];
+            passNum++;
+            if (passNum > MAX_PASSES) {
+                //giving up
+                order.push(...deferredIndices);
+                console.warn("Exceeded maximum number of passes when determining output order, output may contain forward references");
             }
-            // insert index
-            order.splice(ordinal, 0, index);
-        });
+        } while (indices.length > 0 && passNum <= MAX_PASSES);
         // now emit ordered source
-        order.forEach(i => this.emitGatheredSource(mapValue[i]));
+        order.forEach(i => this.emitGatheredSource(this.gatherSource(() => this.emitObject(mapName[i], mapType[i]))));
     }
     emitSourceStructure() {
         if (this.leadingComments !== undefined) {

package/package.json

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