nesoi 3.0.0

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

@@ -0,0 +1,620 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NQL_CompiledQuery = exports.NQL_Compiler = exports.NQL_RuleTree = void 0;
+const bucket_model_schema_1 = require("../model/bucket_model.schema");
+const string_1 = require("../../../../engine/util/string");
+const bucket_1 = require("../bucket");
+class NQL_RuleTree {
+    constructor(module, bucketName, query, debug = false) {
+        this.module = module;
+        this.bucketName = bucketName;
+        this.query = query;
+        this.debug = debug;
+        const bucket = module.buckets[this.bucketName];
+        this.root = this.parseUnion(bucket, query);
+        if (debug) {
+            console.log(this.describe());
+        }
+        this.simplify();
+        this._addDebugId();
+        if (debug) {
+            console.log(this.describe());
+        }
+    }
+    // Parse NQL
+    parseUnion(bucket, query, select) {
+        const meta = bucket_1.Bucket.getQueryMeta(bucket);
+        const union = {
+            meta: {
+                ...meta,
+                avgTime: 0
+            },
+            inters: [
+                { meta: {}, rules: [] }
+            ]
+        };
+        for (const key in query) {
+            const value = query[key];
+            const parsedKey = this.parseKey(bucket, key);
+            // Fieldpath term -> Condition
+            if (parsedKey.type === 'fieldpath') {
+                const parsed = this.parseValue(value, parsedKey, meta, select);
+                const rule = ('subquery' in parsed)
+                    ? parsed.subquery
+                    : {
+                        meta: { ...meta },
+                        select,
+                        fieldpath: parsedKey.fieldpath,
+                        value: parsed,
+                        op: parsedKey.op,
+                        case_i: parsedKey.case_i,
+                        not: parsedKey.not
+                    };
+                // console.log({ parsedKey, parsed, rule })
+                if (!parsedKey.or) {
+                    union.inters[0].rules.push(rule);
+                }
+                else {
+                    union.inters.push({ meta: {}, rules: [rule] });
+                }
+            }
+            // TODO: Pre-parse graph link into subquery
+            // Graph Link term -> Condition
+            // else if (parsedKey.type === 'graphlink') {
+            //     parsedValue = this.parseExpression(parsedKey.linkBucket!, value)
+            // }
+            else if (parsedKey.type === 'and') {
+                const subInter = this.parseUnion(bucket, value, select);
+                union.inters[0].rules.push(subInter);
+            }
+            else if (parsedKey.type === 'or') {
+                const subInter = this.parseUnion(bucket, value, select);
+                union.inters.push({ meta: {}, rules: [subInter] });
+            }
+            else if (parsedKey.type === 'order') {
+                union.order = this.parseOrder(bucket, value);
+            }
+        }
+        if (!union.inters[0]?.rules.length) {
+            union.inters.splice(0, 1);
+        }
+        return union;
+    }
+    parseOrder(bucket, value) {
+        let by = value['by'];
+        if (by) {
+            const field = bucket_model_schema_1.$BucketModel.get(bucket.schema.model, by);
+            if (!field) {
+                throw new Error(`Field '${by}' not found on bucket '${bucket.schema.name}'`);
+            }
+            if (![
+                'date', 'datetime', 'decimal', 'enum', 'float', 'int', 'string'
+            ].includes(field.type)) {
+                throw new Error(`Field '${by}' is not sortable`);
+            }
+        }
+        else {
+            by = 'id';
+        }
+        let dir = value['dir'];
+        if (dir) {
+            if (dir !== 'asc' && dir !== 'desc') {
+                throw new Error(`Invalid query order direction '${dir}', expected 'asc'|'desc'`);
+            }
+        }
+        else {
+            dir = 'desc';
+        }
+        return { by, dir };
+    }
+    parseKey(bucket, key) {
+        if (key === '#order') {
+            return { type: 'order' };
+        }
+        else if (key.startsWith('#and')) {
+            return { type: 'and' };
+        }
+        else if (key.startsWith('#or')) {
+            return { type: 'or' };
+        }
+        else if (key.startsWith('*')) {
+            const linkName = key.slice(1);
+            const link = bucket.schema.graph.links[linkName];
+            if (!link) {
+                throw new Error(`Graph Link '${link}' doesn't exist on the bucket ${bucket}`);
+            }
+            const linkBucket = this.module.buckets[link.bucket.refName].schema;
+            if (!linkBucket) {
+                throw new Error(`Graph Link '${link}' points to a bucket '${link.bucket}' not found on the module ${this.module.name}`);
+            }
+            return { type: 'graphlink', link: link.name, linkBucket };
+        }
+        else {
+            const term = key.match(/^(or )?([\w|.|*]+)( not)? ?(~)?(.*)$/);
+            if (!term) {
+                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) {
+                throw new Error(`Field '${fieldpath}' not found on bucket '${bucket.schema.name}'`);
+            }
+            const _op = this.parseOp(bucket.schema.name, field, op);
+            return { type: 'fieldpath', or: !!or, fieldpath, not: !!not, case_i: !!case_i, op: _op };
+        }
+    }
+    parseOp(bucketName, field, 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}'`);
+        }
+        return _op;
+    }
+    parseValue(value, parsedKey, meta, select) {
+        if (typeof value === 'object') {
+            // Array
+            if (Array.isArray(value)) {
+                const statyc = [];
+                const params = [];
+                for (const item of value) {
+                    const parsed = this.parseValue(item, parsedKey, meta, select);
+                    if ('static' in parsed) {
+                        statyc.push(parsed.static);
+                    }
+                    else if ('param' in parsed) {
+                        params.push(parsed.param);
+                    }
+                    else if ('subquery' in parsed) {
+                        throw new Error(`Subqueries not accepted inside array value [${value}]`);
+                    }
+                }
+                if (statyc.length > 0 && params.length > 0) {
+                    throw new Error(`Cannot mix static and parameter values inside array value [${value}]`);
+                }
+                if (params.length > 0) {
+                    return { param: params };
+                }
+                else {
+                    return { static: statyc };
+                }
+            }
+            else {
+                // Parameter
+                if ('.' in value) {
+                    return { param: value['.'] };
+                }
+                // Sub-Query
+                return { subquery: this.parseSubQuery(value, parsedKey, meta, select) };
+            }
+        }
+        // Static value
+        else {
+            return { static: value };
+        }
+    }
+    parseSubQuery(value, parsedKey, meta, select) {
+        const union = {
+            meta: {},
+            inters: [
+                { meta: {}, rules: [] }
+            ]
+        };
+        for (const key in value) {
+            if (key.startsWith('@') || key.startsWith('or @')) {
+                const refField = key.match(/(or )?@(\w+)\.(.*)/);
+                if (!refField) {
+                    throw new Error(`Invalid bucket field '${key}'`);
+                }
+                const [_, or, refBucket, fieldpath] = refField;
+                const bucket = this.module.buckets[refBucket];
+                if (!bucket) {
+                    throw new Error(`Bucket '${bucket}' not found on module`);
+                }
+                const field = bucket_model_schema_1.$BucketModel.get(bucket.schema.model, fieldpath);
+                if (!field) {
+                    throw new Error(`Field '${fieldpath}' not found on bucket '${bucket.schema.name}'`);
+                }
+                const refInter = this.parseUnion(bucket, value[key], fieldpath);
+                const rule = {
+                    meta: { ...meta },
+                    select,
+                    fieldpath: parsedKey.fieldpath,
+                    case_i: parsedKey.case_i,
+                    not: parsedKey.not,
+                    op: parsedKey.op,
+                    value: {
+                        subquery: refInter
+                    }
+                };
+                if (!or) {
+                    union.inters[0].rules.push(rule);
+                }
+                else {
+                    union.inters.push({ meta: {}, rules: [rule] });
+                }
+            }
+        }
+        if (!union.inters[0]?.rules.length) {
+            union.inters.splice(0, 1);
+        }
+        // // Regroup inter rules by scope
+        // // Also, transfer "select" from subquery to scope rule
+        // for (const inter of union.inters) {
+        //     const rulesByScope: Record<string, NQL_Rule[]> = {}
+        //     for (const rule of inter.rules) {
+        //         const union = (rule as any).value.subquery as NQL_Union;
+        //         rulesByScope[union.meta.scope!] ??= []
+        //         rulesByScope[union.meta.scope!].push(rule as NQL_Rule);
+        //     }
+        //     inter.rules = Object.values(rulesByScope).map(rules => {
+        //         const rule = rules[0];
+        //         return {
+        //             ...rule,
+        //             value: {
+        //                 subquery: {
+        //                     meta: { ...(rule.value as any).subquery.meta },
+        //                     inters: rules.map(c =>
+        //                         (c.value as any).subquery.inters
+        //                     ).flat(1)
+        //                 }
+        //             }
+        //         }
+        //     })
+        // }
+        return union;
+    }
+    // Cleanup
+    /**
+     * Depth-first search on the tree:
+     * - Collapses single-child Unions
+     * - Accumulate avgTime over tree nodes, for building multi-tree
+     */
+    simplify() {
+        const stack = [[this.root, -1]];
+        while (stack.length) {
+            const node = stack.at(-1);
+            const parent = stack.at(-2);
+            // Union
+            if ('inters' in node[0]) {
+                // Union has a single child and a parent, should be collapsed
+                if (node[0].inters.length == 1 && parent) {
+                    // Parent is a Intersection
+                    if ('rules' in parent[0]) {
+                        const inter = node[0].inters[0];
+                        parent[0].rules.splice(parent[1], 1, ...inter.rules);
+                        stack.pop();
+                        stack.push([inter, -1]);
+                        continue;
+                    }
+                }
+                // Iterate
+                node[1]++;
+                const next = node[0].inters[node[1]];
+                if (next)
+                    stack.push([next, -1]);
+                else {
+                    if (parent) {
+                        // Add union time to parent
+                        parent[0].meta.avgTime = (parent[0].meta.avgTime || 0) + node[0].meta.avgTime;
+                    }
+                    stack.pop();
+                }
+                continue;
+            }
+            // Intersection
+            else if ('rules' in node[0]) {
+                // Iterate
+                node[1]++;
+                const next = node[0].rules[node[1]];
+                if (next)
+                    stack.push([next, -1]);
+                else {
+                    // Add inter time to union
+                    parent[0].meta.avgTime = (parent[0].meta.avgTime || 0) + node[0].meta.avgTime;
+                    stack.pop();
+                }
+                continue;
+            }
+            // Rule
+            else {
+                // Iterate
+                if ('subquery' in node[0].value && node[1] < 0) {
+                    node[1]++;
+                    const next = node[0].value.subquery;
+                    stack.push([next, -1]);
+                }
+                else {
+                    // Add rule time to inter
+                    parent[0].meta.avgTime = (parent[0].meta.avgTime || 0) + node[0].meta.avgTime;
+                    stack.pop();
+                }
+                continue;
+            }
+        }
+    }
+    // Pretty Print
+    _addDebugId() {
+        let id = 0;
+        const addIndex = (node) => {
+            node._debug_id = id++;
+            if ('inters' in node) {
+                node.inters.forEach(inter => {
+                    addIndex(inter);
+                });
+            }
+            else if ('rules' in node) {
+                node.rules.forEach(rule => {
+                    addIndex(rule);
+                });
+            }
+            else if ('value' in node) {
+                if ('subquery' in node.value) {
+                    addIndex(node.value['subquery']);
+                }
+            }
+        };
+        addIndex(this.root);
+    }
+    describeNQL() {
+        let str = '';
+        str += (0, string_1.colored)('◆ NQL:\n', 'lightblue');
+        str += (0, string_1.colored)(JSON.stringify(this.query, undefined, 2), 'darkgray');
+        return str;
+    }
+    describe() {
+        return NQL_RuleTree.describe(this.root);
+    }
+    static describe(node, d = 0) {
+        let str = '';
+        // Union
+        if ('inters' in node) {
+            str += Array(d).fill('  ').join('')
+                + (0, string_1.colored)(`└ ${node._debug_id || ''}[OR] `, 'lightpurple')
+                + (0, string_1.colored)(`${node.meta.scope || ''} ${node.meta.avgTime || '?'}ms `, 'black')
+                + (node.order ? ` order by ${node.order.by} ${node.order.dir}` : '')
+                + '\n';
+            node.inters.forEach(inter => {
+                str += this.describe(inter, d + 1);
+            });
+        }
+        // Intersection
+        else if ('rules' in node) {
+            str += Array(d).fill('  ').join('')
+                + (0, string_1.colored)(`└ ${node._debug_id || ''}[AND] `, 'lightblue')
+                + (0, string_1.colored)(`${node.meta.scope || ''} ${node.meta.avgTime || '?'}ms `, 'black')
+                + '\n';
+            node.rules.forEach(rule => {
+                str += this.describe(rule, d + 1);
+            });
+        }
+        // Rule
+        else if ('value' in node) {
+            str += Array(d).fill('  ').join('')
+                + (0, string_1.colored)(`└ ${node._debug_id || ''}[if] `, 'lightcyan')
+                + (0, string_1.colored)(node.select ? '(⊹ ' + node.select + ') ' : '', 'brown')
+                + (0, string_1.colored)(`${node.meta.scope || ''} ${node.meta.avgTime || '?'}ms `, 'black')
+                + `@${node.meta.bucket?.name}.${node.fieldpath}${node.not ? ' not' : ''} ${node.case_i ? '~' : ''}${node.op}`
+                + (('static' in node.value) ? ` ${node.value.static}`
+                    : ('param' in node.value) ? ` ->${node.value.param}`
+                        : ' ▼')
+                + '\n';
+            if ('subquery' in node.value) {
+                str += this.describe(node.value['subquery'], d + 1);
+            }
+        }
+        return str;
+    }
+}
+exports.NQL_RuleTree = NQL_RuleTree;
+NQL_RuleTree.OpByType = {
+    'boolean': ['==', 'in', 'present'],
+    'date': ['<', '<=', '==', '>', '>=', 'in', 'present'],
+    'datetime': ['<', '<=', '==', '>', '>=', 'in', 'present'],
+    'decimal': ['<', '<=', '==', '>', '>=', 'in', 'present'],
+    'dict': ['==', 'contains', 'contains_any', 'in', 'present'],
+    'enum': ['==', 'contains', 'contains_any', 'in', 'present'],
+    'file': [],
+    'float': ['<', '<=', '==', '>', '>=', 'in', 'present'],
+    'int': ['<', '<=', '==', '>', '>=', 'in', 'present'],
+    'obj': ['==', 'contains', 'contains_any', 'in', 'present'],
+    'string': ['==', 'contains', 'contains_any', 'in', 'present'],
+    'unknown': ['present']
+};
+/**
+ * Builds a NQL_CompiledQuery by splitting it into multiple parts
+ */
+class NQL_Compiler {
+    static build(module, bucketName, query) {
+        const tree = new NQL_RuleTree(module, bucketName, query);
+        return this.buildUnion(tree.root);
+    }
+    static buildUnion(union) {
+        // const debugLog: string[] = [];
+        // Create top-level part
+        const parts = [{
+                i: 0,
+                many: true,
+                union: {}
+            }];
+        const orderedParts = [];
+        // Stacks used on process
+        const stack = [[union, -1]];
+        const buildStack = [parts[0].union];
+        const partStack = [parts[0]];
+        // Sort union children by avgTime before iterating
+        union.inters.sort((a, b) => a.meta.avgTime - b.meta.avgTime);
+        while (stack.length) {
+            const node = stack.at(-1);
+            // debugLog.push('⇢ ' + node[0]._debug_id);
+            // Union
+            if ('inters' in node[0]) {
+                const union = node[0];
+                // Rebuild union
+                const buildNode = buildStack.at(-1);
+                if (node[1] < 0) {
+                    const build = {
+                        ...union,
+                        inters: Array.from(Array(union.inters.length), _ => ({}))
+                    };
+                    Object.assign(buildNode, build);
+                }
+                // Iterate inter
+                node[1]++;
+                const next = union.inters[node[1]];
+                const buildNext = buildNode.inters[node[1]];
+                if (next) {
+                    // Sort union children by avgTime before iterating
+                    next.rules.sort((a, b) => a.meta.avgTime - b.meta.avgTime);
+                    // Union → Intersection
+                    stack.push([next, -1]);
+                    buildStack.push(buildNext);
+                    continue;
+                }
+            }
+            // Intersection
+            else if ('rules' in node[0]) {
+                const inter = node[0];
+                // Rebuild inter
+                const buildNode = buildStack.at(-1);
+                if (node[1] < 0) {
+                    const build = {
+                        ...inter,
+                        rules: Array.from(Array(inter.rules.length), _ => ({}))
+                    };
+                    Object.assign(buildNode, build);
+                }
+                // Iterate
+                node[1]++;
+                const next = inter.rules[node[1]];
+                const buildNext = buildNode.rules[node[1]];
+                if (next) {
+                    // Sort children by avgTime before iterating
+                    if ('value' in next) {
+                        if ('subquery' in next.value) {
+                            next.value.subquery.inters.sort((a, b) => a.meta.avgTime - b.meta.avgTime);
+                        }
+                    }
+                    else {
+                        next.inters.sort((a, b) => a.meta.avgTime - b.meta.avgTime);
+                    }
+                    // Intersection → Condition
+                    stack.push([next, -1]);
+                    buildStack.push(buildNext);
+                    continue;
+                }
+            }
+            // Rule
+            else {
+                const rule = node[0];
+                const buildNode = buildStack.at(-1);
+                // Divergent Scope: A subquery scope doesn't match the
+                // rule scope, create new Part and Replace with Parameter
+                if (node[1] < 0 && 'subquery' in rule.value) {
+                    const union = rule.value.subquery;
+                    if (rule.meta.scope !== union.meta.scope) {
+                        // Start new Part
+                        const newPart = {
+                            i: parts.length,
+                            many: (rule.op === 'in' || rule.op === 'contains_any'),
+                            union: {
+                                ...union,
+                                inters: Array.from(Array(union.inters.length), _ => ({}))
+                            },
+                            parent: partStack.at(-1)
+                        };
+                        // debugLog.push('+ [part] ' + newPart.i);
+                        parts.push(newPart);
+                        partStack.push(newPart);
+                        // Make part the one being built
+                        Object.assign(buildNode, {
+                            ...rule,
+                            value: { subquery: newPart.union }
+                        });
+                        // Add part to original rule, to remove it
+                        // from the stack once we're done (&1)
+                        rule.part = newPart.i;
+                        // Also add part to built rule, for easier reference
+                        // when running.
+                        buildNode.part = newPart.i;
+                    }
+                }
+                // Rebuild rule, if not a divergent scope
+                let rebuild = undefined;
+                if (node[1] < 0 && !rule.part) {
+                    rebuild = {
+                        ...rule
+                    };
+                    if ('subquery' in rebuild.value) {
+                        rebuild.value = { subquery: {} };
+                    }
+                    Object.assign(buildNode, rebuild);
+                }
+                // Iterate
+                if ('subquery' in rule.value && node[1] < 0) {
+                    node[1]++;
+                    const next = rule.value.subquery;
+                    const secNext = buildNode.value?.subquery;
+                    // Sort children by avgTime before iterating
+                    next.inters.sort((a, b) => a.meta.avgTime - b.meta.avgTime);
+                    // Rule → Union
+                    stack.push([next, -1]);
+                    buildStack.push(secNext);
+                    continue;
+                }
+                else {
+                    // Close part (&1)
+                    if (rule.part) {
+                        // Rebuild Union on original tree as Condition
+                        buildNode.value = { param: `%__${rule.part}__%` };
+                        if (rule.part == partStack.at(-1).i) {
+                            // debugLog.push('⊙ [part] ' + rule.part);
+                            orderedParts.push(parts[rule.part]);
+                            partStack.pop();
+                        }
+                    }
+                }
+            }
+            stack.pop();
+            buildStack.pop();
+            // debugLog.push('↑ ' + node[0]._debug_id);
+        }
+        return new NQL_CompiledQuery([...orderedParts, parts[0]]);
+    }
+}
+exports.NQL_Compiler = NQL_Compiler;
+/**
+ * A query ready to be run by the NQL engine, which will call
+ * each NQLRunner with a different adapter
+ */
+class NQL_CompiledQuery {
+    constructor(parts) {
+        this.parts = {};
+        this.execOrder = [];
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            this.execOrder.push(part.i);
+            this.parts[part.i] = part;
+        }
+    }
+    // Pretty Print   
+    describe() {
+        let str = '';
+        for (let i = 0; i < this.execOrder.length; i++) {
+            const part = this.parts[this.execOrder[i]];
+            str += (0, string_1.colored)(`- Part ${part.i}\n`, 'lightpurple');
+            str += (0, string_1.colored)(part.many ? 'many ' : 'one ', 'green');
+            str += part.parent ? (0, string_1.colored)(`[child of ${part.parent.i}]\n`, 'brown') : '\n';
+            str += NQL_RuleTree.describe(part.union);
+            str += '\n';
+        }
+        return str;
+    }
+}
+exports.NQL_CompiledQuery = NQL_CompiledQuery;

