nesoi 3.4.2 → 3.4.3

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

@@ -30,6 +30,10 @@ class BucketView {
         const module = trx_node_1.TrxNode.getModule(trx);
         const tag = new dependency_1.Tag(this.bucket.module.name, 'bucket', this.bucket.schema.name);
         const meta = await daemon_1.Daemon.getBucketMetadata(module.daemon, tag);
+        if (flags?.serialize) {
+            const model = new bucket_model_1.BucketModel(meta.schema);
+            root = model.copy(root, 'load', () => true);
+        }
         const parsed = {};
         if ('__root' in this.schema.fields || '__parent' in this.schema.fields || '__value' in this.schema.fields) {
             Object.assign(parsed, root);
@@ -56,6 +60,8 @@ class BucketView {
         };
     }
     async parseMany(trx, roots, flags) {
+        if (!roots.length)
+            return [];
         const module = trx_node_1.TrxNode.getModule(trx);
         const tag = new dependency_1.Tag(this.bucket.module.name, 'bucket', this.bucket.schema.name);
         const meta = await daemon_1.Daemon.getBucketMetadata(module.daemon, tag);
@@ -89,7 +95,7 @@ class BucketView {
         return parseds;
     }
     async parseLayer(trx, layer, flags) {
-        const next = [];
+        let next = [];
         // Model props
         for (const node of layer) {
             if (node.field.scope !== 'model')
@@ -131,6 +137,8 @@ class BucketView {
                 data: node.data
             })));
         }
+        // Exclude eventual nodes without data
+        next = next.filter(node => node.data.length);
         return next;
     }
     toDict(as_dict, data, final = false) {
@@ -255,7 +263,7 @@ class BucketView {
                 }
             }
             // Copy modelpath value from object
-            const value = model.copy(data.parent, 'save', () => !!flags?.serialize, node_modelpath);
+            const value = model.copy(data.parent, 'load', () => !!flags?.serialize, node_modelpath);
             const many = modelpath.split('.').includes('*');
             // Modelpath contains '*', so it returns N results
             if (many) {
@@ -417,7 +425,13 @@ class BucketView {
         const otherBucket = await daemon_1.Daemon.getBucketMetadata(daemon, otherBucketDep);
         // Step 3: Build view
         let next = [];
-        let nextData = linksObjs;
+        let nextData = linksObjs.map((link, i) => ({
+            root: node.data[i].root,
+            parent: link,
+            value: link,
+            index: node.data[i].index,
+            target: node.data[i].target[node.data[i].key]
+        }));
         if (meta.view) {
             const view = otherBucket.schema.views[meta.view];
             const includeRoot = '__root' in view.fields;
@@ -445,7 +459,13 @@ class BucketView {
                     }
                 }
                 if (!node.field.prop) {
-                    nextData = _links.map((ll, i) => ll.map((l, j) => ({ value: l, target: node.data[i].target[node.data[i].key][j] }))).flat(1);
+                    nextData = _links.map((ll, i) => ll.map((l, j) => ({
+                        root: node.data[i].root,
+                        parent: l,
+                        value: l,
+                        index: node.data[i].index,
+                        target: node.data[i].target[node.data[i].key][j]
+                    }))).flat(1);
                 }
                 else {
                     nextData = [];
@@ -468,7 +488,11 @@ class BucketView {
                         }
                         target.$v = meta.view;
                         nextData.push({
-                            value: _links[i], target: node.data[i].target[key]
+                            root: _links[i],
+                            parent: _links[i],
+                            value: _links[i],
+                            index: [],
+                            target: node.data[i].target[key]
                         });
                     }
                 }
@@ -483,10 +507,10 @@ class BucketView {
                         bucket: otherBucket,
                         field,
                         data: nextData.map($ => ({
-                            root: $.value,
-                            parent: $.value,
+                            root: $.root,
+                            parent: $.parent,
                             value: $.value,
-                            index: [],
+                            index: $.index,
                             target: $.target,
                             key: field.name
                         }))
@@ -561,6 +585,21 @@ class BucketView {
                 });
             }
         }
