quicktype-core 23.0.99 → 23.0.101

package/dist/language/Golang.d.ts

@@ -5,6 +5,7 @@ import { Sourcelike } from "../Source";
 import { TargetLanguage } from "../TargetLanguage";
 import { ConvenienceRenderer } from "../ConvenienceRenderer";
 import { RenderContext } from "../Renderer";
+import { StringTypeMapping } from "..";
 export declare const goOptions: {
     justTypes: BooleanOption;
     justTypesAndPackage: BooleanOption;
@@ -17,6 +18,7 @@ export declare class GoTargetLanguage extends TargetLanguage {
     constructor();
     protected getOptions(): Option<any>[];
     get supportsUnionsWithBothNumberTypes(): boolean;
+    get stringTypeMapping(): StringTypeMapping;
     get supportsOptionalClassProperties(): boolean;
     protected makeRenderer(renderContext: RenderContext, untypedOptionValues: {
         [name: string]: any;
@@ -48,6 +50,10 @@ export declare class GoRenderer extends ConvenienceRenderer {
     private emitUnion;
     private emitSingleFileHeaderComments;
     private emitPackageDefinitons;
+    private emitImports;
     private emitHelperFunctions;
     protected emitSourceStructure(): void;
+    private collectAllImports;
+    private collectClassImports;
+    private collectUnionImports;
 }

package/dist/language/Golang.js

@@ -36,6 +36,11 @@ class GoTargetLanguage extends TargetLanguage_1.TargetLanguage {
     get supportsUnionsWithBothNumberTypes() {
         return true;
     }
+    get stringTypeMapping() {
+        const mapping = new Map();
+        mapping.set("date-time", "date-time");
+        return mapping;
+    }
     get supportsOptionalClassProperties() {
         return true;
     }
@@ -57,7 +62,7 @@ const primitiveValueTypeKinds = ["integer", "double", "bool", "string"];
 const compoundTypeKinds = ["array", "class", "map", "enum"];
 function isValueType(t) {
     const kind = t.kind;
-    return primitiveValueTypeKinds.indexOf(kind) >= 0 || kind === "class" || kind === "enum";
+    return primitiveValueTypeKinds.indexOf(kind) >= 0 || kind === "class" || kind === "enum" || kind === "date-time";
 }
 function canOmitEmpty(cp) {
     if (!cp.isOptional)
@@ -154,6 +159,11 @@ class GoRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             if (nullable !== null)
                 return this.nullableGoType(nullable, withIssues);
             return this.nameForNamedType(unionType);
+        }, transformedStringType => {
+            if (transformedStringType.kind === "date-time") {
+                return "time.Time";
+            }
+            return "string";
         });
     }
     emitTopLevel(t, name) {
@@ -190,8 +200,8 @@ class GoRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     }
     emitClass(c, className) {
         this.startFile(className);
-        this.emitPackageDefinitons(false);
         let columns = [];
+        const usedTypes = new Set();
         this.forEachClassProperty(c, "none", (name, jsonName, p) => {
             const description = this.descriptionForClassProperty(c, jsonName);
             const docStrings = description !== undefined && description.length > 0 ? description.map(d => "// " + d) : [];
@@ -207,7 +217,9 @@ class GoRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
                 [goType, " "],
                 ["`", tags, "`"]
             ]);
+            usedTypes.add(goType.toString());
         });
+        this.emitPackageDefinitons(false, usedTypes.has("time.Time") || usedTypes.has("*,time.Time") ? new Set(["time"]) : undefined);
         this.emitDescription(this.descriptionForType(c));
         this.emitStruct(className, columns);
         this.endFile();
@@ -310,7 +322,7 @@ class GoRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("//    bytes, err = ", ref, ".Marshal()");
         });
     }
