@wooksjs/event-core 0.5.6 → 0.5.8

package/dist/index.cjs

@@ -4,53 +4,19 @@ var crypto = require('crypto');
 var node_async_hooks = require('node:async_hooks');
 var logger = require('@prostojs/logger');
 
-class Hookable {
-    constructor() {
-        this.hooks = {};
-    }
-    hook(name, cb) {
-        if (!this.hooks[name]) {
-            this.hooks[name] = [];
-        }
-        this.hooks[name].push(cb);
-        return () => {
-            this.unhook(name, cb);
-        };
-    }
-    callHook(name, ...args) {
-        if (this.hooks[name]) {
-            for (const cb of this.hooks[name]) {
-                try {
-                    cb(...args);
-                }
-                catch (error) {
-                    console.error(`Error in hook ${name}:`, error);
-                }
-            }
-        }
-    }
-    unhook(name, cb) {
-        if (this.hooks[name]) {
-            this.hooks[name] = this.hooks[name].filter(hookCb => hookCb !== cb);
-        }
+class ContextInjector {
+    with(name, attributes, cb) {
+        const fn = typeof attributes === 'function' ? attributes : cb;
+        return fn();
     }
 }
-
-class EventContextHooks extends Hookable {
-    fireStartEvent(eventType) {
-        this.callHook('start-event', eventType);
-    }
-    fireEndEvent(eventType, abortReason) {
-        this.callHook('end-event', eventType, abortReason);
-    }
-    onStartEvent(cb) {
-        return this.hook('start-event', cb);
-    }
-    onEndEvent(cb) {
-        return this.hook('end-event', cb);
-    }
+let ci = new ContextInjector();
+function getContextInjector() {
+    return ci;
+}
+function replaceContextInjector(newCi) {
+    ci = newCi;
 }
-const eventContextHooks = new EventContextHooks();
 
 function attachHook(target, opts, name) {
     Object.defineProperty(target, name || 'value', {
@@ -63,40 +29,8 @@ function attachHook(target, opts, name) {
 const asyncStorage = new node_async_hooks.AsyncLocalStorage();
 function createAsyncEventContext(data) {
     const newContext = { ...data };
-    return (cb) => {
-        asyncStorage.run(newContext, () => {
-            eventContextHooks.fireStartEvent(newContext.event.type);
-        });
-        const result = asyncStorage.run(newContext, cb);
-        if (result instanceof Promise) {
-            result
-                .then(r => {
-                fireEndEvent(r);
-                return r;
-            })
-                .catch(error => {
-                fireEndEvent(error);
-            });
-        }
-        else {
-            fireEndEvent(result);
-        }
-        function fireEndEvent(output) {
-            if (!newContext._ended) {
-                if (output instanceof Error) {
-                    asyncStorage.run(newContext, () => {
-                        eventContextHooks.fireEndEvent(newContext.event.type, output.message);
-                    });
-                }
-                else {
-                    asyncStorage.run(newContext, () => {
-                        eventContextHooks.fireEndEvent(newContext.event.type);
-                    });
-                }
-            }
-        }
-        return result;
-    };
+    const ci = getContextInjector();
+    return (cb) => asyncStorage.run(newContext, () => ci.with('Event:start', { eventType: newContext.event.type }, cb));
 }
 function useAsyncEventContext(expectedTypes) {
     let cc = asyncStorage.getStore();
@@ -260,12 +194,13 @@ function useRouteParams() {
     };
 }
 
+exports.ContextInjector = ContextInjector;
 exports.EventLogger = EventLogger;
-exports.Hookable = Hookable;
 exports.asyncStorage = asyncStorage;
 exports.attachHook = attachHook;
 exports.createAsyncEventContext = createAsyncEventContext;
-exports.eventContextHooks = eventContextHooks;
+exports.getContextInjector = getContextInjector;
+exports.replaceContextInjector = replaceContextInjector;
 exports.useAsyncEventContext = useAsyncEventContext;
 exports.useEventId = useEventId;
 exports.useEventLogger = useEventLogger;

package/dist/index.d.ts

@@ -280,48 +280,19 @@ declare function useRouteParams<T extends object = Record<string, string | strin
     get: <K extends keyof T>(name: K) => T[K];
 };
 
-type HookCallback = (...args: any[]) => any;
-declare class Hookable {
-    private hooks;
-    /**
-     * Registers a callback to a specific hook name.
-     * @param name - The name of the hook.
-     * @param cb - The callback to register.
-     */
-    hook(name: string, cb: HookCallback): () => void;
-    /**
-     * Calls all callbacks registered to the specified hook name.
-     * @param name - The name of the hook.
-     * @param args - The arguments to pass to each callback.
-     */
-    callHook(name: string, ...args: any[]): void;
-    /**
-     * Unregisters a specific callback from a hook name.
-     * @param name - The name of the hook.
-     * @param cb - The callback to unregister.
-     */
-    unhook(name: string, cb: HookCallback): void;
-}
-
-declare class EventContextHooks extends Hookable {
-    /**
-     * SHould be fired right after a new context is created
-     */
-    fireStartEvent(eventType: string): void;
-    /**
-     * Should be fired at the very end of event processing
-     */
-    fireEndEvent(eventType: string, abortReason?: string): void;
-    /**
-     * Fires when a new context was just created
-     */
-    onStartEvent(cb: (eventType: string) => void): () => void;
-    /**
-     * Fires when event was processed
-     */
-    onEndEvent(cb: (eventType: string, abortReason?: string) => void): () => void;
+/**
+ * ContextInjector
+ *
+ * Provides a way to inject context
+ * Usefull when working with opentelemetry spans
+ */
+declare class ContextInjector<N> {
+    with<T>(name: N, attributes: Record<string, string | number | boolean>, cb: TContextInjectorCallback<T>): T;
+    with<T>(name: N, cb: TContextInjectorCallback<T>): T;
 }
-declare const eventContextHooks: EventContextHooks;
+type TContextInjectorCallback<T> = () => T;
+declare function getContextInjector<N = 'Event:start'>(): ContextInjector<N>;
+declare function replaceContextInjector(newCi: ContextInjector<string>): void;
 
 declare function attachHook<V = unknown, T extends object | Function = object, P extends PropertyKey = 'value'>(target: T, opts: {
     get: () => V | undefined;
@@ -331,4 +302,4 @@ type THook<T = string, K extends PropertyKey = 'value'> = {
     [key in K]: T;
 };
 
-export { EventLogger, Hookable, type TEmpty, type TEventLoggerData, type TEventOptions, type TGenericContextStore, type TGenericEvent, type THook, asyncStorage, attachHook, createAsyncEventContext, eventContextHooks, useAsyncEventContext, useEventId, useEventLogger, useRouteParams };
+export { ContextInjector, EventLogger, type TEmpty, type TEventLoggerData, type TEventOptions, type TGenericContextStore, type TGenericEvent, type THook, asyncStorage, attachHook, createAsyncEventContext, getContextInjector, replaceContextInjector, useAsyncEventContext, useEventId, useEventLogger, useRouteParams };

package/dist/index.mjs

@@ -2,53 +2,19 @@ import { randomUUID } from 'crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { ProstoLogger, createConsoleTransort, coloredConsole } from '@prostojs/logger';
 
-class Hookable {
-    constructor() {
-        this.hooks = {};
-    }
-    hook(name, cb) {
-        if (!this.hooks[name]) {
-            this.hooks[name] = [];
-        }
-        this.hooks[name].push(cb);
-        return () => {
-            this.unhook(name, cb);
-        };
-    }
-    callHook(name, ...args) {
-        if (this.hooks[name]) {
-            for (const cb of this.hooks[name]) {
-                try {
-                    cb(...args);
-                }
-                catch (error) {
-                    console.error(`Error in hook ${name}:`, error);
-                }
-            }
-        }
-    }
-    unhook(name, cb) {
-        if (this.hooks[name]) {
-            this.hooks[name] = this.hooks[name].filter(hookCb => hookCb !== cb);
-        }
+class ContextInjector {
+    with(name, attributes, cb) {
+        const fn = typeof attributes === 'function' ? attributes : cb;
+        return fn();
     }
 }
-
-class EventContextHooks extends Hookable {
-    fireStartEvent(eventType) {
-        this.callHook('start-event', eventType);
-    }
-    fireEndEvent(eventType, abortReason) {
-        this.callHook('end-event', eventType, abortReason);
-    }
-    onStartEvent(cb) {
-        return this.hook('start-event', cb);
-    }
-    onEndEvent(cb) {
-        return this.hook('end-event', cb);
-    }
+let ci = new ContextInjector();
+function getContextInjector() {
+    return ci;
+}
+function replaceContextInjector(newCi) {
+    ci = newCi;
 }
-const eventContextHooks = new EventContextHooks();
 
 function attachHook(target, opts, name) {
     Object.defineProperty(target, name || 'value', {
@@ -61,40 +27,8 @@ function attachHook(target, opts, name) {
 const asyncStorage = new AsyncLocalStorage();
 function createAsyncEventContext(data) {
     const newContext = { ...data };
-    return (cb) => {
-        asyncStorage.run(newContext, () => {
-            eventContextHooks.fireStartEvent(newContext.event.type);
-        });
-        const result = asyncStorage.run(newContext, cb);
-        if (result instanceof Promise) {
-            result
-                .then(r => {
-                fireEndEvent(r);
-                return r;
-            })
-                .catch(error => {
-                fireEndEvent(error);
-            });
-        }
-        else {
-            fireEndEvent(result);
-        }
-        function fireEndEvent(output) {
-            if (!newContext._ended) {
-                if (output instanceof Error) {
-                    asyncStorage.run(newContext, () => {
-                        eventContextHooks.fireEndEvent(newContext.event.type, output.message);
-                    });
-                }
-                else {
-                    asyncStorage.run(newContext, () => {
-                        eventContextHooks.fireEndEvent(newContext.event.type);
-                    });
-                }
-            }
-        }
-        return result;
-    };
+    const ci = getContextInjector();
+    return (cb) => asyncStorage.run(newContext, () => ci.with('Event:start', { eventType: newContext.event.type }, cb));
 }
 function useAsyncEventContext(expectedTypes) {
     let cc = asyncStorage.getStore();
@@ -258,4 +192,4 @@ function useRouteParams() {
     };
 }
 
-export { EventLogger, Hookable, asyncStorage, attachHook, createAsyncEventContext, eventContextHooks, useAsyncEventContext, useEventId, useEventLogger, useRouteParams };
+export { ContextInjector, EventLogger, asyncStorage, attachHook, createAsyncEventContext, getContextInjector, replaceContextInjector, useAsyncEventContext, useEventId, useEventLogger, useRouteParams };

package/package.json

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