@snowtop/ent 0.0.2 → 0.0.3-5.alpha.2

package/schema/field.js

@@ -19,11 +19,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnumListType = exports.DateListType = exports.TimetzListType = exports.TimeListType = exports.TimestamptzListType = exports.TimestampListType = exports.BooleanListType = exports.FloatListType = 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.IntegerType = exports.IntegerField = exports.UUIDType = exports.UUIDField = exports.BaseField = void 0;
-const schema_1 = require("./schema");
-const snake_case_1 = require("snake-case");
+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 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 +38,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) {
@@ -64,6 +66,7 @@ class UUIDField extends BaseField {
                         values: polymorphic.types,
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
+                        nullable: options.nullable,
                     }),
                 ];
             }
@@ -74,10 +77,35 @@ class UUIDField extends BaseField {
                         name,
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
+                        nullable: options.nullable,
                     }),
                 ];
             }
         }
+        if (options.fieldEdge?.enforceSchema &&
+            !options.fieldEdge.getLoaderInfoFromSchema) {
+            throw new Error(`cannot enforceSchema if getLoaderInfoFromSchema wasn't passed in`);
+        }
+    }
+    isBuilder(val) {
+        return val.placeholderID !== undefined;
+    }
+    async valid(val) {
+        if (!this.options.fieldEdge?.enforceSchema) {
+            return true;
+        }
+        const getLoaderInfo = this.options.fieldEdge.getLoaderInfoFromSchema;
+        const loaderInfo = getLoaderInfo(this.options.fieldEdge.schema);
+        if (!loaderInfo) {
+            throw new Error(`couldn't get loaderInfo for ${this.options.fieldEdge.schema}`);
+        }
+        if (this.isBuilder(val)) {
+            // if builder, the nodeType of the builder and the nodeType of the loaderInfo should match
+            return val.nodeType === loaderInfo.nodeType;
+        }
+        // TODO we need context here to make sure that we hit local cache
+        const row = await loaderInfo.loaderFactory.createLoader().load(val);
+        return row !== null;
     }
 }
 exports.UUIDField = UUIDField;
