@snowtop/ent 0.1.0-alpha14 → 0.1.0-alpha141

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;

package/schema/schema.d.ts

@@ -1,6 +1,7 @@
 import { Data, Ent, LoaderInfo, PrivacyPolicy, Viewer } from "../core/base";
-import { Builder } from "../action/action";
+import { Builder, Changeset } from "../action/action";
 import { Clause } from "../core/clause";
+import { AssocEdgeInput } from "../action/operations";
 export declare type FieldMap = {
     [key: string]: Field;
 };
@@ -8,11 +9,23 @@ interface FieldInfo {
     dbCol: string;
     inputKey: string;
 }
-export declare type FieldInfoMap = {
+export type FieldInfoMap = {
     [key: string]: FieldInfo;
 };
+export interface GlobalSchema {
+    edges?: Edge[];
+    extraEdgeFields?: FieldMap;
+    transformEdgeRead?: () => Clause;
+    transformEdgeWrite?: (stmt: EdgeUpdateOperation) => TransformedEdgeUpdateOperation | null;
+    fields?: FieldMap;
+}
+type FieldOverride = Pick<FieldOptions, "nullable" | "storageKey" | "serverDefault" | "unique" | "hideFromGraphQL" | "graphqlName" | "index">;
+export type FieldOverrideMap = {
+    [key: string]: FieldOverride;
+};
 export default interface Schema {
-    fields: FieldMap | Field[];
+    fields: FieldMap;
+    fieldOverrides?: FieldOverrideMap;
     tableName?: string;
     patterns?: Pattern[];
     edges?: Edge[];
@@ -25,6 +38,8 @@ export default interface Schema {
     constraints?: Constraint[];
     indices?: Index[];
     hideFromGraphQL?: boolean;
+    customGraphQLInterfaces?: string[];
+    supportUpsert?: boolean;
 }
 export interface AssocEdge {
     name: string;
@@ -61,17 +76,30 @@ export interface AssocEdgeGroup {
     tableName?: string;
     assocEdges: AssocEdge[];
     statusEnums?: string[];
-    nullStates: string | string[];
+    viewerBased?: boolean;
+    nullStates?: string | string[];
     nullStateFn?: string;
     edgeAction?: EdgeGroupAction;
 }
-export declare type Edge = AssocEdge;
+export type Edge = AssocEdge;
+interface ImportPath {
+    importPath: string;
+    import: string;
+    defaultImport?: boolean;
+    originalImport?: string;
+}
+export interface TransformReadBetaResult {
+    code: string;
+    imports: ImportPath[];
+}
 export interface Pattern {
     name: string;
-    fields: FieldMap | Field[];
+    fields: FieldMap;
+    disableMixin?: boolean;
     edges?: Edge[];
     transformRead?: () => Clause;
-    transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | null;
+    transformReadCodegen_BETA?: () => string | TransformReadBetaResult;
+    transformWrite?: <T extends Ent<TViewer>, TViewer extends Viewer = Viewer>(stmt: UpdateOperation<T, TViewer>) => TransformedUpdateOperation<T, TViewer> | null;
     transformsDelete?: boolean;
     transformsInsert?: boolean;
     transformsUpdate?: boolean;
@@ -81,16 +109,25 @@ export declare enum SQLStatementOperation {
     Update = "update",
     Delete = "delete"
 }
-export interface UpdateOperation<T extends Ent> {
+export interface EdgeUpdateOperation {
+    op: SQLStatementOperation;
+    edge: AssocEdgeInput;
+}
+export interface TransformedEdgeUpdateOperation {
     op: SQLStatementOperation;
-    existingEnt: T | null;
-    viewer: Viewer;
+    data?: Data;
+}
+export interface UpdateOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    op: SQLStatementOperation;
+    builder: Builder<TEnt, TViewer, any>;
+    input: Data;
     data?: Map<string, any>;
 }
-export interface TransformedUpdateOperation<T extends Ent> {
+export interface TransformedUpdateOperation<T extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     op: SQLStatementOperation;
     data?: Data;
     existingEnt?: T | null;
+    changeset?(): Promise<Changeset> | Changeset;
 }
 export declare enum DBType {
     UUID = "UUID",
@@ -106,19 +143,27 @@ export declare enum DBType {
     JSONB = "JSONB",
     Enum = "Enum",
     StringEnum = "StringEnum",
+    IntEnum = "IntEnum",
     Date = "Date",
     Time = "Time",
     Timetz = "Timetz",
     List = "List"
 }
-export interface ImportType {
+export interface DeprecatedImportType {
     path: string;
     type: string;
     [x: string]: any;
 }
+export interface ConvertType {
+    path: string;
+    function: string;
+}
 declare type EnumMap = {
     [key: string]: string;
 };
+declare type IntEnumMap = {
+    [key: string]: number;
+};
 export interface Type {
     dbType: DBType;
     listElemType?: Type;
@@ -126,9 +171,14 @@ export interface Type {
     graphQLType?: string;
     values?: string[];
     enumMap?: EnumMap;
-    importType?: ImportType;
+    intEnumMap?: IntEnumMap;
+    deprecatedIntEnumMap?: IntEnumMap;
+    disableUnknownType?: boolean;
+    globalType?: string;
+    importType?: DeprecatedImportType;
     subFields?: FieldMap;
     unionFields?: FieldMap;
+    [x: string]: any;
 }
 export interface ForeignKey {
     schema: string;
@@ -136,20 +186,29 @@ export interface ForeignKey {
     name?: string;
     disableIndex?: boolean;
     disableBuilderType?: boolean;
+    [x: string]: any;
 }
-declare type getLoaderInfoFn = (type: string) => LoaderInfo;
+type getLoaderInfoFn = (type: string) => LoaderInfo;
 export interface InverseFieldEdge {
     name: string;
     edgeConstName?: string;
     tableName?: string;
     hideFromGraphQL?: boolean;
 }
+export interface IndexEdgeOptions {
+    name: string;
+}
 export interface FieldEdge {
     schema: string;
     inverseEdge?: string | InverseFieldEdge;
+    indexEdge?: IndexEdgeOptions;
     enforceSchema?: boolean;
     getLoaderInfoFromSchema?: getLoaderInfoFn;
     disableBuilderType?: boolean;
+    edgeConstName?: string;
+}
+interface PrivateOptions {
+    exposeToActions?: boolean;
 }
 export interface FieldOptions {
     nullable?: boolean;
@@ -157,39 +216,48 @@ export interface FieldOptions {
     serverDefault?: any;
     unique?: boolean;
     hideFromGraphQL?: boolean;
-    private?: boolean;
+    private?: boolean | PrivateOptions;
     sensitive?: boolean;
     graphqlName?: string;
     index?: boolean;
     foreignKey?: ForeignKey;
     fieldEdge?: FieldEdge;
     primaryKey?: boolean;
+    immutable?: boolean;
     disableUserEditable?: boolean;
     disableUserGraphQLEditable?: boolean;
     defaultValueOnCreate?(builder: Builder<Ent>, input: Data): any;
     defaultToViewerOnCreate?: boolean;
+    onlyUpdateIfOtherFieldsBeingSet_BETA?: boolean;
     defaultValueOnEdit?(builder: Builder<Ent>, input: Data): any;
     derivedWhenEmbedded?: boolean;
     polymorphic?: boolean | PolymorphicOptions;
     privacyPolicy?: PrivacyPolicy | (() => PrivacyPolicy);
     getDerivedFields?(name: string): FieldMap;
+    convert?: ConvertType;
+    fetchOnDemand?: boolean;
+    dbOnly?: boolean;
     [x: string]: any;
 }
 export interface PolymorphicOptions {
+    name?: string;
     types?: string[];
     hideFromInverseGraphQL?: boolean;
     disableBuilderType?: boolean;
+    serverDefault?: any;
+    edgeConstName?: string;
 }
 export interface Field extends FieldOptions {
     type: Type;
     valid?(val: any): Promise<boolean> | boolean;
+    validateWithFullData?(val: any, builder: Builder<any>): boolean | Promise<boolean>;
     format?(val: any, nested?: boolean): any;
     logValue(val: any): any;
 }
 export interface SchemaConstructor {
     new (): Schema;
 }
-export declare type SchemaInputType = Schema | SchemaConstructor;
+export type SchemaInputType = Schema | SchemaConstructor;
 export declare function getSchema(value: SchemaInputType): Schema;
 export declare function getFields(value: SchemaInputType): Map<string, Field>;
 /**
@@ -203,7 +271,7 @@ interface objectLoaderOptions {
     instanceKey?: string;
 }
 export declare function getObjectLoaderProperties(value: SchemaInputType, tableName: string): objectLoaderOptions | undefined;
-export declare function getTransformedUpdateOp<T extends Ent>(value: SchemaInputType, stmt: UpdateOperation<T>): TransformedUpdateOperation<T> | null;
+export declare function getTransformedUpdateOp<TEnt extends Ent<TViewer>, TViewer extends Viewer>(value: SchemaInputType, stmt: UpdateOperation<TEnt, TViewer>): TransformedUpdateOperation<TEnt> | null;
 export declare enum ActionOperation {
     Create = 1,
     Edit = 2,
@@ -213,15 +281,18 @@ export declare enum ActionOperation {
     RemoveEdge = 32,
     EdgeGroup = 64
 }
-declare type actionFieldType = "ID" | "Boolean" | "Int" | "Float" | "String" | "Time" | "Object";
-declare type NullableListOptions = "contents" | "contentsAndList";
+type actionFieldType = "ID" | "Boolean" | "Int" | "Float" | "String" | "Time" | "JSON" | "Object";
+type NullableListOptions = "contents" | "contentsAndList";
 export interface ActionField {
     name: string;
     type: actionFieldType;
     nullable?: boolean | NullableListOptions;
+    optional?: boolean;
     list?: boolean;
     actionName?: string;
     excludedFields?: string[];
+    hideFromGraphQL?: boolean;
+    [x: string]: any;
 }
 export interface Action {
     operation: ActionOperation;
@@ -235,6 +306,7 @@ export interface Action {
     optionalFields?: string[];
     requiredFields?: string[];
     noFields?: boolean;
+    [x: string]: any;
 }
 export declare const NoFields = "__NO_FIELDS__";
 export declare function requiredField(field: string): string;
@@ -245,6 +317,7 @@ export interface Constraint {
     columns: string[];
     fkey?: ForeignKeyInfo;
     condition?: string;
+    [x: string]: any;
 }
 export interface FullTextWeight {
     A?: string[];
@@ -258,17 +331,21 @@ export interface FullText {
     languageColumn?: string;
     indexType?: "gin" | "gist";
     weights?: FullTextWeight;
+    [x: string]: any;
 }
 export interface Index {
     name: string;
     columns: string[];
     unique?: boolean;
     fulltext?: FullText;
+    indexType?: "gin" | "btree";
+    [x: string]: any;
 }
 export interface ForeignKeyInfo {
     tableName: string;
     ondelete?: "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT" | "NO ACTION";
     columns: string[];
+    [x: string]: any;
 }
 export declare enum ConstraintType {
     PrimaryKey = "primary",

package/schema/schema.js

@@ -35,6 +35,7 @@ var DBType;
     DBType["JSONB"] = "JSONB";
     DBType["Enum"] = "Enum";
     DBType["StringEnum"] = "StringEnum";
+    DBType["IntEnum"] = "IntEnum";
     DBType["Date"] = "Date";
     DBType["Time"] = "Time";
     DBType["Timetz"] = "Timetz";
@@ -55,21 +56,11 @@ exports.getSchema = getSchema;
 function getFields(value) {
     const schema = getSchema(value);
     function addFields(fields) {
-        if (Array.isArray(fields)) {
-            for (const field of fields) {
-                const name = field.name;
-                if (!name) {
-                    throw new Error(`name required`);
-                }
-                if (field.getDerivedFields !== undefined) {
-                    addFields(field.getDerivedFields(name));
-                }
-                m.set(name, field);
-            }
-            return;
-        }
         for (const name in fields) {
             const field = fields[name];
+            if (field.dbOnly) {
+                continue;
+            }
             if (field.getDerivedFields !== undefined) {
                 addFields(field.getDerivedFields(name));
             }
@@ -121,6 +112,7 @@ function getFieldsWithPrivacy(value, fieldMap) {
                     m.set(info.dbCol, privacyPolicy);
                 }
             }
+            return;
         }
         for (const name in fields) {
             const field = fields[name];
@@ -168,6 +160,9 @@ function getTransformedReadClause(value) {
     return;
 }
 exports.getTransformedReadClause = getTransformedReadClause;
+// would like to avoid calling this so that itwe don't run into circular dependencies
+// but the fact that it returns a clause makes it hard since we don't control the patterns...
+// we can make each clause return a format that can be extrapolated and used in codegen...
 function getObjectLoaderProperties(value, tableName) {
     return {
         clause: () => getTransformedReadClause(value),
@@ -209,6 +204,9 @@ var ActionOperation;
     // RemoveEdge is used to provide the ability to remove an edge in an AssociationEdge.
     ActionOperation[ActionOperation["RemoveEdge"] = 32] = "RemoveEdge";
     // EdgeGroup is used to provide the ability to edit an edge group in an AssociationEdgeGroup.
+    // if you want to clear this edge group e.g. any set edge with id1 and id2,
+    // you should create a custom action that takes the id as an action only field,
+    // and then calls `clearEdgeTypeInGroup` in a trigger to clear
     ActionOperation[ActionOperation["EdgeGroup"] = 64] = "EdgeGroup";
 })(ActionOperation = exports.ActionOperation || (exports.ActionOperation = {}));
 // sentinel that indicates an action has no fields

package/schema/struct_field.d.ts

@@ -1,17 +1,29 @@
 import { BaseField, ListField } from "./field";
 import { FieldOptions, Field, Type, FieldMap } from "./schema";
-export interface StructOptions extends FieldOptions {
+interface structFieldOptions extends FieldOptions {
     tsType: string;
     fields: FieldMap;
     graphQLType?: string;
     jsonNotJSONB?: boolean;
 }
+interface GlobalStructOptions extends FieldOptions {
+    globalType: string;
+}
+export type StructOptions = structFieldOptions | GlobalStructOptions;
 export declare class StructField extends BaseField implements Field {
     private options;
+    private jsonAsList?;
     type: Type;
-    constructor(options: StructOptions);
-    format(obj: any, nested?: boolean): string | Object;
+    constructor(options: StructOptions, jsonAsList?: boolean | undefined);
+    formatImpl(obj: any, nested?: boolean): string | Object;
+    format(obj: any, nested?: boolean): any;
+    private validImpl;
     valid(obj: any): Promise<boolean>;
 }
 export declare function StructType(options: StructOptions): StructField & StructOptions;
+/**
+ * @deprecated use StructTypeAsList
+ */
 export declare function StructListType(options: StructOptions): ListField;
+export declare function StructTypeAsList(options: StructOptions): StructField & StructOptions;
+export {};

package/schema/struct_field.js

@@ -1,44 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StructListType = exports.StructType = exports.StructField = void 0;
+exports.StructTypeAsList = exports.StructListType = exports.StructType = exports.StructField = void 0;
+const camel_case_1 = require("camel-case");
 const field_1 = require("./field");
 const schema_1 = require("./schema");
-const camel_case_1 = require("camel-case");
+const global_schema_1 = require("../core/global_schema");
+const logger_1 = require("../core/logger");
 class StructField extends field_1.BaseField {
-    constructor(options) {
+    constructor(options, jsonAsList) {
         super();
         this.options = options;
+        this.jsonAsList = jsonAsList;
         this.type = {
             dbType: schema_1.DBType.JSONB,
         };
         this.type.subFields = options.fields;
         this.type.type = options.tsType;
         this.type.graphQLType = options.graphQLType || options.tsType;
+        this.type.globalType = this.options.globalType;
         if (options.jsonNotJSONB) {
             this.type.dbType = schema_1.DBType.JSON;
         }
+        if (jsonAsList) {
+            this.type.listElemType = {
+                dbType: schema_1.DBType.JSONB,
+            };
+        }
     }
-    // right now, we store things in the db in lowerCase format
-    // this will lead to issues if field changes.
-    // TODO: use storageKey and convert back...
-    format(obj, nested) {
+    formatImpl(obj, nested) {
         if (!(obj instanceof Object)) {
             throw new Error("valid was not called");
         }
         let ret = {};
         for (const k in this.options.fields) {
+            const field = this.options.fields[k];
+            // check two values
+            // store in dbKey format
             // TODO more #510
-            let dbKey = (0, camel_case_1.camelCase)(k);
-            let val = obj[dbKey];
-            // for tests with snake_case
-            if (val === undefined && obj[k] !== undefined) {
-                val = obj[k];
-                dbKey = k;
+            let dbKey = (0, schema_1.getStorageKey)(field, k);
+            let camelKey = (0, camel_case_1.camelCase)(k);
+            let val = obj[camelKey];
+            if (val === undefined && obj[dbKey] !== undefined) {
+                val = obj[dbKey];
             }
             if (val === undefined) {
                 continue;
             }
-            const field = this.options.fields[k];
             if (field.format) {
                 // indicate nested so this isn't JSON stringified
                 ret[dbKey] = field.format(val, true);
@@ -47,13 +54,53 @@ class StructField extends field_1.BaseField {
                 ret[dbKey] = val;
             }
         }
-        // don't json.stringify if nested
+        // don't json.stringify if nested or list
         if (nested) {
             return ret;
         }
         return JSON.stringify(ret);
     }
-    async valid(obj) {
+    format(obj, nested) {
+        if (this.type.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            if (f && f.format) {
+                if (JSON.stringify(this.type.listElemType) !==
+                    JSON.stringify(f?.type.listElemType)) {
+                    if (this.jsonAsList) {
+                        // handle as nested
+                        // @ts-ignore
+                        const formatted = obj.map((v) => f.format(v, true));
+                        if (nested) {
+                            return formatted;
+                        }
+                        else {
+                            return JSON.stringify(formatted);
+                        }
+                    }
+                    else {
+                        const formatted = f.format([obj], true);
+                        if (nested) {
+                            return formatted[0];
+                        }
+                        else {
+                            return JSON.stringify(formatted[0]);
+                        }
+                    }
+                }
+                // TODO handle format code
+                return f.format(obj);
+            }
+        }
+        if (Array.isArray(obj) && this.jsonAsList) {
+            const ret = obj.map((v) => this.formatImpl(v, true));
+            if (nested) {
+                return ret;
+            }
+            return JSON.stringify(ret);
+        }
+        return this.formatImpl(obj, nested);
+    }
+    async validImpl(obj) {
         if (!(obj instanceof Object)) {
             return false;
         }
@@ -63,12 +110,11 @@ class StructField extends field_1.BaseField {
         for (const k in this.options.fields) {
             const field = this.options.fields[k];
             // TODO more #510
-            let dbKey = (0, camel_case_1.camelCase)(k);
-            let val = obj[dbKey];
-            // for tests with snake_case
-            if (val === undefined && obj[k] !== undefined) {
-                val = obj[k];
-                dbKey = k;
+            let dbKey = (0, schema_1.getStorageKey)(field, k);
+            let camelKey = (0, camel_case_1.camelCase)(k);
+            let val = obj[camelKey];
+            if (val === undefined && obj[dbKey] !== undefined) {
+                val = obj[dbKey];
             }
             if (val === undefined || val === null) {
                 // nullable, nothing to do here
@@ -89,6 +135,47 @@ class StructField extends field_1.BaseField {
         const ret = await Promise.all(promises);
         return ret.every((v) => v);
     }
+    async valid(obj) {
+        if (this.type.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            // list and global type is not valid.
+            if (f) {
+                if (f.valid) {
+                    if (JSON.stringify(this.type.listElemType) !==
+                        JSON.stringify(f?.type.listElemType)) {
+                        if (this.jsonAsList) {
+                            if (!Array.isArray(obj)) {
+                                return false;
+                            }
+                            // @ts-ignore
+                            const valid = await Promise.all(obj.map((v) => f.valid(v)));
+                            return valid.every((b) => b);
+                        }
+                        else {
+                            return f.valid([obj]);
+                        }
+                    }
+                    return f.valid(obj);
+                }
+                return true;
+            }
+            else {
+                (0, logger_1.log)("error", `globalType ${this.type.globalType} not found in global schema`);
+                return false;
+            }
+        }
+        if (this.jsonAsList) {
+            if (!Array.isArray(obj)) {
+                return false;
+            }
+            const valid = await Promise.all(obj.map((v) => this.validImpl(v)));
+            return valid.every((b) => b);
+        }
+        if (!(obj instanceof Object)) {
+            return false;
+        }
+        return this.validImpl(obj);
+    }
 }
 exports.StructField = StructField;
 function StructType(options) {
@@ -96,7 +183,15 @@ function StructType(options) {
     return Object.assign(result, options);
 }
 exports.StructType = StructType;
+/**
+ * @deprecated use StructTypeAsList
+ */
 function StructListType(options) {
     return new field_1.ListField(StructType(options), options);
 }
 exports.StructListType = StructListType;
+function StructTypeAsList(options) {
+    let result = new StructField(options, true);
+    return Object.assign(result, options);
+}
+exports.StructTypeAsList = StructTypeAsList;