nesoi 3.0.0 → 3.0.3

package/lib/engine/transaction/nodes/bucket_query.trx_node.d.ts

@@ -3,15 +3,17 @@ import { TrxNode } from '../trx_node';
 import { $Bucket } from "../../../elements/entities/bucket/bucket.schema";
 import { Bucket } from "../../../elements/entities/bucket/bucket";
 import { NQL_AnyQuery, NQL_Pagination, NQL_Query } from "../../../elements/entities/bucket/query/nql.schema";
+import { NQL_Result } from "../../../elements/entities/bucket/query/nql_engine";
 export declare class BucketQueryTrxNode<M extends $Module, B extends $Bucket, V extends ViewName<B>, Obj = ViewObj<B, V>> {
     private trx;
     private bucket;
     private query;
     private view;
-    constructor(trx: TrxNode<any, M, any>, bucket: Bucket<M, B>, query: NQL_AnyQuery, view: V);
+    private enableTenancy;
+    constructor(trx: TrxNode<any, M, any>, bucket: Bucket<M, B>, query: NQL_AnyQuery, view: V, enableTenancy: boolean);
     merge($: NQL_Query<M, B>): void;
     first(): Promise<Obj | undefined>;
     firstOrFail(): Promise<Obj>;
     all(): Promise<Obj[]>;
-    page(pagination: NQL_Pagination): Promise<Obj[]>;
+    page(pagination?: NQL_Pagination): Promise<NQL_Result<Obj>>;
 }

package/lib/engine/transaction/nodes/bucket_query.trx_node.js

