@wooksjs/event-core 0.4.36 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/dist/index.cjs +52 -19
  2. package/dist/index.d.ts +230 -39
  3. package/dist/index.mjs +50 -18
  4. package/package.json +1 -1
package/dist/index.cjs CHANGED
@@ -1,6 +1,7 @@
1
1
  'use strict';
2
2
 
3
3
  var crypto = require('crypto');
4
+ var node_async_hooks = require('node:async_hooks');
4
5
  var hookable = require('hookable');
5
6
  var logger = require('@prostojs/logger');
6
7
 
@@ -28,18 +29,43 @@ function attachHook(target, opts, name) {
28
29
  return target;
29
30
  }
30
31
 
31
- let currentContext = null;
32
- function createEventContext(data) {
32
+ const asyncStorage = new node_async_hooks.AsyncLocalStorage();
33
+ function createAsyncEventContext(data) {
33
34
  const newContext = { ...data };
34
- currentContext = newContext;
35
35
  eventContextHooks.fireStartEvent(data.event.type);
36
- return _getCtxHelpers(newContext);
36
+ return (cb) => {
37
+ const result = asyncStorage.run(newContext, cb);
38
+ if (result instanceof Promise) {
39
+ result
40
+ .then(r => {
41
+ endEvent(r);
42
+ return r;
43
+ })
44
+ .catch(error => {
45
+ endEvent(error);
46
+ });
47
+ }
48
+ else {
49
+ endEvent(result);
50
+ }
51
+ function endEvent(output) {
52
+ if (!newContext._ended) {
53
+ if (output instanceof Error) {
54
+ eventContextHooks.fireEndEvent(data.event.type, output.message);
55
+ }
56
+ else {
57
+ eventContextHooks.fireEndEvent(data.event.type);
58
+ }
59
+ }
60
+ }
61
+ return result;
62
+ };
37
63
  }
38
- function useEventContext(expectedTypes) {
39
- if (!currentContext) {
40
- throw new Error('Event context does not exist. Use event context synchronously within the runtime of the event.');
64
+ function useAsyncEventContext(expectedTypes) {
65
+ let cc = asyncStorage.getStore();
66
+ if (!cc) {
67
+ throw new Error('Event context does not exist at this point.');
41
68
  }
42
- let cc = currentContext;
43
69
  if (expectedTypes || typeof expectedTypes === 'string') {
44
70
  const type = cc.event.type;
45
71
  const types = typeof expectedTypes === 'string' ? [expectedTypes] : expectedTypes;
@@ -128,14 +154,14 @@ function _getCtxHelpers(cc) {
128
154
  function set(key, v) {
129
155
  getCtx()[key] = v;
130
156
  }
131
- const clearCtx = () => (cc === currentContext ? (currentContext = null) : null);
157
+ const hasParentCtx = () => !!cc.parentCtx;
132
158
  return {
133
159
  getCtx,
134
- restoreCtx: () => (currentContext = cc),
135
- clearCtx,
136
160
  endEvent: (abortReason) => {
137
- eventContextHooks.fireEndEvent(cc.event.type, abortReason);
138
- clearCtx();
161
+ if (cc && !cc._ended) {
162
+ cc._ended = true;
163
+ eventContextHooks.fireEndEvent(cc.event.type, abortReason);
164
+ }
139
165
  },
140
166
  store,
141
167
  getStore: get,
@@ -143,12 +169,18 @@ function _getCtxHelpers(cc) {
143
169
  setParentCtx: (parentCtx) => {
144
170
  cc.parentCtx = parentCtx;
145
171
  },
146
- restoreParentCtx: () => (currentContext = cc.parentCtx || null),
172
+ hasParentCtx,
173
+ getParentCtx: () => {
174
+ if (!hasParentCtx()) {
175
+ throw new Error('Parent context is not available');
176
+ }
177
+ return _getCtxHelpers(cc.parentCtx);
178
+ },
147
179
  };
148
180
  }
149
181
 
150
182
  function useEventId() {
151
- const { store } = useEventContext();
183
+ const { store } = useAsyncEventContext();
152
184
  const { init } = store('event');
153
185
  const getId = () => init('id', () => crypto.randomUUID());
154
186
  return { getId };
@@ -178,7 +210,7 @@ class EventLogger extends logger.ProstoLogger {
178
210
 
179
211
  function useEventLogger(topic) {
180
212
  const { getId } = useEventId();
181
- const { store, getCtx } = useEventContext();
213
+ const { store, getCtx } = useAsyncEventContext();
182
214
  const { init } = store('event');
183
215
  const ctx = getCtx();
184
216
  const get = () => init('logger', () => new EventLogger(getId(), ctx.options.eventLogger));
@@ -186,7 +218,7 @@ function useEventLogger(topic) {
186
218
  }
187
219
 
188
220
  function useRouteParams() {
189
- const { store } = useEventContext();
221
+ const { store } = useAsyncEventContext();
190
222
  const params = (store('routeParams').value || {});
191
223
  function get(name) {
192
224
  return params[name];
@@ -198,10 +230,11 @@ function useRouteParams() {
198
230
  }
199
231
 
200
232
  exports.EventLogger = EventLogger;
233
+ exports.asyncStorage = asyncStorage;
201
234
  exports.attachHook = attachHook;
202
- exports.createEventContext = createEventContext;
235
+ exports.createAsyncEventContext = createAsyncEventContext;
203
236
  exports.eventContextHooks = eventContextHooks;
204
- exports.useEventContext = useEventContext;
237
+ exports.useAsyncEventContext = useAsyncEventContext;
205
238
  exports.useEventId = useEventId;
206
239
  exports.useEventLogger = useEventLogger;
207
240
  exports.useRouteParams = useRouteParams;
package/dist/index.d.ts CHANGED
@@ -1,5 +1,6 @@
1
1
  import * as _prostojs_logger from '@prostojs/logger';
2
2
  import { TProstoLoggerOptions, ProstoLogger } from '@prostojs/logger';
3
+ import { AsyncLocalStorage } from 'node:async_hooks';
3
4
  import { Hookable } from 'hookable';
4
5
 
5
6
  declare function useEventId(): {
@@ -24,48 +25,17 @@ interface TGenericContextStore<CustomEventType = TEmpty> {
24
25
  options: TEventOptions;
25
26
  parentCtx?: TGenericContextStore;
26
27
  routeParams?: Record<string, string | string[]>;
28
+ _ended?: boolean;
27
29
  }
28
30
  /**
29
- * Create a new event context
31
+ * AsyncLocalStorage instance
30
32
  *
31
- * @param data
32
- * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
33
+ * Use on your own risk only if you know what you're doing
33
34
  */
34
- declare function createEventContext<S = TEmpty, EventTypeToCreate = TEmpty>(data: S & TGenericContextStore<EventTypeToCreate>): {
35
- getCtx: () => S & TGenericContextStore<EventTypeToCreate>;
36
- restoreCtx: () => TGenericContextStore<TEmpty>;
37
- clearCtx: () => null;
38
- endEvent: (abortReason?: string | undefined) => void;
39
- store: <K extends keyof S | keyof TGenericContextStore<EventTypeToCreate>>(key: K) => {
40
- value: (S & TGenericContextStore<EventTypeToCreate>)[K];
41
- hook: <K2 extends keyof Required<S & TGenericContextStore<EventTypeToCreate>>[K]>(key2: K2) => {
42
- value: Required<S & TGenericContextStore<EventTypeToCreate>>[K][K2];
43
- isDefined: boolean;
44
- };
45
- 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];
46
- 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];
47
- get: <K2_3 extends keyof Required<S & TGenericContextStore<EventTypeToCreate>>[K]>(key2: K2_3) => Required<S & TGenericContextStore<EventTypeToCreate>>[K][K2_3] | undefined;
48
- has: <K2_4 extends keyof Required<S & TGenericContextStore<EventTypeToCreate>>[K]>(key2: K2_4) => boolean;
49
- del: <K2_5 extends keyof Required<S & TGenericContextStore<EventTypeToCreate>>[K]>(key2: K2_5) => void;
50
- entries: () => [string, unknown][];
51
- clear: () => void;
52
- };
53
- getStore: <K_1 extends keyof S | keyof TGenericContextStore<EventTypeToCreate>>(key: K_1) => (S & TGenericContextStore<EventTypeToCreate>)[K_1];
54
- setStore: <K_2 extends keyof S | keyof TGenericContextStore<EventTypeToCreate>>(key: K_2, v: (S & TGenericContextStore<EventTypeToCreate>)[K_2]) => void;
55
- setParentCtx: (parentCtx: unknown) => void;
56
- restoreParentCtx: () => TGenericContextStore<TEmpty> | null;
57
- };
58
- /**
59
- * Use existing event context
60
- *
61
- * !Must be called syncronously while context is reachable
62
- *
63
- * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
64
- */
65
- declare function useEventContext<S = TEmpty, EventType = TEmpty>(expectedTypes?: string | string[]): {
35
+ declare const asyncStorage: AsyncLocalStorage<unknown>;
36
+ declare function createAsyncEventContext<S = TEmpty, EventTypeToCreate = TEmpty>(data: S & TGenericContextStore<EventTypeToCreate>): <T>(cb: (...a: any[]) => T) => T;
37
+ declare function useAsyncEventContext<S = TEmpty, EventType = TEmpty>(expectedTypes?: string | string[]): {
66
38
  getCtx: () => S & TGenericContextStore<EventType>;
67
- restoreCtx: () => TGenericContextStore<TEmpty>;
68
- clearCtx: () => null;
69
39
  endEvent: (abortReason?: string | undefined) => void;
70
40
  store: <K extends keyof S | keyof TGenericContextStore<EventType>>(key: K) => {
71
41
  value: (S & TGenericContextStore<EventType>)[K];
@@ -84,7 +54,228 @@ declare function useEventContext<S = TEmpty, EventType = TEmpty>(expectedTypes?:
84
54
  getStore: <K_1 extends keyof S | keyof TGenericContextStore<EventType>>(key: K_1) => (S & TGenericContextStore<EventType>)[K_1];
85
55
  setStore: <K_2 extends keyof S | keyof TGenericContextStore<EventType>>(key: K_2, v: (S & TGenericContextStore<EventType>)[K_2]) => void;
86
56
  setParentCtx: (parentCtx: unknown) => void;
87
- restoreParentCtx: () => TGenericContextStore<TEmpty> | null;
57
+ hasParentCtx: () => boolean;
58
+ getParentCtx: <T2 = S & TGenericContextStore<EventType>>() => {
59
+ getCtx: () => T2;
60
+ endEvent: (abortReason?: string | undefined) => void;
61
+ store: <K_3 extends keyof T2>(key: K_3) => {
62
+ value: T2[K_3];
63
+ hook: <K2_6 extends keyof Required<T2>[K_3]>(key2: K2_6) => {
64
+ value: Required<T2>[K_3][K2_6];
65
+ isDefined: boolean;
66
+ };
67
+ 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];
68
+ 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];
69
+ get: <K2_9 extends keyof Required<T2>[K_3]>(key2: K2_9) => Required<T2>[K_3][K2_9] | undefined;
70
+ has: <K2_10 extends keyof Required<T2>[K_3]>(key2: K2_10) => boolean;
71
+ del: <K2_11 extends keyof Required<T2>[K_3]>(key2: K2_11) => void;
72
+ entries: () => [string, unknown][];
73
+ clear: () => void;
74
+ };
75
+ getStore: <K_4 extends keyof T2>(key: K_4) => T2[K_4];
76
+ setStore: <K_5 extends keyof T2>(key: K_5, v: T2[K_5]) => void;
77
+ setParentCtx: (parentCtx: unknown) => void;
78
+ hasParentCtx: () => boolean;
79
+ getParentCtx: <T2_1 = T2>() => {
80
+ getCtx: () => T2_1;
81
+ endEvent: (abortReason?: string | undefined) => void;
82
+ store: <K_6 extends keyof T2_1>(key: K_6) => {
83
+ value: T2_1[K_6];
84
+ hook: <K2_12 extends keyof Required<T2_1>[K_6]>(key2: K2_12) => {
85
+ value: Required<T2_1>[K_6][K2_12];
86
+ isDefined: boolean;
87
+ };
88
+ 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];
89
+ 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];
90
+ get: <K2_15 extends keyof Required<T2_1>[K_6]>(key2: K2_15) => Required<T2_1>[K_6][K2_15] | undefined;
91
+ has: <K2_16 extends keyof Required<T2_1>[K_6]>(key2: K2_16) => boolean;
92
+ del: <K2_17 extends keyof Required<T2_1>[K_6]>(key2: K2_17) => void;
93
+ entries: () => [string, unknown][];
94
+ clear: () => void;
95
+ };
96
+ getStore: <K_7 extends keyof T2_1>(key: K_7) => T2_1[K_7];
97
+ setStore: <K_8 extends keyof T2_1>(key: K_8, v: T2_1[K_8]) => void;
98
+ setParentCtx: (parentCtx: unknown) => void;
99
+ hasParentCtx: () => boolean;
100
+ getParentCtx: <T2_2 = T2_1>() => {
101
+ getCtx: () => T2_2;
102
+ endEvent: (abortReason?: string | undefined) => void;
103
+ store: <K_9 extends keyof T2_2>(key: K_9) => {
104
+ value: T2_2[K_9];
105
+ hook: <K2_18 extends keyof Required<T2_2>[K_9]>(key2: K2_18) => {
106
+ value: Required<T2_2>[K_9][K2_18];
107
+ isDefined: boolean;
108
+ };
109
+ 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];
110
+ 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];
111
+ get: <K2_21 extends keyof Required<T2_2>[K_9]>(key2: K2_21) => Required<T2_2>[K_9][K2_21] | undefined;
112
+ has: <K2_22 extends keyof Required<T2_2>[K_9]>(key2: K2_22) => boolean;
113
+ del: <K2_23 extends keyof Required<T2_2>[K_9]>(key2: K2_23) => void;
114
+ entries: () => [string, unknown][];
115
+ clear: () => void;
116
+ };
117
+ getStore: <K_10 extends keyof T2_2>(key: K_10) => T2_2[K_10];
118
+ setStore: <K_11 extends keyof T2_2>(key: K_11, v: T2_2[K_11]) => void;
119
+ setParentCtx: (parentCtx: unknown) => void;
120
+ hasParentCtx: () => boolean;
121
+ getParentCtx: <T2_3 = T2_2>() => {
122
+ getCtx: () => T2_3;
123
+ endEvent: (abortReason?: string | undefined) => void;
124
+ store: <K_12 extends keyof T2_3>(key: K_12) => {
125
+ value: T2_3[K_12];
126
+ hook: <K2_24 extends keyof Required<T2_3>[K_12]>(key2: K2_24) => {
127
+ value: Required<T2_3>[K_12][K2_24];
128
+ isDefined: boolean;
129
+ };
130
+ 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];
131
+ 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];
132
+ get: <K2_27 extends keyof Required<T2_3>[K_12]>(key2: K2_27) => Required<T2_3>[K_12][K2_27] | undefined;
133
+ has: <K2_28 extends keyof Required<T2_3>[K_12]>(key2: K2_28) => boolean;
134
+ del: <K2_29 extends keyof Required<T2_3>[K_12]>(key2: K2_29) => void;
135
+ entries: () => [string, unknown][];
136
+ clear: () => void;
137
+ };
138
+ getStore: <K_13 extends keyof T2_3>(key: K_13) => T2_3[K_13];
139
+ setStore: <K_14 extends keyof T2_3>(key: K_14, v: T2_3[K_14]) => void;
140
+ setParentCtx: (parentCtx: unknown) => void;
141
+ hasParentCtx: () => boolean;
142
+ getParentCtx: <T2_4 = T2_3>() => {
143
+ getCtx: () => T2_4;
144
+ endEvent: (abortReason?: string | undefined) => void;
145
+ store: <K_15 extends keyof T2_4>(key: K_15) => {
146
+ value: T2_4[K_15];
147
+ hook: <K2_30 extends keyof Required<T2_4>[K_15]>(key2: K2_30) => {
148
+ value: Required<T2_4>[K_15][K2_30];
149
+ isDefined: boolean;
150
+ };
151
+ 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];
152
+ 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];
153
+ get: <K2_33 extends keyof Required<T2_4>[K_15]>(key2: K2_33) => Required<T2_4>[K_15][K2_33] | undefined;
154
+ has: <K2_34 extends keyof Required<T2_4>[K_15]>(key2: K2_34) => boolean;
155
+ del: <K2_35 extends keyof Required<T2_4>[K_15]>(key2: K2_35) => void;
156
+ entries: () => [string, unknown][];
157
+ clear: () => void;
158
+ };
159
+ getStore: <K_16 extends keyof T2_4>(key: K_16) => T2_4[K_16];
160
+ setStore: <K_17 extends keyof T2_4>(key: K_17, v: T2_4[K_17]) => void;
161
+ setParentCtx: (parentCtx: unknown) => void;
162
+ hasParentCtx: () => boolean;
163
+ getParentCtx: <T2_5 = T2_4>() => {
164
+ getCtx: () => T2_5;
165
+ endEvent: (abortReason?: string | undefined) => void;
166
+ store: <K_18 extends keyof T2_5>(key: K_18) => {
167
+ value: T2_5[K_18];
168
+ hook: <K2_36 extends keyof Required<T2_5>[K_18]>(key2: K2_36) => {
169
+ value: Required<T2_5>[K_18][K2_36];
170
+ isDefined: boolean;
171
+ };
172
+ 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];
173
+ 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];
174
+ get: <K2_39 extends keyof Required<T2_5>[K_18]>(key2: K2_39) => Required<T2_5>[K_18][K2_39] | undefined;
175
+ has: <K2_40 extends keyof Required<T2_5>[K_18]>(key2: K2_40) => boolean;
176
+ del: <K2_41 extends keyof Required<T2_5>[K_18]>(key2: K2_41) => void;
177
+ entries: () => [string, unknown][];
178
+ clear: () => void;
179
+ };
180
+ getStore: <K_19 extends keyof T2_5>(key: K_19) => T2_5[K_19];
181
+ setStore: <K_20 extends keyof T2_5>(key: K_20, v: T2_5[K_20]) => void;
182
+ setParentCtx: (parentCtx: unknown) => void;
183
+ hasParentCtx: () => boolean;
184
+ getParentCtx: <T2_6 = T2_5>() => {
185
+ getCtx: () => T2_6;
186
+ endEvent: (abortReason?: string | undefined) => void;
187
+ store: <K_21 extends keyof T2_6>(key: K_21) => {
188
+ value: T2_6[K_21];
189
+ hook: <K2_42 extends keyof Required<T2_6>[K_21]>(key2: K2_42) => {
190
+ value: Required<T2_6>[K_21][K2_42];
191
+ isDefined: boolean;
192
+ };
193
+ 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];
194
+ 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];
195
+ get: <K2_45 extends keyof Required<T2_6>[K_21]>(key2: K2_45) => Required<T2_6>[K_21][K2_45] | undefined;
196
+ has: <K2_46 extends keyof Required<T2_6>[K_21]>(key2: K2_46) => boolean;
197
+ del: <K2_47 extends keyof Required<T2_6>[K_21]>(key2: K2_47) => void;
198
+ entries: () => [string, unknown][];
199
+ clear: () => void;
200
+ };
201
+ getStore: <K_22 extends keyof T2_6>(key: K_22) => T2_6[K_22];
202
+ setStore: <K_23 extends keyof T2_6>(key: K_23, v: T2_6[K_23]) => void;
203
+ setParentCtx: (parentCtx: unknown) => void;
204
+ hasParentCtx: () => boolean;
205
+ getParentCtx: <T2_7 = T2_6>() => {
206
+ getCtx: () => T2_7;
207
+ endEvent: (abortReason?: string | undefined) => void;
208
+ store: <K_24 extends keyof T2_7>(key: K_24) => {
209
+ value: T2_7[K_24];
210
+ hook: <K2_48 extends keyof Required<T2_7>[K_24]>(key2: K2_48) => {
211
+ value: Required<T2_7>[K_24][K2_48];
212
+ isDefined: boolean;
213
+ };
214
+ 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];
215
+ 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];
216
+ get: <K2_51 extends keyof Required<T2_7>[K_24]>(key2: K2_51) => Required<T2_7>[K_24][K2_51] | undefined;
217
+ has: <K2_52 extends keyof Required<T2_7>[K_24]>(key2: K2_52) => boolean;
218
+ del: <K2_53 extends keyof Required<T2_7>[K_24]>(key2: K2_53) => void;
219
+ entries: () => [string, unknown][];
220
+ clear: () => void;
221
+ };
222
+ getStore: <K_25 extends keyof T2_7>(key: K_25) => T2_7[K_25];
223
+ setStore: <K_26 extends keyof T2_7>(key: K_26, v: T2_7[K_26]) => void;
224
+ setParentCtx: (parentCtx: unknown) => void;
225
+ hasParentCtx: () => boolean;
226
+ getParentCtx: <T2_8 = T2_7>() => {
227
+ getCtx: () => T2_8;
228
+ endEvent: (abortReason?: string | undefined) => void;
229
+ store: <K_27 extends keyof T2_8>(key: K_27) => {
230
+ value: T2_8[K_27];
231
+ hook: <K2_54 extends keyof Required<T2_8>[K_27]>(key2: K2_54) => {
232
+ value: Required<T2_8>[K_27][K2_54];
233
+ isDefined: boolean;
234
+ };
235
+ 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];
236
+ 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];
237
+ get: <K2_57 extends keyof Required<T2_8>[K_27]>(key2: K2_57) => Required<T2_8>[K_27][K2_57] | undefined;
238
+ has: <K2_58 extends keyof Required<T2_8>[K_27]>(key2: K2_58) => boolean;
239
+ del: <K2_59 extends keyof Required<T2_8>[K_27]>(key2: K2_59) => void;
240
+ entries: () => [string, unknown][];
241
+ clear: () => void;
242
+ };
243
+ getStore: <K_28 extends keyof T2_8>(key: K_28) => T2_8[K_28];
244
+ setStore: <K_29 extends keyof T2_8>(key: K_29, v: T2_8[K_29]) => void;
245
+ setParentCtx: (parentCtx: unknown) => void;
246
+ hasParentCtx: () => boolean;
247
+ getParentCtx: <T2_9 = T2_8>() => {
248
+ getCtx: () => T2_9;
249
+ endEvent: (abortReason?: string | undefined) => void;
250
+ store: <K_30 extends keyof T2_9>(key: K_30) => {
251
+ value: T2_9[K_30];
252
+ hook: <K2_60 extends keyof Required<T2_9>[K_30]>(key2: K2_60) => {
253
+ value: Required<T2_9>[K_30][K2_60];
254
+ isDefined: boolean;
255
+ };
256
+ 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];
257
+ 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];
258
+ get: <K2_63 extends keyof Required<T2_9>[K_30]>(key2: K2_63) => Required<T2_9>[K_30][K2_63] | undefined;
259
+ has: <K2_64 extends keyof Required<T2_9>[K_30]>(key2: K2_64) => boolean;
260
+ del: <K2_65 extends keyof Required<T2_9>[K_30]>(key2: K2_65) => void;
261
+ entries: () => [string, unknown][];
262
+ clear: () => void;
263
+ };
264
+ getStore: <K_31 extends keyof T2_9>(key: K_31) => T2_9[K_31];
265
+ setStore: <K_32 extends keyof T2_9>(key: K_32, v: T2_9[K_32]) => void;
266
+ setParentCtx: (parentCtx: unknown) => void;
267
+ hasParentCtx: () => boolean;
268
+ getParentCtx: <T2_10 = T2_9>() => any;
269
+ };
270
+ };
271
+ };
272
+ };
273
+ };
274
+ };
275
+ };
276
+ };
277
+ };
278
+ };
88
279
  };
