@snowtop/ent 0.1.0-alpha6 → 0.1.0-alpha63

package/parse_schema/parse.js

@@ -22,6 +22,7 @@ function processFields(src, patternName) {
         let f = { name, ...field };
         f.hasDefaultValueOnCreate = field.defaultValueOnCreate != undefined;
         f.hasDefaultValueOnEdit = field.defaultValueOnEdit != undefined;
+        f.hasFieldPrivacy = field.privacyPolicy !== undefined;
         if (field.polymorphic) {
             // convert boolean into object
             // we keep boolean as an option to keep API simple
@@ -35,6 +36,19 @@ function processFields(src, patternName) {
         else {
             delete f.polymorphic;
         }
+        if (field.private) {
+            // convert boolean into object
+            // we keep boolean as an option to keep API simple
+            if (typeof field.private === "boolean") {
+                f.private = {};
+            }
+            else {
+                f.private = field.private;
+            }
+        }
+        else {
+            delete f.private;
+        }
         // convert string to object to make API consumed by go simple
         if (f.fieldEdge && f.fieldEdge.inverseEdge) {
             if (typeof f.fieldEdge.inverseEdge === "string") {
@@ -46,6 +60,7 @@ function processFields(src, patternName) {
         if (patternName) {
             f.patternName = patternName;
         }
+        transformType(field.type);
         if (field.getDerivedFields) {
             f.derivedFields = processFields(field.getDerivedFields(name));
         }
@@ -65,6 +80,24 @@ function processFields(src, patternName) {
     }
     return ret;
 }
+function transformImportType(typ) {
+    if (!typ.importType) {
+        return;
+    }
+    typ.importType = {
+        ...typ.importType,
+        // these 2 needed for forwards compatibility with new go schema
+        importPath: typ.importType.path,
+        import: typ.importType.type,
+    };
+}
+function transformType(typ) {
+    if (!typ) {
+        return;
+    }
+    transformImportType(typ);
+    transformType(typ.listElemType);
+}
 function processEdges(src, patternName) {
     const ret = [];
     for (const edge of src) {
@@ -89,6 +122,9 @@ function processEdgeGroups(processedSchema, edgeGroups) {
     }
 }
 function processPattern(patterns, pattern, processedSchema) {
+    let ret = {
+        ...pattern,
+    };
     const name = pattern.name;
     const fields = processFields(pattern.fields, pattern.name);
     processedSchema.fields.push(...fields);
@@ -96,6 +132,10 @@ function processPattern(patterns, pattern, processedSchema) {
         const edges = processEdges(pattern.edges, pattern.name);
         processedSchema.assocEdges.push(...edges);
     }
+    // flag transformsSelect
+    if (pattern.transformRead) {
+        ret.transformsSelect = true;
+    }
     if (patterns[name] === undefined) {
         // intentionally processing separately and not passing pattern.name
         const edges = processEdges(pattern.edges || []);
@@ -103,12 +143,14 @@ function processPattern(patterns, pattern, processedSchema) {
             name: pattern.name,
             assocEdges: edges,
             fields: fields,
+            disableMixin: pattern.disableMixin,
         };
     }
     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
     }
+    return ret;
 }
 var NullableResult;
 (function (NullableResult) {
@@ -143,20 +185,29 @@ function processAction(action) {
     ret.actionOnlyFields = actionOnlyFields;
     return ret;
 }
-function parseSchema(potentialSchemas) {
+function parseSchema(potentialSchemas, globalSchema) {
     let schemas = {};
     let patterns = {};
+    let parsedGlobalSchema;
+    if (globalSchema) {
+        parsedGlobalSchema = parseGlobalSchema(globalSchema);
+    }
     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,
@@ -169,13 +220,28 @@ function parseSchema(potentialSchemas) {
         };
         // let's put patterns first just so we have id, created_at, updated_at first
         // ¯\_(ツ)_/¯
+        let patternNames = [];
         if (schema.patterns) {
             for (const pattern of schema.patterns) {
-                processPattern(patterns, pattern, processedSchema);
+                const ret = processPattern(patterns, pattern, processedSchema);
+                patternNames.push(pattern.name);
+                if (ret.transformsSelect) {
+                    if (processedSchema.transformsSelect) {
+                        throw new Error(`can only have one pattern which transforms default querying behavior`);
+                    }
+                    processedSchema.transformsSelect = true;
+                }
+                if (ret.transformsDelete) {
+                    if (processedSchema.transformsDelete) {
+                        throw new Error(`can only have one pattern which transforms default deletion behavior`);
+                    }
+                    processedSchema.transformsDelete = true;
+                }
             }
         }
         const fields = processFields(schema.fields);
         processedSchema.fields.push(...fields);
+        processedSchema.patternNames = patternNames;
         if (schema.edges) {
             const edges = processEdges(schema.edges);
             processedSchema.assocEdges.push(...edges);
@@ -185,6 +251,22 @@ function parseSchema(potentialSchemas) {
         }
         schemas[key] = processedSchema;
     }
-    return { schemas, patterns };
+    return { schemas, patterns, globalSchema: parsedGlobalSchema };
 }
 exports.parseSchema = parseSchema;
+function parseGlobalSchema(s) {
+    const ret = {
+        globalEdges: [],
+        extraEdgeFields: [],
+        initForEdges: !!s.extraEdgeFields ||
+            s.transformEdgeRead !== undefined ||
+            s.transformEdgeWrite !== undefined,
+    };
+    if (s.extraEdgeFields) {
+        ret.extraEdgeFields = processFields(s.extraEdgeFields);
+    }
+    if (s.edges) {
+        ret.globalEdges = processEdges(s.edges);
+    }
+    return ret;
+}

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,6 +1,6 @@
 "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 = {
@@ -66,9 +66,56 @@ let nodeFieldsWithTZ = {
 exports.Node = {
     name: "node",
     fields: nodeFields,
+    disableMixin: true,
 };
-// 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,
+                disableMixin: true,
+            },
+        ];
+        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 +125,7 @@ class BaseEntSchema {
     }
 }
 exports.BaseEntSchema = BaseEntSchema;
+// @deprecated use EntSchemaWithTZ
 class BaseEntSchemaWithTZ {
     constructor() {
         this.patterns = [
@@ -85,6 +133,7 @@ class BaseEntSchemaWithTZ {
                 // default schema added
                 name: "nodeWithTZ",
                 fields: nodeFieldsWithTZ,
+                disableMixin: true,
             },
         ];
     }

package/schema/field.d.ts

@@ -44,7 +44,7 @@ export declare function IntegerType(options?: IntegerOptions): IntegerField;
 export declare class BigIntegerField extends BaseField implements Field {
     type: Type;
 }
-export declare function BigIntegerType(options: FieldOptions): BigIntegerField;
+export declare function BigIntegerType(options?: FieldOptions): BigIntegerField;
 export declare class FloatField extends BaseField implements Field {
     type: Type;
 }
@@ -118,26 +118,53 @@ export declare class DateField extends BaseField implements Field {
     format(val: any): any;
 }
 export declare function DateType(options?: FieldOptions): DateField;
-declare type EnumMap = {
+declare type StringEnumMap = {
     [key: string]: string;
 };
+/**
+ * @deprecated use StringEnumOptions
+ */
 export interface EnumOptions extends FieldOptions {
     values?: string[];
-    map?: EnumMap;
+    map?: StringEnumMap;
     tsType?: string;
     graphQLType?: string;
     createEnumType?: boolean;
 }
+export interface StringEnumOptions extends EnumOptions {
+}
+/**
+ * @deprecated Use StringEnumField
+ */
 export declare class EnumField extends BaseField implements Field {
     type: Type;
     private values?;
     private map?;
-    constructor(options: EnumOptions);
+    constructor(options: StringEnumOptions);
     convertForGQL(value: string): string;
     valid(val: any): boolean;
     format(val: any): any;
 }
-export declare function EnumType(options: EnumOptions): EnumField;
+export declare class StringEnumField extends EnumField {
+}
+export declare function EnumType(options: StringEnumOptions): EnumField;
+declare type IntEnumMap = {
+    [key: string]: number;
+};
+export interface IntegerEnumOptions extends FieldOptions {
+    map: IntEnumMap;
+    deprecated?: IntEnumMap;
+    tsType?: string;
+    graphQLType?: string;
+}
+export declare class IntegerEnumField extends BaseField implements Field {
+    type: Type;
+    private map;
+    constructor(options: IntegerEnumOptions);
+    valid(val: any): boolean;
+    format(val: any): any;
+}
+export declare function IntegerEnumType(options: IntegerEnumOptions): IntegerEnumField;
 export declare class ListField extends BaseField {
     private field;
     type: Type;
@@ -163,6 +190,7 @@ export declare function TimestamptzListType(options?: TimestampOptions): ListFie
 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 EnumListType(options: StringEnumOptions): ListField;
+export declare function IntegerEnumListType(options: IntegerEnumOptions): ListField;
 export declare function UUIDListType(options?: FieldOptions): ListField;
 export {};

package/schema/field.js

@@ -19,12 +19,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 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;
+exports.UUIDListType = exports.IntegerEnumListType = 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.IntegerEnumType = exports.IntegerEnumField = exports.EnumType = exports.StringEnumField = 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 db_1 = __importStar(require("../core/db"));
 const schema_1 = require("./schema");
 const util_1 = require("util");
+const uuid_1 = require("uuid");
 class BaseField {
     logValue(val) {
         if (this.sensitive) {
@@ -92,6 +93,9 @@ class UUIDField extends BaseField {
         return val.placeholderID !== undefined;
     }
     async valid(val) {
+        if (typeof val === "string" && !(0, uuid_1.validate)(val)) {
+            return false;
+        }
         if (!this.options?.fieldEdge?.enforceSchema) {
             return true;
         }
@@ -444,6 +448,9 @@ function DateType(options) {
     return Object.assign(result, options);
 }
 exports.DateType = DateType;
+/**
+ * @deprecated Use StringEnumField
+ */
 class EnumField extends BaseField {
     constructor(options) {
         super();
@@ -546,11 +553,57 @@ class EnumField extends BaseField {
     }
 }
 exports.EnumField = EnumField;
+class StringEnumField extends EnumField {
+}
+exports.StringEnumField = StringEnumField;
 function EnumType(options) {
-    let result = new EnumField(options);
+    let result = new StringEnumField(options);
     return Object.assign(result, options);
 }
 exports.EnumType = EnumType;
+class IntegerEnumField extends BaseField {
+    constructor(options) {
+        super();
+        this.type = {
+            dbType: schema_1.DBType.IntEnum,
+            intEnumMap: options.map,
+            type: options.tsType,
+            graphQLType: options.graphQLType,
+            deprecatedIntEnumMap: options.deprecated,
+        };
+        let count = 0;
+        for (const k in options.map) {
+            count++;
+            break;
+        }
+        if (!count) {
+            throw new Error("need at least one entry in enum map");
+        }
+        if (options.foreignKey) {
+            throw new Error(`foreignKey on intEnum not supported`);
+        }
+        this.map = options.map;
+    }
+    valid(val) {
+        // lookup table enum and indicated via presence of foreignKey
+        for (const k in this.map) {
+            const v = this.map[k];
+            if (v === val || v === parseInt(val)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    format(val) {
+        return parseInt(val);
+    }
+}
+exports.IntegerEnumField = IntegerEnumField;
+function IntegerEnumType(options) {
+    let result = new IntegerEnumField(options);
+    return Object.assign(result, options);
+}
+exports.IntegerEnumType = IntegerEnumType;
 class ListField extends BaseField {
     constructor(field, options) {
         super();
@@ -593,6 +646,10 @@ class ListField extends BaseField {
     }
     postgresVal(val, jsonType) {
         if (!jsonType) {
+            // support empty strings in list
+            if (val === "") {
+                val = '"' + val + '"';
+            }
             return val;
         }
         return JSON.stringify(val);
@@ -616,7 +673,7 @@ class ListField extends BaseField {
         for (let i = 0; i < val.length; i++) {
             let formatted = val[i];
             if (this.field.format) {
-                formatted = this.field.format(val[i]);
+                formatted = this.field.format(val[i], nested);
             }
             // postgres supports arrays natively so we
             // structure it in the expected format
@@ -720,6 +777,14 @@ function EnumListType(options) {
     return new ListField(EnumType(options), options);
 }
 exports.EnumListType = EnumListType;
+function IntegerEnumListType(options) {
+    // not all of these will make sense in a list...
+    // can make it work eventually but involves work we're not currently trying to do
+    // developer can try to work around it by calling below on their own.
+    // unclear what the behavior is
+    return new ListField(IntegerEnumType(options), options);
+}
+exports.IntegerEnumListType = IntegerEnumListType;
 function UUIDListType(options) {
     return new ListField(UUIDType(options), options);
 }

package/schema/index.d.ts

@@ -1,7 +1,7 @@
 import Schema from "./schema";
 export { 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 { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, getFieldsWithPrivacy, getStorageKey, ActionOperation, Action, EdgeAction, NoFields, FieldMap, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, UpdateOperation, TransformedUpdateOperation, SQLStatementOperation, EdgeUpdateOperation, TransformedEdgeUpdateOperation, getTransformedReadClause, getObjectLoaderProperties, GlobalSchema, } from "./schema";
+export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, EntSchema, EntSchemaWithTZ, SchemaConfig, } from "./base_schema";
 export * from "./field";
 export * from "./json_field";
 export * from "./struct_field";

package/schema/index.js

@@ -10,20 +10,27 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = exports.optionalField = exports.requiredField = exports.ConstraintType = exports.NoFields = exports.ActionOperation = exports.getFields = exports.DBType = void 0;
+exports.EntSchemaWithTZ = exports.EntSchema = exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.SQLStatementOperation = exports.optionalField = exports.requiredField = exports.ConstraintType = exports.NoFields = exports.ActionOperation = exports.getStorageKey = exports.getFieldsWithPrivacy = exports.getFields = exports.DBType = void 0;
 var schema_1 = require("./schema");
 Object.defineProperty(exports, "DBType", { enumerable: true, get: function () { return schema_1.DBType; } });
 Object.defineProperty(exports, "getFields", { enumerable: true, get: function () { return schema_1.getFields; } });
+Object.defineProperty(exports, "getFieldsWithPrivacy", { enumerable: true, get: function () { return schema_1.getFieldsWithPrivacy; } });
+Object.defineProperty(exports, "getStorageKey", { enumerable: true, get: function () { return schema_1.getStorageKey; } });
 Object.defineProperty(exports, "ActionOperation", { enumerable: true, get: function () { return schema_1.ActionOperation; } });
 Object.defineProperty(exports, "NoFields", { enumerable: true, get: function () { return schema_1.NoFields; } });
 Object.defineProperty(exports, "ConstraintType", { enumerable: true, get: function () { return schema_1.ConstraintType; } });
 Object.defineProperty(exports, "requiredField", { enumerable: true, get: function () { return schema_1.requiredField; } });
 Object.defineProperty(exports, "optionalField", { enumerable: true, get: function () { return schema_1.optionalField; } });
+Object.defineProperty(exports, "SQLStatementOperation", { enumerable: true, get: function () { return schema_1.SQLStatementOperation; } });
+Object.defineProperty(exports, "getTransformedReadClause", { enumerable: true, get: function () { return schema_1.getTransformedReadClause; } });
+Object.defineProperty(exports, "getObjectLoaderProperties", { enumerable: true, get: function () { return schema_1.getObjectLoaderProperties; } });
 var base_schema_1 = require("./base_schema");
 Object.defineProperty(exports, "Timestamps", { enumerable: true, get: function () { return base_schema_1.Timestamps; } });
 Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return base_schema_1.Node; } });
 Object.defineProperty(exports, "BaseEntSchema", { enumerable: true, get: function () { return base_schema_1.BaseEntSchema; } });
 Object.defineProperty(exports, "BaseEntSchemaWithTZ", { enumerable: true, get: function () { return base_schema_1.BaseEntSchemaWithTZ; } });
+Object.defineProperty(exports, "EntSchema", { enumerable: true, get: function () { return base_schema_1.EntSchema; } });
+Object.defineProperty(exports, "EntSchemaWithTZ", { enumerable: true, get: function () { return base_schema_1.EntSchemaWithTZ; } });
 __exportStar(require("./field"), exports);
 __exportStar(require("./json_field"), exports);
 __exportStar(require("./struct_field"), exports);