@@ -4,11 +4,12 @@ exports.BucketQueryTrxNode = void 0;
 const trx_node_1 = require("../trx_node");
 const error_1 = require("../../data/error");
 class BucketQueryTrxNode {
-    constructor(trx, bucket, query, view) {
+    constructor(trx, bucket, query, view, enableTenancy) {
         this.trx = trx;
         this.bucket = bucket;
         this.query = query;
         this.view = view;
+        this.enableTenancy = enableTenancy;
     }
     merge($) {
         const and = $['#and'];
@@ -23,34 +24,40 @@ class BucketQueryTrxNode {
         await trx_node_1.TrxNode.open(this.trx, 'queryFirst', { schema: this.query, view: this.view });
         let results;
         try {
-            results = await this.bucket.query(this.trx, this.query, undefined, this.view);
+            results = await this.bucket.query(this.trx, this.query, {
+                perPage: 1
+            }, this.view, {
+                no_tenancy: !this.enableTenancy
+            });
         }
         catch (e) {
             await trx_node_1.TrxNode.error(this.trx, e); // Bucket unexpected error
             throw e;
         }
-        await trx_node_1.TrxNode.ok(this.trx, { length: results.length });
-        return results.length
-            ? results[0]
+        await trx_node_1.TrxNode.ok(this.trx, { length: results.data.length });
+        return results.data.length
+            ? results.data[0]
             : undefined;
     }
     async firstOrFail() {
         await trx_node_1.TrxNode.open(this.trx, 'queryFirstOrFail', { schema: this.query, view: this.view });
         let results;
         try {
-            results = await this.bucket.query(this.trx, this.query, undefined, this.view);
+            results = await this.bucket.query(this.trx, this.query, undefined, this.view, {
+                no_tenancy: !this.enableTenancy
+            });
         }
         catch (e) {
             await trx_node_1.TrxNode.error(this.trx, e); // Bucket unexpected error
             throw e;
         }
-        if (!results.length) {
+        if (!results.data.length) {
             const e = error_1.NesoiError.Bucket.Query.NoResults({ bucket: this.bucket.schema.alias, query: this.query });
             await trx_node_1.TrxNode.error(this.trx, e);
             throw e;
         }
-        await trx_node_1.TrxNode.ok(this.trx, { length: results.length });
-        return results[0];
+        await trx_node_1.TrxNode.ok(this.trx, { length: results.data.length });
+        return results.data[0];
     }
     async all() {
         await trx_node_1.TrxNode.open(this.trx, 'queryAll', { schema: this.query, view: this.view });
@@ -62,21 +69,26 @@ class BucketQueryTrxNode {
             await trx_node_1.TrxNode.error(this.trx, e); // Bucket unexpected error
             throw e;
         }
-        await trx_node_1.TrxNode.ok(this.trx, { length: results.length });
-        return results;
+        await trx_node_1.TrxNode.ok(this.trx, { length: results.data.length });
+        return results.data;
     }
     async page(pagination) {
+        if (!pagination) {
+            return {
+                data: await this.all()
+            };
+        }
         await trx_node_1.TrxNode.open(this.trx, 'queryPage', { schema: this.query, pagination, view: this.view });
-        let results;
+        let result;
         try {
-            results = await this.bucket.query(this.trx, this.query, pagination, this.view);
+            result = await this.bucket.query(this.trx, this.query, pagination, this.view);
         }
         catch (e) {
             await trx_node_1.TrxNode.error(this.trx, e); // Bucket unexpected error
             throw e;
         }
-        await trx_node_1.TrxNode.ok(this.trx, { length: results.length });
-        return results;
+        await trx_node_1.TrxNode.ok(this.trx, { length: result.data.length });
+        return result;
     }
 }
 exports.BucketQueryTrxNode = BucketQueryTrxNode;

package/lib/engine/transaction/nodes/job.trx_node.d.ts

@@ -3,11 +3,12 @@ import { TrxNode } from '../trx_node';
 import { $Job } from "../../../elements/blocks/job/job.schema";
 import { Job } from "../../../elements/blocks/job/job";
 import { Message } from "../../../elements/entities/message/message";
+import { JobInput } from "../../../elements/blocks/job/job.types";
 export declare class JobTrxNode<M extends $Module, $ extends $Job> {
     private trx;
     private job;
     private ctx?;
     constructor(trx: TrxNode<any, M, any>, job: Job<any, M, $>, ctx?: Record<string, any> | undefined);
-    run(message: $['#input']['#raw']): Promise<$['#output']>;
+    run(message: JobInput<$>): Promise<$['#output']>;
     forward(message: Message<$['#input']>): Promise<$['#output']>;
 }

package/lib/engine/transaction/nodes/job.trx_node.js

@@ -11,6 +11,12 @@ class JobTrxNode {
     async run(message) {
         const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.job.schema.module, 'job', this.job.schema.name);
         await trx_node_1.TrxNode.open(trx, 'run', message);
+        // Special case for Jobs with a '' inline message,
+        // which is not required on the run method.
+        if (!('$' in message)
+            && this.job.schema.input.some(dep => dep.tag === `${this.job.module.name}::message:${this.job.schema.name}`)) {
+            message['$'] = this.job.schema.name;
+        }
         let response;
         try {
             response = await this.job.consumeRaw(trx, message, this.ctx);

package/lib/engine/transaction/trx.d.ts

@@ -2,7 +2,7 @@ import { $Module, $Space } from "../../schema";
 import { Module } from '../module';
 import { AnyTrxNode, TrxNode, TrxNodeStatus } from './trx_node';
 import { TrxEngineOrigin } from './trx_engine';
-import { AnyUsers } from '../auth/authn';
+import { AnyUsers, AuthnRequest } from '../auth/authn';
 import { NesoiDatetime } from '../data/datetime';
 type TrxOrigin = TrxEngineOrigin | `trx:${string}`;
 type TrxState = 'open' | 'ok' | 'error';
@@ -27,7 +27,10 @@ export declare class Trx<S extends $Space, M extends $Module, Authn extends AnyU
     start: NesoiDatetime;
     end?: NesoiDatetime;
     ctx: Record<string, any>;
-    constructor(module: Module<S, M>, origin: TrxOrigin, users?: Authn, id?: string, root?: TrxNode<S, M, Authn>, nodes?: Record<string, TrxNode<S, M, Authn>>);
+    constructor(module: Module<S, M>, origin: TrxOrigin, authn?: {
+        tokens: AuthnRequest<any>;
+        users: Authn;
+    }, id?: string, root?: TrxNode<S, M, Authn>, nodes?: Record<string, TrxNode<S, M, Authn>>);
     addNode(node: TrxNode<S, M, Authn>): void;
     status(): TrxStatus<any>;
     /**

package/lib/engine/transaction/trx.js

@@ -46,13 +46,13 @@ class TrxStatus {
 }
 exports.TrxStatus = TrxStatus;
 class Trx {
-    constructor(module, origin, users, id, root, nodes) {
+    constructor(module, origin, authn, id, root, nodes) {
         this.start = datetime_1.NesoiDatetime.now();
         this.ctx = {};
         this.module = module;
         this.id = id || (Math.random() + 1).toString(36).substring(7);
         this.origin = origin;
-        this.root = root || new trx_node_1.TrxNode('root', this, undefined, module, users, id);
+        this.root = root || new trx_node_1.TrxNode('root', this, undefined, module, authn, id);
         this.nodes = nodes || {};
     }
     addNode(node) {

package/lib/engine/transaction/trx_engine.config.d.ts

@@ -9,7 +9,5 @@ export type TrxEngineConfig<S extends $Space, M extends $Module, Authn extends A
      * Adapter used to store transactions of this module.
      */
     adapter?: (schema: M) => BucketAdapter<AnyTrx>;
-    trx?: {
-        wrap?: <T extends Trx<S, M, Authn>>(trx: T, fn: TrxEngineWrapFn<S, M>, providers: Providers) => Promise<any>;
-    };
+    wrap?: <T extends Trx<S, M, Authn>>(trx: T, fn: TrxEngineWrapFn<S, M>, providers: Providers) => Promise<any>;
 };

package/lib/engine/transaction/trx_engine.d.ts

@@ -2,7 +2,7 @@ import { $Module, $Space } from "../../schema";
 import { Module } from '../module';
 import { Trx } from './trx';
 import { TrxNode, TrxNodeStatus } from './trx_node';
-import { AnyAuthnProviders, AnyUsers, AuthnRequest } from '../auth/authn';
+import { AnyAuthnProviders, AuthnRequest } from '../auth/authn';
 import { TrxEngineConfig } from './trx_engine.config';
 export type TrxEngineOrigin = `app:${string}`;
 export declare class TrxEngine<S extends $Space, M extends $Module, Authn extends AnyAuthnProviders> {
@@ -18,7 +18,7 @@ export declare class TrxEngine<S extends $Space, M extends $Module, Authn extend
     private adapter;
     constructor(origin: TrxEngineOrigin, module: Module<S, M>, authnProviders?: Authn | undefined, config?: TrxEngineConfig<S, M, any, any> | undefined, providers?: Record<string, any>);
     getModule(): Module<S, M>;
-    get(id?: string, users?: AnyUsers): Promise<Trx<S, M, any>>;
+    get(id?: string): Promise<Trx<S, M, any>>;
     trx(fn: (trx: TrxNode<S, M, any>) => Promise<TrxNodeStatus>, authn?: AuthnRequest<keyof Authn>): Promise<import("./trx").TrxStatus<any>>;
     private authenticate;
     private commit;

package/lib/engine/transaction/trx_engine.js

@@ -22,12 +22,12 @@ class TrxEngine {
     getModule() {
         return this.module;
     }
-    async get(id, users) {
+    async get(id) {
         let trx = undefined;
         if (!id) {
-            trx = new trx_1.Trx(this.module, this.origin, users);
+            trx = new trx_1.Trx(this.module, this.origin);
             log_1.Log.info('module', this.module.name, `Begin ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
-            return this.adapter.put(this.innerTrx.root, trx);
+            return this.adapter.create(this.innerTrx.root, trx);
         }
         else {
             trx = await this.adapter.get(this.innerTrx.root, id);
@@ -36,19 +36,22 @@ class TrxEngine {
             }
             else {
                 log_1.Log.info('module', this.module.name, `Chain ${(0, log_1.scopeTag)('trx', id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
-                trx = new trx_1.Trx(this.module, this.origin, users, id);
-                return this.adapter.put(this.innerTrx.root, trx);
+                trx = new trx_1.Trx(this.module, this.origin, undefined, id);
+                return this.adapter.create(this.innerTrx.root, trx);
             }
         }
         return trx;
     }
     async trx(fn, authn) {
-        const users = authn ? await this.authenticate(authn) : undefined;
-        const trx = await this.get(undefined, users);
+        const trx = await this.get(undefined);
         try {
+            const users = authn ? await this.authenticate(trx.root, authn) : undefined;
+            if (users) {
+                trx_node_1.TrxNode.addAuthn(trx.root, authn, users);
+            }
             let output;
-            if (this.config?.trx?.wrap) {
-                output = await this.config?.trx?.wrap(trx, fn, this.providers);
+            if (this.config?.wrap) {
+                output = await this.config?.wrap(trx, fn, this.providers);
             }
             else {
                 output = await fn(trx.root);
@@ -61,7 +64,7 @@ class TrxEngine {
         return trx.status();
     }
     // authentication
-    async authenticate(request) {
+    async authenticate(trx, request) {
         if (!this.authnProviders) {
             throw error_1.NesoiError.Authn.NoProvidersRegisteredForModule(this.module.name);
         }
@@ -71,7 +74,7 @@ class TrxEngine {
             if (!(provider in this.authnProviders)) {
                 throw error_1.NesoiError.Authn.NoProviderRegisteredForModule(this.module.name, provider);
             }
-            users[provider] = await this.authnProviders[provider].authenticate(token);
+            users[provider] = await this.authnProviders[provider].authenticate({ trx, token });
         }
         return users;
     }

package/lib/engine/transaction/trx_node.d.ts

@@ -7,7 +7,7 @@ import { QueueTrxNode } from './nodes/queue.trx_node';
 import { ResourceTrxNode } from './nodes/resource.trx_node';
 import { $Message } from "../../elements/entities/message/message.schema";
 import { MachineTrxNode } from './nodes/machine.trx_node';
-import { AnyUsers } from '../auth/authn';
+import { AnyUsers, AuthnRequest } from '../auth/authn';
 import { Enum } from "../../elements/entities/constants/constants";
 import { KeysOfUnion } from '../util/type';
 type TrxNodeBlock = 'bucket' | 'message' | 'job' | 'resource' | 'machine' | 'queue' | 'controller';
@@ -27,7 +27,7 @@ export declare class TrxNode<Space extends $Space, M extends $Module, Authn exte
     private trx;
     private parent;
     private module;
-    private users?;
+    private authn?;
     id: string;
     globalId: string;
     private children;
@@ -37,7 +37,10 @@ export declare class TrxNode<Space extends $Space, M extends $Module, Authn exte
     private output?;
     private error?;
     private time;
-    constructor(scope: 'root' | `${string}::${TrxNodeBlock}:${string}` | `${string}::virtual`, trx: AnyTrx, parent: AnyTrxNode | undefined, module: AnyModule, users?: Authn | undefined, id?: string);
+    constructor(scope: 'root' | `${string}::${TrxNodeBlock}:${string}` | `${string}::virtual`, trx: AnyTrx, parent: AnyTrxNode | undefined, module: AnyModule, authn?: {
+        tokens: AuthnRequest<any>;
+        users: Authn;
+    } | undefined, id?: string);
     static open(node: AnyTrxNode, action: string, input: Record<string, any>): Promise<void>;
     static ok(node: AnyTrxNode, output?: Record<string, any>): Promise<void>;
     static error(node: AnyTrxNode, error: any): Promise<void>;
@@ -50,12 +53,19 @@ export declare class TrxNode<Space extends $Space, M extends $Module, Authn exte
     resource<Name extends keyof M['resources'], Resource extends M['resources'][Name]>(name: Name): ResourceTrxNode<M, Resource>;
     machine<Name extends keyof M['machines'], Machine extends M['machines'][Name]>(name: Name): MachineTrxNode<M, Machine>;
     queue<Name extends keyof M['queues'], Queue extends M['queues'][Name]>(name: Name): QueueTrxNode<M, Queue>;
+    token<U extends keyof Authn & keyof M['#authn']>(provider: U): M['#authn'][U];
     user<U extends keyof Authn & keyof M['#authn']>(provider: U): M['#authn'][U];
     virtual<T>(def: VirtualModuleDef, fn: ($: AnyTrxNode) => T | Promise<T>): Promise<T>;
     status(): TrxNodeStatus;
     static makeChildNode<Space extends $Space, M extends $Module, Authn extends AnyUsers>(node: TrxNode<Space, M, Authn>, module: string, block: TrxNodeBlock, name: string): TrxNode<Space, M, Authn>;
     static makeVirtualChildNode<Space extends $Space, M extends $Module, Authn extends AnyUsers>(node: TrxNode<Space, M, Authn>, module: AnyModule): TrxNode<Space, M, Authn>;
-    static getModule(node: TrxNode<any, any, any>): AnyModule;
+    static addAuthn(node: AnyTrxNode, tokens: AuthnRequest<any>, users: AnyUsers): void;
+    static getModule(node: AnyTrxNode): AnyModule;
+    static getFirstUserMatch(node: AnyTrxNode, authnProviders?: Record<string, any>): {
+        provider: string;
+        user: any;
+    } | undefined;
+    static checkAuthn(node: AnyTrxNode, authnProviderOptions?: string[]): void;
 }
 export type AnyTrxNode = TrxNode<any, any, any>;
 export {};

package/lib/engine/transaction/trx_node.js

@@ -16,12 +16,12 @@ const datetime_1 = require("../data/datetime");
     Transaction Node
 */
 class TrxNode {
-    constructor(scope, trx, parent, module, users, id) {
+    constructor(scope, trx, parent, module, authn, id) {
         this.scope = scope;
         this.trx = trx;
         this.parent = parent;
         this.module = module;
-        this.users = users;
+        this.authn = authn;
         this.children = [];
         this.time = {
             start: datetime_1.NesoiDatetime.now(),
@@ -117,17 +117,25 @@ class TrxNode {
         return new queue_trx_node_1.QueueTrxNode(this, queue);
     }
     // Authentication
+    token(provider) {
+        if (!this.authn?.tokens) {
+            throw error_1.NesoiError.Authn.NoUsersAuthenticatedForTrxNode(this.globalId);
+        }
+        return this.authn?.tokens[provider];
+    }
     user(provider) {
-        if (!this.users) {
+        if (!this.authn?.users) {
             throw error_1.NesoiError.Authn.NoUsersAuthenticatedForTrxNode(this.globalId);
         }
-        return this.users[provider];
+        return this.authn?.users[provider];
     }
     // Virtual Module Transaction
     async virtual(def, fn) {
+        if (!this.module.daemon) {
+            throw new Error(`Internal Error: unable to reach nesoi daemon when building virtual module '${def.name}'`);
+        }
         // Build virtual module
-        const module = TrxNode.getModule(this);
-        const virtualModule = await module_1.Module.virtual(module, def);
+        const virtualModule = await module_1.Module.virtual(this.module.daemon, def);
         // Create trx node of virtual module
         const node = TrxNode.makeVirtualChildNode(this, virtualModule);
         await TrxNode.open(node, 'run', {});
@@ -157,19 +165,53 @@ class TrxNode {
     }
     //
     static makeChildNode(node, module, block, name) {
-        const child = new TrxNode(`${module}::${block}:${name}`, node.trx, node, node.module);
+        const child = new TrxNode(`${module}::${block}:${name}`, node.trx, node, node.module, node.authn);
         node.children.push(child);
         node.trx.addNode(child);
         return child;
     }
     static makeVirtualChildNode(node, module) {
-        const child = new TrxNode(`${module.name}::virtual`, node.trx, node, module);
+        const child = new TrxNode(`${module.name}::virtual`, node.trx, node, module, node.authn);
         node.children.push(child);
         node.trx.addNode(child);
         return child;
     }
+    static addAuthn(node, tokens, users) {
+        var _a, _b;
+        node.authn ?? (node.authn = {
+            tokens: {},
+            users: {}
+        });
+        (_a = node.authn).tokens ?? (_a.tokens = {});
+        (_b = node.authn).users ?? (_b.users = {});
+        Object.assign(node.authn.tokens, tokens);
+        Object.assign(node.authn.users, users);
+    }
     static getModule(node) {
         return node.module;
     }
+    static getFirstUserMatch(node, authnProviders) {
+        if (!authnProviders)
+            return undefined;
+        for (const provider in authnProviders) {
+            const user = node.authn?.users[provider];
+            if (user) {
+                return { provider, user };
+            }
+        }
+        return undefined;
+    }
+    static checkAuthn(node, authnProviderOptions) {
+        if (!authnProviderOptions?.length)
+            return;
+        if (node.authn?.users) {
+            for (const provider of authnProviderOptions) {
+                if (provider in node.authn.users) {
+                    return;
+                }
+            }
+        }
+        throw error_1.NesoiError.Trx.NotAuthenticated({});
+    }
 }
 exports.TrxNode = TrxNode;

package/lib/engine/tree.d.ts

@@ -28,7 +28,7 @@ export declare class ModuleTree {
         module: string;
         type: BuilderType;
         name: string;
-    }): import("../elements").$Message | import("../elements").$Bucket | import("../elements").$Constants | import("../elements").$Externals | import("../elements").$Job | import("../elements").$Resource | import("../elements").$Machine | import("../elements").$Controller;
+    }): import("../elements").$Message | import("../elements").$Machine | import("../elements").$Bucket | import("../elements").$Constants | import("../elements").$Job | import("../elements").$Externals | import("../elements").$Resource | import("../elements").$Controller;
     allNodes(): ResolvedBuilderNode[];
 }
 export {};

package/lib/engine/util/crypto.d.ts

@@ -0,0 +1,50 @@
+export declare class Crypto {
+    static DEFAULTS: {
+        algorithm: string;
+        /**
+         * NIST recommends 96 bits or 12 bytes IV for GCM
+         * to promote interoperability, efficiency, and
+         * simplicity of design
+         */
+        iv_bytes: number;
+        /**
+         * Note: 256 (in algorithm name) is key size.
+         * Block size for AES is always 128
+         */
+        key_bytes: number;
+        /**
+         * To prevent rainbow table attacks
+         * */
+        salt_bytes: number;
+    };
+    /**
+     * To prevent rainbow table attacks
+     * */
+    static getIV(): Buffer;
+    /**
+     * To prevent rainbow table attacks
+     * */
+    static getSalt(): Buffer;
+    /**
+     *
+     * @param {Buffer} password - The password to be used for generating key
+     *
+     */
+    static getKeyFromPassword(password: string, salt: string): string;
+    /**
+     *
+     * @param {string} payload - The clear text message to be encrypted
+     * @param {string} key - The key to be used for encryption
+     */
+    static encrypt(value: any, key: string): string;
+    /**
+     *
+     * @param {Buffer} ciphertext - Cipher text
+     * @param {Buffer} key - The key to be used for decryption
+     *
+     * The caller of this function has the responsibility to clear
+     * the Buffer after the decryption to prevent the message text
+     * and the key from lingering in the memory
+     */
+    static decrypt(ciphertext: string, key: string): any;
+}

package/lib/engine/util/crypto.js

@@ -0,0 +1,89 @@
+"use strict";
+// TODO: Jest breaks with crypto types.
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+//@ts-nocheck
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Crypto = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+class Crypto {
+    /**
+     * To prevent rainbow table attacks
+     * */
+    static getIV() {
+        return crypto_1.default.randomBytes(this.DEFAULTS.iv_bytes);
+    }
+    /**
+     * To prevent rainbow table attacks
+     * */
+    static getSalt() {
+        return crypto_1.default.randomBytes(this.DEFAULTS.salt_bytes);
+    }
+    /**
+     *
+     * @param {Buffer} password - The password to be used for generating key
+     *
+     */
+    static getKeyFromPassword(password, salt) {
+        const buffer = crypto_1.default.scryptSync(password, salt, this.DEFAULTS.key_bytes);
+        const str = buffer.toString();
+        buffer.fill(0);
+        return str;
+    }
+    /**
+     *
+     * @param {string} payload - The clear text message to be encrypted
+     * @param {string} key - The key to be used for encryption
+     */
+    static encrypt(value, key) {
+        const payload = JSON.stringify(value);
+        const iv = this.getIV();
+        const cipher = crypto_1.default.createCipheriv(this.DEFAULTS.algorithm, key, iv);
+        let encrypted = cipher.update(payload);
+        encrypted = Buffer.concat([encrypted, cipher.final()]);
+        const buffer = Buffer.concat([iv, encrypted]);
+        const str = buffer.toString();
+        buffer.fill(0);
+        return str;
+    }
+    /**
+     *
+     * @param {Buffer} ciphertext - Cipher text
+     * @param {Buffer} key - The key to be used for decryption
+     *
+     * The caller of this function has the responsibility to clear
+     * the Buffer after the decryption to prevent the message text
+     * and the key from lingering in the memory
+     */
+    static decrypt(ciphertext, key) {
+        const iv = ciphertext.slice(0, 12);
+        const encryptedMessage = ciphertext.slice(12, -16);
+        const decipher = crypto_1.default.createDecipheriv(this.DEFAULTS.algorithm, key, iv);
+        const payload = decipher.update(encryptedMessage, 'utf8');
+        const buffer = Buffer.concat([payload, decipher.final()]);
+        const str = buffer.toString();
+        buffer.fill(0);
+        return JSON.parse(str);
+    }
+}
+exports.Crypto = Crypto;
+Crypto.DEFAULTS = {
+    algorithm: 'aes-256',
+    /**
+     * NIST recommends 96 bits or 12 bytes IV for GCM
+     * to promote interoperability, efficiency, and
+     * simplicity of design
+     */
+    iv_bytes: 12,
+    /**
+     * Note: 256 (in algorithm name) is key size.
+     * Block size for AES is always 128
+     */
+    key_bytes: 32,
+    /**
+     * To prevent rainbow table attacks
+     * */
+    salt_bytes: 16
+};

package/lib/engine/util/deep.d.ts

@@ -5,3 +5,8 @@ export type DeepPartial<T> = T extends object ? {
 export type DeepPartialNullable<T> = UndefinedToOptional<T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]> | null;
 } : T>;
+type Obj = Record<string, any>;
+export declare class Deep {
+    static copy<T extends Obj>(obj: T): T;
+}
+export {};

package/lib/engine/util/deep.js

@@ -1,2 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deep = void 0;
+class Deep {
+    static copy(obj) {
+        const copy = {};
+        let poll = [[obj, copy]];
+        while (poll.length) {
+            const next = [];
+            for (const [obj, copy] of poll) {
+                if (Array.isArray(obj)) {
+                    for (const item of obj) {
+                        if (item === null) {
+                            copy.push(null);
+                        }
+                        else if (typeof item === 'object') {
+                            const nextCopy = Array.isArray(item) ? [] : {};
+                            copy.push(nextCopy);
+                            next.push([item, nextCopy]);
+                        }
+                        else {
+                            copy.push(item);
+                        }
+                    }
+                }
+                else {
+                    for (const key in obj) {
+                        const item = obj[key];
+                        if (item === null) {
+                            copy[key] = null;
+                        }
+                        else if (typeof item === 'object') {
+                            const nextCopy = Array.isArray(item) ? [] : {};
+                            copy[key] = nextCopy;
+                            next.push([item, nextCopy]);
+                        }
+                        else {
+                            copy[key] = item;
+                        }
+                    }
+                }
+            }
+            poll = next;
+        }
+        return copy;
+    }
+}
+exports.Deep = Deep;

package/lib/engine/util/dotenv.d.ts

@@ -1,15 +1,9 @@
 export type DotEnvFile = Record<string, string>;
 export declare class DotEnv {
     static path: string;
-    static load(): DotEnvFile;
+    static load(): void;
+    static parse(): DotEnvFile;
     static save(dotenv: DotEnvFile): void;
     static get(key: string): string;
     static set(key: string, value: string): void;
 }
-export type DotEnvValidatorFile = Record<string, string>;
-export declare class DotEnvValidator {
-    static path: string;
-    static load(): DotEnvValidatorFile;
-    static save(validator: DotEnvValidatorFile): void;
-    static set(key: string, type: 'string' | 'number' | 'enum', args?: any): void;
-}