@snowtop/ent 0.1.0-alpha7 → 0.1.0-alpha75

package/index.js

@@ -25,8 +25,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.AllowIfFuncRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedOutRule = exports.DenyIfLoggedInRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = exports.DB = exports.getEdgeTypeInGroup = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadEdges = exports.loadEdgeDatas = exports.loadEdgeData = exports.AssocEdgeData = exports.AssocEdge = exports.DeleteNodeOperation = exports.EdgeOperation = exports.EditNodeOperation = exports.loadRows = exports.loadRow = exports.loadRowX = exports.performRawQuery = exports.applyPrivacyPolicyForEntX = exports.applyPrivacyPolicyForEnt = exports.loadEntXViaKey = exports.loadEntViaKey = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadEnts = exports.loadEntX = exports.loadCustomEnts = exports.loadCustomData = exports.loadEnt = void 0;
-exports.setLogLevels = exports.loadConfig = exports.LoggedOutViewer = exports.IDViewer = exports.ContextCache = exports.query = exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.AllowIfConditionAppliesRule = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.DelayedResultRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = void 0;
+exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.AllowIfFuncRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedOutRule = exports.DenyIfLoggedInRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = exports.DB = exports.setGlobalSchema = exports.getEdgeTypeInGroup = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadEdges = exports.loadEdgeDatas = exports.loadEdgeData = exports.AssocEdgeData = exports.AssocEdge = exports.DeleteNodeOperation = exports.EdgeOperation = exports.EditNodeOperation = exports.loadRows = exports.loadRow = exports.loadRowX = exports.performRawQuery = exports.loadEntXViaKey = exports.loadEntViaKey = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadEnts = exports.loadEntX = exports.loadCustomEnts = exports.loadCustomData = exports.loadEnt = void 0;
+exports.setLogLevels = exports.loadConfig = exports.LoggedOutViewer = exports.IDViewer = exports.ContextCache = exports.query = exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.AllowIfConditionAppliesRule = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.DelayedResultRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = void 0;
 __exportStar(require("./core/base"), exports);
 var ent_1 = require("./core/ent");
 Object.defineProperty(exports, "loadEnt", { enumerable: true, get: function () { return ent_1.loadEnt; } });
