@snowtop/ent 0.0.2 → 0.0.3-5.alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.0.2",
+  "version": "0.0.35.alpha.2",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -9,7 +9,7 @@
   },
   "dependencies": {
     "@types/node": "^15.0.2",
-    "better-sqlite3": "^7.4.1",
+    "camel-case": "^4.1.2",
     "dataloader": "^2.0.0",
     "glob": "^7.1.6",
     "graph-data-structure": "^1.12.0",
@@ -20,16 +20,26 @@
     "minimist": "^1.2.5",
     "pascal-case": "^3.1.2",
     "pg": "^8.0.3",
-    "prettier": "^2.3.0",
+    "prettier": "^2.3.2",
     "reflect-metadata": "^0.1.13",
     "snake-case": "^3.0.3",
-    "ts-node": "^9.1.1",
-    "tsconfig-paths": "^3.9.0",
-    "typescript": "^4.2.4",
+    "ts-node": "^10.2.1",
+    "tsconfig-paths": "^3.11.0",
+    "tslib": "^2.3.1",
+    "typescript": "^4.4.2",
     "uuid": "^8.3.2"
   },
   "peerDependencies": {
-    "graphql": ">= 15.3.0"
+    "better-sqlite3": "^7.4.1",
+    "graphql": "^15.5"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=14.0"
   },
   "devDependencies": {},
   "scripts": {},
@@ -43,9 +53,6 @@
     "type": "git",
     "url": "git+ssh://git@github.com/lolopinto/ent.git"
   },
-  "resolutions": {
-    "graphql": "^15.3.0"
-  },
   "bugs": {
     "url": "https://github.com/lolopinto/ent/issues"
   },

package/parse_schema/parse.d.ts

@@ -0,0 +1,48 @@
+import { Schema, Field, AssocEdge, AssocEdgeGroup, Action } from "../schema";
+import { ActionField } from "../schema/schema";
+declare enum NullableResult {
+    CONTENTS = "contents",
+    CONTENTS_AND_LIST = "contentsAndList",
+    ITEM = "true"
+}
+declare type ProcessedActionField = Omit<ActionField, "nullable"> & {
+    nullable?: NullableResult;
+};
+declare type ProcessedAssocEdge = Omit<AssocEdge, "actionOnlyFields" | "edgeActions"> & {
+    patternName?: string;
+    edgeActions?: OutputAction[];
+};
+declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" | "fields"> & {
+    actions: OutputAction[];
+    assocEdges: ProcessedAssocEdge[];
+    assocEdgeGroups: ProcessedAssocEdgeGroup[];
+    fields: ProcessedField[];
+};
+declare type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
+    edgeAction?: OutputAction;
+};
+declare type OutputAction = Omit<Action, "actionOnlyFields"> & {
+    actionOnlyFields?: ProcessedActionField[];
+};
+interface schemasDict {
+    [key: string]: ProcessedSchema;
+}
+interface ProcessedPattern {
+    name: string;
+    assocEdges: ProcessedAssocEdge[];
+    fields: ProcessedField[];
+}
+declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate"> & {
+    hasDefaultValueOnCreate?: boolean;
+    hasDefaultValueOnEdit?: boolean;
+    patternName?: string;
+};
+interface patternsDict {
+    [key: string]: ProcessedPattern;
+}
+interface Result {
+    schemas: schemasDict;
+    patterns: patternsDict;
+}
+export declare function parseSchema(potentialSchemas: {}): Result;
+export {};

