@snowtop/ent 0.0.30-alpha → 0.0.32-alpha.10

package/action/action.d.ts

@@ -7,7 +7,7 @@ export declare enum WriteOperation {
     Delete = "delete"
 }
 export interface Builder<T extends Ent> {
-    existingEnt?: Ent;
+    existingEnt?: T;
     ent: EntConstructor<T>;
     placeholderID: ID;
     readonly viewer: Viewer;

package/action/experimental_action.d.ts

@@ -1,4 +1,4 @@
-import { Viewer, Ent } from "../core/base";
+import { Viewer, Ent, Data } from "../core/base";
 import { Action, WriteOperation, Builder, Trigger, Observer, Changeset, Validator } from "./action";
 export interface ActionOptions<T extends Ent> {
     existingEnt?: T | null;
@@ -35,4 +35,6 @@ export declare class BaseAction<T extends Ent> implements Action<T> {
 interface BuilderConstructor<T extends Ent> {
     new (viewer: Viewer, operation: WriteOperation, action: Action<T>, existingEnt?: T | undefined): EntBuilder<T>;
 }
+export declare function updateRawObject<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
+export declare function getSimpleEditAction<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt>, existingEnt: TEnt, input: TInput): Action<TEnt>;
 export {};

package/action/experimental_action.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseAction = void 0;
+exports.getSimpleEditAction = exports.updateRawObject = exports.BaseAction = void 0;
 const privacy_1 = require("../core/privacy");
 const action_1 = require("./action");
 class BaseAction {
@@ -66,3 +66,28 @@ class BaseAction {
     }
 }
 exports.BaseAction = BaseAction;
+// this provides a way to just update a row in the database.
+// skips privacy, triggers, observers, etc
+// does do field validation
+// note that only editable fields in the builder can be passed here
+async function updateRawObject(viewer, builderCtr, existingEnt, input) {
+    const action = new BaseAction(viewer, builderCtr, {
+        existingEnt: existingEnt,
+        operation: action_1.WriteOperation.Edit,
+        input,
+    });
+    return action.saveX();
+}
+exports.updateRawObject = updateRawObject;
+// creates an action which has no privacy, triggers, observers etc
+// does do field validation
+// useful to batch a bunch of writes together with BaseAction.bulkAction
+// note that only editable fields in the builder can be passed here
+function getSimpleEditAction(viewer, builderCtr, existingEnt, input) {
+    return new BaseAction(viewer, builderCtr, {
+        existingEnt: existingEnt,
+        operation: action_1.WriteOperation.Edit,
+        input,
+    });
+}
+exports.getSimpleEditAction = getSimpleEditAction;

package/action/orchestrator.d.ts

@@ -59,12 +59,14 @@ export declare class Orchestrator<T extends Ent> {
     private validators;
     private isBuilder;
     private getFieldsWithDefaultValues;
+    private hasData;
+    private transformFieldValue;
     private formatAndValidateFields;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     build(): Promise<EntChangeset<T>>;
     private viewerForEntLoad;
-    private returnedRow;
+    returnedRow(): Promise<Data | null>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
 }

package/action/orchestrator.js

@@ -303,6 +303,7 @@ class Orchestrator {
     getFieldsWithDefaultValues(builder, schemaFields, action) {
         const editedFields = this.options.editedFields();
         let data = {};
+        let defaultData = {};
         let input = action?.getInput() || {};
         let updateInput = false;
         for (const [fieldName, field] of schemaFields) {
@@ -327,26 +328,86 @@ class Orchestrator {
                 if (field.defaultValueOnEdit &&
                     this.options.operation === action_1.WriteOperation.Edit) {
                     defaultValue = field.defaultValueOnEdit(builder, input);
-                    // TODO special case this if this is the only thing changing and don't do the write.
                 }
             }
-            data[dbKey] = value;
+            if (value !== undefined) {
+                data[dbKey] = value;
+            }
             if (defaultValue !== undefined) {
                 updateInput = true;
-                data[dbKey] = defaultValue;
+                defaultData[dbKey] = defaultValue;
                 this.defaultFieldsByFieldName[fieldName] = defaultValue;
                 // TODO related to #510. we need this logic to be consistent so do this all in TypeScript or get it from go somehow
                 this.defaultFieldsByTSName[(0, camel_case_1.camelCase)(fieldName)] = defaultValue;
             }
         }
-        if (updateInput && this.options.updateInput) {
-            // this basically fixes #605. just needs to be exposed correctly
-            this.options.updateInput(this.defaultFieldsByTSName);
+        // if there's data changing, add data
+        if (this.hasData(data)) {
+            data = {
+                ...data,
+                ...defaultData,
+            };
+            if (updateInput && this.options.updateInput) {
+                // this basically fixes #605. just needs to be exposed correctly
+                this.options.updateInput(this.defaultFieldsByTSName);
+            }
         }
         return data;
     }
+    hasData(data) {
+        for (const _k in data) {
+            return true;
+        }
+        return false;
+    }
+    async transformFieldValue(field, dbKey, value) {
+        // now format and validate...
+        if (value === null) {
+            if (!field.nullable) {
+                throw new Error(`field ${field.name} set to null for non-nullable field`);
+            }
+        }
+        else if (value === undefined) {
+            if (!field.nullable &&
+                // required field can be skipped if server default set
+                // not checking defaultValueOnCreate() or defaultValueOnEdit() as that's set above
+                // not setting server default as we're depending on the database handling that.
+                // server default allowed
+                field.serverDefault === undefined &&
+                this.options.operation === action_1.WriteOperation.Insert) {
+                throw new Error(`required field ${field.name} not set`);
+            }
+        }
+        else if (this.isBuilder(value)) {
+            if (field.valid) {
+                const valid = await Promise.resolve(field.valid(value));
+                if (!valid) {
+                    throw new Error(`invalid field ${field.name} with value ${value}`);
+                }
+            }
+            // keep track of dependencies to resolve
+            this.dependencies.set(value.placeholderID, value);
+            // keep track of fields to resolve
+            this.fieldsToResolve.push(dbKey);
+        }
+        else {
+            if (field.valid) {
+                // TODO this could be async. handle this better
+                const valid = await Promise.resolve(field.valid(value));
+                if (!valid) {
+                    throw new Error(`invalid field ${field.name} with value ${value}`);
+                }
+            }
+            if (field.format) {
+                // TODO this could be async e.g. password. handle this better
+                value = await Promise.resolve(field.format(value));
+            }
+        }
+        return value;
+    }
     async formatAndValidateFields(schemaFields) {
-        if (this.options.operation == action_1.WriteOperation.Delete) {
+        const op = this.options.operation;
+        if (op === action_1.WriteOperation.Delete) {
             return;
         }
         const editedFields = this.options.editedFields();
@@ -355,53 +416,32 @@ class Orchestrator {
         let logValues = {};
         for (const [fieldName, field] of schemaFields) {
             let value = editedFields.get(fieldName);
-            if (value === undefined) {
+            if (value === undefined && op === action_1.WriteOperation.Insert) {
                 // null allowed
                 value = this.defaultFieldsByFieldName[fieldName];
             }
             let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
-            // now format and validate...
-            if (value === null) {
-                if (!field.nullable) {
-                    throw new Error(`field ${field.name} set to null for non-nullable field`);
-                }
-            }
-            else if (value === undefined) {
-                if (!field.nullable &&
-                    // required field can be skipped if server default set
-                    // not checking defaultValueOnCreate() or defaultValueOnEdit() as that's set above
-                    // not setting server default as we're depending on the database handling that.
-                    // server default allowed
-                    field.serverDefault === undefined &&
-                    this.options.operation === action_1.WriteOperation.Insert) {
-                    throw new Error(`required field ${field.name} not set`);
-                }
-            }
-            else if (this.isBuilder(value)) {
-                let builder = value;
-                // keep track of dependencies to resolve
-                this.dependencies.set(builder.placeholderID, builder);
-                // keep track of fields to resolve
-                this.fieldsToResolve.push(dbKey);
-            }
-            else {
-                if (field.valid) {
-                    // TODO this could be async. handle this better
-                    let valid = await Promise.resolve(field.valid(value));
-                    if (!valid) {
-                        throw new Error(`invalid field ${field.name} with value ${value}`);
-                    }
-                }
-                if (field.format) {
-                    // TODO this could be async e.g. password. handle this better
-                    value = await Promise.resolve(field.format(value));
-                }
-            }
+            value = await this.transformFieldValue(field, dbKey, value);
             if (value !== undefined) {
                 data[dbKey] = value;
                 logValues[dbKey] = field.logValue(value);
             }
         }
+        //  we ignored default values while editing.
+        // if we're editing and there's data, add default values
+        if (op === action_1.WriteOperation.Edit && this.hasData(data)) {
+            for (const fieldName in this.defaultFieldsByFieldName) {
+                const defaultValue = this.defaultFieldsByFieldName[fieldName];
+                let field = schemaFields.get(fieldName);
+                let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
+                // no value, let's just default
+                if (data[dbKey] === undefined) {
+                    const value = await this.transformFieldValue(field, dbKey, defaultValue);
+                    data[dbKey] = value;
+                    logValues[dbKey] = field.logValue(value);
+                }
+            }
+        }
         this.validatedFields = data;
         this.logValues = logValues;
     }
@@ -423,7 +463,6 @@ class Orchestrator {
         await this.validX();
         let ops = [this.buildMainOp()];
         await this.buildEdgeOps(ops);
-        //    console.log("post build");
         return new EntChangeset(this.options.viewer, this.options.builder.placeholderID, this.options.loaderOptions.ent, ops, this.dependencies, this.changesets, this.options);
     }
     async viewerForEntLoad(data) {

package/core/ent.d.ts

@@ -61,6 +61,7 @@ export declare class EditNodeOperation<T extends Ent> implements DataOperation {
     placeholderID?: ID | undefined;
     constructor(options: EditNodeOptions<T>, existingEnt?: Ent | null);
     resolve<T extends Ent>(executor: Executor): void;
+    private hasData;
     performWrite(queryer: Queryer, context?: Context): Promise<void>;
     private reloadRow;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;

package/core/ent.js

@@ -421,13 +421,24 @@ class EditNodeOperation {
         });
         this.options.fields = fields;
     }
+    hasData(data) {
+        for (const _k in data) {
+            return true;
+        }
+        return false;
+    }
     async performWrite(queryer, context) {
         let options = {
             ...this.options,
             context,
         };
         if (this.existingEnt) {
-            this.row = await editRow(queryer, options, this.existingEnt.id, "RETURNING *");
+            if (this.hasData(options.fields)) {
+                this.row = await editRow(queryer, options, this.existingEnt.id, "RETURNING *");
+            }
+            else {
+                this.row = this.existingEnt["data"];
+            }
         }
         else {
             this.row = await createRow(queryer, options, "RETURNING *");
@@ -455,8 +466,13 @@ class EditNodeOperation {
             context,
         };
         if (this.existingEnt) {
-            editRowSync(queryer, options, this.existingEnt.id, "RETURNING *");
-            this.reloadRow(queryer, this.existingEnt.id, options);
+            if (this.hasData(this.options.fields)) {
+                editRowSync(queryer, options, this.existingEnt.id, "RETURNING *");
+                this.reloadRow(queryer, this.existingEnt.id, options);
+            }
+            else {
+                this.row = this.existingEnt["data"];
+            }
         }
         else {
             createRowSync(queryer, options, "RETURNING *");

package/graphql/index.d.ts

@@ -6,5 +6,5 @@ export { GraphQLEdgeType, GraphQLConnectionType, } from "./query/connection_type
 export { GraphQLNodeInterface } from "./builtins/node";
 export { GraphQLConnectionInterface } from "./builtins/connection";
 export { GraphQLEdgeInterface } from "./builtins/edge";
-export { NodeResolver, EntNodeResolver, registerResolver, clearResolvers, resolveID, nodeIDEncoder, mustDecodeIDFromGQLID, encodeGQLID, } from "./node_resolver";
+export { NodeResolver, EntNodeResolver, registerResolver, clearResolvers, resolveID, nodeIDEncoder, mustDecodeIDFromGQLID, mustDecodeNullableIDFromGQLID, encodeGQLID, } from "./node_resolver";
 export { convertFromGQLEnum, convertToGQLEnum } from "./enums";

package/graphql/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToGQLEnum = exports.convertFromGQLEnum = exports.encodeGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = exports.GraphQLEdgeInterface = exports.GraphQLConnectionInterface = exports.GraphQLNodeInterface = exports.GraphQLConnectionType = exports.GraphQLEdgeType = exports.GraphQLEdgeConnection = exports.GraphQLPageInfo = exports.GraphQLTime = exports.gqlFileUpload = exports.GQLCapture = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlArg = exports.gqlField = void 0;
+exports.convertToGQLEnum = exports.convertFromGQLEnum = exports.encodeGQLID = exports.mustDecodeNullableIDFromGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = exports.GraphQLEdgeInterface = exports.GraphQLConnectionInterface = exports.GraphQLNodeInterface = exports.GraphQLConnectionType = exports.GraphQLEdgeType = exports.GraphQLEdgeConnection = exports.GraphQLPageInfo = exports.GraphQLTime = exports.gqlFileUpload = exports.GQLCapture = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlArg = exports.gqlField = void 0;
 var graphql_1 = require("./graphql");
 Object.defineProperty(exports, "gqlField", { enumerable: true, get: function () { return graphql_1.gqlField; } });
 Object.defineProperty(exports, "gqlArg", { enumerable: true, get: function () { return graphql_1.gqlArg; } });
@@ -35,6 +35,7 @@ Object.defineProperty(exports, "clearResolvers", { enumerable: true, get: functi
 Object.defineProperty(exports, "resolveID", { enumerable: true, get: function () { return node_resolver_1.resolveID; } });
 Object.defineProperty(exports, "nodeIDEncoder", { enumerable: true, get: function () { return node_resolver_1.nodeIDEncoder; } });
 Object.defineProperty(exports, "mustDecodeIDFromGQLID", { enumerable: true, get: function () { return node_resolver_1.mustDecodeIDFromGQLID; } });
+Object.defineProperty(exports, "mustDecodeNullableIDFromGQLID", { enumerable: true, get: function () { return node_resolver_1.mustDecodeNullableIDFromGQLID; } });
 Object.defineProperty(exports, "encodeGQLID", { enumerable: true, get: function () { return node_resolver_1.encodeGQLID; } });
 var enums_1 = require("./enums");
 Object.defineProperty(exports, "convertFromGQLEnum", { enumerable: true, get: function () { return enums_1.convertFromGQLEnum; } });

package/graphql/node_resolver.d.ts

@@ -24,5 +24,6 @@ export declare function clearResolvers(): Promise<void>;
 export declare function resolveID(viewer: Viewer, id: string): Promise<Node | null>;
 export declare const nodeIDEncoder: GraphQLFieldResolver<Ent, {}>;
 export declare function mustDecodeIDFromGQLID(id: string): ID;
+export declare function mustDecodeNullableIDFromGQLID(id: string | null | undefined): any;
 export declare function encodeGQLID(node: Ent): string;
 export {};

package/graphql/node_resolver.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = void 0;
+exports.encodeGQLID = exports.mustDecodeNullableIDFromGQLID = exports.mustDecodeIDFromGQLID = exports.nodeIDEncoder = exports.resolveID = exports.clearResolvers = exports.registerResolver = exports.EntNodeResolver = void 0;
 class EntNodeResolver {
     constructor(loader) {
         this.loader = loader;
@@ -76,6 +76,19 @@ function mustDecodeIDFromGQLID(id) {
     return decoded;
 }
 exports.mustDecodeIDFromGQLID = mustDecodeIDFromGQLID;
+// TODO get the right (non-any) return type here. may need to change codegen to do the right thing here
+function mustDecodeNullableIDFromGQLID(id) {
+    // support undefined because fields in action
+    if (id === null || id === undefined) {
+        return id;
+    }
+    const decoded = EntNodeResolver.decode(id);
+    if (!decoded) {
+        throw new Error(`wasn't able to decode invalid ${id}`);
+    }
+    return decoded;
+}
+exports.mustDecodeNullableIDFromGQLID = mustDecodeNullableIDFromGQLID;
 // This takes an ent and returns the graphql id
 function encodeGQLID(node) {
     // let's do 3 parts. we take the "node" prefix

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.0.30-alpha",
+  "version": "0.0.32-alpha.10",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/parse_schema/parse.js

@@ -16,6 +16,14 @@ function processFields(processedSchema, src) {
                 f["polymorphic"] = field.polymorphic;
             }
         }
+        // convert string to object to make API consumed by go simple
+        if (f.fieldEdge && f.fieldEdge.inverseEdge) {
+            if (typeof f.fieldEdge.inverseEdge === "string") {
+                f.fieldEdge.inverseEdge = {
+                    name: f.fieldEdge.inverseEdge,
+                };
+            }
+        }
         processedSchema.fields.push(f);
     }
 }

package/schema/base_schema.js

@@ -37,7 +37,7 @@ let nodeField = (0, field_1.UUIDType)({
         return (0, uuid_1.v4)();
     },
 });
-let nodeFields = [nodeField].concat(tsFields);
+let nodeFields = [nodeField, ...tsFields];
 let nodeFieldsWithTZ = [
     nodeField,
     (0, field_1.TimestampType)({

package/schema/field.d.ts

@@ -17,8 +17,11 @@ export declare abstract class BaseField {
     logValue(val: any): any;
 }
 export declare class UUIDField extends BaseField implements Field {
+    private options;
     type: Type;
     constructor(options: FieldOptions);
+    private isBuilder;
+    valid(val: any): Promise<boolean>;
 }
 export declare function UUIDType(options: FieldOptions): UUIDField;
 export interface IntegerOptions extends FieldOptions {
@@ -141,7 +144,7 @@ export declare class ListField extends BaseField {
     private validators;
     constructor(field: Field, options: FieldOptions);
     validate(validator: (val: any[]) => boolean): this;
-    valid(val: any): boolean;
+    valid(val: any): Promise<boolean>;
     private postgresVal;
     format(val: any): any;
     minLen(l: number): this;

package/schema/field.js

@@ -22,8 +22,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UUIDListType = exports.EnumListType = exports.DateListType = exports.TimetzListType = exports.TimeListType = exports.TimestamptzListType = exports.TimestampListType = exports.BooleanListType = exports.BigIntegerListType = exports.FloatListType = exports.IntegerListType = exports.IntListType = exports.StringListType = exports.ListField = exports.EnumType = exports.EnumField = exports.DateType = exports.DateField = exports.TimetzType = exports.TimeType = exports.TimeField = exports.leftPad = exports.TimestamptzType = exports.TimestampType = exports.TimestampField = exports.StringType = exports.StringField = exports.BooleanType = exports.BooleanField = exports.FloatType = exports.FloatField = exports.BigIntegerType = exports.BigIntegerField = exports.IntegerType = exports.IntegerField = exports.UUIDType = exports.UUIDField = exports.BaseField = void 0;
 const luxon_1 = require("luxon");
 const snake_case_1 = require("snake-case");
+const camel_case_1 = require("camel-case");
 const db_1 = __importStar(require("../core/db"));
 const schema_1 = require("./schema");
+const util_1 = require("util");
 class BaseField {
     logValue(val) {
         if (this.sensitive) {
@@ -37,6 +39,7 @@ exports.BaseField = BaseField;
 class UUIDField extends BaseField {
     constructor(options) {
         super();
+        this.options = options;
         this.type = { dbType: schema_1.DBType.UUID };
         const polymorphic = options.polymorphic;
         if (polymorphic) {
@@ -80,6 +83,32 @@ class UUIDField extends BaseField {
                 ];
             }
         }
+        if (options.fieldEdge?.enforceSchema &&
+            !options.fieldEdge.getLoaderOptions) {
+            throw new Error(`cannot enforceSchema if getLoaderOptions wasn't passed in`);
+        }
+    }
+    isBuilder(val) {
+        return val.placeholderID !== undefined;
+    }
+    async valid(val) {
+        if (!this.options.fieldEdge?.enforceSchema) {
+            return true;
+        }
+        // TODO #510 consistency.
+        const f = (0, camel_case_1.camelCase)(this.options.fieldEdge.schema);
+        const getLoaderOptions = this.options.fieldEdge.getLoaderOptions;
+        const loadRowOptions = getLoaderOptions(f);
+        if (!loadRowOptions) {
+            throw new Error(`couldn't get loaderOptions for ${f}`);
+        }
+        if (this.isBuilder(val)) {
+            // if builder, the ent type of the builder and the ent type returned by the load constructor should match
+            return val.ent === loadRowOptions.ent;
+        }
+        // TODO we need context here to make sure that we hit local cache
+        const row = await loadRowOptions.loaderFactory.createLoader().load(val);
+        return row !== null;
     }
 }
 exports.UUIDField = UUIDField;
@@ -542,7 +571,7 @@ class ListField extends BaseField {
         this.validators.push(validator);
         return this;
     }
-    valid(val) {
+    async valid(val) {
         if (!Array.isArray(val)) {
             return false;
         }
@@ -551,15 +580,18 @@ class ListField extends BaseField {
                 return false;
             }
         }
-        if (!this.field.valid) {
+        const valid = this.field.valid;
+        if (!valid) {
             return true;
         }
-        for (const v of val) {
-            if (!this.field.valid(v)) {
-                return false;
-            }
+        const res = valid.apply(this.field, [val[0]]);
+        if (util_1.types.isPromise(res)) {
+            const ret = await Promise.all(val.map(async (v) => await valid.apply(this.field, [v])));
+            return ret.every((v) => v);
         }
-        return true;
+        const ret = val.map((v) => valid.apply(this.field, [v]));
+        const result = ret.every((v) => v);
+        return result;
     }
     postgresVal(val, jsonType) {
         if (!jsonType) {

package/schema/schema.d.ts

@@ -1,4 +1,4 @@
-import { Data, Ent } from "../core/base";
+import { Data, Ent, LoadEntOptions } from "../core/base";
 import { Builder } from "../action/action";
 export default interface Schema {
     fields: Field[];
@@ -100,10 +100,21 @@ export interface ForeignKey {
     column: string;
     name?: string;
     disableIndex?: boolean;
+    disableBuilderType?: boolean;
+}
+declare type getLoaderOptionsFn = (type: any) => LoadEntOptions<Ent>;
+export interface InverseFieldEdge {
+    name: string;
+    edgeConstName?: string;
+    tableName?: string;
+    hideFromGraphQL?: boolean;
 }
 export interface FieldEdge {
     schema: string;
-    inverseEdge: string;
+    inverseEdge?: string | InverseFieldEdge;
+    enforceSchema?: boolean;
+    getLoaderOptions?: getLoaderOptionsFn;
+    disableBuilderType?: boolean;
 }
 export interface FieldOptions {
     name: string;
@@ -130,10 +141,11 @@ export interface FieldOptions {
 export interface PolymorphicOptions {
     types?: string[];
     hideFromInverseGraphQL?: boolean;
+    disableBuilderType?: boolean;
 }
 export interface Field extends FieldOptions {
     type: Type;
-    valid?(val: any): boolean;
+    valid?(val: any): Promise<boolean> | boolean;
     format?(val: any): any;
     logValue(val: any): any;
 }
@@ -159,6 +171,7 @@ export interface ActionField {
     nullable?: boolean | NullableListOptions;
     list?: boolean;
     actionName?: string;
+    excludedFields?: string[];
 }
 export interface Action {
     operation: ActionOperation;

package/testutils/builder.d.ts

@@ -66,12 +66,12 @@ export declare class SimpleBuilder<T extends Ent> implements Builder<T> {
     viewer: Viewer;
     private schema;
     operation: WriteOperation;
-    existingEnt: Ent | undefined;
+    existingEnt: T | undefined;
     ent: EntConstructor<T>;
     placeholderID: ID;
     orchestrator: Orchestrator<T>;
     fields: Map<string, any>;
-    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: Ent | undefined, action?: Action<T> | undefined);
+    constructor(viewer: Viewer, schema: BuilderSchema<T>, fields: Map<string, any>, operation?: WriteOperation, existingEnt?: T | undefined, action?: Action<T> | undefined);
     build(): Promise<Changeset<T>>;
     editedEnt(): Promise<T | null>;
     editedEntX(): Promise<T>;
@@ -100,5 +100,6 @@ export declare class SimpleAction<T extends Ent> implements Action<T> {
     save(): Promise<T | null>;
     saveX(): Promise<T>;
     editedEnt(): Promise<T | null>;
+    editedEntX(): Promise<T>;
 }
 export {};

package/testutils/builder.js

@@ -203,16 +203,19 @@ class SimpleAction {
     async save() {
         await (0, action_1.saveBuilder)(this.builder);
         if (this.builder.operation !== action_1.WriteOperation.Delete) {
-            return await this.builder.orchestrator.editedEnt();
+            return this.builder.orchestrator.editedEnt();
         }
         return null;
     }
     async saveX() {
         await (0, action_1.saveBuilderX)(this.builder);
-        return await this.builder.orchestrator.editedEntX();
+        return this.builder.orchestrator.editedEntX();
     }
     async editedEnt() {
-        return await this.builder.orchestrator.editedEnt();
+        return this.builder.orchestrator.editedEnt();
+    }
+    async editedEntX() {
+        return this.builder.orchestrator.editedEntX();
     }
 }
 exports.SimpleAction = SimpleAction;

package/testutils/ent-graphql-tests/index.d.ts

@@ -27,6 +27,7 @@ export declare function expectQueryFromRoot(config: queryRootConfig, ...options:
 export interface mutationRootConfig extends queryConfig {
     mutation: string;
     disableInputWrapping?: boolean;
+    nullQueryPaths?: string[];
 }
 export declare function expectMutation(config: mutationRootConfig, ...options: Option[]): Promise<supertest.SuperTest<supertest.Test>>;
 export {};

package/testutils/parse_sql.js

@@ -121,6 +121,22 @@ function getDataToReturn(data, colNames, returningAll) {
     return ret;
 }
 exports.getDataToReturn = getDataToReturn;
+function processBeforeStoring(val) {
+    if (typeof val !== "string") {
+        return val;
+    }
+    // convert postgres lists into lists before storing
+    if (val[0] === "{" && val[val.length - 1] === "}") {
+        try {
+            // valid json, don't convert
+            JSON.parse(val);
+        }
+        catch (e) {
+            return val.substring(1, val.length - 1).split(",");
+        }
+    }
+    return val;
+}
 function parseInsertStatement(ast, values, // values passed to query
 returningAll) {
     const tableName = getTableName(ast.table);
@@ -138,7 +154,7 @@ returningAll) {
     // INSERT INTO tableName (cols) VALUES (pos args)
     for (let i = 0; i < columns.length; i++) {
         let col = columns[i];
-        data[col] = values[i];
+        data[col] = processBeforeStoring(values[i]);
     }
     let returningData = null;
     if (returningAll) {
@@ -411,7 +427,7 @@ function parseUpdateStatement(ast, values, map, returningAll) {
     for (const set of ast.set) {
         let col = set.column;
         let value = getValueFromRegex(set.value, values);
-        overwrite[col] = value;
+        overwrite[col] = processBeforeStoring(value);
     }
     let columns = new Set();
     if (ast.returning) {