@@ -38,8 +38,6 @@ Object.defineProperty(exports, "loadDerivedEnt", { enumerable: true, get: functi
 Object.defineProperty(exports, "loadDerivedEntX", { enumerable: true, get: function () { return ent_1.loadDerivedEntX; } });
 Object.defineProperty(exports, "loadEntViaKey", { enumerable: true, get: function () { return ent_1.loadEntViaKey; } });
 Object.defineProperty(exports, "loadEntXViaKey", { enumerable: true, get: function () { return ent_1.loadEntXViaKey; } });
-Object.defineProperty(exports, "applyPrivacyPolicyForEnt", { enumerable: true, get: function () { return ent_1.applyPrivacyPolicyForEnt; } });
-Object.defineProperty(exports, "applyPrivacyPolicyForEntX", { enumerable: true, get: function () { return ent_1.applyPrivacyPolicyForEntX; } });
 Object.defineProperty(exports, "performRawQuery", { enumerable: true, get: function () { return ent_1.performRawQuery; } });
 // even these 3 need to change...
 Object.defineProperty(exports, "loadRowX", { enumerable: true, get: function () { return ent_1.loadRowX; } });
@@ -59,10 +57,11 @@ Object.defineProperty(exports, "loadRawEdgeCountX", { enumerable: true, get: fun
 Object.defineProperty(exports, "loadEdgeForID2", { enumerable: true, get: function () { return ent_1.loadEdgeForID2; } });
 Object.defineProperty(exports, "loadNodesByEdge", { enumerable: true, get: function () { return ent_1.loadNodesByEdge; } });
 Object.defineProperty(exports, "getEdgeTypeInGroup", { enumerable: true, get: function () { return ent_1.getEdgeTypeInGroup; } });
+Object.defineProperty(exports, "setGlobalSchema", { enumerable: true, get: function () { return ent_1.setGlobalSchema; } });
 const db_1 = __importDefault(require("./core/db"));
 exports.DB = db_1.default;
 __exportStar(require("./core/loaders"), exports);
-// TODO figure out if this should be its own
+// TODO figure out if this should be its own import path e.g. @snowtop/ent/privacy
 var privacy_1 = require("./core/privacy");
 Object.defineProperty(exports, "EntPrivacyError", { enumerable: true, get: function () { return privacy_1.EntPrivacyError; } });
 Object.defineProperty(exports, "AlwaysAllowRule", { enumerable: true, get: function () { return privacy_1.AlwaysAllowRule; } });
@@ -109,12 +108,32 @@ const query = {
     Eq: q.Eq,
     NotEq: q.NotEq,
     And: q.And,
+    AndOptional: q.AndOptional,
     Or: q.Or,
     In: q.In,
     Greater: q.Greater,
     Less: q.Less,
     GreaterEq: q.GreaterEq,
     LessEq: q.LessEq,
+    ArrayEq: q.ArrayEq,
+    ArrayNotEq: q.ArrayNotEq,
+    PostgresArrayContainsValue: q.PostgresArrayContainsValue,
+    PostgresArrayContains: q.PostgresArrayContains,
+    PostgresArrayNotContainsValue: q.PostgresArrayNotContainsValue,
+    PostgresArrayNotContains: q.PostgresArrayNotContains,
+    PostgresArrayOverlaps: q.PostgresArrayOverlaps,
+    PostgresArrayNotOverlaps: q.PostgresArrayNotOverlaps,
+    JSONPathValuePredicate: q.JSONPathValuePredicate,
+    JSONObjectFieldKeyASJSON: q.JSONObjectFieldKeyASJSON,
+    JSONObjectFieldKeyAsText: q.JSONObjectFieldKeyAsText,
+    TsQuery: q.TsQuery,
+    PlainToTsQuery: q.PlainToTsQuery,
+    PhraseToTsQuery: q.PhraseToTsQuery,
+    WebsearchToTsQuery: q.WebsearchToTsQuery,
+    TsVectorColTsQuery: q.TsVectorColTsQuery,
+    TsVectorPlainToTsQuery: q.TsVectorPlainToTsQuery,
+    TsVectorPhraseToTsQuery: q.TsVectorPhraseToTsQuery,
+    TsVectorWebsearchToTsQuery: q.TsVectorWebsearchToTsQuery,
 };
 exports.query = query;
 var context_1 = require("./core/context");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha7",
+  "version": "0.1.0-alpha75",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -17,7 +17,7 @@
     "json5": "^2.1.3",
     "luxon": "^1.25.0",
     "memoizee": "^0.4.15",
-    "minimist": "^1.2.5",
+    "minimist": "^1.2.6",
     "pascal-case": "^3.1.2",
     "pg": "^8.0.3",
     "prettier": "^2.3.2",
@@ -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, Type } from "../schema";
-import { ActionField } from "../schema/schema";
+import { Schema, Field, AssocEdge, AssocEdgeGroup, Action } from "../schema";
+import { ActionField, Type, GlobalSchema } from "../schema/schema";
 declare enum NullableResult {
     CONTENTS = "contents",
     CONTENTS_AND_LIST = "contentsAndList",
@@ -12,11 +12,19 @@ declare type ProcessedAssocEdge = Omit<AssocEdge, "actionOnlyFields" | "edgeActi
     patternName?: string;
     edgeActions?: OutputAction[];
 };
-declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" | "fields"> & {
+interface TransformFlags {
+    transformsSelect?: boolean;
+    transformsDelete?: boolean;
+    transformsInsert?: boolean;
+    transformsUpdate?: boolean;
+}
+declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" | "fields"> & TransformFlags & {
     actions: OutputAction[];
     assocEdges: ProcessedAssocEdge[];
     assocEdgeGroups: ProcessedAssocEdgeGroup[];
     fields: ProcessedField[];
+    schemaPath?: string;
+    patternNames?: string[];
 };
 declare type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
     edgeAction?: OutputAction;
@@ -31,17 +39,19 @@ interface ProcessedPattern {
     name: string;
     assocEdges: ProcessedAssocEdge[];
     fields: ProcessedField[];
+    disableMixin?: boolean;
 }
 declare type ProcessedType = Omit<Type, "subFields" | "listElemType" | "unionFields"> & {
     subFields?: ProcessedField[];
     listElemType?: ProcessedType;
     unionFields?: ProcessedField[];
 };
-declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate" | "type"> & {
+declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate" | "privacyPolicy" | "type"> & {
     name: string;
     hasDefaultValueOnCreate?: boolean;
     hasDefaultValueOnEdit?: boolean;
     patternName?: string;
+    hasFieldPrivacy?: boolean;
     derivedFields?: ProcessedField[];
     type: ProcessedType;
 };
@@ -51,6 +61,15 @@ interface patternsDict {
 interface Result {
     schemas: schemasDict;
     patterns: patternsDict;
+    globalSchema?: ProcessedGlobalSchema;
+}
+declare type PotentialSchemas = {
+    [key: string]: any;
+};
+export declare function parseSchema(potentialSchemas: PotentialSchemas, globalSchema?: GlobalSchema): Result;
+interface ProcessedGlobalSchema {
+    globalEdges: ProcessedAssocEdge[];
+    extraEdgeFields: ProcessedField[];
+    initForEdges?: boolean;
 }
-export declare function parseSchema(potentialSchemas: {}): Result;
 export {};

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);
@@ -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";