nesoi 3.3.30 → 3.4.1

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

@@ -1,8 +1,9 @@
 import { $Bucket } from '../bucket.schema';
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
-export type $BucketViewFieldFn<TrxNode extends AnyTrxNode, B extends $Bucket, Raw, Value> = (ctx: {
+export type $BucketViewFieldFn<TrxNode extends AnyTrxNode, B extends $Bucket, Parent, Value, Return = any> = (ctx: {
     trx: TrxNode;
-    raw: B['#data'];
+    root: B['#data'];
+    parent: Parent;
     value: Value;
     bucket: $Bucket;
 }) => any | Promise<any>;
@@ -37,9 +38,10 @@ export declare class $BucketViewField {
     prop?: string | undefined;
     children?: $BucketViewFields | undefined;
     chain?: $BucketViewField | undefined;
+    as_dict?: number[] | undefined;
     $t: string;
     '#data': unknown;
-    constructor(name: string, scope: 'model' | 'graph' | 'computed' | 'group' | 'view' | 'drive', alias: string, meta: $BucketViewFieldMeta, prop?: string | undefined, children?: $BucketViewFields | undefined, chain?: $BucketViewField | undefined);
+    constructor(name: string, scope: 'model' | 'graph' | 'computed' | 'group' | 'view' | 'drive', alias: string, meta: $BucketViewFieldMeta, prop?: string | undefined, children?: $BucketViewFields | undefined, chain?: $BucketViewField | undefined, as_dict?: number[] | undefined);
 }
 export type $BucketViewFields = {
     [x: string]: $BucketViewField;

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

@@ -13,9 +13,10 @@ class $BucketViewField {
     prop;
     children;
     chain;
+    as_dict;
     $t = 'bucket.view.field';
     '#data';
-    constructor(name, scope, alias, meta, prop, children, chain) {
+    constructor(name, scope, alias, meta, prop, children, chain, as_dict) {
         this.name = name;
         this.scope = scope;
         this.alias = alias;
@@ -23,6 +24,7 @@ class $BucketViewField {
         this.prop = prop;
         this.children = children;
         this.chain = chain;
+        this.as_dict = as_dict;
     }
 }
 exports.$BucketViewField = $BucketViewField;

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

@@ -19,11 +19,15 @@ type ComputedData<Fn extends $BucketViewFieldFn<any, any, any, any>, R = ReturnT
 export declare class BucketViewFieldFactory<Space extends $Space, Module extends $Module, Bucket extends $Bucket> {
     protected scope: $BucketViewField['scope'];
     protected meta: $BucketViewField['meta'];
-    raw(): {
-        [K in keyof Bucket['#data']]: BucketViewFieldBuilder<Module, Bucket, Bucket, Bucket['#data'][K], 'model'>;
+    get inject(): {
+        readonly root: { [K in keyof Bucket["#data"]]: BucketViewFieldBuilder<Module, Bucket, Bucket, Bucket["#data"][K], "model">; };
+        readonly parent: { [K in keyof Bucket["#data"]]: BucketViewFieldBuilder<Module, Bucket, Bucket, Bucket["#data"][K], "model">; };
+        readonly value: { [K in keyof Bucket["#data"]]: BucketViewFieldBuilder<Module, Bucket, Bucket, Bucket["#data"][K], "model">; };
     };
+    get root(): BucketViewFieldBuilder<Module, Bucket, Bucket, any, "model", never>;
+    get parent(): BucketViewFieldBuilder<Module, Bucket, Bucket, any, "model", never>;
+    get value(): BucketViewFieldBuilder<Module, Bucket, Bucket, any, "model", never>;
     model<K extends keyof Bucket['#modelpath']>(path: K): BucketViewFieldBuilder<Module, Bucket, Bucket, Bucket["#modelpath"][K], "model", never>;
-    value(): BucketViewFieldBuilder<Module, Bucket, Bucket, any, "model", never>;
     computed<Fn extends $BucketViewFieldFn<TrxNode<Space, Module, Space['authnUsers']>, Bucket, Bucket['#data'], Bucket['#data']>>(fn: Fn): BucketViewFieldBuilder<Module, Bucket, Bucket, ComputedData<Fn, ReturnType<Fn>>, "computed", never>;
     graph<L extends keyof Bucket['graph']['links'], V extends (keyof Bucket['graph']['links'][L]['#bucket']['views']) | undefined>(link: L, view?: V): BucketViewFieldBuilder<Module, Bucket, Bucket["graph"]["links"][L]["#bucket"], Bucket["graph"]["links"][L]["#many"] extends true ? (undefined extends V ? Bucket["graph"]["links"][L]["#bucket"]["#data"] : ViewObj<Bucket["graph"]["links"][L]["#bucket"], NonNullable<V>>)[] : undefined extends V ? Bucket["graph"]["links"][L]["#bucket"]["#data"] : ViewObj<Bucket["graph"]["links"][L]["#bucket"], NonNullable<V>>, "graph", `${Bucket["graph"]["links"][L]["#bucket"]["name"]}.${V & string}`>;
     drive<F extends DriveFieldpath<Bucket>>(path: F): BucketViewFieldBuilder<Module, Bucket, Bucket, string, "drive", never>;
@@ -41,11 +45,17 @@ export declare class BucketViewFieldBuilder<Module extends $Module, Bucket exten
     protected subview?: (BucketViewFieldBuilders<any> | BucketViewDef<any, any, any>) | undefined;
     $b: "view.field";
     protected _prop?: string;
-    protected _chain?: BucketViewFieldBuilder<any, any, any, any, any>;
+    protected _chain?: ($: BucketViewFieldFactory<any, Module, Bucket>) => BucketViewFieldBuilder<Module, Bucket, any, any, any>;
+    protected _as_dict?: number[];
     constructor(scope: $BucketViewField['scope'], meta: $BucketViewFieldMeta, subview?: (BucketViewFieldBuilders<any> | BucketViewDef<any, any, any>) | undefined);
     prop<Obj extends Data extends any[] ? Data[number] : Data, K extends keyof Obj>(prop: K): BucketViewFieldBuilder<Module, Bucket, ChainBucket, Obj[K], Scope, GraphLink>;
     map<Def extends BucketViewDef<any, Module, ChainBucket>>(def: Def): BucketViewFieldBuilder<Module, Bucket, ChainBucket, { [K in keyof Def]: Def extends BucketViewFieldBuilder<any, any, infer X, any, any> ? X : never; }, Scope, GraphLink>;
-    chain<Fn extends $BucketViewFieldFn<TrxNode<any, Module, never>, ChainBucket, Bucket['#data'], Data>>(fn: Fn): BucketViewFieldBuilder<Module, Bucket, ChainBucket, ComputedData<Fn, ReturnType<Fn>>, Scope, GraphLink>;
+    chain<Def extends ($: BucketViewFieldFactory<any, Module, Bucket>) => BucketViewFieldBuilder<Module, Bucket, any, any, any>>(def: Def): BucketViewFieldBuilder<Module, Bucket, ChainBucket, Data, Scope, GraphLink>;
+    dict(indexes?: number[]): BucketViewFieldBuilder<Module, Bucket, ChainBucket, Data extends any[] ? {
+        [x: string]: Data[number];
+    } : {
+        [x: string]: Data;
+    }, Scope, GraphLink>;
     static build(builder: BucketViewFieldBuilder<any, any, any, any, any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, name: string, n_indexes: number, tree?: ModuleTree): $BucketViewField;
     static buildFields(fields: BucketViewFieldBuilders<any>, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, n_indexes?: number, tree?: ModuleTree): $BucketViewFields;
 }

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

@@ -14,22 +14,50 @@ const bucket_model_schema_1 = require("../model/bucket_model.schema");
 class BucketViewFieldFactory {
     scope;
     meta;
-    raw() {
+    get inject() {
         return {
-            __raw: {}
+            get root() {
+                return {
+                    __root: {}
+                };
+            },
+            get parent() {
+                return {
+                    __parent: {}
+                };
+            },
+            get value() {
+                return {
+                    __value: {}
+                };
+            },
         };
     }
-    model(path) {
+    get root() {
         return new BucketViewFieldBuilder('model', {
             model: {
-                path: path
+                path: '__root'
             }
         });
     }
-    value() {
+    get parent() {
         return new BucketViewFieldBuilder('model', {
             model: {
-                path: '.'
+                path: '__parent'
+            }
+        });
+    }
+    get value() {
+        return new BucketViewFieldBuilder('model', {
+            model: {
+                path: '__value'
+            }
+        });
+    }
+    model(path) {
+        return new BucketViewFieldBuilder('model', {
+            model: {
+                path: path
             }
         });
     }
@@ -63,10 +91,6 @@ class BucketViewFieldFactory {
             }
         });
     }
-    // from<
-    // >(
-    // ) {
-    // }
     extend(view, fields) {
         return {
             __ext: view,
@@ -92,6 +116,7 @@ class BucketViewFieldBuilder {
     $b = 'view.field';
     _prop;
     _chain;
+    _as_dict;
     constructor(scope, meta, subview) {
         this.scope = scope;
         this.meta = meta;
@@ -108,21 +133,37 @@ class BucketViewFieldBuilder {
         if (this._prop) {
             throw new Error('Subview not allowed for view field which picks a prop');
         }
+        if (this._chain) {
+            throw new Error('Subview not allowed on field with chain');
+        }
+        if (this.subview) {
+            throw new Error('Cannot map the same field more than once');
+        }
         this.subview = def;
         return this;
     }
-    chain(fn) {
-        this._chain = new BucketViewFieldBuilder('computed', {
-            computed: {
-                fn: fn
-            }
-        });
+    chain(def) {
+        if (this.subview) {
+            throw new Error('Chain not allowed on field with subiew (map)');
+        }
+        if (this._chain) {
+            throw new Error('Cannot chain the same field more than once');
+        }
+        this._chain = def;
+        // TODO
+        // type CData = ComputedData<Fn>
+        return this;
+    }
+    dict(indexes) {
+        if (!this.meta.model || !this.meta.model.path.split('.').includes('*')) {
+            throw new Error('Dict can only be used on model fields containing at least one \'*\'');
+        }
+        this._as_dict = indexes ?? [-1];
         return this;
     }
     // Build
     static build(builder, model, graph, views, name, n_indexes, tree) {
         let children = undefined;
-        const chainBuilder = builder._chain;
         let spread_n = 0;
         let graphLink = undefined;
         if (builder.scope === 'model') {
@@ -140,12 +181,14 @@ class BucketViewFieldBuilder {
                 }
                 throw new Error(`Maximum index allowed: $${n_indexes - 1}`);
             }
-            // Retrieve one or more BucketModelFields referenced by a modelpath.
-            // (It's only more than one when using unions)
-            // The field itself is not used, but serves to validate that the modelpath exists.
-            const modelFields = bucket_model_schema_1.$BucketModel.getField(model, path);
-            if (!modelFields.length) {
-                throw error_1.NesoiError.Builder.Bucket.UnknownModelField(builder.meta.model.path);
+            if (path !== '__root' && path !== '__parent' && path !== '__value') {
+                // Retrieve one or more BucketModelFields referenced by a modelpath.
+                // (It's only more than one when using unions)
+                // The field itself is not used, but serves to validate that the modelpath exists.
+                const modelFields = bucket_model_schema_1.$BucketModel.getFields(model, path);
+                if (!modelFields.length) {
+                    throw error_1.NesoiError.Builder.Bucket.UnknownModelField(builder.meta.model.path);
+                }
             }
         }
         else if (builder.scope === 'graph') {
@@ -184,10 +227,12 @@ class BucketViewFieldBuilder {
             children = Object.assign({}, children, overrides);
         }
         let chain;
-        if (chainBuilder) {
-            chain = BucketViewFieldBuilder.build(chainBuilder, model, graph, views, name, n_indexes, tree);
+        if (builder._chain) {
+            const factory = new BucketViewFieldFactory();
+            const subview = builder._chain(factory);
+            chain = BucketViewFieldBuilder.build(subview, model, graph, views, name, n_indexes + spread_n, tree);
         }
-        return new bucket_view_schema_1.$BucketViewField(name, builder.scope, name, builder.meta, builder._prop, children, chain);
+        return new bucket_view_schema_1.$BucketViewField(name, builder.scope, name, builder.meta, builder._prop, children, chain, builder._as_dict);
     }
     static buildFields(fields, model, graph, views, n_indexes = 0, tree) {
         const schema = {};
@@ -200,8 +245,17 @@ class BucketViewFieldBuilder {
             if (f === '__ext') {
                 continue;
             }
-            if (f === '__raw') {
-                schema['__raw'] = {};
+            if (f === '__root') {
+                schema['__root'] = {};
+                continue;
+            }
+            if (f === '__parent') {
+                schema['__parent'] = {};
+                continue;
+            }
+            if (f === '__value') {
+                schema['__value'] = {};
+                continue;
             }
             const field = fields[f];
             schema[f] = BucketViewFieldBuilder.build(field, model, graph, views, f, n_indexes, tree);

package/lib/elements/entities/message/template/message_template_parser.d.ts

@@ -3,5 +3,9 @@ import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
 export declare function MessageTemplateFieldParser(trx: AnyTrxNode, fields: $MessageTemplateFields, raw: Record<string, any>): Promise<Record<string, any>>;
 /**
  * Empty values: `{}`, `[]`, `''`, `null`, `undefined`
+ * @returns
+ *  0: not empty
+ *  1: null, undefined
+ *  2: {}, [] or ''
  */
-export declare function isEmpty(value: any): boolean;
+export declare function isEmpty(value: any): 0 | 2 | 1;

package/lib/elements/entities/message/template/message_template_parser.js

@@ -30,14 +30,16 @@ async function MessageTemplateFieldParser(trx, fields, raw) {
 async function parseFieldValue(trx, field, path, raw, value, inject) {
     sanitize(field, path, value);
     let output;
-    if (isEmpty(value)) {
+    const empty = isEmpty(value);
+    if (empty) {
         if (field.required) {
             throw error_1.NesoiError.Message.FieldIsRequired({ alias: field.alias, path: path.join('.'), value });
         }
         else if (field.defaultValue !== undefined) {
             output = field.defaultValue;
         }
-        else {
+        // If the value is null/undefined, transform into undefined
+        else if (empty === 1) {
             output = undefined;
         }
     }
@@ -176,21 +178,25 @@ function sanitize(field, path, value) {
 }
 /**
  * Empty values: `{}`, `[]`, `''`, `null`, `undefined`
+ * @returns
+ *  0: not empty
+ *  1: null, undefined
+ *  2: {}, [] or ''
  */
 function isEmpty(value) {
     if (value === null || value === undefined) {
-        return true;
+        return 1;
     }
     if (Array.isArray(value)) {
-        return value.length === 0;
+        return value.length === 0 ? 2 : 0;
     }
     if (typeof value === 'object') {
-        return Object.keys(value).length === 0;
+        return Object.keys(value).length === 0 ? 2 : 0;
     }
     if (typeof value === 'string') {
-        return value.length === 0;
+        return value.length === 0 ? 2 : 0;
     }
-    return false;
+    return 0;
 }
 /**
  * Rules

package/lib/engine/daemon.d.ts

@@ -127,21 +127,11 @@ export declare class DaemonTrx<S extends $Space, M extends $Module, AuthUsers ex
      *
      */
     private _origin?;
-    /**
-     * An idempotent transaction doesn't generate a commit/rollback.
-     */
-    private _idempotent;
     /**
      * @param trxEngine The transaction engine where to run the transaction.
      */
     constructor(trxEngine: AnyTrxEngine);
     origin(origin: string): this;
-    /**
-     * Flags this transaction as idempotent.
-     * This means its not stored, neither commited/rolled back.
-     * This should generally be used for readonly transactions.
-     */
-    idempotent(value?: boolean): this;
     /**
      * Inherit authentication from another transaction node.
      */
@@ -158,7 +148,7 @@ export declare class DaemonTrx<S extends $Space, M extends $Module, AuthUsers ex
      * @param fn A function to execute inside the transaction
      * @returns A `TrxStatus` containing metadata about the transaction and the function response
      */
-    run<Output>(fn: (trx: TrxNode<S, M, AuthUsers>) => Promise<Output>, id?: string): Promise<TrxStatus<Output>>;
+    run<Output>(fn: (trx: TrxNode<S, M, AuthUsers>) => Promise<Output>, id?: string, idempotent?: boolean): Promise<TrxStatus<Output>>;
     /**
      * Run a method inside the transaction, and hold it until
      * the external caller decides to commit.

package/lib/engine/daemon.js

@@ -180,10 +180,6 @@ class DaemonTrx {
      *
      */
     _origin;
-    /**
-     * An idempotent transaction doesn't generate a commit/rollback.
-     */
-    _idempotent = false;
     /**
      * @param trxEngine The transaction engine where to run the transaction.
      */
@@ -194,15 +190,6 @@ class DaemonTrx {
         this._origin = origin;
         return this;
     }
-    /**
-     * Flags this transaction as idempotent.
-     * This means its not stored, neither commited/rolled back.
-     * This should generally be used for readonly transactions.
-     */
-    idempotent(value = true) {
-        this._idempotent = value;
-        return this;
-    }
     /**
      * Inherit authentication from another transaction node.
      */
@@ -225,14 +212,14 @@ class DaemonTrx {
      * @param fn A function to execute inside the transaction
      * @returns A `TrxStatus` containing metadata about the transaction and the function response
      */
-    run(fn, id) {
+    run(fn, id, idempotent) {
         const inheritedAuth = this._inherit?.auth;
         const tokens = {
             ...inheritedAuth?.tokens,
             ...this.tokens
         };
         const users = inheritedAuth?.users;
-        return this.trxEngine.trx(fn, id, tokens, users, this._origin, this._idempotent);
+        return this.trxEngine.trx(fn, id, tokens, users, this._origin, idempotent);
     }
     /**
      * Run a method inside the transaction, and hold it until
@@ -248,17 +235,7 @@ class DaemonTrx {
             ...this.tokens
         };
         const users = inheritedAuth?.users;
-        // Idempotent transactions are not commited/rolled back, so they don't need to be held.
-        if (this._idempotent) {
-            const status = await this.trxEngine.trx(fn, id, tokens, users, this._origin, this._idempotent);
-            return {
-                id: status.id,
-                status,
-                commit: () => Promise.resolve(),
-                rollback: () => Promise.resolve(),
-            };
-        }
-        return this.trxEngine.trx_hold(fn, id, tokens, users);
+        return this.trxEngine.trx_hold(fn, id, tokens, users, this._origin);
     }
 }
 exports.DaemonTrx = DaemonTrx;

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

@@ -1,4 +1,14 @@
 import { NesoiDuration } from './duration';
+export type NesoiDateTimeValues = {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+    ms: number;
+    tz: NesoiDatetime['tz'];
+};
 /**
  * @category Engine
  * @subcategory Data
@@ -39,17 +49,41 @@ export declare class NesoiDatetime {
      */
     tz: keyof typeof NesoiDatetime.tz;
     constructor(epoch?: number, tz?: keyof typeof NesoiDatetime.tz);
-    toISO(): string;
+    atTimezone(tz: NesoiDatetime['tz']): NesoiDatetime;
     /**
      * Parse a timestamp from ISO 8601 format.
      *
      * Example: `2025-04-16T23:04:42.000-03:00`
      */
     static fromISO(iso: string): NesoiDatetime;
+    /**
+     * Make a new `NesoiDateTime`
+     * @param year Numeric year
+     * @param month 1~12
+     * @param day 1~31
+     * @param hour 0~24
+     * @param minute 0~60
+     * @param second 0~60
+     * @param ms 0~999
+     * @param tz
+     * @returns
+     */
+    static make(year?: number, month?: number, day?: number, hour?: number, minute?: number, second?: number, ms?: number, tz?: NesoiDatetime['tz']): NesoiDatetime;
+    static fromValues(values: Partial<NesoiDateTimeValues>): NesoiDatetime;
+    toISO(): string;
+    toValues(): NesoiDateTimeValues;
+    toJSDate(): Date;
     static now(): NesoiDatetime;
     static isoNow(): string;
     static shortIsoNow(): string;
     plus(period: `${number} ${keyof typeof NesoiDuration.UNITS}`): NesoiDatetime;
     minus(period: `${number} ${keyof typeof NesoiDuration.UNITS}`): NesoiDatetime;
     shift(period: `${'+' | '-'} ${number} ${keyof typeof NesoiDuration.UNITS}`): NesoiDatetime;
+    /**
+     * Returns a new `NesoiDatetime` which refers to the
+     * start of a given period **on the object timezone**.
+     * @param period
+     * @returns
+     */
+    startOf(period: 'day' | 'month' | 'year'): NesoiDatetime;
 }

package/lib/engine/data/datetime.js

@@ -43,25 +43,14 @@ class NesoiDatetime {
      */
     tz;
     constructor(epoch, tz = 'Z') {
-        this.epoch = epoch || new Date().getTime();
+        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;
+    // Manipulate timezone
+    atTimezone(tz) {
+        return new NesoiDatetime(this.epoch, tz);
     }
+    // Parse
     /**
      * Parse a timestamp from ISO 8601 format.
      *
@@ -87,6 +76,79 @@ class NesoiDatetime {
         const jsDate = Date.parse(iso);
         return new NesoiDatetime(jsDate, tz);
     }
+    /**
+     * Make a new `NesoiDateTime`
+     * @param year Numeric year
+     * @param month 1~12
+     * @param day 1~31
+     * @param hour 0~24
+     * @param minute 0~60
+     * @param second 0~60
+     * @param ms 0~999
+     * @param tz
+     * @returns
+     */
+    static make(year = 0, month = 1, day = 1, hour = 0, minute = 0, second = 0, ms = 0, tz = 'Z') {
+        const _month = (month < 10 ? '0' : '') + month;
+        const _day = (day < 10 ? '0' : '') + day;
+        const _hour = (hour < 10 ? '0' : '') + hour;
+        const _minute = (minute < 10 ? '0' : '') + minute;
+        const _second = (second < 10 ? '0' : '') + second;
+        const _ms = (ms < 100 ? '0' : '') + (ms < 10 ? '0' : '') + ms;
+        return this.fromISO(`${year}-${_month}-${_day}T${_hour}:${_minute}:${_second}.${_ms}${tz}`);
+    }
+    static fromValues(values) {
+        return this.make(values.year, values.month, values.day, values.hour, values.minute, values.second, values.ms, values.tz);
+    }
+    // Dump
+    toISO() {
+        const date = new Date(0);
+        date.setUTCMilliseconds(this.epoch);
+        return date.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;
+    }
+    toValues() {
+        const date = new Date(0);
+        date.setUTCMilliseconds(this.epoch);
+        const str = date.toLocaleString('sv-SE', {
+            timeZone: NesoiDatetime.tz[this.tz],
+            year: 'numeric',
+            month: 'numeric',
+            day: 'numeric',
+            hour: 'numeric',
+            minute: 'numeric',
+            second: 'numeric',
+            fractionalSecondDigits: 3,
+        });
+        const [_, year, month, day, hour, minute, second, ms] = str.match(/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}),(\d{3})/);
+        return {
+            year: parseInt(year),
+            month: parseInt(month),
+            day: parseInt(day),
+            hour: parseInt(hour),
+            minute: parseInt(minute),
+            second: parseInt(second),
+            ms: parseInt(ms),
+            tz: this.tz
+        };
+    }
+    toJSDate() {
+        const date = new Date(0);
+        date.setUTCMilliseconds(this.epoch);
+        return date;
+    }
+    // Now
     static now() {
         return new NesoiDatetime();
     }
@@ -96,6 +158,7 @@ class NesoiDatetime {
     static shortIsoNow() {
         return new NesoiDatetime().toISO().slice(5, 19);
     }
+    // Shift
     plus(period) {
         return this.shift(`+ ${period}`);
     }
@@ -157,5 +220,29 @@ class NesoiDatetime {
         }
         return new NesoiDatetime(epoch, this.tz);
     }
+    // Start Of
+    /**
+     * Returns a new `NesoiDatetime` which refers to the
+     * start of a given period **on the object timezone**.
+     * @param period
+     * @returns
+     */
+    startOf(period) {
+        const values = this.toValues();
+        values.ms = 0;
+        values.second = 0;
+        values.minute = 0;
+        values.hour = 0;
+        switch (period) {
+            case 'month':
+                values.day = 1;
+                break;
+            case 'year':
+                values.day = 1;
+                values.month = 1;
+                break;
+        }
+        return NesoiDatetime.fromValues(values);
+    }
 }
 exports.NesoiDatetime = NesoiDatetime;

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

@@ -120,6 +120,11 @@ export declare namespace NesoiError {
             path: string;
             bucket: string;
         }): BaseError;
+        function IdempotentTransaction($: {
+            bucket: string;
+            trx: string;
+            action: string;
+        }): BaseError;
         namespace Graph {
             function LinkNotFound($: {
                 bucket: string;
@@ -153,6 +158,10 @@ export declare namespace NesoiError {
             }): BaseError;
         }
         namespace Model {
+            function InvalidModelpath($: {
+                bucket: string;
+                modelpath: string;
+            }): BaseError;
             function InvalidEnum($: {
                 bucket: string;
                 value: string;
@@ -174,6 +183,14 @@ export declare namespace NesoiError {
                 bucket: string;
                 value: string;
             }): BaseError;
+            function InvalidNesoiDuration($: {
+                bucket: string;
+                value: string;
+            }): BaseError;
+            function InvalidNesoiDecimal($: {
+                bucket: string;
+                value: string;
+            }): BaseError;
         }
         namespace Drive {
             function NoAdapter($: {