@@ -87,17 +115,67 @@ function UUIDType(options) {
 }
 exports.UUIDType = UUIDType;
 class IntegerField extends BaseField {
-    constructor() {
-        super(...arguments);
+    constructor(options) {
+        super();
         this.type = { dbType: schema_1.DBType.Int };
+        this.validators = [];
+        this.options = { name: "field" };
+        // for legacy callers
+        this.handleOptions(options || this.options);
+    }
+    getOptions() {
+        return this.options;
+    }
+    handleOptions(options) {
+        const params = {
+            min: this.min,
+            max: this.max,
+        };
+        for (const k in params) {
+            const v = options[k];
+            if (v !== undefined) {
+                params[k].apply(this, [v]);
+            }
+        }
+        this.options = options;
+    }
+    min(l) {
+        return this.validate((val) => val >= l);
+    }
+    max(l) {
+        return this.validate((val) => val <= l);
+    }
+    valid(val) {
+        for (const validator of this.validators) {
+            if (!validator(val)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    validate(validator) {
+        this.validators.push(validator);
+        return this;
     }
 }
 exports.IntegerField = IntegerField;
 function IntegerType(options) {
-    let result = new IntegerField();
+    let result = new IntegerField(options);
     return Object.assign(result, options);
 }
 exports.IntegerType = IntegerType;
+class BigIntegerField extends BaseField {
+    constructor() {
+        super(...arguments);
+        this.type = { dbType: schema_1.DBType.BigInt };
+    }
+}
+exports.BigIntegerField = BigIntegerField;
+function BigIntegerType(options) {
+    let result = new BigIntegerField();
+    return Object.assign(result, options);
+}
+exports.BigIntegerType = BigIntegerType;
 class FloatField extends BaseField {
     constructor() {
         super(...arguments);
@@ -128,11 +206,12 @@ class StringField extends BaseField {
         this.type = { dbType: schema_1.DBType.String };
         this.validators = [];
         this.formatters = [];
+        this.options = { name: "field" };
         // for legacy callers
         this.handleOptions(options || { name: "field" });
     }
     getOptions() {
-        return this.getOptions;
+        return this.options;
     }
     handleOptions(options) {
         const noParams = {
@@ -160,6 +239,7 @@ class StringField extends BaseField {
                 noParams[k].apply(this);
             }
         }
+        this.options = options;
     }
     minLen(l) {
         return this.validate((val) => {
@@ -310,12 +390,12 @@ class TimeField extends BaseField {
         if (this.withTimezone) {
             // for some reason this API is backwards
             let div = (val.getTimezoneOffset() / 60) * -1;
-            offset = exports.leftPad(div);
+            offset = (0, exports.leftPad)(div);
         }
-        let hh = exports.leftPad(val.getHours());
-        let mm = exports.leftPad(val.getMinutes());
-        let ss = exports.leftPad(val.getSeconds());
-        let ms = exports.leftPad(val.getMilliseconds());
+        let hh = (0, exports.leftPad)(val.getHours());
+        let mm = (0, exports.leftPad)(val.getMinutes());
+        let ss = (0, exports.leftPad)(val.getSeconds());
+        let ms = (0, exports.leftPad)(val.getMilliseconds());
         if (ms !== "00" && offset) {
             return `${hh}:${mm}:${ss}.${ms}${offset}`;
         }
@@ -348,11 +428,11 @@ class DateField extends BaseField {
         if (!(val instanceof Date)) {
             return val;
         }
-        let yy = exports.leftPad(val.getFullYear());
+        let yy = (0, exports.leftPad)(val.getFullYear());
         // lol this API
         // for some reason this is 0-index
-        let mm = exports.leftPad(val.getMonth() + 1);
-        let dd = exports.leftPad(val.getDate());
+        let mm = (0, exports.leftPad)(val.getMonth() + 1);
+        let dd = (0, exports.leftPad)(val.getDate());
         let ret = `${yy}-${mm}-${dd}`;
         return ret;
     }
@@ -370,20 +450,33 @@ class EnumField extends BaseField {
             // if createEnumType boolean, we create postgres enum otherwise we use a string for it
             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,
         };
         if (!options.foreignKey) {
-            if (!options.values) {
-                throw new Error("values required if not look up table enum. Look-up table enum indicated by foreignKey field");
+            if (!options.values && !options.map) {
+                throw new Error("values or map required if not look up table enum. Look-up table enum indicated by foreignKey field");
             }
-            if (!options.values.length) {
-                throw new Error("need at least one value in enum type");
+            if (options.values) {
+                if (!options.values.length) {
+                    throw new Error("need at least one value in enum type");
+                }
+            }
+            if (options.map) {
+                let count = 0;
+                for (const k in options.map) {
+                    count++;
+                    break;
+                }
+                if (!count) {
+                    throw new Error("need at least one entry in enum map");
+                }
             }
         }
         else {
-            if (options.values) {
-                throw new Error("cannot specify values and foreign key for lookup table enum type");
+            if (options.values || options.map) {
+                throw new Error("cannot specify values or map and foreign key for lookup table enum type");
             }
             if (options.createEnumType) {
                 throw new Error("cannot specify createEnumType without specifying values");
@@ -396,30 +489,55 @@ class EnumField extends BaseField {
             }
         }
         this.values = options.values;
+        this.map = options.map;
     }
+    // TODO need to update this for map
     convertForGQL(value) {
-        return snake_case_1.snakeCase(value).toUpperCase();
+        return (0, snake_case_1.snakeCase)(value).toUpperCase();
     }
     valid(val) {
         // lookup table enum and indicated via presence of foreignKey
-        if (!this.values) {
+        if (!this.values && !this.map) {
             return true;
         }
-        let str = String(val);
-        return this.values.some((value) => value === str || this.convertForGQL(value) === str);
+        if (this.values) {
+            let str = String(val);
+            return this.values.some((value) => value === str || this.convertForGQL(value) === str);
+        }
+        for (const k in this.map) {
+            const v = this.map[k];
+            if (v === val || this.convertForGQL(k) === val) {
+                // TODO decide on behavior for GQL since GQL only supports one type
+                return true;
+            }
+        }
+        return false;
     }
     format(val) {
         // TODO need to format correctly for graphql purposes...
         // how to best get the values in the db...
-        if (!this.values) {
+        if (!this.values && !this.map) {
             return val;
         }
         let str = String(val);
-        for (let i = 0; i < this.values.length; i++) {
-            let value = this.values[i];
-            // store the format that maps to the given value in the db instead of saving the upper case value
-            if (str === value || str === this.convertForGQL(value)) {
-                return value;
+        if (this.values) {
+            for (let i = 0; i < this.values.length; i++) {
+                let value = this.values[i];
+                // store the format that maps to the given value in the db instead of saving the upper case value
+                if (str === value || str === this.convertForGQL(value)) {
+                    return value;
+                }
+            }
+        }
+        if (this.map) {
+            for (const k in this.map) {
+                const v = this.map[k];
+                if (str === v) {
+                    return v;
+                }
+                if (str === this.convertForGQL(k)) {
+                    return v;
+                }
             }
         }
         // whelp, just return what's passed
@@ -436,6 +554,7 @@ class ListField extends BaseField {
     constructor(field, options) {
         super();
         this.field = field;
+        this.validators = [];
         if (field.type.dbType === schema_1.DBType.List) {
             throw new Error(`nested lists not currently supported`);
         }
@@ -445,36 +564,92 @@ class ListField extends BaseField {
         };
         Object.assign(this, options);
     }
-    valid(val) {
+    validate(validator) {
+        this.validators.push(validator);
+        return this;
+    }
+    async valid(val) {
         if (!Array.isArray(val)) {
             return false;
         }
-        if (!this.field.valid) {
-            return true;
-        }
-        for (const v of val) {
-            if (!this.field.valid(v)) {
+        for (const validator of this.validators) {
+            if (!validator(val)) {
                 return false;
             }
         }
-        return true;
+        const valid = this.field.valid;
+        if (!valid) {
+            return true;
+        }
+        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);
+        }
+        const ret = val.map((v) => valid.apply(this.field, [v]));
+        const result = ret.every((v) => v);
+        return result;
+    }
+    postgresVal(val, jsonType) {
+        if (!jsonType) {
+            return val;
+        }
+        return JSON.stringify(val);
     }
     format(val) {
         if (!Array.isArray(val)) {
             throw new Error(`need an array to format`);
         }
-        if (this.field.format) {
-            for (let i = 0; i < val.length; i++) {
-                val[i] = this.field.format(val[i]);
+        const elemDBType = this.type.listElemType.dbType;
+        const jsonType = elemDBType === "JSON" || elemDBType === "JSONB";
+        const postgres = db_1.default.getDialect() === db_1.Dialect.Postgres;
+        if (!postgres && !this.field.format) {
+            return JSON.stringify(val);
+        }
+        let ret = [];
+        let postgresRet = "{";
+        for (let i = 0; i < val.length; i++) {
+            let formatted = val[i];
+            if (this.field.format) {
+                formatted = this.field.format(val[i]);
+            }
+            // postgres supports arrays natively so we
+            // structure it in the expected format
+            if (postgres) {
+                postgresRet += this.postgresVal(formatted, jsonType);
+                if (i !== val.length - 1) {
+                    postgresRet += ",";
+                }
+            }
+            else {
+                ret[i] = formatted;
             }
         }
-        // postgres supports arrays natively so we
-        // structure it in the expected format
-        if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
-            return `{${val.join(",")}}`;
+        if (postgres) {
+            return postgresRet + "}";
         }
-        // For SQLite, we store a JSON string
-        return JSON.stringify(val);
+        return JSON.stringify(ret);
+    }
+    minLen(l) {
+        return this.validate((val) => val.length >= l);
+    }
+    maxLen(l) {
+        return this.validate((val) => val.length <= l);
+    }
+    length(l) {
+        return this.validate((val) => val.length === l);
+    }
+    // like python's range() function
+    // start is where to start and stop is the number to stop (not inclusive in the range)
+    range(start, stop) {
+        return this.validate((val) => {
+            for (const v of val) {
+                if (v < start || v >= stop) {
+                    return false;
+                }
+            }
+            return true;
+        });
     }
 }
 exports.ListField = ListField;
@@ -486,10 +661,18 @@ function IntListType(options) {
     return new ListField(IntegerType(options), options);
 }
 exports.IntListType = IntListType;
+function IntegerListType(options) {
+    return new ListField(IntegerType(options), options);
+}
+exports.IntegerListType = IntegerListType;
 function FloatListType(options) {
     return new ListField(FloatType(options), options);
 }
 exports.FloatListType = FloatListType;
+function BigIntegerListType(options) {
+    return new ListField(BigIntegerType(options), options);
+}
+exports.BigIntegerListType = BigIntegerListType;
 function BooleanListType(options) {
     return new ListField(BooleanType(options), options);
 }
@@ -528,3 +711,7 @@ function EnumListType(options) {
     return new ListField(EnumType(options), options);
 }
 exports.EnumListType = EnumListType;
+function UUIDListType(options) {
+    return new ListField(UUIDType(options), options);
+}
+exports.UUIDListType = UUIDListType;

package/schema/index.d.ts

@@ -3,3 +3,4 @@ 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 * from "./field";
+export * from "./json_field";

package/schema/index.js

@@ -25,3 +25,4 @@ Object.defineProperty(exports, "Node", { enumerable: true, get: function () { re
 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; } });
 __exportStar(require("./field"), exports);
+__exportStar(require("./json_field"), exports);

package/schema/json_field.d.ts

@@ -0,0 +1,17 @@
+import { FieldOptions, Type, Field, ImportType } from "./schema";
+import { BaseField, ListField } from "./field";
+export interface JSONOptions extends FieldOptions {
+    validator?: (val: any) => boolean;
+    importType?: ImportType;
+}
+export declare class JSONField extends BaseField implements Field {
+    private options;
+    type: Type;
+    constructor(jsonb: boolean, options: JSONOptions);
+    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;

package/schema/json_field.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 {
+    constructor(jsonb, options) {
+        super();
+        this.options = options;
+        this.type = {
+            dbType: schema_1.DBType.JSON,
+        };
+        if (jsonb) {
+            this.type.dbType = schema_1.DBType.JSONB;
+        }
+        if (options.importType) {
+            this.type.importType = options.importType;
+        }
+    }
+    format(val) {
+        return JSON.stringify(val);
+    }
+    valid(val) {
+        if (this.options.validator) {
+            return this.options.validator(val);
+        }
+        return true;
+    }
+}
+exports.JSONField = JSONField;
+function JSONType(options) {
+    let result = new JSONField(false, options);
+    return Object.assign(result, options);
+}
+exports.JSONType = JSONType;
+function JSONBType(options) {
+    let result = new JSONField(true, options);
+    return Object.assign(result, options);
+}
+exports.JSONBType = JSONBType;
+function JSONBListType(options) {
+    return new field_1.ListField(JSONBType(options), options);
+}
+exports.JSONBListType = JSONBListType;
+function JSONListType(options) {
+    return new field_1.ListField(JSONType(options), options);
+}
+exports.JSONListType = JSONListType;

package/schema/schema.d.ts

@@ -1,3 +1,5 @@
+import { Data, Ent, LoaderInfo } from "../core/base";
+import { Builder } from "../action/action";
 export default interface Schema {
     fields: Field[];
     tableName?: string;
@@ -22,6 +24,7 @@ export interface AssocEdge {
     tableName?: string;
     edgeActions?: EdgeAction[];
     hideFromGraphQL?: boolean;
+    edgeConstName?: string;
 }
 export interface EdgeAction {
     operation: ActionOperation;
@@ -32,6 +35,7 @@ export interface EdgeAction {
 }
 export interface InverseAssocEdge {
     name: string;
+    edgeConstName?: string;
 }
 export interface EdgeGroupAction {
     operation: ActionOperation.EdgeGroup;
@@ -52,18 +56,22 @@ export interface AssocEdgeGroup {
 }
 export declare type Edge = AssocEdge;
 export interface Pattern {
+    name: string;
     fields: Field[];
+    edges?: Edge[];
 }
 export declare enum DBType {
     UUID = "UUID",
     Int64ID = "Int64ID",
     Boolean = "Boolean",
     Int = "Int",
+    BigInt = "BigInt",
     Float = "Float",
     String = "String",
     Timestamp = "Timestamp",
     Timestamptz = "Timestamptz",
     JSON = "JSON",
+    JSONB = "JSONB",
     Enum = "Enum",
     StringEnum = "StringEnum",
     Date = "Date",
@@ -71,22 +79,42 @@ export declare enum DBType {
     Timetz = "Timetz",
     List = "List"
 }
+export interface ImportType {
+    path: string;
+    type: string;
+}
+declare type EnumMap = {
+    [key: string]: string;
+};
 export interface Type {
     dbType: DBType;
     listElemType?: Type;
     type?: string;
     graphQLType?: string;
     values?: string[];
+    enumMap?: EnumMap;
+    importType?: ImportType;
 }
 export interface ForeignKey {
     schema: string;
     column: string;
     name?: string;
     disableIndex?: boolean;
+    disableBuilderType?: boolean;
+}
+declare type getLoaderInfoFn = (type: string) => LoaderInfo;
+export interface InverseFieldEdge {
+    name: string;
+    edgeConstName?: string;
+    tableName?: string;
+    hideFromGraphQL?: boolean;
 }
 export interface FieldEdge {
     schema: string;
-    inverseEdge: string;
+    inverseEdge?: string | InverseFieldEdge;
+    enforceSchema?: boolean;
+    getLoaderInfoFromSchema?: getLoaderInfoFn;
+    disableBuilderType?: boolean;
 }
 export interface FieldOptions {
     name: string;
@@ -103,8 +131,9 @@ export interface FieldOptions {
     fieldEdge?: FieldEdge;
     primaryKey?: boolean;
     disableUserEditable?: boolean;
-    defaultValueOnCreate?(): any;
-    defaultValueOnEdit?(): any;
+    defaultValueOnCreate?(builder: Builder<Ent>, input: Data): any;
+    defaultToViewerOnCreate?: boolean;
+    defaultValueOnEdit?(builder: Builder<Ent>, input: Data): any;
     derivedWhenEmbedded?: boolean;
     polymorphic?: boolean | PolymorphicOptions;
     derivedFields?: Field[];
@@ -112,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;
 }
@@ -141,6 +171,7 @@ export interface ActionField {
     nullable?: boolean | NullableListOptions;
     list?: boolean;
     actionName?: string;
+    excludedFields?: string[];
 }
 export interface Action {
     operation: ActionOperation;
@@ -150,6 +181,10 @@ export interface Action {
     graphQLName?: string;
     hideFromGraphQL?: boolean;
     actionOnlyFields?: ActionField[];
+    excludedFields?: string[];
+    optionalFields?: string[];
+    requiredFields?: string[];
+    noFields?: boolean;
 }
 export declare const NoFields = "__NO_FIELDS__";
 export declare function requiredField(field: string): string;

package/schema/schema.js

@@ -10,12 +10,14 @@ var DBType;
     DBType["Int64ID"] = "Int64ID";
     DBType["Boolean"] = "Boolean";
     DBType["Int"] = "Int";
+    DBType["BigInt"] = "BigInt";
     DBType["Float"] = "Float";
     DBType["String"] = "String";
     //
     DBType["Timestamp"] = "Timestamp";
     DBType["Timestamptz"] = "Timestamptz";
     DBType["JSON"] = "JSON";
+    DBType["JSONB"] = "JSONB";
     DBType["Enum"] = "Enum";
     DBType["StringEnum"] = "StringEnum";
     DBType["Date"] = "Date";