@snowtop/ent 0.0.40-alpha6 → 0.1.0-alpha10

package/graphql/query/shared_assoc_test.js

@@ -110,7 +110,7 @@ function sharedAssocTests() {
             name: "User",
             fields: {
                 id: {
-                    type: (0, graphql_1.GraphQLNonNull)(graphql_1.GraphQLID),
+                    type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLID),
                 },
                 firstName: {
                     type: graphql_1.GraphQLString,
@@ -128,7 +128,7 @@ function sharedAssocTests() {
             name: "Event",
             fields: {
                 id: {
-                    type: (0, graphql_1.GraphQLNonNull)(graphql_1.GraphQLID),
+                    type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLID),
                 },
             },
             interfaces: [node_1.GraphQLNodeInterface],

package/graphql/scalars/time.d.ts

@@ -1,2 +1,2 @@
 import { GraphQLScalarType } from "graphql";
-export declare const GraphQLTime: GraphQLScalarType;
+export declare const GraphQLTime: GraphQLScalarType<Date, string>;

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.0.40-alpha6",
+  "version": "0.1.0-alpha10",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -31,7 +31,7 @@
   },
   "peerDependencies": {
     "better-sqlite3": "^7.4.1",
-    "graphql": "^15.5"
+    "graphql": "^16.5.0"
   },
   "peerDependenciesMeta": {
     "better-sqlite3": {

package/parse_schema/parse.d.ts

@@ -1,5 +1,5 @@
 import { Schema, Field, AssocEdge, AssocEdgeGroup, Action } from "../schema";
-import { ActionField } from "../schema/schema";
+import { ActionField, Type } from "../schema/schema";
 declare enum NullableResult {
     CONTENTS = "contents",
     CONTENTS_AND_LIST = "contentsAndList",
@@ -23,6 +23,7 @@ declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" |
     assocEdges: ProcessedAssocEdge[];
     assocEdgeGroups: ProcessedAssocEdgeGroup[];
     fields: ProcessedField[];
+    schemaPath?: string;
 };
 declare type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
     edgeAction?: OutputAction;
@@ -38,11 +39,19 @@ interface ProcessedPattern {
     assocEdges: ProcessedAssocEdge[];
     fields: ProcessedField[];
 }
-declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate" | "privacyPolicy"> & {
+declare type ProcessedType = Omit<Type, "subFields" | "listElemType" | "unionFields"> & {
+    subFields?: ProcessedField[];
+    listElemType?: ProcessedType;
+    unionFields?: ProcessedField[];
+};
+declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate" | "privacyPolicy" | "type"> & {
+    name: string;
     hasDefaultValueOnCreate?: boolean;
     hasDefaultValueOnEdit?: boolean;
     patternName?: string;
     hasFieldPrivacy?: boolean;
+    derivedFields?: ProcessedField[];
+    type: ProcessedType;
 };
 interface patternsDict {
     [key: string]: ProcessedPattern;
@@ -51,5 +60,8 @@ interface Result {
     schemas: schemasDict;
     patterns: patternsDict;
 }
-export declare function parseSchema(potentialSchemas: {}): Result;
+declare type PotentialSchemas = {
+    [key: string]: any;
+};
+export declare function parseSchema(potentialSchemas: PotentialSchemas): Result;
 export {};

package/parse_schema/parse.js

@@ -3,8 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSchema = void 0;
 function processFields(src, patternName) {
     const ret = [];
-    for (const field of src) {
-        let f = { ...field };
+    let m = {};
+    if (Array.isArray(src)) {
+        for (const field of src) {
+            const name = field.name;
+            if (!name) {
+                throw new Error(`name is required`);
+            }
+            m[name] = field;
+        }
+    }
+    else {
+        m = src;
+    }
+    for (const name in m) {
+        const field = m[name];
+        //@ts-ignore type and other changed fields with different type in ProcessedField vs Field
+        let f = { name, ...field };
         f.hasDefaultValueOnCreate = field.defaultValueOnCreate != undefined;
         f.hasDefaultValueOnEdit = field.defaultValueOnEdit != undefined;
         f.hasFieldPrivacy = field.privacyPolicy !== undefined;
@@ -33,6 +48,21 @@ function processFields(src, patternName) {
             f.patternName = patternName;
         }
         transformType(field.type);
+        if (field.getDerivedFields) {
+            f.derivedFields = processFields(field.getDerivedFields(name));
+        }
+        if (field.type.subFields) {
+            f.type.subFields = processFields(field.type.subFields);
+        }
+        if (field.type.unionFields) {
+            f.type.unionFields = processFields(field.type.unionFields);
+        }
+        if (field.type.listElemType &&
+            field.type.listElemType.subFields &&
+            // check to avoid ts-ignore below. exists just for tsc
+            f.type.listElemType) {
+            f.type.listElemType.subFields = processFields(field.type.listElemType.subFields);
+        }
         ret.push(f);
     }
     return ret;
@@ -147,14 +177,19 @@ function parseSchema(potentialSchemas) {
     for (const key in potentialSchemas) {
         const value = potentialSchemas[key];
         let schema;
-        if (value.constructor == Object) {
-            schema = value;
-        }
-        else {
-            schema = new value();
+        const name = value.constructor.name;
+        // named class e.g. new BaseEntSchema
+        switch (name) {
+            case "Function":
+                schema = new value();
+                break;
+            default:
+                // implicit schema or named class
+                schema = value;
         }
         let processedSchema = {
             fields: [],
+            schemaPath: schema.schemaPath,
             tableName: schema.tableName,
             enumTable: schema.enumTable,
             dbRows: schema.dbRows,

package/schema/base_schema.d.ts

@@ -1,6 +1,41 @@
-import { Pattern } from "./schema";
+import { Field, FieldMap, Pattern } from "./schema";
+import { Action, AssocEdgeGroup, Constraint, Edge, Index, Schema } from ".";
 export declare const Timestamps: Pattern;
 export declare const Node: Pattern;
+export interface SchemaConfig extends Schema {
+}
+export declare class EntSchema implements Schema {
+    fields: FieldMap | Field[];
+    tableName: string | undefined;
+    patterns: Pattern[];
+    edges: Edge[] | undefined;
+    edgeGroups: AssocEdgeGroup[] | undefined;
+    actions: Action[] | undefined;
+    enumTable: boolean | undefined;
+    dbRows: {
+        [key: string]: any;
+    }[] | undefined;
+    constraints: Constraint[] | undefined;
+    indices: Index[] | undefined;
+    hideFromGraphQL?: boolean;
+    constructor(cfg: SchemaConfig);
+}
+export declare class EntSchemaWithTZ implements Schema {
+    fields: FieldMap | Field[];
+    tableName: string | undefined;
+    patterns: Pattern[];
+    edges: Edge[] | undefined;
+    edgeGroups: AssocEdgeGroup[] | undefined;
+    actions: Action[] | undefined;
+    enumTable: boolean | undefined;
+    dbRows: {
+        [key: string]: any;
+    }[] | undefined;
+    constraints: Constraint[] | undefined;
+    indices: Index[] | undefined;
+    hideFromGraphQL?: boolean;
+    constructor(cfg: SchemaConfig);
+}
 export declare abstract class BaseEntSchema {
     addPatterns(...patterns: Pattern[]): void;
     patterns: Pattern[];

package/schema/base_schema.js

@@ -1,19 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = void 0;
+exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.EntSchemaWithTZ = exports.EntSchema = 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,14 +61,59 @@ let nodeFieldsWithTZ = [
         },
         withTimezone: true,
     }),
-];
+};
 // Node is a Pattern that adds 3 fields to the ent: (id, createdAt, and updatedAt timestamps)
 exports.Node = {
     name: "node",
     fields: nodeFields,
 };
-// Base ent schema. has Node Pattern by default.
+// Ent schema. has Node Pattern by default.
 // exists just to have less typing and easier for clients to implement
+class EntSchema {
+    constructor(cfg) {
+        this.patterns = [exports.Node];
+        this.fields = cfg.fields;
+        this.tableName = cfg.tableName;
+        if (cfg.patterns) {
+            this.patterns.push(...cfg.patterns);
+        }
+        this.edges = cfg.edges;
+        this.edgeGroups = cfg.edgeGroups;
+        this.actions = cfg.actions;
+        this.enumTable = cfg.enumTable;
+        this.dbRows = cfg.dbRows;
+        this.constraints = cfg.constraints;
+        this.indices = cfg.indices;
+        this.hideFromGraphQL = cfg.hideFromGraphQL;
+    }
+}
+exports.EntSchema = EntSchema;
+class EntSchemaWithTZ {
+    constructor(cfg) {
+        this.patterns = [
+            {
+                // default schema added
+                name: "nodeWithTZ",
+                fields: nodeFieldsWithTZ,
+            },
+        ];
+        this.fields = cfg.fields;
+        this.tableName = cfg.tableName;
+        if (cfg.patterns) {
+            this.patterns.push(...cfg.patterns);
+        }
+        this.edges = cfg.edges;
+        this.edgeGroups = cfg.edgeGroups;
+        this.actions = cfg.actions;
+        this.enumTable = cfg.enumTable;
+        this.dbRows = cfg.dbRows;
+        this.constraints = cfg.constraints;
+        this.indices = cfg.indices;
+        this.hideFromGraphQL = cfg.hideFromGraphQL;
+    }
+}
+exports.EntSchemaWithTZ = EntSchemaWithTZ;
+// @deprecated use EntSchema
 class BaseEntSchema {
     constructor() {
         this.patterns = [exports.Node];
@@ -78,6 +123,7 @@ class BaseEntSchema {
     }
 }
 exports.BaseEntSchema = BaseEntSchema;
+// @deprecated use EntSchemaWithTZ
 class BaseEntSchemaWithTZ {
     constructor() {
         this.patterns = [

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 {};