@snowtop/ent 0.1.0-alpha → 0.1.0-alpha1

package/action/orchestrator.js

@@ -309,7 +309,7 @@ class Orchestrator {
         for (const [fieldName, field] of schemaFields) {
             let value = editedFields.get(fieldName);
             let defaultValue = undefined;
-            let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
+            let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(fieldName);
             if (value === undefined) {
                 if (this.options.operation === action_1.WriteOperation.Insert) {
                     if (field.defaultToViewerOnCreate && field.defaultValueOnCreate) {
@@ -321,7 +321,7 @@ class Orchestrator {
                     if (field.defaultValueOnCreate) {
                         defaultValue = field.defaultValueOnCreate(builder, input);
                         if (defaultValue === undefined) {
-                            throw new Error(`defaultValueOnCreate() returned undefined for field ${field.name}`);
+                            throw new Error(`defaultValueOnCreate() returned undefined for field ${fieldName}`);
                         }
                     }
                 }
@@ -360,11 +360,11 @@ class Orchestrator {
         }
         return false;
     }
-    async transformFieldValue(field, dbKey, value) {
+    async transformFieldValue(fieldName, field, dbKey, value) {
         // now format and validate...
         if (value === null) {
             if (!field.nullable) {
-                throw new Error(`field ${field.name} set to null for non-nullable field`);
+                throw new Error(`field ${fieldName} set to null for non-nullable field`);
             }
         }
         else if (value === undefined) {
@@ -375,14 +375,14 @@ class Orchestrator {
                 // server default allowed
                 field.serverDefault === undefined &&
                 this.options.operation === action_1.WriteOperation.Insert) {
-                throw new Error(`required field ${field.name} not set`);
+                throw new Error(`required field ${fieldName} not set`);
             }
         }
         else if (this.isBuilder(value)) {
             if (field.valid) {
                 const valid = await Promise.resolve(field.valid(value));
                 if (!valid) {
-                    throw new Error(`invalid field ${field.name} with value ${value}`);
+                    throw new Error(`invalid field ${fieldName} with value ${value}`);
                 }
             }
             // keep track of dependencies to resolve
@@ -395,7 +395,7 @@ class Orchestrator {
                 // TODO this could be async. handle this better
                 const valid = await Promise.resolve(field.valid(value));
                 if (!valid) {
-                    throw new Error(`invalid field ${field.name} with value ${value}`);
+                    throw new Error(`invalid field ${fieldName} with value ${value}`);
                 }
             }
             if (field.format) {
@@ -420,8 +420,8 @@ class Orchestrator {
                 // null allowed
                 value = this.defaultFieldsByFieldName[fieldName];
             }
-            let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
-            value = await this.transformFieldValue(field, dbKey, value);
+            let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(fieldName);
+            value = await this.transformFieldValue(fieldName, field, dbKey, value);
             if (value !== undefined) {
                 data[dbKey] = value;
                 logValues[dbKey] = field.logValue(value);
@@ -433,10 +433,10 @@ class Orchestrator {
             for (const fieldName in this.defaultFieldsByFieldName) {
                 const defaultValue = this.defaultFieldsByFieldName[fieldName];
                 let field = schemaFields.get(fieldName);
-                let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(field.name);
+                let dbKey = field.storageKey || (0, snake_case_1.snakeCase)(fieldName);
                 // no value, let's just default
                 if (data[dbKey] === undefined) {
-                    const value = await this.transformFieldValue(field, dbKey, defaultValue);
+                    const value = await this.transformFieldValue(fieldName, field, dbKey, defaultValue);
                     data[dbKey] = value;
                     logValues[dbKey] = field.logValue(value);
                 }

package/imports/index.d.ts

@@ -11,7 +11,6 @@ interface classResult {
     file: file;
 }
 export declare function parseCustomImports(filePath: string, opts?: Options): PathResult;
-export declare function findTSConfigFile(filePath: string): string | null;
 export interface importInfo {
     name: string;
     importPath: string;

package/imports/index.js

@@ -22,12 +22,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findTSConfigFile = exports.parseCustomImports = void 0;
+exports.parseCustomImports = void 0;
 const glob_1 = __importDefault(require("glob"));
 const typescript_1 = __importDefault(require("typescript"));
-const json5_1 = __importDefault(require("json5"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const compilerOptions_1 = require("../tsc/compilerOptions");
 function getFiles(filePath, opts) {
     if (!path.isAbsolute(filePath)) {
         throw new Error("absolute file path required");
@@ -44,7 +44,7 @@ function getFiles(filePath, opts) {
 }
 function parseCustomImports(filePath, opts) {
     const files = getFiles(filePath, opts);
-    const options = readCompilerOptions(filePath);
+    const options = (0, compilerOptions_1.readCompilerOptions)(filePath);
     let classMap = new Map();
     files.forEach((file) => {
         const sourceFile = typescript_1.default.createSourceFile(file, fs.readFileSync(file).toString(), options.target || typescript_1.default.ScriptTarget.ES2015);
@@ -77,39 +77,6 @@ function parseCustomImports(filePath, opts) {
     };
 }
 exports.parseCustomImports = parseCustomImports;
-function findTSConfigFile(filePath) {
-    while (filePath != "/") {
-        let configPath = `${filePath}/tsconfig.json`;
-        if (fs.existsSync(configPath)) {
-            return configPath;
-        }
-        filePath = path.join(filePath, "..");
-    }
-    return null;
-}
-exports.findTSConfigFile = findTSConfigFile;
-// inspiration taken from compiler.ts
-function readCompilerOptions(filePath) {
-    let configPath = findTSConfigFile(filePath);
-    if (!configPath) {
-        return {};
-    }
-    let json = {};
-    try {
-        json = json5_1.default.parse(fs.readFileSync(configPath, {
-            encoding: "utf8",
-        }));
-    }
-    catch (e) {
-        console.error("couldn't read tsconfig.json file");
-        return {};
-    }
-    let options = json["compilerOptions"] || {};
-    if (options.moduleResolution === "node") {
-        options.moduleResolution = typescript_1.default.ModuleResolutionKind.NodeJs;
-    }
-    return options;
-}
 function traverse(sourceFile, f, classMap) {
     typescript_1.default.forEachChild(sourceFile, function (node) {
         switch (node.kind) {

package/package.json

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

package/parse_schema/parse.d.ts

@@ -33,9 +33,11 @@ interface ProcessedPattern {
     fields: ProcessedField[];
 }
 declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate"> & {
+    name: string;
     hasDefaultValueOnCreate?: boolean;
     hasDefaultValueOnEdit?: boolean;
     patternName?: string;
+    derivedFields?: ProcessedField[];
 };
 interface patternsDict {
     [key: string]: ProcessedPattern;

package/parse_schema/parse.js

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSchema = void 0;
 function processFields(src, patternName) {
     const ret = [];
-    for (const field of src) {
-        let f = { ...field };
+    for (const name in src) {
+        const field = src[name];
+        let f = { name, ...field };
         f.hasDefaultValueOnCreate = field.defaultValueOnCreate != undefined;
         f.hasDefaultValueOnEdit = field.defaultValueOnEdit != undefined;
         if (field.polymorphic) {
@@ -17,6 +18,9 @@ function processFields(src, patternName) {
                 f.polymorphic = field.polymorphic;
             }
         }
+        else {
+            delete f.polymorphic;
+        }
         // convert string to object to make API consumed by go simple
         if (f.fieldEdge && f.fieldEdge.inverseEdge) {
             if (typeof f.fieldEdge.inverseEdge === "string") {
@@ -28,6 +32,9 @@ function processFields(src, patternName) {
         if (patternName) {
             f.patternName = patternName;
         }
+        if (field.getDerivedFields) {
+            f.derivedFields = processFields(field.getDerivedFields(name));
+        }
         ret.push(f);
     }
     return ret;
@@ -91,6 +98,7 @@ function processAction(action) {
     let actionOnlyFields = action.actionOnlyFields.map((f) => {
         let f2 = f;
         if (!f.nullable) {
+            delete f2.nullable;
             return f2;
         }
         if (typeof f.nullable === "boolean") {

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

@@ -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) {

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, LoaderInfo } from "../core/base";
 import { Builder } from "../action/action";
+export declare type FieldMap = {
+    [key: string]: Field;
+};
 export default interface Schema {
-    fields: Field[];
+    fields: FieldMap;
     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;
     edges?: Edge[];
 }
 export declare enum DBType {
@@ -117,7 +120,6 @@ export interface FieldEdge {
     disableBuilderType?: boolean;
 }
 export interface FieldOptions {
-    name: string;
     nullable?: boolean;
     storageKey?: string;
     serverDefault?: any;
@@ -136,7 +138,7 @@ export interface FieldOptions {
     defaultValueOnEdit?(builder: Builder<Ent>, input: Data): any;
     derivedWhenEmbedded?: boolean;
     polymorphic?: boolean | PolymorphicOptions;
-    derivedFields?: Field[];
+    getDerivedFields?(name: string): FieldMap;
 }
 export interface PolymorphicOptions {
     types?: string[];

package/schema/schema.js

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

package/scripts/transform_schema.js

@@ -0,0 +1,288 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const glob_1 = require("glob");
+const typescript_1 = __importDefault(require("typescript"));
+const fs = __importStar(require("fs"));
+const compilerOptions_1 = require("../tsc/compilerOptions");
+const child_process_1 = require("child_process");
+function getTarget(target) {
+    switch (target.toLowerCase()) {
+        case "es2015":
+            return typescript_1.default.ScriptTarget.ES2015;
+        case "es2016":
+            return typescript_1.default.ScriptTarget.ES2016;
+        case "es2017":
+            return typescript_1.default.ScriptTarget.ES2017;
+        case "es2018":
+            return typescript_1.default.ScriptTarget.ES2018;
+        case "es2019":
+            return typescript_1.default.ScriptTarget.ES2019;
+        case "es2020":
+            return typescript_1.default.ScriptTarget.ES2020;
+        case "es2021":
+            return typescript_1.default.ScriptTarget.ES2021;
+        case "es3":
+            return typescript_1.default.ScriptTarget.ES3;
+        case "es5":
+            return typescript_1.default.ScriptTarget.ES5;
+        case "esnext":
+            return typescript_1.default.ScriptTarget.ESNext;
+        default:
+            return typescript_1.default.ScriptTarget.ESNext;
+    }
+}
+async function main() {
+    // this assumes this is being run from root of directory
+    const options = (0, compilerOptions_1.readCompilerOptions)(".");
+    let files = glob_1.glob.sync("src/schema/*.ts");
+    const target = options.target
+        ? // @ts-ignore
+            getTarget(options.target)
+        : typescript_1.default.ScriptTarget.ESNext;
+    // filter to only event.ts e.g. for comments and whitespace...
+    //  files = files.filter((f) => f.endsWith("event.ts"));
+    files.forEach((file) => {
+        // assume valid file since we do glob above
+        const idx = file.lastIndexOf(".ts");
+        const writeFile = file.substring(0, idx) + "2" + ".ts";
+        let contents = fs.readFileSync(file).toString();
+        // go through the file and print everything back if not starting immediately after other position
+        const sourceFile = typescript_1.default.createSourceFile(file, contents, target, false, typescript_1.default.ScriptKind.TS);
+        const nodes = [];
+        let updateImport = false;
+        const f = {
+            trackNode: function (tni) {
+                nodes.push({
+                    node: tni.node,
+                    importNode: tni.node && typescript_1.default.isImportDeclaration(tni.node),
+                    rawString: tni.rawString,
+                });
+            },
+            flagUpdateImport() {
+                updateImport = true;
+            },
+        };
+        if (!traverse(contents, sourceFile, f)) {
+            return;
+        }
+        let newContents = "";
+        for (const node of nodes) {
+            if (updateImport && node.importNode) {
+                const importNode = node.node;
+                const transformedImport = transformImport(importNode, sourceFile);
+                if (transformedImport) {
+                    newContents += transformedImport;
+                    continue;
+                }
+            }
+            if (node.node) {
+                newContents += node.node.getFullText(sourceFile);
+            }
+            else if (node.rawString) {
+                newContents += node.rawString;
+            }
+            else {
+                console.error("invalid node");
+            }
+        }
+        //    console.debug(newContents);
+        // ideally there's a flag that indicates if we write
+        fs.writeFileSync(writeFile, newContents);
+    });
+    (0, child_process_1.execSync)("prettier src/schema/*.ts --write");
+}
+function traverse(fileContents, sourceFile, f) {
+    let traversed = false;
+    typescript_1.default.forEachChild(sourceFile, function (node) {
+        if (typescript_1.default.isClassDeclaration(node)) {
+            traversed = true;
+            // TODO address implicit schema doesn't work here...
+            //        console.debug(sourceFile.fileName, node.kind);
+            if (traverseClass(fileContents, sourceFile, node, f)) {
+                f.flagUpdateImport();
+                return;
+            }
+        }
+        f.trackNode({ node });
+    });
+    return traversed;
+}
+// TODO need to replace class field member, print that and see what happens
+function traverseClass(fileContents, sourceFile, node, f) {
+    let updated = false;
+    // beginning of class...
+    // including comment
+    let klassContents = fileContents.substring(node.getFullStart(), node.members[0].getFullStart());
+    for (let member of node.members) {
+        if (!isFieldElement(member, sourceFile)) {
+            klassContents += member.getFullText(sourceFile);
+            continue;
+        }
+        // intentionally doesn't parse decorators since we don't need it
+        let fieldMap = "";
+        // fieldMapComment...
+        const comment = getPreText(fileContents, member, sourceFile);
+        if (comment) {
+            fieldMap += comment;
+        }
+        updated = true;
+        // need to change to fields: FieldMap = {code: StringType()};
+        const property = member;
+        const initializer = property.initializer;
+        fieldMap += "fields: FieldMap = {";
+        for (const element of initializer.elements) {
+            const parsed = parseFieldElement(element, sourceFile, fileContents);
+            if (parsed === null) {
+                return false;
+            }
+            const { callEx, name, nameComment, properties } = parsed;
+            let property = "";
+            const fieldComment = getPreText(fileContents, element, sourceFile).trim();
+            if (fieldComment) {
+                property += "\n" + fieldComment + "\n";
+            }
+            if (nameComment) {
+                property += nameComment + "\n";
+            }
+            // e.g. UUIDType, StringType etc
+            let call = callEx.expression.getText(sourceFile);
+            let fnCall = "";
+            if (properties.length) {
+                fnCall = `{${properties.join(",")}}`;
+            }
+            property += `${name}:${call}(${fnCall}),`;
+            fieldMap += property;
+        }
+        fieldMap += "}";
+        klassContents += fieldMap;
+    }
+    klassContents += "\n}";
+    //  console.debug(klassContents);
+    if (!updated) {
+        return updated;
+    }
+    f.trackNode({ rawString: klassContents });
+    return updated;
+}
+function isFieldElement(member, sourceFile) {
+    if (member.kind !== typescript_1.default.SyntaxKind.PropertyDeclaration) {
+        return false;
+    }
+    const property = member;
+    const token = property.name;
+    if (token.escapedText !== "fields") {
+        return false;
+    }
+    const propertytype = property.type?.getText(sourceFile);
+    if (propertytype !== "Field[]") {
+        return false;
+    }
+    if (property.initializer?.kind !== typescript_1.default.SyntaxKind.ArrayLiteralExpression) {
+        console.error("invalid array type");
+        return false;
+    }
+    return true;
+}
+function parseFieldElement(element, sourceFile, fileContents) {
+    if (element.kind !== typescript_1.default.SyntaxKind.CallExpression) {
+        console.error("skipped non-call expression");
+        return null;
+    }
+    let callEx = element;
+    if (callEx.arguments.length !== 1) {
+        console.error("callExpression with arguments not of length 1");
+        return null;
+    }
+    let arg = callEx.arguments[0];
+    if (arg.kind !== typescript_1.default.SyntaxKind.ObjectLiteralExpression) {
+        console.error("not objectLiteralExpression");
+        return null;
+    }
+    let expr = arg;
+    let name = "";
+    let propertyComment;
+    let properties = [];
+    for (const p of expr.properties) {
+        const p2 = p;
+        // found name property
+        if (p2.name.escapedText === "name") {
+            name = p2.initializer.getText(sourceFile);
+            // check for any comment associated with name: "fooo"
+            propertyComment = getPreText(fileContents, p, sourceFile).trim();
+        }
+        else {
+            properties.push(p.getFullText(sourceFile));
+        }
+    }
+    if (!name) {
+        console.error(`couldn't find name property`);
+        return null;
+    }
+    // remove quotes
+    name = name.slice(1, -1);
+    return {
+        callEx,
+        name,
+        properties,
+        nameComment: propertyComment,
+    };
+}
+function transformImport(importNode, sourceFile) {
+    // remove quotes too
+    const text = importNode.moduleSpecifier.getText(sourceFile).slice(1, -1);
+    if (text !== "@snowtop/ent" &&
+        text !== "@snowtop/ent/schema" &&
+        text !== "@snowtop/ent/schema/") {
+        return;
+    }
+    const importText = importNode.importClause?.getText(sourceFile) || "";
+    const start = importText.indexOf("{");
+    const end = importText.lastIndexOf("}");
+    if (start === -1 || end === -1) {
+        return;
+    }
+    const imports = importText
+        .substring(start + 1, end)
+        //    .trim()
+        .split(",");
+    for (let i = 0; i < imports.length; i++) {
+        const imp = imports[i].trim();
+        if (imp === "Field") {
+            imports[i] = "FieldMap";
+        }
+    }
+    // TODO better to update node instead of doing this but this works for now
+    return ("import " +
+        importText.substring(0, start + 1) +
+        imports.join(", ") +
+        importText.substring(end) +
+        ' from "' +
+        text +
+        '"');
+}
+function getPreText(fileContents, node, sourceFile) {
+    return fileContents.substring(node.getFullStart(), node.getStart(sourceFile));
+}
+Promise.resolve(main());

package/testutils/db/test_db.js

@@ -479,8 +479,8 @@ exports.setupSqlite = setupSqlite;
 function getSchemaTable(schema, dialect) {
     const fields = (0, schema_1.getFields)(schema);
     const columns = [];
-    for (const [_, field] of fields) {
-        columns.push(getColumnFromField(field, dialect));
+    for (const [fieldName, field] of fields) {
+        columns.push(getColumnFromField(fieldName, field, dialect));
     }
     return table((0, builder_1.getTableName)(schema), ...columns);
 }
@@ -520,7 +520,7 @@ function getColumnForDbType(t, dialect) {
             return undefined;
     }
 }
-function getColumnFromField(f, dialect) {
+function getColumnFromField(fieldName, f, dialect) {
     switch (f.type.dbType) {
         case schema_1.DBType.List:
             const elemType = f.type.listElemType;
@@ -531,17 +531,17 @@ function getColumnFromField(f, dialect) {
             if (elemFn === undefined) {
                 throw new Error(`unsupported type for ${elemType}`);
             }
-            return list(storageKey(f), elemFn("ignore"), buildOpts(f));
+            return list(storageKey(fieldName, f), elemFn("ignore"), buildOpts(f));
         default:
             const fn = getColumnForDbType(f.type.dbType, dialect);
             if (fn === undefined) {
                 throw new Error(`unsupported type ${f.type.dbType}`);
             }
-            return getColumn(f, fn);
+            return getColumn(fieldName, f, fn);
     }
 }
-function getColumn(f, col) {
-    return col(storageKey(f), buildOpts(f));
+function getColumn(fieldName, f, col) {
+    return col(storageKey(fieldName, f), buildOpts(f));
 }
 function buildOpts(f) {
     let ret = {};
@@ -560,11 +560,11 @@ function buildOpts(f) {
     }
     return ret;
 }
-function storageKey(f) {
+function storageKey(fieldName, f) {
     if (f.storageKey) {
         return f.storageKey;
     }
-    return (0, snake_case_1.snakeCase)(f.name);
+    return (0, snake_case_1.snakeCase)(fieldName);
 }
 function isSyncClient(client) {
     return client.execSync !== undefined;

package/testutils/fake_data/fake_contact.d.ts

@@ -1,6 +1,6 @@
 import { ID, Ent, Viewer, Data, LoadEntOptions, PrivacyPolicy } from "../../core/base";
 import { BuilderSchema, SimpleBuilder } from "../builder";
-import { Field, BaseEntSchema } from "../../schema";
+import { BaseEntSchema, FieldMap } from "../../schema";
 import { NodeType } from "./const";
 import { ObjectLoaderFactory } from "../../core/loaders";
 export declare class FakeContact implements Ent {
@@ -24,7 +24,7 @@ export declare class FakeContact implements Ent {
 }
 export declare class FakeContactSchema extends BaseEntSchema implements BuilderSchema<FakeContact> {
     ent: typeof FakeContact;
-    fields: Field[];
+    fields: FieldMap;
 }
 export interface ContactCreateInput {
     firstName: string;

package/testutils/fake_data/fake_contact.js

@@ -63,21 +63,14 @@ class FakeContactSchema extends schema_1.BaseEntSchema {
     constructor() {
         super(...arguments);
         this.ent = FakeContact;
-        this.fields = [
-            (0, schema_1.StringType)({
-                name: "firstName",
-            }),
-            (0, schema_1.StringType)({
-                name: "lastName",
-            }),
-            (0, schema_1.StringType)({
-                name: "emailAddress",
-            }),
-            (0, schema_1.UUIDType)({
-                name: "userID",
+        this.fields = {
+            firstName: (0, schema_1.StringType)(),
+            lastName: (0, schema_1.StringType)(),
+            emailAddress: (0, schema_1.StringType)(),
+            userID: (0, schema_1.UUIDType)({
                 foreignKey: { schema: "User", column: "ID" },
             }),
-        ];
+        };
     }
 }
 exports.FakeContactSchema = FakeContactSchema;

package/testutils/fake_data/fake_event.d.ts

@@ -1,6 +1,6 @@
 import { ID, Ent, Viewer, Data, LoadEntOptions, PrivacyPolicy } from "../../core/base";
 import { BuilderSchema, SimpleBuilder } from "../builder";
-import { Field, BaseEntSchema } from "../../schema";
+import { BaseEntSchema, FieldMap } from "../../schema";
 import { NodeType } from "./const";
 export declare class FakeEvent implements Ent {
     viewer: Viewer;
@@ -25,7 +25,7 @@ export declare class FakeEvent implements Ent {
 }
 export declare class FakeEventSchema extends BaseEntSchema implements BuilderSchema<FakeEvent> {
     ent: typeof FakeEvent;
-    fields: Field[];
+    fields: FieldMap;
 }
 export interface EventCreateInput {
     startTime: Date;

package/testutils/fake_data/fake_event.js

@@ -67,30 +67,22 @@ class FakeEventSchema extends schema_1.BaseEntSchema {
     constructor() {
         super(...arguments);
         this.ent = FakeEvent;
-        this.fields = [
-            (0, schema_1.TimestampType)({
-                name: "startTime",
+        this.fields = {
+            startTime: (0, schema_1.TimestampType)({
                 index: true,
             }),
-            (0, schema_1.TimestampType)({
-                name: "endTime",
+            endTime: (0, schema_1.TimestampType)({
                 nullable: true,
             }),
-            (0, schema_1.StringType)({
-                name: "title",
-            }),
-            (0, schema_1.StringType)({
-                name: "location",
-            }),
-            (0, schema_1.StringType)({
-                name: "description",
+            title: (0, schema_1.StringType)(),
+            location: (0, schema_1.StringType)(),
+            description: (0, schema_1.StringType)({
                 nullable: true,
             }),
-            (0, schema_1.UUIDType)({
-                name: "userID",
+            userID: (0, schema_1.UUIDType)({
                 foreignKey: { schema: "User", column: "ID" },
             }),
-        ];
+        };
     }
 }
 exports.FakeEventSchema = FakeEventSchema;

package/testutils/fake_data/fake_user.d.ts

@@ -1,6 +1,6 @@
 import { ID, Ent, Viewer, Data, LoadEntOptions, PrivacyPolicy } from "../../core/base";
 import { BuilderSchema, SimpleAction } from "../builder";
-import { Field, BaseEntSchema } from "../../schema";
+import { BaseEntSchema, FieldMap } from "../../schema";
 import { NodeType } from "./const";
 import { IDViewer, IDViewerOptions } from "../../core/viewer";
 import { ObjectLoaderFactory } from "../../core/loaders";
@@ -34,7 +34,7 @@ export declare class FakeUser implements Ent {
 }
 export declare class FakeUserSchema extends BaseEntSchema implements BuilderSchema<FakeUser> {
     ent: typeof FakeUser;
-    fields: Field[];
+    fields: FieldMap;
 }
 export interface UserCreateInput {
     firstName: string;

package/testutils/fake_data/fake_user.js

@@ -93,24 +93,15 @@ class FakeUserSchema extends schema_1.BaseEntSchema {
     constructor() {
         super(...arguments);
         this.ent = FakeUser;
-        this.fields = [
-            (0, schema_1.StringType)({
-                name: "firstName",
-            }),
-            (0, schema_1.StringType)({
-                name: "lastName",
-            }),
-            (0, schema_1.StringType)({
-                name: "emailAddress",
-            }),
-            (0, schema_1.StringType)({
-                name: "phoneNumber",
-            }),
-            (0, schema_1.StringType)({
-                name: "password",
+        this.fields = {
+            firstName: (0, schema_1.StringType)(),
+            lastName: (0, schema_1.StringType)(),
+            emailAddress: (0, schema_1.StringType)(),
+            phoneNumber: (0, schema_1.StringType)(),
+            password: (0, schema_1.StringType)({
                 nullable: true,
             }),
-        ];
+        };
     }
 }
 exports.FakeUserSchema = FakeUserSchema;

package/tsc/compilerOptions.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function readCompilerOptions(filePath: string): ts.CompilerOptions;

package/tsc/compilerOptions.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCompilerOptions = void 0;
+const fs = __importStar(require("fs"));
+const json5_1 = __importDefault(require("json5"));
+const typescript_1 = __importDefault(require("typescript"));
+const path = __importStar(require("path"));
+function findTSConfigFile(filePath) {
+    while (filePath != "/") {
+        let configPath = `${filePath}/tsconfig.json`;
+        if (fs.existsSync(configPath)) {
+            return configPath;
+        }
+        filePath = path.join(filePath, "..");
+    }
+    return null;
+}
+function readCompilerOptions(filePath) {
+    let configPath = findTSConfigFile(filePath);
+    if (!configPath) {
+        return {};
+    }
+    let json = {};
+    try {
+        json = json5_1.default.parse(fs.readFileSync(configPath, {
+            encoding: "utf8",
+        }));
+    }
+    catch (e) {
+        console.error("couldn't read tsconfig.json file");
+    }
+    let options = json["compilerOptions"] || {};
+    // @ts-ignore
+    if (options.moduleResolution === "node") {
+        options.moduleResolution = typescript_1.default.ModuleResolutionKind.NodeJs;
+    }
+    return options;
+}
+exports.readCompilerOptions = readCompilerOptions;