nesoi 3.2.8 → 3.3.0

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketModel = void 0;
+const error_1 = require("../../../../engine/data/error");
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
+class BucketModel {
+    constructor(bucket, config) {
+        this.config = config;
+        this.alias = bucket.alias;
+        this.schema = bucket.model;
+    }
+    copy(obj) {
+        const meta = this.config?.meta || {
+            created_at: 'created_at',
+            created_by: 'created_by',
+            updated_at: 'updated_at',
+            updated_by: 'updated_by',
+        };
+        const copy = {};
+        let poll = Object.entries(this.schema.fields).map(([path, field]) => ({ path, obj, copy, field }));
+        while (poll.length) {
+            const next = [];
+            for (const entry of poll) {
+                const val = entry.obj[entry.path];
+                if (val === undefined) {
+                    continue;
+                }
+                if (val === null) {
+                    entry.copy[entry.path] = null;
+                    continue;
+                }
+                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['#']
+                    })));
+                }
+                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['#']
+                    })));
+                }
+                else if (entry.field.type === 'obj') {
+                    if (typeof val !== 'object' || Array.isArray(val))
+                        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]
+                    })));
+                }
+                else if (entry.field.type === 'union') {
+                    // TODO: ??????????   
+                    entry.copy[entry.path] = entry.obj[entry.path];
+                }
+                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) });
+                    }
+                    entry.copy[entry.path] = entry.obj[entry.path];
+                }
+                else {
+                    entry.copy[entry.path] = entry.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;
+    }
+}
+exports.BucketModel = BucketModel;

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

@@ -1,9 +1,8 @@
-import { $Dependency } from "../../../../engine/dependency";
-import { BucketAdapterConfig } from '../adapters/bucket_adapter';
+import { Tag } from "../../../../engine/dependency";
 export type $BucketModelFieldType = 'boolean' | 'date' | 'datetime' | 'duration' | 'decimal' | 'enum' | 'file' | 'float' | 'int' | 'string' | 'obj' | 'unknown' | 'dict' | 'list' | 'union' | 'literal';
 export type $BucketModelFieldCrypto = {
     algorithm: string;
-    key: string;
+    value: Tag;
 };
 /**
  * @category Schemas
@@ -20,8 +19,7 @@ export declare class $BucketModelField {
             template: string;
         };
         enum?: {
-            options: string | string[];
-            dep?: $Dependency;
+            options: Record<string, any>;
         };
         decimal?: {
             left?: number;
@@ -41,8 +39,7 @@ export declare class $BucketModelField {
             template: string;
         };
         enum?: {
-            options: string | string[];
-            dep?: $Dependency;
+            options: Record<string, any>;
         };
         decimal?: {
             left?: number;
@@ -75,6 +72,5 @@ export declare class $BucketModel {
     static getField(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 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

@@ -119,74 +119,6 @@ class $BucketModel {
             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 = entry.obj[entry.path];
-                if (val === undefined) {
-                    continue;
-                }
-                if (val === null) {
-                    entry.copy[entry.path] = null;
-                    continue;
-                }
-                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['#']
-                    })));
-                }
-                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['#']
-                    })));
-                }
-                else if (entry.field.type === 'obj') {
-                    if (typeof val !== 'object' || Array.isArray(val))
-                        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]
-                    })));
-                }
-                else if (entry.field.type === 'union') {
-                    // TODO: ??????????   
-                    entry.copy[entry.path] = entry.obj[entry.path];
-                }
-                else {
-                    entry.copy[entry.path] = entry.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 }));

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

@@ -2,10 +2,12 @@ import { $Module, $Space } from "../../../../schema";
 import { $BucketModelField, $BucketModelFieldType, $BucketModelFields } from './bucket_model.schema';
 import { NesoiDate } from "../../../../engine/data/date";
 import { BucketModelpathObjInfer, BucketModelpathDictInfer, BucketModelpathListInfer, BucketModelObjInfer, BucketQuerypathDictInfer, BucketQuerypathListInfer, BucketQuerypathObjInfer, BucketModelpathUnionInfer } from './bucket_model.infer';
+import { Dependency } from "../../../../engine/dependency";
 import { NesoiDecimal } from "../../../../engine/data/decimal";
 import { NesoiDatetime } from "../../../../engine/data/datetime";
 import { NesoiFile } from "../../../../engine/data/file";
 import { NesoiDuration } from "../../../../engine/data/duration";
+import { ModuleTree } from "../../../../engine/tree";
 /**
  * @category Builders
  * @subcategory Entity
@@ -134,7 +136,13 @@ export declare class BucketModelFieldBuilder<Module extends $Module, Input, Outp
     private _required;
     private _defaultValue?;
     private crypto?;
-    constructor(module: string, type: $BucketModelFieldType, alias?: string | undefined, meta?: $BucketModelField['meta'], children?: BucketModelFieldBuilders<Module> | undefined);
+    constructor(module: string, type: $BucketModelFieldType, alias?: string | undefined, meta?: (Omit<NonNullable<$BucketModelField["meta"]>, "enum"> & {
+        enum?: {
+            options: Record<string, any>;
+        } | {
+            dep: Dependency;
+        };
+    }) | undefined, children?: BucketModelFieldBuilders<Module> | undefined);
     as(alias: string): this;
     /**
      * This field can be `undefined` or `null`.
@@ -169,12 +177,12 @@ export declare class BucketModelFieldBuilder<Module extends $Module, Input, Outp
      */
     maxLength(val: number | null): void;
     encrypt(key: keyof Module['constants']['values'], algorithm?: string): this;
