@snowtop/ent 0.1.0-alpha9 → 0.1.0-alpha91

package/schema/field.js

@@ -1,7 +1,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];
@@ -19,12 +23,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 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;
+exports.UUIDListType = exports.IntegerEnumListType = 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.IntegerEnumType = exports.IntegerEnumField = exports.EnumType = exports.StringEnumField = 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 util_1 = require("util");
+const uuid_1 = require("uuid");
+const base_1 = require("../core/base");
 const db_1 = __importStar(require("../core/db"));
 const schema_1 = require("./schema");
-const util_1 = require("util");
 class BaseField {
     logValue(val) {
         if (this.sensitive) {
@@ -67,21 +73,28 @@ class UUIDField extends BaseField {
             if (typeof polymorphic === "object" && polymorphic.types) {
                 // an enum with types validated here
                 return {
-                    [name]: EnumType({
+                    [name]: PolymorphicStringEnumType({
                         values: polymorphic.types,
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
                         nullable: this.options?.nullable,
+                        parentFieldToValidate: fieldName,
+                        serverDefault: polymorphic.serverDefault,
                     }),
                 };
             }
             else {
-                // just a string field...
+                let serverDefault = undefined;
+                if (typeof polymorphic === "object") {
+                    serverDefault = polymorphic.serverDefault;
+                }
                 return {
-                    [name]: StringType({
+                    [name]: PolymorphicStringType({
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
                         nullable: this.options?.nullable,
+                        parentFieldToValidate: fieldName,
+                        serverDefault: serverDefault,
                     }),
                 };
             }
@@ -92,6 +105,9 @@ class UUIDField extends BaseField {
         return val.placeholderID !== undefined;
     }
     async valid(val) {
+        if (typeof val === "string" && !(0, uuid_1.validate)(val)) {
+            return false;
+        }
         if (!this.options?.fieldEdge?.enforceSchema) {
             return true;
         }
@@ -307,6 +323,33 @@ class StringField extends BaseField {
     }
 }
 exports.StringField = StringField;
+function validatePolymorphicTypeWithFullData(val, b, field) {
+    const input = b.getInput();
+    const inputKey = b.orchestrator.__getOptions().fieldInfo[field].inputKey;
+    const v = input[inputKey];
+    if (val === null) {
+        // if this is being set to null, ok if v is also null
+        return v === null;
+    }
+    // if this is not being set, ok if v is not being set
+    if (val === undefined && b.operation === base_1.WriteOperation.Insert) {
+        return v === undefined;
+    }
+    return true;
+}
+class PolymorphicStringField extends StringField {
+    constructor(opts) {
+        super(opts);
+        this.opts = opts;
+    }
+    validateWithFullData(val, b) {
+        return validatePolymorphicTypeWithFullData(val, b, this.opts.parentFieldToValidate);
+    }
+}
+function PolymorphicStringType(opts) {
+    let result = new PolymorphicStringField(opts);
+    return Object.assign(result, opts);
+}
 function StringType(options) {
     let result = new StringField(options);
     const options2 = { ...options };
@@ -426,9 +469,10 @@ class DateField extends BaseField {
         this.type = { dbType: schema_1.DBType.Date };
     }
     format(val) {
-        if (!(val instanceof Date)) {
+        if (typeof val === "string") {
             return val;
         }
+        val = new Date(val);
         let yy = (0, exports.leftPad)(val.getFullYear());
         // lol this API
         // for some reason this is 0-index
@@ -444,6 +488,9 @@ function DateType(options) {
     return Object.assign(result, options);
 }
 exports.DateType = DateType;
+/**
+ * @deprecated Use StringEnumField
+ */
 class EnumField extends BaseField {
     constructor(options) {
         super();
@@ -546,15 +593,75 @@ class EnumField extends BaseField {
     }
 }
 exports.EnumField = EnumField;
+class StringEnumField extends EnumField {
+}
+exports.StringEnumField = StringEnumField;
+class PolymorphicStringEnumField extends StringEnumField {
+    constructor(opts) {
+        super(opts);
+        this.opts = opts;
+    }
+    validateWithFullData(val, b) {
+        return validatePolymorphicTypeWithFullData(val, b, this.opts.parentFieldToValidate);
+    }
+}
+function PolymorphicStringEnumType(options) {
+    let result = new PolymorphicStringEnumField(options);
+    return Object.assign(result, options);
+}
 function EnumType(options) {
-    let result = new EnumField(options);
+    let result = new StringEnumField(options);
     return Object.assign(result, options);
 }
 exports.EnumType = EnumType;
+class IntegerEnumField extends BaseField {
+    constructor(options) {
+        super();
+        this.type = {
+            dbType: schema_1.DBType.IntEnum,
+            intEnumMap: options.map,
+            type: options.tsType,
+            graphQLType: options.graphQLType,
+            deprecatedIntEnumMap: options.deprecated,
+        };
+        let count = 0;
+        for (const k in options.map) {
+            count++;
+            break;
+        }
+        if (!count) {
+            throw new Error("need at least one entry in enum map");
+        }
+        if (options.foreignKey) {
+            throw new Error(`foreignKey on intEnum not supported`);
+        }
+        this.map = options.map;
+    }
+    valid(val) {
+        // lookup table enum and indicated via presence of foreignKey
+        for (const k in this.map) {
+            const v = this.map[k];
+            if (v === val || v === parseInt(val)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    format(val) {
+        return parseInt(val);
+    }
+}
+exports.IntegerEnumField = IntegerEnumField;
+function IntegerEnumType(options) {
+    let result = new IntegerEnumField(options);
+    return Object.assign(result, options);
+}
+exports.IntegerEnumType = IntegerEnumType;
 class ListField extends BaseField {
     constructor(field, options) {
         super();
         this.field = field;
+        this.options = options;
         this.validators = [];
         if (field.type.dbType === schema_1.DBType.List) {
             throw new Error(`nested lists not currently supported`);
@@ -565,6 +672,9 @@ class ListField extends BaseField {
         };
         Object.assign(this, options);
     }
+    __getElemField() {
+        return this.field;
+    }
     validate(validator) {
         this.validators.push(validator);
         return this;
@@ -592,7 +702,12 @@ class ListField extends BaseField {
         return result;
     }
     postgresVal(val, jsonType) {
-        if (!jsonType) {
+        if (!jsonType && val === "") {
+            // support empty strings in list
+            val = '"' + val + '"';
+            return val;
+        }
+        if (this.options?.disableJSONStringify) {
             return val;
         }
         return JSON.stringify(val);
@@ -720,7 +835,18 @@ function EnumListType(options) {
     return new ListField(EnumType(options), options);
 }
 exports.EnumListType = EnumListType;
+function IntegerEnumListType(options) {
+    // not all of these will make sense in a list...
+    // can make it work eventually but involves work we're not currently trying to do
+    // developer can try to work around it by calling below on their own.
+    // unclear what the behavior is
+    return new ListField(IntegerEnumType(options), options);
+}
+exports.IntegerEnumListType = IntegerEnumListType;
 function UUIDListType(options) {
-    return new ListField(UUIDType(options), options);
+    return new ListField(UUIDType(options), {
+        ...options,
+        disableJSONStringify: true,
+    });
 }
 exports.UUIDListType = UUIDListType;

package/schema/index.d.ts

@@ -1,7 +1,7 @@
 import Schema from "./schema";
 export { Schema };
-export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, getFieldsWithPrivacy, getStorageKey, ActionOperation, Action, EdgeAction, NoFields, FieldMap, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, UpdateOperation, TransformedUpdateOperation, SQLStatementOperation, getTransformedReadClause, getObjectLoaderProperties, } from "./schema";
-export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, EntSchema, EntSchemaWithTZ, } from "./base_schema";
+export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, getFieldsWithPrivacy, getStorageKey, ActionOperation, Action, EdgeAction, NoFields, FieldMap, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, UpdateOperation, TransformedUpdateOperation, SQLStatementOperation, EdgeUpdateOperation, TransformedEdgeUpdateOperation, getTransformedReadClause, getObjectLoaderProperties, GlobalSchema, } from "./schema";
+export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, EntSchema, EntSchemaWithTZ, SchemaConfig, } from "./base_schema";
 export * from "./field";
 export * from "./json_field";
 export * from "./struct_field";

package/schema/index.js

@@ -1,7 +1,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];

package/schema/json_field.d.ts

@@ -4,14 +4,26 @@ export interface JSONOptions extends FieldOptions {
     validator?: (val: any) => boolean;
     importType?: ImportType;
 }
+interface allJSONOptions extends JSONOptions {
+    jsonAsList?: boolean;
+}
 export declare class JSONField extends BaseField implements Field {
     private options?;
     type: Type;
-    constructor(jsonb: boolean, options?: JSONOptions | undefined);
+    constructor(jsonb: boolean, options?: allJSONOptions | undefined);
     format(val: any): string;
     valid(val: any): boolean;
 }
 export declare function JSONType(options?: JSONOptions): JSONField;
 export declare function JSONBType(options?: JSONOptions): JSONField;
+/**
+ * @deprecated use JSONBTypeAsList
+ */
 export declare function JSONBListType(options?: JSONOptions): ListField;
+/**
+ * @deprecated use JSONTypeAsList
+ */
 export declare function JSONListType(options?: JSONOptions): ListField;
+export declare function JSONBTypeAsList(options?: JSONOptions): JSONField & JSONOptions;
+export declare function JSONTypeAsList(options?: JSONOptions): JSONField & JSONOptions;
+export {};

package/schema/json_field.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONListType = exports.JSONBListType = exports.JSONBType = exports.JSONType = exports.JSONField = void 0;
+exports.JSONTypeAsList = exports.JSONBTypeAsList = exports.JSONListType = exports.JSONBListType = exports.JSONBType = exports.JSONType = exports.JSONField = void 0;
 const schema_1 = require("./schema");
 const field_1 = require("./field");
 class JSONField extends field_1.BaseField {
@@ -16,6 +16,11 @@ class JSONField extends field_1.BaseField {
         if (options?.importType) {
             this.type.importType = options.importType;
         }
+        if (options?.jsonAsList) {
+            this.type.listElemType = {
+                dbType: schema_1.DBType.JSONB,
+            };
+        }
     }
     format(val) {
         return JSON.stringify(val);
@@ -38,11 +43,33 @@ function JSONBType(options) {
     return Object.assign(result, options);
 }
 exports.JSONBType = JSONBType;
+/**
+ * @deprecated use JSONBTypeAsList
+ */
 function JSONBListType(options) {
     return new field_1.ListField(JSONBType(options), options);
 }
 exports.JSONBListType = JSONBListType;
+/**
+ * @deprecated use JSONTypeAsList
+ */
 function JSONListType(options) {
     return new field_1.ListField(JSONType(options), options);
 }
 exports.JSONListType = JSONListType;
+function JSONBTypeAsList(options) {
+    let result = new JSONField(true, {
+        ...options,
+        jsonAsList: true,
+    });
+    return Object.assign(result, options);
+}
+exports.JSONBTypeAsList = JSONBTypeAsList;
+function JSONTypeAsList(options) {
+    let result = new JSONField(false, {
+        ...options,
+        jsonAsList: true,
+    });
+    return Object.assign(result, options);
+}
+exports.JSONTypeAsList = JSONTypeAsList;

package/schema/schema.d.ts

@@ -1,9 +1,23 @@
 import { Data, Ent, LoaderInfo, PrivacyPolicy, Viewer } from "../core/base";
-import { Builder } from "../action/action";
+import { Builder, Changeset } from "../action/action";
 import { Clause } from "../core/clause";
+import { AssocEdgeInput } from "../core/ent";
 export declare type FieldMap = {
     [key: string]: Field;
 };
+interface FieldInfo {
+    dbCol: string;
+    inputKey: string;
+}
+export declare type FieldInfoMap = {
+    [key: string]: FieldInfo;
+};
+export interface GlobalSchema {
+    edges?: Edge[];
+    extraEdgeFields?: FieldMap;
+    transformEdgeRead?: () => Clause;
+    transformEdgeWrite?: (stmt: EdgeUpdateOperation) => TransformedEdgeUpdateOperation | null;
+}
 export default interface Schema {
     fields: FieldMap | Field[];
     tableName?: string;
@@ -54,7 +68,8 @@ export interface AssocEdgeGroup {
     tableName?: string;
     assocEdges: AssocEdge[];
     statusEnums?: string[];
-    nullStates: string | string[];
+    viewerBased?: boolean;
+    nullStates?: string | string[];
     nullStateFn?: string;
     edgeAction?: EdgeGroupAction;
 }
@@ -62,9 +77,10 @@ export declare type Edge = AssocEdge;
 export interface Pattern {
     name: string;
     fields: FieldMap | Field[];
+    disableMixin?: boolean;
     edges?: Edge[];
     transformRead?: () => Clause;
-    transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | undefined;
+    transformWrite?: <T extends Ent<TViewer>, TViewer extends Viewer = Viewer>(stmt: UpdateOperation<T, TViewer>) => TransformedUpdateOperation<T, TViewer> | null;
     transformsDelete?: boolean;
     transformsInsert?: boolean;
     transformsUpdate?: boolean;
@@ -74,16 +90,25 @@ export declare enum SQLStatementOperation {
     Update = "update",
     Delete = "delete"
 }
-export interface UpdateOperation<T extends Ent> {
+export interface EdgeUpdateOperation {
+    op: SQLStatementOperation;
+    edge: AssocEdgeInput;
+}
+export interface TransformedEdgeUpdateOperation {
     op: SQLStatementOperation;
-    existingEnt?: T;
-    viewer: Viewer;
+    data?: Data;
+}
+export interface UpdateOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    op: SQLStatementOperation;
+    builder: Builder<TEnt, TViewer, any>;
+    input: Data;
     data?: Map<string, any>;
 }
-export interface TransformedUpdateOperation<T extends Ent> {
+export interface TransformedUpdateOperation<T extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     op: SQLStatementOperation;
     data?: Data;
-    existingEnt?: T;
+    existingEnt?: T | null;
+    changeset?(): Promise<Changeset> | Changeset;
 }
 export declare enum DBType {
     UUID = "UUID",
@@ -99,6 +124,7 @@ export declare enum DBType {
     JSONB = "JSONB",
     Enum = "Enum",
     StringEnum = "StringEnum",
+    IntEnum = "IntEnum",
     Date = "Date",
     Time = "Time",
     Timetz = "Timetz",
@@ -109,9 +135,16 @@ export interface ImportType {
     type: string;
     [x: string]: any;
 }
+export interface ConvertType {
+    path: string;
+    function: string;
+}
 declare type EnumMap = {
     [key: string]: string;
 };
+declare type IntEnumMap = {
+    [key: string]: number;
+};
 export interface Type {
     dbType: DBType;
     listElemType?: Type;
@@ -119,9 +152,12 @@ export interface Type {
     graphQLType?: string;
     values?: string[];
     enumMap?: EnumMap;
+    intEnumMap?: IntEnumMap;
+    deprecatedIntEnumMap?: IntEnumMap;
     importType?: ImportType;
     subFields?: FieldMap;
     unionFields?: FieldMap;
+    [x: string]: any;
 }
 export interface ForeignKey {
     schema: string;
@@ -129,6 +165,7 @@ export interface ForeignKey {
     name?: string;
     disableIndex?: boolean;
     disableBuilderType?: boolean;
+    [x: string]: any;
 }
 declare type getLoaderInfoFn = (type: string) => LoaderInfo;
 export interface InverseFieldEdge {
@@ -144,13 +181,16 @@ export interface FieldEdge {
     getLoaderInfoFromSchema?: getLoaderInfoFn;
     disableBuilderType?: boolean;
 }
+interface PrivateOptions {
+    exposeToActions?: boolean;
+}
 export interface FieldOptions {
     nullable?: boolean;
     storageKey?: string;
     serverDefault?: any;
     unique?: boolean;
     hideFromGraphQL?: boolean;
-    private?: boolean;
+    private?: boolean | PrivateOptions;
     sensitive?: boolean;
     graphqlName?: string;
     index?: boolean;
@@ -166,16 +206,21 @@ export interface FieldOptions {
     polymorphic?: boolean | PolymorphicOptions;
     privacyPolicy?: PrivacyPolicy | (() => PrivacyPolicy);
     getDerivedFields?(name: string): FieldMap;
+    convert?: ConvertType;
+    fetchOnDemand?: boolean;
     [x: string]: any;
 }
 export interface PolymorphicOptions {
+    name?: string;
     types?: string[];
     hideFromInverseGraphQL?: boolean;
     disableBuilderType?: boolean;
+    serverDefault?: any;
 }
 export interface Field extends FieldOptions {
     type: Type;
     valid?(val: any): Promise<boolean> | boolean;
+    validateWithFullData?(val: any, builder: Builder<any>): boolean | Promise<boolean>;
     format?(val: any, nested?: boolean): any;
     logValue(val: any): any;
 }
@@ -185,15 +230,18 @@ export interface SchemaConstructor {
 export declare type SchemaInputType = Schema | SchemaConstructor;
 export declare function getSchema(value: SchemaInputType): Schema;
 export declare function getFields(value: SchemaInputType): Map<string, Field>;
+/**
+ * @deprecated should only be used by tests
+ */
 export declare function getStorageKey(field: Field, fieldName: string): string;
-export declare function getFieldsWithPrivacy(value: SchemaInputType): Map<string, PrivacyPolicy>;
+export declare function getFieldsWithPrivacy(value: SchemaInputType, fieldMap: FieldInfoMap): Map<string, PrivacyPolicy>;
 export declare function getTransformedReadClause(value: SchemaInputType): Clause | undefined;
 interface objectLoaderOptions {
     clause?: () => Clause | undefined;
     instanceKey?: string;
 }
 export declare function getObjectLoaderProperties(value: SchemaInputType, tableName: string): objectLoaderOptions | undefined;
-export declare function getTransformedUpdateOp<T extends Ent>(value: SchemaInputType, stmt: UpdateOperation<T>): TransformedUpdateOperation<T> | undefined;
+export declare function getTransformedUpdateOp<TEnt extends Ent<TViewer>, TViewer extends Viewer>(value: SchemaInputType, stmt: UpdateOperation<TEnt, TViewer>): TransformedUpdateOperation<TEnt> | null;
 export declare enum ActionOperation {
     Create = 1,
     Edit = 2,
@@ -212,6 +260,7 @@ export interface ActionField {
     list?: boolean;
     actionName?: string;
     excludedFields?: string[];
+    [x: string]: any;
 }
 export interface Action {
     operation: ActionOperation;
@@ -225,6 +274,7 @@ export interface Action {
     optionalFields?: string[];
     requiredFields?: string[];
     noFields?: boolean;
+    [x: string]: any;
 }
 export declare const NoFields = "__NO_FIELDS__";
 export declare function requiredField(field: string): string;
@@ -235,6 +285,7 @@ export interface Constraint {
     columns: string[];
     fkey?: ForeignKeyInfo;
     condition?: string;
+    [x: string]: any;
 }
 export interface FullTextWeight {
     A?: string[];
@@ -248,17 +299,21 @@ export interface FullText {
     languageColumn?: string;
     indexType?: "gin" | "gist";
     weights?: FullTextWeight;
+    [x: string]: any;
 }
 export interface Index {
     name: string;
     columns: string[];
     unique?: boolean;
     fulltext?: FullText;
+    indexType?: "gin" | "btree";
+    [x: string]: any;
 }
 export interface ForeignKeyInfo {
     tableName: string;
     ondelete?: "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT" | "NO ACTION";
     columns: string[];
+    [x: string]: any;
 }
 export declare enum ConstraintType {
     PrimaryKey = "primary",

package/schema/schema.js

@@ -35,6 +35,7 @@ var DBType;
     DBType["JSONB"] = "JSONB";
     DBType["Enum"] = "Enum";
     DBType["StringEnum"] = "StringEnum";
+    DBType["IntEnum"] = "IntEnum";
     DBType["Date"] = "Date";
     DBType["Time"] = "Time";
     DBType["Timetz"] = "Timetz";
@@ -86,12 +87,15 @@ function getFields(value) {
     return m;
 }
 exports.getFields = getFields;
+/**
+ * @deprecated should only be used by tests
+ */
 function getStorageKey(field, fieldName) {
     return field.storageKey || (0, snake_case_1.snakeCase)(fieldName);
 }
 exports.getStorageKey = getStorageKey;
 // returns a mapping of storage key to field privacy
-function getFieldsWithPrivacy(value) {
+function getFieldsWithPrivacy(value, fieldMap) {
     const schema = getSchema(value);
     function addFields(fields) {
         if (Array.isArray(fields)) {
@@ -111,9 +115,14 @@ function getFieldsWithPrivacy(value) {
                     else {
                         privacyPolicy = field.privacyPolicy;
                     }
-                    m.set(getStorageKey(field, name), privacyPolicy);
+                    const info = fieldMap[name];
+                    if (!info) {
+                        throw new Error(`field with name ${name} not passed in fieldMap`);
+                    }
+                    m.set(info.dbCol, privacyPolicy);
                 }
             }
+            return;
         }
         for (const name in fields) {
             const field = fields[name];
@@ -128,7 +137,11 @@ function getFieldsWithPrivacy(value) {
                 else {
                     privacyPolicy = field.privacyPolicy;
                 }
-                m.set(getStorageKey(field, name), privacyPolicy);
+                const info = fieldMap[name];
+                if (!info) {
+                    throw new Error(`field with name ${name} not passed in fieldMap`);
+                }
+                m.set(info.dbCol, privacyPolicy);
             }
         }
     }
@@ -167,13 +180,14 @@ exports.getObjectLoaderProperties = getObjectLoaderProperties;
 function getTransformedUpdateOp(value, stmt) {
     const schema = getSchema(value);
     if (!schema.patterns) {
-        return;
+        return null;
     }
     for (const p of schema.patterns) {
         if (p.transformWrite) {
             return p.transformWrite(stmt);
         }
     }
+    return null;
 }
 exports.getTransformedUpdateOp = getTransformedUpdateOp;
 // this maps to ActionOperation in ent/action.go

package/schema/struct_field.d.ts

@@ -6,12 +6,22 @@ export interface StructOptions extends FieldOptions {
     graphQLType?: string;
     jsonNotJSONB?: boolean;
 }
+interface allStructOptions extends StructOptions {
+    jsonAsList?: boolean;
+}
 export declare class StructField extends BaseField implements Field {
     private options;
     type: Type;
-    constructor(options: StructOptions);
+    constructor(options: allStructOptions);
+    formatImpl(obj: any, nested?: boolean): string | Object;
     format(obj: any, nested?: boolean): string | Object;
+    private validImpl;
     valid(obj: any): Promise<boolean>;
 }
 export declare function StructType(options: StructOptions): StructField & StructOptions;
+/**
+ * @deprecated use StructTypeAsList
+ */
 export declare function StructListType(options: StructOptions): ListField;
+export declare function StructTypeAsList(options: allStructOptions): StructField & allStructOptions;
+export {};