zibri 2.3.0 → 2.4.0

package/src/routing/router.ts

@@ -9,7 +9,6 @@ import { MissingBaseRouteError } from './missing-base-route.error';
 import { createHeaderParamMetadata, createPathParamMetadata, createQueryParamMetadata } from './param-metdata.helpers';
 import { RouterInterface } from './router.interface';
 import { ZibriApplication } from '../application';
-import { runWithRequest } from './request.context';
 import { resolveRouteParams } from './resolve-route-params.function';
 import { OpenApiRouteConfiguration, RouteConfiguration, RouteConfigurationInput } from './route-configuration.model';
 import type { AuthServiceInterface } from '../auth/auth-service.interface';
@@ -28,6 +27,7 @@ import { MimeType } from '../http/mime-type.enum';
 import { type LoggerInterface } from '../logging/logger.interface';
 import { OpenApiResponse } from '../open-api/open-api.model';
 import { FileResponse } from '../parsing/form-data/file-response.model';
+import { buildCspHeaders, CspOptions, CspSource } from '../parsing/html/csp-options.model';
 import { HtmlResponse } from '../parsing/html/html-response.model';
 import type { ParserInterface } from '../parsing/parser.interface';
 import { Newable } from '../types/newable.type';
@@ -35,6 +35,10 @@ import { MetadataUtilities } from '../utilities/metadata.utilities';
 import { Ms } from '../utilities/ms';
 import type { ValidationServiceInterface } from '../validation/validation-service.interface';
 import { ControllerData } from './decorators/controller.decorator';
