nesoi 3.3.20 → 3.3.22

package/lib/elements/edge/controller/adapters/controller_adapter.d.ts

@@ -13,7 +13,10 @@ export declare abstract class ControllerAdapter {
     protected schema: $Controller;
     protected daemon?: AnyDaemon;
     constructor(module: $Module, schema: $Controller);
-    trx(fn: (trx: AnyTrxNode) => Promise<any>, auth?: AuthRequest<any>): Promise<import("../../../../engine/transaction/trx").TrxStatus<any>>;
+    trx(fn: (trx: AnyTrxNode) => Promise<any>, endpoint: {
+        name: string;
+        idempotent?: boolean;
+    }, auth?: AuthRequest<any>): Promise<import("../../../../engine/transaction/trx").TrxStatus<any>>;
     bind(daemon: AnyDaemon): void;
     protected abstract makeEndpoint(path: string, schema: $ControllerEndpoint): void;
     protected abstract makeTopic(schema: $ControllerTopic): void;

package/lib/elements/edge/controller/adapters/controller_adapter.js

@@ -14,14 +14,18 @@ class ControllerAdapter {
         this.module = module;
         this.schema = schema;
     }
-    async trx(fn, auth) {
+    async trx(fn, endpoint, auth) {
         if (!this.daemon) {
             throw new Error('Controller not bound to a daemon');
         }
         try {
-            return await this.daemon.trx(this.schema.module)
-                .auth(auth)
-                .run(fn);
+            const trx = this.daemon.trx(this.schema.module)
+                .origin(endpoint.name)
+                .auth(auth);
+            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+            if (endpoint.idempotent)
+                trx.idempotent;
+            return await trx.run(fn);
         }
         catch (e) {
             log_1.Log.error('controller', this.schema.name, 'Unknown error', e);

package/lib/elements/edge/controller/controller.js

@@ -36,7 +36,7 @@ class ControllerEndpoint {
             if (this.schema.target.type === 'machine') {
                 return trx.machine(this.schema.target.short).run(raw);
             }
-        }, auth);
+        }, this.schema, auth);
     }
 }
 exports.ControllerEndpoint = ControllerEndpoint;
@@ -57,7 +57,7 @@ class ControllerTopic {
         const response = await this.adapter.trx(async (trx) => {
             await trx_node_1.TrxNode.checkAuth(trx, this.schema.auth);
             return trx.topic(this.schema.name).subscribe(fn);
-        }, auth);
+        }, this.schema, auth);
         if (response.state === 'error') {
             throw error_1.NesoiError.Controller.SubscribeFailed({ topic: this.schema.alias });
         }
@@ -67,7 +67,7 @@ class ControllerTopic {
         const response = await this.adapter.trx(async (trx) => {
             await trx_node_1.TrxNode.checkAuth(trx, this.schema.auth);
             return trx.topic(this.schema.name).unsubscribe(id);
-        });
+        }, this.schema);
         if (response.state === 'error') {
             throw error_1.NesoiError.Controller.UnsubscribeFailed({ topic: this.schema.alias });
         }

package/lib/elements/edge/controller/controller.schema.d.ts

