nesoi 3.1.8 → 3.2.2

package/lib/compiler/apps/distributed/stages/4_dump_modules_stage.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DumpModulesStage = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const log_1 = require("../../../../engine/util/log");
+const app_1 = require("../../../../engine/apps/app");
+/**
+ * [distributed Compiler Stage #4]
+ * Dump modules to build/modules folder.
+ *
+ * @category distributed Compiler
+ * @subcategory Stages
+ */
+class DumpModulesStage {
+    constructor(distributed, app) {
+        this.distributed = distributed;
+        this.app = app;
+    }
+    async run() {
+        const { compiler, dirs: _dirs } = this.distributed;
+        for (const name in this.app.nodes) {
+            log_1.Log.info('compiler', 'distributed', `[${name}] Dumping modules to build/modules folder...`);
+            const node = this.app.nodes[name];
+            const info = app_1.App.getInfo(node);
+            const dirs = _dirs.nodes[name];
+            for (const name of info.spaceModules) {
+                const module = compiler.modules[name];
+                this.dumpModule(module, dirs.build_modules);
+            }
+        }
+    }
+    dumpModule(module, dir) {
+        log_1.Log.debug('compiler', 'distributed', `Dumping module ${module.lowName}`);
+        let str = `const { Module } = require('${module.compiler.config?.nesoiPath || 'nesoi'}/lib/engine/module');\n`;
+        str += `exports.default = new Module('${module.lowName}')\n`;
+        str += '  .inject({';
+        const externals = module.module.schema.externals;
+        if (externals) {
+            str += '\n    externals: {';
+            if (Object.keys(externals.buckets).length) {
+                str += '\n      buckets: {';
+                for (const b in externals.buckets) {
+                    const dep = externals.buckets[b];
+                    str += `\n        '${b}': ${JSON.stringify(dep, undefined, 2).replace(/\n/g, '\n        ')},`;
+                }
+                str += '\n      },';
+            }
+            if (Object.keys(externals.messages).length) {
+                str += '\n      messages: {';
+                for (const b in externals.messages) {
+                    const dep = externals.messages[b];
+                    str += `\n        '${b}': ${JSON.stringify(dep, undefined, 2).replace(/\n/g, '\n        ')},`;
+                }
+                str += '\n      },';
+            }
+            if (Object.keys(externals.jobs).length) {
+                str += '\n      jobs: {\n';
+                for (const b in externals.jobs) {
+                    const dep = externals.jobs[b];
+                    str += `\n        '${b}': ${JSON.stringify(dep, undefined, 2).replace(/\n/g, '\n        ')},`;
+                }
+                str += '\n      },';
+            }
+            if (Object.keys(externals.machines).length) {
+                str += '\n      machines: {\n';
+                for (const b in externals.machines) {
+                    const dep = externals.machines[b];
+                    str += `\n        '${b}': ${JSON.stringify(dep, undefined, 2).replace(/\n/g, '\n        ')},`;
+                }
+                str += '\n      },';
+            }
+            str += '\n    },';
+        }
+        const constants = module.module.schema.constants;
+        if (constants && (Object.values(constants.values).length || Object.values(constants.enums).length)) {
+            str += `\n    constants: require('./${module.lowName}/constants__${module.lowName}').default,`;
+        }
+        const buckets = Object.values(module.module.schema.buckets || {});
+        if (buckets.length) {
+            str += '\n    buckets: [\n';
+            buckets.forEach(bucket => {
+                str += `      require('./${module.lowName}/bucket__${bucket.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const messages = Object.values(module.module.schema.messages || {});
+        if (messages.length) {
+            str += '\n    messages: [\n';
+            messages.forEach(message => {
+                str += `      require('./${module.lowName}/message__${message.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const jobs = Object.values(module.module.schema.jobs || {});
+        if (jobs.length) {
+            str += '\n    jobs: [\n';
+            jobs.forEach(job => {
+                str += `      require('./${module.lowName}/job__${job.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const resources = Object.values(module.module.schema.resources || {});
+        if (resources.length) {
+            str += '\n    resources: [\n';
+            resources.forEach(resource => {
+                str += `      require('./${module.lowName}/resource__${resource.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const machines = Object.values(module.module.schema.machines || {});
+        if (machines.length) {
+            str += '\n    machines: [\n';
+            machines.forEach(machine => {
+                str += `      require('./${module.lowName}/machine__${machine.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const controllers = Object.values(module.module.schema.controllers || {});
+        if (controllers.length) {
+            str += '\n    controllers: [\n';
+            controllers.forEach(controller => {
+                str += `      require('./${module.lowName}/controller__${controller.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const queues = Object.values(module.module.schema.queues || {});
+        if (queues.length) {
+            str += '\n    queues: [\n';
+            queues.forEach(queue => {
+                str += `      require('./${module.lowName}/queue__${queue.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        const topics = Object.values(module.module.schema.topics || {});
+        if (topics.length) {
+            str += '\n    topics: [\n';
+            topics.forEach(topic => {
+                str += `      require('./${module.lowName}/topic__${topic.name}').default,\n`;
+            });
+            str += '    ],';
+        }
+        str += '})';
+        const moduleFilename = `${module.lowName}.js`;
+        const modulePath = path.resolve(dir, moduleFilename);
+        fs.writeFileSync(modulePath, str);
+    }
+}
+exports.DumpModulesStage = DumpModulesStage;

package/lib/compiler/apps/distributed/stages/5_copy_static_stage.js

@@ -0,0 +1,31 @@
+"use strict";
+// import * as fs from 'fs';
+// import * as path from 'path';
+// import { Log } from '~/engine/util/log';
+// import { MonolythApp } from '~/engine/apps/monolyth/monolyth.app';
+// import { MonolythCompiler } from '../monolyth_compiler';
+// import { Space } from '~/engine/space';
+// /**
+//  * [Monolyth Compiler Stage #5]
+//  * Copy the paths passed to `staticPaths` on the compiler
+//  * config to the build folder.
+//  * 
+//  * @category Monolyth Compiler
+//  * @subcategory Stages
+//  */
+// export class CopyStaticStage {
+//     public constructor(
+//         private monolyth: MonolythCompiler,
+//         private app: MonolythApp<any, any>
+//     ) {}
+//     public async run() {
+//         Log.info('compiler', 'monolyth', 'Copying static paths to build folder...')
+//         for (const staticPath of this.monolyth.config.staticPaths || []) {
+//             const from = Space.path(this.monolyth.compiler.space, staticPath);
+//             const to = path.join(this.monolyth.dirs.build, staticPath);
+//             fs.cpSync(from, to, {
+//                 recursive: true
+//             })
+//         }
+//     }
+// }

package/lib/compiler/apps/distributed/stages/6_dump_cli_stage.js

@@ -0,0 +1,34 @@
+"use strict";
+// import * as fs from 'fs';
+// import * as path from 'path';
+// import { Log } from '~/engine/util/log';
+// import { MonolythApp } from '~/engine/apps/monolyth/monolyth.app';
+// import { MonolythCompiler } from '../monolyth_compiler';
+// /**
+//  * [Monolyth Compiler Stage #6]
+//  * Dump the cli.js file to build/bin folder.
+//  * 
+//  * @category Monolyth Compiler
+//  * @subcategory Stages
+//  */
+// export class DumpCLIStage {
+//     public constructor(
+//         private monolyth: MonolythCompiler,
+//         private app: MonolythApp<any, any>
+//     ) {}
+//     public async run() {
+//         Log.info('compiler', 'monolyth', 'Dumping cli.js file to build/bin folder...')
+//         const { dirs } = this.monolyth;
+//         let str = '';
+//         str += 'require("nesoi/tools/dotenv");\n';
+//         str += 'const app = require(\'../app\').default\n';
+//         str += 'const { Log } = require(\'nesoi/lib/engine/util/log\');\n';
+//         str += 'Log.level = \'debug\';\n'
+//         str += '\n';
+//         str += '(async () => {\n';
+//         str += '  (await app.daemon()).cli();\n';
+//         str += '})()'
+//         const filePath = path.resolve(dirs.build_bin, 'cli.js')
+//         fs.writeFileSync(filePath, str);
+//     }
+// }

package/lib/compiler/apps/distributed/stages/7_dump_package_json_stage.js

@@ -0,0 +1,45 @@
+"use strict";
+// import * as fs from 'fs';
+// import * as path from 'path';
+// import { Log } from '~/engine/util/log';
+// import { MonolythCompiler } from '../monolyth_compiler';
+// import { Space } from '~/engine/space';
+// import { MonolythApp } from '~/engine/apps/monolyth/monolyth.app';
+// /**
+//  * [Monolyth Compiler Stage #7]
+//  * Dump the package.json file to build folder.
+//  * 
+//  * @category Monolyth Compiler
+//  * @subcategory Stages
+//  */
+// export class DumpPackageJsonStage {
+//     public constructor(
+//         private monolyth: MonolythCompiler,
+//         private app: MonolythApp<any, any>
+//     ) {}
+//     public async run() {
+//         Log.info('compiler', 'monolyth', 'Dumping package.json to build folder...')
+//         const { config, compiler, dirs } = this.monolyth;
+//         const packageJsonPath = config.nesoiPath
+//             ? path.join(config.nesoiPath, 'package.json')
+//             : path.join('..', '..', '..', '..', '..', 'package.json');
+//         const nesoiPackageJson = await import(packageJsonPath);
+//         const spacePackageJson = await import(Space.path(compiler.space,'package.json'));
+//         const filePath = path.resolve(dirs.build, 'package.json');
+//         const scripts: Record<string, string> = {
+//             cli: 'node bin/cli.js'
+//         };
+//         Object.entries(config.scripts || {}).forEach(([name, path]) => {
+//             const jspath = path.replace(/\.ts/,'.js');
+//             scripts[name] = `node ${jspath}`;
+//         });
+//         const dependencies = {
+//             ...spacePackageJson.dependencies,
+//             nesoi: config.nesoiPath
+//                 ? `file:${config.nesoiPath}`
+//                 : nesoiPackageJson.version
+//         }
+//         const packageJson = MonolythApp.package(this.app, scripts, dependencies);
+//         fs.writeFileSync(filePath, JSON.stringify(packageJson, undefined, 2))
+//     }
+// }

package/lib/compiler/elements/element.js

@@ -93,9 +93,9 @@ class Element {
             return msgName.type;
         });
         const objs = schema.output?.obj?.map(bucket => {
-            const schema = compiler.tree.getSchema(bucket);
+            const schema = compiler.tree.getSchema(bucket.dep);
             const bucketName = name_helpers_1.NameHelpers.names(schema);
-            return bucketName.high;
+            return bucketName.high + (bucket.many ? '[]' : '');
         });
         const type = [
             raw,

package/lib/compiler/index.d.ts

@@ -1,2 +1,3 @@
 export { Compiler } from './compiler';
 export { MonolythCompiler } from './apps/monolyth/monolyth_compiler';
+export { DistributedCompiler } from './apps/distributed/distributed_compiler';

package/lib/compiler/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonolythCompiler = exports.Compiler = void 0;
+exports.DistributedCompiler = exports.MonolythCompiler = exports.Compiler = void 0;
 var compiler_1 = require("./compiler");
 Object.defineProperty(exports, "Compiler", { enumerable: true, get: function () { return compiler_1.Compiler; } });
 var monolyth_compiler_1 = require("./apps/monolyth/monolyth_compiler");
 Object.defineProperty(exports, "MonolythCompiler", { enumerable: true, get: function () { return monolyth_compiler_1.MonolythCompiler; } });
+var distributed_compiler_1 = require("./apps/distributed/distributed_compiler");
+Object.defineProperty(exports, "DistributedCompiler", { enumerable: true, get: function () { return distributed_compiler_1.DistributedCompiler; } });

package/lib/elements/blocks/block.builder.d.ts

@@ -30,4 +30,5 @@ export declare abstract class BlockBuilder<Space extends $Space, Module extends
     protected outputRaw(): unknown;
     protected outputMsg(...msgs: string[]): unknown;
     protected outputObj(...objs: string[]): unknown;
+    protected outputObjs(...objs: string[]): unknown;
 }

package/lib/elements/blocks/block.builder.js

@@ -79,7 +79,22 @@ class BlockBuilder {
         this._output ?? (this._output = {});
         (_a = this._output).obj ?? (_a.obj = []);
         objs.forEach(obj => {
-            this._output?.obj?.push(new dependency_1.$Dependency(this.module, 'bucket', obj, true));
+            this._output?.obj?.push({
+                dep: new dependency_1.$Dependency(this.module, 'bucket', obj, true),
+                many: false
+            });
+        });
+        return this;
+    }
+    outputObjs(...objs) {
+        var _a;
+        this._output ?? (this._output = {});
+        (_a = this._output).obj ?? (_a.obj = []);
+        objs.forEach(obj => {
+            this._output?.obj?.push({
+                dep: new dependency_1.$Dependency(this.module, 'bucket', obj, true),
+                many: true
+            });
         });
         return this;
     }

package/lib/elements/blocks/block.schema.d.ts

@@ -6,7 +6,10 @@ export type $BlockType = 'job' | 'resource' | 'machine' | 'queue' | 'topic';
 export type $BlockOutput = {
     raw?: TypeAsObj;
     msg?: $Dependency[];
-    obj?: $Dependency[];
+    obj?: {
+        dep: $Dependency;
+        many: boolean;
+    }[];
 };
 /**
  * @category Schemas

package/lib/elements/blocks/job/internal/resource_job.js

@@ -30,7 +30,7 @@ class ResourceJob {
             obj = await scope.execMethod({ ...$, obj, bucket: scope.bucket });
         }
         if (scope.afterMethod) {
-            obj = await scope.afterMethod({ ...$, obj, bucket: scope.bucket });
+            await scope.afterMethod({ ...$, obj, bucket: scope.bucket });
         }
         return obj;
     }

package/lib/elements/blocks/job/job.builder.d.ts

@@ -51,6 +51,7 @@ export declare class JobBuilder<Space extends $Space, Module extends $Module, Jo
         obj: <BucketName extends keyof Module["buckets"], Bucket extends NoInfer<Module["buckets"][BucketName]>>(...objs: BucketName[]) => JobBuilder<Space, Module, Overlay<Job, {
             "#output": unknown extends Job["#output"] ? Bucket["#data"] : (Job["#output"] | Bucket["#data"]);
         }>, Ctx>;
+        objs: (...objs: string[]) => unknown;
     };
     protected outputRaw<T>(): JobBuilder<Space, Module, Overlay<Job, {
         "#output": unknown extends Job["#output"] ? T : (Job["#output"] | T);

package/lib/elements/blocks/job/job.builder.js

@@ -41,7 +41,8 @@ class JobBuilder extends block_builder_1.BlockBuilder {
         return {
             raw: this.outputRaw.bind(this),
             msg: this.outputMsg.bind(this),
-            obj: this.outputObj.bind(this)
+            obj: this.outputObj.bind(this),
+            objs: this.outputObjs.bind(this)
         };
     }
     outputRaw() {

package/lib/elements/blocks/resource/resource.builder.js

@@ -63,7 +63,7 @@ class ResourceBuilder extends block_builder_1.BlockBuilder {
         const jobBuilder = new resource_job_builder_1.ResourceJobBuilder(this.module, name, this._bucket.refName, 'query', alias, resource_1.Resource.query, this._authn)
             .input($ => ({
             view: $.enum(views).default(views[0]),
-            query: $.dict($.any).default({}),
+            query: $.dict($.any.optional).default({}),
             page: $.int.default(0),
             perPage: $.int.default(10)
         }))

package/lib/elements/blocks/resource/resource.js

@@ -120,6 +120,7 @@ class Resource extends block_1.Block {
                 if (type === 'query is empty') {
                     out = !(await trx.bucket(bucket.refName)
                         .query(arg)
+                        .params(obj)
                         .first());
                 }
                 else if (type === 'has no link') {

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

@@ -136,10 +136,10 @@ export declare abstract class BucketAdapter<Obj extends NesoiObj> {
     /**
      * Return the results of a query
      */
-    query<MetadataOnly extends boolean>(trx: AnyTrxNode, query: NQL_AnyQuery, pagination?: NQL_Pagination, params?: Record<string, any>, config?: {
+    query<MetadataOnly extends boolean>(trx: AnyTrxNode, query: NQL_AnyQuery, pagination?: NQL_Pagination, params?: Record<string, any>[], config?: {
         view?: string;
         metadataOnly?: MetadataOnly;
-    }): Promise<NQL_Result<MetadataOnly extends true ? {
+    }, runner?: NQLRunner): Promise<NQL_Result<MetadataOnly extends true ? {
         id: Obj['id'];
         [x: string]: any;
     } : Obj>>;

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

@@ -25,14 +25,14 @@ class BucketAdapter {
     /**
      * Return the results of a query
      */
-    async query(trx, query, pagination, params, config) {
+    async query(trx, query, pagination, params, config, runner) {
         const module = trx_node_1.TrxNode.getModule(trx);
         const refName = (module.name === this.schema.module
             ? '' : `${this.schema.module}::`)
             + this.schema.name;
         const compiled = await nql_compiler_1.NQL_Compiler.build(module, refName, query);
         const view = config?.view ? this.schema.views[config.view] : undefined;
-        const result = await module.nql.run(trx, compiled, pagination, params, view);
+        const result = await module.nql.run(trx, compiled, pagination, params, view, runner);
         if (config?.metadataOnly) {
             result.data = result.data.map(obj => ({
                 id: obj.id,

package/lib/elements/entities/bucket/adapters/memory.nql.d.ts

@@ -10,7 +10,7 @@ export declare class MemoryNQLRunner extends NQLRunner {
     protected adapter?: AnyMemoryBucketAdapter;
     constructor();
     bind(adapter: AnyMemoryBucketAdapter): void;
-    run(trx: AnyTrxNode, part: NQL_Part, params: Obj, pagination?: NQL_Pagination): Promise<{
+    run(trx: AnyTrxNode, part: NQL_Part, params: Obj[], pagination?: NQL_Pagination): Promise<{
         data: any[];
         totalItems: number | undefined;
         page: number | undefined;

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

@@ -21,7 +21,7 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
         let response;
         // Empty query, don't filter data
         if (part.union.inters.length === 0) {
-            response = data;
+            response = { ...data };
         }
         // Non-empty query
         else {
@@ -105,7 +105,7 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
             for (const rule of inter.rules) {
                 // <Union>
                 if ('inters' in rule) {
-                    if (!_union(rule, objs, objs))
+                    if (!_union(rule, objs, params))
                         return false;
                 }
                 // <Rule>
@@ -132,8 +132,12 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
                     continue;
                 }
                 const obj = objs[id];
-                let match = _obj(rule, obj, params);
-                // console.log(`    -> match: ${match}\n`)
+                let match = false;
+                for (const paramGroup of params) {
+                    match = _obj(rule, obj, paramGroup);
+                    if (match)
+                        break;
+                }
                 if (rule.not) {
                     match = !match;
                 }
@@ -174,7 +178,7 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
             let queryValue;
             // Value is a subquery, run union
             if ('subquery' in rule.value) {
-                const subOut = _union(rule.value.subquery.union, objs, params);
+                const subOut = _union(rule.value.subquery.union, objs, [params]);
                 const subList = Object.values(subOut);
                 // Subquery operator is for a list, filter
                 if (rule.op === 'in' || rule.op === 'contains_any') {

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

@@ -85,7 +85,7 @@ export declare class Bucket<M extends $Module, $ extends $Bucket> {
         no_tenancy: boolean;
     }): Promise<Obj[]>;
     /**
-     * Read raw entity of a graph link
+     * Read raw entity of a graph link for 1 object
      *
      * - Options:
      *   - `silent`: If not found, return `undefined` instead of throwing an exception
@@ -95,6 +95,17 @@ export declare class Bucket<M extends $Module, $ extends $Bucket> {
         silent?: boolean;
         no_tenancy?: boolean;
     }): Promise<Link['#many'] extends true ? Obj[] : (Obj | undefined)>;
+    /**
+     * Read raw entities of a graph link for N objects
+     *
+     * - Options:
+     *   - `silent`: If not found, return `undefined` instead of throwing an exception
+     *   - `no_tenancy`: Don't apply tenancy rules.
+     */
+    readManyLinks<LinkName extends keyof $['graph']['links'], Link extends $['graph']['links'][LinkName], LinkBucket extends Link['#bucket'], V extends ViewName<LinkBucket>, Obj extends ViewObj<LinkBucket, V>>(trx: AnyTrxNode, ids: $['#data']['id'][], link: LinkName, options?: {
+        silent?: boolean;
+        no_tenancy?: boolean;
+    }): Promise<Link['#many'] extends true ? Obj[] : (Obj | undefined)>;
     /**
      * Read the view of an entity of a graph link
      *
@@ -190,7 +201,7 @@ export declare class Bucket<M extends $Module, $ extends $Bucket> {
      */
     query<V extends ViewName<$>, Obj extends ViewObj<$, V>>(trx: AnyTrxNode, query: NQL_AnyQuery, pagination?: NQL_Pagination, view?: V, options?: {
         no_tenancy?: boolean;
-        params?: Record<string, any>;
+        params?: Record<string, any>[];
     }): Promise<NQL_Result<Obj>>;
     /**
      * Add `created_by`, `created_at`, `updated_by` and `updated_at` fields to object

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

@@ -120,7 +120,7 @@ class Bucket {
         let raws;
         // With Tenancy
         if (tenancy) {
-            const result = await this.adapter.query(trx, tenancy, undefined, options?.query_view ? { view: options?.query_view } : undefined);
+            const result = await this.adapter.query(trx, tenancy, undefined, options?.query_view ? [{ view: options?.query_view }] : undefined);
             raws = result.data;
         }
         // Without Tenancy
@@ -169,7 +169,7 @@ class Bucket {
     }
     // Graph
     /**
-     * Read raw entity of a graph link
+     * Read raw entity of a graph link for 1 object
      *
      * - Options:
      *   - `silent`: If not found, return `undefined` instead of throwing an exception
@@ -201,6 +201,44 @@ class Bucket {
         }
         return linkObj;
     }
+    /**
+     * Read raw entities of a graph link for N objects
+     *
+     * - Options:
+     *   - `silent`: If not found, return `undefined` instead of throwing an exception
+     *   - `no_tenancy`: Don't apply tenancy rules.
+     */
+    async readManyLinks(trx, ids, link, options) {
+        log_1.Log.debug('bucket', this.schema.name, `Read Link, ids=${ids} l=${link}`);
+        // Validate IDs
+        for (const id of ids) {
+            if (typeof id !== 'string' && typeof id !== 'number') {
+                throw error_1.NesoiError.Bucket.InvalidId({ bucket: this.schema.alias, id });
+            }
+        }
+        // Read object
+        const objs = await this.query(trx, {
+            'id in': ids
+        }).then(res => res.data);
+        // Empty response
+        if (!objs.length) {
+            const schema = this.schema.graph.links[link];
+            if (schema.many) {
+                return [];
+            }
+            return undefined;
+        }
+        // Read link
+        const linkObj = await this.graph.readManyLinks(trx, objs, link, options);
+        // TODO
+        // // Encryption
+        // if (linkObj) {
+        //     if (this.schema.model.hasEncryptedField) {
+        //         await this.decrypt(trx, linkObj);
+        //     }
+        // }
+        return linkObj;
+    }
     /**
      * Read the view of an entity of a graph link
      *
@@ -455,7 +493,7 @@ class Bucket {
         var _a, _b;
         log_1.Log.debug('bucket', this.schema.name, `Put id=${obj['id']}`, obj);
         // Separate composition
-        const composition = obj['#composition'] || {};
+        let composition = obj['#composition'];
         delete obj['#composition'];
         // Add meta (created_by/created_at/updated_by/updated_at)
         this.addMeta(trx, obj, 'create');
@@ -470,6 +508,12 @@ class Bucket {
         // Put
         const _obj = await this.adapter.put(trx, obj);
         // Composition
+        if (composition) {
+            this.replaceFutureId(composition, _obj.id);
+        }
+        else {
+            composition = {};
+        }
         for (const link of Object.values(this.schema.graph.links)) {
             if (link.rel !== 'composition')
                 continue;

package/lib/elements/entities/bucket/graph/bucket_graph.d.ts

@@ -22,6 +22,17 @@ export declare class BucketGraph<M extends $Module, $ extends $Bucket> {
         silent?: boolean;
         no_tenancy?: boolean;
     }): Promise<Obj | Obj[] | undefined>;
+    /**
+     * Read the data from a link
+     *
+     * - Options
+     *   - `silent`: If not found, returns undefined instead of raising an exception (default: `false`)
+     *   - `no_tenancy`: Don't apply tenancy rules (default: `false`)
+     */
+    readManyLinks<LinkName extends keyof $['graph']['links'], LinkBucketName extends $['graph']['links'][LinkName]['bucket']['refName'], LinkBucket extends M['buckets'][LinkBucketName], Obj = LinkBucket['#data']>(trx: AnyTrxNode, objs: $['#data'][], link: LinkName, options?: {
+        silent?: boolean;
+        no_tenancy?: boolean;
+    }): Promise<Obj[] | Obj[][]>;
     /**
      * Read the data from a link and build it with a given view
      *