@travetto/context 2.1.5 → 2.2.2

package/README.md

@@ -64,4 +64,4 @@ export class SystemInitiatedContext {
 
 ## Extension - Rest
 
-Within the [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") module, it can be challening to share context across the various layers that may be touched by a request.  This module provides [AsyncContextInterceptor](https://github.com/travetto/travetto/tree/main/module/context/src/extension/rest.interceptor.ts#L17) to create a data store that will be private to an individual request. This is used by [Rest Auth](https://github.com/travetto/travetto/tree/main/module/auth-rest#readme "Rest authentication integration support for the travetto framework") to store authentiated user information for built-in authorization and permission validation.
+Within the [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") module, it can be challenging to share context across the various layers that may be touched by a request.  This module provides [AsyncContextInterceptor](https://github.com/travetto/travetto/tree/main/module/context/src/extension/rest.interceptor.ts#L17) to create a data store that will be private to an individual request. This is used by [Rest Auth](https://github.com/travetto/travetto/tree/main/module/auth-rest#readme "Rest authentication integration support for the travetto framework") to store authenticated user information for built-in authorization and permission validation.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/context",
   "displayName": "Async Context",
-  "version": "2.1.5",
+  "version": "2.2.2",
   "description": "Async-aware state management, maintaining context across asynchronous calls.",
   "keywords": [
     "async-hooks",
@@ -27,10 +27,10 @@
     "directory": "module/context"
   },
   "dependencies": {
-    "@travetto/di": "^2.1.5"
+    "@travetto/di": "^2.2.2"
   },
   "optionalPeerDependencies": {
-    "@travetto/rest": "^2.1.5"
+    "@travetto/rest": "^2.2.2"
   },
   "publishConfig": {
     "access": "public"

package/src/decorator.ts

@@ -4,11 +4,16 @@ import { AsyncContext } from './service';
  * Allows running a function while providing an async context
  */
 export function WithAsyncContext<T extends { context: AsyncContext }>(data?: Record<string, unknown>) {
-  return function <U extends unknown[], V = unknown>(target: T, prop: string, descriptor: TypedPropertyDescriptor<(...args: U) => Promise<V>>) {
-    const og = descriptor.value!;
-    descriptor.value = function (this: T, ...args: unknown[]) {
-      return (this.context.run((og as Function).bind(this, ...args),
-        data ? JSON.parse(JSON.stringify(data)) : {})) as Promise<V>;
+  return function <U extends unknown[], V = unknown>(
+    target: T,
+    prop: string,
+    descriptor: TypedPropertyDescriptor<(...args: U) => Promise<V>>
+  ): typeof descriptor {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const og = descriptor.value! as (this: T, ...args: unknown[]) => Promise<V>;
+    descriptor.value = function (this: T, ...args: unknown[]): Promise<V> {
+      return (this.context.run(og.bind(this, ...args),
+        data ? JSON.parse(JSON.stringify(data)) : {}));
     };
 
     Object.defineProperty(descriptor.value, 'name', { value: og.name });

package/src/extension/rest.interceptor.ts

@@ -28,7 +28,7 @@ export class AsyncContextInterceptor implements RestInterceptor {
     return !this.config.disabled;
   }
 
-  intercept(req: Request, res: Response, next: () => Promise<void>) {
+  intercept(req: Request, res: Response, next: () => Promise<void>): Promise<void> {
     return this.context.run(next);
   }
 }

package/src/service.ts

@@ -14,13 +14,14 @@ type Ctx = Record<string | symbol, unknown>;
 export class AsyncContext {
 
   alStorage = new AsyncLocalStorage<{ value: Ctx }>();
+  active = 0;
 
   constructor() {
     this.run = this.run.bind(this);
     this.iterate = this.iterate.bind(this);
   }
 
-  #store(setAs?: Ctx | null) {
+  #store(setAs?: Ctx | null): Ctx {
     const val = this.alStorage.getStore();
     if (!val) {
       throw new AppError('Context is not initialized', 'general');
@@ -39,13 +40,14 @@ export class AsyncContext {
    * Get entire context or a portion by key
    */
   get<T = unknown>(key: string | symbol): T;
-  get(): Record<string | symbol, unknown>;
-  get<T>(key?: string | symbol) {
+  get(): Ctx;
+  get<T>(key?: string | symbol): Ctx | T {
     const root = this.#store();
     if (key) {
-      return root[key as string];
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return root[key as string] as T;
     } else {
-      return root as T;
+      return root;
     }
   }
 
@@ -54,29 +56,51 @@ export class AsyncContext {
    */
   set(key: string | symbol, val: unknown): void;
   set(val: Ctx): void;
-  set(keyOrVal: string | symbol | Ctx, valWithKey?: unknown) {
+  set(keyOrVal: string | symbol | Ctx, valWithKey?: unknown): void {
     if (typeof keyOrVal === 'string' || typeof keyOrVal === 'symbol') {
-      this.get()[keyOrVal as string] = valWithKey;
+      this.get()[keyOrVal] = valWithKey;
     } else {
-      this.#store(keyOrVal as Ctx);
+      this.#store(keyOrVal);
     }
   }
 
-  #context(ctx: Ctx = {}): { value: Ctx } {
-    return { value: this.alStorage.getStore() ? { ...this.#store(), ...ctx } : ctx };
-  }
-
   /**
    * Run an async function and ensure the context is available during execution
    */
   async run<T = unknown>(fn: () => Promise<T>, init: Ctx = {}): Promise<T> {
-    return await this.alStorage.run(this.#context(init), fn);
+    if (this.alStorage.getStore()) {
+      init = { ...this.#store(), ...init };
+    }
+    this.active += 1;
+    this.alStorage.enterWith({ value: init });
+    try {
+      return await fn();
+    } finally {
+      // @ts-expect-error
+      delete this.alStorage.getStore().value;
+      if ((this.active -= 1) === 0) {
+        this.alStorage.disable();
+      }
+    }
   }
 
   /**
    * Run an async function and ensure the context is available during execution
    */
   async * iterate<T>(fn: () => AsyncGenerator<T>, init: Ctx = {}): AsyncGenerator<T> {
-    return yield* this.alStorage.run(this.#context(init), fn);
+    if (this.alStorage.getStore()) {
+      init = { ...this.#store(), ...init };
+    }
+    this.active += 1;
+    this.alStorage.enterWith({ value: init });
+    try {
+      return yield* fn();
+    } finally {
+      // @ts-expect-error
+      delete this.alStorage.getStore().value;
+      if ((this.active -= 1) === 0) {
+        this.alStorage.disable();
+      }
+    }
   }
 }

package/test-support/suite-context.ts

@@ -11,7 +11,7 @@ const Init = Symbol();
  * @param data
  */
 export function WithSuiteContext(data: Record<string, unknown> = {}) {
-  return (target: Class) => {
+  return (target: Class): void => {
     function wrapped(ctx: AsyncContext, og: Function) {
       return function (this: unknown) {
         return ctx.run(og.bind(this), JSON.parse(JSON.stringify(data)));
@@ -24,6 +24,7 @@ export function WithSuiteContext(data: Record<string, unknown> = {}) {
           this[Init] = true;
           const ctx = await DependencyRegistry.getInstance(AsyncContext);
           for (const t of SuiteRegistry.get(target).tests) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             const fn = wrapped(ctx, this[t.methodName] as Function);
             Object.defineProperty(fn, 'name', { value: t.methodName });
             this[t.methodName] = fn;