nesoi 3.0.21 → 3.1.1

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

@@ -3,9 +3,10 @@ import { $Queue } from './queue.schema';
 import { ResolvedBuilderNode } from "../../../engine/dependency";
 import { BlockBuilder } from '../block.builder';
 import { Overlay } from "../../../engine/util/type";
-import { MultiMessageTemplateDef } from "../../entities/message/template/message_template.builder";
+import { MessageTemplateDef } from "../../entities/message/template/message_template.builder";
 import { $MessageInfer } from "../../entities/message/message.infer";
 import { ModuleTree } from "../../../engine/tree";
+import { $Message } from "../../entities/message/message.schema";
 /**
  * @category Builders
  * @subcategory Block
@@ -16,25 +17,15 @@ export declare class QueueBuilder<Space extends $Space, M extends $Module, $ ext
     authn<U extends keyof Space['authnUsers']>(...providers: U[]): QueueBuilder<Space, M, $ & {
         "#authn": U extends any[] ? U[number] : U;
     }>;
-    messages<Def extends MultiMessageTemplateDef<Space, M>>(def: Def): QueueBuilder<Space, Overlay<M, {
-        messages: Overlay<M["messages"], { [K in keyof ReturnType<Def> as `${string}${K extends "" ? "" : "."}${K & string}`]: $MessageInfer<`${string}${K extends "" ? "" : "."}${K & string}`, ($: any) => ReturnType<Def>[K], ReturnType<Def>[K], import("../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def>[K], ReturnType<Def>[K] extends infer T ? { [K_1 in keyof T]: ReturnType<Def>[K][K_1] extends import("../../entities/message/template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt extends [undefined, undefined], infer Nul extends [null, null]> ? {
-            path: `${K_1 & string}${keyof I & string}`;
-            data: I[keyof I];
-            opt: Opt[0];
-            nul: Nul[0];
-        } : never; } : never>, import("../../entities/message/message.infer").$MessageOutputInfer<ReturnType<Def>[K], ReturnType<Def>[K] extends infer T_1 ? { [K_2 in keyof T_1]: ReturnType<Def>[K][K_2] extends import("../../entities/message/template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
-            path: `${K_2 & string}${keyof O & string}`;
-            data: O[keyof O];
-            opt: Opt_1[1];
-            nul: Nul_1[1];
-        } : never; } : never>>; }>;
+    message<Name extends string, Def extends MessageTemplateDef<Space, M, Name>, FullName extends string = `${$['name']}${Name extends '' ? '' : '.'}${Name & string}`, Msg extends $Message = $MessageInfer<FullName, ($: any) => ReturnType<Def>>>(name: Name, def: Def): QueueBuilder<Space, Overlay<M, {
+        messages: Overlay<M["messages"], { [K in FullName]: Msg; }>;
     }>, $>;
     input<MsgName extends ScopedMessageName<M, $['name']>, Msg extends ScopedMessage<M, $['name'], MsgName>>(...def: MsgName[]): QueueBuilder<Space, M, Overlay<$, {
-        "#input": Msg;
+        "#input": $["#input"] | Msg;
     }>>;
     static build(node: QueueBuilderNode, tree: ModuleTree, module: $Module): {
         schema: $Queue;
-        inlineMessages: Record<string, import("../..").$Message>;
+        inlineMessages: Record<string, $Message>;
     };
 }
 export type AnyQueueBuilder = QueueBuilder<any, any, any>;

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

@@ -17,8 +17,8 @@ class QueueBuilder extends block_builder_1.BlockBuilder {
     authn(...providers) {
         return super.authn(...providers);
     }
-    messages(def) {
-        return super.messages(def);
+    message(name, def) {
+        return super.message(name, def);
     }
     input(...def) {
         return super._input(...def);

package/lib/elements/edge/externals/externals.builder.d.ts

@@ -17,10 +17,12 @@ export declare class ExternalsBuilder<Space extends $Space, ModuleName extends k
     $b: "externals";
     name: string;
     private buckets;
+    private messages;
     private jobs;
     private machines;
     constructor(module: string);
     bucket<M extends keyof Space['modules'], B extends ExternalBucketRefName<Space, ModuleName>>(ref: B): this;
+    message<M extends Exclude<keyof Space['modules'], ModuleName>, B extends keyof Space['modules'][M]['messages']>(ref: `${M & string}::${B & string}`): this;
     job<M extends Exclude<keyof Space['modules'], ModuleName>, B extends keyof Space['modules'][M]['jobs']>(ref: `${M & string}::${B & string}`): this;
     machine<M extends Exclude<keyof Space['modules'], ModuleName>, B extends keyof Space['modules'][M]['machines']>(ref: `${M & string}::${B & string}`): this;
     static merge(to: AnyExternalsBuilder, from: AnyExternalsBuilder): void;

package/lib/elements/edge/externals/externals.builder.js

@@ -13,6 +13,7 @@ class ExternalsBuilder {
         this.$b = 'externals';
         this.name = '*';
         this.buckets = {};
+        this.messages = {};
         this.jobs = {};
         this.machines = {};
     }
@@ -20,6 +21,10 @@ class ExternalsBuilder {
         this.buckets[ref] = new dependency_1.$Dependency(this.module, 'bucket', ref);
         return this;
     }
+    message(ref) {
+        this.messages[ref] = new dependency_1.$Dependency(this.module, 'message', ref);
+        return this;
+    }
     job(ref) {
         this.jobs[ref] = new dependency_1.$Dependency(this.module, 'job', ref);
         return this;
@@ -34,7 +39,7 @@ class ExternalsBuilder {
     }
     // Build
     static build(node) {
-        node.schema = new externals_schema_1.$Externals(node.module, node.builder.buckets, node.builder.jobs, node.builder.machines);
+        node.schema = new externals_schema_1.$Externals(node.module, node.builder.buckets, node.builder.messages, node.builder.jobs, node.builder.machines);
         return node.schema;
     }
 }

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

@@ -6,10 +6,11 @@ import { $Dependency } from "../../../engine/dependency";
 export declare class $Externals {
     name: string;
     buckets: Record<string, $Dependency>;
+    messages: Record<string, $Dependency>;
     jobs: Record<string, $Dependency>;
     machines: Record<string, $Dependency>;
     $t: "externals";
     module: string;
-    constructor(name: string, buckets?: Record<string, $Dependency>, jobs?: Record<string, $Dependency>, machines?: Record<string, $Dependency>);
+    constructor(name: string, buckets?: Record<string, $Dependency>, messages?: Record<string, $Dependency>, jobs?: Record<string, $Dependency>, machines?: Record<string, $Dependency>);
     static merge(to: $Externals, from: $Externals): void;
 }

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

@@ -6,9 +6,10 @@ exports.$Externals = void 0;
  * @subcategory Edge
  */
 class $Externals {
-    constructor(name, buckets = {}, jobs = {}, machines = {}) {
+    constructor(name, buckets = {}, messages = {}, jobs = {}, machines = {}) {
         this.name = name;
         this.buckets = buckets;
+        this.messages = messages;
         this.jobs = jobs;
         this.machines = machines;
         this.$t = 'externals';
@@ -16,6 +17,7 @@ class $Externals {
     }
     static merge(to, from) {
         Object.assign(to.buckets, from.buckets);
+        Object.assign(to.messages, from.messages);
         Object.assign(to.jobs, from.jobs);
         Object.assign(to.machines, from.machines);
     }

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

@@ -141,7 +141,7 @@ export declare abstract class BucketAdapter<Obj extends NesoiObj> {
     }): Promise<NQL_Result<MetadataOnly extends true ? {
         id: Obj['id'];
         [x: string]: any;
-    }[] : Obj[]>>;
+    } : Obj>>;
     /**
      * Return the epoch of the last update of an object
      * @param {Obj} obj An object of this bucket

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

@@ -6,6 +6,13 @@ import { BucketCacheSync } from '../cache/bucket_cache';
 /**
  * @category Adapters
  * @subcategory Entity
+ *
+ * > Every method that alters data makes a `Deep.copy` of the input
+ * > before processing it, to avoid side-effects to the input data
+ * > by modifying the external data on the adapter.
+ * > It also makes a `Deep.copy` of the data before outputting it,
+ * > to avoid side-effects on the adapter data by modifying the returned
+ * > object externally.
  * */
 export declare class MemoryBucketAdapter<B extends $Bucket, Obj extends B['#data']> extends BucketAdapter<Obj> {
     schema: B;

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

@@ -4,9 +4,17 @@ exports.MemoryBucketAdapter = void 0;
 const bucket_adapter_1 = require("./bucket_adapter");
 const crypto_1 = require("crypto");
 const memory_nql_1 = require("./memory.nql");
+const bucket_model_schema_1 = require("../model/bucket_model.schema");
 /**
  * @category Adapters
  * @subcategory Entity
+ *
+ * > Every method that alters data makes a `Deep.copy` of the input
+ * > before processing it, to avoid side-effects to the input data
+ * > by modifying the external data on the adapter.
+ * > It also makes a `Deep.copy` of the data before outputting it,
+ * > to avoid side-effects on the adapter data by modifying the returned
+ * > object externally.
  * */
 class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
     constructor(schema, data = {}, config) {
@@ -37,12 +45,14 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
     }
     /* Write Operations */
     async create(trx, obj) {
+        const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
         const lastId = (await this.index(trx))
-            .map((obj) => parseInt(obj.id))
+            .map((_obj) => parseInt(_obj.id))
             .sort((a, b) => b - a)[0] || 0;
-        obj.id = lastId + 1;
-        this.data[obj.id] = obj;
-        return Promise.resolve(obj);
+        input.id = lastId + 1;
+        this.data[input.id] = input;
+        const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, input, this.config.meta);
+        return Promise.resolve(output);
     }
     async createMany(trx, objs) {
         const out = [];
@@ -55,17 +65,16 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
         if (!obj.id || !this.data[obj.id]) {
             throw new Error(`Object with id ${obj.id} not found for replace`);
         }
-        this.data[obj.id] = obj;
-        return Promise.resolve(obj);
+        const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+        this.data[input.id] = input;
+        const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, input, this.config.meta);
+        return Promise.resolve(output);
     }
