nesoi 3.0.21 → 3.1.1

package/lib/elements/entities/bucket/model/bucket_model.schema.d.ts

@@ -1,5 +1,6 @@
 import { $Dependency } from "../../../../engine/dependency";
-export type $BucketModelFieldType = 'boolean' | 'date' | 'datetime' | 'duration' | 'decimal' | 'enum' | 'file' | 'float' | 'int' | 'string' | 'obj' | 'unknown' | 'dict';
+import { BucketAdapterConfig } from '../adapters/bucket_adapter';
+export type $BucketModelFieldType = 'boolean' | 'date' | 'datetime' | 'duration' | 'decimal' | 'enum' | 'file' | 'float' | 'int' | 'string' | 'obj' | 'unknown' | 'dict' | 'list' | 'union';
 export type $BucketModelFieldCrypto = {
     algorithm: string;
     key: string;
@@ -13,7 +14,6 @@ export declare class $BucketModelField {
     path: string;
     type: $BucketModelFieldType;
     alias: string;
-    array: boolean;
     required: boolean;
     meta?: {
         enum?: {
@@ -31,10 +31,9 @@ export declare class $BucketModelField {
     } | undefined;
     defaultValue?: any | undefined;
     children?: $BucketModelFields | undefined;
-    or?: $BucketModelField | undefined;
     crypto?: $BucketModelFieldCrypto | undefined;
     $t: string;
-    constructor(name: string, path: string, type: $BucketModelFieldType, alias: string, array: boolean, required: boolean, meta?: {
+    constructor(name: string, path: string, type: $BucketModelFieldType, alias: string, required: boolean, meta?: {
         enum?: {
             options: string | string[];
             dep?: $Dependency;
@@ -47,7 +46,7 @@ export declare class $BucketModelField {
             extnames?: string[];
             maxsize?: number;
         };
-    } | undefined, defaultValue?: any | undefined, children?: $BucketModelFields | undefined, or?: $BucketModelField | undefined, crypto?: $BucketModelFieldCrypto | undefined);
+    } | undefined, defaultValue?: any | undefined, children?: $BucketModelFields | undefined, crypto?: $BucketModelFieldCrypto | undefined);
 }
 export type $BucketModelFields = {
     [x: string]: $BucketModelField;
@@ -67,6 +66,9 @@ export declare class $BucketModel {
     constructor(fields: $BucketModelFields & {
         id: $BucketModelField;
     }, defaults?: Record<string, any>, hasFileField?: boolean, hasEncryptedField?: boolean);
-    static get(model: $BucketModel, fieldpath: string): $BucketModelField | undefined;
+    static getField(model: $BucketModel, modelpath: string): $BucketModelField[];
     static fieldsOfType(model: $BucketModel, type: $BucketModelFieldType): $BucketModelField[];
+    static forEachField(model: $BucketModel, predicate: (field: $BucketModelField, path: string) => void): void;
+    static copy<T extends Record<string, any>>(model: $BucketModel, obj: T, meta?: BucketAdapterConfig['meta']): T;
+    static getModelpaths(model: $BucketModel): Record<string, $BucketModelField[]>;
 }

package/lib/elements/entities/bucket/model/bucket_model.schema.js

@@ -6,17 +6,15 @@ exports.$BucketModel = exports.$BucketModelField = void 0;
  * @subcategory Entity
  * */
 class $BucketModelField {
-    constructor(name, path, type, alias, array, required, meta, defaultValue, children, or, crypto) {
+    constructor(name, path, type, alias, required, meta, defaultValue, children, crypto) {
         this.name = name;
         this.path = path;
         this.type = type;
         this.alias = alias;
-        this.array = array;
         this.required = required;
         this.meta = meta;
         this.defaultValue = defaultValue;
         this.children = children;
-        this.or = or;
         this.crypto = crypto;
         this.$t = 'bucket.model.field';
     }
@@ -34,26 +32,55 @@ class $BucketModel {
         this.hasEncryptedField = hasEncryptedField;
         this.$t = 'bucket.model';
     }
-    static get(model, fieldpath) {
-        const paths = fieldpath.split('.');
-        let ref = model.fields;
-        for (let i = 0; i < paths.length; i++) {
-            const path = paths[i];
-            if (path === '#') {
-                continue;
-            }
-            else {
-                ref = ref?.[path];
-            }
-            if (!ref?.children || i == paths.length - 1) {
-                return ref;
-            }
-            if (!ref) {
-                return undefined;
+    static getField(model, modelpath) {
+        const paths = modelpath.split('.');
+        const results = [];
+        let poll = [{ i: 0, field: { children: model.fields } }];
+        while (poll.length) {
+            const next = [];
+            for (const item of poll) {
+                const path = paths[item.i];
+                if (!path) {
+                    results.push(item.field);
+                    continue;
+                }
+                const field = item.field;
+                // If the field is a union, add all of it's children with the same path index
+                if (field.type === 'union') {
+                    next.push(...Object.values(field.children).map(field => ({
+                        i: item.i,
+                        field
+                    })));
+                    continue;
+                }
+                // If it's a list or dict, or an object 
+                if (field.type === 'list' || field.type === 'dict') {
+                    // If not, iterate
+                    next.push({
+                        i: item.i + 1,
+                        field: field.children['#']
+                    });
+                    continue;
+                }
+                // If it's an object and the path is '*', walk all of it's children
+                if (field.type === 'obj' && path === '*') {
+                    next.push(...Object.values(field.children).map(field => ({
+                        i: item.i + 1,
+                        field
+                    })));
+                    continue;
+                }
+                const child = field.children[path];
+                if (child) {
+                    next.push({
+                        i: item.i + 1,
+                        field: child
+                    });
+                }
             }
-            ref = ref.children;
+            poll = next;
         }
-        return ref;
+        return results;
     }
     static fieldsOfType(model, type) {
         const fields = [];
@@ -72,5 +99,141 @@ class $BucketModel {
         }
         return fields;
     }
+    static forEachField(model, predicate) {
+        let poll = Object.entries(model.fields).map(([path, field]) => ({ path, field }));
+        while (poll.length) {
+            const next = [];
+            for (const obj of poll) {
+                predicate(obj.field, obj.path);
+                if (obj.field.children) {
+                    next.push(...Object.values(obj.field.children)
+                        .map((field, i) => ({
+                        field,
+                        path: obj.path + '.' + (obj.field.type === 'union' ? i : field.name)
+                    })));
+                }
+            }
+            poll = next;
+        }
+    }
+    static copy(model, obj, meta = {
+        created_at: 'created_at',
+        created_by: 'created_by',
+        updated_at: 'updated_at',
+        updated_by: 'updated_by',
+    }) {
+        const copy = {};
+        let poll = Object.entries(model.fields).map(([path, field]) => ({ path, obj, copy, field }));
+        while (poll.length) {
+            const next = [];
+            for (const entry of poll) {
+                const val = obj[entry.path];
+                if (val === undefined) {
+                    continue;
+                }
+                if (val === null) {
+                    copy[entry.path] = null;
+                    continue;
+                }
+                if (entry.field.type === 'list') {
+                    if (!Array.isArray(val))
+                        continue;
+                    copy[entry.path] = [];
+                    next.push(...val.map((_, i) => ({
+                        path: i.toString(),
+                        obj: val,
+                        copy: copy[entry.path],
+                        field: entry.field.children['*']
+                    })));
+                }
+                else if (entry.field.type === 'dict') {
+                    if (typeof val !== 'object' || Array.isArray(val))
+                        continue;
+                    copy[entry.path] = {};
+                    next.push(...Object.keys(val).map((path) => ({
+                        path,
+                        obj: val,
+                        copy: copy[entry.path],
+                        field: entry.field.children['*']
+                    })));
+                }
+                else if (entry.field.type === 'obj') {
+                    if (typeof val !== 'object' || Array.isArray(val))
+                        continue;
+                    copy[entry.path] = {};
+                    next.push(...Object.keys(entry.field.children).map(path => ({
+                        path: path,
+                        obj: val,
+                        copy: copy[entry.path],
+                        field: entry.field.children[path]
+                    })));
+                }
+                else if (entry.field.type === 'union') {
+                    // TODO: ??????????   
+                    copy[entry.path] = obj[entry.path];
+                }
+                else {
+                    copy[entry.path] = obj[entry.path];
+                }
+            }
+            poll = next;
+        }
+        copy[meta.created_at] = obj[meta.created_at];
+        copy[meta.created_by] = obj[meta.created_by];
+        copy[meta.updated_at] = obj[meta.updated_at];
+        copy[meta.updated_by] = obj[meta.updated_by];
+        return copy;
+    }
+    static getModelpaths(model) {
+        const modelpaths = {};
+        let poll = Object.entries(model.fields).map(([path, field]) => ({ path, field }));
+        while (poll.length) {
+            const next = [];
+            for (const obj of poll) {
+                if (obj.field.type === 'union') {
+                    modelpaths[obj.path] = [obj.field];
+                }
+                else {
+                    modelpaths[obj.path] = [obj.field];
+                    if (obj.field.children) {
+                        if (obj.field.type === 'dict') {
+                            modelpaths[obj.path + '{*}'] = [obj.field.children['#']];
+                        }
+                        else if (obj.field.type === 'list') {
+                            modelpaths[obj.path + '[*]'] = [obj.field.children['#']];
+                        }
+                        else if (obj.field.type === 'obj') {
+                            modelpaths[obj.path + '{*}'] = Object.values(obj.field.children);
+                        }
+                        for (const key in obj.field.children) {
+                            const child = obj.field.children[key];
+                            if (obj.field.type === 'dict') {
+                                modelpaths[obj.path + '{$${number}}'] = [child];
+                                next.push({
+                                    field: child,
+                                    path: obj.path + '{${string}}'
+                                });
+                            }
+                            else if (obj.field.type === 'list') {
+                                modelpaths[obj.path + '[$${number}]'] = [child];
+                                next.push({
+                                    field: child,
+                                    path: obj.path + '[${number}]'
+                                });
+                            }
+                            else {
+                                next.push({
+                                    field: child,
+                                    path: obj.path + '.' + child.name
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            poll = next;
+        }
+        return modelpaths;
+    }
 }
 exports.$BucketModel = $BucketModel;

package/lib/elements/entities/bucket/model/bucket_model_field.builder.d.ts

@@ -1,7 +1,7 @@
 import { $Module, $Space } from "../../../../schema";
 import { $BucketModelField, $BucketModelFieldType, $BucketModelFields } from './bucket_model.schema';
 import { NesoiDate } from "../../../../engine/data/date";
-import { BucketFieldpathObjInfer, BucketModelObjInfer } from './bucket_model.infer';
+import { BucketModelpathObjInfer, BucketModelpathDictInfer, BucketModelpathListInfer, BucketModelObjInfer, BucketQuerypathDictInfer, BucketQuerypathListInfer, BucketQuerypathObjInfer, BucketModelpathUnionInfer } from './bucket_model.infer';
 import { EnumFromName, EnumName } from '../../constants/constants.schema';
 import { NesoiDecimal } from "../../../../engine/data/decimal";
 import { NesoiDatetime } from "../../../../engine/data/datetime";
@@ -16,111 +16,144 @@ export declare class BucketModelFieldFactory<Space extends $Space, Module extend
     constructor(module: string);
     private alias?;
     as(alias: string): Omit<typeof this, "as">;
-    get any(): BucketModelFieldBuilder<Module, any, never, any, {
+    get any(): BucketModelFieldBuilder<Module, any, any, [false, false], {
+        '': any;
+    }, {
         '': any;
     }>;
-    get boolean(): BucketModelFieldBuilder<Module, boolean, never, boolean, {
+    get boolean(): BucketModelFieldBuilder<Module, boolean, boolean, [false, false], {
+        '': boolean;
+    }, {
         '': boolean;
     }>;
-    get date(): BucketModelFieldBuilder<Module, NesoiDate, never, NesoiDate, {
+    get date(): BucketModelFieldBuilder<Module, NesoiDate, NesoiDate, [false, false], {
+        '': NesoiDate;
+    }, {
         '': NesoiDate;
     }>;
-    get datetime(): BucketModelFieldBuilder<Module, NesoiDatetime, never, NesoiDatetime, {
+    get datetime(): BucketModelFieldBuilder<Module, NesoiDatetime, NesoiDatetime, [false, false], {
+        '': NesoiDatetime;
+    }, {
         '': NesoiDatetime;
     }>;
-    get duration(): BucketModelFieldBuilder<Module, NesoiDuration, never, NesoiDuration, {
+    get duration(): BucketModelFieldBuilder<Module, NesoiDuration, NesoiDuration, [false, false], {
+        '': NesoiDuration;
+    }, {
         '': NesoiDuration;
     }>;
     decimal(def?: {
         left?: number;
         right?: number;
-    }): BucketModelFieldBuilder<Module, NesoiDecimal, never, NesoiDecimal, {
+    }): BucketModelFieldBuilder<Module, NesoiDecimal, NesoiDecimal, [false, false], {
+        '': NesoiDecimal;
+    }, {
         '': NesoiDecimal;
     }>;
-    enum<Enums extends EnumName<Space>, Options extends (keyof Enums & string) | (readonly string[])>(options: Options): BucketModelFieldBuilder<Module, Options extends string ? EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options], never, Options extends string ? EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options], {
-        '': Options extends string ? EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options];
+    enum<Enums extends EnumName<Space>, Options extends (keyof Enums & string) | (readonly string[])>(options: Options): BucketModelFieldBuilder<Module, Options extends string ? keyof EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options], Options extends string ? keyof EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options], [false, false], {
+        '': Options extends string ? keyof EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options];
+    }, {
+        '': Options extends string ? keyof EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options];
     }>;
-    get int(): BucketModelFieldBuilder<Module, number, never, number, {
+    get int(): BucketModelFieldBuilder<Module, number, number, [false, false], {
+        '': number;
+    }, {
         '': number;
     }>;
-    get float(): BucketModelFieldBuilder<Module, number, never, number, {
+    get float(): BucketModelFieldBuilder<Module, number, number, [false, false], {
+        '': number;
+    }, {
         '': number;
     }>;
-    get string(): BucketModelFieldBuilder<Module, string, never, string, {
+    get string(): BucketModelFieldBuilder<Module, string, string, [false, false], {
+        '': string;
+    }, {
         '': string;
     }>;
+    file(def?: {
+        extnames?: string[];
+        maxsize?: number;
+    }): BucketModelFieldBuilder<Module, NesoiFile, NesoiFile, [false, false], {
+        '': NesoiFile;
+    }, {
+        '': NesoiFile;
+    }>;
     /**
      * An object with a specific set of child fields.
      */
-    obj<T extends BucketModelFieldBuilders<Module>>(fields?: T): BucketModelFieldBuilder<Module, BucketModelObjInfer<T>, never, BucketModelObjInfer<T>, {
+    obj<T extends BucketModelFieldBuilders<Module>>(fields?: T): BucketModelFieldBuilder<Module, BucketModelObjInfer<T>, BucketModelObjInfer<T>, [false, false], {
         '': BucketModelObjInfer<T>;
-    } & BucketFieldpathObjInfer<T, ".">>;
+    } & {
+        '.*': BucketModelObjInfer<T>[keyof { [K in keyof T as T[K]["#optional"][1] extends true ? never : `${K & string}`]: T[K]["#output"]; } | keyof { [K_1 in keyof T as T[K_1]["#optional"][1] extends true ? `${K_1 & string}` : never]?: T[K_1]["#output"] | undefined; }];
+    } & BucketModelpathObjInfer<T>, {
+        '': BucketModelObjInfer<T>;
+    } & BucketQuerypathObjInfer<T>>;
     /**
      * An object with an unknown number of child fields of a given type.
      *
      * - All child fields are optional. You can specify a default value.
      */
-    dict<T extends BucketModelFieldBuilder<Module, any>>(dictItem: T): BucketModelFieldBuilder<Module, Record<string, T extends BucketModelFieldBuilder<any, any, any, infer X, {
-        '': infer X;
-    }> ? X : never>, never, Record<string, T extends BucketModelFieldBuilder<any, any, any, infer X, {
-        '': infer X;
-    }> ? X : never>, {
-        '': Record<string, T extends BucketModelFieldBuilder<any, any, any, infer X, {
-            '': infer X;
-        }> ? X : never>;
-    } & BucketFieldpathObjInfer<{
-        '': T;
-    }, ".#">>;
-    file(def?: {
-        extnames?: string[];
-        maxsize?: number;
-    }): BucketModelFieldBuilder<Module, NesoiFile, never, NesoiFile, {
-        '': NesoiFile;
-    }>;
+    dict<T extends BucketModelFieldBuilder<Module, any, any, any, any>>(dictItem: T): BucketModelFieldBuilder<Module, Record<string, T["#input"]>, Record<string, T["#output"]>, [false, false], {
+        '': Record<string, T["#output"]>;
+    } & BucketModelpathDictInfer<T>, {
+        '': Record<string, T["#output"]>;
+    } & BucketQuerypathDictInfer<T>>;
+    /**
+     * A list of a given type
+     * - All child fields are optional. You can specify a default value.
+     */
+    list<T extends BucketModelFieldBuilder<Module, any, any, any, any>>(listItem: T): BucketModelFieldBuilder<Module, T["#input"][], T["#output"][], [false, false], {
+        '': T["#output"][];
+    } & BucketModelpathListInfer<T>, {
+        '': T["#output"][];
+    } & BucketQuerypathListInfer<T>>;
+    union<Builders extends AnyBucketModelFieldBuilder[]>(...children: Builders): BucketModelFieldBuilder<Module, Builders[number]["#input"], Builders[number]["#output"], [false, false], BucketModelpathUnionInfer<Builders>, Builders[number]["#querypath"]>;
 }
 /**
  * @category Builders
  * @subcategory Entity
  * */
-export declare class BucketModelFieldBuilder<Module extends $Module, DefinedData, TypeAppend = never, Data = DefinedData | TypeAppend, Fieldpath = {
-    '': Data;
+export declare class BucketModelFieldBuilder<Module extends $Module, Input, Output, Optional = [false, false], Modelpath = {
+    '': Output;
+}, Querypath = {
+    '': Output;
 }> {
     private module;
     private type;
     private alias?;
     private meta?;
     private children?;
-    private _array;
+    '#input': Input;
+    '#output': Output;
+    '#optional': Optional;
+    '#modelpath': Modelpath;
+    '#querypath': Querypath;
     private _required;
     private _defaultValue?;
-    private _or?;
     private crypto?;
     constructor(module: string, type: $BucketModelFieldType, alias?: string | undefined, meta?: $BucketModelField['meta'], children?: BucketModelFieldBuilders<Module> | undefined);
     as(alias: string): this;
     /**
-     * This field can be `undefined`.
+     * This field can be `undefined` or `null`.
      */
-    get optional(): BucketModelFieldBuilder<Module, DefinedData, undefined, DefinedData | undefined, { [K in keyof Fieldpath]: Fieldpath[K] | undefined; }>;
+    get optional(): BucketModelFieldBuilder<Module, Input | null | undefined, Output | null | undefined, [
+        true,
+        true
+    ], {
+        [K in keyof Modelpath]: Modelpath[K] | null | undefined;
+    }, {
+        [K in keyof Querypath]: Querypath[K] | null | undefined;
+    }>;
     /**
      * If this field is undefined on the source, it will be
      * read as the given value.
-     * Also, when creating or updating the model through a default
-     * resource method, this value is used if undefined is passed.
+     * Also, when a message is generated for this model,
+     * the field can be undefined on the input and will have this value
+     * after parsed.
      */
-    default(defaultValue: DefinedData): BucketModelFieldBuilder<Module, DefinedData, never, DefinedData, Fieldpath>;
-    get array(): BucketModelFieldBuilder<Module, DefinedData[], TypeAppend, DefinedData[] | TypeAppend, { [K in Exclude<keyof Fieldpath, ""> as `.#${K & string}`]: Fieldpath[K]; } & {
-        "": DefinedData[] | TypeAppend;
-        ".#": DefinedData | TypeAppend;
-    }>;
-    or<Def extends AnyBucketModelFieldBuilder>(def: Def): BucketModelFieldBuilder<Module, DefinedData | (Def extends BucketModelFieldBuilder<any, any, any, infer X, {
-        '': infer X;
-    }> ? X : never), TypeAppend, DefinedData | (Def extends BucketModelFieldBuilder<any, any, any, infer X, {
-        '': infer X;
-    }> ? X : never) | TypeAppend, { [K in Exclude<keyof Fieldpath, "">]: Fieldpath[K] | (K extends keyof (Def extends BucketModelFieldBuilder<any, any, any, any, infer X_1> ? X_1 : never) ? (Def extends BucketModelFieldBuilder<any, any, any, any, infer X_1> ? X_1 : never)[K] : undefined); } & {
-        "": DefinedData | (Def extends BucketModelFieldBuilder<any, any, any, infer X, {
-            '': infer X;
-        }> ? X : never) | TypeAppend;
-    } & { [K in Exclude<keyof (Def extends BucketModelFieldBuilder<any, any, any, any, infer X_1> ? X_1 : never), "">]: (Def extends BucketModelFieldBuilder<any, any, any, any, infer X_1> ? X_1 : never)[K]; }>;
+    default(defaultValue: Output): BucketModelFieldBuilder<Module, Input | undefined, Output, [
+        true,
+        (Optional & [boolean, boolean])[1]
+    ], Modelpath, Querypath>;
     /**
      * This can be applied to `string` and `enum` fields,
      * to control storage performance.
@@ -132,7 +165,7 @@ export declare class BucketModelFieldBuilder<Module extends $Module, DefinedData
      */
     maxLength(val: number | null): void;
     encrypt(key: keyof Module['constants']['values'], algorithm?: string): void;
-    static build(builder: BucketModelFieldBuilder<any, any>, name: string, basePath?: string): {
+    static build(builder: AnyBucketModelFieldBuilder, name: string, basePath?: string): {
         schema: $BucketModelField;
         hasFile: boolean;
         hasEncrypted: boolean;
@@ -145,6 +178,6 @@ export declare class BucketModelFieldBuilder<Module extends $Module, DefinedData
     };
 }
 export type BucketModelFieldBuilders<Module extends $Module> = {
-    [x: string]: BucketModelFieldBuilder<Module, any> | BucketModelFieldBuilders<Module>;
+    [x: string]: BucketModelFieldBuilder<Module, any, any, any, any, any> | BucketModelFieldBuilders<Module>;
 };
-export type AnyBucketModelFieldBuilder = BucketModelFieldBuilder<any, any>;
+export type AnyBucketModelFieldBuilder = BucketModelFieldBuilder<any, any, any, any, any, any>;

package/lib/elements/entities/bucket/model/bucket_model_field.builder.js

@@ -65,6 +65,11 @@ class BucketModelFieldFactory {
     get string() {
         return new BucketModelFieldBuilder(this.module, 'string', this.alias);
     }
+    file(def) {
+        return new BucketModelFieldBuilder(this.module, 'file', this.alias, {
+            file: def
+        });
+    }
     /**
      * An object with a specific set of child fields.
      */
@@ -77,13 +82,17 @@ class BucketModelFieldFactory {
      * - All child fields are optional. You can specify a default value.
      */
     dict(dictItem) {
-        dictItem = dictItem.optional;
-        return new BucketModelFieldBuilder(this.module, 'dict', this.alias, undefined, { __dict: dictItem });
+        return new BucketModelFieldBuilder(this.module, 'dict', this.alias, undefined, { '#': dictItem });
     }
-    file(def) {
-        return new BucketModelFieldBuilder(this.module, 'file', this.alias, {
-            file: def
-        });
+    /**
+     * A list of a given type
+     * - All child fields are optional. You can specify a default value.
+     */
+    list(listItem) {
+        return new BucketModelFieldBuilder(this.module, 'list', this.alias, undefined, { '#': listItem });
+    }
+    union(...children) {
+        return new BucketModelFieldBuilder(this.module, 'union', this.alias, undefined, Object.fromEntries(children.map((c, i) => [i, c])));
     }
 }
 exports.BucketModelFieldFactory = BucketModelFieldFactory;
@@ -101,7 +110,6 @@ class BucketModelFieldBuilder {
         this.alias = alias;
         this.meta = meta;
         this.children = children;
-        this._array = false;
         this._required = true;
         this._defaultValue = undefined;
     }
@@ -110,7 +118,7 @@ class BucketModelFieldBuilder {
         return this;
     }
     /**
-     * This field can be `undefined`.
+     * This field can be `undefined` or `null`.
      */
     get optional() {
         this._required = false;
@@ -119,26 +127,15 @@ class BucketModelFieldBuilder {
     /**
      * If this field is undefined on the source, it will be
      * read as the given value.
-     * Also, when creating or updating the model through a default
-     * resource method, this value is used if undefined is passed.
+     * Also, when a message is generated for this model,
+     * the field can be undefined on the input and will have this value
+     * after parsed.
      */
     default(defaultValue) {
         this._required = false;
         this._defaultValue = defaultValue;
         return this;
     }
-    get array() {
-        this._array = true;
-        if (this._or) {
-            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-            this._or.array;
-        }
-        return this;
-    }
-    or(def) {
-        def._or = this;
-        return def;
-    }
     /**
      * This can be applied to `string` and `enum` fields,
      * to control storage performance.
@@ -159,24 +156,19 @@ class BucketModelFieldBuilder {
     // Build
     static build(builder, name, basePath = '') {
         const path = basePath + name;
-        const itemPath = builder._array ? path + '.#.' : path + '.';
+        const childrenPath = path + '.';
         const children = builder.children
-            ? BucketModelFieldBuilder.buildChildren(builder.module, builder.children, itemPath)
+            ? BucketModelFieldBuilder.buildChildren(builder.module, builder.children, childrenPath)
             : undefined;
         const defaults = builder._defaultValue && builder.children
             ? Object.assign({}, builder._defaultValue, children?.defaults)
             : builder._defaultValue;
-        const or = builder._or
-            ? this.build(builder._or, name, basePath)
-            : undefined;
-        const schema = new bucket_model_schema_1.$BucketModelField(name, path, builder.type, builder.alias || name, builder._array, builder._required, builder.meta, defaults, children?.schema, or?.schema, builder.crypto);
+        const schema = new bucket_model_schema_1.$BucketModelField(name, path, builder.type, builder.alias || name, builder._required, builder.meta, defaults, children?.schema, builder.crypto);
         const hasFile = builder.type === 'file'
             || children?.hasFileField
-            || or?.hasFile
             || false;
         const hasEncrypted = !!builder.crypto
             || children?.hasEncryptedField
-            || or?.hasEncrypted
             || false;
         return { schema, hasFile, hasEncrypted };
     }