nesoi 3.0.0 → 3.0.6

package/lib/engine/cli/cli_input.js

@@ -0,0 +1,207 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIInputHandler = void 0;
+const stream_1 = require("stream");
+const readline = __importStar(require("readline"));
+class CLIInputHandler {
+    constructor(suggestions = []) {
+        this.suggestions = suggestions;
+        this.items = [];
+        this.history = 0;
+        this.buffer = '';
+        this.cursor = 0;
+    }
+    /**
+     * Wait for user input:
+     * - Some text + Enter
+     * - Special Keys: Up/Down/Tab
+     */
+    async input(ctx) {
+        return new Promise(resolve => {
+            const mutableStdout = new stream_1.Writable({
+                write: function (chunk, encoding, callback) {
+                }
+            });
+            this.buffer = '';
+            this.cursor = 0;
+            this.suggestion = undefined;
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: mutableStdout,
+                terminal: true
+            });
+            const print = () => {
+                process.stdout.clearLine(0);
+                process.stdout.cursorTo(0);
+                process.stdout.write(ctx + ' ' + this.buffer);
+                process.stdout.moveCursor(this.cursor - this.buffer.length, 0);
+            };
+            print();
+            const onKeypress = (ch, key) => {
+                // History
+                if (key.name === 'up') {
+                    this.buffer = this.up() || this.buffer;
+                    this.cursor = this.buffer.length;
+                    print();
+                    return;
+                }
+                if (key.name === 'down') {
+                    this.buffer = this.down() || '';
+                    this.cursor = this.buffer.length;
+                    print();
+                    return;
+                }
+                // Suggestion
+                if (key.name === 'tab') {
+                    this.buffer = this.suggest(this.buffer) || this.buffer;
+                    this.cursor = this.buffer.length;
+                    print();
+                    return;
+                }
+                this.suggestion = undefined;
+                // Text Editing
+                if (key.name === 'left') {
+                    if (this.cursor > 0) {
+                        process.stdout.moveCursor(-1, 0);
+                        this.cursor -= 1;
+                    }
+                    print();
+                    return;
+                }
+                if (key.name === 'right') {
+                    if (this.cursor < this.buffer.length) {
+                        process.stdout.moveCursor(1, 0);
+                        this.cursor += 1;
+                    }
+                    print();
+                    return;
+                }
+                if (key.name === 'backspace') {
+                    if (this.buffer.length == 0) {
+                        return;
+                    }
+                    this.buffer = this.buffer.slice(0, this.cursor - 1)
+                        + this.buffer.slice(this.cursor);
+                    this.cursor -= 1;
+                    print();
+                    return;
+                }
+                if (key.name === 'delete') {
+                    if (this.buffer.length == 0) {
+                        return;
+                    }
+                    this.buffer = this.buffer.slice(0, this.cursor)
+                        + this.buffer.slice(this.cursor + 1);
+                    print();
+                    return;
+                }
+                // Submit
+                if (key.name === 'return') {
+                    submit(this.buffer);
+                    return;
+                }
+                // Text Characters
+                else {
+                    this.buffer = this.buffer.slice(0, this.cursor)
+                        + ch
+                        + this.buffer.slice(this.cursor);
+                    this.cursor += 1;
+                    print();
+                }
+            };
+            const onCancel = () => {
+                if (!this.buffer.length) {
+                    process.stdout.clearLine(0);
+                    process.stdout.cursorTo(0);
+                    process.exit();
+                }
+                submit(undefined);
+            };
+            const submit = (value) => {
+                process.stdout.write('\n');
+                rl.close();
+                process.stdin.off('keypress', onKeypress);
+                rl.off('SIGINT', onCancel);
+                this.buffer = '';
+                if (value !== undefined) {
+                    this.add(value);
+                }
+                resolve(value);
+            };
+            process.stdin.on('keypress', onKeypress);
+            rl.on('SIGINT', onCancel);
+        });
+    }
+    add(item) {
+        this.history = 0;
+        this.suggestion = undefined;
+        if (this.items[0] === item) {
+            return;
+        }
+        this.items.unshift(item);
+    }
+    up() {
+        if (this.history >= this.items.length)
+            return;
+        const item = this.items[this.history];
+        this.history += 1;
+        return item;
+    }
+    down() {
+        if (this.history <= 0)
+            return;
+        const item = this.items[this.history];
+        this.history -= 1;
+        return item;
+    }
+    suggest(_seed) {
+        const idx = this.suggestion?.idx || 0;
+        const seed = this.suggestion?.seed || _seed;
+        for (let i = idx; i < this.suggestions.length; i++) {
+            const sugg = this.suggestions[i];
+            if (sugg.startsWith(seed)) {
+                this.suggestion = {
+                    seed,
+                    idx: i + 1
+                };
+                return sugg;
+            }
+        }
+        this.suggestion = undefined;
+        return seed;
+    }
+}
+exports.CLIInputHandler = CLIInputHandler;

