@snowtop/ent 0.0.18 → 0.0.22

package/action/orchestrator.js

@@ -224,55 +224,44 @@ class Orchestrator {
     }
     async validate() {
         const action = this.options.action;
-        let privacyPolicy = action?.getPrivacyPolicy();
         const builder = this.options.builder;
-        let promises = [];
+        // this runs in 3 phases:
+        // * privacy policy
+        // * triggers
+        // * validators
+        let privacyPolicy = action?.getPrivacyPolicy();
         if (privacyPolicy) {
-            promises.push((0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, builder.existingEnt, this.throwError.bind(this)));
+            await (0, privacy_1.applyPrivacyPolicyX)(this.options.viewer, privacyPolicy, builder.existingEnt, this.throwError.bind(this));
         }
         // have to run triggers which update fields first before field and other validators
         // so running this first to build things up
         let triggers = action?.triggers;
         if (triggers) {
-            let triggerPromises = [];
-            triggers.forEach((trigger) => {
-                let c = trigger.changeset(builder, action.getInput());
-                if (c) {
-                    triggerPromises.push(c);
-                }
-            });
-            // TODO right now trying to parallelize this with validateFields below
-            // may need to run triggers first to be deterministic
-            // TODO: see https://github.com/lolopinto/ent/pull/50
-            promises.push(this.triggers(triggerPromises));
+            await this.triggers(action, builder, triggers);
         }
-        promises.push(this.validateFields(builder, action));
         let validators = action?.validators || [];
-        if (validators) {
-            promises.push(this.validators(validators, action, builder));
-        }
-        await Promise.all(promises);
-    }
-    async triggers(triggerPromises) {
-        // keep changesets to use later
-        let changesets = await Promise.all(triggerPromises.map(async (promise) => {
-            if (Array.isArray(promise)) {
-                return await Promise.all(promise);
+        await Promise.all([
+            this.validateFields(builder, action),
+            this.validators(validators, action, builder),
+        ]);
+    }
+    async triggers(action, builder, triggers) {
+        await Promise.all(triggers.map(async (trigger) => {
+            let ret = await trigger.changeset(builder, action.getInput());
+            if (Array.isArray(ret)) {
+                ret = await Promise.all(ret);
             }
-            return await promise;
-        }));
-        changesets.forEach((c) => {
-            if (Array.isArray(c)) {
-                for (const v of c) {
+            if (Array.isArray(ret)) {
+                for (const v of ret) {
                     if (typeof v === "object") {
                         this.changesets.push(v);
                     }
                 }
             }
-            else if (c) {
-                this.changesets.push(c);
+            else if (ret) {
+                this.changesets.push(ret);
             }
-        });
+        }));
     }
     async validators(validators, action, builder) {
         let promises = [];

package/core/convert.d.ts

@@ -10,3 +10,5 @@ export declare function convertBoolList(val: any): boolean[];
 export declare function convertNullableBoolList(val: any): boolean[] | null;
 export declare function convertJSON(val: any): any;
 export declare function convertNullableJSON(val: any): any | null;
+export declare function convertJSONList(val: any): boolean[];
+export declare function convertNullableJSONList(val: any): any[] | null;

package/core/convert.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertNullableJSON = exports.convertJSON = exports.convertNullableBoolList = exports.convertBoolList = exports.convertNullableDateList = exports.convertDateList = exports.convertNullableList = exports.convertList = exports.convertNullableBool = exports.convertBool = exports.convertNullableDate = exports.convertDate = void 0;
+exports.convertNullableJSONList = exports.convertJSONList = exports.convertNullableJSON = exports.convertJSON = exports.convertNullableBoolList = exports.convertBoolList = exports.convertNullableDateList = exports.convertDateList = exports.convertNullableList = exports.convertList = exports.convertNullableBool = exports.convertBool = exports.convertNullableDate = exports.convertDate = void 0;
 const luxon_1 = require("luxon");
 // these are needed to deal with SQLite having different types stored in the db vs the representation
 // gotten back from the db/needed in ent land
@@ -95,3 +95,11 @@ function convertNullableJSON(val) {
     return convertJSON(val);
 }
 exports.convertNullableJSON = convertNullableJSON;
+function convertJSONList(val) {
+    return convertList(val, convertJSON);
+}
+exports.convertJSONList = convertJSONList;
+function convertNullableJSONList(val) {
+    return convertNullableList(val, convertJSON);
+}
+exports.convertNullableJSONList = convertNullableJSONList;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.0.18",
+  "version": "0.0.22",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/schema/field.d.ts

@@ -101,8 +101,12 @@ export declare class DateField extends BaseField implements Field {
     format(val: any): any;
 }
 export declare function DateType(options: FieldOptions): DateField;
+declare type EnumMap = {
+    [key: string]: string;
+};
 export interface EnumOptions extends FieldOptions {
     values?: string[];
+    map?: EnumMap;
     tsType?: string;
     graphQLType?: string;
     createEnumType?: boolean;
@@ -110,6 +114,7 @@ export interface EnumOptions extends FieldOptions {
 export declare class EnumField extends BaseField implements Field {
     type: Type;
     private values?;
+    private map?;
     constructor(options: EnumOptions);
     convertForGQL(value: string): string;
     valid(val: any): boolean;
@@ -119,13 +124,22 @@ export declare function EnumType(options: EnumOptions): EnumField;
 export declare class ListField extends BaseField {
     private field;
     type: Type;
+    private validators;
     constructor(field: Field, options: FieldOptions);
+    validate(validator: (val: any[]) => boolean): this;
     valid(val: any): boolean;
+    private postgresVal;
     format(val: any): any;
+    minLen(l: number): this;
+    maxLen(l: number): this;
+    length(l: number): this;
+    range(start: any, stop: any): this;
 }
 export declare function StringListType(options: StringOptions): ListField;
 export declare function IntListType(options: FieldOptions): ListField;
+export declare function IntegerListType(options: FieldOptions): ListField;
 export declare function FloatListType(options: FieldOptions): ListField;
+export declare function BigIntegerListType(options: FieldOptions): ListField;
 export declare function BooleanListType(options: FieldOptions): ListField;
 export declare function TimestampListType(options: TimestampOptions): ListField;
 export declare function TimestamptzListType(options: TimestampOptions): ListField;
@@ -134,3 +148,4 @@ export declare function TimetzListType(options: TimeOptions): ListField;
 export declare function DateListType(options: FieldOptions): ListField;
 export declare function EnumListType(options: EnumOptions): ListField;
 export declare function UUIDListType(options: FieldOptions): ListField;
+export {};

package/schema/field.js

@@ -19,7 +19,7 @@ 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.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.BigIntegerType = exports.BigIntegerField = exports.IntegerType = exports.IntegerField = exports.UUIDType = exports.UUIDField = exports.BaseField = void 0;
+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 schema_1 = require("./schema");
 const snake_case_1 = require("snake-case");
 const luxon_1 = require("luxon");
@@ -64,6 +64,7 @@ class UUIDField extends BaseField {
                         values: polymorphic.types,
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
+                        nullable: options.nullable,
                     }),
                 ];
             }
@@ -74,6 +75,7 @@ class UUIDField extends BaseField {
                         name,
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
+                        nullable: options.nullable,
                     }),
                 ];
             }
@@ -382,20 +384,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");
@@ -408,30 +423,55 @@ class EnumField extends BaseField {
             }
         }
         this.values = options.values;
+        this.map = options.map;
     }
+    // TODO need to update this for map
     convertForGQL(value) {
         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
@@ -448,6 +488,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`);
         }
@@ -457,10 +498,19 @@ class ListField extends BaseField {
         };
         Object.assign(this, options);
     }
+    validate(validator) {
+        this.validators.push(validator);
+        return this;
+    }
     valid(val) {
         if (!Array.isArray(val)) {
             return false;
         }
+        for (const validator of this.validators) {
+            if (!validator(val)) {
+                return false;
+            }
+        }
         if (!this.field.valid) {
             return true;
         }
@@ -471,22 +521,66 @@ class ListField extends BaseField {
         }
         return true;
     }
+    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;
@@ -498,10 +592,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);
 }

package/schema/json_field.d.ts

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONBType = exports.JSONType = exports.JSONField = void 0;
+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 {
@@ -38,3 +38,11 @@ function JSONBType(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

@@ -83,12 +83,16 @@ 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 {