feat: add callback

Author: maxgfr

README.md

@@ -2,7 +2,7 @@
 
 `node-simple-context` is an helper to create a context in node.
 
-This library is highly inspired by [nctx](https://github.com/devthejo/nctx). You definitely should check it out!
+This library is highly inspired by [nctx](https://github.com/devthejo/nctx). You definitely should check it out! Thanks to @devthejo for his help 💪
 
 ## Installation
 
@@ -51,6 +51,8 @@ console.log(contextA.get<string>('foo')); // bar
 
 Thanks to [`AsyncLocalStorage`](https://nodejs.org/api/async_context.html) api, you can `fork` your context in promise or async functions. As you can see below:
 
+> You can also pass a callback in `fork` method to runs a function synchronously within a context and returns its return value which uses [run method from AsyncLocalStorage](https://nodejs.org/api/async_context.html#asynclocalstoragerunstore-callback-args) (cf. [example](./src/__tests__/context.test.ts#L134))
+
 ```ts
 const context = createSimpleContext();
 

src/__tests__/context.test.ts

@@ -1,3 +1,4 @@
+import EventEmitter from 'events';
 import { createSimpleContext, SimpleContext } from '..';
 
 describe('SimpleContext', () => {
@@ -129,4 +130,68 @@ describe('SimpleContext', () => {
     ]);
     expect(res).toStrictEqual(['foo=tata', 'foo=toto', 'foo=titi', 'foo=tutu']);
   });
+
+  it('should work if the values are wrapped in a callback run', async () => {
+    function Deferred() {
+      let resolve;
+      let reject;
+      const promise = new Promise((thisResolve, thisReject) => {
+        resolve = thisResolve;
+        reject = thisReject;
+      });
+      return Object.assign(promise, { resolve, reject });
+    }
+    const emitter = new EventEmitter();
+
+    const context = createSimpleContext();
+
+    const deferredTiti: any = Deferred();
+    const deferredToto: any = Deferred();
+    emitter.on('titi', () => {
+      context.fork(() => {
+        context.set('foo', 'titi2');
+      });
+    });
+    emitter.on('toto', () => {
+      context.fork(() => {
+        context.set('foo', 'toto2');
+      });
+    });
+
+    setTimeout(() => {
+      context.fork(() => {
+        context.set('foo', 'titi');
+        emitter.emit('titi');
+        setTimeout(() => {
+          deferredTiti.resolve(context.get('foo'));
+        }, 50);
+      });
+    }, 100);
+    setTimeout(() => {
+      context.fork(() => {
+        context.set('foo', 'toto');
+        emitter.emit('toto');
+        setTimeout(() => {
+          deferredToto.resolve(context.get('foo'));
+        }, 50);
+      });
+    }, 200);
+
+    expect([await deferredTiti, await deferredToto]).toStrictEqual([
+      'titi',
+      'toto',
+    ]);
+  });
+
+  it('should return good value with the callback', async () => {
+    const context = createSimpleContext();
+
+    const string = context
+      .fork(() => {
+        return 'hello';
+      })
+      .toUpperCase();
+
+    expect(string).toBe('HELLO');
+  });
 });

src/context.ts

@@ -16,8 +16,13 @@ export class SimpleContext {
     return this.setForkProperty<T>(key, value);
   }
 
-  public fork(): SimpleContext {
+  public fork<T>(callback: () => T): T;
+  public fork(): SimpleContext;
+  public fork<T>(callback?: () => T): SimpleContext | T {
     const forkedProperties = { ...this.properties };
+    if (callback) {
+      return this.asyncLocalStorage.run(forkedProperties, callback);
+    }
     this.asyncLocalStorage.enterWith(forkedProperties);
     return this;
   }