nesoi 3.0.20 → 3.1.0

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, 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], {
+    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], Options extends string ? EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options], [false, false], {
+        '': 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];
     }>;
-    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>;
+    } & 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"]>;
+    } & { [J in keyof T["#modelpath"] as `.$${number}${J & string}` | `.${string}${J & string}`]: T["#modelpath"][J]; } & { [J_1 in keyof T["#modelpath"] as `.*${J_1 & string}`]: Record<string, T["#modelpath"][J_1]>; }, {
+        '': 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"][];
+    } & { [J in keyof T["#modelpath"] as `.$${number}${J & string}` | `.${number}${J & string}`]: T["#modelpath"][J]; } & { [J_1 in keyof T["#modelpath"] as `.*${J_1 & string}`]: T["#modelpath"][J_1][]; }, {
+        '': 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 };
     }

package/lib/elements/entities/bucket/query/nql.schema.d.ts

@@ -2,6 +2,7 @@ import { $Bucket } from '../bucket.schema';
 import { $Module } from "../../../../schema";
 import { NesoiDate } from "../../../../engine/data/date";
 import { NesoiDatetime } from "../../../../engine/data/datetime";
+import { NesoiDuration } from "../../../../engine/data/duration";
 export type NQL_QueryMeta = {
     bucket?: $Bucket;
     scope?: string;
@@ -49,8 +50,8 @@ export type NQL_Node = NQL_Union | NQL_Intersection | NQL_Rule;
  * All operations
  */
 export type NQL_Operation = '==' | '>' | '<' | '>=' | '<=' | 'in' | 'contains' | 'contains_any' | 'present';
-export type NQL_Order<Fieldpath> = {
-    by?: keyof Fieldpath[];
+export type NQL_Order<Querypath> = {
+    by?: keyof Querypath[];
     dir?: ('asc' | 'desc')[];
 };
 export type NQL_Pagination = {
@@ -61,7 +62,7 @@ export type NQL_Pagination = {
 /**
  * A union of all operators which apply to the selected field
  */
-type NQL_OpFromField<T> = T extends boolean ? '' | ' ==' | ' in' | ' present' : T extends number | NesoiDate | NesoiDatetime ? '' | ' ==' | ' >' | ' <' | ' >=' | ' <=' | ' in' | ' present' : T extends string ? '' | ' ==' | ' in' | ' contains' | ' contains_any' | ' present' | ' ~' | ' ~in' | ' ~contains' | ' ~contains_any' : T extends boolean[] | number[] | NesoiDate[] | NesoiDatetime[] | string[] ? '' | ' ==' | ' in' | ' contains' | ' contains_any' | ' present' : T extends object ? ' contains' | ' contains_any' | ' present' : ' present';
+type NQL_OpFromField<T> = T extends boolean ? '' | ' ==' | ' in' | ' present' : T extends number | NesoiDate | NesoiDatetime | NesoiDuration ? '' | ' ==' | ' >' | ' <' | ' >=' | ' <=' | ' in' | ' present' : T extends string ? '' | ' ==' | ' in' | ' contains' | ' contains_any' | ' present' | ' ~' | ' ~in' | ' ~contains' | ' ~contains_any' : T extends object ? ' contains' | ' contains_any' | ' present' : ' present';
 /**
  * A dict of accepted values for a given operator on a bucket field
  */
@@ -92,13 +93,15 @@ type NQL_ConditionValue<T, Parameters, Titem = NoInfer<T extends (infer X)[] ? X
     '.': P;
 } | {
     '.': PArr;
-}[];
+}[] | {
+    '$': string;
+};
 /**
  * A field name of the subquery bucket which resolves to
  * a type that's compatible with the query
  */
-type NQL_SubQueryField<$ extends $Bucket, Field, Fieldpath = NoInfer<$['#fieldpath']>, T = NoInfer<Fieldpath[Field & keyof Fieldpath]>> = keyof {
-    [X in keyof Fieldpath as NonNullable<T> extends NonNullable<Fieldpath[X]> ? X : never]: any;
+type NQL_SubQueryField<$ extends $Bucket, Field, Querypath = NoInfer<$['#modelpath']>, T = NoInfer<Querypath[Field & keyof Querypath]>> = keyof {
+    [X in keyof Querypath as NonNullable<T> extends NonNullable<Querypath[X]> ? X : never]: any;
 };
 /**
  * A subquery passed as value to a query
@@ -120,14 +123,14 @@ type NQL_GraphLinks<M extends $Module, $ extends $Bucket, Parameters = {}> = {
     All possible query rules on the format:
     (or |)FIELDNAME( not|)OPERATOR
 */
-type NQL_Terms<M extends $Module, $ extends $Bucket, Parameters = {}, Fieldpath = NoInfer<$['#fieldpath']>, Conditions = NoInfer<{
-    [Field in keyof Fieldpath as Field]: {
-        [Op in NQL_OpFromField<Fieldpath[Field]> as `${'or ' | ''}${Field & string}${' not' | ''}${Op}`]?: NQL_ConditionValue<NQL_ValueFromOp<Fieldpath[Field]>[Op], Parameters> | NQL_SubQuery<M, Field, Parameters>;
+type NQL_Terms<M extends $Module, $ extends $Bucket, Parameters = {}, Querypath = NoInfer<$['#querypath']>, Conditions = NoInfer<{
+    [Field in keyof Querypath as Field]: {
+        [Op in NQL_OpFromField<Querypath[Field]> as `${'or ' | ''}${Field & string}${' not' | ''}${Op}`]?: NQL_ConditionValue<NQL_ValueFromOp<Querypath[Field]>[Op], Parameters> | NQL_SubQuery<M, Field, Parameters>;
     };
 }>> = Conditions[keyof Conditions] & {
     [K in `${'#and' | '#or'}${string}`]?: NQL_Terms<M, $, Parameters>;
 } & NQL_GraphLinks<M, $, Parameters> & {
-    '#order'?: NQL_Order<Fieldpath>;
+    '#order'?: NQL_Order<Querypath>;
 };
 /**
  * NQL Dynamic Query Type

package/lib/elements/entities/bucket/query/nql_compiler.js

@@ -86,14 +86,16 @@ class NQL_RuleTree {
         let by = value['by'];
         if (by) {
             for (const key of by) {
-                const field = bucket_model_schema_1.$BucketModel.get(bucket.schema.model, key);
-                if (!field) {
+                const fields = bucket_model_schema_1.$BucketModel.getField(bucket.schema.model, key);
+                if (!fields.length) {
                     throw new Error(`Field '${key}' not found on bucket '${bucket.schema.name}'`);
                 }
-                if (![
-                    'date', 'datetime', 'duration', 'decimal', 'enum', 'float', 'int', 'string'
-                ].includes(field.type)) {
-                    throw new Error(`Field '${key}' is not sortable`);
+                for (const field of fields) {
+                    if (![
+                        'date', 'datetime', 'duration', 'decimal', 'enum', 'float', 'int', 'string'
+                    ].includes(field.type)) {
+                        throw new Error(`Field '${key}' is not sortable`);
+                    }
                 }
             }
         }
@@ -141,25 +143,46 @@ class NQL_RuleTree {
                 throw new Error(`Invalid term '${key}'`);
             }
             const [_, or, fieldpath, not, case_i, op] = term;
-            const field = bucket_model_schema_1.$BucketModel.get(bucket.schema.model, fieldpath);
-            if (!field) {
+            const fields = bucket_model_schema_1.$BucketModel.getField(bucket.schema.model, fieldpath);
+            if (!fields.length) {
                 throw new Error(`Field '${fieldpath}' not found on bucket '${bucket.schema.name}'`);
             }
-            const _op = this.parseOp(bucket.schema.name, field, op);
+            const _op = this.parseOp(bucket.schema.name, fields, op);
             return { type: 'fieldpath', or: !!or, fieldpath, not: !!not, case_i: !!case_i, op: _op };
         }
     }
-    parseOp(bucketName, field, op) {
+    parseOp(bucketName, fields, op) {
         const _op = (op === '' ? '==' : op);
-        if (![
-            '==', '>', '<', '>=', '<=',
-            'in', 'contains', 'contains_any', 'present'
-        ].includes(_op)) {
-            throw new Error(`Invalid operation '${_op}' not found on bucket '${bucketName}'`);
-        }
-        const allowedOps = NQL_RuleTree.OpByType[field.type];
-        if (!allowedOps.includes(_op)) {
-            throw new Error(`Field '${field.name}' of type '${field.type}' doesn't support operation '${op}'`);
+        for (const field of fields) {
+            if (![
+                '==', '>', '<', '>=', '<=',
+                'in', 'contains', 'contains_any', 'present'
+            ].includes(_op)) {
+                throw new Error(`Invalid operation '${_op}'`);
+            }
+            let allowedOps;
+            // If field is a union, use the intersection of allowed operations
+            if (field.type === 'union') {
+                const children = Object.values(field.children);
+                const opsUnion = children
+                    .map(f => NQL_RuleTree.OpByType[f.type])
+                    .flat(1);
+                const dict = {};
+                for (const op of opsUnion) {
+                    dict[op] ?? (dict[op] = 0);
+                    dict[op]++;
+                }
+                allowedOps = Object.entries(dict)
+                    .filter(([k, v]) => v === children.length)
+                    .map(([k]) => k);
+            }
+            // If not, use the field allowed operations
+            else {
+                allowedOps = NQL_RuleTree.OpByType[field.type];
+            }
+            if (!allowedOps.includes(_op)) {
+                throw new Error(`Field '${field.name}' of type '${field.type}' doesn't support operation '${_op}'`);
+            }
         }
         return _op;
     }
@@ -223,7 +246,7 @@ class NQL_RuleTree {
                 if (!bucket) {
                     throw new Error(`Bucket '${bucket}' not found on module`);
                 }
-                const field = bucket_model_schema_1.$BucketModel.get(bucket.schema.model, fieldpath);
+                const field = bucket_model_schema_1.$BucketModel.getField(bucket.schema.model, fieldpath);
                 if (!field) {
                     throw new Error(`Field '${fieldpath}' not found on bucket '${bucket.schema.name}'`);
                 }
@@ -442,8 +465,10 @@ NQL_RuleTree.OpByType = {
     'file': [],
     'float': ['<', '<=', '==', '>', '>=', 'in', 'present'],
     'int': ['<', '<=', '==', '>', '>=', 'in', 'present'],
-    'obj': ['==', 'contains', 'contains_any', 'in', 'present'],
     'string': ['==', 'contains', 'contains_any', 'in', 'present'],
+    'obj': ['contains_any', 'in', 'present'],
+    'list': ['contains', 'contains_any', 'present'],
+    'union': [],
     'unknown': ['present']
 };
 /**

package/lib/elements/entities/bucket/view/bucket_view.builder.js

@@ -21,7 +21,7 @@ class BucketViewBuilder {
     static build(builder, model, graph, views) {
         const fields = bucket_view_field_builder_1.BucketViewFieldBuilder.buildFields(builder._fields, model, graph, views);
         const schema = new bucket_view_schema_1.$BucketView(builder.name, fields);
-        schema.fields.id = new bucket_view_schema_1.$BucketViewField('id', 'model', 'id', 'id', false, true, { model: { key: 'id' } });
+        schema.fields.id = new bucket_view_schema_1.$BucketViewField('id', 'model', 'id', { model: { path: 'id' } });
         return schema;
     }
 }

package/lib/elements/entities/bucket/view/bucket_view.d.ts

@@ -11,4 +11,23 @@ export declare class BucketView<$ extends $BucketView> {
     schema: $;
     constructor(bucket: Bucket<any, any>, schema: $);
     parse<Obj extends NesoiObj>(trx: AnyTrxNode, raw: Obj): Promise<$['#data']>;
+    private parseLayer;
+    /**
+     * [model]
+     * Read one property from
+     */
+    private parseModelProp;
+    private doParseModelProp;
+    /**
+     * [computed]
+     */
+    private parseComputedProp;
+    /**
+     * [graph]
+     */
+    private parseGraphProp;
+    /**
+     * [drive]
+     */
+    private parseDriveProp;
 }