+        // Step 4b: Add chain to queue
+        if (node.field.chain) {
+            next.push({
+                bucket: node.bucket,
+                field: node.field.chain,
+                data: linksObjs.map((l, i) => ({
+                    root: node.data[i].root,
+                    parent: l,
+                    index: node.data[i].index,
+                    value: l,
+                    target: node.data[i].target,
+                    key: node.data[i].key
+                }))
+            });
+        }
         return next;
     }
     /**

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

@@ -158,6 +158,10 @@ export declare namespace NesoiError {
             }): BaseError;
         }
         namespace Model {
+            function FieldRequired($: {
+                bucket: string;
+                field: string;
+            }): BaseError;
             function InvalidModelpath($: {
                 bucket: string;
                 modelpath: string;

package/lib/engine/data/error.js

@@ -296,6 +296,10 @@ var NesoiError;
         })(Fieldpath = Bucket.Fieldpath || (Bucket.Fieldpath = {}));
         let Model;
         (function (Model) {
+            function FieldRequired($) {
+                return new BaseError('Bucket.Model.InvalidModelpath', `Field '${$.field}' is required on bucket '${$.bucket}'`, Status.BAD_REQUEST, $);
+            }
+            Model.FieldRequired = FieldRequired;
             function InvalidModelpath($) {
                 return new BaseError('Bucket.Model.InvalidModelpath', `Modelpath '${$.modelpath}' not found on bucket '${$.bucket}'`, Status.BAD_REQUEST, $);
             }

package/lib/engine/transaction/nodes/bucket.trx_node.d.ts

@@ -91,7 +91,11 @@ export declare class BucketTrxNode<M extends $Module, $ extends $Bucket> {
     /**
      * Returns `true` if the graph link resolves to at least 1 object.
      */
-    hasLink<LinkName extends keyof $['graph']['links']>(id: $['#data']['id'], link: LinkName): Promise<boolean | undefined>;
+    hasLink<LinkName extends keyof $['graph']['links']>(id: $['#data']['id'], link: LinkName): Promise<boolean>;
+    /**
+     * Returns the number of objects matching the link.
+     */
+    countLink<LinkName extends keyof $['graph']['links']>(id: $['#data']['id'], link: LinkName): Promise<number>;
     /**
      * Creates an object by passing it to the bucket adapter.
      * Also creates the compositions of this bucket, from the

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

@@ -211,6 +211,14 @@ class BucketTrxNode {
             no_tenancy: !this.enableTenancy
         }), undefined, true);
     }
+    /**
+     * Returns the number of objects matching the link.
+     */
+    async countLink(id, link) {
+        return this.wrap('countLink', { id, link }, (trx, bucket) => bucket.countLink(trx, id, link, {
+            no_tenancy: !this.enableTenancy
+        }), undefined, true);
+    }
     /*
         Create
     */

package/lib/engine/transaction/nodes/bucket_query.trx_node.d.ts

@@ -17,10 +17,14 @@ export declare class BucketQueryTrxNode<M extends $Module, B extends $Bucket, V
     private view?;
     private _params?;
     private _param_templates?;
+    private _serialize;
+    private _metadata_only;
     private external;
     private bucket?;
     constructor(trx: TrxNode<any, M, any>, tag: Tag, query: NQL_AnyQuery, enableTenancy: boolean, view?: V | undefined);
     merge($: NQL_Query<M, B>): void;
