@snowtop/ent 0.1.0-alpha2 → 0.1.0-alpha20

package/parse_schema/parse.js

@@ -18,9 +18,11 @@ function processFields(src, patternName) {
     }
     for (const name in m) {
         const field = m[name];
+        //@ts-ignore type and other changed fields with different type in ProcessedField vs Field
         let f = { name, ...field };
         f.hasDefaultValueOnCreate = field.defaultValueOnCreate != undefined;
         f.hasDefaultValueOnEdit = field.defaultValueOnEdit != undefined;
+        f.hasFieldPrivacy = field.privacyPolicy !== undefined;
         if (field.polymorphic) {
             // convert boolean into object
             // we keep boolean as an option to keep API simple
@@ -45,13 +47,44 @@ function processFields(src, patternName) {
         if (patternName) {
             f.patternName = patternName;
         }
+        transformType(field.type);
         if (field.getDerivedFields) {
             f.derivedFields = processFields(field.getDerivedFields(name));
         }
+        if (field.type.subFields) {
+            f.type.subFields = processFields(field.type.subFields);
+        }
+        if (field.type.unionFields) {
+            f.type.unionFields = processFields(field.type.unionFields);
+        }
+        if (field.type.listElemType &&
+            field.type.listElemType.subFields &&
+            // check to avoid ts-ignore below. exists just for tsc
+            f.type.listElemType) {
+            f.type.listElemType.subFields = processFields(field.type.listElemType.subFields);
+        }
         ret.push(f);
     }
     return ret;
 }
+function transformImportType(typ) {
+    if (!typ.importType) {
+        return;
+    }
+    typ.importType = {
+        ...typ.importType,
+        // these 2 needed for forwards compatibility with new go schema
+        importPath: typ.importType.path,
+        import: typ.importType.type,
+    };
+}
+function transformType(typ) {
+    if (!typ) {
+        return;
+    }
+    transformImportType(typ);
+    transformType(typ.listElemType);
+}
 function processEdges(src, patternName) {
     const ret = [];
     for (const edge of src) {
@@ -76,6 +109,9 @@ function processEdgeGroups(processedSchema, edgeGroups) {
     }
 }
 function processPattern(patterns, pattern, processedSchema) {
+    let ret = {
+        ...pattern,
+    };
     const name = pattern.name;
     const fields = processFields(pattern.fields, pattern.name);
     processedSchema.fields.push(...fields);
@@ -83,6 +119,10 @@ function processPattern(patterns, pattern, processedSchema) {
         const edges = processEdges(pattern.edges, pattern.name);
         processedSchema.assocEdges.push(...edges);
     }
+    // flag transformsSelect
+    if (pattern.transformRead) {
+        ret.transformsSelect = true;
+    }
     if (patterns[name] === undefined) {
         // intentionally processing separately and not passing pattern.name
         const edges = processEdges(pattern.edges || []);
@@ -90,12 +130,14 @@ function processPattern(patterns, pattern, processedSchema) {
             name: pattern.name,
             assocEdges: edges,
             fields: fields,
+            disableMixin: pattern.disableMixin,
         };
     }
     else {
         // TODO ideally we want to make sure that different patterns don't have the same name
         // can't do a deepEqual check because function calls and therefore different instances in fields
     }
+    return ret;
 }
 var NullableResult;
 (function (NullableResult) {
@@ -136,14 +178,19 @@ function parseSchema(potentialSchemas) {
     for (const key in potentialSchemas) {
         const value = potentialSchemas[key];
         let schema;
-        if (value.constructor == Object) {
-            schema = value;
-        }
-        else {
-            schema = new value();
+        const name = value.constructor.name;
+        // named class e.g. new BaseEntSchema
+        switch (name) {
+            case "Function":
+                schema = new value();
+                break;
+            default:
+                // implicit schema or named class
+                schema = value;
         }
         let processedSchema = {
             fields: [],
+            schemaPath: schema.schemaPath,
             tableName: schema.tableName,
             enumTable: schema.enumTable,
             dbRows: schema.dbRows,
@@ -156,13 +203,28 @@ function parseSchema(potentialSchemas) {
         };
         // let's put patterns first just so we have id, created_at, updated_at first
         // ¯\_(ツ)_/¯
+        let patternNames = [];
         if (schema.patterns) {
             for (const pattern of schema.patterns) {
-                processPattern(patterns, pattern, processedSchema);
+                const ret = processPattern(patterns, pattern, processedSchema);
+                patternNames.push(pattern.name);
+                if (ret.transformsSelect) {
+                    if (processedSchema.transformsSelect) {
+                        throw new Error(`can only have one pattern which transforms default querying behavior`);
+                    }
+                    processedSchema.transformsSelect = true;
+                }
+                if (ret.transformsDelete) {
+                    if (processedSchema.transformsDelete) {
+                        throw new Error(`can only have one pattern which transforms default deletion behavior`);
+                    }
+                    processedSchema.transformsDelete = true;
+                }
             }
         }
         const fields = processFields(schema.fields);
         processedSchema.fields.push(...fields);
+        processedSchema.patternNames = patternNames;
         if (schema.edges) {
             const edges = processEdges(schema.edges);
             processedSchema.assocEdges.push(...edges);

package/schema/base_schema.d.ts

@@ -1,6 +1,41 @@
-import { Pattern } from "./schema";
+import { Field, FieldMap, Pattern } from "./schema";
+import { Action, AssocEdgeGroup, Constraint, Edge, Index, Schema } from ".";
 export declare const Timestamps: Pattern;
 export declare const Node: Pattern;
+export interface SchemaConfig extends Schema {
+}
+export declare class EntSchema implements Schema {
+    fields: FieldMap | Field[];
+    tableName: string | undefined;
+    patterns: Pattern[];
+    edges: Edge[] | undefined;
+    edgeGroups: AssocEdgeGroup[] | undefined;
+    actions: Action[] | undefined;
+    enumTable: boolean | undefined;
+    dbRows: {
+        [key: string]: any;
+    }[] | undefined;
+    constraints: Constraint[] | undefined;
+    indices: Index[] | undefined;
+    hideFromGraphQL?: boolean;
+    constructor(cfg: SchemaConfig);
+}
+export declare class EntSchemaWithTZ implements Schema {
+    fields: FieldMap | Field[];
+    tableName: string | undefined;
+    patterns: Pattern[];
+    edges: Edge[] | undefined;
+    edgeGroups: AssocEdgeGroup[] | undefined;
+    actions: Action[] | undefined;
+    enumTable: boolean | undefined;
+    dbRows: {
+        [key: string]: any;
+    }[] | undefined;
+    constraints: Constraint[] | undefined;
+    indices: Index[] | undefined;
+    hideFromGraphQL?: boolean;
+    constructor(cfg: SchemaConfig);
+}
 export declare abstract class BaseEntSchema {
     addPatterns(...patterns: Pattern[]): void;
     patterns: Pattern[];

package/schema/base_schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = void 0;
+exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.EntSchemaWithTZ = exports.EntSchema = exports.Node = exports.Timestamps = void 0;
 const uuid_1 = require("uuid");
 const field_1 = require("./field");
 let tsFields = {
@@ -66,9 +66,56 @@ let nodeFieldsWithTZ = {
 exports.Node = {
     name: "node",
     fields: nodeFields,
+    disableMixin: true,
 };
-// Base ent schema. has Node Pattern by default.
+// Ent schema. has Node Pattern by default.
 // exists just to have less typing and easier for clients to implement
+class EntSchema {
+    constructor(cfg) {
+        this.patterns = [exports.Node];
+        this.fields = cfg.fields;
+        this.tableName = cfg.tableName;
+        if (cfg.patterns) {
+            this.patterns.push(...cfg.patterns);
+        }
+        this.edges = cfg.edges;
+        this.edgeGroups = cfg.edgeGroups;
+        this.actions = cfg.actions;
+        this.enumTable = cfg.enumTable;
+        this.dbRows = cfg.dbRows;
+        this.constraints = cfg.constraints;
+        this.indices = cfg.indices;
+        this.hideFromGraphQL = cfg.hideFromGraphQL;
+    }
+}
+exports.EntSchema = EntSchema;
+class EntSchemaWithTZ {
+    constructor(cfg) {
+        this.patterns = [
+            {
+                // default schema added
+                name: "nodeWithTZ",
+                fields: nodeFieldsWithTZ,
+                disableMixin: true,
+            },
+        ];
+        this.fields = cfg.fields;
+        this.tableName = cfg.tableName;
+        if (cfg.patterns) {
+            this.patterns.push(...cfg.patterns);
+        }
+        this.edges = cfg.edges;
+        this.edgeGroups = cfg.edgeGroups;
+        this.actions = cfg.actions;
+        this.enumTable = cfg.enumTable;
+        this.dbRows = cfg.dbRows;
+        this.constraints = cfg.constraints;
+        this.indices = cfg.indices;
+        this.hideFromGraphQL = cfg.hideFromGraphQL;
+    }
+}
+exports.EntSchemaWithTZ = EntSchemaWithTZ;
+// @deprecated use EntSchema
 class BaseEntSchema {
     constructor() {
         this.patterns = [exports.Node];
@@ -78,6 +125,7 @@ class BaseEntSchema {
     }
 }
 exports.BaseEntSchema = BaseEntSchema;
+// @deprecated use EntSchemaWithTZ
 class BaseEntSchemaWithTZ {
     constructor() {
         this.patterns = [
@@ -85,6 +133,7 @@ class BaseEntSchemaWithTZ {
                 // default schema added
                 name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
+                disableMixin: true,
             },
         ];
     }

package/schema/field.d.ts

@@ -146,7 +146,7 @@ export declare class ListField extends BaseField {
     validate(validator: (val: any[]) => boolean): this;
     valid(val: any): Promise<boolean>;
     private postgresVal;
-    format(val: any): any;
+    format(val: any, nested?: boolean): any;
     minLen(l: number): this;
     maxLen(l: number): this;
     length(l: number): this;

package/schema/field.js

@@ -597,13 +597,17 @@ class ListField extends BaseField {
         }
         return JSON.stringify(val);
     }
-    format(val) {
+    format(val, nested) {
         if (!Array.isArray(val)) {
             throw new Error(`need an array to format`);
         }
         const elemDBType = this.type.listElemType.dbType;
         const jsonType = elemDBType === "JSON" || elemDBType === "JSONB";
-        const postgres = db_1.default.getDialect() === db_1.Dialect.Postgres;
+        // postgres ish doesn't apply when nested
+        const postgres = !nested && db_1.default.getDialect() === db_1.Dialect.Postgres;
+        if (nested && !this.field.format) {
+            return val;
+        }
         if (!postgres && !this.field.format) {
             return JSON.stringify(val);
         }
@@ -612,7 +616,7 @@ class ListField extends BaseField {
         for (let i = 0; i < val.length; i++) {
             let formatted = val[i];
             if (this.field.format) {
-                formatted = this.field.format(val[i]);
+                formatted = this.field.format(val[i], nested);
             }
             // postgres supports arrays natively so we
             // structure it in the expected format
@@ -629,6 +633,10 @@ class ListField extends BaseField {
         if (postgres) {
             return postgresRet + "}";
         }
+        // don't JSON.stringify if nested
+        if (nested) {
+            return ret;
+        }
         return JSON.stringify(ret);
     }
     minLen(l) {

package/schema/index.d.ts

@@ -1,6 +1,8 @@
 import Schema from "./schema";
 export { Schema };
-export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, ActionOperation, Action, EdgeAction, NoFields, FieldMap, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, } from "./schema";
-export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, } 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, getTransformedReadClause, getObjectLoaderProperties, } from "./schema";
+export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, EntSchema, EntSchemaWithTZ, } from "./base_schema";
 export * from "./field";
 export * from "./json_field";
+export * from "./struct_field";
+export * from "./union_field";

package/schema/index.js

@@ -10,19 +10,28 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = exports.optionalField = exports.requiredField = exports.ConstraintType = exports.NoFields = exports.ActionOperation = exports.getFields = exports.DBType = void 0;
+exports.EntSchemaWithTZ = exports.EntSchema = exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.SQLStatementOperation = exports.optionalField = exports.requiredField = exports.ConstraintType = exports.NoFields = exports.ActionOperation = exports.getStorageKey = exports.getFieldsWithPrivacy = exports.getFields = exports.DBType = void 0;
 var schema_1 = require("./schema");
 Object.defineProperty(exports, "DBType", { enumerable: true, get: function () { return schema_1.DBType; } });
 Object.defineProperty(exports, "getFields", { enumerable: true, get: function () { return schema_1.getFields; } });
+Object.defineProperty(exports, "getFieldsWithPrivacy", { enumerable: true, get: function () { return schema_1.getFieldsWithPrivacy; } });
+Object.defineProperty(exports, "getStorageKey", { enumerable: true, get: function () { return schema_1.getStorageKey; } });
 Object.defineProperty(exports, "ActionOperation", { enumerable: true, get: function () { return schema_1.ActionOperation; } });
 Object.defineProperty(exports, "NoFields", { enumerable: true, get: function () { return schema_1.NoFields; } });
 Object.defineProperty(exports, "ConstraintType", { enumerable: true, get: function () { return schema_1.ConstraintType; } });
 Object.defineProperty(exports, "requiredField", { enumerable: true, get: function () { return schema_1.requiredField; } });
 Object.defineProperty(exports, "optionalField", { enumerable: true, get: function () { return schema_1.optionalField; } });
+Object.defineProperty(exports, "SQLStatementOperation", { enumerable: true, get: function () { return schema_1.SQLStatementOperation; } });
+Object.defineProperty(exports, "getTransformedReadClause", { enumerable: true, get: function () { return schema_1.getTransformedReadClause; } });
+Object.defineProperty(exports, "getObjectLoaderProperties", { enumerable: true, get: function () { return schema_1.getObjectLoaderProperties; } });
 var base_schema_1 = require("./base_schema");
 Object.defineProperty(exports, "Timestamps", { enumerable: true, get: function () { return base_schema_1.Timestamps; } });
 Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return base_schema_1.Node; } });
 Object.defineProperty(exports, "BaseEntSchema", { enumerable: true, get: function () { return base_schema_1.BaseEntSchema; } });
 Object.defineProperty(exports, "BaseEntSchemaWithTZ", { enumerable: true, get: function () { return base_schema_1.BaseEntSchemaWithTZ; } });
+Object.defineProperty(exports, "EntSchema", { enumerable: true, get: function () { return base_schema_1.EntSchema; } });
+Object.defineProperty(exports, "EntSchemaWithTZ", { enumerable: true, get: function () { return base_schema_1.EntSchemaWithTZ; } });
 __exportStar(require("./field"), exports);
 __exportStar(require("./json_field"), exports);
+__exportStar(require("./struct_field"), exports);
+__exportStar(require("./union_field"), exports);

package/schema/schema.d.ts

@@ -1,8 +1,16 @@
-import { Data, Ent, LoaderInfo } from "../core/base";
+import { Data, Ent, LoaderInfo, PrivacyPolicy, Viewer } from "../core/base";
 import { Builder } from "../action/action";
+import { Clause } from "../core/clause";
 export declare type FieldMap = {
     [key: string]: Field;
 };
+interface FieldInfo {
+    dbCol: string;
+    inputKey: string;
+}
+export declare type FieldInfoMap = {
+    [key: string]: FieldInfo;
+};
 export default interface Schema {
     fields: FieldMap | Field[];
     tableName?: string;
@@ -61,7 +69,29 @@ 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> | null;
+    transformsDelete?: boolean;
+    transformsInsert?: boolean;
+    transformsUpdate?: boolean;
+}
+export declare enum SQLStatementOperation {
+    Insert = "insert",
+    Update = "update",
+    Delete = "delete"
+}
+export interface UpdateOperation<T extends Ent> {
+    op: SQLStatementOperation;
+    existingEnt: T | null;
+    viewer: Viewer;
+    data?: Map<string, any>;
+}
+export interface TransformedUpdateOperation<T extends Ent> {
+    op: SQLStatementOperation;
+    data?: Data;
+    existingEnt?: T | null;
 }
 export declare enum DBType {
     UUID = "UUID",
@@ -85,6 +115,7 @@ export declare enum DBType {
 export interface ImportType {
     path: string;
     type: string;
+    [x: string]: any;
 }
 declare type EnumMap = {
     [key: string]: string;
@@ -97,6 +128,8 @@ export interface Type {
     values?: string[];
     enumMap?: EnumMap;
     importType?: ImportType;
+    subFields?: FieldMap;
+    unionFields?: FieldMap;
 }
 export interface ForeignKey {
     schema: string;
@@ -133,11 +166,13 @@ export interface FieldOptions {
     fieldEdge?: FieldEdge;
     primaryKey?: boolean;
     disableUserEditable?: boolean;
+    disableUserGraphQLEditable?: boolean;
     defaultValueOnCreate?(builder: Builder<Ent>, input: Data): any;
     defaultToViewerOnCreate?: boolean;
     defaultValueOnEdit?(builder: Builder<Ent>, input: Data): any;
     derivedWhenEmbedded?: boolean;
     polymorphic?: boolean | PolymorphicOptions;
+    privacyPolicy?: PrivacyPolicy | (() => PrivacyPolicy);
     getDerivedFields?(name: string): FieldMap;
     [x: string]: any;
 }
@@ -149,14 +184,27 @@ export interface PolymorphicOptions {
 export interface Field extends FieldOptions {
     type: Type;
     valid?(val: any): Promise<boolean> | boolean;
-    format?(val: any): any;
+    format?(val: any, nested?: boolean): any;
     logValue(val: any): any;
 }
 export interface SchemaConstructor {
     new (): Schema;
 }
 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, 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> | null;
 export declare enum ActionOperation {
     Create = 1,
     Edit = 2,
@@ -199,10 +247,24 @@ export interface Constraint {
     fkey?: ForeignKeyInfo;
     condition?: string;
 }
+export interface FullTextWeight {
+    A?: string[];
+    B?: string[];
+    C?: string[];
+    D?: string[];
+}
+export interface FullText {
+    generatedColumnName?: string;
+    language?: "english" | "french" | "german" | "simple";
+    languageColumn?: string;
+    indexType?: "gin" | "gist";
+    weights?: FullTextWeight;
+}
 export interface Index {
     name: string;
     columns: string[];
     unique?: boolean;
+    fulltext?: FullText;
 }
 export interface ForeignKeyInfo {
     tableName: string;

package/schema/schema.js

@@ -1,6 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConstraintType = exports.optionalField = exports.requiredField = exports.NoFields = exports.ActionOperation = exports.getFields = exports.DBType = void 0;
+exports.ConstraintType = exports.optionalField = exports.requiredField = exports.NoFields = exports.ActionOperation = exports.getTransformedUpdateOp = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.getFieldsWithPrivacy = exports.getStorageKey = exports.getFields = exports.getSchema = exports.DBType = exports.SQLStatementOperation = void 0;
+const snake_case_1 = require("snake-case");
+// we also want this transformation to exist on a per-action basis
+// if it exists on an action, we don't do the global schema transformation
+var SQLStatementOperation;
+(function (SQLStatementOperation) {
+    // transform insert e.g. to an update based on whatever logic
+    SQLStatementOperation["Insert"] = "insert";
+    // // transform select e.g. deleted_at. can't change from select to different query type
+    // // but can change the query
+    // Select = "select",
+    // e.g. change updated value
+    SQLStatementOperation["Update"] = "update";
+    // delete -> update theoretically e.g. deleted_at
+    SQLStatementOperation["Delete"] = "delete";
+})(SQLStatementOperation = exports.SQLStatementOperation || (exports.SQLStatementOperation = {}));
 // we want --strictNullChecks flag so nullable is used to type graphql, ts, db
 // should eventually generate (boolean | null) etc
 // supported db types
@@ -28,14 +43,17 @@ var DBType;
 function isSchema(value) {
     return value.fields !== undefined;
 }
-function getFields(value) {
-    let schema;
+function getSchema(value) {
     if (isSchema(value)) {
-        schema = value;
+        return value;
     }
     else {
-        schema = new value();
+        return new value();
     }
+}
+exports.getSchema = getSchema;
+function getFields(value) {
+    const schema = getSchema(value);
     function addFields(fields) {
         if (Array.isArray(fields)) {
             for (const field of fields) {
@@ -68,6 +86,108 @@ 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, fieldMap) {
+    const schema = getSchema(value);
+    function addFields(fields) {
+        if (Array.isArray(fields)) {
+            for (const field of fields) {
+                const name = field.name;
+                if (!field.name) {
+                    throw new Error(`name required`);
+                }
+                if (field.getDerivedFields !== undefined) {
+                    addFields(field.getDerivedFields(name));
+                }
+                if (field.privacyPolicy) {
+                    let privacyPolicy;
+                    if (typeof field.privacyPolicy === "function") {
+                        privacyPolicy = field.privacyPolicy();
+                    }
+                    else {
+                        privacyPolicy = field.privacyPolicy;
+                    }
+                    const info = fieldMap[name];
+                    if (!info) {
+                        throw new Error(`field with name ${name} not passed in fieldMap`);
+                    }
+                    m.set(info.dbCol, privacyPolicy);
+                }
+            }
+        }
+        for (const name in fields) {
+            const field = fields[name];
+            if (field.getDerivedFields !== undefined) {
+                addFields(field.getDerivedFields(name));
+            }
+            if (field.privacyPolicy) {
+                let privacyPolicy;
+                if (typeof field.privacyPolicy === "function") {
+                    privacyPolicy = field.privacyPolicy();
+                }
+                else {
+                    privacyPolicy = field.privacyPolicy;
+                }
+                const info = fieldMap[name];
+                if (!info) {
+                    throw new Error(`field with name ${name} not passed in fieldMap`);
+                }
+                m.set(info.dbCol, privacyPolicy);
+            }
+        }
+    }
+    let m = new Map();
+    if (schema.patterns) {
+        for (const pattern of schema.patterns) {
+            addFields(pattern.fields);
+        }
+    }
+    addFields(schema.fields);
+    return m;
+}
+exports.getFieldsWithPrivacy = getFieldsWithPrivacy;
+function getTransformedReadClause(value) {
+    const schema = getSchema(value);
+    if (!schema.patterns) {
+        return;
+    }
+    for (const p of schema.patterns) {
+        // e.g. discarded_at, deleted_at, etc
+        if (p.transformRead) {
+            // return clause.Eq('deleted_at', null);
+            return p.transformRead();
+        }
+    }
+    return;
+}
+exports.getTransformedReadClause = getTransformedReadClause;
+function getObjectLoaderProperties(value, tableName) {
+    return {
+        clause: () => getTransformedReadClause(value),
+        instanceKey: `${tableName}:transformedReadClause`,
+    };
+}
+exports.getObjectLoaderProperties = getObjectLoaderProperties;
+function getTransformedUpdateOp(value, stmt) {
+    const schema = getSchema(value);
+    if (!schema.patterns) {
+        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
 var ActionOperation;
 (function (ActionOperation) {

package/schema/struct_field.d.ts

@@ -0,0 +1,17 @@
+import { BaseField, ListField } from "./field";
+import { FieldOptions, Field, Type, FieldMap } from "./schema";
+export interface StructOptions extends FieldOptions {
+    tsType: string;
+    fields: FieldMap;
+    graphQLType?: string;
+    jsonNotJSONB?: boolean;
+}
+export declare class StructField extends BaseField implements Field {
+    private options;
+    type: Type;
+    constructor(options: StructOptions);
+    format(obj: any, nested?: boolean): string | Object;
+    valid(obj: any): Promise<boolean>;
+}
+export declare function StructType(options: StructOptions): StructField & StructOptions;
+export declare function StructListType(options: StructOptions): ListField;