@snowtop/ent 0.1.0-alpha9 → 0.1.0-alpha90

package/parse_schema/parse.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSchema = void 0;
-function processFields(src, patternName) {
+async function processFields(src, patternName) {
     const ret = [];
     let m = {};
     if (Array.isArray(src)) {
@@ -36,6 +36,19 @@ function processFields(src, patternName) {
         else {
             delete f.polymorphic;
         }
+        if (field.private) {
+            // convert boolean into object
+            // we keep boolean as an option to keep API simple
+            if (typeof field.private === "boolean") {
+                f.private = {};
+            }
+            else {
+                f.private = field.private;
+            }
+        }
+        else {
+            delete f.private;
+        }
         // convert string to object to make API consumed by go simple
         if (f.fieldEdge && f.fieldEdge.inverseEdge) {
             if (typeof f.fieldEdge.inverseEdge === "string") {
@@ -47,26 +60,48 @@ function processFields(src, patternName) {
         if (patternName) {
             f.patternName = patternName;
         }
+        if (field.serverDefault !== undefined) {
+            f.serverDefault = await transformServerDefault(name, field, field.serverDefault);
+        }
         transformType(field.type);
         if (field.getDerivedFields) {
-            f.derivedFields = processFields(field.getDerivedFields(name));
+            f.derivedFields = await processFields(field.getDerivedFields(name));
         }
         if (field.type.subFields) {
-            f.type.subFields = processFields(field.type.subFields);
+            f.type.subFields = await processFields(field.type.subFields);
         }
         if (field.type.unionFields) {
-            f.type.unionFields = processFields(field.type.unionFields);
+            f.type.unionFields = await 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);
+            f.type.listElemType.subFields = await processFields(field.type.listElemType.subFields);
         }
         ret.push(f);
     }
     return ret;
 }
+async function transformServerDefault(name, f, value) {
+    if (f.valid) {
+        if (!(await f.valid(value))) {
+            throw new Error(`invalid value ${value} passed to field ${name}`);
+        }
+    }
+    if (f.format) {
+        value = await f.format(value);
+    }
+    switch (typeof value) {
+        case "boolean":
+        case "number":
+        case "bigint":
+        case "string":
+            return `${value}`;
+        default:
+            throw new Error(`invalid value ${value} passed to field ${name}`);
+    }
+}
 function transformImportType(typ) {
     if (!typ.importType) {
         return;
@@ -108,12 +143,12 @@ function processEdgeGroups(processedSchema, edgeGroups) {
         processedSchema.assocEdgeGroups.push(group2);
     }
 }
-function processPattern(patterns, pattern, processedSchema) {
+async function processPattern(patterns, pattern, processedSchema) {
     let ret = {
         ...pattern,
     };
     const name = pattern.name;
-    const fields = processFields(pattern.fields, pattern.name);
+    const fields = await processFields(pattern.fields, pattern.name);
     processedSchema.fields.push(...fields);
     if (pattern.edges) {
         const edges = processEdges(pattern.edges, pattern.name);
@@ -130,6 +165,7 @@ function processPattern(patterns, pattern, processedSchema) {
             name: pattern.name,
             assocEdges: edges,
             fields: fields,
+            disableMixin: pattern.disableMixin,
         };
     }
     else {
@@ -171,9 +207,13 @@ function processAction(action) {
     ret.actionOnlyFields = actionOnlyFields;
     return ret;
 }
-function parseSchema(potentialSchemas) {
+async function parseSchema(potentialSchemas, globalSchema) {
     let schemas = {};
     let patterns = {};
+    let parsedGlobalSchema;
+    if (globalSchema) {
+        parsedGlobalSchema = await parseGlobalSchema(globalSchema);
+    }
     for (const key in potentialSchemas) {
         const value = potentialSchemas[key];
         let schema;
@@ -202,9 +242,11 @@ 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) {
-                const ret = processPattern(patterns, pattern, processedSchema);
+                const ret = await 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`);
@@ -219,8 +261,9 @@ function parseSchema(potentialSchemas) {
                 }
             }
         }
-        const fields = processFields(schema.fields);
+        const fields = await processFields(schema.fields);
         processedSchema.fields.push(...fields);
+        processedSchema.patternNames = patternNames;
         if (schema.edges) {
             const edges = processEdges(schema.edges);
             processedSchema.assocEdges.push(...edges);
@@ -230,6 +273,22 @@ function parseSchema(potentialSchemas) {
         }
         schemas[key] = processedSchema;
     }
-    return { schemas, patterns };
+    return { schemas, patterns, globalSchema: parsedGlobalSchema };
 }
 exports.parseSchema = parseSchema;
+async function parseGlobalSchema(s) {
+    const ret = {
+        globalEdges: [],
+        extraEdgeFields: [],
+        initForEdges: !!s.extraEdgeFields ||
+            s.transformEdgeRead !== undefined ||
+            s.transformEdgeWrite !== undefined,
+    };
+    if (s.extraEdgeFields) {
+        ret.extraEdgeFields = await processFields(s.extraEdgeFields);
+    }
+    if (s.edges) {
+        ret.globalEdges = processEdges(s.edges);
+    }
+    return ret;
+}

package/schema/base_schema.js

@@ -66,6 +66,7 @@ let nodeFieldsWithTZ = {
 exports.Node = {
     name: "node",
     fields: nodeFields,
+    disableMixin: true,
 };
 // Ent schema. has Node Pattern by default.
 // exists just to have less typing and easier for clients to implement
@@ -95,6 +96,7 @@ class EntSchemaWithTZ {
                 // default schema added
                 name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
+                disableMixin: true,
             },
         ];
         this.fields = cfg.fields;
@@ -131,6 +133,7 @@ class BaseEntSchemaWithTZ {
                 // default schema added
                 name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
+                disableMixin: true,
             },
         ];
     }

package/schema/field.d.ts

@@ -44,7 +44,7 @@ export declare function IntegerType(options?: IntegerOptions): IntegerField;
 export declare class BigIntegerField extends BaseField implements Field {
     type: Type;
 }
-export declare function BigIntegerType(options: FieldOptions): BigIntegerField;
+export declare function BigIntegerType(options?: FieldOptions): BigIntegerField;
 export declare class FloatField extends BaseField implements Field {
     type: Type;
 }
@@ -118,31 +118,66 @@ export declare class DateField extends BaseField implements Field {
     format(val: any): any;
 }
 export declare function DateType(options?: FieldOptions): DateField;
-declare type EnumMap = {
+declare type StringEnumMap = {
     [key: string]: string;
 };
+/**
+ * @deprecated use StringEnumOptions
+ */
 export interface EnumOptions extends FieldOptions {
     values?: string[];
-    map?: EnumMap;
+    map?: StringEnumMap;
     tsType?: string;
     graphQLType?: string;
     createEnumType?: boolean;
 }
+/**
+ * @deprecated Use StringEnumField
+ */
 export declare class EnumField extends BaseField implements Field {
     type: Type;
     private values?;
     private map?;
-    constructor(options: EnumOptions);
+    constructor(options: StringEnumOptions);
     convertForGQL(value: string): string;
     valid(val: any): boolean;
     format(val: any): any;
 }
-export declare function EnumType(options: EnumOptions): EnumField;
+export declare class StringEnumField extends EnumField {
+}
+export interface PolymorphicStringEnumOptions extends EnumOptions {
+    parentFieldToValidate: string;
+}
+export interface StringEnumOptions extends EnumOptions {
+}
+export declare function EnumType(options: StringEnumOptions): EnumField;
+declare type IntEnumMap = {
+    [key: string]: number;
+};
+export interface IntegerEnumOptions extends FieldOptions {
+    map: IntEnumMap;
+    deprecated?: IntEnumMap;
+    tsType?: string;
+    graphQLType?: string;
+}
+export declare class IntegerEnumField extends BaseField implements Field {
+    type: Type;
+    private map;
+    constructor(options: IntegerEnumOptions);
+    valid(val: any): boolean;
+    format(val: any): any;
+}
+export declare function IntegerEnumType(options: IntegerEnumOptions): IntegerEnumField;
+interface ListOptions extends FieldOptions {
+    disableJSONStringify?: boolean;
+}
 export declare class ListField extends BaseField {
     private field;
+    private options?;
     type: Type;
     private validators;
-    constructor(field: Field, options?: FieldOptions);
+    constructor(field: Field, options?: ListOptions | undefined);
+    __getElemField(): Field;
     validate(validator: (val: any[]) => boolean): this;
     valid(val: any): Promise<boolean>;
     private postgresVal;
@@ -153,7 +188,7 @@ export declare class ListField extends BaseField {
     range(start: any, stop: any): this;
 }
 export declare function StringListType(options?: StringOptions): ListField;
-export declare function IntListType(options: FieldOptions): 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;
@@ -163,6 +198,7 @@ export declare function TimestamptzListType(options?: TimestampOptions): ListFie
 export declare function TimeListType(options?: TimeOptions): ListField;
 export declare function TimetzListType(options: TimeOptions): ListField;
 export declare function DateListType(options?: FieldOptions): ListField;
-export declare function EnumListType(options: EnumOptions): ListField;
+export declare function EnumListType(options: StringEnumOptions): ListField;
+export declare function IntegerEnumListType(options: IntegerEnumOptions): ListField;
 export declare function UUIDListType(options?: FieldOptions): ListField;
 export {};

package/schema/field.js

@@ -19,12 +19,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UUIDListType = exports.EnumListType = exports.DateListType = exports.TimetzListType = exports.TimeListType = exports.TimestamptzListType = exports.TimestampListType = exports.BooleanListType = exports.BigIntegerListType = exports.FloatListType = exports.IntegerListType = exports.IntListType = exports.StringListType = exports.ListField = exports.EnumType = exports.EnumField = exports.DateType = exports.DateField = exports.TimetzType = exports.TimeType = exports.TimeField = exports.leftPad = exports.TimestamptzType = exports.TimestampType = exports.TimestampField = exports.StringType = exports.StringField = exports.BooleanType = exports.BooleanField = exports.FloatType = exports.FloatField = exports.BigIntegerType = exports.BigIntegerField = exports.IntegerType = exports.IntegerField = exports.UUIDType = exports.UUIDField = exports.BaseField = void 0;
+exports.UUIDListType = exports.IntegerEnumListType = exports.EnumListType = exports.DateListType = exports.TimetzListType = exports.TimeListType = exports.TimestamptzListType = exports.TimestampListType = exports.BooleanListType = exports.BigIntegerListType = exports.FloatListType = exports.IntegerListType = exports.IntListType = exports.StringListType = exports.ListField = exports.IntegerEnumType = exports.IntegerEnumField = exports.EnumType = exports.StringEnumField = exports.EnumField = exports.DateType = exports.DateField = exports.TimetzType = exports.TimeType = exports.TimeField = exports.leftPad = exports.TimestamptzType = exports.TimestampType = exports.TimestampField = exports.StringType = exports.StringField = exports.BooleanType = exports.BooleanField = exports.FloatType = exports.FloatField = exports.BigIntegerType = exports.BigIntegerField = exports.IntegerType = exports.IntegerField = exports.UUIDType = exports.UUIDField = exports.BaseField = void 0;
 const luxon_1 = require("luxon");
 const snake_case_1 = require("snake-case");
+const util_1 = require("util");
+const uuid_1 = require("uuid");
+const base_1 = require("../core/base");
 const db_1 = __importStar(require("../core/db"));
 const schema_1 = require("./schema");
-const util_1 = require("util");
 class BaseField {
     logValue(val) {
         if (this.sensitive) {
@@ -67,21 +69,22 @@ class UUIDField extends BaseField {
             if (typeof polymorphic === "object" && polymorphic.types) {
                 // an enum with types validated here
                 return {
-                    [name]: EnumType({
+                    [name]: PolymorphicStringEnumType({
                         values: polymorphic.types,
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
                         nullable: this.options?.nullable,
+                        parentFieldToValidate: fieldName,
                     }),
                 };
             }
             else {
-                // just a string field...
                 return {
-                    [name]: StringType({
+                    [name]: PolymorphicStringType({
                         hideFromGraphQL: true,
                         derivedWhenEmbedded: true,
                         nullable: this.options?.nullable,
+                        parentFieldToValidate: fieldName,
                     }),
                 };
             }
@@ -92,6 +95,9 @@ class UUIDField extends BaseField {
         return val.placeholderID !== undefined;
     }
     async valid(val) {
+        if (typeof val === "string" && !(0, uuid_1.validate)(val)) {
+            return false;
+        }
         if (!this.options?.fieldEdge?.enforceSchema) {
             return true;
         }
@@ -307,6 +313,33 @@ class StringField extends BaseField {
     }
 }
 exports.StringField = StringField;
+function validatePolymorphicTypeWithFullData(val, b, field) {
+    const input = b.getInput();
+    const inputKey = b.orchestrator.__getOptions().fieldInfo[field].inputKey;
+    const v = input[inputKey];
+    if (val === null) {
+        // if this is being set to null, ok if v is also null
+        return v === null;
+    }
+    // if this is not being set, ok if v is not being set
+    if (val === undefined && b.operation === base_1.WriteOperation.Insert) {
+        return v === undefined;
+    }
+    return true;
+}
+class PolymorphicStringField extends StringField {
+    constructor(opts) {
+        super(opts);
+        this.opts = opts;
+    }
+    validateWithFullData(val, b) {
+        return validatePolymorphicTypeWithFullData(val, b, this.opts.parentFieldToValidate);
+    }
+}
+function PolymorphicStringType(opts) {
+    let result = new PolymorphicStringField(opts);
+    return Object.assign(result, opts);
+}
 function StringType(options) {
     let result = new StringField(options);
     const options2 = { ...options };
@@ -426,9 +459,10 @@ class DateField extends BaseField {
         this.type = { dbType: schema_1.DBType.Date };
     }
     format(val) {
-        if (!(val instanceof Date)) {
+        if (typeof val === "string") {
             return val;
         }
+        val = new Date(val);
         let yy = (0, exports.leftPad)(val.getFullYear());
         // lol this API
         // for some reason this is 0-index
@@ -444,6 +478,9 @@ function DateType(options) {
     return Object.assign(result, options);
 }
 exports.DateType = DateType;
+/**
+ * @deprecated Use StringEnumField
+ */
 class EnumField extends BaseField {
     constructor(options) {
         super();
@@ -546,15 +583,75 @@ class EnumField extends BaseField {
     }
 }
 exports.EnumField = EnumField;
+class StringEnumField extends EnumField {
+}
+exports.StringEnumField = StringEnumField;
+class PolymorphicStringEnumField extends StringEnumField {
+    constructor(opts) {
+        super(opts);
+        this.opts = opts;
+    }
+    validateWithFullData(val, b) {
+        return validatePolymorphicTypeWithFullData(val, b, this.opts.parentFieldToValidate);
+    }
+}
+function PolymorphicStringEnumType(options) {
+    let result = new PolymorphicStringEnumField(options);
+    return Object.assign(result, options);
+}
 function EnumType(options) {
-    let result = new EnumField(options);
+    let result = new StringEnumField(options);
     return Object.assign(result, options);
 }
 exports.EnumType = EnumType;
+class IntegerEnumField extends BaseField {
+    constructor(options) {
+        super();
+        this.type = {
+            dbType: schema_1.DBType.IntEnum,
+            intEnumMap: options.map,
+            type: options.tsType,
+            graphQLType: options.graphQLType,
+            deprecatedIntEnumMap: options.deprecated,
+        };
+        let count = 0;
+        for (const k in options.map) {
+            count++;
+            break;
+        }
+        if (!count) {
+            throw new Error("need at least one entry in enum map");
+        }
+        if (options.foreignKey) {
+            throw new Error(`foreignKey on intEnum not supported`);
+        }
+        this.map = options.map;
+    }
+    valid(val) {
+        // lookup table enum and indicated via presence of foreignKey
+        for (const k in this.map) {
+            const v = this.map[k];
+            if (v === val || v === parseInt(val)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    format(val) {
+        return parseInt(val);
+    }
+}
+exports.IntegerEnumField = IntegerEnumField;
+function IntegerEnumType(options) {
+    let result = new IntegerEnumField(options);
+    return Object.assign(result, options);
+}
+exports.IntegerEnumType = IntegerEnumType;
 class ListField extends BaseField {
     constructor(field, options) {
         super();
         this.field = field;
+        this.options = options;
         this.validators = [];
         if (field.type.dbType === schema_1.DBType.List) {
             throw new Error(`nested lists not currently supported`);
@@ -565,6 +662,9 @@ class ListField extends BaseField {
         };
         Object.assign(this, options);
     }
+    __getElemField() {
+        return this.field;
+    }
     validate(validator) {
         this.validators.push(validator);
         return this;
@@ -592,7 +692,12 @@ class ListField extends BaseField {
         return result;
     }
     postgresVal(val, jsonType) {
-        if (!jsonType) {
+        if (!jsonType && val === "") {
+            // support empty strings in list
+            val = '"' + val + '"';
+            return val;
+        }
+        if (this.options?.disableJSONStringify) {
             return val;
         }
         return JSON.stringify(val);
@@ -720,7 +825,18 @@ function EnumListType(options) {
     return new ListField(EnumType(options), options);
 }
 exports.EnumListType = EnumListType;
+function IntegerEnumListType(options) {
+    // not all of these will make sense in a list...
+    // can make it work eventually but involves work we're not currently trying to do
+    // developer can try to work around it by calling below on their own.
+    // unclear what the behavior is
+    return new ListField(IntegerEnumType(options), options);
+}
+exports.IntegerEnumListType = IntegerEnumListType;
 function UUIDListType(options) {
-    return new ListField(UUIDType(options), options);
+    return new ListField(UUIDType(options), {
+        ...options,
+        disableJSONStringify: true,
+    });
 }
 exports.UUIDListType = UUIDListType;

package/schema/index.d.ts

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

package/schema/json_field.d.ts

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

package/schema/json_field.js

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