@snowtop/ent 0.1.0-alpha → 0.1.0-alpha12

package/schema/field.js

@@ -40,19 +40,25 @@ class UUIDField extends BaseField {
         super();
         this.options = options;
         this.type = { dbType: schema_1.DBType.UUID };
-        const polymorphic = options.polymorphic;
+        if (options?.fieldEdge?.enforceSchema &&
+            !options.fieldEdge.getLoaderInfoFromSchema) {
+            throw new Error(`cannot enforceSchema if getLoaderInfoFromSchema wasn't passed in`);
+        }
+    }
+    getDerivedFields(fieldName) {
+        const polymorphic = this.options?.polymorphic;
         if (polymorphic) {
             let name = "";
-            if (options.name.endsWith("_id")) {
-                let idx = options.name.indexOf("_id");
-                name = options.name.substring(0, idx) + "_type";
+            if (fieldName.endsWith("_id")) {
+                let idx = fieldName.indexOf("_id");
+                name = fieldName.substring(0, idx) + "_type";
             }
-            else if (options.name.endsWith("ID")) {
-                let idx = options.name.indexOf("ID");
-                name = options.name.substring(0, idx) + "Type";
+            else if (fieldName.endsWith("ID")) {
+                let idx = fieldName.indexOf("ID");
+                name = fieldName.substring(0, idx) + "Type";
             }
             else {
-                throw new Error(`unsupported id polymorhpic type ${options.name}`);
+                throw new Error(`unsupported id polymorhpic type ${fieldName}`);
             }
             // polymorphic field automatically hidden from GraphQL
             // can be made visible with custom fields if user wants to change this behavior
@@ -60,38 +66,33 @@ class UUIDField extends BaseField {
             // intentionally not made private as it doesn't seem like it needs to be hidden
             if (typeof polymorphic === "object" && polymorphic.types) {
                 // an enum with types validated here
-                this.derivedFields = [
-                    EnumType({
-                        name,
+                return {
+                    [name]: EnumType({
                         values: polymorphic.types,
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
-                        nullable: options.nullable,
+                        nullable: this.options?.nullable,
                     }),
-                ];
+                };
             }
             else {
                 // just a string field...
-                this.derivedFields = [
-                    StringType({
-                        name,
+                return {
+                    [name]: StringType({
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
-                        nullable: options.nullable,
+                        nullable: this.options?.nullable,
                     }),
-                ];
+                };
             }
         }
-        if (options.fieldEdge?.enforceSchema &&
-            !options.fieldEdge.getLoaderInfoFromSchema) {
-            throw new Error(`cannot enforceSchema if getLoaderInfoFromSchema wasn't passed in`);
-        }
+        return {};
     }
     isBuilder(val) {
         return val.placeholderID !== undefined;
     }
     async valid(val) {
-        if (!this.options.fieldEdge?.enforceSchema) {
+        if (!this.options?.fieldEdge?.enforceSchema) {
             return true;
         }
         const getLoaderInfo = this.options.fieldEdge.getLoaderInfoFromSchema;
@@ -119,7 +120,7 @@ class IntegerField extends BaseField {
         super();
         this.type = { dbType: schema_1.DBType.Int };
         this.validators = [];
-        this.options = { name: "field" };
+        this.options = {};
         // for legacy callers
         this.handleOptions(options || this.options);
     }
@@ -206,9 +207,9 @@ class StringField extends BaseField {
         this.type = { dbType: schema_1.DBType.String };
         this.validators = [];
         this.formatters = [];
-        this.options = { name: "field" };
+        this.options = {};
         // for legacy callers
-        this.handleOptions(options || { name: "field" });
+        this.handleOptions(options || {});
     }
     getOptions() {
         return this.options;
@@ -347,7 +348,7 @@ class TimestampField extends BaseField {
 }
 exports.TimestampField = TimestampField;
 function TimestampType(options) {
-    let result = new TimestampField(options);
+    let result = new TimestampField({ ...options });
     return Object.assign(result, options);
 }
 exports.TimestampType = TimestampType;
@@ -374,7 +375,7 @@ class TimeField extends BaseField {
     constructor(options) {
         super();
         this.type = { dbType: schema_1.DBType.Time };
-        if (options.withTimezone) {
+        if (options?.withTimezone) {
             this.type = {
                 dbType: schema_1.DBType.Timetz,
             };
@@ -451,8 +452,8 @@ class EnumField extends BaseField {
             dbType: options.createEnumType ? schema_1.DBType.Enum : schema_1.DBType.StringEnum,
             values: options.values,
             enumMap: options.map,
-            type: options.tsType || options.name,
-            graphQLType: options.graphQLType || options.name,
+            type: options.tsType,
+            graphQLType: options.graphQLType,
         };
         if (!options.foreignKey) {
             if (!options.values && !options.map) {
@@ -596,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);
         }
@@ -611,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
@@ -628,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, 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/json_field.d.ts

@@ -5,13 +5,13 @@ export interface JSONOptions extends FieldOptions {
     importType?: ImportType;
 }
 export declare class JSONField extends BaseField implements Field {
-    private options;
+    private options?;
     type: Type;
-    constructor(jsonb: boolean, options: JSONOptions);
+    constructor(jsonb: boolean, options?: JSONOptions | undefined);
     format(val: any): string;
     valid(val: any): boolean;
 }
-export declare function JSONType(options: JSONOptions): JSONField;
-export declare function JSONBType(options: JSONOptions): JSONField;
-export declare function JSONBListType(options: JSONOptions): ListField;
-export declare function JSONListType(options: JSONOptions): ListField;
+export declare function JSONType(options?: JSONOptions): JSONField;
+export declare function JSONBType(options?: JSONOptions): JSONField;
+export declare function JSONBListType(options?: JSONOptions): ListField;
+export declare function JSONListType(options?: JSONOptions): ListField;

package/schema/json_field.js

@@ -13,7 +13,7 @@ class JSONField extends field_1.BaseField {
         if (jsonb) {
             this.type.dbType = schema_1.DBType.JSONB;
         }
-        if (options.importType) {
+        if (options?.importType) {
             this.type.importType = options.importType;
         }
     }
@@ -21,7 +21,7 @@ class JSONField extends field_1.BaseField {
         return JSON.stringify(val);
     }
     valid(val) {
-        if (this.options.validator) {
+        if (this.options?.validator) {
             return this.options.validator(val);
         }
         return true;

package/schema/schema.d.ts

@@ -1,7 +1,18 @@
-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: Field[];
+    fields: FieldMap | Field[];
     tableName?: string;
     patterns?: Pattern[];
     edges?: Edge[];
@@ -57,8 +68,29 @@ export interface AssocEdgeGroup {
 export declare type Edge = AssocEdge;
 export interface Pattern {
     name: string;
-    fields: Field[];
+    fields: FieldMap | Field[];
     edges?: Edge[];
+    transformRead?: () => Clause;
+    transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | undefined;
+    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;
+    viewer: Viewer;
+    data?: Map<string, any>;
+}
+export interface TransformedUpdateOperation<T extends Ent> {
+    op: SQLStatementOperation;
+    data?: Data;
+    existingEnt?: T;
 }
 export declare enum DBType {
     UUID = "UUID",
@@ -82,6 +114,7 @@ export declare enum DBType {
 export interface ImportType {
     path: string;
     type: string;
+    [x: string]: any;
 }
 declare type EnumMap = {
     [key: string]: string;
@@ -94,6 +127,8 @@ export interface Type {
     values?: string[];
     enumMap?: EnumMap;
     importType?: ImportType;
+    subFields?: FieldMap;
+    unionFields?: FieldMap;
 }
 export interface ForeignKey {
     schema: string;
@@ -117,7 +152,6 @@ export interface FieldEdge {
     disableBuilderType?: boolean;
 }
 export interface FieldOptions {
-    name: string;
     nullable?: boolean;
     storageKey?: string;
     serverDefault?: any;
@@ -131,12 +165,15 @@ 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;
-    derivedFields?: Field[];
+    privacyPolicy?: PrivacyPolicy | (() => PrivacyPolicy);
+    getDerivedFields?(name: string): FieldMap;
+    [x: string]: any;
 }
 export interface PolymorphicOptions {
     types?: string[];
@@ -146,14 +183,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> | undefined;
 export declare enum ActionOperation {
     Create = 1,
     Edit = 2,
@@ -196,10 +246,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,21 +43,37 @@ 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) {
-        for (const field of fields) {
-            const derivedFields = field.derivedFields;
-            if (derivedFields !== undefined) {
-                addFields(derivedFields);
+        if (Array.isArray(fields)) {
+            for (const field of fields) {
+                const name = field.name;
+                if (!name) {
+                    throw new Error(`name required`);
+                }
+                if (field.getDerivedFields !== undefined) {
+                    addFields(field.getDerivedFields(name));
+                }
+                m.set(name, field);
+            }
+            return;
+        }
+        for (const name in fields) {
+            const field = fields[name];
+            if (field.getDerivedFields !== undefined) {
+                addFields(field.getDerivedFields(name));
             }
-            m.set(field.name, field);
+            m.set(name, field);
         }
     }
     let m = new Map();
@@ -55,6 +86,107 @@ 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;
+    }
+    for (const p of schema.patterns) {
+        if (p.transformWrite) {
+            return p.transformWrite(stmt);
+        }
+    }
+}
+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;