@wooksjs/event-core 0.4.37 → 0.5.0

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var crypto = require('crypto');
+var node_async_hooks = require('node:async_hooks');
 var hookable = require('hookable');
 var logger = require('@prostojs/logger');
 
@@ -28,18 +29,43 @@ function attachHook(target, opts, name) {
     return target;
 }
 
-let currentContext = null;
-function createEventContext(data) {
+const asyncStorage = new node_async_hooks.AsyncLocalStorage();
+function createAsyncEventContext(data) {
     const newContext = { ...data };
-    currentContext = newContext;
     eventContextHooks.fireStartEvent(data.event.type);
-    return _getCtxHelpers(newContext);
+    return (cb) => {
+        const result = asyncStorage.run(newContext, cb);
+        if (result instanceof Promise) {
+            result
+                .then(r => {
+                endEvent(r);
+                return r;
+            })
+                .catch(error => {
+                endEvent(error);
+            });
+        }
+        else {
+            endEvent(result);
+        }
+        function endEvent(output) {
+            if (!newContext._ended) {
+                if (output instanceof Error) {
+                    eventContextHooks.fireEndEvent(data.event.type, output.message);
+                }
+                else {
+                    eventContextHooks.fireEndEvent(data.event.type);
+                }
+            }
+        }
+        return result;
+    };
 }
-function useEventContext(expectedTypes) {
-    if (!currentContext) {
-        throw new Error('Event context does not exist. Use event context synchronously within the runtime of the event.');
+function useAsyncEventContext(expectedTypes) {
+    let cc = asyncStorage.getStore();
+    if (!cc) {
+        throw new Error('Event context does not exist at this point.');
     }
-    let cc = currentContext;
     if (expectedTypes || typeof expectedTypes === 'string') {
         const type = cc.event.type;
         const types = typeof expectedTypes === 'string' ? [expectedTypes] : expectedTypes;
@@ -128,15 +154,13 @@ function _getCtxHelpers(cc) {
     function set(key, v) {
         getCtx()[key] = v;
     }
-    const clearCtx = () => (cc === currentContext ? (currentContext = null) : null);
+    const hasParentCtx = () => !!cc.parentCtx;
     return {
         getCtx,
-        restoreCtx: () => (currentContext = cc),
-        clearCtx,
         endEvent: (abortReason) => {
-            if (cc) {
+            if (cc && !cc._ended) {
+                cc._ended = true;
                 eventContextHooks.fireEndEvent(cc.event.type, abortReason);
-                clearCtx();
             }
         },
         store,
@@ -145,12 +169,18 @@ function _getCtxHelpers(cc) {
         setParentCtx: (parentCtx) => {
             cc.parentCtx = parentCtx;
         },
-        restoreParentCtx: () => (currentContext = cc.parentCtx || null),
+        hasParentCtx,
+        getParentCtx: () => {
+            if (!hasParentCtx()) {
+                throw new Error('Parent context is not available');
+            }
+            return _getCtxHelpers(cc.parentCtx);
+        },
     };
 }
 
 function useEventId() {
-    const { store } = useEventContext();
+    const { store } = useAsyncEventContext();
     const { init } = store('event');
     const getId = () => init('id', () => crypto.randomUUID());
     return { getId };
@@ -180,7 +210,7 @@ class EventLogger extends logger.ProstoLogger {
 
 function useEventLogger(topic) {
     const { getId } = useEventId();
-    const { store, getCtx } = useEventContext();
+    const { store, getCtx } = useAsyncEventContext();
     const { init } = store('event');
     const ctx = getCtx();
     const get = () => init('logger', () => new EventLogger(getId(), ctx.options.eventLogger));
@@ -188,7 +218,7 @@ function useEventLogger(topic) {
 }
 
 function useRouteParams() {
-    const { store } = useEventContext();
+    const { store } = useAsyncEventContext();
     const params = (store('routeParams').value || {});
     function get(name) {
         return params[name];
@@ -200,10 +230,11 @@ function useRouteParams() {
 }
 
 exports.EventLogger = EventLogger;
+exports.asyncStorage = asyncStorage;
 exports.attachHook = attachHook;
-exports.createEventContext = createEventContext;
+exports.createAsyncEventContext = createAsyncEventContext;
 exports.eventContextHooks = eventContextHooks;
-exports.useEventContext = useEventContext;
+exports.useAsyncEventContext = useAsyncEventContext;
 exports.useEventId = useEventId;
 exports.useEventLogger = useEventLogger;
 exports.useRouteParams = useRouteParams;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import * as _prostojs_logger from '@prostojs/logger';
 import { TProstoLoggerOptions, ProstoLogger } from '@prostojs/logger';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { Hookable } from 'hookable';
 
 declare function useEventId(): {
@@ -24,48 +25,17 @@ interface TGenericContextStore<CustomEventType = TEmpty> {
     options: TEventOptions;
     parentCtx?: TGenericContextStore;
     routeParams?: Record<string, string | string[]>;
+    _ended?: boolean;
 }
 /**
- * Create a new event context
+ * AsyncLocalStorage instance
  *
- * @param data
- * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
+ * Use on your own risk only if you know what you're doing
  */
-declare function createEventContext<S = TEmpty, EventTypeToCreate = TEmpty>(data: S & TGenericContextStore<EventTypeToCreate>): {
-    getCtx: () => S & TGenericContextStore<EventTypeToCreate>;
-    restoreCtx: () => TGenericContextStore<TEmpty>;
-    clearCtx: () => null;
-    endEvent: (abortReason?: string | undefined) => void;
-    store: <K extends keyof S | keyof TGenericContextStore<EventTypeToCreate>>(key: K) => {
-        value: (S & TGenericContextStore<EventTypeToCreate>)[K];
-        hook: <K2 extends keyof Required<S & TGenericContextStore<EventTypeToCreate>>[K]>(key2: K2) => {
-            value: Required<S & TGenericContextStore<EventTypeToCreate>>[K][K2];
-            isDefined: boolean;
-        };
-        init: <K2_1 extends keyof Required<S & TGenericContextStore<EventTypeToCreate>>[K]>(key2: K2_1, getter: () => Required<Required<S & TGenericContextStore<EventTypeToCreate>>[K]>[K2_1]) => Required<Required<S & TGenericContextStore<EventTypeToCreate>>[K]>[K2_1];
-        set: <K2_2 extends keyof Required<S & TGenericContextStore<EventTypeToCreate>>[K]>(key2: K2_2, v: Required<(S & TGenericContextStore<EventTypeToCreate>)[K]>[K2_2]) => Required<(S & TGenericContextStore<EventTypeToCreate>)[K]>[K2_2];
-        get: <K2_3 extends keyof Required<S & TGenericContextStore<EventTypeToCreate>>[K]>(key2: K2_3) => Required<S & TGenericContextStore<EventTypeToCreate>>[K][K2_3] | undefined;
-        has: <K2_4 extends keyof Required<S & TGenericContextStore<EventTypeToCreate>>[K]>(key2: K2_4) => boolean;
-        del: <K2_5 extends keyof Required<S & TGenericContextStore<EventTypeToCreate>>[K]>(key2: K2_5) => void;
-        entries: () => [string, unknown][];
-        clear: () => void;
-    };
-    getStore: <K_1 extends keyof S | keyof TGenericContextStore<EventTypeToCreate>>(key: K_1) => (S & TGenericContextStore<EventTypeToCreate>)[K_1];
-    setStore: <K_2 extends keyof S | keyof TGenericContextStore<EventTypeToCreate>>(key: K_2, v: (S & TGenericContextStore<EventTypeToCreate>)[K_2]) => void;
-    setParentCtx: (parentCtx: unknown) => void;
-    restoreParentCtx: () => TGenericContextStore<TEmpty> | null;
-};
-/**
- * Use existing event context
- *
- * !Must be called syncronously while context is reachable
- *
- * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
- */
-declare function useEventContext<S = TEmpty, EventType = TEmpty>(expectedTypes?: string | string[]): {
+declare const asyncStorage: AsyncLocalStorage<unknown>;
+declare function createAsyncEventContext<S = TEmpty, EventTypeToCreate = TEmpty>(data: S & TGenericContextStore<EventTypeToCreate>): <T>(cb: (...a: any[]) => T) => T;
+declare function useAsyncEventContext<S = TEmpty, EventType = TEmpty>(expectedTypes?: string | string[]): {
     getCtx: () => S & TGenericContextStore<EventType>;
-    restoreCtx: () => TGenericContextStore<TEmpty>;
-    clearCtx: () => null;
     endEvent: (abortReason?: string | undefined) => void;
     store: <K extends keyof S | keyof TGenericContextStore<EventType>>(key: K) => {
         value: (S & TGenericContextStore<EventType>)[K];
@@ -84,7 +54,228 @@ declare function useEventContext<S = TEmpty, EventType = TEmpty>(expectedTypes?:
     getStore: <K_1 extends keyof S | keyof TGenericContextStore<EventType>>(key: K_1) => (S & TGenericContextStore<EventType>)[K_1];
     setStore: <K_2 extends keyof S | keyof TGenericContextStore<EventType>>(key: K_2, v: (S & TGenericContextStore<EventType>)[K_2]) => void;
     setParentCtx: (parentCtx: unknown) => void;
-    restoreParentCtx: () => TGenericContextStore<TEmpty> | null;
+    hasParentCtx: () => boolean;
+    getParentCtx: <T2 = S & TGenericContextStore<EventType>>() => {
+        getCtx: () => T2;
+        endEvent: (abortReason?: string | undefined) => void;
+        store: <K_3 extends keyof T2>(key: K_3) => {
+            value: T2[K_3];
+            hook: <K2_6 extends keyof Required<T2>[K_3]>(key2: K2_6) => {
+                value: Required<T2>[K_3][K2_6];
+                isDefined: boolean;
+            };
+            init: <K2_7 extends keyof Required<T2>[K_3]>(key2: K2_7, getter: () => Required<Required<T2>[K_3]>[K2_7]) => Required<Required<T2>[K_3]>[K2_7];
+            set: <K2_8 extends keyof Required<T2>[K_3]>(key2: K2_8, v: Required<T2[K_3]>[K2_8]) => Required<T2[K_3]>[K2_8];
+            get: <K2_9 extends keyof Required<T2>[K_3]>(key2: K2_9) => Required<T2>[K_3][K2_9] | undefined;
+            has: <K2_10 extends keyof Required<T2>[K_3]>(key2: K2_10) => boolean;
+            del: <K2_11 extends keyof Required<T2>[K_3]>(key2: K2_11) => void;
+            entries: () => [string, unknown][];
+            clear: () => void;
+        };
+        getStore: <K_4 extends keyof T2>(key: K_4) => T2[K_4];
+        setStore: <K_5 extends keyof T2>(key: K_5, v: T2[K_5]) => void;
+        setParentCtx: (parentCtx: unknown) => void;
+        hasParentCtx: () => boolean;
+        getParentCtx: <T2_1 = T2>() => {
+            getCtx: () => T2_1;
+            endEvent: (abortReason?: string | undefined) => void;
+            store: <K_6 extends keyof T2_1>(key: K_6) => {
+                value: T2_1[K_6];
+                hook: <K2_12 extends keyof Required<T2_1>[K_6]>(key2: K2_12) => {
+                    value: Required<T2_1>[K_6][K2_12];
+                    isDefined: boolean;
+                };
+                init: <K2_13 extends keyof Required<T2_1>[K_6]>(key2: K2_13, getter: () => Required<Required<T2_1>[K_6]>[K2_13]) => Required<Required<T2_1>[K_6]>[K2_13];
+                set: <K2_14 extends keyof Required<T2_1>[K_6]>(key2: K2_14, v: Required<T2_1[K_6]>[K2_14]) => Required<T2_1[K_6]>[K2_14];
+                get: <K2_15 extends keyof Required<T2_1>[K_6]>(key2: K2_15) => Required<T2_1>[K_6][K2_15] | undefined;
+                has: <K2_16 extends keyof Required<T2_1>[K_6]>(key2: K2_16) => boolean;
+                del: <K2_17 extends keyof Required<T2_1>[K_6]>(key2: K2_17) => void;
+                entries: () => [string, unknown][];
+                clear: () => void;
+            };
+            getStore: <K_7 extends keyof T2_1>(key: K_7) => T2_1[K_7];
+            setStore: <K_8 extends keyof T2_1>(key: K_8, v: T2_1[K_8]) => void;
+            setParentCtx: (parentCtx: unknown) => void;
+            hasParentCtx: () => boolean;
+            getParentCtx: <T2_2 = T2_1>() => {
+                getCtx: () => T2_2;
+                endEvent: (abortReason?: string | undefined) => void;
+                store: <K_9 extends keyof T2_2>(key: K_9) => {
+                    value: T2_2[K_9];
+                    hook: <K2_18 extends keyof Required<T2_2>[K_9]>(key2: K2_18) => {
+                        value: Required<T2_2>[K_9][K2_18];
+                        isDefined: boolean;
+                    };
+                    init: <K2_19 extends keyof Required<T2_2>[K_9]>(key2: K2_19, getter: () => Required<Required<T2_2>[K_9]>[K2_19]) => Required<Required<T2_2>[K_9]>[K2_19];
+                    set: <K2_20 extends keyof Required<T2_2>[K_9]>(key2: K2_20, v: Required<T2_2[K_9]>[K2_20]) => Required<T2_2[K_9]>[K2_20];
+                    get: <K2_21 extends keyof Required<T2_2>[K_9]>(key2: K2_21) => Required<T2_2>[K_9][K2_21] | undefined;
+                    has: <K2_22 extends keyof Required<T2_2>[K_9]>(key2: K2_22) => boolean;
+                    del: <K2_23 extends keyof Required<T2_2>[K_9]>(key2: K2_23) => void;
+                    entries: () => [string, unknown][];
+                    clear: () => void;
+                };
+                getStore: <K_10 extends keyof T2_2>(key: K_10) => T2_2[K_10];
+                setStore: <K_11 extends keyof T2_2>(key: K_11, v: T2_2[K_11]) => void;
+                setParentCtx: (parentCtx: unknown) => void;
+                hasParentCtx: () => boolean;
+                getParentCtx: <T2_3 = T2_2>() => {
+                    getCtx: () => T2_3;
+                    endEvent: (abortReason?: string | undefined) => void;
+                    store: <K_12 extends keyof T2_3>(key: K_12) => {
+                        value: T2_3[K_12];
+                        hook: <K2_24 extends keyof Required<T2_3>[K_12]>(key2: K2_24) => {
+                            value: Required<T2_3>[K_12][K2_24];
+                            isDefined: boolean;
+                        };
+                        init: <K2_25 extends keyof Required<T2_3>[K_12]>(key2: K2_25, getter: () => Required<Required<T2_3>[K_12]>[K2_25]) => Required<Required<T2_3>[K_12]>[K2_25];
+                        set: <K2_26 extends keyof Required<T2_3>[K_12]>(key2: K2_26, v: Required<T2_3[K_12]>[K2_26]) => Required<T2_3[K_12]>[K2_26];
+                        get: <K2_27 extends keyof Required<T2_3>[K_12]>(key2: K2_27) => Required<T2_3>[K_12][K2_27] | undefined;
+                        has: <K2_28 extends keyof Required<T2_3>[K_12]>(key2: K2_28) => boolean;
+                        del: <K2_29 extends keyof Required<T2_3>[K_12]>(key2: K2_29) => void;
+                        entries: () => [string, unknown][];
+                        clear: () => void;
+                    };
+                    getStore: <K_13 extends keyof T2_3>(key: K_13) => T2_3[K_13];
+                    setStore: <K_14 extends keyof T2_3>(key: K_14, v: T2_3[K_14]) => void;
+                    setParentCtx: (parentCtx: unknown) => void;
+                    hasParentCtx: () => boolean;
+                    getParentCtx: <T2_4 = T2_3>() => {
+                        getCtx: () => T2_4;
+                        endEvent: (abortReason?: string | undefined) => void;
+                        store: <K_15 extends keyof T2_4>(key: K_15) => {
+                            value: T2_4[K_15];
+                            hook: <K2_30 extends keyof Required<T2_4>[K_15]>(key2: K2_30) => {
+                                value: Required<T2_4>[K_15][K2_30];
+                                isDefined: boolean;
+                            };
+                            init: <K2_31 extends keyof Required<T2_4>[K_15]>(key2: K2_31, getter: () => Required<Required<T2_4>[K_15]>[K2_31]) => Required<Required<T2_4>[K_15]>[K2_31];
+                            set: <K2_32 extends keyof Required<T2_4>[K_15]>(key2: K2_32, v: Required<T2_4[K_15]>[K2_32]) => Required<T2_4[K_15]>[K2_32];
+                            get: <K2_33 extends keyof Required<T2_4>[K_15]>(key2: K2_33) => Required<T2_4>[K_15][K2_33] | undefined;
+                            has: <K2_34 extends keyof Required<T2_4>[K_15]>(key2: K2_34) => boolean;
+                            del: <K2_35 extends keyof Required<T2_4>[K_15]>(key2: K2_35) => void;
+                            entries: () => [string, unknown][];
+                            clear: () => void;
+                        };
+                        getStore: <K_16 extends keyof T2_4>(key: K_16) => T2_4[K_16];
+                        setStore: <K_17 extends keyof T2_4>(key: K_17, v: T2_4[K_17]) => void;
+                        setParentCtx: (parentCtx: unknown) => void;
+                        hasParentCtx: () => boolean;
+                        getParentCtx: <T2_5 = T2_4>() => {
+                            getCtx: () => T2_5;
+                            endEvent: (abortReason?: string | undefined) => void;
+                            store: <K_18 extends keyof T2_5>(key: K_18) => {
+                                value: T2_5[K_18];
+                                hook: <K2_36 extends keyof Required<T2_5>[K_18]>(key2: K2_36) => {
+                                    value: Required<T2_5>[K_18][K2_36];
+                                    isDefined: boolean;
+                                };
+                                init: <K2_37 extends keyof Required<T2_5>[K_18]>(key2: K2_37, getter: () => Required<Required<T2_5>[K_18]>[K2_37]) => Required<Required<T2_5>[K_18]>[K2_37];
+                                set: <K2_38 extends keyof Required<T2_5>[K_18]>(key2: K2_38, v: Required<T2_5[K_18]>[K2_38]) => Required<T2_5[K_18]>[K2_38];
+                                get: <K2_39 extends keyof Required<T2_5>[K_18]>(key2: K2_39) => Required<T2_5>[K_18][K2_39] | undefined;
+                                has: <K2_40 extends keyof Required<T2_5>[K_18]>(key2: K2_40) => boolean;
+                                del: <K2_41 extends keyof Required<T2_5>[K_18]>(key2: K2_41) => void;
+                                entries: () => [string, unknown][];
+                                clear: () => void;
+                            };
+                            getStore: <K_19 extends keyof T2_5>(key: K_19) => T2_5[K_19];
+                            setStore: <K_20 extends keyof T2_5>(key: K_20, v: T2_5[K_20]) => void;
+                            setParentCtx: (parentCtx: unknown) => void;
+                            hasParentCtx: () => boolean;
+                            getParentCtx: <T2_6 = T2_5>() => {
+                                getCtx: () => T2_6;
+                                endEvent: (abortReason?: string | undefined) => void;
+                                store: <K_21 extends keyof T2_6>(key: K_21) => {
+                                    value: T2_6[K_21];
+                                    hook: <K2_42 extends keyof Required<T2_6>[K_21]>(key2: K2_42) => {
+                                        value: Required<T2_6>[K_21][K2_42];
+                                        isDefined: boolean;
+                                    };
+                                    init: <K2_43 extends keyof Required<T2_6>[K_21]>(key2: K2_43, getter: () => Required<Required<T2_6>[K_21]>[K2_43]) => Required<Required<T2_6>[K_21]>[K2_43];
+                                    set: <K2_44 extends keyof Required<T2_6>[K_21]>(key2: K2_44, v: Required<T2_6[K_21]>[K2_44]) => Required<T2_6[K_21]>[K2_44];
+                                    get: <K2_45 extends keyof Required<T2_6>[K_21]>(key2: K2_45) => Required<T2_6>[K_21][K2_45] | undefined;
+                                    has: <K2_46 extends keyof Required<T2_6>[K_21]>(key2: K2_46) => boolean;
+                                    del: <K2_47 extends keyof Required<T2_6>[K_21]>(key2: K2_47) => void;
+                                    entries: () => [string, unknown][];
+                                    clear: () => void;
+                                };
+                                getStore: <K_22 extends keyof T2_6>(key: K_22) => T2_6[K_22];
+                                setStore: <K_23 extends keyof T2_6>(key: K_23, v: T2_6[K_23]) => void;
+                                setParentCtx: (parentCtx: unknown) => void;
+                                hasParentCtx: () => boolean;
+                                getParentCtx: <T2_7 = T2_6>() => {
+                                    getCtx: () => T2_7;
+                                    endEvent: (abortReason?: string | undefined) => void;
+                                    store: <K_24 extends keyof T2_7>(key: K_24) => {
+                                        value: T2_7[K_24];
+                                        hook: <K2_48 extends keyof Required<T2_7>[K_24]>(key2: K2_48) => {
+                                            value: Required<T2_7>[K_24][K2_48];
+                                            isDefined: boolean;
+                                        };
+                                        init: <K2_49 extends keyof Required<T2_7>[K_24]>(key2: K2_49, getter: () => Required<Required<T2_7>[K_24]>[K2_49]) => Required<Required<T2_7>[K_24]>[K2_49];
+                                        set: <K2_50 extends keyof Required<T2_7>[K_24]>(key2: K2_50, v: Required<T2_7[K_24]>[K2_50]) => Required<T2_7[K_24]>[K2_50];
+                                        get: <K2_51 extends keyof Required<T2_7>[K_24]>(key2: K2_51) => Required<T2_7>[K_24][K2_51] | undefined;
+                                        has: <K2_52 extends keyof Required<T2_7>[K_24]>(key2: K2_52) => boolean;
+                                        del: <K2_53 extends keyof Required<T2_7>[K_24]>(key2: K2_53) => void;
+                                        entries: () => [string, unknown][];
+                                        clear: () => void;
+                                    };
+                                    getStore: <K_25 extends keyof T2_7>(key: K_25) => T2_7[K_25];
+                                    setStore: <K_26 extends keyof T2_7>(key: K_26, v: T2_7[K_26]) => void;
+                                    setParentCtx: (parentCtx: unknown) => void;
+                                    hasParentCtx: () => boolean;
+                                    getParentCtx: <T2_8 = T2_7>() => {
+                                        getCtx: () => T2_8;
+                                        endEvent: (abortReason?: string | undefined) => void;
+                                        store: <K_27 extends keyof T2_8>(key: K_27) => {
+                                            value: T2_8[K_27];
+                                            hook: <K2_54 extends keyof Required<T2_8>[K_27]>(key2: K2_54) => {
+                                                value: Required<T2_8>[K_27][K2_54];
+                                                isDefined: boolean;
+                                            };
+                                            init: <K2_55 extends keyof Required<T2_8>[K_27]>(key2: K2_55, getter: () => Required<Required<T2_8>[K_27]>[K2_55]) => Required<Required<T2_8>[K_27]>[K2_55];
+                                            set: <K2_56 extends keyof Required<T2_8>[K_27]>(key2: K2_56, v: Required<T2_8[K_27]>[K2_56]) => Required<T2_8[K_27]>[K2_56];
+                                            get: <K2_57 extends keyof Required<T2_8>[K_27]>(key2: K2_57) => Required<T2_8>[K_27][K2_57] | undefined;
+                                            has: <K2_58 extends keyof Required<T2_8>[K_27]>(key2: K2_58) => boolean;
+                                            del: <K2_59 extends keyof Required<T2_8>[K_27]>(key2: K2_59) => void;
+                                            entries: () => [string, unknown][];
+                                            clear: () => void;
+                                        };
+                                        getStore: <K_28 extends keyof T2_8>(key: K_28) => T2_8[K_28];
+                                        setStore: <K_29 extends keyof T2_8>(key: K_29, v: T2_8[K_29]) => void;
+                                        setParentCtx: (parentCtx: unknown) => void;
+                                        hasParentCtx: () => boolean;
+                                        getParentCtx: <T2_9 = T2_8>() => {
+                                            getCtx: () => T2_9;
+                                            endEvent: (abortReason?: string | undefined) => void;
+                                            store: <K_30 extends keyof T2_9>(key: K_30) => {
+                                                value: T2_9[K_30];
+                                                hook: <K2_60 extends keyof Required<T2_9>[K_30]>(key2: K2_60) => {
+                                                    value: Required<T2_9>[K_30][K2_60];
+                                                    isDefined: boolean;
+                                                };
+                                                init: <K2_61 extends keyof Required<T2_9>[K_30]>(key2: K2_61, getter: () => Required<Required<T2_9>[K_30]>[K2_61]) => Required<Required<T2_9>[K_30]>[K2_61];
+                                                set: <K2_62 extends keyof Required<T2_9>[K_30]>(key2: K2_62, v: Required<T2_9[K_30]>[K2_62]) => Required<T2_9[K_30]>[K2_62];
+                                                get: <K2_63 extends keyof Required<T2_9>[K_30]>(key2: K2_63) => Required<T2_9>[K_30][K2_63] | undefined;
+                                                has: <K2_64 extends keyof Required<T2_9>[K_30]>(key2: K2_64) => boolean;
+                                                del: <K2_65 extends keyof Required<T2_9>[K_30]>(key2: K2_65) => void;
+                                                entries: () => [string, unknown][];
+                                                clear: () => void;
+                                            };
+                                            getStore: <K_31 extends keyof T2_9>(key: K_31) => T2_9[K_31];
+                                            setStore: <K_32 extends keyof T2_9>(key: K_32, v: T2_9[K_32]) => void;
+                                            setParentCtx: (parentCtx: unknown) => void;
+                                            hasParentCtx: () => boolean;
+                                            getParentCtx: <T2_10 = T2_9>() => any;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
 };
 
 interface TEventLoggerData {
@@ -117,4 +308,4 @@ type THook<T = string, K extends PropertyKey = 'value'> = {
     [key in K]: T;
 };
 
-export { EventLogger, type TEmpty, type TEventLoggerData, type TEventOptions, type TGenericContextStore, type TGenericEvent, type THook, attachHook, createEventContext, eventContextHooks, useEventContext, useEventId, useEventLogger, useRouteParams };
+export { EventLogger, type TEmpty, type TEventLoggerData, type TEventOptions, type TGenericContextStore, type TGenericEvent, type THook, asyncStorage, attachHook, createAsyncEventContext, eventContextHooks, useAsyncEventContext, useEventId, useEventLogger, useRouteParams };

package/dist/index.mjs

@@ -1,4 +1,5 @@
 import { randomUUID } from 'crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { Hookable } from 'hookable';
 import { ProstoLogger, createConsoleTransort, coloredConsole } from '@prostojs/logger';
 
@@ -26,18 +27,43 @@ function attachHook(target, opts, name) {
     return target;
 }
 
-let currentContext = null;
-function createEventContext(data) {
+const asyncStorage = new AsyncLocalStorage();
+function createAsyncEventContext(data) {
     const newContext = { ...data };
-    currentContext = newContext;
     eventContextHooks.fireStartEvent(data.event.type);
-    return _getCtxHelpers(newContext);
+    return (cb) => {
+        const result = asyncStorage.run(newContext, cb);
+        if (result instanceof Promise) {
+            result
+                .then(r => {
+                endEvent(r);
+                return r;
+            })
+                .catch(error => {
+                endEvent(error);
+            });
+        }
+        else {
+            endEvent(result);
+        }
+        function endEvent(output) {
+            if (!newContext._ended) {
+                if (output instanceof Error) {
+                    eventContextHooks.fireEndEvent(data.event.type, output.message);
+                }
+                else {
+                    eventContextHooks.fireEndEvent(data.event.type);
+                }
+            }
+        }
+        return result;
+    };
 }
-function useEventContext(expectedTypes) {
-    if (!currentContext) {
-        throw new Error('Event context does not exist. Use event context synchronously within the runtime of the event.');
+function useAsyncEventContext(expectedTypes) {
+    let cc = asyncStorage.getStore();
+    if (!cc) {
+        throw new Error('Event context does not exist at this point.');
     }
-    let cc = currentContext;
     if (expectedTypes || typeof expectedTypes === 'string') {
         const type = cc.event.type;
         const types = typeof expectedTypes === 'string' ? [expectedTypes] : expectedTypes;
@@ -126,15 +152,13 @@ function _getCtxHelpers(cc) {
     function set(key, v) {
         getCtx()[key] = v;
     }
-    const clearCtx = () => (cc === currentContext ? (currentContext = null) : null);
+    const hasParentCtx = () => !!cc.parentCtx;
     return {
         getCtx,
-        restoreCtx: () => (currentContext = cc),
-        clearCtx,
         endEvent: (abortReason) => {
-            if (cc) {
+            if (cc && !cc._ended) {
+                cc._ended = true;
                 eventContextHooks.fireEndEvent(cc.event.type, abortReason);
-                clearCtx();
             }
         },
         store,
@@ -143,12 +167,18 @@ function _getCtxHelpers(cc) {
         setParentCtx: (parentCtx) => {
             cc.parentCtx = parentCtx;
         },
-        restoreParentCtx: () => (currentContext = cc.parentCtx || null),
+        hasParentCtx,
+        getParentCtx: () => {
+            if (!hasParentCtx()) {
+                throw new Error('Parent context is not available');
+            }
+            return _getCtxHelpers(cc.parentCtx);
+        },
     };
 }
 
 function useEventId() {
-    const { store } = useEventContext();
+    const { store } = useAsyncEventContext();
     const { init } = store('event');
     const getId = () => init('id', () => randomUUID());
     return { getId };
@@ -178,7 +208,7 @@ class EventLogger extends ProstoLogger {
 
 function useEventLogger(topic) {
     const { getId } = useEventId();
-    const { store, getCtx } = useEventContext();
+    const { store, getCtx } = useAsyncEventContext();
     const { init } = store('event');
     const ctx = getCtx();
     const get = () => init('logger', () => new EventLogger(getId(), ctx.options.eventLogger));
@@ -186,7 +216,7 @@ function useEventLogger(topic) {
 }
 
 function useRouteParams() {
-    const { store } = useEventContext();
+    const { store } = useAsyncEventContext();
     const params = (store('routeParams').value || {});
     function get(name) {
         return params[name];
@@ -197,4 +227,4 @@ function useRouteParams() {
     };
 }
 
-export { EventLogger, attachHook, createEventContext, eventContextHooks, useEventContext, useEventId, useEventLogger, useRouteParams };
+export { EventLogger, asyncStorage, attachHook, createAsyncEventContext, eventContextHooks, useAsyncEventContext, useEventId, useEventLogger, useRouteParams };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooksjs/event-core",
-  "version": "0.4.37",
+  "version": "0.5.0",
   "description": "@wooksjs/event-core",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",