@@ -14,8 +14,9 @@ export declare class $ControllerEndpoint {
     msg: Tag;
     target: Tag;
     implicit?: Record<string, any> | undefined;
+    idempotent: boolean;
     $t: string;
-    constructor(name: string, alias: string, auth: $BlockAuth[], tags: string[], msg: Tag, target: Tag, implicit?: Record<string, any> | undefined);
+    constructor(name: string, alias: string, auth: $BlockAuth[], tags: string[], msg: Tag, target: Tag, implicit?: Record<string, any> | undefined, idempotent?: boolean);
 }
 /**
  * @category Schemas

package/lib/elements/edge/controller/controller.schema.js

@@ -13,8 +13,9 @@ class $ControllerEndpoint {
     msg;
     target;
     implicit;
+    idempotent;
     $t = 'controller.endpoint';
-    constructor(name, alias, auth, tags, msg, target, implicit) {
+    constructor(name, alias, auth, tags, msg, target, implicit, idempotent = false) {
         this.name = name;
         this.alias = alias;
         this.auth = auth;
@@ -22,6 +23,7 @@ class $ControllerEndpoint {
         this.msg = msg;
         this.target = target;
         this.implicit = implicit;
+        this.idempotent = idempotent;
     }
 }
 exports.$ControllerEndpoint = $ControllerEndpoint;

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

@@ -3,8 +3,8 @@ import { NesoiObj, ObjWithOptionalId } from "../../../../engine/data/obj";
 import { BucketCacheSync } from '../cache/bucket_cache';
 import { NQL_AnyQuery, NQL_Pagination } from '../query/nql.schema';
 import { NQLRunner, NQL_Result } from '../query/nql_engine';
+import { NQL_CompiledQuery } from '../query/nql_compiler';
 import { $Bucket } from "../../..";
-import { BucketMetadata } from "../../../../engine/transaction/trx_engine";
 export type BucketAdapterConfig = {
     meta: {
         created_at: string;
@@ -146,8 +146,30 @@ export declare abstract class BucketAdapter<Obj extends NesoiObj, Config extends
         metadataOnly?: MetadataOnly;
     }, custom?: {
         module?: string;
-        runners?: Record<string, NQLRunner>;
-        metadata?: BucketMetadata;
+        buckets?: Record<string, {
+            scope: string;
+            nql: NQLRunner;
+        }>;
+    }): Promise<NQL_Result<MetadataOnly extends true ? {
+        id: Obj['id'];
+        [x: string]: any;
+    } : Obj>>;
+    _compileQuery(trx: AnyTrxNode, query: NQL_AnyQuery, custom?: {
+        module?: string;
+        buckets?: Record<string, {
+            scope: string;
+            nql: NQLRunner;
+        }>;
+    }): Promise<NQL_CompiledQuery>;
+    _queryCompiled<MetadataOnly extends boolean>(trx: AnyTrxNode, compiled: NQL_CompiledQuery, pagination?: NQL_Pagination, params?: Record<string, any>[], param_templates?: Record<string, string>[], config?: {
+        view?: string;
+        metadataOnly?: MetadataOnly;
+    }, custom?: {
+        module?: string;
+        buckets?: Record<string, {
+            scope: string;
+            nql: NQLRunner;
+        }>;
     }): Promise<NQL_Result<MetadataOnly extends true ? {
         id: Obj['id'];
         [x: string]: any;
@@ -157,5 +179,6 @@ export declare abstract class BucketAdapter<Obj extends NesoiObj, Config extends
      * @param {Obj} obj An object of this bucket
      */
     getUpdateEpoch(obj: Obj): number;
+    private static getCacheCustomBuckets;
 }
 export type AnyBucketAdapter = BucketAdapter<any, any>;

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