+import { AlsUtilities } from '../context/als.utilities';
+import { HttpRequestContext } from '../context/request/http-request.context';
+import { JsonUtilities } from '../utilities/json.utilities';
+import { ObjectUtilities } from '../utilities/object.utilities';
 
 /**
  * Default router implementation of Zibri.
@@ -77,7 +81,6 @@ export class Router implements RouterInterface, OnAppInit, OnAppStart {
     // eslint-disable-next-line jsdoc/require-jsdoc
     onAppStart(app: ZibriApplication): void {
         app.use(this.expressRouter);
-        app.use((req, _res, next) => runWithRequest(req as HttpRequest, () => next()));
     }
 
     private checkForOrphanedControllers(controllers: Newable<unknown>[]): void {
@@ -226,40 +229,54 @@ export class Router implements RouterInterface, OnAppInit, OnAppStart {
         HeaderMetaObject extends Record<string, HeaderParamMetadata>
     >(route: RouteConfiguration<BodyMetaObject, PathMetaObject, QueryMetaObject, HeaderMetaObject>): RequestHandler {
         const handler: RequestHandler = (async (
-            req: HttpRequest,
+            request: HttpRequest,
             res: HttpResponse,
             next: NextFunction
         ) => {
-            try {
-                if (route.bodyMetadata) {
-                    req.body = await this.parser.parseBody(req, route.bodyMetadata);
-                    this.validationService.validateBody(req.body, route.bodyMetadata);
-                }
-                for (const key in route.pathParams) {
-                    (req.params[key] as unknown) = this.parser.parsePathParam(req, route.pathParams[key]);
-                    this.validationService.validatePathParam(req.params[key], route.pathParams[key]);
-                }
-                for (const key in route.queryParams) {
-                    (req.query[key] as unknown) = this.parser.parseQueryParam(
-                        req,
-                        route.queryParams[key]
-                    );
-                    this.validationService.validateQueryParam(req.query[key], route.queryParams[key]);
+            const context: HttpRequestContext = new HttpRequestContext(request, res, undefined, undefined);
+            await AlsUtilities.runWithHttpRequestContext(context, async () => {
+                try {
+                    // parse
+                    for (const key of ObjectUtilities.keys(route.pathParams)) {
+                        (context.request.params[key] as unknown) = this.parser.parsePathParam(context.request, route.pathParams[key]);
+                    }
+                    for (const key of ObjectUtilities.keys(route.queryParams)) {
+                        (context.request.query[key] as unknown) = this.parser.parseQueryParam(
+                            context.request,
+                            route.queryParams[key]
+                        );
+                    }
+                    for (const key of ObjectUtilities.keys(route.headerParams)) {
+                        (context.request.headers[key] as unknown) = this.parser.parseHeaderParam(
+                            context.request,
+                            route.headerParams[key]
+                        );
+                    }
+                    if (route.bodyMetadata) {
+                        context.request.body = await this.parser.parseBody(context.request, route.bodyMetadata);
+                    }
+                    // validate
+                    await Promise.all([
+                        ...ObjectUtilities.keys(route.pathParams).map(async key => {
+                            await this.validationService.validatePathParam(context.request.params[key], route.pathParams[key]);
+                        }),
+                        ...ObjectUtilities.keys(route.queryParams).map(async key => {
+                            await this.validationService.validateQueryParam(context.request.query[key], route.queryParams[key]);
+                        }),
+                        ...ObjectUtilities.keys(route.headerParams).map(async key => {
+                            await this.validationService.validateHeaderParam(context.request.headers[key], route.headerParams[key]);
+                        }),
+                        ...route.bodyMetadata ? [this.validationService.validateBody(context.request.body, route.bodyMetadata)] : []
+                    ]);
+
+                    // eslint-disable-next-line typescript/no-explicit-any
+                    const result: unknown = await route.handler(context.request as HttpRequest<any, any, any, any>, context.response, next);
+                    await this.returnResult(context.response, result, next, []);
                 }
-                for (const key in route.headerParams) {
-                    (req.headers[key] as unknown) = this.parser.parseHeaderParam(
-                        req,
-                        route.headerParams[key]
-                    );
-                    this.validationService.validateHeaderParam(req.headers[key], route.headerParams[key]);
+                catch (error) {
+                    next(error);
                 }
-                // eslint-disable-next-line typescript/no-explicit-any
-                const result: unknown = await route.handler(req as HttpRequest<any, any, any, any>, res, next);
-                this.returnResult(res, result, next);
-            }
-            catch (error) {
-                next(error);
-            }
+            });
         }) as RequestHandler;
         return handler;
     }
@@ -273,29 +290,37 @@ export class Router implements RouterInterface, OnAppInit, OnAppStart {
             await this.logger.warn(`No responses defined on route ${controllerClass.name}.${route.controllerMethod}`);
         }
         const handler: RequestHandler = (async (req: HttpRequest, res: HttpResponse, next: NextFunction) => {
-            try {
-                await this.authService.checkAccess(controllerClass, route.controllerMethod, req);
-                const controller: unknown = inject(controllerClass);
-                const params: unknown[] = await this.resolveRouteParams(
-                    controllerClass,
-                    route.controllerMethod,
-                    // eslint-disable-next-line typescript/no-unsafe-member-access, typescript/no-explicit-any
-                    ((controller as any)[route.controllerMethod] as Function).length,
-                    req
-                );
+            const context: HttpRequestContext = new HttpRequestContext(
+                req,
+                res,
+                controllerClass,
+                route.controllerMethod
+            );
+            await AlsUtilities.runWithHttpRequestContext(context, async () => {
+                try {
+                    await this.authService.checkAccess(controllerClass, route.controllerMethod, context);
+                    const controller: unknown = inject(controllerClass);
+                    const params: unknown[] = await resolveRouteParams(
+                        controllerClass,
+                        route.controllerMethod,
+                        // eslint-disable-next-line typescript/no-unsafe-member-access, typescript/no-explicit-any
+                        ((controller as any)[route.controllerMethod] as Function).length,
+                        context
+                    );
 
-                // eslint-disable-next-line typescript/no-unsafe-call, typescript/no-explicit-any, typescript/no-unsafe-member-access
-                const result: unknown = await ((controller as any)[route.controllerMethod] as Function)(...params);
-                this.returnResult(res, result, next);
-            }
-            catch (error) {
-                next(error);
-            }
+                    // eslint-disable-next-line typescript/no-unsafe-call, typescript/no-explicit-any, typescript/no-unsafe-member-access
+                    const result: unknown = await ((controller as any)[route.controllerMethod] as Function)(...params);
+                    await this.returnResult(context.response, result, next, responses);
+                }
+                catch (error) {
+                    next(error);
+                }
+            });
         }) as RequestHandler;
         return handler;
     }
 
-    private returnResult(res: HttpResponse, result: unknown, next: NextFunction): void {
+    private async returnResult(res: HttpResponse, result: unknown, next: NextFunction, responses: OpenApiResponse[]): Promise<void> {
         if (res.headersSent) {
             return;
         }
@@ -304,88 +329,109 @@ export class Router implements RouterInterface, OnAppInit, OnAppStart {
             return;
         }
 
-        // if (
-        //     responses.length // all non error responses are json responses
-        //     && responses.filter(r => r.type !== 'error').length === responses.filter(r => r.type === 'json').length
-        //     && ((result instanceof FileResponse) || (result instanceof HtmlResponse))
-        // ) {
-        //     throw new Error('Invalid return value, json cannot be FileResponse or HtmlResponse');
-        // }
+        this.validateResultType(responses, result);
 
-        // if (
-        //     responses.length // all non error responses are file responses
-        //     && responses.filter(r => r.type !== 'error').length === responses.filter(r => r.type === 'file').length
-        //     && !(result instanceof FileResponse)
-        // ) {
-        //     throw new Error('Invalid return value, needs to be a FileResponse');
-        // }
+        if (result instanceof FileResponse) {
+            await this.returnFileResult(res, result, next);
+            return;
+        }
 
-        // if (
-        //     responses.length // all non error responses are html responses
-        //     && responses.filter(r => r.type !== 'error').length === responses.filter(r => r.type === 'html').length
-        //     && !(result instanceof FileResponse)
-        // ) {
-        //     throw new Error('Invalid return value, needs to be a HtmlResponse');
-        // }
+        if (result instanceof HtmlResponse) {
+            this.returnHtmlResult(res, result, next);
+            return;
+        }
 
-        if (result instanceof FileResponse) {
-            res.setHeader(KnownHeader.CONTENT_TYPE, result.mimeType as MimeType);
-            res.setHeader(KnownHeader.CONTENT_DISPOSITION, `attachment; filename="${encodeURIComponent(result.filename)}"`);
-            if (result.size != undefined) {
-                res.setHeader(KnownHeader.CONTENT_LENGTH, result.size);
-            }
+        res.json(JsonUtilities.parse(JsonUtilities.stringify(result)));
+    }
 
-            // send file from disk
-            if (typeof result.data === 'string') {
-                res.sendFile(result.data);
-                return;
+    private async returnFileResult(res: HttpResponse, result: FileResponse, next: NextFunction): Promise<void> {
+        res.setHeader(KnownHeader.CONTENT_TYPE, result.mimeType as MimeType);
+        res.setHeader(KnownHeader.CONTENT_DISPOSITION, `attachment; filename="${encodeURIComponent(result.filename)}"`);
+        if (result.size != undefined) {
+            res.setHeader(KnownHeader.CONTENT_LENGTH, result.size);
+        }
+        if (result.csp !== false) {
+            if (result.mimeType === MimeType.SVG) {
+                await this.logger.warn('Useless CSP headers found on a file that is not of type svg');
+            }
+            const csp: CspOptions = result.csp === true ? inject(ZIBRI_DI_TOKENS.DEFAULT_CSP_OPTIONS) : result.csp;
+            res.setHeader(KnownHeader.CONTENT_SECURITY_POLICY, buildCspHeaders(csp));
+            if (csp.frameAncestors.length === 1) {
+                const ancestor: CspSource = csp.frameAncestors[0];
+                if (ancestor === '\'none\'') {
+                    res.setHeader(KnownHeader.X_FRAME_OPTIONS, 'DENY');
+                }
+                else if (ancestor === '\'self\'') {
+                    // eslint-disable-next-line cspell/spellchecker
+                    res.setHeader(KnownHeader.X_FRAME_OPTIONS, 'SAMEORIGIN');
+                }
             }
+        }
 
-            // send file as stream
-            res.on('close', () => (result.data as Readable).destroy());
-            result.data.on('error', err => {
-                res.removeHeader(KnownHeader.CONTENT_TYPE);
-                res.removeHeader(KnownHeader.CONTENT_LENGTH);
-                res.removeHeader(KnownHeader.CONTENT_DISPOSITION);
-                next(err);
-            }).pipe(res);
+        // send file from disk
+        if (typeof result.data === 'string') {
+            res.sendFile(result.data);
             return;
         }
 
-        if (result instanceof HtmlResponse) {
-            res.setHeader(KnownHeader.CONTENT_TYPE, MimeType.HTML);
-            // send html as string
-            if (typeof result.data === 'string') {
-                res.type('.html').send(result.data);
-                return;
+        // send file as stream
+        res.on('close', () => (result.data as Readable).destroy());
+        result.data.on('error', err => {
+            res.removeHeader(KnownHeader.CONTENT_TYPE);
+            res.removeHeader(KnownHeader.CONTENT_LENGTH);
+            res.removeHeader(KnownHeader.CONTENT_DISPOSITION);
+            res.removeHeader(KnownHeader.CONTENT_SECURITY_POLICY);
+            next(err);
+        }).pipe(res);
+    }
+
+    private returnHtmlResult(res: HttpResponse, result: HtmlResponse, next: NextFunction): void {
+        res.setHeader(KnownHeader.CONTENT_TYPE, MimeType.HTML);
+        if (result.csp !== false) {
+            const csp: CspOptions = result.csp === true ? inject(ZIBRI_DI_TOKENS.DEFAULT_CSP_OPTIONS) : result.csp;
+            res.setHeader(KnownHeader.CONTENT_SECURITY_POLICY, buildCspHeaders(csp));
+            if (csp.frameAncestors.length === 1) {
+                const ancestor: CspSource = csp.frameAncestors[0];
+                if (ancestor === '\'none\'') {
+                    res.setHeader(KnownHeader.X_FRAME_OPTIONS, 'DENY');
+                }
+                else if (ancestor === '\'self\'') {
+                    // eslint-disable-next-line cspell/spellchecker
+                    res.setHeader(KnownHeader.X_FRAME_OPTIONS, 'SAMEORIGIN');
+                }
             }
-            // send html as stream
-            res.on('close', () => (result.data as Readable).destroy());
-            result.data.on('error', err => {
-                res.removeHeader(KnownHeader.CONTENT_TYPE);
-                next(err);
-            }).pipe(res);
+        }
+        // send html as string
+        if (typeof result.data === 'string') {
+            res.type('.html').send(result.data);
             return;
         }
-
-        res.json(result);
+        // send html as stream
+        res.on('close', () => (result.data as Readable).destroy());
+        result.data.on('error', err => {
+            res.removeHeader(KnownHeader.CONTENT_TYPE);
+            res.removeHeader(KnownHeader.CONTENT_SECURITY_POLICY);
+            next(err);
+        }).pipe(res);
     }
 
-    private async resolveRouteParams(
-        controllerClass: Newable<unknown>,
-        controllerMethod: string,
-        totalParamCount: number,
-        req: HttpRequest
-    ): Promise<unknown[]> {
-        return await resolveRouteParams(
-            controllerClass,
-            controllerMethod,
-            totalParamCount,
-            req,
-            this.parser,
-            this.validationService,
-            this.authService,
-            undefined
-        );
+    private validateResultType(responses: OpenApiResponse[], result: {}): void {
+        if (responses.some(r => r.type === 'json') // all non error responses are json responses
+            && responses.filter(r => r.type !== 'error').length === responses.filter(r => r.type === 'json').length
+            && ((result instanceof FileResponse) || (result instanceof HtmlResponse))) {
+            throw new Error('Invalid return value, json cannot be FileResponse or HtmlResponse');
+        }
+
+        if (responses.some(r => r.type === 'file') // all non error responses are file responses
+            && responses.filter(r => r.type !== 'error').length === responses.filter(r => r.type === 'file').length
+            && !(result instanceof FileResponse)) {
+            throw new Error('Invalid return value, needs to be a FileResponse');
+        }
+
+        if (responses.some(r => r.type === 'html') // all non error responses are html responses
+            && responses.filter(r => r.type !== 'error').length === responses.filter(r => r.type === 'html').length
+            && !(result instanceof HtmlResponse)) {
+            throw new Error('Invalid return value, needs to be a HtmlResponse');
+        }
     }
 }

package/src/types/any-enum.type.ts

@@ -1,2 +1,2 @@
 // eslint-disable-next-line jsdoc/require-jsdoc
-export type AnyEnum<T extends string | number = string | number> = { [key: string]: T };
+export type AnyEnum<T extends string | number | bigint = string | number | bigint> = { [key: string]: T };

package/src/types/deep-partial.type.ts

@@ -1,11 +1,14 @@
 // eslint-disable-next-line jsdoc/require-jsdoc
-export type DeepPartial<T> = T | (T extends (infer U)[]
-    ? DeepPartial<U>[]
-    : T extends Map<infer K, infer V>
-        ? Map<DeepPartial<K>, DeepPartial<V>>
-        : T extends Set<infer M>
-            ? Set<DeepPartial<M>>
-            : T extends object
-                ? {
-                    [K in keyof T]?: DeepPartial<T[K]>;
-                } : T);
+export type DeepPartial<T> = T | (
+    T extends Date
+        ? Date
+        : T extends (infer U)[]
+            ? DeepPartial<U>[]
+            : T extends Map<infer K, infer V>
+                ? Map<DeepPartial<K>, DeepPartial<V>>
+                : T extends Set<infer M>
+                    ? Set<DeepPartial<M>>
+                    : T extends object
+                        ? { [K in keyof T]?: DeepPartial<T[K]> }
+                        : T
+);

package/src/types/percentage.type.ts

@@ -4,7 +4,7 @@ type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] exte
     : Enumerate<N, [...Acc, Acc['length']]>;
 
 // eslint-disable-next-line jsdoc/require-jsdoc
-type IntRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>>;
+export type IntRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>>;
 
 /**
  * A number from 0 to 100.

package/src/utilities/bytes.ts

@@ -0,0 +1,20 @@
+/* eslint-disable typescript/typedef */
+// eslint-disable-next-line jsdoc/require-jsdoc
+export abstract class Bytes {
+    /**
+     * The amount of ms in a second.
+     */
+    static B = 1 as const;
+    /**
+     * The amount of ms in a minute.
+     */
+    static KB = 1000 as const;
+    /**
+     * The amount of ms in an hour.
+     */
+    static MB = 1_000_000 as const;
+    /**
+     * The amount of ms in a day.
+     */
+    static GB = 1_000_000_000 as const;
+}