package/lib/engine/cli/ui.d.ts

@@ -2,7 +2,7 @@ export default class UI {
     /**
      * Show a list of options and let the user pick with up/down + enter
      */
-    static select(title: string, options: string[], defaul?: number): Promise<string>;
+    static select<T>(title: string, options: T[], val?: NoInfer<(o: T) => string>, defaul?: number): Promise<T>;
     /**
      * Ask a question and wait for the answer
      */

package/lib/engine/cli/ui.js

@@ -40,7 +40,7 @@ class UI {
     /**
      * Show a list of options and let the user pick with up/down + enter
      */
-    static async select(title, options, defaul = 0) {
+    static async select(title, options, val = (o => o), defaul = 0) {
         return new Promise(resolve => {
             UI.step(title);
             let mute = true;
@@ -61,7 +61,7 @@ class UI {
             const print = () => {
                 mute = false;
                 for (let i = 0; i < options.length; i++) {
-                    rl.write((0, string_1.colored)(`${i === selected ? '» ' : '  '}` + options[i] + '\n', i === selected ? 'lightgreen' : 'lightgray'));
+                    rl.write((0, string_1.colored)(`${i === selected ? '» ' : '  '}` + val(options[i]) + '\n', i === selected ? 'lightgreen' : 'lightgray'));
                 }
                 mute = true;
             };

package/lib/engine/daemon.d.ts

@@ -14,8 +14,9 @@ export declare abstract class Daemon<S extends $Space, Modules extends ModuleNam
     private _cli?;
     constructor(name: string, trxEngines: Record<Modules, AnyTrxEngine>, providers: Record<string, any>, app?: AnyAppConfig | undefined);
     trx<K extends Modules & keyof S['modules']>(moduleName: K): DaemonTrx<S, S["modules"][K], {}>;
-    cli(): Promise<void>;
+    cli(cmd?: string): Promise<void>;
     private bindControllers;
+    static destroy(daemon: AnyDaemon): Promise<void>;
     static reload(daemon: AnyDaemon, trxEngines: Record<string, AnyTrxEngine>, providers: Record<string, any>): void;
     static get<T extends {
         name: string;
@@ -29,7 +30,7 @@ export declare class DaemonTrx<S extends $Space, M extends $Module, Authn extend
     private trxEngine;
     private _authn?;
     constructor(trxEngine: AnyTrxEngine);
-    authn<Authn extends AuthnRequest<keyof S['authnUsers']>>(authn: Authn): DaemonTrx<S, M, { [K in keyof Authn]: S["authnUsers"][K & keyof S["authnUsers"]]; }>;
+    authn<Authn extends AuthnRequest<keyof S['authnUsers']>>(authn?: Authn): DaemonTrx<S, M, { [K in keyof Authn]: S["authnUsers"][K & keyof S["authnUsers"]]; }>;
     run<Output>(fn: (trx: TrxNode<S, M, Authn>) => Promise<Output>): Promise<TrxStatus<Output>>;
 }
 export type AnyDaemon = Daemon<any, any>;

package/lib/engine/daemon.js

@@ -20,9 +20,9 @@ class Daemon {
         }
         return new DaemonTrx(trxEngine);
     }
-    async cli() {
+    async cli(cmd) {
         this._cli = new cli_1.CLI(this, this.app?.cli);
-        await this._cli.run();
+        await this._cli.run(cmd);
     }
     bindControllers() {
         log_1.Log.info('daemon', this.name, 'Binding controllers');
@@ -34,10 +34,22 @@ class Daemon {
             }
         }
     }
+    static async destroy(daemon) {
+        log_1.Log.info('daemon', this.name, 'Stop');
+        for (const key in daemon.providers) {
+            const provider = daemon.providers[key];
+            await provider.__down(provider);
+            delete daemon.providers[key];
+        }
+        for (const key in daemon.trxEngines) {
+            delete daemon.trxEngines[key];
+        }
+    }
     static reload(daemon, trxEngines, providers) {
         log_1.Log.info('daemon', this.name, 'Reloaded');
         daemon.trxEngines = trxEngines;
         daemon.providers = providers;
+        daemon.bindControllers();
     }
     static get(daemon, key) {
         return daemon?.[key];

package/lib/engine/data/date.js

@@ -9,8 +9,8 @@ class NesoiDate {
         this.year = year;
     }
     static fromISO(iso) {
-        // TODO: Check invalid ISO
-        const match = iso.match(/(\d{4})-([01]\d)-([0-3]\d)/);
+        const match = iso.match(/(\d{4})-(\d{2})-(\d{2})/);
+        // TODO: Check invalid date
         if (!match) {
             throw error_1.NesoiError.Data.InvalidISOString({ value: iso });
         }

package/lib/engine/data/datetime.d.ts

@@ -1,12 +1,48 @@
 export declare class NesoiDatetime {
+    static tz: {
+        '-12:00': string;
+        '-11:00': string;
+        '-10:00': string;
+        '-07:00': string;
+        '-06:00': string;
+        '-05:00': string;
+        '-04:00': string;
+        '-03:00': string;
+        '-02:00': string;
+        '-01:00': string;
+        Z: string;
+        '+01:00': string;
+        '+02:00': string;
+        '+03:00': string;
+        '+04:00': string;
+        '+05:00': string;
+        '+06:00': string;
+        '+07:00': string;
+        '+08:00': string;
+        '+09:00': string;
+        '+10:00': string;
+        '+11:00': string;
+        '+12:00': string;
+        '+13:00': string;
+    };
     /**
-     * Time in milliseconds since 1970-01-01
+     * Time in milliseconds since 1970-01-01T00:00:00.000Z
      */
     epoch: number;
-    constructor(jsDate?: Date);
+    /**
+     * Timezone represented as string (Z, -03, +05, ...)
+     */
+    tz: keyof typeof NesoiDatetime.tz;
+    constructor(epoch?: number, tz?: keyof typeof NesoiDatetime.tz);
+    toISO(): string;
+    /**
+     * Parse a timestamp from ISO 8601 format.
+     *
+     * Example: `2025-04-16T23:04:42.000-03:00`
+     */
     static fromISO(iso: string): NesoiDatetime;
     static now(): NesoiDatetime;
     static isoNow(): string;
-    static shortNow(): string;
-    toISO(): string;
+    static shortIsoNow(): string;
+    plus(period: `${number} ${'second' | 'minute' | 'hour' | 'day' | 'week' | 'month'}${'s' | ''}`): this;
 }

package/lib/engine/data/datetime.js

@@ -3,29 +3,88 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NesoiDatetime = void 0;
 const error_1 = require("./error");
 class NesoiDatetime {
-    constructor(jsDate) {
-        this.epoch = (jsDate || new Date()).getTime();
+    constructor(epoch, tz = 'Z') {
+        this.epoch = epoch || new Date().getTime();
+        this.tz = tz;
     }
+    // Dump
+    toISO() {
+        return new Date(this.epoch).toLocaleString('sv-SE', {
+            timeZone: NesoiDatetime.tz[this.tz],
+            year: 'numeric',
+            month: 'numeric',
+            day: 'numeric',
+            hour: 'numeric',
+            minute: 'numeric',
+            second: 'numeric',
+            fractionalSecondDigits: 3
+        })
+            .replace(' ', 'T')
+            .replace(',', '.')
+            + this.tz;
+    }
+    /**
+     * Parse a timestamp from ISO 8601 format.
+     *
+     * Example: `2025-04-16T23:04:42.000-03:00`
+     */
     static fromISO(iso) {
-        // TODO: Check invalid ISO
-        const match = iso.match(/(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/);
+        const match = iso.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?(([-+]\d{2})|Z)?(:00)?$/);
+        // TODO: Check invalid datetimes
         if (!match) {
             throw error_1.NesoiError.Data.InvalidISOString({ value: iso });
         }
-        const jsDate = new Date(iso);
-        return new NesoiDatetime(jsDate);
+        let tz = match[8];
+        if (!tz) {
+            iso += 'Z';
+            tz = 'Z';
+        }
+        if (tz !== 'Z') {
+            if (!match[10]) {
+                iso += ':00';
+            }
+            tz += ':00';
+        }
+        const jsDate = Date.parse(iso);
+        return new NesoiDatetime(jsDate, tz);
     }
     static now() {
         return new NesoiDatetime();
     }
     static isoNow() {
-        return new Date().toISOString();
+        return new NesoiDatetime().toISO();
     }
-    static shortNow() {
-        return new Date().toISOString().slice(5, 19);
+    static shortIsoNow() {
+        return new NesoiDatetime().toISO().slice(5, 19);
     }
-    toISO() {
-        return new Date(this.epoch).toISOString();
+    plus(period) {
+        return this;
     }
 }
 exports.NesoiDatetime = NesoiDatetime;
+NesoiDatetime.tz = {
+    '-12:00': 'Etc/GMT+12',
+    '-11:00': 'Etc/GMT+11',
+    '-10:00': 'Etc/GMT+10',
+    '-07:00': 'Etc/GMT+7',
+    '-06:00': 'Etc/GMT+6',
+    '-05:00': 'Etc/GMT+5',
+    '-04:00': 'Etc/GMT+4',
+    '-03:00': 'Etc/GMT+3',
+    '-02:00': 'Etc/GMT+2',
+    '-01:00': 'Etc/GMT+1',
+    'Z': 'Etc/GMT',
+    '+01:00': 'Etc/GMT-1',
+    '+02:00': 'Etc/GMT-2',
+    '+03:00': 'Etc/GMT-3',
+    '+04:00': 'Etc/GMT-4',
+    '+05:00': 'Etc/GMT-5',
+    '+06:00': 'Etc/GMT-6',
+    '+07:00': 'Etc/GMT-7',
+    '+08:00': 'Etc/GMT-8',
+    '+09:00': 'Etc/GMT-9',
+    '+10:00': 'Etc/GMT-10',
+    '+11:00': 'Etc/GMT-11',
+    '+12:00': 'Etc/GMT-12',
+    '+13:00': 'Etc/GMT-13',
+};

package/lib/engine/data/decimal.d.ts

@@ -1,4 +1,4 @@
-export declare class Decimal {
+export declare class NesoiDecimal {
     private neg;
     private left;
     private right;

package/lib/engine/data/decimal.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Decimal = void 0;
+exports.NesoiDecimal = void 0;
 const error_1 = require("./error");
-class Decimal {
+class NesoiDecimal {
     constructor(value, pLeft = 12, pRight = 12) {
         this.neg = false;
         let payload = value.trim();
@@ -67,4 +67,4 @@ class Decimal {
         return (this.neg ? -1 : 1) * (this.left + this.right * this.r_exp);
     }
 }
-exports.Decimal = Decimal;
+exports.NesoiDecimal = NesoiDecimal;

package/lib/engine/data/error.d.ts

@@ -22,7 +22,10 @@ export declare namespace NesoiError {
             function UnknownGraphLink(name: string): BaseError;
             function UnknownViewName(name: string): BaseError;
             function NoChildrenOnViewGroup(name: string): BaseError;
-            function CompositionWithPivotNotAllowed(): BaseError;
+            function CompositionThroughPivotNotAllowed($: {
+                bucket: string;
+                link: string;
+            }): BaseError;
         }
         namespace Message {
             function UnknownTemplateFieldType(type: string): BaseError;
@@ -55,6 +58,7 @@ export declare namespace NesoiError {
     namespace Trx {
         function ModuleNotFound(module: string): BaseError;
         function NodeNotFound(node: string, trx: string): BaseError;
+        function NotAuthenticated($: {}): BaseError;
     }
     namespace Bucket {
         function InvalidId($: {
@@ -84,6 +88,10 @@ export declare namespace NesoiError {
             bucket: string;
             link: string;
         }): BaseError;
+        function FieldNotFound($: {
+            path: string;
+            bucket: string;
+        }): BaseError;
         namespace Graph {
             function LinkNotFound($: {
                 bucket: string;
@@ -93,7 +101,11 @@ export declare namespace NesoiError {
             function LinkManyRefOffSelfWithArrayValue(link: string): BaseError;
             function LinkOneWithArrayValue(link: string): BaseError;
             function PivotValueIsUndefined(link: string): BaseError;
-            function RequiredLinkNotFound(link: string, value: any): BaseError;
+            function RequiredLinkNotFound($: {
+                bucket: string;
+                link: string;
+                id: number | string;
+            }): BaseError;
         }
         namespace Query {
             function NoResults($: {
@@ -112,6 +124,11 @@ export declare namespace NesoiError {
                 index: (string | number)[];
             }): BaseError;
         }
+        namespace Drive {
+            function NoAdapter($: {
+                bucket: string;
+            }): BaseError;
+        }
     }
     namespace Data {
         function InvalidISOString($: {
@@ -167,11 +184,11 @@ export declare namespace NesoiError {
             path: string;
             value: any;
         }): BaseError;
-        function RuleFailed(rule: $MessageTemplateRule<any, any>, error: string): BaseError;
+        function RuleFailed(rule: $MessageTemplateRule, error: string): BaseError;
         function FileTooBig(prop: {
             name: string;
             alias?: string;
-        }, maxSize: number): BaseError;
+        }, maxsize: number): BaseError;
         function FileExtNotAllowed(prop: {
             name: string;
             alias?: string;

package/lib/engine/data/error.js

@@ -20,6 +20,7 @@ var NesoiError;
         Status[Status["BAD_REQUEST"] = 400] = "BAD_REQUEST";
         Status[Status["NOT_FOUND"] = 404] = "NOT_FOUND";
         Status[Status["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+        Status[Status["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
         Status[Status["INTERNAL_ERROR"] = 500] = "INTERNAL_ERROR";
     })(Status || (Status = {}));
     let Builder;
@@ -49,10 +50,10 @@ var NesoiError;
                 return new BaseError('Builder.Bucket.NoChildrenOnViewGroup', `Bucket view group ${name} has no children`, Status.NOT_FOUND);
             }
             Bucket.NoChildrenOnViewGroup = NoChildrenOnViewGroup;
-            function CompositionWithPivotNotAllowed() {
-                return new BaseError('Builder.Bucket.CompositionWithPivotNotAllowed', 'Composition with pivot is not allowed', Status.NOT_FOUND);
+            function CompositionThroughPivotNotAllowed($) {
+                return new BaseError('Builder.Bucket.CompositionThroughPivotNotAllowed', `Link '${$.link}' on bucket '${$.bucket}' passes through pivot, so it cannot be a composition`, Status.INTERNAL_ERROR);
             }
-            Bucket.CompositionWithPivotNotAllowed = CompositionWithPivotNotAllowed;
+            Bucket.CompositionThroughPivotNotAllowed = CompositionThroughPivotNotAllowed;
         })(Bucket = Builder.Bucket || (Builder.Bucket = {}));
         let Message;
         (function (Message) {
@@ -148,6 +149,10 @@ var NesoiError;
             return new BaseError('Trx.NodeNotFoundOnTrx', `Node ${node} not found on transaction ${trx}`, Status.NOT_FOUND);
         }
         Trx.NodeNotFound = NodeNotFound;
+        function NotAuthenticated($) {
+            return new BaseError('Trx.NotAuthenticated', 'Unauthorized', Status.UNAUTHORIZED, $);
+        }
+        Trx.NotAuthenticated = NotAuthenticated;
     })(Trx = NesoiError.Trx || (NesoiError.Trx = {}));
     /*
         Elements / Entities
@@ -178,6 +183,10 @@ var NesoiError;
             return new BaseError('Bucket.CompositionValueShouldBeArray', `Request to ${$.method} bucket '${$.bucket}' failed, composition for link ${$.link} should be an array`, Status.BAD_REQUEST, $);
         }
         Bucket.CompositionValueShouldBeArray = CompositionValueShouldBeArray;
+        function FieldNotFound($) {
+            return new BaseError('Bucket.FieldNotFound', `Field '${$.path}' not found on bucket '${$.bucket}'`, Status.NOT_FOUND, $);
+        }
+        Bucket.FieldNotFound = FieldNotFound;
         let Graph;
         (function (Graph) {
             function LinkNotFound($) {
@@ -200,8 +209,8 @@ var NesoiError;
                 return new BaseError('Bucket.Graph.PivotValueIsUndefined', `Link ${link} has a pivot value with undefined/null on the other id`, Status.NOT_FOUND);
             }
             Graph.PivotValueIsUndefined = PivotValueIsUndefined;
-            function RequiredLinkNotFound(link, value) {
-                return new BaseError('Bucket.Graph.RequiredLinkNotFound', `Link ${link} value not found for value ${value}`, Status.NOT_FOUND);
+            function RequiredLinkNotFound($) {
+                return new BaseError('Bucket.Graph.RequiredLinkNotFound', `Link '${$.link}' of '${$.bucket}' not found for object with id ${$.id}`, Status.PRECONDITION_FAILED, $);
             }
             Graph.RequiredLinkNotFound = RequiredLinkNotFound;
         })(Graph = Bucket.Graph || (Bucket.Graph = {}));
@@ -239,6 +248,13 @@ var NesoiError;
             }
             Fieldpath.InvalidIndexLength = InvalidIndexLength;
         })(Fieldpath = Bucket.Fieldpath || (Bucket.Fieldpath = {}));
+        let Drive;
+        (function (Drive) {
+            function NoAdapter($) {
+                return new BaseError('Bucket.Drive.NoAdapter', `Bucket '${$.bucket}' needs a DriveAdapter configured to handle files.`, Status.BAD_REQUEST, $);
+            }
+            Drive.NoAdapter = NoAdapter;
+        })(Drive = Bucket.Drive || (Bucket.Drive = {}));
     })(Bucket = NesoiError.Bucket || (NesoiError.Bucket = {}));
     let Data;
     (function (Data) {
@@ -301,8 +317,8 @@ var NesoiError;
             return new BaseError('Message.RuleFailed', error);
         }
         Message.RuleFailed = RuleFailed;
-        function FileTooBig(prop, maxSize) {
-            return new BaseError('Message.FileTooBig', `${prop.alias || prop.name} size exceeds max (${maxSize})`);
+        function FileTooBig(prop, maxsize) {
+            return new BaseError('Message.FileTooBig', `${prop.alias || prop.name} size exceeds max (${maxsize})`);
         }
         Message.FileTooBig = FileTooBig;
         function FileExtNotAllowed(prop, options) {

package/lib/engine/data/file.d.ts

@@ -0,0 +1,38 @@
+import { TrxNode } from '../transaction/trx_node';
+import { $Module } from "../../elements";
+export declare class NesoiFile {
+    __nesoi_file: boolean;
+    filepath: string;
+    filename: string;
+    extname: string;
+    mimetype: string | null;
+    size: number;
+    originalFilename: string | null;
+    newFilename: string;
+    mtime: Date | null;
+    hashAlgorithm: false | 'sha1' | 'md5' | 'sha256';
+    private _hash;
+    constructor(filepath: string, extra?: {
+        originalFilename?: string | null;
+        newFilename?: string | null;
+    });
+    static hash(file: NesoiFile, hashAlgorithm: 'sha1' | 'md5' | 'sha256'): Promise<{
+        algorithm: "sha1" | "sha256" | "md5";
+        hash: string | object;
+    }>;
+    static delete<M extends $Module>($: {
+        trx: TrxNode<any, M, any>;
+    }, bucket: keyof M['buckets'], file: NesoiFile, options?: {
+        silent?: boolean;
+    }): Promise<void> | undefined;
+    static move<M extends $Module>($: {
+        trx: TrxNode<any, M, any>;
+    }, bucket: keyof M['buckets'], file: NesoiFile, to: string, options?: {
+        silent?: boolean;
+    }): Promise<void>;
+    static read<M extends $Module>($: {
+        trx: TrxNode<any, M, any>;
+    }, bucket: keyof M['buckets'], file: NesoiFile, options?: {
+        silent?: boolean;
+    }): Promise<void>;
+}