@snowtop/ent 0.1.0-alpha16 → 0.1.0-alpha160-test2

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 types_1 = require("util/types");
+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;
@@ -583,7 +727,7 @@ class ListField extends BaseField {
             return true;
         }
         const res = valid.apply(this.field, [val[0]]);
-        if (util_1.types.isPromise(res)) {
+        if ((0, types_1.isPromise)(res)) {
             const ret = await Promise.all(val.map(async (v) => await valid.apply(this.field, [v])));
             return ret.every((v) => v);
         }
@@ -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";

package/schema/index.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];
@@ -10,11 +14,12 @@ 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.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;
+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.getFieldsWithEditPrivacy = 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, "getFieldsWithEditPrivacy", { enumerable: true, get: function () { return schema_1.getFieldsWithEditPrivacy; } });
 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; } });

package/schema/json_field.d.ts

@@ -1,17 +1,29 @@
-import { FieldOptions, Type, Field, ImportType } from "./schema";
+import { FieldOptions, Type, Field, DeprecatedImportType } from "./schema";
 import { BaseField, ListField } from "./field";
 export interface JSONOptions extends FieldOptions {
     validator?: (val: any) => boolean;
-    importType?: ImportType;
+    importType?: DeprecatedImportType;
+}
+interface allJSONOptions extends JSONOptions {
+    jsonAsList?: boolean;
 }
 export declare class JSONField extends BaseField implements Field {
     private options?;
     type: Type;
-    constructor(jsonb: boolean, options?: JSONOptions | undefined);
-    format(val: any): string;
+    constructor(jsonb: boolean, options?: allJSONOptions | undefined);
+    format(val: any, nested?: boolean): any;
     valid(val: any): boolean;
 }
 export declare function JSONType(options?: JSONOptions): JSONField;
 export declare function JSONBType(options?: JSONOptions): JSONField;
+/**
+ * @deprecated use JSONBTypeAsList
+ */
 export declare function JSONBListType(options?: JSONOptions): ListField;
+/**
+ * @deprecated use JSONTypeAsList
+ */
 export declare function JSONListType(options?: JSONOptions): ListField;
+export declare function JSONBTypeAsList(options?: JSONOptions): JSONField & JSONOptions;
+export declare function JSONTypeAsList(options?: JSONOptions): JSONField & JSONOptions;
+export {};

package/schema/json_field.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONListType = exports.JSONBListType = exports.JSONBType = exports.JSONType = exports.JSONField = void 0;
+exports.JSONTypeAsList = exports.JSONBTypeAsList = exports.JSONListType = exports.JSONBListType = exports.JSONBType = exports.JSONType = exports.JSONField = void 0;
 const schema_1 = require("./schema");
 const field_1 = require("./field");
 class JSONField extends field_1.BaseField {
@@ -16,8 +16,16 @@ class JSONField extends field_1.BaseField {
         if (options?.importType) {
             this.type.importType = options.importType;
         }
+        if (options?.jsonAsList) {
+            this.type.listElemType = {
+                dbType: schema_1.DBType.JSONB,
+            };
+        }
     }
-    format(val) {
+    format(val, nested) {
+        if (nested) {
+            return val;
+        }
         return JSON.stringify(val);
     }
     valid(val) {
@@ -38,11 +46,33 @@ function JSONBType(options) {
     return Object.assign(result, options);
 }
 exports.JSONBType = JSONBType;
+/**
+ * @deprecated use JSONBTypeAsList
+ */
 function JSONBListType(options) {
     return new field_1.ListField(JSONBType(options), options);
 }
 exports.JSONBListType = JSONBListType;
+/**
+ * @deprecated use JSONTypeAsList
+ */
 function JSONListType(options) {
     return new field_1.ListField(JSONType(options), options);
 }
 exports.JSONListType = JSONListType;
+function JSONBTypeAsList(options) {
+    let result = new JSONField(true, {
+        ...options,
+        jsonAsList: true,
+    });
+    return Object.assign(result, options);
+}
+exports.JSONBTypeAsList = JSONBTypeAsList;
+function JSONTypeAsList(options) {
+    let result = new JSONField(false, {
+        ...options,
+        jsonAsList: true,
+    });
+    return Object.assign(result, options);
+}
+exports.JSONTypeAsList = JSONTypeAsList;