+    serialize(value?: boolean): this;
+    metadata_only(value?: boolean): this;
     params(value?: Record<string, any> | Record<string, any>[]): this;
     param_templates(value?: Record<string, any> | Record<string, any>[]): this;
     wrap(action: string, input: Record<string, any>, fn: (trx: AnyTrxNode, element: Bucket<M, B>) => Promise<any>): Promise<{

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

@@ -17,6 +17,8 @@ class BucketQueryTrxNode {
     view;
     _params = [];
     _param_templates = [];
+    _serialize = false;
+    _metadata_only = false;
     external;
     bucket;
     constructor(trx, tag, query, enableTenancy, view) {
@@ -40,6 +42,18 @@ class BucketQueryTrxNode {
         this.query['#and*'] = and; // TODO: make this a little better
         this.query['#or*'] = or; // TODO: make this a little better
     }
+    serialize(value) {
+        if (value) {
+            this._serialize = true;
+        }
+        return this;
+    }
+    metadata_only(value) {
+        if (value) {
+            this._metadata_only = true;
+        }
+        return this;
+    }
     params(value) {
         this._params = value
             ? Array.isArray(value) ? value : [value]
@@ -82,6 +96,8 @@ class BucketQueryTrxNode {
             return bucket.query(trx, this.query, {
                 perPage: 1
             }, this.view, {
+                metadata_only: this._metadata_only,
+                serialize: this._serialize,
                 no_tenancy: !this.enableTenancy,
                 params: this._params,
                 param_templates: this._param_templates
@@ -94,6 +110,8 @@ class BucketQueryTrxNode {
     async firstOrFail() {
         const results = await this.wrap('queryFirstOrFail', { schema: this.query, view: this.view }, async (trx, bucket) => {
             const results = await bucket.query(trx, this.query, undefined, this.view, {
+                metadata_only: this._metadata_only,
+                serialize: this._serialize,
                 no_tenancy: !this.enableTenancy,
                 params: this._params,
                 param_templates: this._param_templates
@@ -108,6 +126,8 @@ class BucketQueryTrxNode {
     async all() {
         const results = await this.wrap('queryAll', { schema: this.query, view: this.view }, async (trx, bucket) => {
             return bucket.query(trx, this.query, undefined, this.view, {
+                metadata_only: this._metadata_only,
+                serialize: this._serialize,
                 params: this._params,
                 param_templates: this._param_templates
             });
@@ -123,6 +143,8 @@ class BucketQueryTrxNode {
         }
         const results = await this.wrap('queryPage', { schema: this.query, view: this.view }, async (trx, bucket) => {
             return bucket.query(trx, this.query, pagination, this.view, {
+                metadata_only: this._metadata_only,
+                serialize: this._serialize,
                 params: this._params,
                 param_templates: this._param_templates
             });

package/lib/engine/transaction/trx_engine.d.ts

@@ -40,11 +40,11 @@ export declare class TrxEngine<S extends $Space, M extends $Module, AuthUsers ex
     private services;
     private $TrxBucket;
     /**
-     * Transaction used to read/write transactions on the adapter
+     * Transaction used to read/write transactions on the log adapter
      */
     private innerTrx;
-    private adapter;
     private log_adapter?;
+    private ongoing;
     constructor(origin: TrxEngineOrigin, module: Module<S, M>, authnProviders?: AuthUsers | undefined, config?: TrxEngineConfig<S, M, any, any> | undefined, services?: Record<string, IService>);
     getModule(): Module<S, M>;
     get(id?: string, origin?: string, req_idempotent?: boolean): Promise<Trx<S, M, any>>;

package/lib/engine/transaction/trx_engine.js

@@ -5,7 +5,6 @@ const log_1 = require("../util/log");
 const trx_1 = require("./trx");
 const trx_node_1 = require("./trx_node");
 const error_1 = require("../data/error");
-const memory_bucket_adapter_1 = require("../../elements/entities/bucket/adapters/memory.bucket_adapter");
 const elements_1 = require("../../elements");
 const bucket_model_schema_1 = require("../../elements/entities/bucket/model/bucket_model.schema");
 const bucket_graph_schema_1 = require("../../elements/entities/bucket/graph/bucket_graph.schema");
@@ -22,11 +21,14 @@ class TrxEngine {
     services;
     $TrxBucket;
     /**
-     * Transaction used to read/write transactions on the adapter
+     * Transaction used to read/write transactions on the log adapter
      */
     innerTrx;
-    adapter;
     log_adapter;
+    /*
+     * Ongoing Transactions
+     */
+    ongoing = {};
     constructor(origin, module, authnProviders, config, services = {}) {
         this.origin = origin;
         this.module = module;
@@ -42,7 +44,6 @@ class TrxEngine {
             start: new bucket_model_schema_1.$BucketModelField('start', 'start', 'datetime', 'Start', true),
             end: new bucket_model_schema_1.$BucketModelField('end', 'end', 'datetime', 'End', false)
         }), new bucket_graph_schema_1.$BucketGraph(), {});
-        this.adapter = config?.adapter?.(this.$TrxBucket) || new memory_bucket_adapter_1.MemoryBucketAdapter(this.$TrxBucket, {});
         if (config?.log_adapter) {
             this.log_adapter = config?.log_adapter?.(this.$TrxBucket);
         }
@@ -62,20 +63,20 @@ class TrxEngine {
                 await wrap.begin(trx, this.services);
             }
             if (!req_idempotent) {
-                await this.adapter.create(this.innerTrx.root, {
+                this.ongoing[trx.id] = {
                     id: trx.id,
                     state: 'open',
                     origin: trx.origin,
                     start: trx.start,
                     end: trx.end,
                     module: this.module.name,
-                });
+                };
             }
             return trx;
         }
         // Chain/Continue transaction
         else {
-            const trxData = await this.adapter.get(this.innerTrx.root, id);
+            const trxData = await this.ongoing[id];
             // If trxData exists, the transaction to which it refers is non-idempotent,
             // since idempotent transactions are not stored.
             //
@@ -145,14 +146,14 @@ class TrxEngine {
                     // The wrappers decide how to begin a db transaction, based on the trx idempotent flag.
                     await wrap.begin(trx, this.services);
                 }
-                await this.adapter.create(this.innerTrx.root, {
+                this.ongoing[trx.id] = {
                     id: trx.id,
                     state: 'open',
                     origin: _origin,
                     start: trx.start,
                     end: trx.end,
                     module: this.module.name,
-                });
+                };
             }
         }
         return trx;
@@ -227,14 +228,14 @@ class TrxEngine {
     async hold(trx, output) {
         log_1.Log.debug('module', this.module.name, `Hold ${(0, log_1.scopeTag)('trx', trx.root.globalId)}`);
         trx_node_1.TrxNode.hold(trx.root, output);
-        await this.adapter.put(this.innerTrx.root, {
+        this.ongoing[trx.id] = {
             id: trx.id,
             state: 'hold',
             origin: this.origin,
             start: trx.start,
             end: trx.end,
             module: this.module.name,
-        });
+        };
         return trx;
     }
     async ok(trx, output, idempotent) {
@@ -260,7 +261,7 @@ class TrxEngine {
             end: trx.end,
             module: this.module.name,
         });
-        await this.adapter.delete(this.innerTrx.root, trx.id);
+        delete this.ongoing[trx.id];
         for (const wrap of this.config?.wrap || []) {
             await wrap.commit(trx, this.services);
         }
@@ -289,7 +290,7 @@ class TrxEngine {
             end: trx.end,
             module: this.module.name,
         });
-        await this.adapter.delete(this.innerTrx.root, trx.id);
+        delete this.ongoing[trx.id];
         for (const wrap of this.config?.wrap || []) {
             await wrap.rollback(trx, this.services);
         }

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

@@ -8,7 +8,6 @@ import { NesoiFile } from '../data/file';
 import { NesoiDuration } from '../data/duration';
 import { Tag } from '../dependency';
 export declare function parseBoolean(field: {
-    pathRaw: string;
     alias: string;
 }, path: string[], value: any): boolean;
 export declare function parseDate(field: {
@@ -33,15 +32,12 @@ export declare function parseEnum(raw: Record<string, any>, field: {
     alias: string;
 }, path: string[], value: any, meta: NonNullable<$MessageTemplateFieldMeta['enum']>, trx: AnyTrxNode): string;
 export declare function parseFile(field: {
-    pathRaw: string;
-    name: string;
     alias: string;
 }, path: string[], value: any, options?: {
     maxsize?: number;
     extnames?: string[];
 }): NesoiFile;
 export declare function parseFloat_(field: {
-    pathRaw: string;
     alias: string;
 }, path: string[], value: any): number;
 export declare function parseId<M extends $Module, Name extends BucketName<M>, View extends ViewName<M['buckets'][Name]> | undefined>(field: {
@@ -52,15 +48,12 @@ export declare function parseId<M extends $Module, Name extends BucketName<M>, V
     obj: any;
 }>;
 export declare function parseInt_(field: {
-    pathRaw: string;
     alias: string;
 }, path: string[], value: any): number;
 export declare function parseString(field: {
-    pathRaw: string;
     alias: string;
 }, path: string[], value: any): string;
 export declare function parseLiteral(field: {
-    pathRaw: string;
     alias: string;
 }, path: string[], value: any, template: string): string;
 export declare function parseStringOrNumber(field: {

package/package.json

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

package/tools/joaquin/bucket.d.ts

@@ -18,6 +18,10 @@ export declare function expectBucket(def: (builder: AnyBucketBuilder) => any, in
     builder: AnyBucketBuilder;
     data: Record<string, any>;
 })[]): {
+    toCopyOne(raw: Record<string, any>, op: "save" | "load"): {
+        as(parsed: Record<string, any> | Record<string, any>[]): Promise<void>;
+        butFail(error: (...args: any[]) => NesoiError.BaseError): Promise<void>;
+    };
     toBuildOne(raw: Record<string, any>, view: string, flags?: {
         serialize: boolean;
     }): {

package/tools/joaquin/bucket.js

@@ -4,7 +4,11 @@ exports.givenBucket = givenBucket;
 exports.expectBucket = expectBucket;
 const bucket_builder_1 = require("../../src/elements/entities/bucket/bucket.builder");
 const inline_app_1 = require("../../src/engine/app/inline.app");
+const trx_1 = require("../../src/engine/transaction/trx");
 const elements_1 = require("../../src/elements");
+const daemon_1 = require("../../src/engine/daemon");
+const datetime_1 = require("../../src/engine/data/datetime");
+const bucket_model_1 = require("../../src/elements/entities/bucket/model/bucket_model");
 function givenBucket(name, def) {
     const builder = new bucket_builder_1.BucketBuilder('test', name);
     const data = {};
@@ -37,6 +41,15 @@ function expectBucket(def, inject = []) {
     });
     let promise;
     const step1 = {
+        toCopyOne(raw, op) {
+            promise = () => app.daemon().then(daemon => {
+                const bucket = daemon_1.Daemon.getModule(daemon, 'test').buckets['test'];
+                const model = new bucket_model_1.BucketModel(bucket.schema);
+                const copy = model.copy(raw, op);
+                return new trx_1.TrxStatus('', 'trx:', datetime_1.NesoiDatetime.now(), datetime_1.NesoiDatetime.now(), 'ok', copy);
+            });
+            return step2;
+        },
         toBuildOne(raw, view, flags) {
             promise = () => app.daemon().then(daemon => daemon.trx('test').run(trx => trx.bucket('test').buildOne(raw, view, flags)));
             return step2;