package/parse_schema/parse.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSchema = void 0;
+function processFields(src, patternName) {
+    const ret = [];
+    for (const field of src) {
+        let f = { ...field };
+        f.hasDefaultValueOnCreate = field.defaultValueOnCreate != undefined;
+        f.hasDefaultValueOnEdit = field.defaultValueOnEdit != undefined;
+        if (field.polymorphic) {
+            // convert boolean into object
+            // we keep boolean as an option to keep API simple
+            if (typeof field.polymorphic === "boolean") {
+                f.polymorphic = {};
+            }
+            else {
+                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") {
+                f.fieldEdge.inverseEdge = {
+                    name: f.fieldEdge.inverseEdge,
+                };
+            }
+        }
+        if (patternName) {
+            f.patternName = patternName;
+        }
+        ret.push(f);
+    }
+    return ret;
+}
+function processEdges(src, patternName) {
+    const ret = [];
+    for (const edge of src) {
+        let edge2 = { ...edge };
+        edge2.edgeActions = edge.edgeActions?.map((action) => processAction(action));
+        edge2.patternName = patternName;
+        ret.push(edge2);
+    }
+    return ret;
+}
+function processEdgeGroups(processedSchema, edgeGroups) {
+    // array-ify this
+    for (const group of edgeGroups) {
+        if (group.nullStates && !Array.isArray(group.nullStates)) {
+            group.nullStates = [group.nullStates];
+        }
+        let group2 = { ...group };
+        if (group.edgeAction) {
+            group2.edgeAction = processAction(group.edgeAction);
+        }
+        processedSchema.assocEdgeGroups.push(group2);
+    }
+}
+function processPattern(patterns, pattern, processedSchema) {
+    const name = pattern.name;
+    const fields = processFields(pattern.fields, pattern.name);
+    processedSchema.fields.push(...fields);
+    if (pattern.edges) {
+        const edges = processEdges(pattern.edges, pattern.name);
+        processedSchema.assocEdges.push(...edges);
+    }
+    if (patterns[name] === undefined) {
+        // intentionally processing separately and not passing pattern.name
+        const edges = processEdges(pattern.edges || []);
+        patterns[name] = {
+            name: pattern.name,
+            assocEdges: edges,
+            fields: fields,
+        };
+    }
+    else {
+        // TODO ideally we want to make sure that different patterns don't have the same name
+        // can't do a deepEqual check because function calls and therefore different instances in fields
+    }
+}
+var NullableResult;
+(function (NullableResult) {
+    NullableResult["CONTENTS"] = "contents";
+    NullableResult["CONTENTS_AND_LIST"] = "contentsAndList";
+    NullableResult["ITEM"] = "true";
+})(NullableResult || (NullableResult = {}));
+function processAction(action) {
+    if (!action.actionOnlyFields) {
+        return { ...action };
+    }
+    let ret = { ...action };
+    let actionOnlyFields = action.actionOnlyFields.map((f) => {
+        let f2 = f;
+        if (!f.nullable) {
+            delete f2.nullable;
+            return f2;
+        }
+        if (typeof f.nullable === "boolean") {
+            f2.nullable = NullableResult.ITEM;
+        }
+        else {
+            if (f.nullable === "contentsAndList") {
+                f2.nullable = NullableResult.CONTENTS_AND_LIST;
+            }
+            else {
+                f2.nullable = NullableResult.CONTENTS;
+            }
+        }
+        return f2;
+    });
+    ret.actionOnlyFields = actionOnlyFields;
+    return ret;
+}
+function parseSchema(potentialSchemas) {
+    let schemas = {};
+    let patterns = {};
+    for (const key in potentialSchemas) {
+        const value = potentialSchemas[key];
+        let schema;
+        if (value.constructor == Object) {
+            schema = value;
+        }
+        else {
+            schema = new value();
+        }
+        let processedSchema = {
+            fields: [],
+            tableName: schema.tableName,
+            enumTable: schema.enumTable,
+            dbRows: schema.dbRows,
+            constraints: schema.constraints,
+            indices: schema.indices,
+            hideFromGraphQL: schema.hideFromGraphQL,
+            actions: schema.actions?.map((action) => processAction(action)) || [],
+            assocEdges: [],
+            assocEdgeGroups: [],
+        };
+        // let's put patterns first just so we have id, created_at, updated_at first
+        // ¯\_(ツ)_/¯
+        if (schema.patterns) {
+            for (const pattern of schema.patterns) {
+                processPattern(patterns, pattern, processedSchema);
+            }
+        }
+        const fields = processFields(schema.fields);
+        processedSchema.fields.push(...fields);
+        if (schema.edges) {
+            const edges = processEdges(schema.edges);
+            processedSchema.assocEdges.push(...edges);
+        }
+        if (schema.edgeGroups) {
+            processEdgeGroups(processedSchema, schema.edgeGroups);
+        }
+        schemas[key] = processedSchema;
+    }
+    return { schemas, patterns };
+}
+exports.parseSchema = parseSchema;

