nesoi 3.0.0 → 3.0.3

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,23 @@
+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;
+    });
+    hash(hashAlgorithm: 'sha1' | 'md5' | 'sha256'): Promise<{
+        algorithm: "sha1" | "sha256" | "md5";
+        hash: string | object;
+    }>;
+    delete(): void;
+    move(to: string): void;
+}

package/lib/engine/data/file.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NesoiFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const hash_1 = require("../util/hash");
+const mime_1 = require("../util/mime");
+// Based on [formidable](https://github.com/node-formidable/formidable)
+class NesoiFile {
+    constructor(filepath, extra) {
+        this.__nesoi_file = true;
+        this.hashAlgorithm = false;
+        // Only available after `.hash` is called
+        this._hash = null;
+        this.filepath = filepath;
+        this.filename = path_1.default.basename(filepath);
+        const mime = mime_1.Mime.ofFilepath(filepath);
+        this.extname = extra?.originalFilename
+            ? path_1.default.extname(extra.originalFilename).slice(1)
+            : mime.extname;
+        this.mimetype = mime.mimetype;
+        const stat = fs_1.default.statSync(filepath);
+        this.size = stat.size;
+        this.originalFilename = extra?.originalFilename || null;
+        this.newFilename = extra?.newFilename || this.filename;
+        this.mtime = stat.mtime;
+    }
+    async hash(hashAlgorithm) {
+        if (!this._hash) {
+            this.hashAlgorithm = hashAlgorithm;
+            this._hash = hash_1.Hash.file(this.filepath, this.hashAlgorithm).then(hash => {
+                this._hash = hash;
+            });
+        }
+        return {
+            algorithm: hashAlgorithm,
+            hash: this._hash
+        };
+    }
+    delete() {
+        if (fs_1.default.existsSync(this.filepath))
+            fs_1.default.rmSync(this.filepath);
+    }
+    move(to) {
+        if (fs_1.default.existsSync(this.filepath))
+            fs_1.default.renameSync(this.filepath, to);
+        this.filepath = to;
+    }
+}
+exports.NesoiFile = NesoiFile;

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

@@ -0,0 +1,6 @@
+export declare class NesoiJSON {
+    /**
+     * Dumps an object to
+     */
+    static dump(obj: Record<string, any>): string;
+}

package/lib/engine/data/json.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NesoiJSON = void 0;
+const date_1 = require("./date");
+const datetime_1 = require("./datetime");
+const decimal_1 = require("./decimal");
+class NesoiJSON {
+    /**
+     * Dumps an object to
+     */
+    static dump(obj) {
+        return JSON.stringify(obj, (key, value) => {
+            if (value instanceof date_1.NesoiDate) {
+                return value.toISO();
+            }
+            if (value instanceof datetime_1.NesoiDatetime) {
+                return value.toISO();
+            }
+            if (value instanceof decimal_1.NesoiDecimal) {
+                return value.toString();
+            }
+            return value;
+        });
+    }
+}
+exports.NesoiJSON = NesoiJSON;

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

@@ -2,7 +2,7 @@ export type NesoiObjId = number | string;
 export interface NesoiObj {
     id: NesoiObjId;
 }
-export type NewOrOldObj<T extends NesoiObj> = {
+export type ObjWithOptionalId<T extends NesoiObj> = {
     id?: T['id'];
 } & Omit<T, 'id'>;
 type DefinedKeys<T> = {

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

@@ -0,0 +1,14 @@
+import { NesoiDatetime } from './datetime';
+export type TrashObj = {
+    id: number;
+    bucket: string;
+    original_id: number | string;
+    data: Record<string, any>;
+    adapter: {
+        name: string;
+        [x: string]: any;
+    };
+    trx: Record<string, any>;
+    deleted_by?: number | string;
+    deleted_at: NesoiDatetime;
+};

package/lib/engine/data/trash.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,17 +1,12 @@
-type TreeNode<T> = {
-    path: string;
-    key: string;
-    value: T;
-};
 export declare class Tree {
     /**
-     * When the fieldpath contains a `.*.`, which refers to a item in a list:
-     * - If the `index` parameter is null, returns nested lists
-     * - If the `index` parameter is a list of indices, returns the target object
+     * Read one or more values from the object, from a _fieldpath_.
      *
+     * The `index` argument is only relevant if the fieldpath contains a spread (`.#`):
+     * - `*`: Return all values of the matched array or dict
+     * - `0`: Return the first value of an array or dict (dict ordering is unstable)
+     * - `(number|string)[]`: Sequence of values to replace the `#`s on the fieldpath
      */
-    static get(obj: Record<string, any>, fieldpath: string, index?: 0 | null | (number | string)[]): any;
-    static find<P>(obj: Record<string, P>, fn: (path: string, value: P) => boolean, link?: string, _prefix?: string): TreeNode<P> | undefined;
-    static findAll<P>(obj: Record<string, P>, fn: (path: string, value: P) => boolean, _prefix?: string): TreeNode<P>[];
+    static get(obj: Record<string, any>, fieldpath: string, index?: '*' | 0 | (number | string)[]): any;
+    static set(obj: Record<string, any>, fieldpath: string, replacer: (v: any, i: (number | string)[]) => any, __index?: (number | string)[]): void;
 }
-export {};