nesoi 3.3.5 → 3.3.6

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

@@ -22,7 +22,7 @@ class NQL_Engine {
             }
         }
     }
-    async run(trx, query, pagination, params = [{}], view, customRunners) {
+    async run(trx, query, pagination, params = [{}], path_params = [], view, customRunners) {
         if (!params.length)
             params = [{}];
         let result = {
@@ -36,7 +36,7 @@ class NQL_Engine {
                 ? { ...this.runners, ...customRunners }
                 : this.runners;
             const _runner = runners[part.union.meta.scope];
-            const out = await _runner.run(trx, part, params, pagination, view);
+            const out = await _runner.run(trx, part, params, path_params, pagination, view);
             result = out;
             // Part failed, return
             // Failure here is only when a single value is expected,

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

@@ -4,6 +4,7 @@ import { $BucketGraph } from '../graph/bucket_graph.schema';
 import { BucketViewFieldBuilders, BucketViewFieldFactory } from './bucket_view_field.builder';
 import { $Bucket } from '../bucket.schema';
 import { $Module, $Space } from "../../..";
+import { ModuleTree } from "../../../../engine/tree";
 /**
  * @category Builders
  * @subcategory Entity
@@ -13,6 +14,6 @@ export declare class BucketViewBuilder<Space extends $Space, Module extends $Mod
     private _fields;
     constructor(name: string);
     fields($: BucketViewDef<Space, Module, Bucket>): this;
-    static build(builder: BucketViewBuilder<any, any, any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews): $BucketView;
+    static build(builder: BucketViewBuilder<any, any, any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, tree: ModuleTree): $BucketView;
 }
-export type BucketViewDef<Space extends $Space, Module extends $Module, Bucket extends $Bucket> = ($: BucketViewFieldFactory<Space, Module, Bucket>) => BucketViewFieldBuilders;
+export type BucketViewDef<Space extends $Space, Module extends $Module, Bucket extends $Bucket> = ($: BucketViewFieldFactory<Space, Module, Bucket>) => BucketViewFieldBuilders<Bucket>;

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

@@ -13,13 +13,13 @@ class BucketViewBuilder {
         this._fields = {};
     }
     fields($) {
-        const fieldBuilder = new bucket_view_field_builder_1.BucketViewFieldFactory(this);
+        const fieldBuilder = new bucket_view_field_builder_1.BucketViewFieldFactory();
         this._fields = $(fieldBuilder);
         return this;
     }
     // Build
-    static build(builder, model, graph, views) {
-        const fields = bucket_view_field_builder_1.BucketViewFieldBuilder.buildFields(builder._fields, model, graph, views);
+    static build(builder, model, graph, views, tree) {
+        const fields = bucket_view_field_builder_1.BucketViewFieldBuilder.buildFields(builder._fields, model, graph, views, undefined, tree);
         const schema = new bucket_view_schema_1.$BucketView(builder.name, fields);
         schema.fields.id = new bucket_view_schema_1.$BucketViewField('id', 'model', 'id', { model: { path: 'id' } });
         return schema;

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

@@ -153,6 +153,7 @@ class BucketView {
         if (!node.field.children)
             return [];
         const next = [];
+        // subview
         for (const key in node.field.children) {
             if (key === '__raw')
                 continue;
@@ -258,6 +259,12 @@ class BucketView {
                 }
             }
         }
+        // Apply prop
+        for (const data of poll) {
+            if (node.field.prop) {
+                data.target[data.key] = data.target[data.key][node.field.prop];
+            }
+        }
         return poll.map(p => ({
             index: p.index,
             raw: p.raw,
@@ -271,7 +278,7 @@ class BucketView {
     async parseComputedProp(trx, node) {
         const meta = node.field.meta.computed;
         for (const entry of node.data) {
-            entry.target[node.field.name] = await promise_1.default.solve(meta.fn({ trx, raw: entry.raw, bucket: node.bucket.schema }));
+            entry.target[node.field.name] = await promise_1.default.solve(meta.fn({ trx, raw: entry.raw, value: entry.value, bucket: node.bucket.schema }));
         }
     }
     /**
@@ -279,29 +286,47 @@ class BucketView {
      */
     async parseGraphProp(trx, node) {
         const meta = node.field.meta.graph;
-        let links;
+        let linksObjs;
         const module = trx_node_1.TrxNode.getModule(trx);
+        // Step 1: Read many links from bucket
         // External
         if (node.bucket.tag.module !== module.name) {
-            links = await trx.bucket(node.bucket.tag.short).readManyLinks(node.data.map(entry => entry.raw.id), meta.link);
+            linksObjs = await trx.bucket(node.bucket.tag.short).readManyLinks(node.data.map(entry => entry.raw.id), meta.path, node.data.map(entry => entry.index.map(i => i.toString())));
         }
         // Internal
         else {
             const bucket = module.buckets[node.bucket.tag.name];
-            links = await bucket.graph.readManyLinks(trx, node.data.map(entry => entry.raw), meta.link, { silent: true });
+            linksObjs = await bucket.graph.readManyLinks(trx, node.data.map(entry => entry.raw), {
+                name: meta.link,
+                indexes: node.data.map(entry => entry.index.map(i => i.toString()))
+            }, { silent: true });
         }
-        for (let i = 0; i < links.length; i++) {
+        // Step 2: Initialize target values
+        const link = node.bucket.schema.graph.links[meta.link];
+        for (let i = 0; i < linksObjs.length; i++) {
             if (meta.view) {
-                const link = node.bucket.schema.graph.links[meta.link];
-                node.data[i].target[node.field.name] = link.many
-                    ? []
-                    : (links[i] ? {} : undefined);
+                if (link.many) {
+                    node.data[i].target[node.field.name] = [];
+                }
+                else {
+                    node.data[i].target[node.field.name] = linksObjs[i] ? {} : undefined;
+                }
+            }
+            else if (node.field.prop) {
+                if (link.many) {
+                    node.data[i].target[node.field.name] = linksObjs[i].map((link) => link[node.field.prop]);
+                }
+                else {
+                    node.data[i].target[node.field.name] = linksObjs[i]?.[node.field.prop];
+                }
             }
             else {
-                node.data[i].target[node.field.name] = links[i];
+                node.data[i].target[node.field.name] = linksObjs[i];
             }
         }
+        // Step 3: Build view
         let next = [];
+        let nextData = linksObjs;
         if (meta.view) {
             const schema = node.bucket.schema;
             const otherBucketDep = schema.graph.links[meta.link].bucket;
@@ -311,46 +336,112 @@ class BucketView {
             const view = otherBucket.schema.views[meta.view];
             const { __raw, ...v } = view.fields;
             const link = node.bucket.schema.graph.links[meta.link];
-            let nextData;
             if (link.many) {
-                const _links = links;
+                const _links = linksObjs;
                 for (let i = 0; i < _links.length; i++) {
                     const target = node.data[i].target[node.field.name];
                     for (let j = 0; j < _links[i].length; j++) {
-                        target.push(__raw ? { ..._links[i][j] } : {});
-                        target[j].$v = meta.view;
+                        if (node.field.prop) {
+                            target.push(_links[i][j][node.field.prop]);
+                        }
+                        else {
+                            target.push(__raw ? { ..._links[i][j] } : {});
+                            target[j].$v = meta.view;
+                        }
                     }
                 }
-                nextData = _links.map((ll, i) => ll.map((l, j) => ({ value: l, target: node.data[i].target[node.field.name][j] }))).flat(1);
+                if (!node.field.prop) {
+                    nextData = _links.map((ll, i) => ll.map((l, j) => ({ value: l, target: node.data[i].target[node.field.name][j] }))).flat(1);
+                }
+                else {
+                    nextData = [];
+                }
             }
             else {
-                const _links = links;
+                const _links = linksObjs;
                 nextData = [];
                 for (let i = 0; i < _links.length; i++) {
                     if (!_links[i])
                         continue;
-                    const target = node.data[i].target[node.field.name];
-                    if (__raw) {
-                        Object.assign(target, _links[i]);
+                    if (node.field.prop) {
+                        node.data[i].target[node.field.name] = _links[i][node.field.prop];
+                    }
+                    else {
+                        const target = node.data[i].target[node.field.name];
+                        if (__raw) {
+                            Object.assign(target, _links[i]);
+                        }
+                        target.$v = meta.view;
+                        nextData.push({
+                            value: _links[i], target: node.data[i].target[node.field.name]
+                        });
                     }
-                    target.$v = meta.view;
-                    nextData.push({
-                        value: _links[i], target: node.data[i].target[node.field.name]
-                    });
                 }
             }
-            // TODODO: support external bucket on transitive graph
+            // (still step 3) Add link bucket view fields to queue
             next = [];
-            for (const field of Object.values(v)) {
-                const bucket = await daemon_1.Daemon.getBucketMetadata(module.daemon, otherBucketDep);
+            const bucket = await daemon_1.Daemon.getBucketMetadata(module.daemon, otherBucketDep);
+            // Next data is empty if meta.prop is defined, since there's no need to go deeper
+            if (nextData.length) {
+                for (const field of Object.values(v)) {
+                    next.push({
+                        bucket,
+                        field,
+                        data: nextData.map($ => ({
+                            raw: $.value,
+                            value: $.value,
+                            index: [],
+                            target: $.target
+                        }))
+                    });
+                }
+            }
+        }
+        // Step 4: Add subview fields to queue
+        if (node.field.children) {
+            // Prepare subview data
+            const subview_data = [];
+            for (let i = 0; i < linksObjs.length; i++) {
+                const objs = linksObjs[i];
+                let target;
+                if (link.many) {
+                    target = [];
+                    for (const tobj of node.data[i].target[node.field.name]) {
+                        if ('__raw' in node.field.children) {
+                            target.push({ ...tobj });
+                        }
+                        else {
+                            target.push({ id: tobj.id });
+                        }
+                    }
+                    subview_data.push(...objs.map((obj, i) => ({
+                        obj: { ...obj },
+                        target: target[i]
+                    })));
+                }
+                else {
+                    target = { id: objs.id };
+                    if ('__raw' in node.field.children) {
+                        Object.assign(target, node.data[i].target[node.field.name]);
+                    }
+                    subview_data.push({ obj: { ...objs }, target });
+                }
+                node.data[i].target[node.field.name] = target;
+            }
+            const module = trx_node_1.TrxNode.getModule(trx);
+            const subview_bucket = daemon_1.Daemon.getBucketMetadata(module.daemon, link.bucket);
+            // Add subview data to queue
+            for (const key in node.field.children) {
+                if (key === '__raw')
+                    continue;
                 next.push({
-                    bucket,
-                    field,
-                    data: nextData.map($ => ({
-                        raw: $.value,
-                        value: $.value,
+                    bucket: subview_bucket,
+                    field: node.field.children[key],
+                    data: subview_data.map(data => ({
+                        raw: data.obj,
+                        value: data.obj,
                         index: [],
-                        target: $.target
+                        target: data.target
                     }))
                 });
             }

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

@@ -1,8 +1,9 @@
 import { $Bucket } from '../bucket.schema';
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
-export type $BucketViewFieldFn<TrxNode extends AnyTrxNode, B extends $Bucket> = (ctx: {
+export type $BucketViewFieldFn<TrxNode extends AnyTrxNode, B extends $Bucket, Raw, Value> = (ctx: {
     trx: TrxNode;
     raw: B['#data'];
+    value: Value;
     bucket: $Bucket;
 }) => any | Promise<any>;
 export type $BucketViewFieldMeta = {
@@ -11,10 +12,11 @@ export type $BucketViewFieldMeta = {
     };
     graph?: {
         link: string;
+        path: string;
         view?: string;
     };
     computed?: {
-        fn: $BucketViewFieldFn<any, any>;
+        fn: $BucketViewFieldFn<any, any, any, any>;
     };
     view?: {
         view: string;
@@ -32,11 +34,12 @@ export declare class $BucketViewField {
     scope: 'model' | 'graph' | 'computed' | 'group' | 'view' | 'drive';
     alias: string;
     meta: $BucketViewFieldMeta;
+    prop?: string | undefined;
     children?: $BucketViewFields | undefined;
     chain?: $BucketViewField | undefined;
     $t: string;
     '#data': unknown;
-    constructor(name: string, scope: 'model' | 'graph' | 'computed' | 'group' | 'view' | 'drive', alias: string, meta: $BucketViewFieldMeta, children?: $BucketViewFields | undefined, chain?: $BucketViewField | undefined);
+    constructor(name: string, scope: 'model' | 'graph' | 'computed' | 'group' | 'view' | 'drive', alias: string, meta: $BucketViewFieldMeta, prop?: string | undefined, children?: $BucketViewFields | undefined, chain?: $BucketViewField | undefined);
 }
 export type $BucketViewFields = {
     [x: string]: $BucketViewField;

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

@@ -6,11 +6,12 @@ exports.$BucketView = exports.$BucketViewField = void 0;
  * @subcategory Entity
  * */
 class $BucketViewField {
-    constructor(name, scope, alias, meta, children, chain) {
+    constructor(name, scope, alias, meta, prop, children, chain) {
         this.name = name;
         this.scope = scope;
         this.alias = alias;
         this.meta = meta;
+        this.prop = prop;
         this.children = children;
         this.chain = chain;
         this.$t = 'bucket.view.field';

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

@@ -2,53 +2,54 @@ import { $BucketViewField, $BucketViewFieldFn, $BucketViewFieldMeta, $BucketView
 import { $Module, $Space, ViewObj } from "../../../../schema";
 import { $BucketModel } from '../model/bucket_model.schema';
 import { $BucketGraph } from '../graph/bucket_graph.schema';
-import { BucketViewBuilder } from './bucket_view.builder';
+import { BucketViewDef } from './bucket_view.builder';
 import { $Bucket } from '../bucket.schema';
-import { $BucketViewFieldBuilderInfer } from '../bucket.infer';
+import { $BucketViewDataInfer, $BucketViewFieldBuilderInfer } from '../bucket.infer';
 import { TrxNode } from "../../../../engine/transaction/trx_node";
 import { NesoiFile } from "../../../../engine/data/file";
+import { ModuleTree } from "../../../../engine/tree";
 type DriveFieldpath<Bucket extends $Bucket> = {
     [K in keyof Bucket['#modelpath']]: NonNullable<Bucket['#modelpath'][K]> extends NesoiFile ? K : never;
 }[keyof Bucket['#modelpath']];
-type GraphLinkBucket<Bucket extends $Bucket, L extends keyof Bucket['graph']['links']> = Bucket['graph']['links'][L]['#bucket'];
-type ComputedData<Fn extends $BucketViewFieldFn<any, any>, R = ReturnType<Fn>> = R extends Promise<infer X> ? X : R;
+type ComputedData<Fn extends $BucketViewFieldFn<any, any, any, any>, R = ReturnType<Fn>> = R extends Promise<infer X> ? X : R;
 /**
  * @category Builders
  * @subcategory Entity
  * */
 export declare class BucketViewFieldFactory<Space extends $Space, Module extends $Module, Bucket extends $Bucket> {
-    private _view;
     protected scope: $BucketViewField['scope'];
     protected meta: $BucketViewField['meta'];
-    constructor(_view: BucketViewBuilder<any, any, any>);
     raw(): {
-        [K in keyof Bucket['#data']]: BucketViewFieldBuilder<Bucket['#data'][K], 'model'>;
+        [K in keyof Bucket['#data']]: BucketViewFieldBuilder<Module, Bucket, Bucket, Bucket['#data'][K], 'model'>;
     };
-    model<K extends keyof Bucket['#modelpath'], SubModel extends BucketViewFieldBuilders>(path: K, submodel?: SubModel): BucketViewFieldBuilder<Bucket["#modelpath"][K], "model", never>;
-    value(): BucketViewFieldBuilder<any, "model", never>;
-    computed<Fn extends $BucketViewFieldFn<TrxNode<Space, Module, Space['authnUsers']>, Bucket>>(fn: Fn): BucketViewFieldBuilder<ComputedData<Fn, ReturnType<Fn>>, "computed", never>;
-    graph<L extends keyof Bucket['graph']['links'], LinkBucket extends GraphLinkBucket<Bucket, L>, V extends (keyof LinkBucket['views']) | undefined>(link: L, view?: V): BucketViewFieldBuilder<undefined extends V ? LinkBucket["#data"] : ViewObj<LinkBucket, NonNullable<V>>, "graph", `${LinkBucket["name"]}.${V & string}`>;
-    drive<F extends DriveFieldpath<Bucket>>(path: F): BucketViewFieldBuilder<string, "drive", never>;
-    view<ViewName extends keyof Bucket['views'], View extends Bucket['views'][ViewName]>(view: ViewName): BucketViewFieldBuilder<View["#data"], "view", never>;
-    extend<ViewName extends keyof Bucket['views'], Builders extends BucketViewFieldBuilders>(view: ViewName, fields: Builders): $BucketViewFieldBuilderInfer<Bucket["views"][ViewName]["#data"]> & Builders;
-    static group(name: string, children: $BucketViewFields): $BucketViewField;
+    model<K extends keyof Bucket['#modelpath']>(path: K): BucketViewFieldBuilder<Module, Bucket, Bucket, Bucket["#modelpath"][K], "model", never>;
+    value(): BucketViewFieldBuilder<Module, Bucket, Bucket, any, "model", never>;
+    computed<Fn extends $BucketViewFieldFn<TrxNode<Space, Module, Space['authnUsers']>, Bucket, Bucket['#data'], Bucket['#data']>>(fn: Fn): BucketViewFieldBuilder<Module, Bucket, Bucket, ComputedData<Fn, ReturnType<Fn>>, "computed", never>;
+    graph<L extends keyof Bucket['graph']['links'], V extends (keyof Bucket['graph']['links'][L]['#bucket']['views']) | undefined>(link: L, view?: V): BucketViewFieldBuilder<Module, Bucket, Bucket["graph"]["links"][L]["#bucket"], Bucket["graph"]["links"][L]["#many"] extends true ? (undefined extends V ? Bucket["graph"]["links"][L]["#bucket"]["#data"] : ViewObj<Bucket["graph"]["links"][L]["#bucket"], NonNullable<V>>)[] : undefined extends V ? Bucket["graph"]["links"][L]["#bucket"]["#data"] : ViewObj<Bucket["graph"]["links"][L]["#bucket"], NonNullable<V>>, "graph", `${Bucket["graph"]["links"][L]["#bucket"]["name"]}.${V & string}`>;
+    drive<F extends DriveFieldpath<Bucket>>(path: F): BucketViewFieldBuilder<Module, Bucket, Bucket, string, "drive", never>;
+    view<ViewName extends keyof Bucket['views'], View extends Bucket['views'][ViewName]>(view: ViewName): BucketViewFieldBuilder<Module, Bucket, Bucket, View["#data"], "view", never>;
+    extend<ViewName extends keyof Bucket['views'], Builders extends BucketViewFieldBuilders<any>>(view: ViewName, fields: Builders): $BucketViewFieldBuilderInfer<Bucket["views"][ViewName]["#data"]> & Builders;
+    obj<Builders extends BucketViewFieldBuilders<Bucket>>(children: Builders): BucketViewFieldBuilder<Module, Bucket, Bucket, $BucketViewDataInfer<Builders>, "group", never>;
 }
 /**
  * @category Builders
  * @subcategory Entity
  * */
-export declare class BucketViewFieldBuilder<Data, Scope extends $BucketViewField['scope'], GraphLink extends string = never> {
+export declare class BucketViewFieldBuilder<Module extends $Module, Bucket extends $Bucket, ChainBucket extends $Bucket, Data, Scope extends $BucketViewField['scope'], GraphLink extends string = never> {
     protected scope: $BucketViewField['scope'];
     protected meta: $BucketViewFieldMeta;
-    protected submodel?: BucketViewFieldBuilders | undefined;
+    protected subview?: (BucketViewFieldBuilders<any> | BucketViewDef<any, any, any>) | undefined;
     $b: "view.field";
-    protected _chain?: BucketViewFieldBuilder<any, any, any>;
-    constructor(scope: $BucketViewField['scope'], meta: $BucketViewFieldMeta, submodel?: BucketViewFieldBuilders | undefined);
-    chain<Fn extends $BucketViewFieldFn<any, any>>(fn: Fn): void;
-    static build(builder: BucketViewFieldBuilder<any, any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, name: string, n_indexes: number): $BucketViewField;
-    static buildFields(fields: BucketViewFieldBuilders, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, n_indexes?: number): $BucketViewFields;
+    protected _prop?: string;
+    protected _chain?: BucketViewFieldBuilder<any, any, any, any, any>;
+    constructor(scope: $BucketViewField['scope'], meta: $BucketViewFieldMeta, subview?: (BucketViewFieldBuilders<any> | BucketViewDef<any, any, any>) | undefined);
+    prop<Obj extends Data extends any[] ? Data[number] : Data, K extends keyof Obj>(prop: K): BucketViewFieldBuilder<Module, Bucket, ChainBucket, Obj[K], Scope, GraphLink>;
+    map<Def extends BucketViewDef<any, Module, ChainBucket>>(def: Def): BucketViewFieldBuilder<Module, Bucket, ChainBucket, { [K in keyof Def]: Def extends BucketViewFieldBuilder<any, any, infer X, any, any> ? X : never; }, Scope, GraphLink>;
+    chain<Fn extends $BucketViewFieldFn<TrxNode<any, Module, never>, ChainBucket, Bucket['#data'], Data>>(fn: Fn): BucketViewFieldBuilder<Module, Bucket, ChainBucket, ComputedData<Fn, ReturnType<Fn>>, Scope, GraphLink>;
+    static build(builder: BucketViewFieldBuilder<any, any, any, any, any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, name: string, n_indexes: number, tree?: ModuleTree): $BucketViewField;
+    static buildFields(fields: BucketViewFieldBuilders<any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, n_indexes?: number, tree?: ModuleTree): $BucketViewFields;
 }
-export type BucketViewFieldBuilders = {
-    [x: string]: BucketViewFieldBuilder<any, any, any>;
+export type BucketViewFieldBuilders<Bucket extends $Bucket> = {
+    [x: string]: BucketViewFieldBuilder<any, Bucket, any, any, any>;
 };
 export {};

package/lib/elements/entities/bucket/view/bucket_view_field.builder.js

@@ -12,20 +12,17 @@ const bucket_model_schema_1 = require("../model/bucket_model.schema");
  * @subcategory Entity
  * */
 class BucketViewFieldFactory {
-    constructor(_view) {
-        this._view = _view;
-    }
     raw() {
         return {
             __raw: {}
         };
     }
-    model(path, submodel) {
+    model(path) {
         return new BucketViewFieldBuilder('model', {
             model: {
                 path: path
             }
-        }, submodel);
+        });
     }
     value() {
         return new BucketViewFieldBuilder('model', {
@@ -44,7 +41,8 @@ class BucketViewFieldFactory {
     graph(link, view) {
         return new BucketViewFieldBuilder('graph', {
             graph: {
-                link: link,
+                link: link.replace(/\$\d+/g, '$'),
+                path: link,
                 view: view
             }
         });
@@ -63,14 +61,18 @@ class BucketViewFieldFactory {
             }
         });
     }
+    // from<
+    // >(
+    // ) {
+    // }
     extend(view, fields) {
         return {
             __ext: view,
             ...fields
         };
     }
-    static group(name, children) {
-        return new bucket_view_schema_1.$BucketViewField(name, 'group', name, {}, children);
+    obj(children) {
+        return new BucketViewFieldBuilder('group', {}, children);
     }
 }
 exports.BucketViewFieldFactory = BucketViewFieldFactory;
@@ -82,35 +84,52 @@ exports.BucketViewFieldFactory = BucketViewFieldFactory;
  * @subcategory Entity
  * */
 class BucketViewFieldBuilder {
-    constructor(scope, meta, submodel) {
+    constructor(scope, meta, subview) {
         this.scope = scope;
         this.meta = meta;
-        this.submodel = submodel;
+        this.subview = subview;
         this.$b = 'view.field';
     }
+    prop(prop) {
+        if (this.subview) {
+            throw new Error('Prop not allowed for view field with subview');
+        }
+        this._prop = prop;
+        return this;
+    }
+    map(def) {
+        if (this._prop) {
+            throw new Error('Subview not allowed for view field which picks a prop');
+        }
+        this.subview = def;
+        return this;
+    }
     chain(fn) {
         this._chain = new BucketViewFieldBuilder('computed', {
             computed: {
                 fn: fn
             }
         });
+        return this;
     }
     // Build
-    static build(builder, model, graph, views, name, n_indexes) {
+    static build(builder, model, graph, views, name, n_indexes, tree) {
         let children = undefined;
-        const chain = builder._chain;
+        const chainBuilder = builder._chain;
+        let spread_n = 0;
+        let graphLink = undefined;
         if (builder.scope === 'model') {
             const path = builder.meta.model.path;
-            const spread_n = path.match(/\.\*(\.|$)/g)?.length || 0;
-            if (spread_n === 0 && builder.submodel) {
-                throw new Error('Submodels can only be specified for modelpaths with at least one \'*\'');
+            spread_n = path.match(/\.\*(\.|$)/g)?.length || 0;
+            if (spread_n === 0 && builder.subview) {
+                throw new Error('Subviews can only be specified for modelpaths with at least one \'*\'');
             }
             // Check if indexes are valid
             // $0, $1, $2.. should be up to n_indexes
             const path_indexes = path.match(/\.\$\d+(\.|$)/g)?.map(d => parseInt(d.slice(2))) || [];
             if (Math.max(...path_indexes) >= n_indexes) {
                 if (n_indexes === 0) {
-                    throw new Error('Index $ can only be specified inside a submodel');
+                    throw new Error('Index $ can only be specified inside a subview');
                 }
                 throw new Error(`Maximum index allowed: $${n_indexes - 1}`);
             }
@@ -121,14 +140,10 @@ class BucketViewFieldBuilder {
             if (!modelFields.length) {
                 throw error_1.NesoiError.Builder.Bucket.UnknownModelField(builder.meta.model.path);
             }
-            // If there's a submodel, add it as children
-            if (builder.submodel) {
-                const overrides = this.buildFields(builder.submodel, model, graph, views, n_indexes + spread_n);
-                children = Object.assign({}, children, overrides);
-            }
         }
         else if (builder.scope === 'graph') {
-            const graphLink = builder.meta.graph.link ? graph.links[builder.meta.graph.link] : undefined;
+            const key = builder.meta.graph.link?.replace(/\$\d+/g, '$');
+            graphLink = builder.meta.graph.link ? graph.links[key] : undefined;
             if (!graphLink) {
                 throw error_1.NesoiError.Builder.Bucket.UnknownGraphLink(builder.meta.graph.link || '');
             }
@@ -140,9 +155,34 @@ class BucketViewFieldBuilder {
             }
             children = view.fields;
         }
-        return new bucket_view_schema_1.$BucketViewField(name, builder.scope, name, builder.meta, children, chain);
+        // If there's a subview, add it as children
+        if (builder.subview) {
+            let subview;
+            if (typeof builder.subview === 'function') {
+                const factory = new BucketViewFieldFactory();
+                subview = builder.subview(factory);
+            }
+            else {
+                subview = builder.subview;
+            }
+            let submodelBucket = { model, graph, views };
+            if (builder.scope === 'graph') {
+                const tag = graphLink.bucket;
+                if (tree) {
+                    submodelBucket = tree.allNodes()
+                        .find(node => node.tag.full === tag.full).schema;
+                }
+            }
+            const overrides = this.buildFields(subview, submodelBucket.model, submodelBucket.graph, submodelBucket.views, n_indexes + spread_n, tree);
+            children = Object.assign({}, children, overrides);
+        }
+        let chain;
+        if (chainBuilder) {
+            chain = BucketViewFieldBuilder.build(chainBuilder, model, graph, views, name, n_indexes, tree);
+        }
+        return new bucket_view_schema_1.$BucketViewField(name, builder.scope, name, builder.meta, builder._prop, children, chain);
     }
-    static buildFields(fields, model, graph, views, n_indexes = 0) {
+    static buildFields(fields, model, graph, views, n_indexes = 0, tree) {
         const schema = {};
         // Extended fields inherit from other views
         if ('__ext' in fields) {
@@ -157,7 +197,7 @@ class BucketViewFieldBuilder {
                 schema['__raw'] = {};
             }
             const field = fields[f];
-            schema[f] = BucketViewFieldBuilder.build(field, model, graph, views, f, n_indexes);
+            schema[f] = BucketViewFieldBuilder.build(field, model, graph, views, f, n_indexes, tree);
         }
         return schema;
     }

package/lib/engine/app/inline.app.js

@@ -107,6 +107,12 @@ class InlineApp extends app_1.App {
             const module = app.modules[m];
             module.daemon = this._daemon;
         }
+        // Run init method of services
+        for (const key in app.services) {
+            await promise_1.default.solve(app.services[key].init({
+                daemon: this._daemon
+            }));
+        }
         return this._daemon;
     }
     makeDaemon(trxEngines, services) {

package/lib/engine/app/native/distributed_node.app.js

@@ -117,6 +117,12 @@ class DistributedNodeApp extends app_1.App {
             const module = app.modules[m];
             module.daemon = this._daemon;
         }
+        // Run init method of services
+        for (const key in app.services) {
+            await promise_1.default.solve(app.services[key].init({
+                daemon: this._daemon
+            }));
+        }
         return this._daemon;
     }
     host(config) {

package/lib/engine/app/service.d.ts

@@ -1,3 +1,4 @@
+import { AnyDaemon } from '../daemon';
 import { AnyModule } from '../module';
 /**
  * Service
@@ -15,6 +16,9 @@ export declare abstract class Service<out Name extends string, Config = never> {
         modules: Record<string, AnyModule>;
     }): void | Promise<void>;
     abstract down(): void | Promise<void>;
+    init($: {
+        daemon: AnyDaemon;
+    }): void | Promise<void>;
     constructor(...cfg: Optional<Config>);
     constructor(name: Name, ...cfg: Optional<Config>);
 }
@@ -25,6 +29,9 @@ export interface IService {
     up(this: IService, $: {
         modules: Record<string, AnyModule>;
     }): void | Promise<void>;
+    init(this: IService, $: {
+        daemon: AnyDaemon;
+    }): void | Promise<void>;
     down(this: IService): void | Promise<void>;
 }
 export {};

package/lib/engine/app/service.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Service = void 0;
 class Service {
+    init($) {
+    }
     constructor(arg1, arg2) {
         if (typeof arg1 === 'string') {
             this.name = arg1;