package/lib/elements/entities/bucket/query/nql_engine.d.ts

@@ -0,0 +1,16 @@
+import { AnyModule } from "../../../../engine/module";
+import { NQL_CompiledQuery } from './nql_compiler';
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+import { NQL_Part } from './nql.schema';
+type Obj = Record<string, any>;
+type Objs = Record<string, Obj>;
+export declare abstract class NQLRunner {
+    abstract run(trx: AnyTrxNode, part: NQL_Part, params: Record<string, any>): Promise<Objs>;
+}
+export declare class NQL_Engine {
+    private module;
+    private runners;
+    constructor(module: AnyModule);
+    run(trx: AnyTrxNode, query: NQL_CompiledQuery, params?: Record<string, any>): Promise<Obj[]>;
+}
+export {};

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NQL_Engine = exports.NQLRunner = void 0;
+const bucket_1 = require("../bucket");
+class NQLRunner {
+}
+exports.NQLRunner = NQLRunner;
+class NQL_Engine {
+    constructor(module) {
+        this.module = module;
+        this.runners = {};
+        for (const b in module.buckets) {
+            const bucket = module.buckets[b];
+            const meta = bucket_1.Bucket.getQueryMeta(bucket);
+            if (!(meta.scope in this.runners)) {
+                this.runners[meta.scope] = bucket_1.Bucket.getQueryRunner(bucket);
+            }
+        }
+    }
+    async run(trx, query, params = {}) {
+        let data = [];
+        for (let i = 0; i < query.execOrder.length; i++) {
+            const part_i = query.execOrder[i];
+            const part = query.parts[part_i];
+            // Run part
+            const runner = this.runners[part.union.meta.scope];
+            const out = await runner.run(trx, part, params);
+            data = Object.values(out);
+            // Part failed, return
+            // Failure here is only when a single value is expected,
+            if (!part.many) {
+                if (data.length === 0) {
+                    return [];
+                }
+            }
+            // Fill part params
+            params[`%__${part_i}__%`] = part.many ? data : data[0];
+        }
+        return data;
+    }
+}
+exports.NQL_Engine = NQL_Engine;

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

@@ -0,0 +1,14 @@
+import { $BucketView, $BucketViews } from './bucket_view.schema';
+import { $BucketModel } from '../model/bucket_model.schema';
+import { $BucketGraph } from '../graph/bucket_graph.schema';
+import { BucketViewFieldBuilderTree, BucketViewFieldFactory } from './bucket_view_field.builder';
+import { $Bucket } from '../bucket.schema';
+import { $Module, $Space } from "../../..";
+export declare class BucketViewBuilder<Space extends $Space, Module extends $Module, Bucket extends $Bucket> {
+    private name;
+    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;
+}
+export type BucketViewDef<Space extends $Space, Module extends $Module, Bucket extends $Bucket> = ($: BucketViewFieldFactory<Space, Module, Bucket>) => BucketViewFieldBuilderTree;