@snowtop/ent 0.1.0-alpha157 → 0.1.0-alpha159

package/graphql/graphql.d.ts

@@ -1,12 +1,58 @@
 import { GraphQLScalarType } from "graphql";
-import { FieldMap } from "src/schema";
+import type { FieldMap } from "../schema";
 import { ProcessedField as ParsedProcessedField } from "../parse_schema/parse";
+import { ImportPath } from "../schema/schema";
 interface ClassType<T = any> {
     new (...args: any[]): T;
 }
 declare type StringToStringMap = {
     [key: string]: string;
 };
+interface CustomFieldInput {
+    graphQLName?: string;
+    name?: string;
+    functionName?: string;
+    args?: Field[];
+    results?: Field[];
+    fieldType: CustomFieldTypeInput;
+    description?: string;
+}
+interface CustomTopLevelInput {
+    class?: string;
+    graphQLName?: string;
+    name?: string;
+    functionName?: string;
+    edgeName?: string;
+    args?: Field[];
+    results?: Field[];
+    extraImports?: ImportPath[];
+    functionContents?: string;
+    fieldType: CustomFieldTypeInput;
+    description?: string;
+    list?: boolean;
+    connection?: boolean;
+    resultType?: string;
+}
+type CustomFieldInputMap = {
+    [key: string]: CustomFieldInput[];
+};
+type CustomTypeInputMap = {
+    [key: string]: CustomTypeInput;
+};
+interface CustomObjectInput {
+    name: string;
+    graphQLName?: string;
+    fields?: CustomFieldInput[];
+}
+export interface CustomGraphQLInput {
+    fields?: CustomFieldInputMap;
+    inputs?: CustomObjectInput[];
+    objects?: CustomObjectInput[];
+    args?: CustomObjectInput[];
+    queries?: CustomTopLevelInput[];
+    mutations?: CustomTopLevelInput[];
+    customTypes?: CustomTypeInputMap;
+}
 export interface CustomTypeInput {
     type: string;
     importPath: string;
@@ -60,6 +106,7 @@ export declare enum CustomFieldType {
     Function = "FUNCTION",
     AsyncFunction = "ASYNC_FUNCTION"
 }
+export type CustomFieldTypeInput = "ACCESSOR" | "FIELD" | "FUNCTION" | "ASYNC_FUNCTION";
 interface CustomFieldImpl {
     nodeName: string;
     gqlName: string;
@@ -71,7 +118,7 @@ interface CustomFieldImpl {
 export interface CustomField extends CustomFieldImpl {
     args: Field[];
     results: Field[];
-    extraImports?: any[];
+    extraImports?: ImportPath[];
     functionContents?: string;
     edgeName?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha157",
+  "version": "0.1.0-alpha159",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/schema/schema.d.ts

@@ -86,7 +86,7 @@ export interface AssocEdgeGroup {
     edgeAction?: EdgeGroupAction;
 }
 export type Edge = AssocEdge;
-interface ImportPath {
+export interface ImportPath {
     importPath: string;
     import: string;
     defaultImport?: boolean;

package/scripts/custom_graphql.js

@@ -60,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,
@@ -93,6 +86,18 @@ function transformArgs(f, gqlCapture) {
         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
         ? [
@@ -110,11 +115,11 @@ function transformResultType(f) {
 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,
+            nodeName: custom.class ?? "",
+            functionName: custom.functionName || custom.name || "",
+            gqlName: custom.graphQLName || custom.name || "",
             edgeName: custom.edgeName,
-            fieldType: custom.fieldType,
+            fieldType: transformFieldTypeInput(custom.fieldType),
             args: transformArgs(custom, gqlCapture),
             results: transformResultType(custom),
             description: custom.description,
@@ -134,9 +139,9 @@ function processCustomFields(fields, gqlCapture, nodeName) {
     for (const f of fields) {
         results.push({
             nodeName: nodeName,
-            gqlName: f.graphQLName || f.name,
-            functionName: f.functionName || f.name,
-            fieldType: f.fieldType,
+            gqlName: f.graphQLName || f.name || "",
+            functionName: f.functionName || f.name || "",
+            fieldType: transformFieldTypeInput(f.fieldType),
             args: transformArgs(f, gqlCapture),
             results: transformResultType(f),
             description: f.description,
@@ -194,10 +199,13 @@ async function processJSON(gqlCapture, json) {
         }
     }
     if (json.inputs) {
-        processCustomObjects(json.inputs, gqlCapture, true);
+        processCustomObjects(json.inputs, gqlCapture, gqlCapture.getCustomInputObjects());
     }
     if (json.objects) {
-        processCustomObjects(json.objects, gqlCapture);
+        processCustomObjects(json.objects, gqlCapture, gqlCapture.getCustomObjects());
+    }
+    if (json.args) {
+        processCustomObjects(json.args, gqlCapture, gqlCapture.getCustomArgs());
     }
     if (json.queries) {
         processTopLevel(json.queries, gqlCapture.getCustomQueries(), gqlCapture);
@@ -419,13 +427,9 @@ async function main() {
     const buildClasses = (fields) => {
         fields.forEach((field) => {
             if (field.nodeName && !nodesMap.has(field.nodeName)) {
-                // TODO don't necessarily wanna do this
-                try {
-                    let info = imports.getInfoForClass(field.nodeName);
-                    classes[field.nodeName] = { ...info.class, path: info.file.path };
-                    buildFiles(info.file);
-                }
-                catch (err) { }
+                let info = imports.getInfoForClass(field.nodeName);
+                classes[field.nodeName] = { ...info.class, path: info.file.path };
+                buildFiles(info.file);
             }
             buildClasses2(field.args);
             buildClasses2(field.results);