nesoi 3.0.20 → 3.1.0

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

@@ -5,8 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BucketView = void 0;
 const promise_1 = __importDefault(require("../../../../engine/util/promise"));
-const tree_1 = require("../../../../engine/data/tree");
 const error_1 = require("../../../../engine/data/error");
+const tree_1 = require("../../../../engine/data/tree");
+class ViewValue {
+    constructor() {
+        this.value = undefined;
+    }
+}
 /**
  * @category Elements
  * @subcategory Entity
@@ -17,123 +22,240 @@ class BucketView {
         this.schema = schema;
     }
     async parse(trx, raw) {
-        const bucket = this.bucket;
-        const doParse = async (schema, index) => {
-            const parsedObj = {};
-            // Model props
-            for (const k in schema) {
-                const prop = schema[k];
-                if (prop.scope !== 'model') {
-                    continue;
-                }
-                parsedObj[k] = await parseModelProp(raw, prop, index);
-            }
-            // Computed props
-            for (const k in schema) {
-                const prop = schema[k];
-                if (prop.$t !== 'bucket.view.field') {
-                    continue;
-                }
-                if (prop.scope !== 'computed') {
-                    continue;
-                }
-                const value = prop.value.computed;
-                parsedObj[k] = await promise_1.default.solve(value.fn({ trx, raw, bucket: bucket.schema }));
-            }
-            // Graph props
-            for (const k in schema) {
-                const prop = schema[k];
-                if (prop.$t !== 'bucket.view.field') {
-                    continue;
-                }
-                if (prop.scope !== 'graph') {
-                    continue;
-                }
-                const value = prop.value.graph;
-                let link;
-                if (!value.view) {
-                    link = bucket.graph.readLink(trx, raw, value.link, { silent: true }); // TODO: fieldpath indexes
-                }
-                else {
-                    link = bucket.graph.viewLink(trx, raw, value.link, value.view, { silent: true }); // TODO: fieldpath indexes
+        const parsed = {};
+        if ('__raw' in this.schema.fields) {
+            Object.assign(parsed, raw);
+        }
+        let layer = Object.values(this.schema.fields).map(field => ({
+            field,
+            data: [{
+                    value: raw,
+                    index: [],
+                    target: parsed
+                }]
+        }));
+        while (layer.length) {
+            layer = await this.parseLayer(trx, raw, layer);
+        }
+        parsed['$v'] = this.schema.name;
+        return {
+            id: raw.id,
+            ...parsed
+        };
+    }
+    async parseLayer(trx, raw, layer) {
+        const next = [];
+        // Model props
+        for (const node of layer) {
+            if (node.field.scope !== 'model')
+                continue;
+            next.push(...this.parseModelProp(raw, node));
+        }
+        // Computed props
+        for (const node of layer) {
+            if (node.field.scope !== 'computed')
+                continue;
+            await this.parseComputedProp(trx, raw, node);
+        }
+        // Graph props
+        for (const node of layer) {
+            if (node.field.scope !== 'graph')
+                continue;
+            await this.parseGraphProp(trx, raw, node);
+        }
+        // Drive props
+        for (const node of layer) {
+            if (node.field.scope !== 'drive')
+                continue;
+            await this.parseDriveProp(trx, raw, node);
+        }
+        // Group props
+        for (const node of layer) {
+            if (node.field.scope !== 'group')
+                continue;
+            if (!node.field.children)
+                continue;
+            if ('__raw' in node.field.children) {
+                for (const d of node.data) {
+                    d.target[node.field.name] = d.value;
                 }
-                parsedObj[k] = await promise_1.default.solve(link);
             }
-            // Drive props
-            for (const k in schema) {
-                const prop = schema[k];
-                if (prop.$t !== 'bucket.view.field') {
-                    continue;
-                }
-                if (prop.scope !== 'drive') {
-                    continue;
-                }
-                if (!bucket.drive) {
-                    throw error_1.NesoiError.Bucket.Drive.NoAdapter({ bucket: bucket.schema.alias });
-                }
-                const value = prop.value.drive;
-                const model = tree_1.Tree.get(raw, value.path);
-                if (Array.isArray(model)) {
-                    const public_urls = [];
-                    for (const obj of model) {
-                        public_urls.push(await bucket.drive.public(obj));
+            next.push(...Object.values(node.field.children).map(field => ({
+                field,
+                data: node.data
+            })));
+        }
+        // Chains
+        for (const node of layer) {
+            if (!node.field.chain)
+                continue;
+            next.push({
+                field: node.field.chain,
+                data: node.data.map(d => ({
+                    index: d.index,
+                    target: d.target,
+                    value: d.target[node.field.name]
+                }))
+            });
+        }
+        return next;
+    }
+    /**
+     * [model]
+     * Read one property from
+     */
+    parseModelProp(raw, node) {
+        const initAs = (!node.field.children) ? 'value' : 'obj';
+        const rawChild = '__raw' in (node.field.children || {});
+        const nextData = this.doParseModelProp(raw, node, initAs, rawChild);
+        if (!node.field.children)
+            return [];
+        const next = [];
+        for (const key in node.field.children) {
+            if (key === '__raw')
+                continue;
+            next.push({
+                field: node.field.children[key],
+                data: nextData
+            });
+        }
+        return next;
+    }
+    doParseModelProp(raw, node, initAs, rawChild) {
+        const modelpath = node.field.meta.model.path;
+        const paths = modelpath.split('.');
+        const name = node.field.name;
+        let poll = node.data.map(d => ({
+            ...d,
+            value: raw,
+            key: name
+        }));
+        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`);
                     }
-                    parsedObj[k] = public_urls;
-                }
-                else {
-                    parsedObj[k] = (await bucket.drive.public(model));
-                }
-            }
-            // Group props
-            for (const k in schema) {
-                const prop = schema[k];
-                if (prop.$t !== 'bucket.view.field') {
-                    continue;
-                }
-                if (prop.scope !== 'group') {
-                    continue;
-                }
-                parsedObj[k] = await doParse(prop.children || {}, index);
-            }
-            return parsedObj;
-        };
-        const parseModelProp = async (obj, prop, index, key) => {
-            const value = prop.value.model;
-            const rawValue = tree_1.Tree.get(obj, key || value.key, index);
-            if (prop.children) {
-                if (prop.array) {
-                    if (!Array.isArray(rawValue)) {
-                        return undefined;
+                    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],
+                            value: v,
+                            target: item.target[item.key],
+                            key: i
+                        }));
                     }
-                    const parsedArray = [];
-                    for (let i = 0; i < rawValue.length; i++) {
-                        const child = await doParse(prop.children, [...(index || []), i]);
-                        parsedArray.push(child);
+                    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],
+                            value: v,
+                            target: item.target[item.key],
+                            key: k
+                        }));
                     }
-                    return parsedArray;
-                }
-                else if (prop.type === 'dict') {
-                    if (typeof rawValue !== 'object' || Array.isArray(rawValue)) {
-                        return undefined;
+                }).flat(1);
+                continue;
+            }
+            // $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 parsedDict = {};
-                    for (const j in rawValue) {
-                        parsedDict[j] = await parseModelProp(rawValue, prop.children.__dict, [...(index || []), j], j);
+                    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,
+                            value: n,
+                            target: item.target,
+                            key: item.key
+                        });
                     }
-                    return parsedDict;
                 }
-                else {
-                    return doParse(prop.children, index || []);
+                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;
                 }
             }
-            return rawValue;
-        };
-        const parsedObj = await doParse(this.schema.fields);
-        parsedObj['$v'] = this.schema.name;
-        return {
-            id: raw.id,
-            ...parsedObj
-        };
+        }
+        return poll.map(p => ({
+            index: p.index,
+            value: p.value,
+            target: p.target[p.key]
+        }));
+    }
+    /**
+     * [computed]
+     */
+    async parseComputedProp(trx, raw, 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, bucket: this.bucket.schema }));
+        }
+    }
+    /**
+     * [graph]
+     */
+    async parseGraphProp(trx, raw, node) {
+        const meta = node.field.meta.graph;
+        for (const entry of node.data) {
+            let link;
+            if (!meta.view) {
+                link = this.bucket.graph.readLink(trx, raw, meta.link, { silent: true });
+            }
+            else {
+                link = this.bucket.graph.viewLink(trx, raw, meta.link, meta.view, { silent: true });
+            }
+            entry.target[node.field.name] = await promise_1.default.solve(link);
+        }
+    }
+    /**
+     * [drive]
+     */
+    async parseDriveProp(trx, raw, node) {
+        if (!this.bucket.drive) {
+            throw error_1.NesoiError.Bucket.Drive.NoAdapter({ bucket: this.bucket.schema.alias });
+        }
+        const meta = node.field.meta.drive;
+        for (const entry of node.data) {
+            const value = tree_1.Tree.get(raw, meta.path);
+            if (Array.isArray(value)) {
+                const public_urls = [];
+                for (const obj of value) {
+                    public_urls.push(await this.bucket.drive.public(obj));
+                }
+                entry.target[node.field.name] = public_urls;
+            }
+            else {
+                entry.target[node.field.name] = await this.bucket.drive.public(value);
+            }
+        }
     }
 }
 exports.BucketView = BucketView;

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

@@ -1,4 +1,3 @@
-import { $BucketModelFieldType } from '../model/bucket_model.schema';
 import { $Bucket } from '../bucket.schema';
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
 export type $BucketViewFieldFn<TrxNode extends AnyTrxNode, B extends $Bucket> = (ctx: {
@@ -6,10 +5,9 @@ export type $BucketViewFieldFn<TrxNode extends AnyTrxNode, B extends $Bucket> =
     raw: B['#data'];
     bucket: $Bucket;
 }) => any | Promise<any>;
-export type $BucketViewFieldValue = {
+export type $BucketViewFieldMeta = {
     model?: {
-        key: string;
-        enumOptions?: string | string[];
+        path: string;
     };
     graph?: {
         link: string;
@@ -24,7 +22,6 @@ export type $BucketViewFieldValue = {
     drive?: {
         path: string;
     };
-    group?: {};
 };
 /**
  * @category Schemas
@@ -33,15 +30,13 @@ export type $BucketViewFieldValue = {
 export declare class $BucketViewField {
     name: string;
     scope: 'model' | 'graph' | 'computed' | 'group' | 'view' | 'drive';
-    type: $BucketModelFieldType | 'id';
     alias: string;
-    array: boolean | 'unknown';
-    required: boolean;
-    value: $BucketViewFieldValue;
+    meta: $BucketViewFieldMeta;
     children?: $BucketViewFields | undefined;
+    chain?: $BucketViewField | undefined;
     $t: string;
     '#data': unknown;
-    constructor(name: string, scope: 'model' | 'graph' | 'computed' | 'group' | 'view' | 'drive', type: $BucketModelFieldType | 'id', alias: string, array: boolean | 'unknown', required: boolean, value: $BucketViewFieldValue, children?: $BucketViewFields | undefined);
+    constructor(name: string, scope: 'model' | 'graph' | 'computed' | 'group' | 'view' | 'drive', alias: string, meta: $BucketViewFieldMeta, children?: $BucketViewFields | undefined, chain?: $BucketViewField | undefined);
 }
 export type $BucketViewFields = {
     [x: string]: $BucketViewField;

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

@@ -6,15 +6,13 @@ exports.$BucketView = exports.$BucketViewField = void 0;
  * @subcategory Entity
  * */
 class $BucketViewField {
-    constructor(name, scope, type, alias, array, required, value, children) {
+    constructor(name, scope, alias, meta, children, chain) {
         this.name = name;
         this.scope = scope;
-        this.type = type;
         this.alias = alias;
-        this.array = array;
-        this.required = required;
-        this.value = value;
+        this.meta = meta;
         this.children = children;
+        this.chain = chain;
         this.$t = 'bucket.view.field';
     }
 }

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

@@ -1,4 +1,4 @@
-import { $BucketViewField, $BucketViewFieldFn, $BucketViewFieldValue, $BucketViewFields, $BucketViews } from './bucket_view.schema';
+import { $BucketViewField, $BucketViewFieldFn, $BucketViewFieldMeta, $BucketViewFields, $BucketViews } from './bucket_view.schema';
 import { $Module, $Space, ViewObj } from "../../../../schema";
 import { $BucketModel } from '../model/bucket_model.schema';
 import { $BucketGraph } from '../graph/bucket_graph.schema';
@@ -8,8 +8,8 @@ import { $BucketViewFieldBuilderInfer } from '../bucket.infer';
 import { TrxNode } from "../../../../engine/transaction/trx_node";
 import { NesoiFile } from "../../../../engine/data/file";
 type DriveFieldpath<Bucket extends $Bucket> = {
-    [K in keyof Bucket['#fieldpath']]: NonNullable<Bucket['#fieldpath'][K]> extends NesoiFile ? K : never;
-}[keyof Bucket['#fieldpath']];
+    [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;
 /**
@@ -19,10 +19,12 @@ type ComputedData<Fn extends $BucketViewFieldFn<any, any>, R = ReturnType<Fn>> =
 export declare class BucketViewFieldFactory<Space extends $Space, Module extends $Module, Bucket extends $Bucket> {
     private _view;
     protected scope: $BucketViewField['scope'];
-    protected type: $BucketViewField['type'];
-    protected value: $BucketViewField['value'];
+    protected value: $BucketViewField['meta'];
     constructor(_view: BucketViewBuilder<any, any, any>);
-    model<K extends keyof Bucket['#fieldpath'], Extra extends BucketViewFieldBuilderTree>(key: K, extra?: Extra): BucketViewFieldBuilder<Bucket["#fieldpath"][K], "model", never>;
+    raw(): {
+        [K in keyof Bucket['#data']]: BucketViewFieldBuilder<Bucket['#data'][K], 'model'>;
+    };
+    model<K extends keyof Bucket['#modelpath'], SubModel extends BucketViewFieldBuilderTree>(path: K, submodel?: SubModel): BucketViewFieldBuilder<Bucket["#modelpath"][K], "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>;
@@ -36,12 +38,14 @@ export declare class BucketViewFieldFactory<Space extends $Space, Module extends
  * */
 export declare class BucketViewFieldBuilder<Data, Scope extends $BucketViewField['scope'], GraphLink extends string = never> {
     protected scope: $BucketViewField['scope'];
-    protected value: $BucketViewFieldValue;
-    protected extra?: BucketViewFieldBuilderTree | undefined;
-    protected type: $BucketViewField['type'];
-    constructor(scope: $BucketViewField['scope'], value: $BucketViewFieldValue, extra?: BucketViewFieldBuilderTree | undefined);
-    static build(builder: BucketViewFieldBuilder<any, any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, name: string): $BucketViewField;
-    static buildFields(fields: BucketViewFieldBuilderTree, model: $BucketModel, graph: $BucketGraph, views: $BucketViews): $BucketViewFields;
+    protected meta: $BucketViewFieldMeta;
+    protected submodel?: BucketViewFieldBuilderTree | undefined;
+    $b: "view.field";
+    protected _chain?: BucketViewFieldBuilder<any, any, any>;
+    constructor(scope: $BucketViewField['scope'], meta: $BucketViewFieldMeta, submodel?: BucketViewFieldBuilderTree | 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: BucketViewFieldBuilderTree, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, n_indexes?: number): $BucketViewFields;
 }
 export type BucketViewFieldBuilderTree = {
     [x: string]: BucketViewFieldBuilder<any, any, any> | BucketViewFieldBuilderTree;

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

@@ -4,7 +4,6 @@ exports.BucketViewFieldBuilder = exports.BucketViewFieldFactory = void 0;
 const error_1 = require("../../../../engine/data/error");
 const bucket_view_schema_1 = require("./bucket_view.schema");
 const bucket_model_schema_1 = require("../model/bucket_model.schema");
-const bucket_model_convert_1 = require("../model/bucket_model.convert");
 /*
     Factory
 */
@@ -16,12 +15,17 @@ class BucketViewFieldFactory {
     constructor(_view) {
         this._view = _view;
     }
-    model(key, extra) {
+    raw() {
+        return {
+            __raw: {}
+        };
+    }
+    model(path, submodel) {
         return new BucketViewFieldBuilder('model', {
             model: {
-                key: key.replace(/\.__dict/g, '')
+                path: path
             }
-        }, extra);
+        }, submodel);
     }
     computed(fn) {
         return new BucketViewFieldBuilder('computed', {
@@ -59,7 +63,7 @@ class BucketViewFieldFactory {
         };
     }
     static group(name, children) {
-        return new bucket_view_schema_1.$BucketViewField(name, 'group', 'obj', name, false, true, { group: {} }, children);
+        return new bucket_view_schema_1.$BucketViewField(name, 'group', name, {}, children);
     }
 }
 exports.BucketViewFieldFactory = BucketViewFieldFactory;
@@ -71,59 +75,67 @@ exports.BucketViewFieldFactory = BucketViewFieldFactory;
  * @subcategory Entity
  * */
 class BucketViewFieldBuilder {
-    constructor(scope, value, extra) {
+    constructor(scope, meta, submodel) {
         this.scope = scope;
-        this.value = value;
-        this.extra = extra;
-        this.type = 'unknown';
-        this.type = 'unknown';
+        this.meta = meta;
+        this.submodel = submodel;
+        this.$b = 'view.field';
+    }
+    chain(fn) {
+        this._chain = new BucketViewFieldBuilder('computed', {
+            computed: {
+                fn: fn
+            }
+        });
     }
     // Build
-    static build(builder, model, graph, views, name) {
-        let type = 'unknown';
-        let array = 'unknown';
-        let required = true;
+    static build(builder, model, graph, views, name, n_indexes) {
         let children = undefined;
+        const chain = builder._chain;
         if (builder.scope === 'model') {
-            const modelField = bucket_model_schema_1.$BucketModel.get(model, builder.value.model.key);
-            if (!modelField) {
-                throw error_1.NesoiError.Builder.Bucket.UnknownModelField(builder.value.model.key);
+            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 \'*\'');
             }
-            type = modelField.type;
-            array = builder.value.model.key.endsWith('.#') || modelField.array;
-            required = modelField.required;
-            if (modelField.meta?.enum) {
-                builder.value.model.enumOptions = modelField.meta.enum.options;
+            // 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(`Maximum index allowed: $${n_indexes - 1}`);
             }
-            if (modelField.children) {
-                const path = builder.value.model.key + ((modelField.array || modelField.type === 'dict') ? '.#' : '');
-                const fromModel = (0, bucket_model_convert_1.convertToView)(model, '', modelField.children, path).fields;
-                children = Object.assign({}, fromModel);
+            // Retrieve one or more BucketModelFields referenced by a modelpath.
+            // (It's only more than one when using unions)
+            // The field itself is not used, but serves to validate that the modelpath exists.
+            const modelFields = bucket_model_schema_1.$BucketModel.getField(model, path);
+            if (!modelFields.length) {
+                throw error_1.NesoiError.Builder.Bucket.UnknownModelField(builder.meta.model.path);
             }
-            if (builder.extra) {
-                const extra = this.buildFields(builder.extra, model, graph, views);
-                children = Object.assign({}, children, extra);
+            // 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.value.graph.link ? graph.links[builder.value.graph.link] : undefined;
+            const graphLink = builder.meta.graph.link ? graph.links[builder.meta.graph.link] : undefined;
             if (!graphLink) {
-                throw error_1.NesoiError.Builder.Bucket.UnknownGraphLink(builder.value.graph.link || '');
+                throw error_1.NesoiError.Builder.Bucket.UnknownGraphLink(builder.meta.graph.link || '');
             }
-            array = graphLink.many;
         }
         else if (builder.scope === 'view') {
-            const view = builder.value.view?.view ? views[builder.value.view?.view] : undefined;
+            const view = builder.meta.view?.view ? views[builder.meta.view?.view] : undefined;
             if (!view) {
-                throw error_1.NesoiError.Builder.Bucket.UnknownViewName(builder.value.view?.view || '');
+                throw error_1.NesoiError.Builder.Bucket.UnknownViewName(builder.meta.view?.view || '');
             }
-            type = 'obj';
-            array = false;
             children = view.fields;
         }
-        return new bucket_view_schema_1.$BucketViewField(name, builder.scope, type, name, array, required, builder.value, children);
+        return new bucket_view_schema_1.$BucketViewField(name, builder.scope, name, builder.meta, children, chain);
     }
-    static buildFields(fields, model, graph, views) {
+    static buildFields(fields, model, graph, views, n_indexes = 0) {
         const schema = {};
         // Extended fields inherit from other views
         if ('__ext' in fields) {
@@ -134,15 +146,18 @@ class BucketViewFieldBuilder {
             if (f === '__ext') {
                 continue;
             }
+            if (f === '__raw') {
+                schema['__raw'] = {};
+            }
             const field = fields[f];
             // Normal fields are built here
             if (field instanceof BucketViewFieldBuilder) {
-                schema[f] = BucketViewFieldBuilder.build(field, model, graph, views, f);
+                schema[f] = BucketViewFieldBuilder.build(field, model, graph, views, f, n_indexes);
             }
             // Builders are allowed to implicitly declare nested fields.
             // The code below transforms these groups into fields of the scope 'group'.
             else {
-                const children = BucketViewFieldBuilder.buildFields(field, model, graph, views);
+                const children = BucketViewFieldBuilder.buildFields(field, model, graph, views, n_indexes);
                 schema[f] = BucketViewFieldFactory.group(f, children);
             }
         }