nesoi 3.2.1 → 3.2.2

package/lib/engine/transaction/nodes/bucket_query.trx_node.js

@@ -14,6 +14,7 @@ class BucketQueryTrxNode {
         this.query = query;
         this.enableTenancy = enableTenancy;
         this.view = view;
+        this._params = [];
     }
     merge($) {
         const and = $['#and'];
@@ -24,6 +25,10 @@ class BucketQueryTrxNode {
         this.query['#and*'] = and; // TODO: make this a little better
         this.query['#or*'] = or; // TODO: make this a little better
     }
+    params(value) {
+        this._params = [value];
+        return this;
+    }
     async first() {
         await trx_node_1.TrxNode.open(this.trx, 'queryFirst', { schema: this.query, view: this.view });
         let results;
@@ -31,7 +36,8 @@ class BucketQueryTrxNode {
             results = await this.bucket.query(this.trx, this.query, {
                 perPage: 1
             }, this.view, {
-                no_tenancy: !this.enableTenancy
+                no_tenancy: !this.enableTenancy,
+                params: this._params
             });
         }
         catch (e) {
@@ -47,7 +53,8 @@ class BucketQueryTrxNode {
         let results;
         try {
             results = await this.bucket.query(this.trx, this.query, undefined, this.view, {
-                no_tenancy: !this.enableTenancy
+                no_tenancy: !this.enableTenancy,
+                params: this._params
             });
         }
         catch (e) {
@@ -64,7 +71,9 @@ class BucketQueryTrxNode {
         await trx_node_1.TrxNode.open(this.trx, 'queryAll', { schema: this.query, view: this.view });
         let results;
         try {
-            results = await this.bucket.query(this.trx, this.query, undefined, this.view);
+            results = await this.bucket.query(this.trx, this.query, undefined, this.view, {
+                params: this._params
+            });
         }
         catch (e) {
             throw await trx_node_1.TrxNode.error(this.trx, e); // Bucket unexpected error
@@ -81,7 +90,9 @@ class BucketQueryTrxNode {
         await trx_node_1.TrxNode.open(this.trx, 'queryPage', { schema: this.query, pagination, view: this.view });
         let result;
         try {
-            result = await this.bucket.query(this.trx, this.query, pagination, this.view);
+            result = await this.bucket.query(this.trx, this.query, pagination, this.view, {
+                params: this._params
+            });
         }
         catch (e) {
             throw await trx_node_1.TrxNode.error(this.trx, e); // Bucket unexpected error

package/lib/engine/util/log.d.ts

@@ -1,7 +1,7 @@
 import { $BlockType } from "../../elements/blocks/block.schema";
 declare const LogLevel: readonly ["off", "error", "warn", "info", "debug", "trace"];
 export type LogLevel = typeof LogLevel[number];
-export type LogScope = $BlockType | 'compiler' | 'trx' | 'daemon' | 'app' | 'module' | 'layer' | 'message' | 'bucket' | 'job' | 'resource' | 'controller' | 'queue' | 'topic' | 'constants' | 'externals' | 'inc.server' | 'inc.client';
+export type LogScope = $BlockType | 'compiler' | 'trx' | 'daemon' | 'app' | 'module' | 'layer' | 'message' | 'bucket' | 'job' | 'resource' | 'controller' | 'queue' | 'topic' | 'constants' | 'externals' | 'nql' | 'inc.server' | 'inc.client';
 export declare function scopeTag(scope: LogScope, scope_id: string): string;
 export declare function anyScopeTag(scopeWithId: string): string;
 export declare class Log {

package/lib/engine/util/log.js

@@ -25,6 +25,7 @@ function scopeTag(scope, scope_id) {
         machine: 'lightblue',
         queue: 'lightblue',
         topic: 'lightblue',
+        nql: 'lightpurple',
         'inc.server': 'lightgreen',
         'inc.client': 'lightcyan',
     }[scope] || 'lightgray';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "nesoi",
-    "version": "3.2.1",
+    "version": "3.2.2",
     "description": "Declarative framework for data-driven applications",
     "repository": {
         "type": "git",

package/tools/joaquin/bucket.d.ts

@@ -1,9 +1,29 @@
-import { AnyBucketBuilder } from "../../src/elements/entities/bucket/bucket.builder";
+import { AnyBucketBuilder, BucketBuilder } from "../../src/elements/entities/bucket/bucket.builder";
 import { NesoiError } from "../../src/engine/data/error";
 import { AnyBuilder } from "../../src/engine/module";
-export declare function expectBucket(def: (builder: AnyBucketBuilder) => any, inject?: AnyBuilder[]): {
+export declare function givenBucket<Def>(name: string, def: (builder: AnyBucketBuilder) => any): {
+    builder: BucketBuilder<import("../../src/elements").$Space, import("../../src/elements").$Module, Omit<import("../../src/elements").$Bucket, "views"> & {
+        views: {};
+    }>;
+    data: Record<string, any>;
+    withData(mock: Record<string, any>): {
+        builder: BucketBuilder<import("../../src/elements").$Space, import("../../src/elements").$Module, Omit<import("../../src/elements").$Bucket, "views"> & {
+            views: {};
+        }>;
+        data: Record<string, any>;
+        withData(mock: Record<string, any>): /*elided*/ any;
+    };
+};
+export declare function expectBucket(def: (builder: AnyBucketBuilder) => any, inject?: (AnyBuilder | {
+    builder: AnyBucketBuilder;
+    data: Record<string, any>;
+})[]): {
     toBuildOne(raw: Record<string, any>, view: string): {
-        as(parsed: Record<string, any>): Promise<void>;
+        as(parsed: Record<string, any> | Record<string, any>[]): Promise<void>;
+        butFail(error: (...args: any[]) => NesoiError.BaseError): Promise<void>;
+    };
+    toBuildMany(raws: Record<string, any>[], view: string): {
+        as(parsed: Record<string, any> | Record<string, any>[]): Promise<void>;
         butFail(error: (...args: any[]) => NesoiError.BaseError): Promise<void>;
     };
 };

package/tools/joaquin/bucket.js

@@ -1,43 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.givenBucket = givenBucket;
 exports.expectBucket = expectBucket;
 const bucket_builder_1 = require("../../src/elements/entities/bucket/bucket.builder");
 const inline_app_1 = require("../../src/engine/apps/inline.app");
+const elements_1 = require("../../src/elements");
+function givenBucket(name, def) {
+    const builder = new bucket_builder_1.BucketBuilder('test', name);
+    const data = {};
+    def(builder);
+    return {
+        builder,
+        data,
+        withData(mock) {
+            Object.assign(data, mock);
+            return this;
+        }
+    };
+}
 function expectBucket(def, inject = []) {
     const builder = new bucket_builder_1.BucketBuilder('test', 'test');
     def(builder);
-    const app = new inline_app_1.InlineApp('test', [...inject, builder]);
+    const injectBuilders = inject.map(i => 'builder' in i ? i.builder : i);
+    const app = new inline_app_1.InlineApp('test', [...injectBuilders, builder]);
+    // Configure buckets
+    const bucketConfig = {};
+    for (const i of inject) {
+        if (!('data' in i))
+            continue;
+        bucketConfig[i.builder.name] = {
+            adapter: (schema) => new elements_1.MemoryBucketAdapter(schema, i.data)
+        };
+    }
+    app.config.module('test', {
+        buckets: bucketConfig
+    });
     let promise;
     const step1 = {
         toBuildOne(raw, view) {
-            promise = Promise.all([raw].map(raw => app.daemon().then(daemon => daemon.trx('test').run(trx => trx.bucket('test').buildOne(raw, view)))));
+            promise = () => app.daemon().then(daemon => daemon.trx('test').run(trx => trx.bucket('test').buildOne(raw, view)));
+            return step2;
+        },
+        toBuildMany(raws, view) {
+            promise = () => app.daemon().then(daemon => daemon.trx('test').run(trx => trx.bucket('test').buildMany(raws, view)));
             return step2;
         }
     };
     const step2 = {
         async as(parsed) {
-            const status = await promise;
-            status.forEach(st => {
-                if (st.state === 'error') {
-                    console.log(st.summary());
-                    console.error(st.error?.data);
-                    console.error(st.error?.data?.unionErrors);
-                    console.error(st.error?.stack);
-                }
-                expect(st.state).toEqual('ok');
-                expect(st.output)
-                    .toEqual(parsed);
-            });
+            const status = await promise();
+            if (status.state === 'error') {
+                console.log(status.summary());
+                console.error(status.error?.data);
+                console.error(status.error?.data?.unionErrors);
+                console.error(status.error?.stack);
+            }
+            expect(status.state).toEqual('ok');
+            expect(status.output)
+                .toEqual(parsed);
         },
         async butFail(error) {
             const errorObj = error({});
             try {
-                const status = await promise;
-                status.forEach(st => {
-                    expect(st.state).toEqual('error');
-                    expect(st.error?.name)
-                        .toEqual(errorObj.name);
-                });
+                const status = await promise();
+                expect(status.state).toEqual('error');
+                expect(status.error?.name)
+                    .toEqual(errorObj.name);
             }
             catch (e) {
                 expect(e.toString())

package/tools/joaquin/job.js

@@ -13,18 +13,18 @@ function expectJob(def) {
     const step1 = {
         onRaw(_raw) {
             raw = _raw;
-            promise = app.daemon().then(daemon => daemon.trx('test').run(trx => trx.job('test').run(_raw)));
+            promise = () => app.daemon().then(daemon => daemon.trx('test').run(trx => trx.job('test').run(_raw)));
             return step2;
         },
         onMessage(_msg) {
             msg = _msg;
-            promise = app.daemon().then(daemon => daemon.trx('test').run(trx => trx.job('test').forward(_msg)));
+            promise = () => app.daemon().then(daemon => daemon.trx('test').run(trx => trx.job('test').forward(_msg)));
             return step2;
         }
     };
     const step2 = {
         async toResolve(value) {
-            const status = await promise;
+            const status = await promise();
             expect(status.state).toEqual('ok');
             expect(status.output)
                 .toEqual(value({ raw, msg }));
@@ -32,7 +32,7 @@ function expectJob(def) {
         async toReject(error) {
             const errorObj = error({ raw, msg })({});
             try {
-                const status = await promise;
+                const status = await promise();
                 expect(status.state).toEqual('error');
                 expect(status.error?.name)
                     .toEqual(errorObj.name);