-    replaceMany(trx, objs) {
+    async replaceMany(trx, objs) {
         const out = [];
         for (const obj of objs) {
-            if (!obj.id || !this.data[obj.id]) {
-                throw new Error(`Object with id ${obj.id} not found for replace`);
-            }
-            this.data[obj.id] = obj;
-            out.push(obj);
+            const output = await this.replace(trx, obj);
+            out.push(output);
         }
         return Promise.resolve(out);
     }
@@ -73,39 +82,38 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
         if (!obj.id || !this.data[obj.id]) {
             throw new Error(`Object with id ${obj.id} not found for patch`);
         }
-        const _input = this.data[obj.id];
-        const _obj = obj;
-        for (const key in _obj) {
-            if (_obj[key] === null) {
-                delete _input[key];
+        const data = this.data[obj.id];
+        const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+        for (const key in input) {
+            if (input[key] === null) {
+                delete data[key];
             }
-            else if (_obj[key] !== undefined) {
-                _input[key] = _obj[key];
+            else if (input[key] !== undefined) {
+                data[key] = input[key];
             }
         }
-        return Promise.resolve(_input);
+        const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, data, this.config.meta);
+        return Promise.resolve(output);
     }
-    patchMany(trx, objs) {
+    async patchMany(trx, objs) {
         const out = [];
         for (const obj of objs) {
-            if (!obj.id || !this.data[obj.id]) {
-                throw new Error(`Object with id ${obj.id} not found for patch`);
-            }
-            // TODO: Implement patch
-            this.data[obj.id] = obj;
-            out.push(obj);
+            const output = await this.patch(trx, obj);
+            out.push(output);
         }
         return Promise.resolve(out);
     }
     async put(trx, obj) {
-        if (!obj.id) {
+        const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+        if (!input.id) {
             const lastId = (await this.index(trx))
-                .map((obj) => parseInt(obj.id))
+                .map((_obj) => parseInt(_obj.id))
                 .sort((a, b) => b - a)[0] || 0;
-            obj.id = lastId + 1;
+            input.id = lastId + 1;
         }
-        this.data[obj.id] = obj;
-        return Promise.resolve(obj);
+        this.data[input.id] = input;
+        const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, input, this.config.meta);
+        return Promise.resolve(output);
     }
     async putMany(trx, objs) {
         const lastId = (await this.index(trx))
@@ -114,11 +122,13 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
         let id = lastId + 1;
         const out = [];
         for (const obj of objs) {
-            if (!obj.id) {
-                obj.id = id;
+            const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+            if (!input.id) {
+                input.id = id;
             }
-            this.data[obj.id] = obj;
-            out.push(obj);
+            this.data[input.id] = input;
+            const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, input, this.config.meta);
+            out.push(output);
             id++;
         }
         return Promise.resolve(out);

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

@@ -66,7 +66,7 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
             if (pagination.returnTotal) {
                 totalItems = output.length;
             }
-            if (pagination.page || pagination.perPage) {
+            if (pagination.page !== undefined || pagination.perPage !== undefined) {
                 const a = ((pagination.page || 1) - 1) * (pagination.perPage || 10);
                 const b = a + (pagination.perPage || 10);
                 output = output.slice(a, b);

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

@@ -10,7 +10,7 @@ import { $BucketGraphLinksInfer } from './graph/bucket_graph.infer';
 import { $BucketGraph } from './graph/bucket_graph.schema';
 import { $Dependency, ResolvedBuilderNode } from "../../../engine/dependency";
 import { ModuleTree } from "../../../engine/tree";
-import { BucketFieldpathInfer, BucketModelInfer } from './model/bucket_model.infer';
+import { BucketModelpathInfer, BucketModelInfer, BucketQuerypathInfer } from './model/bucket_model.infer';
 import { Overlay } from "../../../engine/util/type";
 import { $Constants } from '../constants/constants.schema';
 import { NesoiObj } from "../../../engine/data/obj";
@@ -33,14 +33,16 @@ export declare class BucketBuilder<Space extends $Space, Module extends $Module,
     constructor(module: string, name: string);
     as(alias: string): this;
     extend<N extends Exclude<BucketName<Module>, Bucket['name']>>(name: N): BucketBuilder<Space, Module, Module["buckets"][N]>;
-    model<Def extends BucketModelDef<Space, Module>, Obj = BucketModelInfer<Def>, Fieldpath extends {} = BucketFieldpathInfer<Def>>($: Def): BucketBuilder<Space, Overlay<Module, {
+    model<Def extends BucketModelDef<Space, Module>, Obj = BucketModelInfer<Def>, Modelpath extends {} = BucketModelpathInfer<Def>, Querypath extends {} = BucketQuerypathInfer<Def>>($: Def): BucketBuilder<Space, Overlay<Module, {
         buckets: Overlay<Module["buckets"], { [K in Bucket["name"]]: Overlay<Bucket, {
             '#data': Obj & NesoiObj;
-            '#fieldpath': Fieldpath;
+            '#modelpath': Modelpath;
+            '#querypath': Querypath;
         }>; }>;
     }>, Overlay<Bucket, {
         '#data': Obj & NesoiObj;
-        '#fieldpath': Fieldpath;
+        '#modelpath': Modelpath;
+        '#querypath': Querypath;
     }>>;
     /**
      * Optional query to be appended to every read of this bucket, based on the user

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

@@ -425,11 +425,13 @@ class Bucket {
                 continue;
             const linkObj = composition[link.name];
             if (!linkObj) {
-                throw error_1.NesoiError.Bucket.MissingComposition({ method: 'patch', bucket: this.schema.name, link: link.name });
+                if (mode === 'patch')
+                    continue;
+                throw error_1.NesoiError.Bucket.MissingComposition({ method: 'replace', bucket: this.schema.name, link: link.name });
             }
             if (link.many) {
                 if (!Array.isArray(linkObj)) {
-                    throw error_1.NesoiError.Bucket.CompositionValueShouldBeArray({ method: 'patch', bucket: this.schema.name, link: link.name });
+                    throw error_1.NesoiError.Bucket.CompositionValueShouldBeArray({ method: 'replace', bucket: this.schema.name, link: link.name });
                 }
                 for (const linkObjItem of linkObj) {
                     await trx.bucket(link.bucket.refName)[mode](linkObjItem);
@@ -525,20 +527,44 @@ class Bucket {
             }
         }
         // Delete compositions (with other key)
+        // Currently there's only 'self' key
+        //
+        // for(const link of Object.values(this.schema.graph.links)) {
+        //     if (link.rel !== 'composition') continue;
+        //     if (link.keyOwner !== 'other') continue;
+        //     const linked = await this.graph.readLink(trx, id, link.name, {
+        //         silent: true
+        //     }) as any;
+        //     if (!linked) continue;
+        //     if (link.many) {
+        //         for (const linkedItem of linked) {
+        //             await trx.bucket(link.bucket.refName).delete(linkedItem.id);
+        //         }
+        //     }
+        //     else {
+        //         await trx.bucket(link.bucket.refName).delete(linked.id);
+        //     }
+        // }
+        // Composition (with self key)
         for (const link of Object.values(this.schema.graph.links)) {
             if (link.rel !== 'composition')
                 continue;
-            if (link.keyOwner !== 'other')
+            if (link.keyOwner !== 'self')
                 continue;
-            const linked = await this.readLink(trx, id, link.name, {
-                silent: true
-            });
+            const linked = result
+                // If safe, avoid reading the object again inside readLink.
+                // Instead, use graph's readLink which takes the object.
+                ? await this.graph.readLink(trx, result.data[0], link.name, {
+                    silent: true
+                })
+                // If unsafe, read the link base by id.
+                : await this.readLink(trx, id, link.name, {
+                    silent: true
+                });
             if (!linked)
                 continue;
             if (link.many) {
-                for (const linkedItem of linked) {
-                    await trx.bucket(link.bucket.refName).delete(linkedItem.id);
-                }
+                await trx.bucket(link.bucket.refName).unsafe.deleteMany(linked.map((l) => l.id));
             }
             else {
                 await trx.bucket(link.bucket.refName).delete(linked.id);
@@ -550,24 +576,6 @@ class Bucket {
             await trash_1.Trash.add(trx, this.module, this.schema.name, obj);
         }
         await this.adapter.delete(trx, id);
-        // Composition (with self key)
-        for (const link of Object.values(this.schema.graph.links)) {
-            if (link.rel !== 'composition')
-                continue;
-            if (link.keyOwner !== 'self')
-                continue;
-            const linked = await this.readLink(trx, id, link.name, {
-                silent: true
-            });
-            if (!linked)
-                continue;
-            if (link.many) {
-                await trx.bucket(link.bucket.refName).unsafe.deleteMany(linked.map((l) => l.id));
-            }
-            else {
-                await trx.bucket(link.bucket.refName).delete(linked.id);
-            }
-        }
     }
     /**
      * Delete many entities
@@ -735,22 +743,13 @@ class Bucket {
         if (!this.drive) {
             throw error_1.NesoiError.Bucket.Drive.NoAdapter({ bucket: this.schema.alias });
         }
-        const fields = bucket_model_schema_1.$BucketModel.fieldsOfType(this.schema.model, 'file');
-        for (const field of fields) {
-            if (field.array) {
-                const files = tree_1.Tree.get(obj, field.path);
-                const remoteFiles = [];
-                for (const file of files) {
-                    remoteFiles.push(await this.drive.upload(file));
-                }
-                tree_1.Tree.set(obj, field.path, () => remoteFiles);
-            }
-            else {
-                const file = tree_1.Tree.get(obj, field.path);
-                const remoteFile = await this.drive.upload(file);
-                tree_1.Tree.set(obj, field.path, () => remoteFile);
-            }
-        }
+        await bucket_model_schema_1.$BucketModel.forEachField(this.schema.model, async (field) => {
+            if (field.type !== 'file')
+                return;
+            const file = tree_1.Tree.get(obj, field.path);
+            const remoteFile = await this.drive.upload(file);
+            tree_1.Tree.set(obj, field.path, () => remoteFile);
+        });
     }
 }
 exports.Bucket = Bucket;

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

@@ -28,7 +28,8 @@ export declare class $Bucket {
         many: boolean;
         optional: boolean;
     }>;
-    '#fieldpath': {};
+    '#modelpath': {};
+    '#querypath': {};
     '#defaults': Record<string, any>;
     constructor(module: string, name: string, alias: string, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, tenancy?: $BucketTenancy<any, any> | undefined, extended?: $Dependency | undefined);
 }

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

@@ -35,10 +35,7 @@ export declare class BucketCache<Obj extends NesoiObj> {
     constructor(bucketName: string, outerAdapter: AnyBucketAdapter, config: NonNullable<BucketConfig<any, any, any>['cache']>);
     get(trx: AnyTrxNode, id: NesoiObj['id']): Promise<any>;
     index(trx: AnyTrxNode): Promise<any[]>;
-    query(trx: AnyTrxNode, view: $BucketView, query: NQL_AnyQuery, pagination?: NQL_Pagination): Promise<NQL_Result<any[] | {
-        [x: string]: any;
-        id: any;
-    }[]> | Obj[]>;
+    query(trx: AnyTrxNode, view: $BucketView, query: NQL_AnyQuery, pagination?: NQL_Pagination): Promise<NQL_Result<any> | Obj[]>;
     private syncOne;
     private syncOneAndPast;
     private syncAll;

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

@@ -1,9 +1,11 @@
 import { Overlay } from "../../../../engine/util/type";
 import { $BucketGraphLink } from './bucket_graph.schema';
-import { BucketGraphLinkBuilder, BucketGraphLinkBuilders } from './bucket_graph_link.builder';
+import { BucketGraphLinkBuilders } from './bucket_graph_link.builder';
+type Replace<T extends string> = T extends `${infer L}$${infer R}` ? `${L}${string}${Replace<R>}` : T;
 export type $BucketGraphLinksInfer<Builders extends BucketGraphLinkBuilders> = {
-    [K in keyof Builders]: Builders[K] extends BucketGraphLinkBuilder<any, any, infer Y> ? Overlay<$BucketGraphLink, {
-        '#bucket': Y;
-        '#data': Y['#data'];
-    }> : never;
+    [K in keyof Builders as Replace<K & string>]: Overlay<$BucketGraphLink, {
+        '#bucket': Builders[K]['#other'];
+        '#data': Builders[K]['#other']['#data'];
+    }>;
 };
+export {};

package/lib/elements/entities/bucket/graph/bucket_graph_link.builder.d.ts

@@ -8,7 +8,7 @@ import { NQL_AnyQuery, NQL_Query } from '../query/nql.schema';
  * @category Builders
  * @subcategory Entity
  * */
-export declare class BucketGraphLinkFactory<Module extends $Module, SelfBucket extends $Bucket, Fieldpaths = NoInfer<SelfBucket['#fieldpath']>> {
+export declare class BucketGraphLinkFactory<Module extends $Module, SelfBucket extends $Bucket, Fieldpaths = NoInfer<SelfBucket['#modelpath']>> {
     private module;
     private alias?;
     private type;
@@ -28,6 +28,7 @@ export declare class BucketGraphLinkBuilder<Module extends $Module, SelfBucket e
     private query;
     private many;
     private alias?;
+    '#other': OtherBucket;
     private _optional;
     constructor(bucket: $Dependency, rel: 'aggregation' | 'composition', query: NQL_AnyQuery, many: boolean, alias?: string | undefined);
     as(alias: string): this;

package/lib/elements/entities/bucket/model/bucket_model.builder.d.ts

@@ -13,5 +13,5 @@ export declare class BucketModelBuilder<Module extends $Module> {
     static build(builder: BucketModelBuilder<any>): $BucketModel;
 }
 export type BucketModelDef<Space extends $Space, Module extends $Module> = ($: BucketModelFieldFactory<Space, Module>) => {
-    id: BucketModelFieldBuilder<Module, any>;
+    id: BucketModelFieldBuilder<Module, any, any, any, any, any>;
 } & BucketModelFieldBuilders<Module>;

package/lib/elements/entities/bucket/model/bucket_model.convert.d.ts

@@ -5,7 +5,7 @@ import { $Message } from "../../message/message.schema";
  * @category Elements
  * @subcategory Entity
  * */
-export declare function convertToView<Model extends $BucketModel>(model: Model, name: string, fields?: $BucketModelFields, path?: string): $BucketView;
+export declare function convertToView<Model extends $BucketModel>(model: Model, name: string, fields?: $BucketModelFields, path?: string, depth?: number): $BucketView;
 /**
  * @category Elements
  * @subcategory Entity

package/lib/elements/entities/bucket/model/bucket_model.convert.js

@@ -13,7 +13,7 @@ const dependency_1 = require("../../../../engine/dependency");
  * @category Elements
  * @subcategory Entity
  * */
-function convertToView(model, name, fields = model.fields, path) {
+function convertToView(model, name, fields = model.fields, path, depth = 0) {
     const view = new bucket_view_builder_1.BucketViewBuilder(name);
     const convertFields = (fields) => {
         const viewFields = {};
@@ -24,7 +24,7 @@ function convertToView(model, name, fields = model.fields, path) {
                 + field.name;
             const builder = $.model(key);
             const graph = new bucket_graph_schema_1.$BucketGraph();
-            viewFields[f] = bucket_view_field_builder_1.BucketViewFieldBuilder.build(builder, model, graph, {}, field.name);
+            viewFields[f] = bucket_view_field_builder_1.BucketViewFieldBuilder.build(builder, model, graph, {}, field.name, depth);
         }
         return viewFields;
     };
@@ -36,12 +36,12 @@ function convertToView(model, name, fields = model.fields, path) {
  * */
 function convertToMessage(module, model, name, alias, include = [], exclude = []) {
     const convertField = (field) => {
-        return new message_template_schema_1.$MessageTemplateField(field.type, field.name, field.alias, field.alias, field.path, field.path, field.array, field.required, undefined, false, [], [], {
+        return new message_template_schema_1.$MessageTemplateField(field.type, field.name, field.alias, field.path, field.path, field.required, undefined, false, [], {
             enum: field.meta?.enum ? {
                 options: field.meta.enum.options,
                 dep: field.meta.enum.dep ? new dependency_1.$Dependency(module, 'constants', `${field.meta.enum.dep.module}::${field.meta.enum.dep.name}`) : undefined
             } : undefined
-        }, field.children ? convertFields(field.children, include, exclude) : undefined, field.or ? convertField(field.or) : undefined);
+        }, field.children ? convertFields(field.children, include, exclude) : undefined);
     };
     const convertFields = (fields, include = [], exclude = [], root = '') => {
         const msgFields = {};

package/lib/elements/entities/bucket/model/bucket_model.infer.d.ts

@@ -1,13 +1,45 @@
-import { MergeUnion } from "../../../../engine/util/type";
+import { UnionToIntersection } from "../../../../engine/util/type";
 import { BucketModelDef } from './bucket_model.builder';
-import { BucketModelFieldBuilder, BucketModelFieldBuilders } from './bucket_model_field.builder';
-export type BucketModelObjInfer<Builders extends BucketModelFieldBuilders<any>> = {
-    [K in keyof Builders]: Builders[K] extends BucketModelFieldBuilder<any, any, any, infer X> ? X : BucketModelObjInfer<Builders[K] & BucketModelFieldBuilders<any>>;
+import { AnyBucketModelFieldBuilder, BucketModelFieldBuilders } from './bucket_model_field.builder';
+export type BucketModelObjInfer<Fields extends BucketModelFieldBuilders<any>, Prefix = ''> = {
+    [K in keyof Fields as Fields[K]['#optional'][1] extends true ? never : `${Prefix & string}${K & string}`]: Fields[K]['#output'];
+} & {
+    [K in keyof Fields as Fields[K]['#optional'][1] extends true ? `${Prefix & string}${K & string}` : never]?: Fields[K]['#output'];
 };
 export type BucketModelInfer<Def extends BucketModelDef<any, any>> = BucketModelObjInfer<ReturnType<Def>>;
-export type BucketFieldpathObjInfer<Builders extends BucketModelFieldBuilders<any>, Prefix extends string> = MergeUnion<{
-    [K in keyof Builders]: Builders[K] extends BucketModelFieldBuilder<any, any, any, any, infer X> ? {
-        [J in keyof X as `${Prefix}${K & string}${J & string}`]: X[J];
-    } : never;
+type BucketModelpathRawInfer<Builders extends BucketModelFieldBuilders<any>> = UnionToIntersection<{
+    [K in keyof Builders]: {
+        [J in keyof Builders[K]['#modelpath'] as `${K & string}${J & string}`]: Builders[K]['#modelpath'][J];
+    };
 }[keyof Builders]>;
-export type BucketFieldpathInfer<Def extends BucketModelDef<any, any>, Prefix extends string = ''> = BucketFieldpathObjInfer<ReturnType<Def>, Prefix>;
+export type BucketModelpathObjInfer<Builders extends BucketModelFieldBuilders<any>> = UnionToIntersection<{
+    [K in keyof Builders]: {
+        [J in keyof Builders[K]['#modelpath'] as `.${K & string}${J & string}`]: Builders[K]['#modelpath'][J];
+    };
+}[keyof Builders]>;
+export type BucketModelpathListInfer<Builder extends AnyBucketModelFieldBuilder> = {
+    [J in keyof Builder['#modelpath'] as `.*${J & string}` | `.$${number}${J & string}` | `.${number}${J & string}`]: Builder['#modelpath'][J];
+};
+export type BucketModelpathDictInfer<Builder extends AnyBucketModelFieldBuilder> = {
+    [J in keyof Builder['#modelpath'] as `.*${J & string}` | `.$${number}${J & string}` | `.${string}${J & string}`]: Builder['#modelpath'][J];
+};
+export type BucketModelpathUnionInfer<Builders extends AnyBucketModelFieldBuilder[]> = Builders[0]['#modelpath'] | Builders[1]['#modelpath'];
+export type BucketModelpathInfer<Def extends BucketModelDef<any, any>> = BucketModelpathRawInfer<ReturnType<Def>>;
+type BucketQuerypathRawInfer<Builders extends BucketModelFieldBuilders<any>> = {
+    [K in keyof Builders]: {
+        [J in keyof Builders[K]['#querypath'] as `${K & string}${J & string}`]: Builders[K]['#querypath'][J];
+    };
+}[keyof Builders];
+export type BucketQuerypathObjInfer<Builders extends BucketModelFieldBuilders<any>> = UnionToIntersection<{
+    [K in keyof Builders]: {
+        [J in keyof Builders[K]['#querypath'] as `.${K & string}${J & string}`]: Builders[K]['#querypath'][J];
+    };
+}[keyof Builders]>;
+export type BucketQuerypathListInfer<Builder extends AnyBucketModelFieldBuilder> = {
+    [J in keyof Builder['#querypath'] as `.${number | '#' | '*'}${J & string}`]: Builder['#querypath'][J];
+};
+export type BucketQuerypathDictInfer<Builder extends AnyBucketModelFieldBuilder> = {
+    [J in keyof Builder['#querypath'] as `.${string | '#' | '*'}${J & string}`]: Builder['#querypath'][J];
+};
+export type BucketQuerypathInfer<Def extends BucketModelDef<any, any>> = UnionToIntersection<BucketQuerypathRawInfer<ReturnType<Def>>>;
+export {};