@snowtop/ent 0.1.0-alpha16 → 0.1.0-alpha160-test2

package/schema/struct_field.js

@@ -1,44 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StructListType = exports.StructType = exports.StructField = void 0;
+exports.StructTypeAsList = exports.StructListType = exports.StructType = exports.StructField = void 0;
+const camel_case_1 = require("camel-case");
 const field_1 = require("./field");
 const schema_1 = require("./schema");
-const camel_case_1 = require("camel-case");
+const global_schema_1 = require("../core/global_schema");
+const logger_1 = require("../core/logger");
 class StructField extends field_1.BaseField {
-    constructor(options) {
+    constructor(options, jsonAsList) {
         super();
         this.options = options;
+        this.jsonAsList = jsonAsList;
         this.type = {
             dbType: schema_1.DBType.JSONB,
         };
         this.type.subFields = options.fields;
         this.type.type = options.tsType;
         this.type.graphQLType = options.graphQLType || options.tsType;
+        this.type.globalType = this.options.globalType;
         if (options.jsonNotJSONB) {
             this.type.dbType = schema_1.DBType.JSON;
         }
+        if (jsonAsList) {
+            this.type.listElemType = {
+                dbType: schema_1.DBType.JSONB,
+            };
+        }
     }
-    // right now, we store things in the db in lowerCase format
-    // this will lead to issues if field changes.
-    // TODO: use storageKey and convert back...
-    format(obj, nested) {
+    formatImpl(obj, nested) {
         if (!(obj instanceof Object)) {
             throw new Error("valid was not called");
         }
         let ret = {};
         for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            // check two values
+            // store in dbKey format
             // TODO more #510
-            let dbKey = (0, camel_case_1.camelCase)(k);
-            let val = obj[dbKey];
-            // for tests with snake_case
-            if (val === undefined && obj[k] !== undefined) {
-                val = obj[k];
-                dbKey = k;
+            let dbKey = (0, schema_1.getStorageKey)(field, k);
+            let camelKey = (0, camel_case_1.camelCase)(k);
+            let val = obj[camelKey];
+            if (val === undefined && obj[dbKey] !== undefined) {
+                val = obj[dbKey];
             }
             if (val === undefined) {
                 continue;
             }
-            const field = this.options.fields[k];
             if (field.format) {
                 // indicate nested so this isn't JSON stringified
                 ret[dbKey] = field.format(val, true);
@@ -47,13 +54,53 @@ class StructField extends field_1.BaseField {
                 ret[dbKey] = val;
             }
         }
-        // don't json.stringify if nested
+        // don't json.stringify if nested or list
         if (nested) {
             return ret;
         }
         return JSON.stringify(ret);
     }
-    async valid(obj) {
+    format(obj, nested) {
+        if (this.type.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            if (f && f.format) {
+                if (JSON.stringify(this.type.listElemType) !==
+                    JSON.stringify(f?.type.listElemType)) {
+                    if (this.jsonAsList) {
+                        // handle as nested
+                        // @ts-ignore
+                        const formatted = obj.map((v) => f.format(v, true));
+                        if (nested) {
+                            return formatted;
+                        }
+                        else {
+                            return JSON.stringify(formatted);
+                        }
+                    }
+                    else {
+                        const formatted = f.format([obj], true);
+                        if (nested) {
+                            return formatted[0];
+                        }
+                        else {
+                            return JSON.stringify(formatted[0]);
+                        }
+                    }
+                }
+                // TODO handle format code
+                return f.format(obj);
+            }
+        }
+        if (Array.isArray(obj) && this.jsonAsList) {
+            const ret = obj.map((v) => this.formatImpl(v, true));
+            if (nested) {
+                return ret;
+            }
+            return JSON.stringify(ret);
+        }
+        return this.formatImpl(obj, nested);
+    }
+    async validImpl(obj) {
         if (!(obj instanceof Object)) {
             return false;
         }
@@ -63,12 +110,11 @@ class StructField extends field_1.BaseField {
         for (const k in this.options.fields) {
             const field = this.options.fields[k];
             // TODO more #510
-            let dbKey = (0, camel_case_1.camelCase)(k);
-            let val = obj[dbKey];
-            // for tests with snake_case
-            if (val === undefined && obj[k] !== undefined) {
-                val = obj[k];
-                dbKey = k;
+            let dbKey = (0, schema_1.getStorageKey)(field, k);
+            let camelKey = (0, camel_case_1.camelCase)(k);
+            let val = obj[camelKey];
+            if (val === undefined && obj[dbKey] !== undefined) {
+                val = obj[dbKey];
             }
             if (val === undefined || val === null) {
                 // nullable, nothing to do here
@@ -89,6 +135,47 @@ class StructField extends field_1.BaseField {
         const ret = await Promise.all(promises);
         return ret.every((v) => v);
     }
+    async valid(obj) {
+        if (this.type.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            // list and global type is not valid.
+            if (f) {
+                if (f.valid) {
+                    if (JSON.stringify(this.type.listElemType) !==
+                        JSON.stringify(f?.type.listElemType)) {
+                        if (this.jsonAsList) {
+                            if (!Array.isArray(obj)) {
+                                return false;
+                            }
+                            // @ts-ignore
+                            const valid = await Promise.all(obj.map((v) => f.valid(v)));
+                            return valid.every((b) => b);
+                        }
+                        else {
+                            return f.valid([obj]);
+                        }
+                    }
+                    return f.valid(obj);
+                }
+                return true;
+            }
+            else {
+                (0, logger_1.log)("error", `globalType ${this.type.globalType} not found in global schema`);
+                return false;
+            }
+        }
+        if (this.jsonAsList) {
+            if (!Array.isArray(obj)) {
+                return false;
+            }
+            const valid = await Promise.all(obj.map((v) => this.validImpl(v)));
+            return valid.every((b) => b);
+        }
+        if (!(obj instanceof Object)) {
+            return false;
+        }
+        return this.validImpl(obj);
+    }
 }
 exports.StructField = StructField;
 function StructType(options) {
@@ -96,7 +183,15 @@ function StructType(options) {
     return Object.assign(result, options);
 }
 exports.StructType = StructType;
+/**
+ * @deprecated use StructTypeAsList
+ */
 function StructListType(options) {
     return new field_1.ListField(StructType(options), options);
 }
 exports.StructListType = StructListType;
+function StructTypeAsList(options) {
+    let result = new StructField(options, true);
+    return Object.assign(result, options);
+}
+exports.StructTypeAsList = StructTypeAsList;

package/schema/union_field.d.ts

@@ -15,7 +15,7 @@ export declare class UnionField extends BaseField implements FieldOptions {
     type: Type;
     m: Map<Object, string>;
     constructor(options: UnionOptions);
-    format(obj: any): string | Object;
+    format(obj: any): any;
     private validField;
     valid(obj: any): Promise<boolean>;
 }

package/scripts/custom_compiler.js

@@ -2,7 +2,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -25,7 +29,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const typescript_1 = __importDefault(require("typescript"));
 const path = __importStar(require("path"));
-const glob_1 = __importDefault(require("glob"));
+const glob = __importStar(require("glob"));
 const compilerOptions_1 = require("../tsc/compilerOptions");
 // TODO this should probably be its own package but for now it's here
 class Compiler {
@@ -193,7 +197,7 @@ class Compiler {
                     }
                     relPath = path.relative(
                     // just because of how imports work. it's relative from directory not current path
-                    path.dirname(fullPath), path.join(text.substr(0, idx).replace(r, str.substr(0, strIdx)), text.substr(idx)));
+                    path.dirname(fullPath), path.join(text.substring(0, idx).replace(r, str.substring(0, strIdx)), text.substring(idx)));
                     // if file ends with "..", we've reached a case where we're trying to
                     // import something like foo/contact(.ts) from within foo/contact/bar/baz/page.ts
                     // and we're confused about it so we need to detect that case and handle it
@@ -204,7 +208,7 @@ class Compiler {
                             let text2 = text + ".ts";
                             relPath = path.relative(
                             // just because of how imports work. it's relative from directory not current path
-                            path.dirname(fullPath), path.join(text2.substr(0, idx).replace(r, str.substr(0, strIdx)), text2.substr(idx)));
+                            path.dirname(fullPath), path.join(text2.substring(0, idx).replace(r, str.substring(0, strIdx)), text2.substring(idx)));
                         }
                     }
                     if (!relPath.startsWith("..")) {
@@ -213,7 +217,7 @@ class Compiler {
                     // tsc removes this by default so we need to also do it
                     let tsIdx = relPath.indexOf(".ts");
                     if (tsIdx !== -1) {
-                        relPath = relPath.substr(0, tsIdx);
+                        relPath = relPath.substring(0, tsIdx);
                     }
                     return relPath;
                 }
@@ -225,7 +229,7 @@ class Compiler {
                     let relPath = checkPath(paths, text);
                     if (relPath) {
                         // update the node...
-                        return typescript_1.default.updateImportDeclaration(importNode, importNode.decorators, importNode.modifiers, importNode.importClause, typescript_1.default.createLiteral(relPath));
+                        return typescript_1.default.factory.updateImportDeclaration(importNode, importNode.modifiers, importNode.importClause, typescript_1.default.factory.createStringLiteral(relPath), importNode.assertClause);
                     }
                 }
                 if (node.kind === typescript_1.default.SyntaxKind.ExportDeclaration) {
@@ -235,7 +239,7 @@ class Compiler {
                         let relPath = checkPath(paths, text);
                         if (relPath) {
                             // update the node...
-                            return typescript_1.default.updateExportDeclaration(exportNode, exportNode.decorators, exportNode.modifiers, exportNode.exportClause, typescript_1.default.createLiteral(relPath), exportNode.isTypeOnly);
+                            return typescript_1.default.factory.updateExportDeclaration(exportNode, exportNode.modifiers, exportNode.isTypeOnly, exportNode.exportClause, typescript_1.default.factory.createStringLiteral(relPath), exportNode.assertClause);
                         }
                     }
                 }
@@ -261,6 +265,6 @@ class Compiler {
 // todo this should be configurable
 // TODO this should be broken into its own repo and npm module
 // TODO use includes and exclude in tsconfig.json if it exists
-new Compiler(glob_1.default.sync("**/*.ts", {
+new Compiler(glob.sync("**/*.ts", {
     ignore: ["node_modules/**", "tests/**", "**/*.test.ts"],
 }), ["node_modules/@types/node"]).compile();

package/scripts/custom_graphql.js

@@ -2,7 +2,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -23,19 +27,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const glob_1 = __importDefault(require("glob"));
+const glob = __importStar(require("glob"));
 const json5_1 = __importDefault(require("json5"));
 const minimist_1 = __importDefault(require("minimist"));
-const graphql_1 = require("../graphql/graphql");
-const readline = __importStar(require("readline"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const graphql_1 = require("../graphql/graphql");
+const readline = __importStar(require("readline"));
 const imports_1 = require("../imports");
 const process_1 = require("process");
+const child_process_1 = require("child_process");
+const const_1 = require("../core/const");
 // need to use the GQLCapture from the package so that when we call GQLCapture.enable()
 // we're affecting the local paths as opposed to a different instance
 // life is hard
-const MODULE_PATH = "@snowtop/ent/graphql";
+const MODULE_PATH = const_1.GRAPHQL_PATH;
 async function readInputs() {
     return await new Promise((resolve) => {
         const rl = readline.createInterface({
@@ -54,14 +60,7 @@ async function readInputs() {
         });
     });
 }
-function processCustomObjects(l, gqlCapture, input) {
-    let m;
-    if (input) {
-        m = gqlCapture.getCustomInputObjects();
-    }
-    else {
-        m = gqlCapture.getCustomObjects();
-    }
+function processCustomObjects(l, gqlCapture, m) {
     for (const input of l) {
         m.set(input.name, {
             nodeName: input.graphQLName || input.name,
@@ -72,7 +71,7 @@ function processCustomObjects(l, gqlCapture, input) {
         }
     }
 }
-function transformArgs(f) {
+function transformArgs(f, gqlCapture) {
     return (f.args || []).map((v) => {
         const ret = {
             ...v,
@@ -80,13 +79,25 @@ function transformArgs(f) {
         // duplicated from getType in graphql.ts
         if ((0, graphql_1.isCustomType)(ret.type)) {
             ret.type = v.type.type;
-            (0, graphql_1.addCustomType)(v.type);
+            (0, graphql_1.addCustomType)(v.type, gqlCapture);
         }
         // scalar types not supported for now
         ret.tsType = graphql_1.knownAllowedNames.get(v.type);
         return ret;
     });
 }
+function transformFieldTypeInput(input) {
+    switch (input) {
+        case "ACCESSOR":
+            return graphql_1.CustomFieldType.Accessor;
+        case "ASYNC_FUNCTION":
+            return graphql_1.CustomFieldType.AsyncFunction;
+        case "FUNCTION":
+            return graphql_1.CustomFieldType.Function;
+        case "FIELD":
+            return graphql_1.CustomFieldType.Field;
+    }
+}
 function transformResultType(f) {
     return f.resultType
         ? [
@@ -95,60 +106,119 @@ function transformResultType(f) {
                 type: f.resultType,
                 tsType: graphql_1.knownAllowedNames.get(f.resultType),
                 list: f.list,
+                connection: f.connection,
                 nullable: f.nullable,
             },
         ]
         : [];
 }
-function processTopLevel(l, l2) {
+function processTopLevel(l, l2, gqlCapture) {
     for (const custom of l) {
         l2.push({
-            nodeName: custom.class,
-            functionName: custom.functionName || custom.name,
-            gqlName: custom.graphQLName || custom.name,
-            fieldType: custom.fieldType,
-            args: transformArgs(custom),
+            nodeName: custom.class ?? "",
+            functionName: custom.functionName || custom.name || "",
+            gqlName: custom.graphQLName || custom.name || "",
+            edgeName: custom.edgeName,
+            fieldType: transformFieldTypeInput(custom.fieldType),
+            args: transformArgs(custom, gqlCapture),
             results: transformResultType(custom),
+            description: custom.description,
+            extraImports: custom.extraImports,
+            functionContents: custom.functionContents,
         });
     }
 }
+function processCustomTypes(m, gqlCapture) {
+    for (const k in m) {
+        (0, graphql_1.addCustomType)(m[k], gqlCapture);
+    }
+}
 function processCustomFields(fields, gqlCapture, nodeName) {
     const m = gqlCapture.getCustomFields();
     let results = [];
     for (const f of fields) {
         results.push({
             nodeName: nodeName,
-            gqlName: f.graphQLName || f.name,
-            functionName: f.functionName || f.name,
-            fieldType: f.fieldType,
-            args: transformArgs(f),
+            gqlName: f.graphQLName || f.name || "",
+            functionName: f.functionName || f.name || "",
+            fieldType: transformFieldTypeInput(f.fieldType),
+            args: transformArgs(f, gqlCapture),
             results: transformResultType(f),
+            description: f.description,
         });
     }
     m.set(nodeName, results);
 }
+async function captureDynamic(filePath, gqlCapture) {
+    if (!filePath) {
+        return;
+    }
+    return new Promise((resolve, reject) => {
+        let args = [];
+        const env = {
+            ...process.env,
+        };
+        // really only exists if there's a bug with swc or something. we should almost always be using swc
+        if (process.env.DISABLE_SWC) {
+            args = ["--transpileOnly", filePath];
+        }
+        else {
+            args = ["--swc", filePath];
+            // we seem to get tsconfig-paths by default because child process but not 100% sure...
+            env.SWCRC = "true";
+        }
+        const r = (0, child_process_1.spawn)("ts-node", args, {
+            env,
+        });
+        const datas = [];
+        r.stdout.on("data", (data) => {
+            datas.push(data.toString());
+        });
+        r.stderr.on("data", (data) => {
+            reject(new Error(data.toString()));
+        });
+        r.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`error code ${code} on dynamic path`));
+                return;
+            }
+            let json = json5_1.default.parse(datas.join(""));
+            processJSON(gqlCapture, json);
+            resolve(undefined);
+        });
+    });
+}
+async function processJSON(gqlCapture, json) {
+    if (json.fields) {
+        for (const k in json.fields) {
+            processCustomFields(json.fields[k], gqlCapture, k);
+        }
+    }
+    if (json.inputs) {
+        processCustomObjects(json.inputs, gqlCapture, gqlCapture.getCustomInputObjects());
+    }
+    if (json.objects) {
+        processCustomObjects(json.objects, gqlCapture, gqlCapture.getCustomObjects());
+    }
+    if (json.args) {
+        processCustomObjects(json.args, gqlCapture, gqlCapture.getCustomArgs());
+    }
+    if (json.queries) {
+        processTopLevel(json.queries, gqlCapture.getCustomQueries(), gqlCapture);
+    }
+    if (json.mutations) {
+        processTopLevel(json.mutations, gqlCapture.getCustomMutations(), gqlCapture);
+    }
+    if (json.customTypes) {
+        processCustomTypes(json.customTypes, gqlCapture);
+    }
+}
 async function captureCustom(filePath, filesCsv, jsonPath, gqlCapture) {
     if (jsonPath !== undefined) {
         let json = json5_1.default.parse(fs.readFileSync(jsonPath, {
             encoding: "utf8",
         }));
-        if (json.fields) {
-            for (const k in json.fields) {
-                processCustomFields(json.fields[k], gqlCapture, k);
-            }
-        }
-        if (json.inputs) {
-            processCustomObjects(json.inputs, gqlCapture, true);
-        }
-        if (json.objects) {
-            processCustomObjects(json.objects, gqlCapture);
-        }
-        if (json.queries) {
-            processTopLevel(json.queries, gqlCapture.getCustomQueries());
-        }
-        if (json.mutations) {
-            processTopLevel(json.mutations, gqlCapture.getCustomMutations());
-        }
+        processJSON(gqlCapture, json);
         return;
     }
     if (filesCsv !== undefined) {
@@ -178,12 +248,12 @@ async function captureCustom(filePath, filesCsv, jsonPath, gqlCapture) {
         // ignore test files.
         "**/*.test.ts",
     ];
-    const customGQLResolvers = glob_1.default.sync(path.join(filePath, "/graphql/resolvers/**/*.ts"), {
+    const customGQLResolvers = glob.sync(path.join(filePath, "/graphql/resolvers/**/*.ts"), {
         // no actions for now to speed things up
         // no index.ts or internal file.
         ignore: ignore,
     });
-    const customGQLMutations = glob_1.default.sync(path.join(filePath, "/graphql/mutations/**/*.ts"), {
+    const customGQLMutations = glob.sync(path.join(filePath, "/graphql/mutations/**/*.ts"), {
         // no actions for now to speed things up
         // no index.ts or internal file.
         ignore: ignore,
@@ -208,11 +278,27 @@ async function requireFiles(files) {
         throw new Error(err);
     });
 }
+// filePath is path-to-src
 async function parseImports(filePath) {
-    // only do graphql files...
-    return (0, imports_1.parseCustomImports)(path.join(filePath, "graphql"), {
-        ignore: ["**/generated/**", "**/tests/**"],
-    });
+    return (0, imports_1.parseCustomImports)(filePath, [
+        {
+            // graphql files
+            root: path.join(filePath, "graphql"),
+            opts: {
+                ignore: ["**/generated/**", "**/tests/**"],
+            },
+        },
+        {
+            // can't just use top level ent files but have to check for all (non-generated) files
+            // in src/ent/* because custom edges (or other things) could have @gqlField etc
+            // and then have to look for these imports etc
+            root: path.join(filePath, "ent"),
+            opts: {
+                // not in action files since we can't customize payloads (yet?)
+                ignore: ["**/generated/**", "**/tests/**", "**/actions/**"],
+            },
+        },
+    ]);
 }
 function findGraphQLPath(filePath) {
     while (filePath !== "/") {
@@ -227,21 +313,11 @@ function findGraphQLPath(filePath) {
     }
     return undefined;
 }
+// test as follows:
+// there should be an easier way to do this...
+// also, there should be a way to get the list of objects here that's not manual
+//echo "User\nContact\nContactEmail\nComment" | ts-node-script --log-error --project ./tsconfig.json -r tsconfig-paths/register ../../ts/src/scripts/custom_graphql.ts --path ~/code/ent/examples/simple/src/
 async function main() {
-    // known custom types that are not required
-    // if not in the schema, will be ignored
-    // something like GraphQLUpload gotten via gqlArg({type: gqlFileUpload})
-    // these 2 need this because they're added by the schema
-    // if this list grows too long, need to build this into golang types and passed here
-    // TODO foreign non-scalars eventually
-    (0, graphql_1.addCustomType)({
-        importPath: "../graphql/scalars/time",
-        type: "GraphQLTime",
-    });
-    (0, graphql_1.addCustomType)({
-        importPath: "graphql-type-json",
-        type: "GraphQLJSON",
-    });
     const options = (0, minimist_1.default)(process.argv.slice(2));
     if (!options.path) {
         throw new Error("path required");
@@ -266,9 +342,28 @@ async function main() {
         gqlCapture = r.GQLCapture;
         gqlCapture.enable(true);
     }
-    const [inputsRead, _, imports] = await Promise.all([
+    // known custom types that are not required
+    // if not in the schema, will be ignored
+    // something like GraphQLUpload gotten via gqlArg({type: gqlFileUpload})
+    // these 2 need this because they're added by the schema
+    // if this list grows too long, need to build this into golang types and passed here
+    // TODO foreign non-scalars eventually
+    (0, graphql_1.addCustomType)({
+        importPath: MODULE_PATH,
+        // for go tests...
+        // TODO need a flag that only does this for go tests
+        // breaks when running locally sometimes...
+        secondaryImportPath: "../graphql/scalars/time",
+        type: "GraphQLTime",
+    }, gqlCapture);
+    (0, graphql_1.addCustomType)({
+        importPath: "graphql-type-json",
+        type: "GraphQLJSON",
+    }, gqlCapture);
+    const [inputsRead, _, __, imports] = await Promise.all([
         readInputs(),
         captureCustom(options.path, options.files, options.json_path, gqlCapture),
+        captureDynamic(options.dynamic_path, gqlCapture),
         parseImports(options.path),
     ]);
     const { nodes, nodesMap } = inputsRead;
@@ -286,6 +381,8 @@ async function main() {
     let queries = gqlCapture.getProcessedCustomQueries();
     let mutations = gqlCapture.getProcessedCustomMutations();
     let objects = fromMap(gqlCapture.getCustomObjects());
+    let interfaces = fromMap(gqlCapture.getCustomInterfaces());
+    let unions = fromMap(gqlCapture.getCustomUnions());
     let customTypes = fromMap(gqlCapture.getCustomTypes());
     let classes = {};
     let allFiles = {};
@@ -325,7 +422,7 @@ async function main() {
     };
     const buildClasses = (fields) => {
         fields.forEach((field) => {
-            if (!nodesMap.has(field.nodeName)) {
+            if (field.nodeName && !nodesMap.has(field.nodeName)) {
                 let info = imports.getInfoForClass(field.nodeName);
                 classes[field.nodeName] = { ...info.class, path: info.file.path };
                 buildFiles(info.file);
@@ -336,6 +433,10 @@ async function main() {
     };
     buildClasses(mutations);
     buildClasses(queries);
+    // call for every field in a node
+    for (const k in fields) {
+        buildClasses(fields[k]);
+    }
     console.log(JSON.stringify({
         args,
         inputs,
@@ -344,6 +445,8 @@ async function main() {
         mutations,
         classes,
         objects,
+        interfaces,
+        unions,
         files: allFiles,
         customTypes,
     }));