@snowtop/ent 0.0.33 → 0.1.0-alpha2

package/schema/base_schema.js

@@ -3,17 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = void 0;
 const uuid_1 = require("uuid");
 const field_1 = require("./field");
-let tsFields = [
-    (0, field_1.TimestampType)({
-        name: "createdAt",
+let tsFields = {
+    createdAt: (0, field_1.TimestampType)({
         hideFromGraphQL: true,
         disableUserEditable: true,
         defaultValueOnCreate: () => {
             return new Date();
         },
     }),
-    (0, field_1.TimestampType)({
-        name: "updatedAt",
+    updatedAt: (0, field_1.TimestampType)({
         hideFromGraphQL: true,
         disableUserEditable: true,
         defaultValueOnCreate: () => {
@@ -23,25 +21,28 @@ let tsFields = [
             return new Date();
         },
     }),
-];
+};
 // Timestamps is a Pattern that adds a createdAt and updatedAt timestamp fields to the ent
 exports.Timestamps = {
     name: "timestamps",
     fields: tsFields,
 };
 let nodeField = (0, field_1.UUIDType)({
-    name: "ID",
     primaryKey: true,
     disableUserEditable: true,
     defaultValueOnCreate: () => {
         return (0, uuid_1.v4)();
     },
 });
-let nodeFields = [nodeField, ...tsFields];
-let nodeFieldsWithTZ = [
-    nodeField,
-    (0, field_1.TimestampType)({
-        name: "createdAt",
+let nodeFields = {
+    // inconsistent naming :(
+    ID: nodeField,
+    ...tsFields,
+};
+let nodeFieldsWithTZ = {
+    // inconsistent naming :(
+    ID: nodeField,
+    createdAt: (0, field_1.TimestampType)({
         hideFromGraphQL: true,
         disableUserEditable: true,
         defaultValueOnCreate: () => {
@@ -49,8 +50,7 @@ let nodeFieldsWithTZ = [
         },
         withTimezone: true,
     }),
-    (0, field_1.TimestampType)({
-        name: "updatedAt",
+    updatedAt: (0, field_1.TimestampType)({
         hideFromGraphQL: true,
         disableUserEditable: true,
         defaultValueOnCreate: () => {
@@ -61,7 +61,7 @@ let nodeFieldsWithTZ = [
         },
         withTimezone: true,
     }),
-];
+};
 // Node is a Pattern that adds 3 fields to the ent: (id, createdAt, and updatedAt timestamps)
 exports.Node = {
     name: "node",

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,7 +142,7 @@ 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;
@@ -152,17 +152,17 @@ export declare class ListField extends BaseField {
     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

@@ -22,7 +22,6 @@ 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;
 const luxon_1 = require("luxon");
 const snake_case_1 = require("snake-case");
-const camel_case_1 = require("camel-case");
 const db_1 = __importStar(require("../core/db"));
 const schema_1 = require("./schema");
 const util_1 = require("util");
@@ -41,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
@@ -61,53 +66,46 @@ 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.getLoaderOptions) {
-            throw new Error(`cannot enforceSchema if getLoaderOptions 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;
         }
-        // TODO #510 consistency.
-        const f = (0, camel_case_1.camelCase)(this.options.fieldEdge.schema);
-        const getLoaderOptions = this.options.fieldEdge.getLoaderOptions;
-        const loadRowOptions = getLoaderOptions(f);
-        if (!loadRowOptions) {
-            throw new Error(`couldn't get loaderOptions for ${f}`);
+        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 ent type of the builder and the ent type returned by the load constructor should match
-            return val.ent === loadRowOptions.ent;
+            // 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 loadRowOptions.loaderFactory.createLoader().load(val);
+        const row = await loaderInfo.loaderFactory.createLoader().load(val);
         return row !== null;
     }
 }
@@ -122,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);
     }
@@ -209,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;
@@ -350,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;
@@ -377,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,
             };
@@ -454,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) {

package/schema/index.d.ts

@@ -1,6 +1,6 @@
 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";

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, LoadEntOptions } from "../core/base";
+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 {
@@ -102,7 +105,7 @@ export interface ForeignKey {
     disableIndex?: boolean;
     disableBuilderType?: boolean;
 }
-declare type getLoaderOptionsFn = (type: any) => LoadEntOptions<Ent>;
+declare type getLoaderInfoFn = (type: string) => LoaderInfo;
 export interface InverseFieldEdge {
     name: string;
     edgeConstName?: string;
@@ -113,11 +116,10 @@ export interface FieldEdge {
     schema: string;
     inverseEdge?: string | InverseFieldEdge;
     enforceSchema?: boolean;
-    getLoaderOptions?: getLoaderOptionsFn;
+    getLoaderInfoFromSchema?: getLoaderInfoFn;
     disableBuilderType?: boolean;
 }
 export interface FieldOptions {
-    name: string;
     nullable?: boolean;
     storageKey?: string;
     serverDefault?: any;
@@ -136,7 +138,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[];
@@ -171,6 +174,7 @@ export interface ActionField {
     nullable?: boolean | NullableListOptions;
     list?: boolean;
     actionName?: string;
+    excludedFields?: string[];
 }
 export interface Action {
     operation: ActionOperation;

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/scripts/custom_compiler.js

@@ -25,9 +25,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const typescript_1 = __importDefault(require("typescript"));
 const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const json5_1 = __importDefault(require("json5"));
 const glob_1 = __importDefault(require("glob"));
+const compilerOptions_1 = require("../tsc/compilerOptions");
 // TODO this should probably be its own package but for now it's here
 class Compiler {
     constructor(sourceFiles, moduleSearchLocations) {
@@ -35,7 +34,7 @@ class Compiler {
         this.moduleSearchLocations = moduleSearchLocations;
         this.regexMap = new Map();
         this.resolvers = [];
-        this.options = this.readCompilerOptions();
+        this.options = (0, compilerOptions_1.readCompilerOptions)(".");
         if (this.options.paths) {
             for (let key in this.options.paths) {
                 if (key === "*") {
@@ -105,22 +104,6 @@ class Compiler {
         }
         return undefined;
     }
-    readCompilerOptions() {
-        let json = {};
-        try {
-            json = json5_1.default.parse(fs.readFileSync("./tsconfig.json", {
-                encoding: "utf8",
-            }));
-        }
-        catch (e) {
-            console.error("couldn't read tsconfig.json file");
-        }
-        let options = json["compilerOptions"] || {};
-        if (options.moduleResolution === "node") {
-            options.moduleResolution = typescript_1.default.ModuleResolutionKind.NodeJs;
-        }
-        return options;
-    }
     createCompilerHost() {
         return {
             getSourceFile: this.getSourceFile,

package/scripts/transform_schema.d.ts

@@ -0,0 +1 @@
+export {};