@snowtop/ent 0.1.0-alpha110 → 0.1.0-alpha112

package/action/orchestrator.js

@@ -35,6 +35,7 @@ const executor_1 = require("./executor");
 const logger_1 = require("../core/logger");
 const memoizee_1 = __importDefault(require("memoizee"));
 const clause = __importStar(require("../core/clause"));
+const util_1 = require("util");
 var edgeDirection;
 (function (edgeDirection) {
     edgeDirection[edgeDirection["inboundEdge"] = 0] = "inboundEdge";
@@ -272,12 +273,32 @@ class Orchestrator {
         }
         return new EntCannotDeleteEntError(privacyPolicy, action, this.existingEnt);
     }
-    getEntForPrivacyPolicyImpl(editedData) {
+    async getEntForPrivacyPolicyImpl(schemaFields, editedData) {
         if (this.actualOperation !== action_1.WriteOperation.Insert) {
             return this.existingEnt;
         }
+        // need to format fields if possible because ent constructors expect data that's
+        // in the format that's coming from the db
+        // required for object fields...
+        const formatted = { ...editedData };
+        for (const [fieldName, field] of schemaFields) {
+            if (!field.format) {
+                continue;
+            }
+            let dbKey = this.getStorageKey(fieldName);
+            let val = formatted[dbKey];
+            if (!val) {
+                continue;
+            }
+            // nested so it's not JSON stringified or anything like that
+            val = field.format(formatted[dbKey], true);
+            if (util_1.types.isPromise(val)) {
+                val = await val;
+            }
+            formatted[dbKey] = val;
+        }
         // we create an unsafe ent to be used for privacy policies
-        return new this.options.builder.ent(this.options.builder.viewer, editedData);
+        return new this.options.builder.ent(this.options.builder.viewer, formatted);
     }
     getSQLStatementOperation() {
         switch (this.actualOperation) {
@@ -307,8 +328,8 @@ class Orchestrator {
         if (this.actualOperation !== action_1.WriteOperation.Insert) {
             return this.existingEnt;
         }
-        const { editedData } = await this.memoizedGetFields();
-        return this.getEntForPrivacyPolicyImpl(editedData);
+        const { schemaFields, editedData } = await this.memoizedGetFields();
+        return this.getEntForPrivacyPolicyImpl(schemaFields, editedData);
     }
     // this gets the fields that were explicitly set plus any default or transformed values
     // mainly exists to get default fields e.g. default id to be used in triggers
@@ -359,7 +380,7 @@ class Orchestrator {
         let privacyError = null;
         if (privacyPolicy) {
             try {
-                await (0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, this.getEntForPrivacyPolicyImpl(editedData), this.throwError.bind(this));
+                await (0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, await this.getEntForPrivacyPolicyImpl(schemaFields, editedData), this.throwError.bind(this));
             }
             catch (err) {
                 privacyError = err;
@@ -536,11 +557,17 @@ class Orchestrator {
                         if (defaultValue === undefined) {
                             throw new Error(`defaultValueOnCreate() returned undefined for field ${fieldName}`);
                         }
+                        if (util_1.types.isPromise(defaultValue)) {
+                            defaultValue = await defaultValue;
+                        }
                     }
                 }
                 if (field.defaultValueOnEdit &&
                     this.actualOperation === action_1.WriteOperation.Edit) {
                     defaultValue = field.defaultValueOnEdit(builder, input);
+                    if (util_1.types.isPromise(defaultValue)) {
+                        defaultValue = await defaultValue;
+                    }
                 }
             }
             if (value !== undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha110",
+  "version": "0.1.0-alpha112",
   "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);
                 }
             }
         }