-    emitPackageDefinitons(includeJSONEncodingImport) {
+    emitPackageDefinitons(includeJSONEncodingImport, imports = new Set()) {
         if (!this._options.justTypes || this._options.justTypesAndPackage) {
             this.ensureBlankLine();
             const packageDeclaration = "package " + this._options.packageName;
@@ -318,25 +330,35 @@ class GoRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.ensureBlankLine();
         }
         if (!this._options.justTypes && !this._options.justTypesAndPackage) {
-            this.ensureBlankLine();
             if (this.haveNamedUnions && this._options.multiFileOutput === false) {
-                this.emitLineOnce('import "bytes"');
-                this.emitLineOnce('import "errors"');
+                imports.add("bytes");
+                imports.add("errors");
             }
             if (includeJSONEncodingImport) {
-                this.emitLineOnce('import "encoding/json"');
+                imports.add("encoding/json");
             }
-            this.ensureBlankLine();
         }
+        this.emitImports(imports);
+    }
+    emitImports(imports) {
+        const sortedImports = Array.from(imports).sort((a, b) => a.localeCompare(b));
+        if (sortedImports.length === 0) {
+            return;
+        }
+        sortedImports.forEach(packageName => {
+            this.emitLineOnce(`import "${packageName}"`);
+        });
+        this.ensureBlankLine();
     }
     emitHelperFunctions() {
         if (this.haveNamedUnions) {
             this.startFile("JSONSchemaSupport");
-            this.emitPackageDefinitons(true);
+            const imports = new Set();
             if (this._options.multiFileOutput) {
-                this.emitLineOnce('import "bytes"');
-                this.emitLineOnce('import "errors"');
+                imports.add("bytes");
+                imports.add("errors");
             }
+            this.emitPackageDefinitons(true, imports);
             this.ensureBlankLine();
             this
                 .emitMultiline(`func unmarshalUnion(data []byte, pi **int64, pf **float64, pb **bool, ps **string, haveArray bool, pa interface{}, haveObject bool, pc interface{}, haveMap bool, pm interface{}, haveEnum bool, pe interface{}, nullable bool) (bool, error) {
@@ -461,6 +483,7 @@ func marshalUnion(pi *int64, pf *float64, pb *bool, ps *string, haveArray bool,
             this._options.justTypesAndPackage === false &&
             this.leadingComments === undefined) {
             this.emitSingleFileHeaderComments();
+            this.emitPackageDefinitons(false, this.collectAllImports());
         }
         this.forEachTopLevel("leading-and-interposing", (t, name) => this.emitTopLevel(t, name), t => !(this._options.justTypes || this._options.justTypesAndPackage) ||
             this.namedTypeToNameForTopLevel(t) === undefined);
@@ -472,5 +495,54 @@ func marshalUnion(pi *int64, pf *float64, pb *bool, ps *string, haveArray bool,
         }
         this.emitHelperFunctions();
     }
+    collectAllImports() {
+        let imports = new Set();
+        this.forEachObject("leading-and-interposing", (c, _className) => {
+            const classImports = this.collectClassImports(c);
+            imports = new Set([...imports, ...classImports]);
+        });
+        this.forEachUnion("leading-and-interposing", (u, _unionName) => {
+            const unionImports = this.collectUnionImports(u);
+            imports = new Set([...imports, ...unionImports]);
+        });
+        return imports;
+    }
+    collectClassImports(c) {
+        const usedTypes = new Set();
+        const mapping = new Map();
+        mapping.set("time.Time", "time");
+        mapping.set("*,time.Time", "time");
+        this.forEachClassProperty(c, "none", (_name, _jsonName, p) => {
+            const goType = this.propertyGoType(p);
+            usedTypes.add(goType.toString());
+        });
+        const imports = new Set();
+        usedTypes.forEach(k => {
+            const typeImport = mapping.get(k);
+            if (typeImport) {
+                imports.add(typeImport);
+            }
+        });
+        return imports;
+    }
+    collectUnionImports(u) {
+        const usedTypes = new Set();
+        const mapping = new Map();
+        mapping.set("time.Time", "time");
+        mapping.set("*,time.Time", "time");
+        this.forEachUnionMember(u, null, "none", null, (_fieldName, t) => {
+            const goType = this.nullableGoType(t, true);
+            usedTypes.add(goType.toString());
+        });
+        const imports = new Set();
+        usedTypes.forEach(k => {
+            const typeImport = mapping.get(k);
+            if (!typeImport) {
+                return;
+            }
+            imports.add(typeImport);
+        });
+        return imports;
+    }
 }
 exports.GoRenderer = GoRenderer;

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.99",
+    "version": "23.0.101",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",