nesoi 3.0.21 → 3.1.1

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

@@ -2,6 +2,7 @@ import { $Bucket } from '../bucket.schema';
 import { $Module } from "../../../../schema";
 import { NesoiDate } from "../../../../engine/data/date";
 import { NesoiDatetime } from "../../../../engine/data/datetime";
+import { NesoiDuration } from "../../../../engine/data/duration";
 export type NQL_QueryMeta = {
     bucket?: $Bucket;
     scope?: string;
@@ -49,8 +50,8 @@ export type NQL_Node = NQL_Union | NQL_Intersection | NQL_Rule;
  * All operations
  */
 export type NQL_Operation = '==' | '>' | '<' | '>=' | '<=' | 'in' | 'contains' | 'contains_any' | 'present';
-export type NQL_Order<Fieldpath> = {
-    by?: keyof Fieldpath[];
+export type NQL_Order<Querypath> = {
+    by?: (keyof Querypath)[];
     dir?: ('asc' | 'desc')[];
 };
 export type NQL_Pagination = {
@@ -61,7 +62,7 @@ export type NQL_Pagination = {
 /**
  * A union of all operators which apply to the selected field
  */
-type NQL_OpFromField<T> = T extends boolean ? '' | ' ==' | ' in' | ' present' : T extends number | NesoiDate | NesoiDatetime ? '' | ' ==' | ' >' | ' <' | ' >=' | ' <=' | ' in' | ' present' : T extends string ? '' | ' ==' | ' in' | ' contains' | ' contains_any' | ' present' | ' ~' | ' ~in' | ' ~contains' | ' ~contains_any' : T extends boolean[] | number[] | NesoiDate[] | NesoiDatetime[] | string[] ? '' | ' ==' | ' in' | ' contains' | ' contains_any' | ' present' : T extends object ? ' contains' | ' contains_any' | ' present' : ' present';
+type NQL_OpFromField<T> = T extends boolean ? '' | ' ==' | ' in' | ' present' : T extends number | NesoiDate | NesoiDatetime | NesoiDuration ? '' | ' ==' | ' >' | ' <' | ' >=' | ' <=' | ' in' | ' present' : T extends string ? '' | ' ==' | ' in' | ' contains' | ' contains_any' | ' present' | ' ~' | ' ~in' | ' ~contains' | ' ~contains_any' : T extends object ? ' contains' | ' contains_any' | ' present' : ' present';
 /**
  * A dict of accepted values for a given operator on a bucket field
  */
@@ -92,13 +93,15 @@ type NQL_ConditionValue<T, Parameters, Titem = NoInfer<T extends (infer X)[] ? X
     '.': P;
 } | {
     '.': PArr;
-}[];
+}[] | {
+    '$': string;
+};
 /**
  * A field name of the subquery bucket which resolves to
  * a type that's compatible with the query
  */
-type NQL_SubQueryField<$ extends $Bucket, Field, Fieldpath = NoInfer<$['#fieldpath']>, T = NoInfer<Fieldpath[Field & keyof Fieldpath]>> = keyof {
-    [X in keyof Fieldpath as NonNullable<T> extends NonNullable<Fieldpath[X]> ? X : never]: any;
+type NQL_SubQueryField<$ extends $Bucket, Field, Querypath = NoInfer<$['#modelpath']>, T = NoInfer<Querypath[Field & keyof Querypath]>> = keyof {
+    [X in keyof Querypath as NonNullable<T> extends NonNullable<Querypath[X]> ? X : never]: any;
 };
 /**
  * A subquery passed as value to a query
@@ -120,14 +123,14 @@ type NQL_GraphLinks<M extends $Module, $ extends $Bucket, Parameters = {}> = {
     All possible query rules on the format:
     (or |)FIELDNAME( not|)OPERATOR
 */
-type NQL_Terms<M extends $Module, $ extends $Bucket, Parameters = {}, Fieldpath = NoInfer<$['#fieldpath']>, Conditions = NoInfer<{
-    [Field in keyof Fieldpath as Field]: {
-        [Op in NQL_OpFromField<Fieldpath[Field]> as `${'or ' | ''}${Field & string}${' not' | ''}${Op}`]?: NQL_ConditionValue<NQL_ValueFromOp<Fieldpath[Field]>[Op], Parameters> | NQL_SubQuery<M, Field, Parameters>;
+type NQL_Terms<M extends $Module, $ extends $Bucket, Parameters = {}, Querypath = NoInfer<$['#querypath']>, Conditions = NoInfer<{
+    [Field in keyof Querypath as Field]: {
+        [Op in NQL_OpFromField<Querypath[Field]> as `${'or ' | ''}${Field & string}${' not' | ''}${Op}`]?: NQL_ConditionValue<NQL_ValueFromOp<Querypath[Field]>[Op], Parameters> | NQL_SubQuery<M, Field, Parameters>;
     };
 }>> = Conditions[keyof Conditions] & {
     [K in `${'#and' | '#or'}${string}`]?: NQL_Terms<M, $, Parameters>;
 } & NQL_GraphLinks<M, $, Parameters> & {
-    '#order'?: NQL_Order<Fieldpath>;
+    '#order'?: NQL_Order<Querypath>;
 };
 /**
  * NQL Dynamic Query Type

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

@@ -86,14 +86,16 @@ class NQL_RuleTree {
         let by = value['by'];
         if (by) {
             for (const key of by) {
-                const field = bucket_model_schema_1.$BucketModel.get(bucket.schema.model, key);
-                if (!field) {
+                const fields = bucket_model_schema_1.$BucketModel.getField(bucket.schema.model, key);
+                if (!fields.length) {
                     throw new Error(`Field '${key}' not found on bucket '${bucket.schema.name}'`);
                 }
-                if (![
-                    'date', 'datetime', 'duration', 'decimal', 'enum', 'float', 'int', 'string'
-                ].includes(field.type)) {
-                    throw new Error(`Field '${key}' is not sortable`);
+                for (const field of fields) {
+                    if (![
+                        'date', 'datetime', 'duration', 'decimal', 'enum', 'float', 'int', 'string'
+                    ].includes(field.type)) {
+                        throw new Error(`Field '${key}' is not sortable`);
+                    }
                 }
             }
         }
@@ -141,25 +143,46 @@ class NQL_RuleTree {
                 throw new Error(`Invalid term '${key}'`);
             }
             const [_, or, fieldpath, not, case_i, op] = term;
-            const field = bucket_model_schema_1.$BucketModel.get(bucket.schema.model, fieldpath);
-            if (!field) {
+            const fields = bucket_model_schema_1.$BucketModel.getField(bucket.schema.model, fieldpath);
+            if (!fields.length) {
                 throw new Error(`Field '${fieldpath}' not found on bucket '${bucket.schema.name}'`);
             }
-            const _op = this.parseOp(bucket.schema.name, field, op);
+            const _op = this.parseOp(bucket.schema.name, fields, op);
             return { type: 'fieldpath', or: !!or, fieldpath, not: !!not, case_i: !!case_i, op: _op };
         }
     }
-    parseOp(bucketName, field, op) {
+    parseOp(bucketName, fields, op) {
         const _op = (op === '' ? '==' : op);
-        if (![
-            '==', '>', '<', '>=', '<=',
-            'in', 'contains', 'contains_any', 'present'
-        ].includes(_op)) {
-            throw new Error(`Invalid operation '${_op}' not found on bucket '${bucketName}'`);
-        }
-        const allowedOps = NQL_RuleTree.OpByType[field.type];
-        if (!allowedOps.includes(_op)) {
-            throw new Error(`Field '${field.name}' of type '${field.type}' doesn't support operation '${op}'`);
+        for (const field of fields) {
+            if (![
+                '==', '>', '<', '>=', '<=',
+                'in', 'contains', 'contains_any', 'present'
+            ].includes(_op)) {
+                throw new Error(`Invalid operation '${_op}'`);
+            }
+            let allowedOps;
+            // If field is a union, use the intersection of allowed operations
+            if (field.type === 'union') {
+                const children = Object.values(field.children);
+                const opsUnion = children
+                    .map(f => NQL_RuleTree.OpByType[f.type])
+                    .flat(1);
+                const dict = {};
+                for (const op of opsUnion) {
+                    dict[op] ?? (dict[op] = 0);
+                    dict[op]++;
+                }
+                allowedOps = Object.entries(dict)
+                    .filter(([k, v]) => v === children.length)
+                    .map(([k]) => k);
+            }
+            // If not, use the field allowed operations
+            else {
+                allowedOps = NQL_RuleTree.OpByType[field.type];
+            }
+            if (!allowedOps.includes(_op)) {
+                throw new Error(`Field '${field.name}' of type '${field.type}' doesn't support operation '${_op}'`);
+            }
         }
         return _op;
     }
@@ -223,7 +246,7 @@ class NQL_RuleTree {
                 if (!bucket) {
                     throw new Error(`Bucket '${bucket}' not found on module`);
                 }
-                const field = bucket_model_schema_1.$BucketModel.get(bucket.schema.model, fieldpath);
+                const field = bucket_model_schema_1.$BucketModel.getField(bucket.schema.model, fieldpath);
                 if (!field) {
                     throw new Error(`Field '${fieldpath}' not found on bucket '${bucket.schema.name}'`);
                 }
@@ -442,8 +465,10 @@ NQL_RuleTree.OpByType = {
     'file': [],
     'float': ['<', '<=', '==', '>', '>=', 'in', 'present'],
     'int': ['<', '<=', '==', '>', '>=', 'in', 'present'],
-    'obj': ['==', 'contains', 'contains_any', 'in', 'present'],
     'string': ['==', 'contains', 'contains_any', 'in', 'present'],
+    'obj': ['contains_any', 'in', 'present'],
+    'list': ['contains', 'contains_any', 'present'],
+    'union': [],
     'unknown': ['present']
 };
 /**

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

@@ -21,7 +21,7 @@ class BucketViewBuilder {
     static build(builder, model, graph, views) {
         const fields = bucket_view_field_builder_1.BucketViewFieldBuilder.buildFields(builder._fields, model, graph, views);
         const schema = new bucket_view_schema_1.$BucketView(builder.name, fields);
-        schema.fields.id = new bucket_view_schema_1.$BucketViewField('id', 'model', 'id', 'id', false, true, { model: { key: 'id' } });
+        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.d.ts

@@ -11,4 +11,23 @@ export declare class BucketView<$ extends $BucketView> {
     schema: $;
     constructor(bucket: Bucket<any, any>, schema: $);
     parse<Obj extends NesoiObj>(trx: AnyTrxNode, raw: Obj): Promise<$['#data']>;
+    private parseLayer;
+    /**
+     * [model]
+     * Read one property from
+     */
+    private parseModelProp;
+    private doParseModelProp;
+    /**
+     * [computed]
+     */
+    private parseComputedProp;
+    /**
+     * [graph]
+     */
+    private parseGraphProp;
+    /**
+     * [drive]
+     */
+    private parseDriveProp;
 }

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';
     }
 }