@snowtop/ent 0.1.0-alpha → 0.1.0-alpha12

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.DenyIfViewerInboundEdgeDoesNotExistRule = 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.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 = 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; } });
@@ -62,7 +60,7 @@ Object.defineProperty(exports, "getEdgeTypeInGroup", { enumerable: true, get: fu
 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 +107,27 @@ 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,
+    ArrayGreater: q.ArrayGreater,
+    ArrayLess: q.ArrayLess,
+    ArrayGreaterEq: q.ArrayGreaterEq,
+    ArrayLessEq: q.ArrayLessEq,
+    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-alpha",
+  "version": "0.1.0-alpha12",
   "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 } from "../schema";
-import { ActionField } from "../schema/schema";
+import { ActionField, Type } from "../schema/schema";
 declare enum NullableResult {
     CONTENTS = "contents",
     CONTENTS_AND_LIST = "contentsAndList",
@@ -12,11 +12,18 @@ 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;
 };
 declare type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
     edgeAction?: OutputAction;
@@ -32,10 +39,19 @@ interface ProcessedPattern {
     assocEdges: ProcessedAssocEdge[];
     fields: ProcessedField[];
 }
-declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate"> & {
+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;
@@ -44,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,10 +3,26 @@ 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;
         if (field.polymorphic) {
             // convert boolean into object
             // we keep boolean as an option to keep API simple
@@ -17,6 +33,9 @@ function processFields(src, patternName) {
                 f.polymorphic = field.polymorphic;
             }
         }
+        else {
+            delete f.polymorphic;
+        }
         // convert string to object to make API consumed by go simple
         if (f.fieldEdge && f.fieldEdge.inverseEdge) {
             if (typeof f.fieldEdge.inverseEdge === "string") {
@@ -28,10 +47,44 @@ function processFields(src, patternName) {
         if (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;
 }
+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) {
@@ -56,6 +109,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);
@@ -63,6 +119,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 || []);
@@ -76,6 +136,7 @@ function processPattern(patterns, pattern, processedSchema) {
         // 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) {
@@ -91,6 +152,7 @@ function processAction(action) {
     let actionOnlyFields = action.actionOnlyFields.map((f) => {
         let f2 = f;
         if (!f.nullable) {
+            delete f2.nullable;
             return f2;
         }
         if (typeof f.nullable === "boolean") {
@@ -115,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,
@@ -137,7 +204,19 @@ function parseSchema(potentialSchemas) {
         // ¯\_(ツ)_/¯
         if (schema.patterns) {
             for (const pattern of schema.patterns) {
-                processPattern(patterns, pattern, processedSchema);
+                const ret = processPattern(patterns, pattern, processedSchema);
+                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);

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