@@ -36,12 +36,30 @@ class BucketAdapter {
     async query(trx, query, pagination, params, param_templates, config, 
     // When running a temporary local memory adapter,
     // these are required
+    custom) {
+        const compiled = await this._compileQuery(trx, query, custom);
+        return this._queryCompiled(trx, compiled, pagination, params, param_templates, config, custom);
+    }
+    async _compileQuery(trx, query, 
+    // When running a temporary local memory adapter,
+    // these are required
     custom) {
         const module = trx_node_1.TrxNode.getModule(trx);
         const moduleName = custom?.module || module.name;
-        const compiled = await nql_compiler_1.NQL_Compiler.build(module.daemon, moduleName, this.schema.name, query, custom?.metadata);
+        const customBuckets = {
+            ...(custom?.buckets || {}),
+            ...BucketAdapter.getCacheCustomBuckets(trx)
+        };
+        return nql_compiler_1.NQL_Compiler.build(module.daemon, moduleName, this.schema.name, query, customBuckets);
+    }
+    async _queryCompiled(trx, compiled, pagination, params, param_templates, config, custom) {
+        const module = trx_node_1.TrxNode.getModule(trx);
+        const customBuckets = {
+            ...(custom?.buckets || {}),
+            ...BucketAdapter.getCacheCustomBuckets(trx)
+        };
         const view = config?.view ? this.schema.views[config.view] : undefined;
-        const result = await module.nql.run(trx, compiled, pagination, params, param_templates, view, custom?.runners);
+        const result = await module.nql.run(trx, compiled, pagination, params, param_templates, view, customBuckets);
         if (config?.metadataOnly) {
             result.data = result.data.map(obj => ({
                 id: obj.id,
@@ -61,5 +79,17 @@ class BucketAdapter {
         }
         return objUpdate.epoch;
     }
+    static getCacheCustomBuckets(node) {
+        const trx = node.trx;
+        const buckets = {};
+        for (const tag in trx.cache) {
+            const adapter = trx.cache[tag].innerAdapter;
+            buckets[tag] = {
+                scope: `__cache_${tag}`,
+                nql: adapter.nql
+            };
+        }
+        return buckets;
+    }
 }
 exports.BucketAdapter = BucketAdapter;

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

@@ -36,8 +36,8 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
                 let fallback = 0;
                 for (let i = 0; i < sort.length; i++) {
                     const s = sort[i];
-                    const a_val = tree_1.Tree.get(a, s.key);
-                    const b_val = tree_1.Tree.get(b, s.key);
+                    const a_val = s.key_is_deep ? tree_1.Tree.get(a, s.key) : a[s.key];
+                    const b_val = s.key_is_deep ? tree_1.Tree.get(b, s.key) : b[s.key];
                     if (a_val == null) {
                         if (b_val == null)
                             return 0;
@@ -172,56 +172,42 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
         };
         const _rule = (rule, objs, params, param_templates) => {
             const out = {};
-            for (const id in objs) {
-                const obj = objs[id];
-                let match = false;
-                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: {} });
+            const combos = [];
+            for (const param of params) {
+                if (param_templates.length) {
+                    for (const template of param_templates) {
+                        combos.push({ params: param, param_template: template });
                     }
                 }
-                for (const combo of combos) {
-                    match = _obj(rule, obj, combo.params, combo.param_template);
-                    if (match)
-                        break;
-                }
-                if (rule.not) {
-                    match = !match;
+                else {
+                    combos.push({ params: param, param_template: {} });
                 }
+            }
+            for (const combo of combos) {
+                const match = _index(rule, objs, combo.params, combo.param_template);
                 if (match) {
-                    if (rule.select) {
-                        out[obj.id] = obj[rule.select];
+                    Object.assign(out, match);
+                    continue;
+                }
+                for (const id in objs) {
+                    const obj = objs[id];
+                    let match = _obj(rule, obj, combo.params, combo.param_template);
+                    if (rule.not) {
+                        match = !match;
                     }
-                    else {
-                        out[obj.id] = obj;
+                    if (match) {
+                        if (rule.select) {
+                            out[obj.id] = obj[rule.select];
+                        }
+                        else {
+                            out[obj.id] = obj;
+                        }
                     }
                 }
             }
             return out;
         };
-        const _obj = (rule, obj, params, param_template) => {
-            const fieldValue = tree_1.Tree.get(obj, rule.fieldpath);
-            // Value is undefined, only 'present' rule applies
-            if (fieldValue === undefined) {
-                if (rule.op === 'present') {
-                    return false;
-                }
-                return false;
-            }
-            // Fieldpath is a spread, apply rule to each item
-            if (rule.fieldpath.includes('.#')) {
-                for (const item of fieldValue) {
-                    if (_obj(rule, item, params, param_template))
-                        return true;
-                }
-                return false;
-            }
+        const _value = (rule, params, param_template) => {
             let queryValue;
             // Value is a subquery, run union
             if ('subquery' in rule.value) {
@@ -238,10 +224,14 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
             }
             else if ('param' in rule.value) {
                 if (Array.isArray(rule.value.param)) {
-                    queryValue = rule.value.param.map(p => tree_1.Tree.get(params, p));
+                    queryValue = rule.value.param_is_deep
+                        ? rule.value.param.map(p => tree_1.Tree.get(params, p))
+                        : rule.value.param.map(p => params[p]);
                 }
                 else {
-                    queryValue = tree_1.Tree.get(params, rule.value.param);
+                    queryValue = rule.value.param_is_deep
+                        ? tree_1.Tree.get(params, rule.value.param)
+                        : params[rule.value.param];
                 }
             }
             else if ('param_with_$' in rule.value) {
@@ -254,6 +244,52 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
             else if ('static' in rule.value) {
                 queryValue = rule.value.static;
             }
+            return queryValue;
+        };
+        const _index = (rule, objs, params, param_template) => {
+            if (rule.op !== '==')
+                return undefined;
+            if (rule.fieldpath !== 'id')
+                return undefined;
+            const queryValue = _value(rule, params, param_template);
+            let out = {};
+            if (rule.not) {
+                out = Object.assign({}, objs);
+                delete out[queryValue];
+            }
+            else {
+                const obj = objs[queryValue];
+                if (obj) {
+                    out[obj.id] = obj;
+                }
+            }
+            if (rule.select) {
+                for (const id in out) {
+                    out[id] = out[id][rule.select];
+                }
+            }
+            return out;
+        };
+        const _obj = (rule, obj, params, param_template) => {
+            const fieldValue = rule.fieldpath_is_deep
+                ? tree_1.Tree.get(obj, rule.fieldpath)
+                : obj[rule.fieldpath];
+            // Value is undefined, only 'present' rule applies
+            if (fieldValue === undefined) {
+                if (rule.op === 'present') {
+                    return false;
+                }
+                return false;
+            }
+            // Fieldpath is a spread, apply rule to each item
+            if (rule.fieldpath.includes('.#')) {
+                for (const item of fieldValue) {
+                    if (_obj(rule, item, params, param_template))
+                        return true;
+                }
+                return false;
+            }
+            const queryValue = _value(rule, params, param_template);
             // Check each operation
             // (Compatible operations and types have already been validated)
             if (rule.op === '<') {

package/lib/elements/entities/bucket/adapters/test.bucket_adapter.d.ts

@@ -0,0 +1,22 @@
+import { BucketAdapterConfig } from './bucket_adapter';
+import { $Bucket, MemoryBucketAdapter } from "../../..";
+/**
+ * @category Adapters
+ * @subcategory Entity
+ */
+export declare class TestBucketAdapter<B extends $Bucket, Obj extends B['#data']> extends MemoryBucketAdapter<B, Obj> {
+    schema: B;
+    data: NoInfer<Record<Obj['id'], Obj>>;
+    private queryMeta?;
+    constructor(schema: B, data?: NoInfer<Record<Obj['id'], Obj>>, config?: BucketAdapterConfig & {
+        queryMeta?: {
+            scope: string;
+            avgTime: number;
+        };
+    });
+    getQueryMeta(): {
+        scope: string;
+        avgTime: number;
+    };
+}
+export type AnyTestBucketAdapter = TestBucketAdapter<any, any>;

package/lib/elements/entities/bucket/adapters/test.bucket_adapter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestBucketAdapter = void 0;
+const elements_1 = require("../../..");
+/**
+ * @category Adapters
+ * @subcategory Entity
+ */
+class TestBucketAdapter extends elements_1.MemoryBucketAdapter {
+    schema;
+    data;
+    queryMeta;
+    constructor(schema, data = {}, config) {
+        super(schema, data, config);
+        this.schema = schema;
+        this.data = data;
+        this.queryMeta = config?.queryMeta;
+    }
+    getQueryMeta() {
+        return this.queryMeta || super.getQueryMeta();
+    }
+}
+exports.TestBucketAdapter = TestBucketAdapter;

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

@@ -88,8 +88,8 @@ class Bucket {
             ? undefined
             : this.getTenancyQuery(trx);
         let raw;
-        // With Tenancy
         const adapter = await trx_1.Trx.getCache(trx, this) || this.cache || this.adapter;
+        // With Tenancy
         if (tenancy) {
             const result = await adapter.query(trx, {
                 id,
@@ -127,8 +127,8 @@ class Bucket {
             ? undefined
             : this.getTenancyQuery(trx);
         let raws;
-        // With Tenancy
         const adapter = await trx_1.Trx.getCache(trx, this) || this.cache || this.adapter;
+        // With Tenancy
         if (tenancy) {
             const result = await adapter.query(trx, tenancy, undefined, undefined, undefined, options?.query_view ? { view: options?.query_view } : undefined);
             raws = result.data;

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

@@ -2,8 +2,9 @@ import { BucketConfig } from '../bucket.config';
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
 import { NesoiObj } from "../../../../engine/data/obj";
 import { NQL_AnyQuery, NQL_Pagination } from '../query/nql.schema';
-import { NQL_Result } from '../query/nql_engine';
+import { NQL_Result, NQLRunner } from '../query/nql_engine';
 import { AnyBucket } from '../bucket';
+import { NQL_CompiledQuery } from '../query/nql_compiler';
 export type BucketCacheSync<T> = {
     obj: T;
     updateEpoch: number;
@@ -42,6 +43,20 @@ export declare class BucketCache<Obj extends NesoiObj> {
         id: Obj['id'];
         [x: string]: any;
     } : Obj>>;
+    _compileQuery(trx: AnyTrxNode, query: NQL_AnyQuery, custom?: {
+        module?: string;
+        buckets?: Record<string, {
+            scope: string;
+            nql: NQLRunner;
+        }>;
+    }): Promise<NQL_CompiledQuery>;
+    _queryCompiled<MetadataOnly extends boolean>(trx: AnyTrxNode, query: NQL_CompiledQuery, pagination?: NQL_Pagination, params?: Record<string, any>[], param_templates?: Record<string, string>[], config?: {
+        view?: string;
+        metadataOnly?: MetadataOnly;
+    }): Promise<NQL_Result<MetadataOnly extends true ? {
+        id: Obj['id'];
+        [x: string]: any;
+    } : Obj>>;
     /**
      * Update inner adapter with data from outer adapter.
      */
@@ -77,5 +92,6 @@ export declare class BucketCache<Obj extends NesoiObj> {
      * - reduces transit payload for data that doesn't change much
      */
     private syncQuery;
+    private static getCacheCustomBuckets;
 }
 export type AnyBucketCache = BucketCache<any>;

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

@@ -2,11 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BucketCache = exports.BucketCacheEntry = void 0;
 const log_1 = require("../../../../engine/util/log");
+const trx_node_1 = require("../../../../engine/transaction/trx_node");
 const memory_bucket_adapter_1 = require("../adapters/memory.bucket_adapter");
 const datetime_1 = require("../../../../engine/data/datetime");
 const bucket_schema_1 = require("../bucket.schema");
 const bucket_model_schema_1 = require("../model/bucket_model.schema");
 const bucket_graph_schema_1 = require("../graph/bucket_graph.schema");
+const dependency_1 = require("../../../../engine/dependency");
+const nql_compiler_1 = require("../query/nql_compiler");
 /**
  * @category Elements
  * @subcategory Entity
@@ -105,26 +108,42 @@ class BucketCache {
         return out;
     }
     async query(trx, query, pagination, params, param_templates, config) {
+        const compiled = await this._compileQuery(trx, query);
+        return this._queryCompiled(trx, compiled, pagination, params, param_templates, config);
+    }
+    async _compileQuery(trx, query, 
+    // When running a temporary local memory adapter,
+    // these are required
+    custom) {
+        const module = trx_node_1.TrxNode.getModule(trx);
+        const moduleName = custom?.module || module.name;
+        const customBuckets = {
+            ...(custom?.buckets || {}),
+            ...BucketCache.getCacheCustomBuckets(trx)
+        };
+        return nql_compiler_1.NQL_Compiler.build(module.daemon, moduleName, this.bucket.schema.name, query, customBuckets);
+    }
+    async _queryCompiled(trx, query, pagination, params, param_templates, config) {
+        const tag = new dependency_1.Tag(this.bucket.schema.module, 'bucket', this.bucket.schema.name);
         const mode = this.config?.mode?.query;
         let data;
         if (mode === 'eager') {
             log_1.Log.debug('bucket', this.bucket.schema.name, 'CACHE index.eager');
-            data = await this.innerAdapter.query(trx, query, pagination, params, param_templates, config);
+            const result = await this.innerAdapter._queryCompiled(trx, query, pagination, params, param_templates, config, {
+                module: this.bucket.schema.module
+            });
+            data = result.data;
         }
-        if (mode === 'incremental') {
-            const { action, sync } = await this.syncQuery(trx, query, pagination, params);
+        else if (mode === 'incremental') {
+            const { action, sync } = await this.syncQuery(trx, query /* TODO */, pagination, params);
             log_1.Log.debug('bucket', this.bucket.schema.name, `CACHE query.incremental, ${action}`);
             data = sync;
         }
         else if (mode === 'all') {
             const { action, sync } = await this.syncAll(trx);
             log_1.Log.debug('bucket', this.bucket.schema.name, `CACHE query.all, ${action}`);
-            const meta = this.innerAdapter.getQueryMeta();
-            const entries = (await this.innerAdapter.query(trx, query, pagination, params, undefined, undefined, {
-                module: this.bucket.schema.module,
-                runners: {
-                    [meta.scope]: this.innerAdapter.nql
-                }
+            const entries = (await this.innerAdapter._queryCompiled(trx, query, pagination, params, undefined, undefined, {
+                module: this.bucket.schema.module
             })).data;
             data = [];
             for (const e of entries) {
@@ -132,8 +151,10 @@ class BucketCache {
                 data.push(obj);
             }
         }
+        // Invalid mode, bypass cache
         else {
-            data = (await this.outerAdapter.query(trx, query, pagination, params)).data;
+            const result = await this.outerAdapter.query(trx, query /* TODO */, pagination, params);
+            data = result.data;
         }
         for (const entry of data) {
             delete entry['__update_epoch'];
@@ -149,6 +170,7 @@ class BucketCache {
      * Update inner adapter with data from outer adapter.
      */
     async sync(trx) {
+        log_1.Log.debug('bucket', this.bucket.schema.name, `CACHE sync, trx: ${trx.globalId}`);
         const objects = await this.outerAdapter.index(trx);
         const entries = objects.map(obj => new BucketCacheEntry(obj, this.outerAdapter.getUpdateEpoch(obj), this.lastSyncEpoch));
         await this.innerAdapter.deleteEverything(trx);
@@ -162,6 +184,7 @@ class BucketCache {
      * - reduces transit payload for data that doesn't change much
      */
     async syncOne(trx, id) {
+        log_1.Log.debug('bucket', this.bucket.schema.name, `CACHE sync one: ${id}, trx: ${trx.globalId}`);
         let localObj = await this.innerAdapter.get(trx, id);
         if (!localObj) {
             const obj = await this.outerAdapter.get(trx, id);
@@ -253,14 +276,11 @@ class BucketCache {
             return { action: 'none', sync: [] };
         }
         // 2. Read ids from the inner adapter
-        const meta = this.innerAdapter.getQueryMeta();
+        const tag = new dependency_1.Tag(this.bucket.schema.module, 'bucket', this.bucket.schema.name);
         const innerData = await this.innerAdapter.query(trx, {
             'id in': outerMetadata.data.map(obj => obj.id)
         }, undefined, undefined, undefined, undefined, {
-            module: this.bucket.schema.module,
-            runners: {
-                [meta.scope]: this.innerAdapter.nql
-            }
+            module: this.bucket.schema.module
         });
         // 3. Filter modified query results
         const outerEpoch = {};
@@ -298,5 +318,17 @@ class BucketCache {
         }
         return { action: 'update', sync: Object.values(queryResults).map(r => new BucketCacheEntry(r.obj, r.updateEpoch, datetime_1.NesoiDatetime.now().epoch)) };
     }
+    static getCacheCustomBuckets(node) {
+        const trx = node.trx;
+        const buckets = {};
+        for (const tag in trx.cache) {
+            const adapter = trx.cache[tag].innerAdapter;
+            buckets[tag] = {
+                scope: `__cache_${tag}`,
+                nql: adapter.nql
+            };
+        }
+        return buckets;
+    }
 }
 exports.BucketCache = BucketCache;