package/src/utilities/doubly-linked-list.ts

@@ -0,0 +1,132 @@
+/**
+ * A node inside a DoublyLinkedList.
+ * You should never instantiate this directly.
+ */
+export class LinkedListNode<T> {
+    /**
+     * The actual value stored inside this node.
+     */
+    value: T;
+    /**
+     * The previous list node.
+     */
+    prev: LinkedListNode<T> | undefined = undefined;
+    /**
+     * The next list node.
+     */
+    next: LinkedListNode<T> | undefined = undefined;
+
+    constructor(value: T) {
+        this.value = value;
+    }
+}
+
+/**
+ * Generic doubly linked list with O(1) removal of arbitrary nodes
+ * and O(1) append / move-to-tail operations.
+ */
+export class DoublyLinkedList<T> {
+    /**
+     * The first list element.
+     */
+    head: LinkedListNode<T> | undefined = undefined;
+    /**
+     * The last list element.
+     */
+    tail: LinkedListNode<T> | undefined = undefined;
+
+    private _size: number = 0;
+
+    // eslint-disable-next-line jsdoc/require-returns
+    /**
+     * The amount of elements inside the list.
+     */
+    get size(): number {
+        return this._size;
+    }
+
+    /**
+     * Appends a value and returns its node (you keep it for later removal).
+     * @param value - The value to add.
+     * @returns The list node of the just added value.
+     */
+    addLast(value: T): LinkedListNode<T> {
+        const node: LinkedListNode<T> = new LinkedListNode(value);
+        if (!this.tail) {
+            this.head = this.tail = node;
+        }
+        else {
+            node.prev = this.tail;
+            this.tail.next = node;
+            this.tail = node;
+        }
+        this._size++;
+        return node;
+    }
+
+    /**
+     * Removes the given node in O(1).
+     * @param node - The node to remove.
+     */
+    remove(node: LinkedListNode<T>): void {
+        if (node.prev) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+
+        if (node.next) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+
+        // Prevent accidental reuse
+        node.prev = node.next = undefined;
+        this._size--;
+    }
+
+    /**
+     * Moves an existing node to the tail (mark as most recently used).
+     * @param node - The node to move to the tail.
+     */
+    moveToTail(node: LinkedListNode<T>): void {
+        if (node === this.tail) {
+            return;
+        } // already last
+        // remove from current position
+        if (node.prev) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+
+        // re-insert at tail
+        node.prev = this.tail;
+        node.next = undefined;
+        if (this.tail) {
+            this.tail.next = node;
+        }
+        else {
+            this.head = node;
+        }
+        this.tail = node;
+    }
+
+    /**
+     * Clears the list completely.
+     */
+    clear(): void {
+        this.head = this.tail = undefined;
+        this._size = 0;
+    }
+}

