@snowtop/ent 0.1.0-alpha15 → 0.1.0-alpha150

package/schema/field.d.ts

@@ -1,3 +1,4 @@
+import { Builder } from "../action/action";
 import { Field, FieldMap, FieldOptions, ForeignKey, PolymorphicOptions, Type } from "./schema";
 export declare abstract class BaseField {
     name: string;
@@ -24,31 +25,36 @@ export declare class UUIDField extends BaseField implements Field {
     valid(val: any): Promise<boolean>;
 }
 export declare function UUIDType(options?: FieldOptions): UUIDField;
-export interface IntegerOptions extends FieldOptions {
-    min?: number;
-    max?: number;
+export interface IntegerOptions extends NumberOptions<number> {
 }
-export declare class IntegerField extends BaseField implements Field {
+export interface NumberOptions<T> extends FieldOptions {
+    min?: T;
+    max?: T;
+}
+export declare class NumberField<T> extends BaseField {
     type: Type;
     private validators;
     private options;
-    constructor(options?: IntegerOptions);
-    getOptions(): IntegerOptions;
+    constructor(options?: NumberOptions<T>);
+    getOptions(): NumberOptions<T>;
     private handleOptions;
-    min(l: number): this;
-    max(l: number): this;
+    min(l: T): this;
+    max(l: T): this;
     valid(val: any): boolean;
     validate(validator: (str: number) => boolean): this;
 }
+export declare class IntegerField extends NumberField<number> implements Field {
+    type: Type;
+}
 export declare function IntegerType(options?: IntegerOptions): IntegerField;
-export declare class BigIntegerField extends BaseField implements Field {
+export declare class BigIntegerField extends NumberField<BigInt> implements Field {
     type: Type;
 }
-export declare function BigIntegerType(options: FieldOptions): BigIntegerField;
-export declare class FloatField extends BaseField implements Field {
+export declare function BigIntegerType(options?: NumberOptions<BigInt>): BigIntegerField;
+export declare class FloatField extends NumberField<number> implements Field {
     type: Type;
 }
-export declare function FloatType(options?: FieldOptions): FloatField;
+export declare function FloatType(options?: NumberOptions<number>): FloatField;
 export declare class BooleanField extends BaseField implements Field {
     type: Type;
 }
@@ -88,6 +94,18 @@ export declare class StringField extends BaseField implements Field {
     trimLeft(): this;
     trimRight(): this;
 }
+interface PolymorphicStringOptions extends StringOptions {
+    parentFieldToValidate: string;
+    types?: string[];
+}
+export declare class PolymorphicStringField extends StringField {
+    private opts;
+    private camelCaseVals;
+    constructor(opts: PolymorphicStringOptions);
+    validateWithFullData(val: any, b: Builder<any>): boolean;
+    valid(val: any): boolean;
+    format(val: any): any;
+}
 export declare function StringType(options?: StringOptions): StringField;
 export interface TimestampOptions extends FieldOptions {
     withTimezone?: boolean;
@@ -118,31 +136,69 @@ 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;
+    disableUnknownType?: boolean;
+    globalType?: string;
 }
+/**
+ * @deprecated Use StringEnumField
+ */
 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;
+    constructor(options: StringEnumOptions);
+    valid(val: any): Promise<boolean>;
+    format(val: any): any;
+}
+export declare class StringEnumField extends EnumField {
+}
+export interface PolymorphicStringEnumOptions extends EnumOptions {
+    parentFieldToValidate: string;
+}
+export interface StringEnumOptions extends EnumOptions {
+}
+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;
+    disableUnknownType?: boolean;
+    globalType?: string;
+}
+export declare class IntegerEnumField extends BaseField implements Field {
+    type: Type;
+    private map;
+    constructor(options: IntegerEnumOptions);
+    valid(val: any): Promise<boolean>;
     format(val: any): any;
 }
-export declare function EnumType(options: EnumOptions): EnumField;
+export declare function IntegerEnumType(options: IntegerEnumOptions): IntegerEnumField;
+interface ListOptions extends FieldOptions {
+    disableJSONStringify?: boolean;
+}
 export declare class ListField extends BaseField {
     private field;
+    private options?;
     type: Type;
     private validators;
-    constructor(field: Field, options?: FieldOptions);
+    constructor(field: Field, options?: ListOptions | undefined);
+    __getElemField(): Field;
     validate(validator: (val: any[]) => boolean): this;
     valid(val: any): Promise<boolean>;
     private postgresVal;
@@ -153,7 +209,7 @@ export declare class ListField extends BaseField {
     range(start: any, stop: any): this;
 }
 export declare function StringListType(options?: StringOptions): ListField;
-export declare function IntListType(options: FieldOptions): 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;
@@ -163,6 +219,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

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -19,12 +23,16 @@ 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.PolymorphicStringField = exports.StringField = exports.BooleanType = exports.BooleanField = exports.FloatType = exports.FloatField = exports.BigIntegerType = exports.BigIntegerField = exports.IntegerType = exports.IntegerField = exports.NumberField = exports.UUIDType = exports.UUIDField = exports.BaseField = void 0;
 const luxon_1 = require("luxon");
-const snake_case_1 = require("snake-case");
+const camel_case_1 = require("camel-case");
+const util_1 = require("util");
+const uuid_1 = require("uuid");
+const base_1 = require("../core/base");
 const db_1 = __importStar(require("../core/db"));
 const schema_1 = require("./schema");
-const util_1 = require("util");
+const global_schema_1 = require("../core/global_schema");
+const logger_1 = require("../core/logger");
 class BaseField {
     logValue(val) {
         if (this.sensitive) {
@@ -60,31 +68,26 @@ class UUIDField extends BaseField {
             else {
                 throw new Error(`unsupported id polymorhpic type ${fieldName}`);
             }
+            let types;
+            let serverDefault = undefined;
+            if (typeof polymorphic === "object") {
+                serverDefault = polymorphic.serverDefault;
+                types = polymorphic.types;
+            }
             // polymorphic field automatically hidden from GraphQL
             // can be made visible with custom fields if user wants to change this behavior
             // can't be foreignKey so need to make other changes to the field
             // intentionally not made private as it doesn't seem like it needs to be hidden
-            if (typeof polymorphic === "object" && polymorphic.types) {
-                // an enum with types validated here
-                return {
-                    [name]: EnumType({
-                        values: polymorphic.types,
-                        hideFromGraphQL: true,
-                        derivedWhenEmbedded: true,
-                        nullable: this.options?.nullable,
-                    }),
-                };
-            }
-            else {
-                // just a string field...
-                return {
-                    [name]: StringType({
-                        hideFromGraphQL: true,
-                        derivedWhenEmbedded: true,
-                        nullable: this.options?.nullable,
-                    }),
-                };
-            }
+            return {
+                [name]: PolymorphicStringType({
+                    types: types,
+                    hideFromGraphQL: true,
+                    derivedWhenEmbedded: true,
+                    nullable: this.options?.nullable,
+                    parentFieldToValidate: fieldName,
+                    serverDefault: serverDefault,
+                }),
+            };
         }
         return {};
     }
@@ -92,6 +95,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;
         }
@@ -115,9 +121,10 @@ function UUIDType(options) {
     return Object.assign(result, options);
 }
 exports.UUIDType = UUIDType;
-class IntegerField extends BaseField {
+class NumberField extends BaseField {
     constructor(options) {
         super();
+        // to be overriden as needed
         this.type = { dbType: schema_1.DBType.Int };
         this.validators = [];
         this.options = {};
@@ -141,9 +148,11 @@ class IntegerField extends BaseField {
         this.options = options;
     }
     min(l) {
+        // @ts-ignore Operator '>=' cannot be applied to types 'number' and 'T'.
         return this.validate((val) => val >= l);
     }
     max(l) {
+        // @ts-ignore Operator '<=' cannot be applied to types 'number' and 'T'.
         return this.validate((val) => val <= l);
     }
     valid(val) {
@@ -159,13 +168,20 @@ class IntegerField extends BaseField {
         return this;
     }
 }
+exports.NumberField = NumberField;
+class IntegerField extends NumberField {
+    constructor() {
+        super(...arguments);
+        this.type = { dbType: schema_1.DBType.Int };
+    }
+}
 exports.IntegerField = IntegerField;
 function IntegerType(options) {
     let result = new IntegerField(options);
     return Object.assign(result, options);
 }
 exports.IntegerType = IntegerType;
-class BigIntegerField extends BaseField {
+class BigIntegerField extends NumberField {
     constructor() {
         super(...arguments);
         this.type = { dbType: schema_1.DBType.BigInt };
@@ -173,11 +189,11 @@ class BigIntegerField extends BaseField {
 }
 exports.BigIntegerField = BigIntegerField;
 function BigIntegerType(options) {
-    let result = new BigIntegerField();
+    let result = new BigIntegerField(options);
     return Object.assign(result, options);
 }
 exports.BigIntegerType = BigIntegerType;
-class FloatField extends BaseField {
+class FloatField extends NumberField {
     constructor() {
         super(...arguments);
         this.type = { dbType: schema_1.DBType.Float };
@@ -185,7 +201,7 @@ class FloatField extends BaseField {
 }
 exports.FloatField = FloatField;
 function FloatType(options) {
-    let result = new FloatField();
+    let result = new FloatField(options);
     return Object.assign(result, options);
 }
 exports.FloatType = FloatType;
@@ -307,6 +323,58 @@ class StringField extends BaseField {
     }
 }
 exports.StringField = StringField;
+class PolymorphicStringField extends StringField {
+    constructor(opts) {
+        super(opts);
+        this.opts = opts;
+        if (opts.types) {
+            this.camelCaseVals = opts.types.map((v) => (0, camel_case_1.camelCase)(v));
+        }
+    }
+    validateWithFullData(val, b) {
+        const input = b.getInput();
+        const inputKey = b.orchestrator.__getOptions().fieldInfo[this.opts.parentFieldToValidate]
+            .inputKey;
+        const v = input[inputKey];
+        if (val === null) {
+            // if this is being set to null, ok if v is also null
+            return v === null;
+        }
+        // if this is not being set, ok if v is not being set
+        if (val === undefined && b.operation === base_1.WriteOperation.Insert) {
+            return v === undefined;
+        }
+        return true;
+    }
+    valid(val) {
+        if (!this.camelCaseVals) {
+            return true;
+        }
+        let str = (0, camel_case_1.camelCase)(String(val));
+        // allow different cases because it could be coming from different clients who don't have strong typing
+        return this.camelCaseVals.some((value) => value === str);
+    }
+    format(val) {
+        if (!this.camelCaseVals) {
+            return val;
+        }
+        const converted = (0, camel_case_1.camelCase)(String(val));
+        for (const v of this.camelCaseVals) {
+            if (v === val) {
+                return val;
+            }
+            if (converted === v) {
+                return converted;
+            }
+        }
+        return val;
+    }
+}
+exports.PolymorphicStringField = PolymorphicStringField;
+function PolymorphicStringType(opts) {
+    let result = new PolymorphicStringField(opts);
+    return Object.assign(result, opts);
+}
 function StringType(options) {
     let result = new StringField(options);
     const options2 = { ...options };
@@ -426,9 +494,10 @@ class DateField extends BaseField {
         this.type = { dbType: schema_1.DBType.Date };
     }
     format(val) {
-        if (!(val instanceof Date)) {
+        if (typeof val === "string") {
             return val;
         }
+        val = new Date(val);
         let yy = (0, exports.leftPad)(val.getFullYear());
         // lol this API
         // for some reason this is 0-index
@@ -444,6 +513,9 @@ function DateType(options) {
     return Object.assign(result, options);
 }
 exports.DateType = DateType;
+/**
+ * @deprecated Use StringEnumField
+ */
 class EnumField extends BaseField {
     constructor(options) {
         super();
@@ -454,10 +526,12 @@ class EnumField extends BaseField {
             enumMap: options.map,
             type: options.tsType,
             graphQLType: options.graphQLType,
+            disableUnknownType: options.disableUnknownType,
+            globalType: options.globalType,
         };
         if (!options.foreignKey) {
-            if (!options.values && !options.map) {
-                throw new Error("values or map required if not look up table enum. Look-up table enum indicated by foreignKey field");
+            if (!options.values && !options.map && !options.globalType) {
+                throw new Error("values, map or globalType required if not look up table enum. Look-up table enum indicated by foreignKey field");
             }
             if (options.values) {
                 if (!options.values.length) {
@@ -466,7 +540,7 @@ class EnumField extends BaseField {
             }
             if (options.map) {
                 let count = 0;
-                for (const k in options.map) {
+                for (const _ in options.map) {
                     count++;
                     break;
                 }
@@ -476,8 +550,8 @@ class EnumField extends BaseField {
             }
         }
         else {
-            if (options.values || options.map) {
-                throw new Error("cannot specify values or map and foreign key for lookup table enum type");
+            if (options.values || options.map || options.globalType) {
+                throw new Error("cannot specify values, map or globalType and foreign key for lookup table enum type");
             }
             if (options.createEnumType) {
                 throw new Error("cannot specify createEnumType without specifying values");
@@ -492,69 +566,136 @@ class EnumField extends BaseField {
         this.values = options.values;
         this.map = options.map;
     }
-    // TODO need to update this for map
-    convertForGQL(value) {
-        return (0, snake_case_1.snakeCase)(value).toUpperCase();
-    }
-    valid(val) {
+    async valid(val) {
+        if (this.type.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            if (f) {
+                if (f.valid) {
+                    return f.valid(val);
+                }
+                return true;
+            }
+            else {
+                (0, logger_1.log)("error", `globalType ${this.type.globalType} not found in global schema`);
+                return false;
+            }
+        }
         // lookup table enum and indicated via presence of foreignKey
         if (!this.values && !this.map) {
             return true;
         }
         if (this.values) {
             let str = String(val);
-            return this.values.some((value) => value === str || this.convertForGQL(value) === str);
+            return this.values.some((value) => value === str);
         }
         for (const k in this.map) {
             const v = this.map[k];
-            if (v === val || this.convertForGQL(k) === val) {
-                // TODO decide on behavior for GQL since GQL only supports one type
+            if (v === val) {
                 return true;
             }
         }
         return false;
     }
     format(val) {
-        // TODO need to format correctly for graphql purposes...
-        // how to best get the values in the db...
-        if (!this.values && !this.map) {
+        if (this.type.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            if (f && f.format) {
+                return f.format(val);
+            }
             return val;
         }
-        let str = String(val);
-        if (this.values) {
-            for (let i = 0; i < this.values.length; i++) {
-                let value = this.values[i];
-                // store the format that maps to the given value in the db instead of saving the upper case value
-                if (str === value || str === this.convertForGQL(value)) {
-                    return value;
-                }
+        return val;
+    }
+}
+exports.EnumField = EnumField;
+class StringEnumField extends EnumField {
+}
+exports.StringEnumField = StringEnumField;
+function EnumType(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,
+            disableUnknownType: options.disableUnknownType,
+            globalType: options.globalType,
+        };
+        if (options.foreignKey) {
+            throw new Error(`foreignKey on intEnum not supported`);
+        }
+        if (options.globalType) {
+            if (options.map) {
+                throw new Error(`cannot specify map and globalType`);
             }
+            this.map = {};
         }
-        if (this.map) {
-            for (const k in this.map) {
-                const v = this.map[k];
-                if (str === v) {
-                    return v;
-                }
-                if (str === this.convertForGQL(k)) {
-                    return v;
+        else {
+            let count = 0;
+            for (const _ in options.map) {
+                count++;
+                break;
+            }
+            if (!count) {
+                throw new Error("need at least one entry in enum map");
+            }
+            if (!options.map) {
+                throw new Error("map required if not globalType");
+            }
+            this.map = options.map;
+        }
+    }
+    async valid(val) {
+        if (this.type?.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            if (f) {
+                if (f.valid) {
+                    return f.valid(val);
                 }
+                return true;
+            }
+            else {
+                (0, logger_1.log)("error", `globalType ${this.type.globalType} not found in global schema`);
+                return false;
             }
         }
-        // whelp, just return what's passed
-        return 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) {
+        if (this.type.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            if (f && f.format) {
+                return f.format(val);
+            }
+        }
+        return parseInt(val);
     }
 }
-exports.EnumField = EnumField;
-function EnumType(options) {
-    let result = new EnumField(options);
+exports.IntegerEnumField = IntegerEnumField;
+function IntegerEnumType(options) {
+    let result = new IntegerEnumField(options);
     return Object.assign(result, options);
 }
-exports.EnumType = EnumType;
+exports.IntegerEnumType = IntegerEnumType;
 class ListField extends BaseField {
     constructor(field, options) {
         super();
         this.field = field;
+        this.options = options;
         this.validators = [];
         if (field.type.dbType === schema_1.DBType.List) {
             throw new Error(`nested lists not currently supported`);
@@ -565,6 +706,9 @@ class ListField extends BaseField {
         };
         Object.assign(this, options);
     }
+    __getElemField() {
+        return this.field;
+    }
     validate(validator) {
         this.validators.push(validator);
         return this;
@@ -592,7 +736,12 @@ class ListField extends BaseField {
         return result;
     }
     postgresVal(val, jsonType) {
-        if (!jsonType) {
+        if (!jsonType && val === "") {
+            // support empty strings in list
+            val = '"' + val + '"';
+            return val;
+        }
+        if (this.options?.disableJSONStringify) {
             return val;
         }
         return JSON.stringify(val);
@@ -720,7 +869,18 @@ 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);
+    return new ListField(UUIDType(options), {
+        ...options,
+        disableJSONStringify: true,
+    });
 }
 exports.UUIDListType = UUIDListType;

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