[Feature] Update API. (#23)

Author: odeadglaz

.github/workflows/node.js.yml

@@ -16,7 +16,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [8.x, 10.x, 12.x, 14.x]
+        node-version: [8.x, 10.x, 12.x, 14.x, 16.x]
 
     steps:
     - uses: actions/checkout@v2

CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 3.0.2 (February 12, 2021)
+
+- Add `update` API for ease usage in case context is a plain `object`.
+
 ## 3.0.1 (February 12, 2021)
 
 - Better `types.d`.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-execution-context",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "Provides execution context wrapper for node JS, can be used to create execution wrapper for handling requests and more",
   "author": "Oded Goldglas <odedglas@gmail.com>",
   "license": "ISC",

src/ExecutionContext/constants.js

@@ -4,6 +4,7 @@
  */
 exports.ExecutionContextErrors = {
     CONTEXT_DOES_NOT_EXIST: 'Execution context does not exists, please ensure to call create/run before.',
+    UPDATE_BLOCKED: 'Calling "update" API is allowed only when provided context is a plain `object`.',
     MONITOR_MISS_CONFIGURATION: 'Monitoring option is off by default, please call `configure` with the proper options.'
 };
 

src/ExecutionContext/index.js

@@ -31,6 +31,15 @@ class ExecutionContext {
         this.manager.set(context);
     }
 
+    /**
+     * Updates the current asynchronous execution context with a given value.
+     * @param {*} context - The new context to expose current asynchronous execution.
+     * @returns void
+     */
+    update(context) {
+        this.manager.update(context);
+    }
+
     /**
      * Gets the current asynchronous execution context.
      * @return {*}

src/ExecutionContext/spec.js

@@ -52,6 +52,35 @@ describe('Context', () => {
             });
         });
 
+        describe('Update', () => {
+            it('Throws an error when context is not created', () => {
+                expect(() => Context.get())
+                    .toThrow(ExecutionContextErrors.CONTEXT_DOES_NOT_EXIST);
+            });
+
+            it('Throws an error when context is a pain `object`', () => {
+                Context.create({ my: 'thing' });
+
+                expect(() => Context.update('Hey'))
+                    .toThrow(ExecutionContextErrors.UPDATE_BLOCKED);
+            });
+
+            describe('When context is created', () => {
+                it('Update context', () => {
+                    Context.create({ val: 'value', other: 'o' });
+                    const context = Context.get();
+
+                    expect(context.val).toEqual('value');
+
+                    Context.update({ val: false });
+                    expect(Context.get()).toMatchObject({
+                        val: false,
+                        other: 'o'
+                    });
+                });
+            });
+        });
+
         describe('Run', () => {
             let spies;
             let execute;

src/ExecutionContext/types.d.ts

@@ -1,5 +1,3 @@
-import { ExecutionMapUsage } from '../lib/types';
-
 interface ExecutionContextNode {
     asyncId: number;
     monitor: boolean;

src/lib/index.js

@@ -58,6 +58,14 @@ module.exports = {
      */
     supportAsyncLocalStorage: (version = process.version) => semver.gte(version, '12.17.0'),
 
+    /**
+     * Returns true if a given thing is an object
+     * @param value - The thing to check.
+     */
+    isObject: (value) => !!value &&
+        !Array.isArray(value) &&
+        typeof value === 'object',
+
     /**
      * Returns a monitoring report over the "executionContext" memory usage.
      * @param {ExecutionContextMap} executionContextMap The execution map to monitor.

src/lib/spec.js

@@ -35,6 +35,21 @@ describe('Lib', () => {
         });
     });
 
+    describe('isObject', () => {
+        it.each([
+            [false, false],
+            [1, false],
+            ['', false],
+            [undefined, false],
+            [[], false],
+            [() => {}, false],
+            [class Test {}, false],
+            [{}, true],
+        ])('Returns true when given value is object (%p)', (value, expected) => {
+           expect(lib.isObject(value)).toEqual(expected);
+        });
+    });
+
     describe('supportAsyncLocalStorage', () => {
         describe('When node version is lower than 12.17.0', () => {
             it.each([

src/managers/asyncHooks/index.js

@@ -1,5 +1,5 @@
 const asyncHooks = require('async_hooks');
-const { monitorMap, handleError, ExecutionContextResource } = require('../../lib');
+const { monitorMap, handleError, isObject, ExecutionContextResource } = require('../../lib');
 const { create: createHooks, onChildProcessDestroy } = require('./hooks');
 const { ExecutionContextErrors } = require('../../ExecutionContext/constants');
 const { DEFAULT_CONFIG } = require('./constants');
@@ -103,6 +103,18 @@ class AsyncHooksContext {
         rootContext.context = context;
     }
 
+    update(context) {
+        const asyncId = asyncHooks.executionAsyncId();
+
+        if (!executionContextMap.has(asyncId)) return handleError(ExecutionContextErrors.CONTEXT_DOES_NOT_EXIST);
+        if (!isObject(context)) return handleError(ExecutionContextErrors.UPDATE_BLOCKED);
+
+        // Update target is always the root context, ref updates will need to be channeled
+        const rootContext = this._getRootContext(asyncId);
+
+        Object.assign(rootContext.context, context);
+    }
+
     configure(config) {
         this.config = config;
     }