package/src/utilities/is-numeric.function.ts

@@ -1,14 +1,16 @@
+const NUMERIC_REGEX: RegExp = /^-?(0|[1-9]\d*)(\.\d+)?$/;
+
 /**
  * Checks whether or not the given value is numeric.
  * @param value - The value to check.
  * @returns True if the value is numeric, false otherwise.
  */
-export function isNumeric(value: unknown): boolean {
+export function isNumeric(value: unknown): value is number | string {
     if (typeof value === 'number') {
         return true;
     }
     if (typeof value === 'string') {
-        return /^-?\d+(\.\d+)?$/.test(value);
+        return NUMERIC_REGEX.test(value);
     }
     return false;
 }

package/src/utilities/json.utilities.ts

@@ -0,0 +1,37 @@
+/**
+ * Utilities for handling json.
+ */
+export abstract class JsonUtilities {
+    /**
+     * Converts a JavaScript Object Notation (JSON) string into an object.
+     * @param value - A valid JSON string.
+     * @param reviver - A function that transforms the results. This function is called for each member of the object.
+     * If a member contains nested objects, the nested objects are transformed before the parent object is.
+     * @throws {SyntaxError} If `text` is not valid JSON.
+     * @returns The parsed object.
+     */
+    // eslint-disable-next-line typescript/no-explicit-any
+    static parse<T>(value: string, reviver?: (this: any, key: string, value: unknown) => unknown): T {
+        return JSON.parse(value, reviver) as T;
+    }
+
+    /**
+     * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+     * @param value - A JavaScript value, usually an object or array, to be converted.
+     * @param replacer - A function that transforms the results.
+     * @param space - Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+     * @throws {TypeError} If a circular reference is found.
+     * @returns A json string.
+     */
+    // eslint-disable-next-line typescript/no-explicit-any
+    static stringify<T>(value: T, replacer?: (this: any, key: string, value: unknown) => unknown, space?: string | number): string {
+        return JSON.stringify(
+            value,
+            (_key, value: unknown) => {
+                const res: unknown = typeof value === 'bigint' ? value.toString() : value;
+                return replacer ? replacer(_key, res) : res;
+            },
+            space
+        );
+    }
+}

package/src/utilities/metadata-injection-keys.enum.ts

@@ -43,5 +43,6 @@ export enum MetadataInjectionKeys {
     BACKUP_RESOURCE_METADATA = 'backup_resource:metadata',
     WEBSOCKET_CONTROLLER_DATA = 'websocket_controller:data',
     WEBSOCKET_CONTROLLER_ROUTES = 'websocket_controller:routes',
-    ROUTE_CURRENT_WEBSOCKET_CONNECTION = 'route:current_websocket_connection'
+    ROUTE_CURRENT_WEBSOCKET_CONNECTION = 'route:current_websocket_connection',
+    EXCLUDED_PROPERTY_VALUE = 'entity:excluded_property_value'
 }

package/src/utilities/ms.ts

@@ -21,4 +21,12 @@ export abstract class Ms {
      * The amount of ms in a week.
      */
     static WEEK = 604_800_000 as const;
+    /**
+     * The amount of ms in a month.
+     */
+    static MONTH = 2_629_746_000 as const;
+    /**
+     * The amount of ms in a year.
+     */
+    static YEAR = 31_556_952_000 as const;
 }

package/src/utilities/now-in-ns.function.ts

@@ -0,0 +1,13 @@
+import { NumberUtilities } from './number.utilities';
+
+const startHr: bigint = process.hrtime.bigint();
+// its okay that we loose precision here, that's what the calculation below is for
+const startInNs: bigint = BigInt(NumberUtilities.multiply(Date.now(), 1_000_000).toString());
+
+/**
+ * Gets the current timestamp with nanosecond precision.
+ * @returns The nanoseconds as a bigint.
+ */
+export function nowInNs(): bigint {
+    return startInNs + (process.hrtime.bigint() - startHr);
+}