package/schema/base_schema.d.ts

@@ -2,8 +2,10 @@ import { Pattern } from "./schema";
 export declare const Timestamps: Pattern;
 export declare const Node: Pattern;
 export declare abstract class BaseEntSchema {
+    addPatterns(...patterns: Pattern[]): void;
     patterns: Pattern[];
 }
 export declare abstract class BaseEntSchemaWithTZ {
+    addPatterns(...patterns: Pattern[]): void;
     patterns: Pattern[];
 }

package/schema/base_schema.js

@@ -4,7 +4,7 @@ exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Tim
 const uuid_1 = require("uuid");
 const field_1 = require("./field");
 let tsFields = [
-    field_1.TimestampType({
+    (0, field_1.TimestampType)({
         name: "createdAt",
         hideFromGraphQL: true,
         disableUserEditable: true,
@@ -12,7 +12,7 @@ let tsFields = [
             return new Date();
         },
     }),
-    field_1.TimestampType({
+    (0, field_1.TimestampType)({
         name: "updatedAt",
         hideFromGraphQL: true,
         disableUserEditable: true,
@@ -26,20 +26,21 @@ let tsFields = [
 ];
 // Timestamps is a Pattern that adds a createdAt and updatedAt timestamp fields to the ent
 exports.Timestamps = {
+    name: "timestamps",
     fields: tsFields,
 };
-let nodeField = field_1.UUIDType({
+let nodeField = (0, field_1.UUIDType)({
     name: "ID",
     primaryKey: true,
     disableUserEditable: true,
     defaultValueOnCreate: () => {
-        return uuid_1.v4();
+        return (0, uuid_1.v4)();
     },
 });
-let nodeFields = [nodeField].concat(tsFields);
+let nodeFields = [nodeField, ...tsFields];
 let nodeFieldsWithTZ = [
     nodeField,
-    field_1.TimestampType({
+    (0, field_1.TimestampType)({
         name: "createdAt",
         hideFromGraphQL: true,
         disableUserEditable: true,
@@ -48,7 +49,7 @@ let nodeFieldsWithTZ = [
         },
         withTimezone: true,
     }),
-    field_1.TimestampType({
+    (0, field_1.TimestampType)({
         name: "updatedAt",
         hideFromGraphQL: true,
         disableUserEditable: true,
@@ -63,6 +64,7 @@ let nodeFieldsWithTZ = [
 ];
 // 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.
@@ -71,15 +73,23 @@ class BaseEntSchema {
     constructor() {
         this.patterns = [exports.Node];
     }
+    addPatterns(...patterns) {
+        this.patterns.push(...patterns);
+    }
 }
 exports.BaseEntSchema = BaseEntSchema;
 class BaseEntSchemaWithTZ {
     constructor() {
         this.patterns = [
             {
+                // default schema added
+                name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
             },
         ];
     }
+    addPatterns(...patterns) {
+        this.patterns.push(...patterns);
+    }
 }
 exports.BaseEntSchemaWithTZ = BaseEntSchemaWithTZ;

package/schema/field.d.ts

@@ -1,4 +1,4 @@
-import { Type, Field, FieldOptions, PolymorphicOptions, ForeignKey } from "./schema";
+import { Field, FieldOptions, ForeignKey, PolymorphicOptions, Type } from "./schema";
 export declare abstract class BaseField {
     name: string;
     nullable?: boolean;
@@ -17,14 +17,34 @@ export declare abstract class BaseField {
     logValue(val: any): any;
 }
 export declare class UUIDField extends BaseField implements Field {
+    private options;
     type: Type;
     constructor(options: FieldOptions);
+    private isBuilder;
+    valid(val: any): Promise<boolean>;
 }
 export declare function UUIDType(options: FieldOptions): UUIDField;
+export interface IntegerOptions extends FieldOptions {
+    min?: number;
+    max?: number;
+}
 export declare class IntegerField extends BaseField implements Field {
     type: Type;
+    private validators;
+    private options;
+    constructor(options?: IntegerOptions);
+    getOptions(): IntegerOptions;
+    private handleOptions;
+    min(l: number): this;
+    max(l: number): this;
+    valid(val: any): boolean;
+    validate(validator: (str: number) => boolean): this;
+}
+export declare function IntegerType(options: IntegerOptions): IntegerField;
+export declare class BigIntegerField extends BaseField implements Field {
+    type: Type;
 }
-export declare function IntegerType(options: FieldOptions): IntegerField;
+export declare function BigIntegerType(options: FieldOptions): BigIntegerField;
 export declare class FloatField extends BaseField implements Field {
     type: Type;
 }
@@ -49,23 +69,24 @@ export declare class StringField extends BaseField implements Field {
     type: Type;
     private validators;
     private formatters;
+    private options;
     constructor(options?: StringOptions);
     getOptions(): StringOptions;
     private handleOptions;
-    minLen(l: number): StringField;
-    maxLen(l: number): StringField;
-    length(l: number): StringField;
+    minLen(l: number): this;
+    maxLen(l: number): this;
+    length(l: number): this;
     valid(val: any): boolean;
     format(val: any): any;
-    validate(validator: (str: string) => boolean): StringField;
-    formatter(formatter: (str: string) => string): StringField;
-    match(pattern: string | RegExp): StringField;
-    doesNotMatch(pattern: string | RegExp): StringField;
-    toLowerCase(): StringField;
-    toUpperCase(): StringField;
-    trim(): StringField;
-    trimLeft(): StringField;
-    trimRight(): StringField;
+    validate(validator: (str: string) => boolean): this;
+    formatter(formatter: (str: string) => string): this;
+    match(pattern: string | RegExp): this;
+    doesNotMatch(pattern: string | RegExp): this;
+    toLowerCase(): this;
+    toUpperCase(): this;
+    trim(): this;
+    trimLeft(): this;
+    trimRight(): this;
 }
 export declare function StringType(options: StringOptions): StringField;
 export interface TimestampOptions extends FieldOptions {
@@ -97,8 +118,12 @@ export declare class DateField extends BaseField implements Field {
     format(val: any): any;
 }
 export declare function DateType(options: FieldOptions): DateField;
+declare type EnumMap = {
+    [key: string]: string;
+};
 export interface EnumOptions extends FieldOptions {
     values?: string[];
+    map?: EnumMap;
     tsType?: string;
     graphQLType?: string;
     createEnumType?: boolean;
@@ -106,6 +131,7 @@ export interface EnumOptions extends FieldOptions {
 export declare class EnumField extends BaseField implements Field {
     type: Type;
     private values?;
+    private map?;
     constructor(options: EnumOptions);
     convertForGQL(value: string): string;
     valid(val: any): boolean;
@@ -115,13 +141,22 @@ export declare function EnumType(options: EnumOptions): EnumField;
 export declare class ListField extends BaseField {
     private field;
     type: Type;
+    private validators;
     constructor(field: Field, options: FieldOptions);
-    valid(val: any): boolean;
+    validate(validator: (val: any[]) => boolean): this;
+    valid(val: any): Promise<boolean>;
+    private postgresVal;
     format(val: any): 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 IntListType(options: FieldOptions): ListField;
+export declare function IntegerListType(options: FieldOptions): ListField;
 export declare function FloatListType(options: FieldOptions): ListField;
+export declare function BigIntegerListType(options: FieldOptions): ListField;
 export declare function BooleanListType(options: FieldOptions): ListField;
 export declare function TimestampListType(options: TimestampOptions): ListField;
 export declare function TimestamptzListType(options: TimestampOptions): ListField;
@@ -129,3 +164,5 @@ export declare function TimeListType(options: TimeOptions): ListField;
 export declare function TimetzListType(options: TimeOptions): ListField;
 export declare function DateListType(options: FieldOptions): ListField;
 export declare function EnumListType(options: EnumOptions): ListField;
+export declare function UUIDListType(options: FieldOptions): ListField;
+export {};