nesoi 3.4.0 → 3.4.1

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

@@ -10,6 +10,7 @@ const error_1 = require("../../../../engine/data/error");
 const tree_1 = require("../../../../engine/data/tree");
 const daemon_1 = require("../../../../engine/daemon");
 const dependency_1 = require("../../../../engine/dependency");
+const bucket_model_1 = require("../model/bucket_model");
 class ViewValue {
     value = undefined;
     constructor() { }
@@ -25,22 +26,24 @@ class BucketView {
         this.bucket = bucket;
         this.schema = schema;
     }
-    async parse(trx, raw, flags) {
+    async parse(trx, root, flags) {
         const module = trx_node_1.TrxNode.getModule(trx);
         const tag = new dependency_1.Tag(this.bucket.module.name, 'bucket', this.bucket.schema.name);
         const meta = await daemon_1.Daemon.getBucketMetadata(module.daemon, tag);
         const parsed = {};
-        if ('__raw' in this.schema.fields) {
-            Object.assign(parsed, raw);
+        if ('__root' in this.schema.fields || '__parent' in this.schema.fields || '__value' in this.schema.fields) {
+            Object.assign(parsed, root);
         }
         let layer = Object.values(this.schema.fields).map(field => ({
             bucket: meta,
             field,
             data: [{
-                    raw,
-                    value: raw,
+                    root,
+                    parent: root,
                     index: [],
-                    target: parsed
+                    value: root,
+                    target: parsed,
+                    key: field.name
                 }]
         }));
         while (layer.length) {
@@ -48,37 +51,39 @@ class BucketView {
         }
         parsed['$v'] = this.schema.name;
         return {
-            id: raw.id,
+            id: root.id,
             ...parsed
         };
     }
-    async parseMany(trx, raws, flags) {
+    async parseMany(trx, roots, flags) {
         const module = trx_node_1.TrxNode.getModule(trx);
         const tag = new dependency_1.Tag(this.bucket.module.name, 'bucket', this.bucket.schema.name);
         const meta = await daemon_1.Daemon.getBucketMetadata(module.daemon, tag);
         const parseds = [];
-        for (const raw of raws) {
+        for (const root of roots) {
             const parsed = {};
-            if ('__raw' in this.schema.fields) {
-                Object.assign(parsed, raw);
+            if ('__root' in this.schema.fields || '__parent' in this.schema.fields || '__value' in this.schema.fields) {
+                Object.assign(parsed, root);
             }
             parseds.push(parsed);
         }
         let layer = Object.values(this.schema.fields).map(field => ({
             bucket: meta,
             field,
-            data: raws.map((raw, i) => ({
-                raw,
-                value: raw,
+            data: roots.map((root, i) => ({
+                root,
+                parent: root,
                 index: [],
-                target: parseds[i]
+                value: root,
+                target: parseds[i],
+                key: field.name
             }))
         }));
         while (layer.length) {
             layer = await this.parseLayer(trx, layer, flags);
         }
-        for (let i = 0; i < raws.length; i++) {
-            parseds[i].id = raws[i].id;
+        for (let i = 0; i < roots.length; i++) {
+            parseds[i].id = roots[i].id;
             parseds[i]['$v'] = this.schema.name;
         }
         return parseds;
@@ -115,9 +120,9 @@ class BucketView {
                 continue;
             if (!node.field.children)
                 continue;
-            if ('__raw' in node.field.children) {
+            if ('__root' in node.field.children || '__parent' in this.schema.fields || '__value' in node.field.children) {
                 for (const d of node.data) {
-                    d.target[node.field.name] = d.value;
+                    d.target[d.key] = d.value;
                 }
             }
             next.push(...Object.values(node.field.children).map(field => ({
@@ -126,152 +131,230 @@ class BucketView {
                 data: node.data
             })));
         }
-        // Chains
-        for (const node of layer) {
-            if (!node.field.chain)
-                continue;
-            next.push({
-                bucket: node.bucket,
-                field: node.field.chain,
-                data: node.data.map(d => ({
-                    index: d.index,
-                    target: d.target,
-                    raw: d.raw,
-                    value: d.target[node.field.name]
-                }))
-            });
-        }
         return next;
     }
+    toDict(as_dict, data, final = false) {
+        const dict = {};
+        const next_data = [];
+        let poll = data.map(d => ({
+            i: 0,
+            index: d.index,
+            value: d.value,
+            target: dict
+        }));
+        while (poll.length) {
+            const next = [];
+            for (const entry of poll) {
+                const isLeaf = entry.i === as_dict.length - 1;
+                const key = entry.index.at(as_dict[entry.i]);
+                if (!key) {
+                    throw new Error(`Invalid view dict argument ${as_dict}`); // TODO: NesoiError
+                }
+                if (isLeaf) {
+                    if (final) {
+                        entry.target[key] = entry.value;
+                    }
+                    else {
+                        entry.target[key] = {};
+                        next_data.push({
+                            target: entry.target[key],
+                            value: entry.value,
+                            index: entry.index
+                        });
+                    }
+                }
+                else {
+                    entry.target[key] = {};
+                    next.push({
+                        i: entry.i + 1,
+                        index: entry.index,
+                        value: entry.value,
+                        target: entry.target[key]
+                    });
+                }
+            }
+            poll = next;
+        }
+        return {
+            value: dict,
+            next: next_data
+        };
+    }
     /**
      * [model]
      * Read one property from
      */
     parseModelProp(node, flags) {
-        const initAs = (!node.field.children) ? 'value' : 'obj';
-        const rawChild = '__raw' in (node.field.children || {});
-        const nextData = this.doParseModelProp(node, initAs, rawChild, flags);
-        if (!node.field.children)
-            return [];
+        const nextData = this.doParseModelProp(node, flags);
         const next = [];
-        // subview
-        for (const key in node.field.children) {
-            if (key === '__raw')
-                continue;
+        // Add children (subview) to queue
+        if (node.field.children) {
+            for (const key in node.field.children) {
+                if (key === '__root')
+                    continue;
+                if (key === '__parent')
+                    continue;
+                if (key === '__value')
+                    continue;
+                next.push({
+                    bucket: node.bucket,
+                    field: node.field.children[key],
+                    data: nextData.map(d => ({
+                        ...d,
+                        key: d.key ?? node.field.children[key].name
+                    }))
+                });
+            }
+        }
+        // Chains
+        if (node.field.chain) {
             next.push({
                 bucket: node.bucket,
-                field: node.field.children[key],
-                data: nextData
+                field: node.field.chain,
+                data: nextData.map(d => ({
+                    root: d.root,
+                    parent: d.parent,
+                    index: d.index,
+                    value: d.value,
+                    target: d.target,
+                    key: d.key
+                }))
             });
         }
         return next;
     }
-    doParseModelProp(node, initAs, rawChild, flags) {
-        const modelpath = node.field.meta.model.path;
-        const isValueModel = modelpath === '.';
-        const name = node.field.name;
-        let poll = node.data.map(d => ({
-            ...d,
-            value: isValueModel ? d.value : d.raw,
-            key: name
-        }));
-        if (isValueModel) {
-            for (const data of poll) {
+    doParseModelProp(node, flags) {
+        const model = new bucket_model_1.BucketModel(node.bucket.schema);
+        let modelpath = node.field.meta.model.path;
+        if (node.field.prop)
+            modelpath += '.' + node.field.prop;
+        const hasSubview = node.field.children;
+        const hasChain = node.field.chain;
+        const hasRootSubviewField = '__root' in (node.field.children || {});
+        const hasParentSubviewField = '__parent' in (node.field.children || {});
+        const hasValueSubviewField = '__value' in (node.field.children || {});
+        const nextData = [];
+        for (const data of node.data) {
+            // Modelpath refers to the whole value 
+            if (modelpath === '__root') {
+                data.target[data.key] = data.root;
+                continue;
+            }
+            if (modelpath === '__parent') {
+                data.target[data.key] = data.parent;
+                continue;
+            }
+            if (modelpath === '__value') {
                 data.target[data.key] = data.value;
+                continue;
             }
-        }
-        else {
-            const paths = modelpath.split('.');
-            for (const path of paths) {
-                // *
-                if (path === '*') {
-                    // Expand each value of the poll (assumed to be a dict or list)
-                    poll = poll.map(item => {
-                        if (typeof item.value !== 'object') {
-                            throw new Error(`Failed to parse ${paths}, intermediate value ${item.value} is not a list or object`);
-                        }
-                        if (Array.isArray(item.value)) {
-                            item.target[item.key] = initAs === 'value'
-                                ? [...item.value]
-                                : item.value.map(() => ({}));
-                            return item.value.map((v, i) => ({
-                                index: [...item.index, i],
-                                raw: item.raw,
-                                value: v,
-                                target: item.target[item.key],
-                                key: i
-                            }));
-                        }
+            let node_modelpath = modelpath;
+            if (data.index.length) {
+                for (let i = 0; i < data.index.length; i++) {
+                    node_modelpath = node_modelpath.replace(new RegExp('\\$' + i, 'g'), data.index[i].toString());
+                }
+            }
+            // Copy modelpath value from object
+            const value = model.copy(data.parent, 'save', () => !!flags?.serialize, node_modelpath);
+            const many = modelpath.split('.').includes('*');
+            // Modelpath contains '*', so it returns N results
+            if (many) {
+                const next = value.map(v => {
+                    const index = [...data.index, ...v.index];
+                    if (hasRootSubviewField || hasParentSubviewField || hasValueSubviewField) {
+                        // Value is not an object, start subview as empty object
+                        if (typeof v.value !== 'object' || Array.isArray(v.value))
+                            return { value: v.value, target: {}, index: index };
+                        // Value is an object, start subview with root/value
                         else {
-                            item.target[item.key] = initAs === 'value'
-                                ? { ...item.value }
-                                : Object.fromEntries(Object.entries(item.value).map(([k]) => [k, {}]));
-                            return Object.entries(item.value).map(([k, v]) => ({
-                                index: [...item.index, k],
-                                raw: item.raw,
-                                value: v,
-                                target: item.target[item.key],
-                                key: k
-                            }));
+                            const val = Object.assign({}, hasRootSubviewField ? data.root : {}, hasParentSubviewField ? data.parent : {}, hasValueSubviewField ? v.value : {});
+                            return { value: v.value, target: val, index: index };
                         }
-                    }).flat(1);
-                    continue;
+                    }
+                    else if (hasSubview)
+                        return { value: v.value, target: {}, index: index };
+                    else
+                        return { value: v.value, target: v.value, index: index };
+                });
+                if (node.field.as_dict) {
+                    const dict = this.toDict(node.field.as_dict, next, !node.field.children);
+                    data.target[data.key] = dict.value;
+                    // Add to be processed by subview
+                    nextData.push(...dict.next.map((v, i) => ({
+                        root: data.root,
+                        parent: data.parent,
+                        index: v.index,
+                        value: v.value,
+                        target: v.target
+                    })));
                 }
-                // $1, $2.. or string|number
                 else {
-                    // Walk each node
-                    const next = [];
-                    for (const item of poll) {
-                        // $0, $1.. -> string
-                        const idx = path.match(/^\$(\d+)/)?.[1];
-                        let _path = path;
-                        if (idx !== undefined) {
-                            // Replace by index key
-                            _path = item.index[parseInt(idx)];
-                        }
-                        const n = typeof item.value === 'object'
-                            ? item.value[_path]
-                            : undefined;
-                        item.target[item.key] = initAs === 'value'
-                            ? n
-                            : {};
-                        if (n !== undefined) {
-                            next.push({
-                                index: item.index,
-                                raw: item.raw,
-                                value: n,
-                                target: item.target,
-                                key: item.key
-                            });
-                        }
+                    if (hasChain) {
+                        data.target[data.key] = [];
+                        nextData.push(...next.map((v, i) => ({
+                            root: data.root,
+                            parent: data.parent,
+                            index: v.index,
+                            value: v.value,
+                            target: data.target[data.key],
+                            key: i.toString()
+                        })));
+                    }
+                    else {
+                        data.target[data.key] = next.map(v => v.target);
+                        // Add to be processed by subview
+                        nextData.push(...next.map((v, i) => ({
+                            root: data.root,
+                            parent: data.parent,
+                            index: v.index,
+                            value: v.value,
+                            target: v.target
+                        })));
                     }
-                    poll = next;
                 }
             }
-        }
-        // For each leaf, if it's an object (not an array),
-        // pre-fill with it's value.
-        // This means that ...$.raw() only works on modelpaths that
-        // result in an object. Otherwise, it's ignored.
-        if (rawChild) {
-            for (const data of poll) {
-                if (typeof data.value === 'object' && !Array.isArray(data.value)) {
-                    data.target[data.key] = data.value;
+            // Modelpath does not contain '*', so it returns 1 result
+            else {
+                const v = value[0];
+                const index = [...data.index, ...(v?.index ?? [])];
+                let target = v?.value;
+                if (hasRootSubviewField || hasParentSubviewField || hasValueSubviewField) {
+                    // Value is not an object, start subview as empty object
+                    if (typeof v.value !== 'object' || Array.isArray(v.value))
+                        target = {};
+                    // Value is an object, start subview with root/value
+                    else {
+                        target = Object.assign({}, hasRootSubviewField ? data.root : {}, hasParentSubviewField ? data.parent : {}, hasValueSubviewField ? v.value : {});
+                    }
+                }
+                else if (hasSubview)
+                    target = {};
+                if (target) {
+                    if (hasChain) {
+                        nextData.push({
+                            root: data.root,
+                            parent: data.parent,
+                            index: index,
+                            value: v.value,
+                            target: data.target,
+                            key: data.key
+                        });
+                    }
+                    else {
+                        data.target[data.key] = target;
+                        // Add to be processed by subview
+                        nextData.push({
+                            root: data.root,
+                            parent: target,
+                            index: index,
+                            value: v.value,
+                            target
+                        });
+                    }
                 }
             }
         }
-        // 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,
-            value: p.value,
-            target: p.target[p.key]
-        }));
+        return nextData;
     }
     /**
      * [computed]
@@ -279,7 +362,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, value: entry.value, bucket: node.bucket.schema }));
+            entry.target[entry.key] = await promise_1.default.solve(meta.fn({ trx, root: entry.root, parent: entry.parent, value: entry.value, bucket: node.bucket.schema }));
         }
     }
     /**
@@ -292,69 +375,77 @@ class BucketView {
         // Step 1: Read many links from bucket
         // External
         if (node.bucket.tag.module !== module.name) {
-            linksObjs = await trx.bucket(node.bucket.tag.short).readManyLinks(node.data.map(entry => entry.raw.id), //ids -> objs -> params
-            meta.path, [] // param templates temporarily disabled
-            );
+            linksObjs = await trx.bucket(node.bucket.tag.short).readManyLinks(node.data.map(entry => entry.parent.id), //ids -> objs -> params
+            meta.path, node.data.map(entry => entry.index));
         }
         // Internal
         else {
             const bucket = module.buckets[node.bucket.tag.name];
-            linksObjs = await bucket.graph.readManyLinks(trx, node.data.map(entry => entry.raw), {
+            linksObjs = await bucket.graph.readManyLinks(trx, node.data.map(entry => entry.parent), {
                 name: meta.link,
-                indexes: [] // param templates temporarily disabled
+                indexes: node.data.map(entry => entry.index)
             }, { silent: true });
         }
         // Step 2: Initialize target values
         const link = node.bucket.schema.graph.links[meta.link];
         for (let i = 0; i < linksObjs.length; i++) {
+            const target = node.data[i].target;
+            const key = node.data[i].key;
             if (meta.view) {
                 if (link.many) {
-                    node.data[i].target[node.field.name] = [];
+                    target[key] = [];
                 }
                 else {
-                    node.data[i].target[node.field.name] = linksObjs[i] ? {} : undefined;
+                    target[key] = 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]);
+                    target[key] = linksObjs[i].map((link) => link[node.field.prop]);
                 }
                 else {
-                    node.data[i].target[node.field.name] = linksObjs[i]?.[node.field.prop];
+                    target[key] = linksObjs[i]?.[node.field.prop];
                 }
             }
             else {
-                node.data[i].target[node.field.name] = linksObjs[i];
+                target[key] = linksObjs[i];
             }
         }
+        const schema = node.bucket.schema;
+        const otherBucketDep = schema.graph.links[meta.link].bucket;
+        const daemon = module.daemon;
+        const otherBucket = await daemon_1.Daemon.getBucketMetadata(daemon, otherBucketDep);
         // 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;
-            const module = trx_node_1.TrxNode.getModule(trx);
-            const daemon = module.daemon;
-            const otherBucket = await daemon_1.Daemon.getBucketMetadata(daemon, otherBucketDep);
             const view = otherBucket.schema.views[meta.view];
-            const { __raw, ...v } = view.fields;
+            const includeRoot = '__root' in view.fields;
+            const includeParent = '__parent' in view.fields;
+            const includeValue = '__value' in view.fields;
+            const v = { ...view.fields };
+            delete v['__root'];
+            delete v['__parent'];
+            delete v['__value'];
             const link = node.bucket.schema.graph.links[meta.link];
             if (link.many) {
                 const _links = linksObjs;
                 for (let i = 0; i < _links.length; i++) {
-                    const target = node.data[i].target[node.field.name];
+                    const key = node.data[i].key;
+                    const target = node.data[i].target[key];
                     for (let j = 0; j < _links[i].length; j++) {
                         if (node.field.prop) {
                             target.push(_links[i][j][node.field.prop]);
                         }
                         else {
-                            target.push(__raw ? { ..._links[i][j] } : {});
+                            const init = Object.assign({ $v: meta.view }, (includeRoot || includeParent || includeValue) ? _links[i][j] : {});
+                            target.push(init);
                             target[j].$v = meta.view;
                         }
                     }
                 }
                 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);
+                    nextData = _links.map((ll, i) => ll.map((l, j) => ({ value: l, target: node.data[i].target[node.data[i].key][j] }))).flat(1);
                 }
                 else {
                     nextData = [];
@@ -366,35 +457,38 @@ class BucketView {
                 for (let i = 0; i < _links.length; i++) {
                     if (!_links[i])
                         continue;
+                    const key = node.data[i].key;
                     if (node.field.prop) {
-                        node.data[i].target[node.field.name] = _links[i][node.field.prop];
+                        node.data[i].target[key] = _links[i][node.field.prop];
                     }
                     else {
-                        const target = node.data[i].target[node.field.name];
-                        if (__raw) {
+                        const target = node.data[i].target[key];
+                        if (includeRoot || includeParent || includeValue) {
                             Object.assign(target, _links[i]);
                         }
                         target.$v = meta.view;
                         nextData.push({
-                            value: _links[i], target: node.data[i].target[node.field.name]
+                            value: _links[i], target: node.data[i].target[key]
                         });
                     }
                 }
             }
             // (still step 3) Add link bucket view fields to queue
             next = [];
-            const bucket = await daemon_1.Daemon.getBucketMetadata(module.daemon, otherBucketDep);
+            // const bucket = await 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,
+                        bucket: otherBucket,
                         field,
                         data: nextData.map($ => ({
-                            raw: $.value,
+                            root: $.value,
+                            parent: $.value,
                             value: $.value,
                             index: [],
-                            target: $.target
+                            target: $.target,
+                            key: field.name
                         }))
                     });
                 }
@@ -406,45 +500,63 @@ class BucketView {
             const subview_data = [];
             for (let i = 0; i < linksObjs.length; i++) {
                 const objs = linksObjs[i];
+                if (!objs)
+                    continue;
+                const key = node.data[i].key;
                 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 });
-                        }
+                    for (const tobj of node.data[i].target[key]) {
+                        const init = Object.assign({ id: tobj.id }, '__root' in node.field.children ? node.data[i].root : {}, '__parent' in node.field.children ? node.data[i].root : {}, '__value' in node.field.children ? tobj : {});
+                        target.push(init);
                     }
-                    subview_data.push(...objs.map((obj, i) => ({
-                        obj: { ...obj },
-                        target: target[i]
+                    subview_data.push(...objs.map((obj, j) => ({
+                        root: node.data[i].root,
+                        parent: node.data[i].parent,
+                        value: { ...obj },
+                        target: target[j]
                     })));
                 }
                 else {
                     target = { id: objs.id };
-                    if ('__raw' in node.field.children) {
-                        Object.assign(target, node.data[i].target[node.field.name]);
+                    if ('__root' in node.field.children) {
+                        Object.assign(target, node.data[i].root);
                     }
-                    subview_data.push({ obj: { ...objs }, target });
+                    if ('__parent' in node.field.children) {
+                        Object.assign(target, node.data[i].parent);
+                    }
+                    if ('__value' in node.field.children) {
+                        Object.assign(target, node.data[i].target[key]);
+                    }
+                    subview_data.push({
+                        root: node.data[i].root,
+                        parent: node.data[i].parent,
+                        value: { ...objs },
+                        target
+                    });
                 }
-                node.data[i].target[node.field.name] = target;
+                node.data[i].target[key] = 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')
+                if (key === '__root')
+                    continue;
+                if (key === '__parent')
+                    continue;
+                if (key === '__value')
                     continue;
                 next.push({
                     bucket: subview_bucket,
                     field: node.field.children[key],
                     data: subview_data.map(data => ({
-                        raw: data.obj,
-                        value: data.obj,
+                        root: data.root,
+                        parent: data.value,
                         index: [],
-                        target: data.target
+                        value: data.value,
+                        target: data.target,
+                        key: node.field.children[key].name
                     }))
                 });
             }
@@ -462,16 +574,16 @@ class BucketView {
         }
         const meta = node.field.meta.drive;
         for (const entry of node.data) {
-            const value = tree_1.Tree.get(entry.raw, meta.path);
+            const value = tree_1.Tree.get(entry.root, meta.path);
             if (Array.isArray(value)) {
                 const public_urls = [];
                 for (const obj of value) {
                     public_urls.push(await drive.public(obj));
                 }
-                entry.target[node.field.name] = public_urls;
+                entry.target[entry.key] = public_urls;
             }
             else {
-                entry.target[node.field.name] = await drive.public(value);
+                entry.target[entry.key] = await drive.public(value);
             }
         }
     }