-    static build(builder: AnyBucketModelFieldBuilder, name: string, basePath?: string): {
+    static build(tree: ModuleTree, builder: AnyBucketModelFieldBuilder, name: string, basePath?: string): {
         schema: $BucketModelField;
         hasFile: boolean;
         hasEncrypted: boolean;
     };
-    static buildChildren(module: string, children: BucketModelFieldBuilders<any>, path?: string): {
+    static buildChildren(tree: ModuleTree, module: string, children: BucketModelFieldBuilders<any>, path?: string): {
         schema: $BucketModelFields;
         defaults: Record<string, any>;
         hasFileField: boolean;
@@ -182,6 +190,6 @@ export declare class BucketModelFieldBuilder<Module extends $Module, Input, Outp
     };
 }
 export type BucketModelFieldBuilders<Module extends $Module> = {
-    [x: string]: BucketModelFieldBuilder<Module, any, any, any, any, any> | BucketModelFieldBuilders<Module>;
+    [x: string]: BucketModelFieldBuilder<Module, any, any, any, any, any>;
 };
 export type AnyBucketModelFieldBuilder = BucketModelFieldBuilder<any, any, any, any, any, any>;

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

@@ -39,21 +39,22 @@ class BucketModelFieldFactory {
         });
     }
     enum(options) {
-        const strings = (Array.isArray(options) || typeof options === 'string')
-            ? options
-            : Object.keys(options);
-        let dep;
+        let meta;
         if (typeof options === 'string') {
-            const tag = dependency_1.$Tag.parseOrFail(options);
-            if (tag.module) {
-                dep = new dependency_1.$Dependency(this.module, 'constants', `${tag.module}::*`);
-            }
-            else {
-                dep = new dependency_1.$Dependency(this.module, 'constants', '*');
-            }
+            const tag = dependency_1.Tag.fromNameOrShort(this.module, 'constants.enum', options);
+            meta = { dep: new dependency_1.Dependency(this.module, tag, { build: true }) };
+        }
+        else if (Array.isArray(options)) {
+            const opts = {};
+            for (const opt of options)
+                opts[opt] = opt;
+            meta = { options: opts };
+        }
+        else {
+            meta = { options: options };
         }
         return new BucketModelFieldBuilder(this.module, 'enum', this.alias, {
-            enum: { options: strings, dep }
+            enum: meta
         });
     }
     get int() {
@@ -155,23 +156,31 @@ class BucketModelFieldBuilder {
     maxLength(val) {
     }
     encrypt(key, algorithm = 'aes256') {
+        const tag = dependency_1.Tag.fromNameOrShort(this.module, 'constants.value', key);
         this.crypto = {
             algorithm,
-            key: key
+            value: new dependency_1.Dependency(this.module, tag, { build: true })
         };
         return this;
     }
     // Build
-    static build(builder, name, basePath = '') {
+    static build(tree, builder, name, basePath = '') {
         const path = basePath + name;
         const childrenPath = path + '.';
+        if (builder.type === 'enum' && 'dep' in builder.meta.enum) {
+            const schema = dependency_1.Tag.resolve(builder.meta.enum.dep.tag, tree);
+            builder.meta.enum = { options: schema.options };
+        }
         const children = builder.children
-            ? BucketModelFieldBuilder.buildChildren(builder.module, builder.children, childrenPath)
+            ? BucketModelFieldBuilder.buildChildren(tree, builder.module, builder.children, childrenPath)
             : undefined;
         const defaults = builder._defaultValue && builder.children
             ? Object.assign({}, builder._defaultValue, children?.defaults)
             : builder._defaultValue;
-        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 schema = new bucket_model_schema_1.$BucketModelField(name, path, builder.type, builder.alias || name, builder._required, builder.meta, defaults, children?.schema, builder.crypto ? {
+            algorithm: builder.crypto.algorithm,
+            value: builder.crypto.value.tag
+        } : undefined);
         const hasFile = builder.type === 'file'
             || children?.hasFileField
             || false;
@@ -180,29 +189,17 @@ class BucketModelFieldBuilder {
             || false;
         return { schema, hasFile, hasEncrypted };
     }
-    static buildChildren(module, children, path) {
+    static buildChildren(tree, module, children, path) {
         const schema = {};
         const defaults = {};
         let hasFileField = false;
         let hasEncryptedField = false;
         for (const c in children) {
             const child = children[c];
-            if (child instanceof BucketModelFieldBuilder) {
-                const out = BucketModelFieldBuilder.build(child, c, path);
-                schema[c] = out.schema;
-                hasFileField || (hasFileField = out.hasFile);
-                hasEncryptedField || (hasEncryptedField = out.hasEncrypted);
-            }
-            // Builders are allowed to implicitly declare nested fields.
-            // The code below transforms these groups into fields of the scope 'group'.
-            else {
-                const fieldTypeBuilder = new BucketModelFieldFactory(module);
-                const fieldBuilder = fieldTypeBuilder.obj(child);
-                const out = BucketModelFieldBuilder.build(fieldBuilder, c, path);
-                schema[c] = out.schema;
-                hasFileField || (hasFileField = out.hasFile);
-                hasEncryptedField || (hasEncryptedField = out.hasEncrypted);
-            }
+            const out = BucketModelFieldBuilder.build(tree, child, c, path);
+            schema[c] = out.schema;
+            hasFileField || (hasFileField = out.hasFile);
+            hasEncryptedField || (hasEncryptedField = out.hasEncrypted);
             defaults[c] = schema[c].defaultValue;
         }
         return { schema, defaults, hasFileField, hasEncryptedField };

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

@@ -4,7 +4,7 @@ import { NesoiDate } from "../../../../engine/data/date";
 import { NesoiDatetime } from "../../../../engine/data/datetime";
 import { NesoiDuration } from "../../../../engine/data/duration";
 export type NQL_QueryMeta = {
-    bucket?: $Bucket;
+    schema?: $Bucket;
     scope?: string;
     avgTime: number;
 };

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

@@ -1,16 +1,20 @@
 import { NQL_AnyQuery, NQL_Union, NQL_Part, NQL_Node } from './nql.schema';
-import { AnyModule } from "../../../../engine/module";
+import { AnyDaemon } from "../../../../engine/daemon";
+import { BucketMetadata } from "../../../../engine/transaction/trx_engine";
 /**
  * @category NQL
  * */
 export declare class NQL_RuleTree {
+    private daemon;
     private module;
     private bucketName;
     private query;
+    private customMetadata?;
     private debug;
     private static OpByType;
     root: NQL_Union;
-    constructor(module: AnyModule, bucketName: string, query: NQL_AnyQuery, debug?: boolean);
+    constructor(daemon: AnyDaemon, module: string, bucketName: string, query: NQL_AnyQuery, customMetadata?: BucketMetadata | undefined, debug?: boolean);
+    parse(): Promise<void>;
     private parseUnion;
     private parseOrder;
     private parseKey;
@@ -35,8 +39,8 @@ export declare class NQL_RuleTree {
  * @category NQL
  * */
 export declare class NQL_Compiler {
-    static build(module: AnyModule, bucketName: string, query: NQL_AnyQuery): NQL_CompiledQuery;
-    static buildUnion(union: NQL_Union): NQL_CompiledQuery;
+    static build(daemon: AnyDaemon, module: string, bucketName: string, query: NQL_AnyQuery, customMetadata?: BucketMetadata): Promise<NQL_CompiledQuery>;
+    static buildTree(tree: NQL_RuleTree): Promise<NQL_CompiledQuery>;
 }
 /**
  * A query ready to be run by the NQL engine, which will call

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

@@ -3,32 +3,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NQL_CompiledQuery = exports.NQL_Compiler = exports.NQL_RuleTree = void 0;
 const bucket_model_schema_1 = require("../model/bucket_model.schema");
 const string_1 = require("../../../../engine/util/string");
+const daemon_1 = require("../../../../engine/daemon");
+const dependency_1 = require("../../../../engine/dependency");
 /**
  * @category NQL
  * */
 class NQL_RuleTree {
-    constructor(module, bucketName, query, debug = false) {
+    constructor(daemon, module, bucketName, query, customMetadata, debug = false) {
+        this.daemon = daemon;
         this.module = module;
         this.bucketName = bucketName;
         this.query = query;
+        this.customMetadata = customMetadata;
         this.debug = debug;
-        const bucket = module.buckets[this.bucketName];
-        this.root = this.parseUnion(bucket, query);
-        if (debug) {
+    }
+    async parse() {
+        const tag = dependency_1.Tag.fromNameOrShort(this.module, 'bucket', this.bucketName);
+        const bucket = this.customMetadata || await daemon_1.Daemon.getBucketMetadata(this.daemon, tag);
+        this.root = await this.parseUnion(bucket, this.query);
+        if (this.debug) {
             console.log(this.describe());
         }
         this.simplify();
         this._addDebugId();
-        if (debug) {
+        if (this.debug) {
             console.log(this.describe());
         }
     }
     // Parse NQL
-    parseUnion(bucket, query, select) {
-        const meta = bucket.getQueryMeta();
+    async parseUnion(bucket, query, select) {
         const union = {
             meta: {
-                ...meta,
+                ...bucket,
                 avgTime: 0
             },
             inters: [
@@ -37,14 +43,14 @@ class NQL_RuleTree {
         };
         for (const key in query) {
             const value = query[key];
-            const parsedKey = this.parseKey(bucket, key);
+            const parsedKey = await this.parseKey(bucket, key);
             // Fieldpath term -> Condition
             if (parsedKey.type === 'fieldpath') {
-                const parsed = this.parseValue(value, parsedKey, meta, select);
+                const parsed = await this.parseValue(value, parsedKey, bucket, select);
                 const rule = ('subquery' in parsed)
                     ? parsed.subquery.union
                     : {
-                        meta: { ...meta },
+                        meta: { ...bucket },
                         select,
                         fieldpath: parsedKey.fieldpath,
                         value: parsed,
@@ -71,15 +77,15 @@ class NQL_RuleTree {
                 throw new Error('Graph Link not supported yet');
             }
             else if (parsedKey.type === 'and') {
-                const subInter = this.parseUnion(bucket, value, select);
+                const subInter = await this.parseUnion(bucket, value, select);
                 union.inters[0].rules.push(subInter);
             }
             else if (parsedKey.type === 'or') {
-                const subInter = this.parseUnion(bucket, value, select);
+                const subInter = await this.parseUnion(bucket, value, select);
                 union.inters.push({ meta: {}, rules: [subInter] });
             }
             else if (parsedKey.type === 'order') {
-                union.order = this.parseOrder(bucket, value);
+                union.order = await this.parseOrder(bucket, value);
             }
         }
         if (!union.inters[0]?.rules.length) {
@@ -91,7 +97,7 @@ class NQL_RuleTree {
         let by = value['by'];
         if (by) {
             for (const key of by) {
-                if (Object.values(bucket.adapter.config.meta).includes(key))
+                if (Object.values(bucket.meta).includes(key))
                     continue;
                 const fields = bucket_model_schema_1.$BucketModel.getField(bucket.schema.model, key);
                 if (!fields.length) {
@@ -99,7 +105,7 @@ class NQL_RuleTree {
                 }
                 for (const field of fields) {
                     if (![
-                        'date', 'datetime', 'duration', 'decimal', 'enum', 'float', 'int', 'string', 'literal', 'boolean'
+                        'date', 'datetime', 'duration', 'decimal', 'enum', 'float', 'int', 'string', 'literal', 'boolean', 'unknown'
                     ].includes(field.type)) {
                         throw new Error(`Field '${key}' is not sortable`);
                     }
@@ -122,7 +128,7 @@ class NQL_RuleTree {
         }
         return { by, dir: dir };
     }
-    parseKey(bucket, key) {
+    async parseKey(bucket, key) {
         if (key === '#order') {
             return { type: 'order' };
         }
@@ -138,11 +144,8 @@ class NQL_RuleTree {
             if (!link) {
                 throw new Error(`Graph Link '${linkName}' doesn't exist on the bucket ${bucket}`);
             }
-            const linkBucket = this.module.buckets[link.bucket.refName].schema;
-            if (!linkBucket) {
-                throw new Error(`Graph Link '${link}' points to a bucket '${link.bucket}' not found on the module ${this.module.name}`);
-            }
-            return { type: 'graphlink', link: link.name, linkBucket };
+            const linkBucket = await daemon_1.Daemon.getBucketMetadata(this.daemon, link.bucket);
+            return { type: 'graphlink', link: link.name, linkBucket: linkBucket.schema };
         }
         else {
             const term = key.match(/^(or )?([\w|.|*]+)( not)? ?(~)?(.*)$/);
@@ -150,19 +153,19 @@ class NQL_RuleTree {
                 throw new Error(`Invalid term '${key}'`);
             }
             const [_, or, fieldpath, not, case_i, op] = term;
-            if (Object.values(bucket.adapter.config.meta).includes(fieldpath)) {
-                const _op = this.parseOp(bucket.schema.name, [{ type: 'datetime', name: fieldpath }], op);
+            if (Object.values(bucket.meta).includes(fieldpath)) {
+                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(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, fields, op);
+            const _op = this.parseOp(fields, op);
             return { type: 'fieldpath', or: !!or, fieldpath, not: !!not, case_i: !!case_i, op: _op };
         }
     }
-    parseOp(bucketName, fields, op) {
+    parseOp(fields, op) {
         const _op = (op === '' ? '==' : op);
         for (const field of fields) {
             if (![
@@ -197,14 +200,14 @@ class NQL_RuleTree {
         }
         return _op;
     }
-    parseValue(value, parsedKey, meta, select) {
+    async parseValue(value, parsedKey, meta, select) {
         if (typeof value === 'object') {
             // Array
             if (Array.isArray(value)) {
                 const statyc = [];
                 const params = [];
                 for (const item of value) {
-                    const parsed = this.parseValue(item, parsedKey, meta, select);
+                    const parsed = await this.parseValue(item, parsedKey, meta, select);
                     if ('static' in parsed) {
                         statyc.push(parsed.static);
                     }
@@ -231,7 +234,7 @@ class NQL_RuleTree {
                     return { param: value['.'] };
                 }
                 // Sub-Query
-                return { subquery: this.parseSubQuery(value, parsedKey, meta, select) };
+                return { subquery: await this.parseSubQuery(value, parsedKey, meta, select) };
             }
         }
         // Static value
@@ -239,7 +242,7 @@ class NQL_RuleTree {
             return { static: value };
         }
     }
-    parseSubQuery(value, parsedKey, meta, select) {
+    async parseSubQuery(value, parsedKey, meta, select) {
         const union = {
             meta: {},
             inters: [
@@ -253,7 +256,8 @@ class NQL_RuleTree {
                     throw new Error(`Invalid bucket field '${key}'`);
                 }
                 const [_, or, refBucket, fieldpath] = refField;
-                const bucket = this.module.buckets[refBucket];
+                const tag = dependency_1.Tag.fromNameOrShort(this.module, 'bucket', refBucket);
+                const bucket = await daemon_1.Daemon.getBucketMetadata(this.daemon, tag);
                 if (!bucket) {
                     throw new Error(`Bucket '${bucket}' not found on module`);
                 }
@@ -261,7 +265,7 @@ class NQL_RuleTree {
                 if (!field) {
                     throw new Error(`Field '${fieldpath}' not found on bucket '${bucket.schema.name}'`);
                 }
-                const refInter = this.parseUnion(bucket, value[key], fieldpath);
+                const refInter = await this.parseUnion(bucket, value[key], fieldpath);
                 const rule = {
                     meta: { ...meta },
                     select,
@@ -336,7 +340,7 @@ class NQL_RuleTree {
                         const inter = node[0].inters[0];
                         parent[0].rules.splice(parent[1], 1, ...inter.rules);
                         stack.pop();
-                        stack.push([inter, -1]);
+                        parent[1]--;
                         continue;
                     }
                 }
@@ -452,7 +456,7 @@ class NQL_RuleTree {
                 + (0, string_1.colored)(`└ ${node._debug_id || ''}[if] `, 'lightcyan')
                 + (0, string_1.colored)(node.select ? '(⊹ ' + node.select + ') ' : '', 'brown')
                 + (0, string_1.colored)(`${node.meta.scope || ''} ${node.meta.avgTime || '?'}ms `, 'black')
-                + `@${node.meta.bucket?.name}.${node.fieldpath}${node.not ? ' not' : ''} ${node.case_i ? '~' : ''}${node.op}`
+                + `@${node.meta.schema?.name}.${node.fieldpath}${node.not ? ' not' : ''} ${node.case_i ? '~' : ''}${node.op}`
                 + (('static' in node.value) ? ` ${node.value.static}`
                     : ('param' in node.value) ? ` ->${node.value.param}`
                         : ' ▼ ' + (0, string_1.colored)('(' + node.value.subquery.bucket.name + '.' + node.value.subquery.select + ')', 'brown'))
@@ -490,11 +494,13 @@ NQL_RuleTree.OpByType = {
  * @category NQL
  * */
 class NQL_Compiler {
-    static build(module, bucketName, query) {
-        const tree = new NQL_RuleTree(module, bucketName, query);
-        return this.buildUnion(tree.root);
+    static async build(daemon, module, bucketName, query, customMetadata) {
+        const tree = new NQL_RuleTree(daemon, module, bucketName, query, customMetadata);
+        return this.buildTree(tree);
     }
-    static buildUnion(union) {
+    static async buildTree(tree) {
+        await tree.parse();
+        const union = tree.root;
         // const debugLog: string[] = [];
         // Create top-level part
         const parts = [{

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

@@ -24,7 +24,7 @@ export declare class NQL_Engine {
     private module;
     private runners;
     constructor(module: AnyModule);
-    run(trx: AnyTrxNode, query: NQL_CompiledQuery, pagination?: NQL_Pagination, params?: Record<string, any>[], view?: $BucketView, runner?: NQLRunner): Promise<NQL_Result>;
+    run(trx: AnyTrxNode, query: NQL_CompiledQuery, pagination?: NQL_Pagination, params?: Record<string, any>[], view?: $BucketView, customRunners?: Record<string, NQLRunner>): Promise<NQL_Result>;
     linkExternal(bucket: AnyBucket): void;
 }
 export {};