nesoi 3.4.0 → 3.4.2

package/lib/compiler/elements/bucket.element.js

@@ -206,9 +206,9 @@ class BucketElement extends element_1.Element {
             for (const key in fields) {
                 const field = fields[key];
                 if (field.scope === 'model' && 'model' in field.meta) {
-                    const modelFields = bucket_model_schema_1.$BucketModel.getField(this.schema.model, field.meta.model.path);
+                    const modelFields = bucket_model_schema_1.$BucketModel.getFields(this.schema.model, field.meta.model.path);
                     const types = [];
-                    if (!field.children || '__raw' in field.children) {
+                    if (!field.children || '__root' in field.children) {
                         types.push(dump_helpers_1.DumpHelpers.dumpUnionType(modelFields.map(f => this.buildModelFieldType(f))));
                     }
                     // Contains children
@@ -238,7 +238,7 @@ class BucketElement extends element_1.Element {
             return data;
         };
         const data = {};
-        if ('__raw' in schema) {
+        if ('__root' in schema) {
             Object.assign(data, model);
         }
         const viewData = buildFields(schema);

package/lib/compiler/typescript/bridge/extract.js

@@ -99,7 +99,7 @@ class TSBridgeExtract {
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'bucket.*.view.1.return.**.chain.0',
+                query: 'bucket.*.view.1.return.**.transform.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {

package/lib/compiler/typescript/bridge/organize.js

@@ -54,9 +54,9 @@ class TSBridgeOrganize {
             organized.buckets[tag].views[view].computed[prop] = node;
             return;
         }
-        const viewChain = path.match(/view▹(\w+)▹1▹return▹([\w|\\.]+)▹chain▹0/);
-        if (viewChain) {
-            const [_, view, prop] = viewChain;
+        const viewTransform = path.match(/view▹(\w+)▹1▹return▹([\w|\\.]+)▹transform▹0/);
+        if (viewTransform) {
+            const [_, view, prop] = viewTransform;
             organized.buckets[tag] ??= { views: {}, tenancy: {} };
             organized.buckets[tag].views[view] ??= { computed: {}, chain: {} };
             organized.buckets[tag].views[view].chain[prop] = node;

package/lib/elements/entities/bucket/adapters/memory.nql.js

@@ -172,26 +172,15 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
         };
         const _rule = (rule, objs, params, param_templates) => {
             const out = {};
-            const combos = [];
-            for (const param of params) {
-                if (param_templates.length) {
-                    for (const template of param_templates) {
-                        combos.push({ params: param, param_template: template });
-                    }
-                }
-                else {
-                    combos.push({ params: param, param_template: {} });
-                }
-            }
-            for (const combo of combos) {
-                const match = _index(rule, objs, combo.params, combo.param_template);
+            for (let i = 0; i < params.length; i++) {
+                const match = _index(rule, objs, params[i], param_templates[i] ?? {});
                 if (match) {
                     Object.assign(out, match);
                     continue;
                 }
                 for (const id in objs) {
                     const obj = objs[id];
-                    let match = _obj(rule, obj, combo.params, combo.param_template);
+                    let match = _obj(rule, obj, params[i], param_templates[i] ?? {});
                     if (rule.not) {
                         match = !match;
                     }
@@ -235,11 +224,16 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
                 }
             }
             else if ('param_with_$' in rule.value) {
-                let path = rule.value.param_with_$;
-                for (const key in param_template) {
-                    path = path.replace(new RegExp(key.replace('$', '\\$'), 'g'), param_template[key]);
+                if (Object.keys(param_template).length) {
+                    let path = rule.value.param_with_$;
+                    for (const key in param_template) {
+                        path = path.replace(new RegExp(key.replace('$', '\\$'), 'g'), param_template[key]);
+                    }
+                    queryValue = tree_1.Tree.get(params, path);
+                }
+                else {
+                    queryValue = undefined;
                 }
-                queryValue = tree_1.Tree.get(params, path);
             }
             else if ('static' in rule.value) {
                 queryValue = rule.value.static;

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

@@ -133,11 +133,15 @@ export declare class Bucket<M extends $Module, $ extends $Bucket> {
     /**
      * Build one object with a view
      */
-    buildOne<V extends ViewName<$>, Obj extends ViewObj<$, V>>(trx: AnyTrxNode, obj: $['#data'], view: V): Promise<Obj>;
+    buildOne<V extends ViewName<$>, Obj extends ViewObj<$, V>>(trx: AnyTrxNode, obj: $['#data'], view: V, flags?: {
+        serialize: boolean;
+    }): Promise<Obj>;
     /**
      * Build a list ob objects with a view
      */
-    buildMany<V extends ViewName<$>, Obj extends ViewObj<$, V>>(trx: AnyTrxNode, objs: $['#data'][], view: V): Promise<Obj[]>;
+    buildMany<V extends ViewName<$>, Obj extends ViewObj<$, V>>(trx: AnyTrxNode, objs: $['#data'][], view: V, flags?: {
+        serialize: boolean;
+    }): Promise<Obj[]>;
     /**
      * Create an entity
      */

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

@@ -304,20 +304,20 @@ class Bucket {
     /**
      * Build one object with a view
      */
-    async buildOne(trx, obj, view) {
+    async buildOne(trx, obj, view, flags) {
         if (!(view in this.views)) {
             throw error_1.NesoiError.Bucket.ViewNotFound({ bucket: this.schema.alias, view: view });
         }
-        return this.views[view].parse(trx, obj);
+        return this.views[view].parse(trx, obj, flags);
     }
     /**
      * Build a list ob objects with a view
      */
-    async buildMany(trx, objs, view) {
+    async buildMany(trx, objs, view, flags) {
         if (!(view in this.views)) {
             throw error_1.NesoiError.Bucket.ViewNotFound({ bucket: this.schema.alias, view: view });
         }
-        return this.views[view].parseMany(trx, objs);
+        return this.views[view].parseMany(trx, objs, flags);
     }
     // Create
     /**

package/lib/elements/entities/bucket/graph/bucket_graph.js

@@ -94,6 +94,14 @@ class BucketGraph {
      *   - `no_tenancy`: Don't apply tenancy rules (default: `false`)
      */
     async readManyLinks(trx, objs, link, options) {
+        // Optimization
+        if (objs.length <= 1) {
+            const result = await this.readLink(trx, objs[0], {
+                name: link.name,
+                index: link.indexes[0] ?? []
+            }, options);
+            return [result];
+        }
         log_1.Log.trace('bucket', this.bucketName, `Read link ${link.name}`);
         const schema = this.schema.links[link.name];
         // 1st Query
@@ -150,17 +158,19 @@ class BucketGraph {
                 }
             },
         });
-        for (const obj of objs) {
+        for (let i = 0; i < objs.length; i++) {
             let result;
+            const param = [{ ...objs[i] }];
+            const param_template = param_templates ? [param_templates[i]] : [];
             if (tempAdapter instanceof bucket_cache_1.BucketCache) {
                 result = await tempAdapter._queryCompiled(trx, compiled, {
                     perPage: schema.many ? undefined : 1,
-                }, [{ ...obj }], undefined);
+                }, param, param_template);
             }
             else {
                 result = await tempAdapter._queryCompiled(trx, compiled, {
                     perPage: schema.many ? undefined : 1,
-                }, [{ ...obj }], undefined, undefined, {
+                }, param, param_template, undefined, {
                     module: schema.bucket.module,
                     buckets: {
                         [schema.bucket.short]: {

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToView = convertToView;
 exports.convertToMessage = convertToMessage;
-const bucket_view_builder_1 = require("../view/bucket_view.builder");
 const bucket_view_schema_1 = require("../view/bucket_view.schema");
 const message_template_schema_1 = require("../../message/template/message_template.schema");
 const bucket_graph_schema_1 = require("../graph/bucket_graph.schema");
@@ -13,22 +12,15 @@ const message_schema_1 = require("../../message/message.schema");
  * @subcategory Entity
  * */
 function convertToView(model, name, fields = model.fields, path, depth = 0) {
-    const view = new bucket_view_builder_1.BucketViewBuilder(name);
-    const convertFields = (fields) => {
-        const viewFields = {};
-        for (const f in fields) {
-            const field = fields[f];
-            const $ = new bucket_view_field_builder_1.BucketViewFieldFactory();
-            const key = (path ? path + '.' : '')
-                + field.name;
-            const builder = $.model(key);
-            const graph = new bucket_graph_schema_1.$BucketGraph();
-            viewFields[f] = bucket_view_field_builder_1.BucketViewFieldBuilder.build(builder, model, graph, {}, field.name, depth);
-        }
-        return viewFields;
-    };
-    const v = new bucket_view_schema_1.$BucketView(name, convertFields(fields));
-    return v;
+    return new bucket_view_schema_1.$BucketView(name, Object.fromEntries(Object.entries(fields).map(([model_key, model_field]) => {
+        const $ = new bucket_view_field_builder_1.BucketViewFieldFactory();
+        const key = (path ? path + '.' : '')
+            + model_field.name;
+        const builder = $.model(key);
+        const graph = new bucket_graph_schema_1.$BucketGraph();
+        const view_field = bucket_view_field_builder_1.BucketViewFieldBuilder.build(builder, model, graph, {}, model_field.name, depth);
+        return [model_key, view_field];
+    })));
 }
 /**
  * @category Elements

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

@@ -7,6 +7,11 @@ type BucketModelCopyCmd = {
     copy: Record<string, any>;
     path: string;
     depth: number;
+    modelpath?: {
+        i: number;
+        asterisk_values: string[];
+    };
+    is_union_option?: boolean | 'last';
 };
 /**
  * @category Elements
@@ -17,6 +22,6 @@ export declare class BucketModel<M extends $Module, $ extends $Bucket> {
     private alias;
     private schema;
     constructor(bucket: $Bucket, config?: BucketAdapterConfig | undefined);
-    copy<T extends Record<string, any>>(obj: T, op: 'save' | 'load', serialize?: (cmd?: BucketModelCopyCmd) => boolean): T;
+    copy<T extends Record<string, any>>(obj: T, op: 'save' | 'load', serialize?: (cmd?: BucketModelCopyCmd) => boolean, modelpath?: string): T;
 }
 export {};

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

@@ -19,7 +19,7 @@ class BucketModel {
         this.alias = bucket.alias;
         this.schema = bucket.model;
     }
-    copy(obj, op, serialize) {
+    copy(obj, op, serialize, modelpath) {
         const meta = this.config?.meta || {
             created_at: 'created_at',
             created_by: 'created_by',
@@ -27,65 +27,170 @@ class BucketModel {
             updated_by: 'updated_by',
         };
         const copy = {};
-        let poll = Object.entries(this.schema.fields).map(([path, field]) => ({
-            path, obj, copy, field, depth: 0
-        }));
+        const modelpath_results = [];
+        const paths = modelpath?.split('.');
+        let poll = paths
+            // Specific modelpath requested, start with root field only
+            ? [{
+                    path: paths[0],
+                    obj,
+                    copy,
+                    field: this.schema.fields[paths[0]],
+                    depth: 0,
+                    modelpath: { i: 0, asterisk_values: [] }
+                }]
+            // No modelpath, use all fields
+            : Object.entries(this.schema.fields).map(([path, field]) => ({
+                path, obj, copy, field, depth: 0
+            }));
         while (poll.length) {
             const next = [];
             for (const entry of poll) {
+                if (entry.is_union_option) {
+                    const alreadyParsed = entry.copy[entry.path] !== undefined;
+                    if (alreadyParsed)
+                        continue;
+                }
                 const val = entry.obj[entry.path];
                 if (val === undefined) {
+                    delete entry.copy[entry.path];
                     continue;
                 }
                 if (val === null) {
-                    entry.copy[entry.path] = null;
+                    delete entry.copy[entry.path];
                     continue;
                 }
+                const isLeafPath = entry.modelpath
+                    ? entry.modelpath.i === (paths?.length ?? 0) - 1
+                    : false;
+                const nextPath = (!entry.modelpath || isLeafPath)
+                    ? undefined
+                    : paths[entry.modelpath.i + 1];
+                const addChildrenToQueue = !entry.modelpath
+                    || entry.modelpath.i >= (paths.length - 1)
+                    || nextPath === '*';
                 if (entry.field.type === 'list') {
                     if (!Array.isArray(val))
                         continue;
                     entry.copy[entry.path] = [];
-                    next.push(...val.map((_, i) => ({
-                        path: i.toString(),
-                        obj: val,
-                        copy: entry.copy[entry.path],
-                        field: entry.field.children['#'],
-                        depth: entry.depth + 1
-                    })));
+                    // Leaf path or no modelpath = add entire list to queue
+                    if (addChildrenToQueue) {
+                        next.push(...val.map((_, i) => ({
+                            path: i.toString(),
+                            obj: val,
+                            copy: entry.copy[entry.path],
+                            field: entry.field.children['#'],
+                            depth: entry.depth + 1,
+                            modelpath: entry.modelpath ? {
+                                i: entry.modelpath.i + 1,
+                                asterisk_values: [...entry.modelpath.asterisk_values, ...(nextPath === '*' ? [i.toString()] : [])]
+                            } : undefined
+                        })));
+                    }
+                    // Branch path = add next path to queue
+                    else {
+                        next.push({
+                            path: nextPath,
+                            obj: val,
+                            copy: entry.copy[entry.path],
+                            field: entry.field.children['#'],
+                            depth: entry.depth + 1,
+                            modelpath: entry.modelpath ? {
+                                i: entry.modelpath.i + 1,
+                                asterisk_values: entry.modelpath.asterisk_values
+                            } : undefined
+                        });
+                    }
                 }
                 else if (entry.field.type === 'dict') {
                     if (typeof val !== 'object' || Array.isArray(val))
                         continue;
                     entry.copy[entry.path] = {};
-                    next.push(...Object.keys(val).map((path) => ({
-                        path,
-                        obj: val,
-                        copy: entry.copy[entry.path],
-                        field: entry.field.children['#'],
-                        depth: entry.depth + 1
-                    })));
+                    // Leaf path or no modelpath = add entire dict to queue
+                    if (addChildrenToQueue) {
+                        next.push(...Object.keys(val).map((path) => ({
+                            path,
+                            obj: val,
+                            copy: entry.copy[entry.path],
+                            field: entry.field.children['#'],
+                            depth: entry.depth + 1,
+                            modelpath: entry.modelpath ? {
+                                i: entry.modelpath.i + 1,
+                                asterisk_values: [...entry.modelpath.asterisk_values, ...(nextPath === '*' ? [path] : [])]
+                            } : undefined
+                        })));
+                    }
+                    // Branch path = add next path to queue
+                    else {
+                        next.push({
+                            path: nextPath,
+                            obj: val,
+                            copy: entry.copy[entry.path],
+                            field: entry.field.children['#'],
+                            depth: entry.depth + 1,
+                            modelpath: entry.modelpath ? {
+                                i: entry.modelpath.i + 1,
+                                asterisk_values: entry.modelpath.asterisk_values
+                            } : undefined
+                        });
+                    }
                 }
                 else if (entry.field.type === 'obj') {
                     if (typeof val !== 'object' || Array.isArray(val))
                         continue;
+                    // disambiguate between dict and obj when obj comes first
+                    // on a union
+                    const objectHasValidFields = Object.keys(val).some(key => key in entry.field.children);
+                    if (!objectHasValidFields)
+                        continue;
                     entry.copy[entry.path] = {};
-                    next.push(...Object.keys(entry.field.children).map(path => ({
-                        path: path,
-                        obj: val,
-                        copy: entry.copy[entry.path],
-                        field: entry.field.children[path],
-                        depth: entry.depth + 1
-                    })));
+                    // Leaf path or no modelpath = add entire dict to queue
+                    if (addChildrenToQueue) {
+                        next.push(...Object.keys(entry.field.children).map(path => ({
+                            path: path,
+                            obj: val,
+                            copy: entry.copy[entry.path],
+                            field: entry.field.children[path],
+                            depth: entry.depth + 1,
+                            modelpath: entry.modelpath ? {
+                                i: entry.modelpath.i + 1,
+                                asterisk_values: [...entry.modelpath.asterisk_values, ...(nextPath === '*' ? [path] : [])]
+                            } : undefined
+                        })));
+                    }
+                    // Branch path = add next path to queue
+                    else {
+                        next.push({
+                            path: nextPath,
+                            obj: val,
+                            copy: entry.copy[entry.path],
+                            field: entry.field.children[nextPath],
+                            depth: entry.depth + 1,
+                            modelpath: entry.modelpath ? {
+                                i: entry.modelpath.i + 1,
+                                asterisk_values: entry.modelpath.asterisk_values
+                            } : undefined
+                        });
+                    }
                 }
                 else if (entry.field.type === 'union') {
-                    // TODO: ??????????   
-                    entry.copy[entry.path] = entry.obj[entry.path];
+                    const options = Object.entries(entry.field.children);
+                    // Add union options to queue with flag
+                    // This flag avoids reparsing a value if an earlier option already did it
+                    next.push(...options.map(([_, option], i) => ({
+                        ...entry,
+                        field: option,
+                        is_union_option: i === options.length - 1 ? 'last' : true
+                    })));
+                    continue;
                 }
                 else if (entry.field.type === 'enum') {
                     const v = entry.obj[entry.path];
                     const options = entry.field.meta.enum.options;
                     if (!(v in options)) {
-                        throw error_1.NesoiError.Bucket.Model.InvalidEnum({ bucket: this.alias, value: v, options: Object.keys(options) });
+                        if (entry.is_union_option !== true) {
+                            throw error_1.NesoiError.Bucket.Model.InvalidEnum({ bucket: this.alias, value: v, options: Object.keys(options) });
+                        }
                     }
                     entry.copy[entry.path] = entry.obj[entry.path];
                 }
@@ -97,7 +202,10 @@ class BucketModel {
                                 entry.copy[entry.path] = date_1.NesoiDate.fromISO(v);
                             }
                             catch {
-                                throw error_1.NesoiError.Bucket.Model.InvalidISODate({ bucket: this.alias, value: v });
+                                if (entry.is_union_option !== true) {
+                                    throw error_1.NesoiError.Bucket.Model.InvalidISODate({ bucket: this.alias, value: v });
+                                }
+                                continue;
                             }
                         }
                         else if (op === 'save') {
@@ -105,7 +213,10 @@ class BucketModel {
                                 entry.copy[entry.path] = v.toISO();
                             }
                             catch {
-                                throw error_1.NesoiError.Bucket.Model.InvalidNesoiDate({ bucket: this.alias, value: v });
+                                if (entry.is_union_option !== true) {
+                                    throw error_1.NesoiError.Bucket.Model.InvalidNesoiDate({ bucket: this.alias, value: v });
+                                }
+                                continue;
                             }
                         }
                     }
@@ -121,7 +232,10 @@ class BucketModel {
                                 entry.copy[entry.path] = datetime_1.NesoiDatetime.fromISO(v);
                             }
                             catch {
-                                throw error_1.NesoiError.Bucket.Model.InvalidISODatetime({ bucket: this.alias, value: v });
+                                if (entry.is_union_option !== true) {
+                                    throw error_1.NesoiError.Bucket.Model.InvalidISODatetime({ bucket: this.alias, value: v });
+                                }
+                                continue;
                             }
                         }
                         else if (op === 'save') {
@@ -129,7 +243,10 @@ class BucketModel {
                                 entry.copy[entry.path] = v.toISO();
                             }
                             catch {
-                                throw error_1.NesoiError.Bucket.Model.InvalidNesoiDatetime({ bucket: this.alias, value: v });
+                                if (entry.is_union_option !== true) {
+                                    throw error_1.NesoiError.Bucket.Model.InvalidNesoiDatetime({ bucket: this.alias, value: v });
+                                }
+                                continue;
                             }
                         }
                     }
@@ -141,30 +258,60 @@ class BucketModel {
                     const meta = entry.field.meta.decimal;
                     const v = entry.obj[entry.path];
                     if (serialize?.(entry)) {
+                        if ((op === 'load' && typeof v !== 'string') || (op === 'save' && !(v instanceof decimal_1.NesoiDecimal))) {
+                            if (entry.is_union_option !== true) {
+                                throw error_1.NesoiError.Bucket.Model.InvalidNesoiDecimal({ bucket: this.alias, value: v });
+                            }
+                            continue;
+                        }
                         if (op === 'load')
                             entry.copy[entry.path] = new decimal_1.NesoiDecimal(v, meta?.left, meta?.right);
                         if (op === 'save')
                             entry.copy[entry.path] = v.toString();
                     }
                     else {
+                        if (!(v instanceof decimal_1.NesoiDecimal)) {
+                            if (entry.is_union_option !== true) {
+                                throw error_1.NesoiError.Bucket.Model.InvalidNesoiDecimal({ bucket: this.alias, value: v });
+                            }
+                            continue;
+                        }
                         entry.copy[entry.path] = v;
                     }
                 }
                 else if (entry.field.type === 'duration') {
                     const v = entry.obj[entry.path];
                     if (serialize?.(entry)) {
+                        if ((op === 'load' && typeof v !== 'string') || (op === 'save' && !(v instanceof duration_1.NesoiDuration))) {
+                            if (entry.is_union_option !== true) {
+                                throw error_1.NesoiError.Bucket.Model.InvalidNesoiDuration({ bucket: this.alias, value: v });
+                            }
+                            continue;
+                        }
                         if (op === 'load')
                             entry.copy[entry.path] = duration_1.NesoiDuration.fromString(v);
                         if (op === 'save')
                             entry.copy[entry.path] = v.toString();
                     }
                     else {
+                        if (!(v instanceof duration_1.NesoiDuration)) {
+                            if (entry.is_union_option !== true) {
+                                throw error_1.NesoiError.Bucket.Model.InvalidNesoiDuration({ bucket: this.alias, value: v });
+                            }
+                            continue;
+                        }
                         entry.copy[entry.path] = v;
                     }
                 }
                 else {
                     entry.copy[entry.path] = entry.obj[entry.path];
                 }
+                if (isLeafPath) {
+                    modelpath_results.push({
+                        value: entry.copy[entry.path],
+                        index: entry.modelpath.asterisk_values
+                    });
+                }
             }
             poll = next;
         }
@@ -184,6 +331,8 @@ class BucketModel {
             copy[meta.created_at] = obj[meta.created_at];
             copy[meta.updated_at] = obj[meta.updated_at];
         }
+        if (modelpath)
+            return modelpath_results;
         return copy;
     }
 }

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

@@ -69,7 +69,7 @@ export declare class $BucketModel {
     constructor(fields: $BucketModelFields & {
         id: $BucketModelField;
     }, defaults?: Record<string, any>, hasFileField?: boolean, hasEncryptedField?: boolean);
-    static getField(model: $BucketModel, modelpath: string): $BucketModelField[];
+    static getFields(model: $BucketModel, modelpath: string): $BucketModelField[];
     static fieldsOfType(model: $BucketModel, type: $BucketModelFieldType): $BucketModelField[];
     static forEachField(model: $BucketModel, predicate: (field: $BucketModelField, path: string) => Promise<void>): Promise<void>;
     static getModelpaths(model: $BucketModel): Record<string, $BucketModelField[]>;

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

@@ -45,7 +45,7 @@ class $BucketModel {
         this.hasFileField = hasFileField;
         this.hasEncryptedField = hasEncryptedField;
     }
-    static getField(model, modelpath) {
+    static getFields(model, modelpath) {
         const paths = modelpath.split('.');
         const results = [];
         let poll = [{ i: 0, field: { children: model.fields } }];
@@ -66,7 +66,7 @@ class $BucketModel {
                     })));
                     continue;
                 }
-                // If it's a list or dict, or an object 
+                // If it's a list or dict, add the index field
                 if (field.type === 'list' || field.type === 'dict') {
                     next.push({
                         i: item.i + 1,

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

@@ -53,6 +53,7 @@ export type NQL_Part = {
     many: boolean;
     union: NQL_Union;
     parent?: NQL_Part;
+    select?: string;
 };
 export type NQL_Node = NQL_Union | NQL_Intersection | NQL_Rule;
 /**

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

@@ -142,7 +142,7 @@ class NQL_RuleTree {
             }
             const is_metadata_field = Object.values(meta.meta).includes(key);
             if (!is_metadata_field) {
-                const fields = bucket_model_schema_1.$BucketModel.getField(meta.schema.model, key);
+                const fields = bucket_model_schema_1.$BucketModel.getFields(meta.schema.model, key);
                 if (!fields.length) {
                     throw new Error(`Field '${key}' not found on bucket '${meta.schema.name}'`);
                 }
@@ -191,7 +191,7 @@ class NQL_RuleTree {
                 const _op = this.parseOp([{ type: 'datetime', name: fieldpath }], op);
                 return { type: 'fieldpath', or: !!or, fieldpath, not: !!not, case_i: !!case_i, op: _op };
             }
-            const fields = bucket_model_schema_1.$BucketModel.getField(meta.schema.model, fieldpath);
+            const fields = bucket_model_schema_1.$BucketModel.getFields(meta.schema.model, fieldpath);
             if (!fields.length) {
                 throw new Error(`Field '${fieldpath}' not found on bucket '${meta.schema.name}'`);
             }
@@ -300,7 +300,7 @@ class NQL_RuleTree {
                     throw new Error(`Bucket '${subMeta}' not found on module`);
                 }
                 subMeta.scope = this.customBuckets[tag.short]?.scope || subMeta.scope;
-                const field = bucket_model_schema_1.$BucketModel.getField(subMeta.schema.model, fieldpath);
+                const field = bucket_model_schema_1.$BucketModel.getFields(subMeta.schema.model, fieldpath);
                 if (!field) {
                     throw new Error(`Field '${fieldpath}' not found on bucket '${subMeta.schema.name}'`);
                 }
@@ -617,7 +617,8 @@ class NQL_Compiler {
                                 ...union,
                                 inters: Array.from(Array(union.inters.length), _ => ({}))
                             },
-                            parent: partStack.at(-1)
+                            parent: partStack.at(-1),
+                            select: rule.value.subquery.select
                         };
                         // debugLog.push('+ [part] ' + newPart.i);
                         parts.push(newPart);

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

@@ -26,8 +26,6 @@ class NQL_Engine {
     async run(trx, query, pagination, params = [{}], param_templates = [], view, customBuckets) {
         if (!params.length)
             params = [{}];
-        if (!param_templates.length)
-            param_templates = [{}];
         let result = {
             data: []
         };