nesoi 3.0.0 → 3.0.3

package/lib/elements/entities/bucket/model/bucket_model.schema.js

@@ -2,24 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$BucketModel = exports.$BucketModelField = void 0;
 class $BucketModelField {
-    constructor(name, type, alias, array, required, _enum, defaultValue, children, or) {
+    constructor(name, path, type, alias, array, required, meta, defaultValue, children, or, crypto) {
         this.name = name;
+        this.path = path;
         this.type = type;
         this.alias = alias;
         this.array = array;
         this.required = required;
-        this._enum = _enum;
+        this.meta = meta;
         this.defaultValue = defaultValue;
         this.children = children;
         this.or = or;
+        this.crypto = crypto;
         this.$t = 'bucket.model.field';
     }
 }
 exports.$BucketModelField = $BucketModelField;
 class $BucketModel {
-    constructor(fields, defaults = {}) {
+    constructor(fields, defaults = {}, hasFileField = false, hasEncryptedField = false) {
         this.fields = fields;
         this.defaults = defaults;
+        this.hasFileField = hasFileField;
+        this.hasEncryptedField = hasEncryptedField;
         this.$t = 'bucket.model';
     }
     static get(model, fieldpath) {
@@ -27,7 +31,7 @@ class $BucketModel {
         let ref = model.fields;
         for (let i = 0; i < paths.length; i++) {
             const path = paths[i];
-            if (path === '*') {
+            if (path === '#') {
                 continue;
             }
             else {
@@ -43,5 +47,22 @@ class $BucketModel {
         }
         return ref;
     }
+    static fieldsOfType(model, type) {
+        const fields = [];
+        let poll = Object.values(model.fields);
+        while (poll.length) {
+            const next = [];
+            for (const field of poll) {
+                if (field.type === type) {
+                    fields.push(field);
+                }
+                if (field.children) {
+                    next.push(...Object.values(field.children));
+                }
+            }
+            poll = next;
+        }
+        return fields;
+    }
 }
 exports.$BucketModel = $BucketModel;

package/lib/elements/entities/bucket/model/bucket_model_field.builder.d.ts

@@ -2,10 +2,10 @@ import { $Module, $Space } from "../../../../schema";
 import { $BucketModelField, $BucketModelFieldType, $BucketModelFields } from './bucket_model.schema';
 import { NesoiDate } from "../../../../engine/data/date";
 import { BucketFieldpathObjInfer, BucketModelObjInfer } from './bucket_model.infer';
-import { $Dependency } from "../../../../engine/dependency";
 import { EnumFromName, EnumName } from '../../constants/constants.schema';
-import { Decimal } from "../../../../engine/data/decimal";
+import { NesoiDecimal } from "../../../../engine/data/decimal";
 import { NesoiDatetime } from "../../../../engine/data/datetime";
+import { NesoiFile } from "../../../../engine/data/file";
 export declare class BucketModelFieldFactory<Space extends $Space, Module extends $Module> {
     private module;
     constructor(module: string);
@@ -26,8 +26,8 @@ export declare class BucketModelFieldFactory<Space extends $Space, Module extend
     decimal(def?: {
         left?: number;
         right?: number;
-    }): BucketModelFieldBuilder<Module, Decimal, never, Decimal, {
-        '': Decimal;
+    }): BucketModelFieldBuilder<Module, NesoiDecimal, never, NesoiDecimal, {
+        '': NesoiDecimal;
     }>;
     enum<Enums extends EnumName<Space>, Options extends (keyof Enums & string) | (readonly string[])>(options: Options): BucketModelFieldBuilder<Module, Options extends string ? EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options], never, Options extends string ? EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options], {
         '': Options extends string ? EnumFromName<Space, Options>["#data"] : Options extends (infer X)[] | readonly (infer X)[] ? X : Options[keyof Options];
@@ -41,9 +41,17 @@ export declare class BucketModelFieldFactory<Space extends $Space, Module extend
     get string(): BucketModelFieldBuilder<Module, string, never, string, {
         '': string;
     }>;
+    /**
+     * An object with a specific set of child fields.
+     */
     obj<T extends BucketModelFieldBuilders<Module>>(fields?: T): BucketModelFieldBuilder<Module, BucketModelObjInfer<T>, never, BucketModelObjInfer<T>, {
         '': BucketModelObjInfer<T>;
     } & BucketFieldpathObjInfer<T, ".">>;
+    /**
+     * An object with an unknown number of child fields of a given type.
+     *
+     * - All child fields are optional. You can specify a default value.
+     */
     dict<T extends BucketModelFieldBuilder<Module, any>>(dictItem: T): BucketModelFieldBuilder<Module, Record<string, T extends BucketModelFieldBuilder<any, any, any, infer X, {
         '': infer X;
     }> ? X : never>, never, Record<string, T extends BucketModelFieldBuilder<any, any, any, infer X, {
@@ -54,7 +62,13 @@ export declare class BucketModelFieldFactory<Space extends $Space, Module extend
         }> ? X : never>;
     } & BucketFieldpathObjInfer<{
         '': T;
-    }, ".*">>;
+    }, ".#">>;
+    file(def?: {
+        extnames?: string[];
+        maxsize?: number;
+    }): BucketModelFieldBuilder<Module, NesoiFile, never, NesoiFile, {
+        '': NesoiFile;
+    }>;
 }
 export declare class BucketModelFieldBuilder<Module extends $Module, DefinedData, TypeAppend = never, Data = DefinedData | TypeAppend, Fieldpath = {
     '': Data;
@@ -62,16 +76,14 @@ export declare class BucketModelFieldBuilder<Module extends $Module, DefinedData
     private module;
     private type;
     private alias?;
-    private _enum?;
+    private meta?;
     private children?;
     private _array;
     private _required;
     private _defaultValue?;
     private _or?;
-    constructor(module: string, type: $BucketModelFieldType, alias?: string | undefined, _enum?: {
-        options: string | string[];
-        dep?: $Dependency;
-    } | undefined, children?: BucketModelFieldBuilders<Module> | undefined);
+    private crypto?;
+    constructor(module: string, type: $BucketModelFieldType, alias?: string | undefined, meta?: $BucketModelField['meta'], children?: BucketModelFieldBuilders<Module> | undefined);
     as(alias: string): this;
     /**
      * This field can be `undefined`.
@@ -84,9 +96,9 @@ export declare class BucketModelFieldBuilder<Module extends $Module, DefinedData
      * resource method, this value is used if undefined is passed.
      */
     default(defaultValue: DefinedData): BucketModelFieldBuilder<Module, DefinedData, never, DefinedData, Fieldpath>;
-    get array(): BucketModelFieldBuilder<Module, DefinedData[], TypeAppend, DefinedData[] | TypeAppend, { [K in Exclude<keyof Fieldpath, ""> as `.*${K & string}`]: Fieldpath[K]; } & {
+    get array(): BucketModelFieldBuilder<Module, DefinedData[], TypeAppend, DefinedData[] | TypeAppend, { [K in Exclude<keyof Fieldpath, ""> as `.#${K & string}`]: Fieldpath[K]; } & {
         "": DefinedData[] | TypeAppend;
-        ".*": DefinedData | TypeAppend;
+        ".#": DefinedData | TypeAppend;
     }>;
     or<Def extends AnyBucketModelFieldBuilder>(def: Def): BucketModelFieldBuilder<Module, DefinedData | (Def extends BucketModelFieldBuilder<any, any, any, infer X, {
         '': infer X;
@@ -107,10 +119,17 @@ export declare class BucketModelFieldBuilder<Module extends $Module, DefinedData
      * > If you want unconstrained enum you must specify `null` here.
      */
     maxLength(val: number | null): void;
-    static build(builder: BucketModelFieldBuilder<any, any>, name: string): $BucketModelField;
-    static buildChildren(module: string, children: BucketModelFieldBuilders<any>): {
+    encrypt(key: keyof Module['constants']['values'], algorithm?: string): void;
+    static build(builder: BucketModelFieldBuilder<any, any>, name: string, path?: string): {
+        schema: $BucketModelField;
+        hasFile: boolean;
+        hasEncrypted: boolean;
+    };
+    static buildChildren(module: string, children: BucketModelFieldBuilders<any>, path?: string): {
         schema: $BucketModelFields;
         defaults: Record<string, any>;
+        hasFileField: boolean;
+        hasEncryptedField: boolean;
     };
 }
 export type BucketModelFieldBuilders<Module extends $Module> = {

package/lib/elements/entities/bucket/model/bucket_model_field.builder.js

@@ -27,8 +27,9 @@ class BucketModelFieldFactory {
         return new BucketModelFieldBuilder(this.module, 'datetime', this.alias);
     }
     decimal(def) {
-        // TODO: store definition on schema
-        return new BucketModelFieldBuilder(this.module, 'decimal', this.alias);
+        return new BucketModelFieldBuilder(this.module, 'decimal', this.alias, {
+            decimal: def
+        });
     }
     enum(options) {
         const strings = (Array.isArray(options) || typeof options === 'string')
@@ -44,7 +45,9 @@ class BucketModelFieldFactory {
                 dep = new dependency_1.$Dependency(this.module, 'constants', '*');
             }
         }
-        return new BucketModelFieldBuilder(this.module, 'enum', this.alias, { options: strings, dep });
+        return new BucketModelFieldBuilder(this.module, 'enum', this.alias, {
+            enum: { options: strings, dep }
+        });
     }
     get int() {
         return new BucketModelFieldBuilder(this.module, 'int', this.alias);
@@ -55,23 +58,37 @@ class BucketModelFieldFactory {
     get string() {
         return new BucketModelFieldBuilder(this.module, 'string', this.alias);
     }
+    /**
+     * An object with a specific set of child fields.
+     */
     obj(fields) {
         return new BucketModelFieldBuilder(this.module, 'obj', this.alias, undefined, fields);
     }
+    /**
+     * An object with an unknown number of child fields of a given type.
+     *
+     * - All child fields are optional. You can specify a default value.
+     */
     dict(dictItem) {
+        dictItem = dictItem.optional;
         return new BucketModelFieldBuilder(this.module, 'dict', this.alias, undefined, { __dict: dictItem });
     }
+    file(def) {
+        return new BucketModelFieldBuilder(this.module, 'file', this.alias, {
+            file: def
+        });
+    }
 }
 exports.BucketModelFieldFactory = BucketModelFieldFactory;
 /*
     Builder
 */
 class BucketModelFieldBuilder {
-    constructor(module, type, alias, _enum, children) {
+    constructor(module, type, alias, meta, children) {
         this.module = module;
         this.type = type;
         this.alias = alias;
-        this._enum = _enum;
+        this.meta = meta;
         this.children = children;
         this._array = false;
         this._required = true;
@@ -118,10 +135,19 @@ class BucketModelFieldBuilder {
      */
     maxLength(val) {
     }
+    encrypt(key, algorithm = 'aes256') {
+        this.crypto = {
+            algorithm,
+            key: key
+        };
+    }
     // Build
-    static build(builder, name) {
+    static build(builder, name, path = '') {
+        path += name;
         const children = builder.children
-            ? BucketModelFieldBuilder.buildChildren(builder.module, builder.children)
+            ? BucketModelFieldBuilder.buildChildren(builder.module, builder.children, builder._array
+                ? path + '.#.'
+                : path + '.')
             : undefined;
         const defaults = builder._defaultValue && builder.children
             ? Object.assign({}, builder._defaultValue, children?.defaults)
@@ -129,26 +155,43 @@ class BucketModelFieldBuilder {
         const or = builder._or
             ? this.build(builder._or, name)
             : undefined;
-        return new bucket_model_schema_1.$BucketModelField(name, builder.type, builder.alias || name, builder._array, builder._required, builder._enum, defaults, children?.schema, or);
-    }
-    static buildChildren(module, children) {
+        const schema = new bucket_model_schema_1.$BucketModelField(name, path, builder.type, builder.alias || name, builder._array, builder._required, builder.meta, defaults, children?.schema, or?.schema, builder.crypto);
+        const hasFile = builder.type === 'file'
+            || children?.hasFileField
+            || or?.hasFile
+            || false;
+        const hasEncrypted = !!builder.crypto
+            || children?.hasEncryptedField
+            || or?.hasEncrypted
+            || false;
+        return { schema, hasFile, hasEncrypted };
+    }
+    static buildChildren(module, children, path) {
         const schema = {};
         const defaults = {};
+        let hasFileField = false;
+        let hasEncryptedField = false;
         for (const c in children) {
             const child = children[c];
             if (child instanceof BucketModelFieldBuilder) {
-                schema[c] = BucketModelFieldBuilder.build(child, c);
+                const out = BucketModelFieldBuilder.build(child, c, path);
+                schema[c] = out.schema;
+                hasFileField || (hasFileField = out.hasFile);
+                hasEncryptedField || (hasEncryptedField = out.hasEncrypted);
             }
             // Builders are allowed to implicitly declare nested fields.
             // The code below transforms these groups into fields of the scope 'group'.
             else {
                 const fieldTypeBuilder = new BucketModelFieldFactory(module);
                 const fieldBuilder = fieldTypeBuilder.obj(child);
-                schema[c] = BucketModelFieldBuilder.build(fieldBuilder, c);
+                const out = BucketModelFieldBuilder.build(fieldBuilder, c, path);
+                schema[c] = out.schema;
+                hasFileField || (hasFileField = out.hasFile);
+                hasEncryptedField || (hasEncryptedField = out.hasEncrypted);
             }
             defaults[c] = schema[c].defaultValue;
         }
-        return { schema, defaults };
+        return { schema, defaults, hasFileField, hasEncryptedField };
     }
 }
 exports.BucketModelFieldBuilder = BucketModelFieldBuilder;

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

@@ -56,6 +56,7 @@ export type NQL_Order<Fieldpath> = {
 export type NQL_Pagination = {
     page?: number;
     perPage?: number;
+    count?: boolean;
 };
 /**
  * A union of all operators which apply to the selected field

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

@@ -3,7 +3,6 @@ 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;
@@ -23,7 +22,7 @@ class NQL_RuleTree {
     }
     // Parse NQL
     parseUnion(bucket, query, select) {
-        const meta = bucket_1.Bucket.getQueryMeta(bucket);
+        const meta = bucket.getQueryMeta();
         const union = {
             meta: {
                 ...meta,
@@ -283,6 +282,12 @@ class NQL_RuleTree {
             const parent = stack.at(-2);
             // Union
             if ('inters' in node[0]) {
+                // Union has no child and a parent, should be removed
+                if (node[0].inters.length == 0 && parent) {
+                    parent[0].rules.splice(parent[1], 1); // TODO: investigate 'as any'
+                    stack.pop();
+                    continue;
+                }
                 // Union has a single child and a parent, should be collapsed
                 if (node[0].inters.length == 1 && parent) {
                     // Parent is a Intersection
@@ -310,6 +315,12 @@ class NQL_RuleTree {
             }
             // Intersection
             else if ('rules' in node[0]) {
+                // Intersection has no rule and a parent, should be removed
+                if (node[0].rules.length == 0 && parent) {
+                    parent[0].inters.splice(parent[1], 1); // TODO: investigate 'as any'
+                    stack.pop();
+                    continue;
+                }
                 // Iterate
                 node[1]++;
                 const next = node[0].rules[node[1]];

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

@@ -1,16 +1,23 @@
 import { AnyModule } from "../../../../engine/module";
 import { NQL_CompiledQuery } from './nql_compiler';
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
-import { NQL_Part } from './nql.schema';
+import { AnyBucket } from '../bucket';
+import { NQL_Pagination, NQL_Part } from './nql.schema';
 type Obj = Record<string, any>;
-type Objs = Record<string, Obj>;
+export type NQL_Result<T = Obj> = {
+    data: T[];
+    count?: number;
+    page?: number;
+    perPage?: number;
+};
 export declare abstract class NQLRunner {
-    abstract run(trx: AnyTrxNode, part: NQL_Part, params: Record<string, any>): Promise<Objs>;
+    abstract run(trx: AnyTrxNode, part: NQL_Part, params: Record<string, any>, pagination?: NQL_Pagination): Promise<NQL_Result>;
 }
 export declare class NQL_Engine {
     private module;
     private runners;
     constructor(module: AnyModule);
-    run(trx: AnyTrxNode, query: NQL_CompiledQuery, params?: Record<string, any>): Promise<Obj[]>;
+    run(trx: AnyTrxNode, query: NQL_CompiledQuery, pagination?: NQL_Pagination, params?: Record<string, any>): Promise<NQL_Result>;
+    linkExternal(bucket: AnyBucket): void;
 }
 export {};

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

@@ -1,7 +1,6 @@
 "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;
@@ -11,32 +10,42 @@ class NQL_Engine {
         this.runners = {};
         for (const b in module.buckets) {
             const bucket = module.buckets[b];
-            const meta = bucket_1.Bucket.getQueryMeta(bucket);
+            const meta = bucket.getQueryMeta();
             if (!(meta.scope in this.runners)) {
-                this.runners[meta.scope] = bucket_1.Bucket.getQueryRunner(bucket);
+                this.runners[meta.scope] = bucket.adapter.nql;
             }
         }
     }
-    async run(trx, query, params = {}) {
-        let data = [];
+    async run(trx, query, pagination, params = {}) {
+        let result = {
+            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);
+            const out = await runner.run(trx, part, params, pagination);
+            result = out;
             // Part failed, return
             // Failure here is only when a single value is expected,
             if (!part.many) {
-                if (data.length === 0) {
-                    return [];
+                if (result.data.length === 0) {
+                    return {
+                        data: []
+                    };
                 }
             }
             // Fill part params
-            params[`%__${part_i}__%`] = part.many ? data : data[0];
+            params[`%__${part_i}__%`] = part.many ? result.data : result.data[0];
+        }
+        return result;
+    }
+    linkExternal(bucket) {
+        const meta = bucket.getQueryMeta();
+        if (!(meta.scope in this.runners)) {
+            this.runners[meta.scope] = bucket.adapter.nql;
         }
-        return data;
     }
 }
 exports.NQL_Engine = NQL_Engine;

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

@@ -6,6 +6,7 @@ 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");
 class BucketView {
     constructor(bucket, schema) {
         this.bucket = bucket;
@@ -21,39 +22,7 @@ class BucketView {
                 if (prop.scope !== 'model') {
                     continue;
                 }
-                const value = prop.value.model;
-                const rawValue = tree_1.Tree.get(raw, value.key, index);
-                if (prop.children) {
-                    if (prop.array) {
-                        if (!Array.isArray(rawValue)) {
-                            continue;
-                        }
-                        const parsedArray = [];
-                        for (let i = 0; i < rawValue.length; i++) {
-                            const child = await doParse(prop.children, [...(index || []), i]);
-                            parsedArray.push(child);
-                        }
-                        parsedObj[k] = parsedArray;
-                        continue;
-                    }
-                    else if (prop.type === 'dict') {
-                        if (typeof rawValue !== 'object' || Array.isArray(rawValue)) {
-                            continue;
-                        }
-                        const parsedArray = [];
-                        for (const k in rawValue) {
-                            const child = await doParse(prop.children, [...(index || []), k]);
-                            parsedArray.push(child);
-                        }
-                        parsedObj[k] = parsedArray;
-                        continue;
-                    }
-                    else {
-                        parsedObj[k] = await doParse(prop.children, index || []);
-                        continue;
-                    }
-                }
-                parsedObj[k] = rawValue;
+                parsedObj[k] = await parseModelProp(raw, prop, index);
             }
             // Computed props
             for (const k in schema) {
@@ -77,7 +46,35 @@ class BucketView {
                     continue;
                 }
                 const value = prop.value.graph;
-                parsedObj[k] = await promise_1.default.solve(bucket.graph.readLink(trx, value.link, raw, value.view, index || []));
+                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
+                }
+                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)) {
+                    parsedObj[k] = await bucket.drive.public(model);
+                }
+                else {
+                    parsedObj[k] = (await bucket.drive.public([model]))[0];
+                }
             }
             // Group props
             for (const k in schema) {
@@ -92,7 +89,38 @@ class BucketView {
             }
             return parsedObj;
         };
-        const parsedObj = await doParse(this.schema.fields, null);
+        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;
+                    }
+                    const parsedArray = [];
+                    for (let i = 0; i < rawValue.length; i++) {
+                        const child = await doParse(prop.children, [...(index || []), i]);
+                        parsedArray.push(child);
+                    }
+                    return parsedArray;
+                }
+                else if (prop.type === 'dict') {
+                    if (typeof rawValue !== 'object' || Array.isArray(rawValue)) {
+                        return undefined;
+                    }
+                    const parsedDict = {};
+                    for (const j in rawValue) {
+                        parsedDict[j] = await parseModelProp(rawValue, prop.children.__dict, [...(index || []), j], j);
+                    }
+                    return parsedDict;
+                }
+                else {
+                    return doParse(prop.children, index || []);
+                }
+            }
+            return rawValue;
+        };
+        const parsedObj = await doParse(this.schema.fields, '*');
         return {
             id: raw.id,
             ...parsedObj

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

@@ -21,11 +21,14 @@ export type $BucketViewFieldValue = {
     view?: {
         view: string;
     };
+    drive?: {
+        path: string;
+    };
     group?: {};
 };
 export declare class $BucketViewField {
     name: string;
-    scope: 'model' | 'graph' | 'computed' | 'group' | 'view';
+    scope: 'model' | 'graph' | 'computed' | 'group' | 'view' | 'drive';
     type: $BucketModelFieldType | 'id';
     alias: string;
     array: boolean | 'unknown';
@@ -34,7 +37,7 @@ export declare class $BucketViewField {
     children?: $BucketViewFields | undefined;
     $t: string;
     '#data': unknown;
-    constructor(name: string, scope: 'model' | 'graph' | 'computed' | 'group' | 'view', 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', type: $BucketModelFieldType | 'id', alias: string, array: boolean | 'unknown', required: boolean, value: $BucketViewFieldValue, children?: $BucketViewFields | undefined);
 }
 export type $BucketViewFields = {
     [x: string]: $BucketViewField;

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

@@ -6,6 +6,10 @@ import { BucketViewBuilder } from './bucket_view.builder';
 import { $Bucket } from '../bucket.schema';
 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']];
 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;
 export declare class BucketViewFieldFactory<Space extends $Space, Module extends $Module, Bucket extends $Bucket> {
@@ -17,6 +21,7 @@ export declare class BucketViewFieldFactory<Space extends $Space, Module extends
     model<K extends keyof Bucket['#fieldpath'], Extra extends BucketViewFieldBuilderTree>(key: K, extra?: Extra): BucketViewFieldBuilder<Bucket["#fieldpath"][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>;
     view<ViewName extends keyof Bucket['views'], View extends Bucket['views'][ViewName]>(view: ViewName): BucketViewFieldBuilder<View["#data"], "view", never>;
     extend<ViewName extends keyof Bucket['views'], Builders extends BucketViewFieldBuilderTree>(view: ViewName, fields: Builders): $BucketViewFieldBuilderInfer<Bucket["views"][ViewName]["#data"]> & Builders;
     static group(name: string, children: $BucketViewFields): $BucketViewField;
@@ -24,10 +29,9 @@ 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 refKey?: string | undefined;
     protected extra?: BucketViewFieldBuilderTree | undefined;
     protected type: $BucketViewField['type'];
-    constructor(scope: $BucketViewField['scope'], value: $BucketViewFieldValue, refKey?: string | undefined, extra?: BucketViewFieldBuilderTree | undefined);
+    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;
 }