@hg-ts/async-context 0.5.17 → 0.5.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hg-ts/async-context",
-  "version": "0.5.17",
+  "version": "0.5.18",
   "main": "dist/index.js",
   "type": "module",
   "exports": {
@@ -18,11 +18,11 @@
     "test:dev": "vitest watch"
   },
   "devDependencies": {
-    "@hg-ts-config/typescript": "0.5.17",
-    "@hg-ts/exception": "0.5.17",
-    "@hg-ts/linter": "0.5.17",
-    "@hg-ts/tests": "0.5.17",
-    "@hg-ts/types": "0.5.17",
+    "@hg-ts-config/typescript": "0.5.18",
+    "@hg-ts/exception": "0.5.18",
+    "@hg-ts/linter": "0.5.18",
+    "@hg-ts/tests": "0.5.18",
+    "@hg-ts/types": "0.5.18",
     "@types/node": "22.19.1",
     "@vitest/coverage-v8": "4.0.14",
     "eslint": "9.18.0",
@@ -35,7 +35,7 @@
     "vitest": "4.0.14"
   },
   "peerDependencies": {
-    "@hg-ts/exception": "0.5.17",
+    "@hg-ts/exception": "0.5.18",
     "reflect-metadata": "*",
     "rxjs": "*",
     "tslib": "*",

package/src/async-context.not-found.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from '@hg-ts/exception';
+
+export class AsyncContextNotFoundException extends BaseException {
+	public constructor() {
+		super('Async context not provided');
+	}
+}

package/src/async-context.provider.ts

@@ -0,0 +1,82 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import {
+	MonoTypeOperatorFunction,
+	Observable,
+} from 'rxjs';
+import { AsyncContextNotFoundException } from './async-context.not-found.exception.js';
+
+type AsyncContextProviderCallback<T> = () => T;
+type AsyncContextFactory<InputType, Context> = (input: InputType) => Context;
+
+type NextCallback<T> = (value: T) => void;
+
+export class AsyncContextProvider<Context> {
+	protected readonly storage = new AsyncLocalStorage<Context>();
+
+	public get(): Nullable<Context> {
+		return this.storage.getStore() ?? null;
+	}
+
+	public getOrFail(): NonNullable<Context> {
+		const context = this.get();
+
+		if (typeof context === 'undefined' || context === null) {
+			throw new AsyncContextNotFoundException();
+		}
+
+		return context as NonNullable<Context>;
+	}
+
+	public run<ReturnType>(
+		context: Context,
+		callback: AsyncContextProviderCallback<ReturnType>,
+	): ReturnType {
+		return this.storage.run(context, callback);
+	}
+
+	public exit<ReturnType>(
+		callback: AsyncContextProviderCallback<ReturnType>,
+	): ReturnType {
+		return this.storage.exit(callback);
+	}
+
+	public runOperator<T>(
+		factory?: AsyncContextFactory<T, Context>,
+	): MonoTypeOperatorFunction<T> {
+		return this.createOperator<T>((next, value) => {
+			const context = factory ? factory(value) : value as any;
+			this.storage.run(context, next);
+		});
+	}
+
+	public exitOperator<T>(): MonoTypeOperatorFunction<T> {
+		return this.createOperator(next => this.storage.exit(next));
+	}
+
+	private createOperator<T>(onNext: (next: () => void, value: T) => void): MonoTypeOperatorFunction<any> {
+		return (source): Observable<T> => new Observable<T>(subscriber => {
+			const callNext: NextCallback<T> = input => {
+				const next = (): void => {
+					if (!subscriber.closed) {
+						subscriber.next(input);
+					}
+				};
+				onNext(next, input);
+			};
+			const callError: NextCallback<T> = input => {
+				const next = (): void => {
+					if (!subscriber.closed) {
+						subscriber.error(input);
+					}
+				};
+				onNext(next, input);
+			};
+
+			source.subscribe({
+				next: callNext,
+				error: callError,
+				complete: () => subscriber.complete(),
+			});
+		});
+	}
+}

package/src/async-context.test.ts

@@ -0,0 +1,161 @@
+import {
+	Describe,
+	expect,
+	ExpectException,
+	Suite,
+	Test,
+} from '@hg-ts/tests';
+import {
+	Subject,
+	Subscription,
+	tap,
+} from 'rxjs';
+
+import { AsyncContextNotFoundException } from './async-context.not-found.exception.js';
+import { AsyncContextProvider } from './async-context.provider.js';
+
+type OperatorTestSubscription = {
+	subscription: Subscription;
+	subject: Subject<number>;
+	input: number;
+	context: number;
+};
+
+@Describe()
+export class AsyncContextTest extends Suite {
+	private context: AsyncContextProvider<number>;
+
+	@Test()
+	public async emptyContext(): Promise<void> {
+		expect(this.context.get()).toBe(null);
+	}
+
+	@Test()
+	public async noPromiseContext(): Promise<void> {
+		const contextValue = Math.random();
+		const resultValue = Math.random();
+
+		const result = this.context.run(contextValue, () => {
+			expect(this.context.getOrFail()).toBe(contextValue);
+
+			this.context.exit(() => {
+				expect(this.context.get()).toBe(null);
+			});
+			return resultValue;
+		});
+
+		expect(result).toBe(resultValue);
+	}
+
+	@Test()
+	public async promiseContext(): Promise<void> {
+		const contextValue = Math.random();
+		const resultValue = Math.random();
+
+		const result = await this.context.run(contextValue, async() => {
+			expect(this.context.getOrFail()).toBe(contextValue);
+
+			await this.context.exit(async() => {
+				expect(this.context.get()).toBe(null);
+			});
+			return resultValue;
+		});
+
+		expect(result).toBe(resultValue);
+	}
+
+	@Test()
+	public async operatorContext(): Promise<void> {
+		const { subject, input } = this.createOperatorTestSubscription();
+
+		subject.next(input);
+		subject.complete();
+
+		expect.assertions(4);
+	}
+
+	@Test()
+	public async operatorWithFactory(): Promise<void> {
+		const { subject, input } = this.createOperatorTestSubscription(value => -value);
+
+		subject.next(input);
+		subject.complete();
+
+		expect.assertions(4);
+	}
+
+	@Test()
+	public async operatorWithErrorContext(): Promise<void> {
+		const { subject, input } = this.createOperatorTestSubscription();
+
+		subject.error(input);
+		subject.complete();
+
+		expect.assertions(4);
+	}
+
+	@Test()
+	public async operatorAfterUnsubscribe(): Promise<void> {
+		const { subject, input, subscription } = this.createOperatorTestSubscription();
+
+		subscription.unsubscribe();
+		subject.next(input);
+		subject.complete();
+
+		expect.assertions(2);
+	}
+
+	@Test()
+	public async operatorWithErrorAfterUnsubscribe(): Promise<void> {
+		const { subject, input, subscription } = this.createOperatorTestSubscription();
+
+		subscription.unsubscribe();
+		subject.error(input);
+		subject.complete();
+
+		expect.assertions(2);
+	}
+
+	@Test()
+	@ExpectException(AsyncContextNotFoundException)
+	public async contextNotFound(): Promise<void> {
+		this.context.getOrFail();
+	}
+
+	public override async beforeEach(): Promise<void> {
+		this.context = new AsyncContextProvider();
+	}
+
+	private createOperatorTestSubscription(factory?: (input: number) => number): OperatorTestSubscription {
+		const subject = new Subject<number>();
+		const input = Math.random();
+		const context = factory ? factory(input) : input;
+
+		const withContext = (value: number): void => {
+			expect(value).toBe(input);
+			expect(this.context.getOrFail()).toBe(context);
+		};
+
+		const withoutContext = (value: number): void => {
+			expect(value).toBe(input);
+			expect(this.context.get()).toBe(null);
+		};
+
+		const subscription = subject.asObservable()
+			.pipe(
+				this.context.runOperator(factory),
+				tap({
+					next: withContext,
+					error: withContext,
+				}),
+				this.context.exitOperator(),
+				tap({
+					next: withoutContext,
+					error: withoutContext,
+				}),
+			)
+			.subscribe({ next() {}, error() {} });
+
+		return { subject, subscription, input, context };
+	}
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './async-context.provider.js';
+export * from './async-context.not-found.exception.js';