feat: typing

Author: maxgfr

README.md

@@ -14,7 +14,7 @@ npm install --save node-simple-context
 
 ### Simple
 
-1. Create a new file `my-context.ts` in which you define your context.
+- 1. Create a new file `my-context.ts` in which you define your context.
 
 ```ts
 import { createSimpleContext } from 'node-simple-context';
@@ -23,21 +23,26 @@ export const contextA = createSimpleContext();
 export const contextB = createSimpleContext();
 ```
 
-2. You now can set the context
+- 2. You now can set the context in your code wherever you want.
 
 ```ts
 import { contextA, contextB } from './my-context';
+
 contextA.set('foo', 'bar');
 contextB.set('foo', 'baz');
 ```
 
-3. In an other file, you can get your context value
+- 3. In an other file, you can get your context value
 
 ```ts
 import { contextA, contextB } from './my-context';
+
 console.log(contextA.get('foo')); // bar
 console.log(contextB.get('foo')); // baz
 console.log(contextA.get('xxx')); // undefined
+
+// in typescript
+console.log(contextA.get<string>('foo')); // bar
 ```
 
 ### Complex
@@ -48,26 +53,26 @@ console.log(contextA.get('xxx')); // undefined
 const context = createSimpleContext();
 
 const func = (): string => {
-  const foo = context.getForkProperty('foo');
+  const foo = context.get('foo');
   return `foo=${foo}`;
 };
 
 context.fork();
-context.setForkProperty('foo', 'bar');
+context.set('foo', 'bar');
 
 const res = await Promise.all([
   new Promise((resolve) => {
     setTimeout(() => {
       context.fork();
-      context.setForkProperty('foo', 'tata');
+      context.set('foo', 'tata');
       resolve(func());
     }, 400);
   }),
   func(),
   new Promise((resolve) => {
     setTimeout(() => {
       context.fork();
-      context.setForkProperty('foo', 'toto');
+      context.set('foo', 'toto');
       resolve(func());
     }, 200);
   }),
@@ -86,23 +91,23 @@ const contextB = createSimpleContext();
 const contextC = createSimpleContext();
 
 const func = (context: SimpleContext): string => {
-  const foo = context.getProperty('foo');
+  const foo = context.get('foo');
   return `foo=${foo}`;
 };
 
-contextC.setProperty('foo', 'bar');
+contextC.set('foo', 'bar');
 
 const res = await Promise.all([
   new Promise((resolve) => {
     setTimeout(() => {
-      contextA.setProperty('foo', 'tata');
+      contextA.set('foo', 'tata');
       resolve(func(contextA));
     }, 400);
   }),
   func(contextC),
   new Promise((resolve) => {
     setTimeout(() => {
-      contextB.setProperty('foo', 'toto');
+      contextB.set('foo', 'toto');
       resolve(func(contextB));
     }, 200);
   }),

package.json

@@ -21,7 +21,10 @@
     "node",
     "node-simple-context",
     "minimalist",
-    "react-context"
+    "react-context",
+    "async_hooks",
+    "async-hooks",
+    "typescript"
   ],
   "scripts": {
     "start": "node build/index.js",

src/__tests__/context.test.ts

@@ -6,30 +6,37 @@ describe('SimpleContext', () => {
     expect(context).toBeInstanceOf(SimpleContext);
   });
 
+  it('should get a value from a context', () => {
+    const context = createSimpleContext();
+    context.set('A', 10);
+    const res = context.get<number>('A');
+    expect(res).toBe(10);
+  });
+
   it('should display value in order with fork', async () => {
     const context = createSimpleContext();
 
     const func = (): string => {
-      const foo = context.getForkProperty('foo');
+      const foo = context.get('foo');
       return `foo=${foo}`;
     };
 
     context.fork();
-    context.setForkProperty('foo', 'bar');
+    context.set('foo', 'bar');
 
     const res = await Promise.all([
       new Promise((resolve) => {
         setTimeout(() => {
           context.fork();
-          context.setForkProperty('foo', 'tata');
+          context.set('foo', 'tata');
           resolve(func());
         }, 400);
       }),
       func(),
       new Promise((resolve) => {
         setTimeout(() => {
           context.fork();
-          context.setForkProperty('foo', 'toto');
+          context.set('foo', 'toto');
           resolve(func());
         }, 200);
       }),
@@ -43,23 +50,23 @@ describe('SimpleContext', () => {
     const contextC = createSimpleContext();
 
     const func = (context: SimpleContext): string => {
-      const foo = context.getProperty('foo');
+      const foo = context.get('foo');
       return `foo=${foo}`;
     };
 
-    contextC.setProperty('foo', 'bar');
+    contextC.set('foo', 'bar');
 
     const res = await Promise.all([
       new Promise((resolve) => {
         setTimeout(() => {
-          contextA.setProperty('foo', 'tata');
+          contextA.set('foo', 'tata');
           resolve(func(contextA));
         }, 400);
       }),
       func(contextC),
       new Promise((resolve) => {
         setTimeout(() => {
-          contextB.setProperty('foo', 'toto');
+          contextB.set('foo', 'toto');
           resolve(func(contextB));
         }, 200);
       }),

src/context.ts

@@ -3,18 +3,26 @@ import async_hooks from 'async_hooks';
 
 export class SimpleContext {
   private contextId: string;
-  private properties: { [key: string]: any } = {};
+  private properties: Record<string, unknown> = {};
   private forks: Array<SimpleContext> = [];
+  private isFork: boolean;
 
-  constructor(private id = randomUUID()) {
-    this.contextId = this.id;
+  constructor(id = randomUUID(), isFork = false) {
+    this.contextId = id;
+    this.isFork = isFork;
   }
 
-  public getProperty(key: string): any {
-    return this.properties[key];
+  public get<T>(key: string): T | undefined {
+    if (this.isFork) {
+      return this.getForkProperty(key);
+    }
+    return this.properties[key] as T | undefined;
   }
 
-  public setProperty(key: string, value: any): void {
+  public set<T>(key: string, value: T): void {
+    if (this.isFork) {
+      return this.setForkProperty(key, value);
+    }
     this.properties[key] = value;
   }
 
@@ -23,19 +31,19 @@ export class SimpleContext {
     this.forks = [...this.forks, new SimpleContext(id)];
   }
 
-  public setForkProperty(key: string, value: any): void {
+  private setForkProperty<T>(key: string, value: T): void {
     const id = async_hooks.executionAsyncId().toString();
     const fork = this.forks.find((fork) => fork.contextId === id);
     if (fork) {
-      fork.setProperty(key, value);
+      fork.set(key, value);
     }
   }
 
-  public getForkProperty(key: string): any {
+  private getForkProperty<T>(key: string): T | undefined {
     const id = async_hooks.executionAsyncId().toString();
     const fork = this.forks.find((fork) => fork.contextId === id);
     if (fork) {
-      return fork.getProperty(key);
+      return fork.get<T>(key);
     }
     return undefined;
   }