@snowtop/ent 0.0.35 → 0.1.0-alpha3

package/schema/field.d.ts

@@ -1,4 +1,4 @@
-import { Field, FieldOptions, ForeignKey, PolymorphicOptions, Type } from "./schema";
+import { Field, FieldMap, FieldOptions, ForeignKey, PolymorphicOptions, Type } from "./schema";
 export declare abstract class BaseField {
     name: string;
     nullable?: boolean;
@@ -12,18 +12,18 @@ export declare abstract class BaseField {
     index?: boolean;
     foreignKey?: ForeignKey;
     polymorphic?: boolean | PolymorphicOptions;
-    derivedFields?: Field[];
     derivedWhenEmbedded?: boolean;
     logValue(val: any): any;
 }
 export declare class UUIDField extends BaseField implements Field {
-    private options;
+    private options?;
     type: Type;
-    constructor(options: FieldOptions);
+    constructor(options?: FieldOptions | undefined);
+    getDerivedFields(fieldName: string): FieldMap;
     private isBuilder;
     valid(val: any): Promise<boolean>;
 }
-export declare function UUIDType(options: FieldOptions): UUIDField;
+export declare function UUIDType(options?: FieldOptions): UUIDField;
 export interface IntegerOptions extends FieldOptions {
     min?: number;
     max?: number;
@@ -40,7 +40,7 @@ export declare class IntegerField extends BaseField implements Field {
     valid(val: any): boolean;
     validate(validator: (str: number) => boolean): this;
 }
-export declare function IntegerType(options: IntegerOptions): IntegerField;
+export declare function IntegerType(options?: IntegerOptions): IntegerField;
 export declare class BigIntegerField extends BaseField implements Field {
     type: Type;
 }
@@ -48,11 +48,11 @@ export declare function BigIntegerType(options: FieldOptions): BigIntegerField;
 export declare class FloatField extends BaseField implements Field {
     type: Type;
 }
-export declare function FloatType(options: FieldOptions): FloatField;
+export declare function FloatType(options?: FieldOptions): FloatField;
 export declare class BooleanField extends BaseField implements Field {
     type: Type;
 }
-export declare function BooleanType(options: FieldOptions): BooleanField;
+export declare function BooleanType(options?: FieldOptions): BooleanField;
 export interface StringOptions extends FieldOptions {
     minLen?: number;
     maxLen?: number;
@@ -88,7 +88,7 @@ export declare class StringField extends BaseField implements Field {
     trimLeft(): this;
     trimRight(): this;
 }
-export declare function StringType(options: StringOptions): StringField;
+export declare function StringType(options?: StringOptions): StringField;
 export interface TimestampOptions extends FieldOptions {
     withTimezone?: boolean;
 }
@@ -98,8 +98,8 @@ export declare class TimestampField extends BaseField implements Field {
     constructor(options: TimestampOptions);
     format(val: Date): any;
 }
-export declare function TimestampType(options: TimestampOptions): TimestampField;
-export declare function TimestamptzType(options: FieldOptions): TimestampField;
+export declare function TimestampType(options?: TimestampOptions): TimestampField;
+export declare function TimestamptzType(options?: FieldOptions): TimestampField;
 export interface TimeOptions extends FieldOptions {
     withTimezone?: boolean;
     precision?: number;
@@ -108,16 +108,16 @@ export declare const leftPad: (val: number) => string;
 export declare class TimeField extends BaseField implements Field {
     type: Type;
     withTimezone?: boolean;
-    constructor(options: TimeOptions);
+    constructor(options?: TimeOptions);
     format(val: any): any;
 }
-export declare function TimeType(options: TimeOptions): TimeField;
-export declare function TimetzType(options: FieldOptions): TimeField;
+export declare function TimeType(options?: TimeOptions): TimeField;
+export declare function TimetzType(options?: FieldOptions): TimeField;
 export declare class DateField extends BaseField implements Field {
     type: Type;
     format(val: any): any;
 }
-export declare function DateType(options: FieldOptions): DateField;
+export declare function DateType(options?: FieldOptions): DateField;
 declare type EnumMap = {
     [key: string]: string;
 };
@@ -142,27 +142,27 @@ export declare class ListField extends BaseField {
     private field;
     type: Type;
     private validators;
-    constructor(field: Field, options: FieldOptions);
+    constructor(field: Field, options?: FieldOptions);
     validate(validator: (val: any[]) => boolean): this;
     valid(val: any): Promise<boolean>;
     private postgresVal;
-    format(val: any): any;
+    format(val: any, nested?: boolean): any;
     minLen(l: number): this;
     maxLen(l: number): this;
     length(l: number): this;
     range(start: any, stop: any): this;
 }
-export declare function StringListType(options: StringOptions): ListField;
+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 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 BooleanListType(options?: FieldOptions): ListField;
 export declare function TimestampListType(options: TimestampOptions): ListField;
-export declare function TimestamptzListType(options: TimestampOptions): ListField;
-export declare function TimeListType(options: TimeOptions): ListField;
+export declare function TimestamptzListType(options?: TimestampOptions): ListField;
+export declare function TimeListType(options?: TimeOptions): ListField;
 export declare function TimetzListType(options: TimeOptions): ListField;
-export declare function DateListType(options: FieldOptions): ListField;
+export declare function DateListType(options?: FieldOptions): ListField;
 export declare function EnumListType(options: EnumOptions): ListField;
-export declare function UUIDListType(options: FieldOptions): ListField;
+export declare function UUIDListType(options?: FieldOptions): ListField;
 export {};

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

package/schema/index.js

@@ -26,3 +26,5 @@ Object.defineProperty(exports, "BaseEntSchema", { enumerable: true, get: functio
 Object.defineProperty(exports, "BaseEntSchemaWithTZ", { enumerable: true, get: function () { return base_schema_1.BaseEntSchemaWithTZ; } });
 __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,10 @@
 import { Data, Ent, LoaderInfo } from "../core/base";
 import { Builder } from "../action/action";
+export declare type FieldMap = {
+    [key: string]: Field;
+};
 export default interface Schema {
-    fields: Field[];
+    fields: FieldMap | Field[];
     tableName?: string;
     patterns?: Pattern[];
     edges?: Edge[];
@@ -57,7 +60,7 @@ export interface AssocEdgeGroup {
 export declare type Edge = AssocEdge;
 export interface Pattern {
     name: string;
-    fields: Field[];
+    fields: FieldMap | Field[];
     edges?: Edge[];
 }
 export declare enum DBType {
@@ -94,6 +97,8 @@ export interface Type {
     values?: string[];
     enumMap?: EnumMap;
     importType?: ImportType;
+    subFields?: FieldMap;
+    unionFields?: FieldMap;
 }
 export interface ForeignKey {
     schema: string;
@@ -117,7 +122,6 @@ export interface FieldEdge {
     disableBuilderType?: boolean;
 }
 export interface FieldOptions {
-    name: string;
     nullable?: boolean;
     storageKey?: string;
     serverDefault?: any;
@@ -136,7 +140,8 @@ export interface FieldOptions {
     defaultValueOnEdit?(builder: Builder<Ent>, input: Data): any;
     derivedWhenEmbedded?: boolean;
     polymorphic?: boolean | PolymorphicOptions;
-    derivedFields?: Field[];
+    getDerivedFields?(name: string): FieldMap;
+    [x: string]: any;
 }
 export interface PolymorphicOptions {
     types?: string[];
@@ -146,7 +151,7 @@ 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 {

package/schema/schema.js

@@ -37,12 +37,25 @@ function getFields(value) {
         schema = new 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);
             }
-            m.set(field.name, field);
+            return;
+        }
+        for (const name in fields) {
+            const field = fields[name];
+            if (field.getDerivedFields !== undefined) {
+                addFields(field.getDerivedFields(name));
+            }
+            m.set(name, field);
         }
     }
     let m = new Map();

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;

package/schema/struct_field.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructListType = exports.StructType = exports.StructField = void 0;
+const field_1 = require("./field");
+const schema_1 = require("./schema");
+const camel_case_1 = require("camel-case");
+class StructField extends field_1.BaseField {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.type = {
+            dbType: schema_1.DBType.JSONB,
+        };
+        this.type.subFields = options.fields;
+        this.type.type = options.tsType;
+        this.type.graphQLType = options.graphQLType || options.tsType;
+        if (options.jsonNotJSONB) {
+            this.type.dbType = schema_1.DBType.JSON;
+        }
+    }
+    // right now, we store things in the db in lowerCase format
+    // this will lead to issues if field changes.
+    // TODO: use storageKey and convert back...
+    format(obj, nested) {
+        if (!(obj instanceof Object)) {
+            throw new Error("valid was not called");
+        }
+        let ret = {};
+        for (const k in this.options.fields) {
+            // TODO more #510
+            let dbKey = (0, camel_case_1.camelCase)(k);
+            let val = obj[dbKey];
+            // for tests with snake_case
+            if (val === undefined && obj[k] !== undefined) {
+                val = obj[k];
+                dbKey = k;
+            }
+            if (val === undefined) {
+                continue;
+            }
+            const field = this.options.fields[k];
+            if (field.format) {
+                // indicate nested so this isn't JSON stringified
+                ret[dbKey] = field.format(val, true);
+            }
+            else {
+                ret[dbKey] = val;
+            }
+        }
+        // don't json.stringify if nested
+        if (nested) {
+            return ret;
+        }
+        return JSON.stringify(ret);
+    }
+    async valid(obj) {
+        if (!(obj instanceof Object)) {
+            return false;
+        }
+        let promises = [];
+        // TODO probably need to support optional fields...
+        let valid = true;
+        for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            // TODO more #510
+            let dbKey = (0, camel_case_1.camelCase)(k);
+            let val = obj[dbKey];
+            // for tests with snake_case
+            if (val === undefined && obj[k] !== undefined) {
+                val = obj[k];
+                dbKey = k;
+            }
+            if (val === undefined || val === null) {
+                // nullable, nothing to do here
+                if (field.nullable) {
+                    continue;
+                }
+                valid = false;
+                break;
+            }
+            if (!field.valid) {
+                continue;
+            }
+            promises.push(field.valid(val));
+        }
+        if (!valid) {
+            return valid;
+        }
+        const ret = await Promise.all(promises);
+        return ret.every((v) => v);
+    }
+}
+exports.StructField = StructField;
+function StructType(options) {
+    let result = new StructField(options);
+    return Object.assign(result, options);
+}
+exports.StructType = StructType;
+function StructListType(options) {
+    return new field_1.ListField(StructType(options), options);
+}
+exports.StructListType = StructListType;

package/schema/union_field.d.ts

@@ -0,0 +1,22 @@
+import { StructField } from "./struct_field";
+import { FieldOptions, Type } from "./schema";
+import { BaseField, ListField } from "./field";
+export declare type StructMap = {
+    [key: string]: StructField;
+};
+export interface UnionOptions extends FieldOptions {
+    tsType: string;
+    fields: StructMap;
+    graphQLType?: string;
+    jsonNotJSONB?: boolean;
+}
+export declare class UnionField extends BaseField implements FieldOptions {
+    private options;
+    type: Type;
+    m: Map<Object, string>;
+    constructor(options: UnionOptions);
+    format(obj: any, nested?: boolean): string | Object;
+    valid(obj: any): Promise<boolean>;
+}
+export declare function UnionType(options: UnionOptions): UnionField & UnionOptions;
+export declare function UnionListType(options: UnionOptions): ListField;

package/schema/union_field.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionListType = exports.UnionType = exports.UnionField = void 0;
+const schema_1 = require("./schema");
+const field_1 = require("./field");
+class UnionField extends field_1.BaseField {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.type = {
+            dbType: schema_1.DBType.JSONB,
+        };
+        this.m = new Map();
+        this.type.unionFields = options.fields;
+        this.type.type = options.tsType;
+        this.type.graphQLType = options.graphQLType || options.tsType;
+        // TODO should throw if not nested?
+        if (options.jsonNotJSONB) {
+            this.type.dbType = schema_1.DBType.JSON;
+        }
+    }
+    format(obj, nested) {
+        if (!(obj instanceof Object)) {
+            throw new Error("valid was not called");
+        }
+        for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            const fmt = field.format(obj, nested);
+            if (fmt !== "{}") {
+                return fmt;
+            }
+        }
+        // TODO need better logic here
+        // maybe add something ignored to the objec that indicates which key?
+        // or store in map
+        throw new Error(`couldn't format union`);
+    }
+    async valid(obj) {
+        if (!(obj instanceof Object)) {
+            return false;
+        }
+        let promises = [];
+        for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            promises.push(field.valid(obj));
+        }
+        const ret = await Promise.all(promises);
+        // only 1 should be valid
+        return ret.filter((v) => v).length === 1;
+    }
+}
+exports.UnionField = UnionField;
+function UnionType(options) {
+    let result = new UnionField(options);
+    return Object.assign(result, options);
+}
+exports.UnionType = UnionType;
+function UnionListType(options) {
+    return new field_1.ListField(UnionType(options), options);
+}
+exports.UnionListType = UnionListType;