89
280
 
90
281
  interface TEventLoggerData {
@@ -117,4 +308,4 @@ type THook<T = string, K extends PropertyKey = 'value'> = {
117
308
  [key in K]: T;
118
309
  };
119
310
 
120
- export { EventLogger, type TEmpty, type TEventLoggerData, type TEventOptions, type TGenericContextStore, type TGenericEvent, type THook, attachHook, createEventContext, eventContextHooks, useEventContext, useEventId, useEventLogger, useRouteParams };
311
+ 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 CHANGED
@@ -1,4 +1,5 @@
1
1
  import { randomUUID } from 'crypto';
2
+ import { AsyncLocalStorage } from 'node:async_hooks';
2
3
  import { Hookable } from 'hookable';
3
4
  import { ProstoLogger, createConsoleTransort, coloredConsole } from '@prostojs/logger';
4
5
 
@@ -26,18 +27,43 @@ function attachHook(target, opts, name) {
26
27
  return target;
27
28
  }
28
29
 
29
- let currentContext = null;
30
- function createEventContext(data) {
30
+ const asyncStorage = new AsyncLocalStorage();
31
+ function createAsyncEventContext(data) {
31
32
  const newContext = { ...data };
32
- currentContext = newContext;
33
33
  eventContextHooks.fireStartEvent(data.event.type);
34
- return _getCtxHelpers(newContext);
34
+ return (cb) => {
35
+ const result = asyncStorage.run(newContext, cb);
36
+ if (result instanceof Promise) {
37
+ result
38
+ .then(r => {
39
+ endEvent(r);
40
+ return r;
41
+ })
42
+ .catch(error => {
43
+ endEvent(error);
44
+ });
45
+ }
46
+ else {
47
+ endEvent(result);
48
+ }
49
+ function endEvent(output) {
50
+ if (!newContext._ended) {
51
+ if (output instanceof Error) {
52
+ eventContextHooks.fireEndEvent(data.event.type, output.message);
53
+ }
54
+ else {
55
+ eventContextHooks.fireEndEvent(data.event.type);
56
+ }
57
+ }
58
+ }
59
+ return result;
60
+ };
35
61
  }
36
- function useEventContext(expectedTypes) {
37
- if (!currentContext) {
38
- throw new Error('Event context does not exist. Use event context synchronously within the runtime of the event.');
62
+ function useAsyncEventContext(expectedTypes) {
63
+ let cc = asyncStorage.getStore();
64
+ if (!cc) {
65
+ throw new Error('Event context does not exist at this point.');
39
66
  }
40
- let cc = currentContext;
41
67
  if (expectedTypes || typeof expectedTypes === 'string') {
42
68
  const type = cc.event.type;
43
69
  const types = typeof expectedTypes === 'string' ? [expectedTypes] : expectedTypes;
@@ -126,14 +152,14 @@ function _getCtxHelpers(cc) {
126
152
  function set(key, v) {
127
153
  getCtx()[key] = v;
128
154
  }
129
- const clearCtx = () => (cc === currentContext ? (currentContext = null) : null);
155
+ const hasParentCtx = () => !!cc.parentCtx;
130
156
  return {
131
157
  getCtx,
132
- restoreCtx: () => (currentContext = cc),
133
- clearCtx,
134
158
  endEvent: (abortReason) => {
135
- eventContextHooks.fireEndEvent(cc.event.type, abortReason);
136
- clearCtx();
159
+ if (cc && !cc._ended) {
160
+ cc._ended = true;
161
+ eventContextHooks.fireEndEvent(cc.event.type, abortReason);
162
+ }
137
163
  },
138
164
  store,
139
165
  getStore: get,
@@ -141,12 +167,18 @@ function _getCtxHelpers(cc) {
141
167
  setParentCtx: (parentCtx) => {
142
168
  cc.parentCtx = parentCtx;
143
169
  },
144
- restoreParentCtx: () => (currentContext = cc.parentCtx || null),
170
+ hasParentCtx,
171
+ getParentCtx: () => {
172
+ if (!hasParentCtx()) {
173
+ throw new Error('Parent context is not available');
174
+ }
175
+ return _getCtxHelpers(cc.parentCtx);
176
+ },
145
177
  };
146
178
  }
147
179
 
148
180
  function useEventId() {
149
- const { store } = useEventContext();
181
+ const { store } = useAsyncEventContext();
150
182
  const { init } = store('event');
151
183
  const getId = () => init('id', () => randomUUID());
152
184
  return { getId };
@@ -176,7 +208,7 @@ class EventLogger extends ProstoLogger {
176
208
 
177
209
  function useEventLogger(topic) {
178
210
  const { getId } = useEventId();
179
- const { store, getCtx } = useEventContext();
211
+ const { store, getCtx } = useAsyncEventContext();
180
212
  const { init } = store('event');
181
213
  const ctx = getCtx();
182
214
  const get = () => init('logger', () => new EventLogger(getId(), ctx.options.eventLogger));
@@ -184,7 +216,7 @@ function useEventLogger(topic) {
184
216
  }
185
217
 
186
218
  function useRouteParams() {
187
- const { store } = useEventContext();
219
+ const { store } = useAsyncEventContext();
188
220
  const params = (store('routeParams').value || {});
189
221
  function get(name) {
190
222
  return params[name];
@@ -195,4 +227,4 @@ function useRouteParams() {
195
227
  };
196
228
  }
197
229
 
198
- export { EventLogger, attachHook, createEventContext, eventContextHooks, useEventContext, useEventId, useEventLogger, useRouteParams };
230
+ export { EventLogger, asyncStorage, attachHook, createAsyncEventContext, eventContextHooks, useAsyncEventContext, useEventId, useEventLogger, useRouteParams };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@wooksjs/event-core",
3
- "version": "0.4.36",
3
+ "version": "0.5.0",
4
4
  "description": "@wooksjs/event-core",
5
5
  "main": "dist/index.cjs",
6
6
  "module": "dist/index.mjs",