nesoi 3.3.19 → 3.3.21

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

@@ -62,7 +62,7 @@ class BucketGraph {
                 ...schema.query,
                 '#and __tenancy__': tenancy
             };
-            const adapter = await trx_1.Trx.getCache(trx, this.bucket) || otherBucket.cache || otherBucket.adapter;
+            const adapter = await trx_1.Trx.getCache(trx, otherBucket) || otherBucket.cache || otherBucket.adapter;
             links = await adapter.query(trx, query, page, params, param_templates ? [param_templates] : undefined);
         }
         // Empty response
@@ -113,8 +113,8 @@ class BucketGraph {
             const tempData = {};
             for (const obj of allLinks)
                 tempData[obj.id] = obj;
-            const otherBucket = await daemon_1.Daemon.getBucketMetadata(module.daemon, schema.bucket);
-            tempAdapter = new memory_bucket_adapter_1.MemoryBucketAdapter(otherBucket.schema, tempData);
+            const otherMeta = await daemon_1.Daemon.getBucketMetadata(module.daemon, schema.bucket);
+            tempAdapter = new memory_bucket_adapter_1.MemoryBucketAdapter(otherMeta.schema, tempData);
         }
         // Internal
         else {
@@ -128,10 +128,10 @@ class BucketGraph {
                 '#and __tenancy__': tenancy
             };
             if (otherBucket.adapter instanceof memory_bucket_adapter_1.MemoryBucketAdapter) {
-                tempAdapter = await trx_1.Trx.getCache(trx, this.bucket) || otherBucket.cache || otherBucket.adapter;
+                tempAdapter = await trx_1.Trx.getCache(trx, otherBucket) || otherBucket.cache || otherBucket.adapter;
             }
             else {
-                const adapter = await trx_1.Trx.getCache(trx, this.bucket) || otherBucket.cache || otherBucket.adapter;
+                const adapter = await trx_1.Trx.getCache(trx, otherBucket) || otherBucket.cache || otherBucket.adapter;
                 const allLinks = await adapter.query(trx, query, undefined, params, param_templates);
                 const tempData = {};
                 for (const obj of allLinks.data)
@@ -141,25 +141,35 @@ class BucketGraph {
         }
         // 2nd Query
         const links = [];
+        const compiled = await tempAdapter._compileQuery(trx, schema.query, {
+            module: schema.bucket.module,
+            buckets: {
+                [schema.bucket.short]: {
+                    scope: '__graph__',
+                    nql: (tempAdapter instanceof bucket_cache_1.BucketCache) ? undefined : tempAdapter.nql
+                }
+            },
+        });
         for (const obj of objs) {
-            const result = tempAdapter instanceof bucket_cache_1.BucketCache
-                ? await tempAdapter.query(trx, schema.query, {
+            let result;
+            if (tempAdapter instanceof bucket_cache_1.BucketCache) {
+                result = await tempAdapter._queryCompiled(trx, compiled, {
                     perPage: schema.many ? undefined : 1,
-                }, [{ ...obj }], undefined)
-                : await tempAdapter.query(trx, schema.query, {
+                }, [{ ...obj }], undefined);
+            }
+            else {
+                result = await tempAdapter._queryCompiled(trx, compiled, {
                     perPage: schema.many ? undefined : 1,
                 }, [{ ...obj }], undefined, undefined, {
                     module: schema.bucket.module,
-                    runners: {
-                        [tempAdapter.getQueryMeta().scope]: tempAdapter.nql
+                    buckets: {
+                        [schema.bucket.short]: {
+                            scope: '__graph__',
+                            nql: tempAdapter.nql
+                        }
                     },
-                    metadata: {
-                        ...tempAdapter.getQueryMeta(),
-                        schema: tempAdapter.schema,
-                        tag: schema.bucket,
-                        meta: tempAdapter.config.meta
-                    }
                 });
+            }
             if (schema.many) {
                 links.push(result.data);
             }
@@ -239,7 +249,7 @@ class BucketGraph {
                 ...schema.query,
                 '#and__tenancy__': tenancy
             };
-            const adapter = await trx_1.Trx.getCache(trx, this.bucket) || otherBucket.cache || otherBucket.adapter;
+            const adapter = await trx_1.Trx.getCache(trx, otherBucket) || otherBucket.cache || otherBucket.adapter;
             links = await adapter.query(trx, query, page, params);
         }
         return !!links.data.length;

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

@@ -13,6 +13,7 @@ export type NQL_Union = {
     inters: NQL_Intersection[];
     sort?: {
         key: string;
+        key_is_deep: boolean;
         dir: ('asc' | 'desc');
     }[];
     _debug_id?: number;
@@ -25,6 +26,7 @@ export type NQL_Intersection = {
 export type NQL_Rule = {
     meta: NQL_QueryMeta;
     fieldpath: string;
+    fieldpath_is_deep: boolean;
     op: NQL_Operation;
     case_i: boolean;
     not: boolean;
@@ -32,6 +34,7 @@ export type NQL_Rule = {
         static: any | any[];
     } | {
         param: string | string[];
+        param_is_deep: boolean;
     } | {
         param_with_$: string;
     } | {

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

@@ -1,6 +1,6 @@
 import { NQL_AnyQuery, NQL_Union, NQL_Part, NQL_Node } from './nql.schema';
 import { AnyDaemon } from "../../../../engine/daemon";
-import { BucketMetadata } from "../../../../engine/transaction/trx_engine";
+import { NQLRunner } from './nql_engine';
 /**
  * @category NQL
  * */
@@ -9,11 +9,14 @@ export declare class NQL_RuleTree {
     private module;
     private bucketName;
     private query;
-    private customMetadata?;
+    private customBuckets;
     private debug;
     private static OpByType;
     root: NQL_Union;
-    constructor(daemon: AnyDaemon, module: string, bucketName: string, query: NQL_AnyQuery, customMetadata?: BucketMetadata | undefined, debug?: boolean);
+    constructor(daemon: AnyDaemon, module: string, bucketName: string, query: NQL_AnyQuery, customBuckets?: Record<string, {
+        scope: string;
+        nql: NQLRunner;
+    }>, debug?: boolean);
     parse(): Promise<void>;
     private parseUnion;
     private parseSort;
@@ -39,7 +42,10 @@ export declare class NQL_RuleTree {
  * @category NQL
  * */
 export declare class NQL_Compiler {
-    static build(daemon: AnyDaemon, module: string, bucketName: string, query: NQL_AnyQuery, customMetadata?: BucketMetadata): Promise<NQL_CompiledQuery>;
+    static build(daemon: AnyDaemon, module: string, bucketName: string, query: NQL_AnyQuery, customBuckets?: Record<string, {
+        scope: string;
+        nql: NQLRunner;
+    }>): Promise<NQL_CompiledQuery>;
     static buildTree(tree: NQL_RuleTree): Promise<NQL_CompiledQuery>;
 }
 /**

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

@@ -13,7 +13,7 @@ class NQL_RuleTree {
     module;
     bucketName;
     query;
-    customMetadata;
+    customBuckets;
     debug;
     static OpByType = {
         'boolean': ['==', 'in', 'present'],
@@ -34,18 +34,19 @@ class NQL_RuleTree {
         'unknown': ['==', 'contains', 'contains_any', 'in', 'present']
     };
     root;
-    constructor(daemon, module, bucketName, query, customMetadata, debug = false) {
+    constructor(daemon, module, bucketName, query, customBuckets = {}, debug = false) {
         this.daemon = daemon;
         this.module = module;
         this.bucketName = bucketName;
         this.query = query;
-        this.customMetadata = customMetadata;
+        this.customBuckets = customBuckets;
         this.debug = 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);
+        const meta = await daemon_1.Daemon.getBucketMetadata(this.daemon, tag);
+        meta.scope = this.customBuckets[tag.short]?.scope || meta.scope;
+        this.root = await this.parseUnion(meta, this.query);
         if (this.debug) {
             console.log(this.describe());
         }
@@ -56,10 +57,10 @@ class NQL_RuleTree {
         }
     }
     // Parse NQL
-    async parseUnion(bucket, query, select) {
+    async parseUnion(meta, query, select) {
         const union = {
             meta: {
-                ...bucket,
+                ...meta,
                 avgTime: 0
             },
             inters: [
@@ -68,16 +69,17 @@ class NQL_RuleTree {
         };
         for (const key in query) {
             const value = query[key];
-            const parsedKey = await this.parseKey(bucket, key);
+            const parsedKey = await this.parseKey(meta, key);
             // Fieldpath term -> Condition
             if (parsedKey.type === 'fieldpath') {
-                const parsed = await this.parseValue(value, parsedKey, bucket, select);
+                const parsed = await this.parseValue(value, parsedKey, meta, select);
                 const rule = ('subquery' in parsed)
                     ? parsed.subquery.union
                     : {
-                        meta: { ...bucket },
+                        meta: { ...meta },
                         select,
                         fieldpath: parsedKey.fieldpath,
+                        fieldpath_is_deep: parsedKey.fieldpath.includes('.'),
                         value: parsed,
                         op: parsedKey.op,
                         case_i: parsedKey.case_i,
@@ -102,15 +104,15 @@ class NQL_RuleTree {
                 throw new Error('Graph Link not supported yet');
             }
             else if (parsedKey.type === 'and') {
-                const subInter = await this.parseUnion(bucket, value, select);
+                const subInter = await this.parseUnion(meta, value, select);
                 union.inters[0].rules.push(subInter);
             }
             else if (parsedKey.type === 'or') {
-                const subInter = await this.parseUnion(bucket, value, select);
+                const subInter = await this.parseUnion(meta, value, select);
                 union.inters.push({ meta: {}, rules: [subInter] });
             }
             else if (parsedKey.type === 'sort') {
-                union.sort = await this.parseSort(bucket, value);
+                union.sort = await this.parseSort(meta, value);
             }
         }
         if (!union.inters[0]?.rules.length) {
@@ -118,7 +120,7 @@ class NQL_RuleTree {
         }
         return union;
     }
-    parseSort(bucket, value) {
+    parseSort(meta, value) {
         if (!Array.isArray(value))
             value = [value];
         if (value.some(v => typeof v !== 'string')) {
@@ -138,11 +140,11 @@ class NQL_RuleTree {
             else {
                 throw new Error(`Invalid query sort direction '${key}', string must end with '@asc' or '@desc'`);
             }
-            const is_metadata_field = Object.values(bucket.meta).includes(key);
+            const is_metadata_field = Object.values(meta.meta).includes(key);
             if (!is_metadata_field) {
-                const fields = bucket_model_schema_1.$BucketModel.getField(bucket.schema.model, key);
+                const fields = bucket_model_schema_1.$BucketModel.getField(meta.schema.model, key);
                 if (!fields.length) {
-                    throw new Error(`Field '${key}' not found on bucket '${bucket.schema.name}'`);
+                    throw new Error(`Field '${key}' not found on bucket '${meta.schema.name}'`);
                 }
                 for (const field of fields) {
                     if (![
@@ -154,12 +156,13 @@ class NQL_RuleTree {
             }
             sort.push({
                 key,
+                key_is_deep: key.includes('.'),
                 dir: vdir
             });
         }
         return sort;
     }
-    async parseKey(bucket, key) {
+    async parseKey(meta, key) {
         if (key === '#sort') {
             return { type: 'sort' };
         }
@@ -171,9 +174,9 @@ class NQL_RuleTree {
         }
         else if (key.startsWith('*')) {
             const linkName = key.slice(1);
-            const link = bucket.schema.graph.links[linkName];
+            const link = meta.schema.graph.links[linkName];
             if (!link) {
-                throw new Error(`Graph Link '${linkName}' doesn't exist on the bucket ${bucket}`);
+                throw new Error(`Graph Link '${linkName}' doesn't exist on the bucket ${meta}`);
             }
             const linkBucket = await daemon_1.Daemon.getBucketMetadata(this.daemon, link.bucket);
             return { type: 'graphlink', link: link.name, linkBucket: linkBucket.schema };
@@ -184,13 +187,13 @@ class NQL_RuleTree {
                 throw new Error(`Invalid term '${key}'`);
             }
             const [_, or, fieldpath, not, case_i, op] = term;
-            if (Object.values(bucket.meta).includes(fieldpath)) {
+            if (Object.values(meta.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);
+            const fields = bucket_model_schema_1.$BucketModel.getField(meta.schema.model, fieldpath);
             if (!fields.length) {
-                throw new Error(`Field '${fieldpath}' not found on bucket '${bucket.schema.name}'`);
+                throw new Error(`Field '${fieldpath}' not found on bucket '${meta.schema.name}'`);
             }
             const _op = this.parseOp(fields, op);
             return { type: 'fieldpath', or: !!or, fieldpath, not: !!not, case_i: !!case_i, op: _op };
@@ -253,7 +256,7 @@ class NQL_RuleTree {
                     throw new Error(`Cannot mix static and parameter values inside array value [${value}]`);
                 }
                 if (params.length > 0) {
-                    return { param: params };
+                    return { param: params, param_is_deep: params.some(p => p.includes('.')) };
                 }
                 else {
                     return { static: statyc };
@@ -262,7 +265,7 @@ class NQL_RuleTree {
             else {
                 // Parameter
                 if ('.' in value) {
-                    return { param: value['.'] };
+                    return { param: value['.'], param_is_deep: value['.'].includes('.') };
                 }
                 // Path Parameter
                 else if ('$' in value) {
@@ -292,24 +295,28 @@ class NQL_RuleTree {
                 }
                 const [_, or, refBucket, fieldpath] = refField;
                 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`);
+                const subMeta = await daemon_1.Daemon.getBucketMetadata(this.daemon, tag);
+                if (!subMeta) {
+                    throw new Error(`Bucket '${subMeta}' not found on module`);
                 }
-                const field = bucket_model_schema_1.$BucketModel.getField(bucket.schema.model, fieldpath);
+                subMeta.scope = this.customBuckets[tag.short]?.scope || subMeta.scope;
+                const field = bucket_model_schema_1.$BucketModel.getField(subMeta.schema.model, fieldpath);
                 if (!field) {
-                    throw new Error(`Field '${fieldpath}' not found on bucket '${bucket.schema.name}'`);
+                    throw new Error(`Field '${fieldpath}' not found on bucket '${subMeta.schema.name}'`);
                 }
-                const refInter = await this.parseUnion(bucket, value[key], fieldpath);
+                // The union belongs to the sub scope.
+                const refInter = await this.parseUnion(subMeta, value[key], fieldpath);
                 const rule = {
+                    // This rule belongs to the parent scope.
                     meta: { ...meta },
                     select,
                     fieldpath: parsedKey.fieldpath,
+                    fieldpath_is_deep: parsedKey.fieldpath.includes('.'),
                     case_i: parsedKey.case_i,
                     not: parsedKey.not,
                     op: parsedKey.op,
                     value: {
-                        subquery: { union: refInter, bucket: bucket.schema, select: fieldpath }
+                        subquery: { union: refInter, bucket: subMeta.schema, select: fieldpath }
                     }
                 };
                 if (!or) {
@@ -512,8 +519,8 @@ exports.NQL_RuleTree = NQL_RuleTree;
  * @category NQL
  * */
 class NQL_Compiler {
-    static async build(daemon, module, bucketName, query, customMetadata) {
-        const tree = new NQL_RuleTree(daemon, module, bucketName, query, customMetadata);
+    static async build(daemon, module, bucketName, query, customBuckets = {}) {
+        const tree = new NQL_RuleTree(daemon, module, bucketName, query, customBuckets);
         return this.buildTree(tree);
     }
     static async buildTree(tree) {
@@ -659,7 +666,7 @@ class NQL_Compiler {
                     // Close part (&1)
                     if (rule.part) {
                         // Rebuild Union on original tree as Condition
-                        buildNode.value = { param: `%__${rule.part}__%` };
+                        buildNode.value = { param: `%__${rule.part}__%`, param_is_deep: false };
                         if (rule.part == partStack.at(-1).i) {
                             // debugLog.push('⊙ [part] ' + rule.part);
                             orderedParts.push(parts[rule.part]);

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

@@ -24,7 +24,10 @@ 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>[], param_templates?: Record<string, string>[], view?: $BucketView, customRunners?: Record<string, NQLRunner>): Promise<NQL_Result>;
+    run(trx: AnyTrxNode, query: NQL_CompiledQuery, pagination?: NQL_Pagination, params?: Record<string, any>[], param_templates?: Record<string, string>[], view?: $BucketView, customBuckets?: Record<string, {
+        scope: string;
+        nql: NQLRunner;
+    }>): Promise<NQL_Result>;
     linkExternal(bucket: AnyBucket): void;
 }
 export {};

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

@@ -23,7 +23,7 @@ class NQL_Engine {
             }
         }
     }
-    async run(trx, query, pagination, params = [{}], param_templates = [], view, customRunners) {
+    async run(trx, query, pagination, params = [{}], param_templates = [], view, customBuckets) {
         if (!params.length)
             params = [{}];
         if (!param_templates.length)
@@ -35,10 +35,8 @@ class NQL_Engine {
             const part_i = query.execOrder[i];
             const part = query.parts[part_i];
             // Run part
-            const runners = customRunners
-                ? { ...this.runners, ...customRunners }
-                : this.runners;
-            const _runner = runners[part.union.meta.scope];
+            const _runner = Object.values(customBuckets || {}).find(b => b.scope === part.union.meta.scope)?.nql
+                || this.runners[part.union.meta.scope];
             const out = await _runner.run(trx, part, params, param_templates, pagination, view);
             result = out;
             // Part failed, return

package/lib/elements/entities/message/template/message_template_field.builder.d.ts

@@ -70,6 +70,7 @@ export declare class MessageTemplateFieldBuilder<Module extends $Module, Message
     private _required;
     private _defaultValue?;
     private _nullable;
+    private _rawName?;
     private _rules;
     constructor(type: $MessageTemplateFieldType, meta: Omit<$MessageTemplateFieldMeta, 'enum' | 'msg' | 'id'> & {
         enum?: {
@@ -97,6 +98,7 @@ export declare class MessageTemplateFieldBuilder<Module extends $Module, Message
     ], InputSuffix>;
     get nullable(): MessageTemplateFieldBuilder<Module, Message, Input | null, Output | null, Children, Optional, InputSuffix>;
     rule(rule: MessageTemplateRuleDef<Output, Message['#raw']>): this;
+    rawName(name: string): this;
     static build(builder: AnyMessageTemplateFieldBuilder, name: string, tree: ModuleTree, module: $Module, basePathRaw: string, basePathParsed: string): $MessageTemplateField;
     static buildMany(fields: MessageTemplateFieldBuilders, tree: ModuleTree, module: $Module, basePathRaw?: string, basePathParsed?: string, name?: string, key?: string): $MessageTemplateFields;
 }

package/lib/elements/entities/message/template/message_template_field.builder.js

@@ -138,6 +138,7 @@ class MessageTemplateFieldBuilder {
     _required = true;
     _defaultValue = undefined;
     _nullable = false;
+    _rawName;
     _rules = [];
     constructor(type, meta, alias, children) {
         this.type = type;
@@ -166,6 +167,10 @@ class MessageTemplateFieldBuilder {
         this._rules.push(rule);
         return this;
     }
+    rawName(name) {
+        this._rawName = name;
+        return this;
+    }
     // Build
     static build(builder, name, tree, module, basePathRaw, basePathParsed) {
         const pathRaw = basePathRaw + (builder.type === 'id' ? `${name}_id` : name);

package/lib/engine/daemon.d.ts

@@ -123,10 +123,29 @@ export declare class DaemonTrx<S extends $Space, M extends $Module, AuthUsers ex
      * authenticate this transaction prior to running.
      */
     private tokens?;
+    /**
+     *
+     */
+    private _origin?;
+    /**
+     * An idempotent transaction doesn't generate a commit/rollback.
+     */
+    private _idempotent;
     /**
      * @param trxEngine The transaction engine where to run the transaction.
      */
     constructor(trxEngine: AnyTrxEngine);
+    origin(origin: string): this;
+    /**
+     * Flags this transaction as idempotent.
+     * This means its not stored, neither commited/rolled back.
+     * This should generally be used for readonly transactions.
+     */
+    get idempotent(): this;
+    /**
+     * Inherit authentication from another transaction node.
+     */
+    idempotent_inherit(trx: AnyTrxNode): this;
     /**
      * Inherit authentication from another transaction node.
      */

package/lib/engine/daemon.js

@@ -176,12 +176,40 @@ class DaemonTrx {
      * authenticate this transaction prior to running.
      */
     tokens;
+    /**
+     *
+     */
+    _origin;
+    /**
+     * An idempotent transaction doesn't generate a commit/rollback.
+     */
+    _idempotent = false;
     /**
      * @param trxEngine The transaction engine where to run the transaction.
      */
     constructor(trxEngine) {
         this.trxEngine = trxEngine;
     }
+    origin(origin) {
+        this._origin = origin;
+        return this;
+    }
+    /**
+     * Flags this transaction as idempotent.
+     * This means its not stored, neither commited/rolled back.
+     * This should generally be used for readonly transactions.
+     */
+    get idempotent() {
+        this._idempotent = true;
+        return this;
+    }
+    /**
+     * Inherit authentication from another transaction node.
+     */
+    idempotent_inherit(trx) {
+        this._idempotent = trx.trx.idempotent;
+        return this;
+    }
     /**
      * Inherit authentication from another transaction node.
      */
@@ -211,7 +239,7 @@ class DaemonTrx {
             ...this.tokens
         };
         const users = inheritedAuth?.users;
-        return this.trxEngine.trx(fn, id, tokens, users);
+        return this.trxEngine.trx(fn, id, tokens, users, this._origin, this._idempotent);
     }
     /**
      * Run a method inside the transaction, and hold it until
@@ -220,13 +248,23 @@ class DaemonTrx {
      * @param fn A function to execute inside the transaction
      * @returns A `TrxStatus` containing metadata about the transaction and the function response
      */
-    run_and_hold(fn, id) {
+    async run_and_hold(fn, id) {
         const inheritedAuth = this._inherit.auth;
         const tokens = {
             ...inheritedAuth?.tokens,
             ...this.tokens
         };
         const users = inheritedAuth?.users;
+        // Idempotent transactions are not commited/rolled back, so they don't need to be held.
+        if (this._idempotent) {
+            const status = await this.trxEngine.trx(fn, id, tokens, users, this._origin, this._idempotent);
+            return {
+                id: status.id,
+                status,
+                commit: () => Promise.resolve(),
+                rollback: () => Promise.resolve(),
+            };
+        }
         return this.trxEngine.trx_hold(fn, id, tokens, users);
     }
 }

package/lib/engine/data/tree.d.ts

@@ -13,7 +13,6 @@ export declare class Tree {
      *
      * @deprecated Fieldpath was consolidated into Modelpath and Querypath.
      */
-    static get(obj: Record<string, any>, fieldpath: string, index?: '*' | 0 | (number | string)[]): any;
-    static getModelpath(obj: Record<string, any>, modelpath: string, index: (string | number)[]): any[];
+    static get(obj: Record<string, any>, fieldpath: string): any;
     static set(obj: Record<string, any>, fieldpath: string, replacer: (v: any, i: (number | string)[]) => any, __index?: (number | string)[]): void;
 }