@snowtop/ent 0.1.0-alpha110 → 0.1.0-alpha111

package/package.json

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

package/schema/json_field.d.ts

@@ -11,7 +11,7 @@ export declare class JSONField extends BaseField implements Field {
     private options?;
     type: Type;
     constructor(jsonb: boolean, options?: allJSONOptions | undefined);
-    format(val: any): string;
+    format(val: any, nested?: boolean): any;
     valid(val: any): boolean;
 }
 export declare function JSONType(options?: JSONOptions): JSONField;

package/schema/json_field.js

@@ -22,7 +22,10 @@ class JSONField extends field_1.BaseField {
             };
         }
     }
-    format(val) {
+    format(val, nested) {
+        if (nested) {
+            return val;
+        }
         return JSON.stringify(val);
     }
     valid(val) {

package/schema/schema.d.ts

@@ -203,6 +203,7 @@ export interface FieldOptions {
     foreignKey?: ForeignKey;
     fieldEdge?: FieldEdge;
     primaryKey?: boolean;
+    immutable?: boolean;
     disableUserEditable?: boolean;
     disableUserGraphQLEditable?: boolean;
     defaultValueOnCreate?(builder: Builder<Ent>, input: Data): any;

package/testutils/ent-graphql-tests/index.js

@@ -162,8 +162,9 @@ function makeGraphQLRequest(config, query, fieldArgs) {
 }
 function buildTreeFromQueryPaths(schema, fieldType, ...options) {
     let fields;
-    if (fieldType instanceof graphql_1.GraphQLObjectType) {
-        fields = fieldType.getFields();
+    const [typ] = getInnerType(fieldType, false);
+    if (typ instanceof graphql_1.GraphQLObjectType) {
+        fields = typ.getFields();
     }
     let topLevelTree = {};
     options.forEach((option) => {
@@ -201,10 +202,11 @@ function buildTreeFromQueryPaths(schema, fieldType, ...options) {
             }
             // TODO this needs to be aware of paths etc so this part works for complicated
             // cases but inlineFragmentRoot is a workaround for now.
-            function handleSubtree(obj, tree) {
+            function handleSubtree(obj, tree, parts) {
+                let parts2 = [...parts];
                 if (Array.isArray(obj)) {
                     for (const obj2 of obj) {
-                        handleSubtree(obj2, tree);
+                        handleSubtree(obj2, tree, parts2);
                     }
                     return;
                 }
@@ -213,28 +215,36 @@ function buildTreeFromQueryPaths(schema, fieldType, ...options) {
                         tree[key] = {};
                     }
                     if (typeof obj[key] === "object") {
-                        if (!isScalarField(key)) {
-                            handleSubtree(obj[key], tree[key]);
+                        let parts2 = [...parts, key];
+                        if (!scalarFieldAtLeaf(parts2)) {
+                            handleSubtree(obj[key], tree[key], parts2);
                         }
                     }
                 }
             }
-            // TODO this needs to work for super complicated objects and have fields update as nesting applies...
-            function isScalarField(f) {
-                const subField = fields?.[f];
-                if (!subField) {
+            function scalarFieldAtLeaf(pathFromRoot) {
+                let root = fields;
+                if (!root) {
                     return false;
                 }
-                if (!(0, graphql_1.isWrappingType)(subField.type)) {
+                let subField;
+                for (const p of pathFromRoot) {
+                    subField = root?.[p];
+                    if (subField) {
+                        [subField] = getInnerType(subField.type, false);
+                        if (subField instanceof graphql_1.GraphQLObjectType) {
+                            root = subField.getFields();
+                        }
+                    }
+                }
+                if (!subField) {
                     return false;
                 }
-                // only spread out if an object
-                const [typ, _] = getInnerType(subField.type, true);
-                return (0, graphql_1.isScalarType)(typ) || (0, graphql_1.isEnumType)(typ);
+                return (0, graphql_1.isScalarType)(subField) || (0, graphql_1.isEnumType)(subField);
             }
             if (i === parts.length - 1 && typeof option[1] === "object") {
-                if (!isScalarField(part)) {
-                    handleSubtree(option[1], tree);
+                if (!scalarFieldAtLeaf(parts)) {
+                    handleSubtree(option[1], tree, parts);
                 }
             }
         }