@azure-net/kit 3.1.0 → 3.9.2

package/dist/core/shared/eventBus/EventBus.d.ts

@@ -1,87 +0,0 @@
-export interface IEvent<T = unknown> {
-    aggregateId: string;
-    eventType: string;
-    eventVersion: number;
-    occurredAt: Date;
-    metadata: IEventMetadata;
-    busName?: string;
-    payload: T;
-}
-export interface IEventMetadata {
-    userId?: string;
-    correlationId: string;
-    causationId?: string;
-    sessionId?: string;
-    [key: string]: unknown;
-}
-export type DomainEventHandler<T = unknown> = (event: IEvent<T>) => void | Promise<void>;
-export interface IEventSubscription {
-    unsubscribe(): void;
-}
-export declare class EventBus<TEventMap extends object> {
-    private options;
-    private handlers;
-    private wildcardHandlers;
-    private middleware;
-    private eventQueue;
-    private isProcessing;
-    private eventHistory;
-    private priorities;
-    private readonly debug;
-    private readonly maxHistorySize;
-    private readonly busName?;
-    constructor(options?: {
-        busName?: string;
-        enableHistory?: boolean;
-        maxHistorySize?: number;
-        enableAsyncProcessing?: boolean;
-        debug?: boolean;
-    });
-    publish<K extends keyof TEventMap>(eventType: K, payload: TEventMap[K], metadata?: Partial<IEventMetadata>): void;
-    publishBatch<K extends keyof TEventMap>(events: Array<{
-        type: K;
-        payload: TEventMap[K];
-        metadata?: Partial<IEventMetadata>;
-    }>): void;
-    subscribe<K extends keyof TEventMap>(eventType: K, handler: DomainEventHandler<TEventMap[K]>, options?: {
-        priority?: number;
-    }): IEventSubscription;
-    subscribeMany<K extends keyof TEventMap>(eventTypes: K[], handler: DomainEventHandler<TEventMap[K]>): IEventSubscription;
-    subscribeAll(handler: DomainEventHandler): IEventSubscription;
-    use(middleware: <T = unknown>(event: IEvent<T>, next: () => Promise<void>) => Promise<void>): void;
-    private processEvent;
-    private executeHandlers;
-    private safeExecuteHandler;
-    private getHandlersForEvent;
-    private processQueue;
-    private addToHistory;
-    getHistory(filter?: {
-        eventType?: keyof TEventMap;
-        aggregateId?: string;
-    }): IEvent[];
-    waitForCompletion(): Promise<void>;
-    clear(): void;
-    private generateAggregateId;
-    private generateCorrelationId;
-}
-export declare const loggingMiddleware: (event: IEvent, next: () => Promise<void>) => Promise<void>;
-export declare const createEventBus: <TEventMap extends object>(opts: {
-    history?: boolean;
-    asyncProcessing?: boolean;
-    historySize?: number;
-    middlewares?: (<T = unknown>(event: IEvent<T>, next: () => Promise<void>) => Promise<void>)[];
-    debug?: boolean;
-    busName?: string;
-}) => {
-    eventBus: EventBus<TEventMap>;
-    CreateEvent: <K extends keyof TEventMap>(eventName: K, data: TEventMap[K]) => void;
-    CreateBatch: <K extends keyof TEventMap>(events: Array<{
-        type: K;
-        payload: TEventMap[K];
-        metadata?: Partial<IEventMetadata>;
-    }>) => void;
-    CreateSubscriber: <K extends keyof TEventMap>(eventType: K, handler: DomainEventHandler<TEventMap[K]>, options?: {
-        priority?: number;
-    }) => IEventSubscription;
-    CreateSubscribers: <K extends keyof TEventMap>(eventTypes: K[], handler: DomainEventHandler<TEventMap[K]>) => IEventSubscription;
-};

package/dist/core/shared/eventBus/EventBus.js

@@ -1,227 +0,0 @@
-export class EventBus {
-    options;
-    handlers = new Map();
-    wildcardHandlers = new Set();
-    middleware = [];
-    eventQueue = [];
-    isProcessing = false;
-    eventHistory = [];
-    priorities = new Map();
-    debug = false;
-    maxHistorySize = 1000;
-    busName;
-    constructor(options = { debug: false }) {
-        this.options = options;
-        this.busName = options.busName ?? undefined;
-        this.debug = options.debug ?? false;
-        if (options.maxHistorySize) {
-            this.maxHistorySize = options.maxHistorySize;
-        }
-    }
-    publish(eventType, payload, metadata) {
-        const event = {
-            aggregateId: this.generateAggregateId(String(eventType), payload),
-            eventType: String(eventType),
-            eventVersion: 1,
-            occurredAt: new Date(),
-            metadata: {
-                correlationId: this.generateCorrelationId(),
-                ...metadata
-            },
-            busName: this.busName,
-            payload
-        };
-        void this.processEvent(event);
-    }
-    publishBatch(events) {
-        const domainEvents = events.map(({ type, payload, metadata }) => ({
-            aggregateId: this.generateAggregateId(type, payload),
-            eventType: type,
-            eventVersion: 1,
-            occurredAt: new Date(),
-            busName: this.busName,
-            metadata: {
-                correlationId: this.generateCorrelationId(),
-                ...metadata
-            },
-            payload
-        }));
-        domainEvents.forEach((event) => this.processEvent(event));
-    }
-    subscribe(eventType, handler, options) {
-        if (!this.handlers.has(eventType)) {
-            this.handlers.set(eventType, new Set());
-        }
-        const handlers = this.handlers.get(eventType);
-        handlers.add(handler);
-        if (options?.priority !== undefined) {
-            this.priorities.set(eventType, options.priority);
-        }
-        return {
-            unsubscribe: () => {
-                handlers.delete(handler);
-                if (handlers.size === 0) {
-                    this.handlers.delete(eventType);
-                    this.priorities.delete(eventType);
-                }
-            }
-        };
-    }
-    subscribeMany(eventTypes, handler) {
-        const subscriptions = eventTypes.map((type) => this.subscribe(type, handler));
-        return {
-            unsubscribe: () => {
-                subscriptions.forEach((sub) => sub.unsubscribe());
-            }
-        };
-    }
-    subscribeAll(handler) {
-        this.wildcardHandlers.add(handler);
-        return {
-            unsubscribe: () => {
-                this.wildcardHandlers.delete(handler);
-            }
-        };
-    }
-    use(middleware) {
-        this.middleware.push(middleware);
-    }
-    async processEvent(event) {
-        if (this.options.enableHistory) {
-            this.addToHistory(event);
-        }
-        const handlers = this.getHandlersForEvent(event);
-        if (!this.debug && handlers.size === 0 && this.wildcardHandlers.size === 0) {
-            return;
-        }
-        if (this.options.enableAsyncProcessing) {
-            this.eventQueue.push({ event, handlers });
-            if (!this.isProcessing) {
-                void this.processQueue();
-            }
-            return;
-        }
-        await this.executeHandlers(event, handlers);
-    }
-    async executeHandlers(event, handlers) {
-        const allHandlers = [...handlers, ...this.wildcardHandlers];
-        let index = -1;
-        const dispatch = async (i) => {
-            if (i <= index) {
-                throw new Error('next() called multiple times');
-            }
-            index = i;
-            if (i === this.middleware.length) {
-                await Promise.all(allHandlers.map((handler) => this.safeExecuteHandler(handler, event)));
-                return;
-            }
-            const middleware = this.middleware[i];
-            await middleware(event, () => dispatch(i + 1));
-        };
-        await dispatch(0);
-    }
-    async safeExecuteHandler(handler, event) {
-        try {
-            await handler(event);
-        }
-        catch (error) {
-            console.error(`Error handling event ${event.eventType}:`, error);
-        }
-    }
-    getHandlersForEvent(event) {
-        const handlers = this.handlers.get(event.eventType);
-        return handlers || new Set();
-    }
-    async processQueue() {
-        if (this.isProcessing || this.eventQueue.length === 0) {
-            return;
-        }
-        this.isProcessing = true;
-        this.eventQueue.sort((a, b) => {
-            const priorityA = this.priorities.get(a.event.eventType) || 0;
-            const priorityB = this.priorities.get(b.event.eventType) || 0;
-            return priorityB - priorityA;
-        });
-        while (this.eventQueue.length > 0) {
-            const batch = this.eventQueue.splice(0, 10);
-            await Promise.all(batch.map(({ event, handlers }) => this.executeHandlers(event, handlers)));
-        }
-        this.isProcessing = false;
-    }
-    addToHistory(event) {
-        this.eventHistory.push(event);
-        if (this.eventHistory.length > this.maxHistorySize) {
-            this.eventHistory.shift();
-        }
-    }
-    getHistory(filter) {
-        if (!filter)
-            return [...this.eventHistory];
-        return this.eventHistory.filter((event) => {
-            switch (true) {
-                case filter.eventType && event.eventType !== filter.eventType:
-                    return false;
-                case filter.aggregateId && event.aggregateId !== filter.aggregateId:
-                    return false;
-                default:
-                    return true;
-            }
-        });
-    }
-    async waitForCompletion() {
-        while (this.isProcessing || this.eventQueue.length > 0) {
-            await new Promise((resolve) => setTimeout(resolve, 10));
-        }
-    }
-    clear() {
-        this.handlers.clear();
-        this.wildcardHandlers.clear();
-        this.eventQueue = [];
-        this.eventHistory = [];
-    }
-    generateAggregateId(eventType, payload) {
-        const maybeEventPayload = payload;
-        if (typeof maybeEventPayload === 'object' && maybeEventPayload?.id)
-            return String(maybeEventPayload.id);
-        if (typeof maybeEventPayload === 'object' && maybeEventPayload?.aggregateId)
-            return String(maybeEventPayload.aggregateId);
-        return `${eventType}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-    }
-    generateCorrelationId() {
-        return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-    }
-}
-export const loggingMiddleware = async (event, next) => {
-    console.log(`[${event.busName ?? ''}Event] ${event.eventType} at ${event.occurredAt.toISOString()}`);
-    console.log(`[${event.busName ?? ''}Event] data:`, event);
-    const start = performance.now();
-    await next();
-    const duration = performance.now() - start;
-    console.log(`[${event.busName ?? ''}Event] ${event.eventType} processed in ${duration.toFixed(2)}ms`);
-};
-export const createEventBus = (opts) => {
-    const { history = true, asyncProcessing = true, historySize = 1000, middlewares = [], debug = false } = opts;
-    const eventBus = new EventBus({
-        busName: opts.busName,
-        enableHistory: history,
-        enableAsyncProcessing: asyncProcessing,
-        maxHistorySize: historySize,
-        debug
-    });
-    middlewares.forEach((value) => {
-        eventBus.use(value);
-    });
-    const CreateEvent = (eventName, data) => {
-        eventBus.publish(eventName, data);
-    };
-    const CreateBatch = (events) => {
-        eventBus.publishBatch(events);
-    };
-    const CreateSubscriber = (eventType, handler, options) => {
-        return eventBus.subscribe(eventType, handler, options);
-    };
-    const CreateSubscribers = (eventTypes, handler) => {
-        return eventBus.subscribeMany(eventTypes, handler);
-    };
-    return { eventBus, CreateEvent, CreateBatch, CreateSubscriber, CreateSubscribers };
-};

package/dist/core/shared/eventBus/index.d.ts

@@ -1 +0,0 @@
-export * from './EventBus.js';

package/dist/core/shared/eventBus/index.js

@@ -1 +0,0 @@
-export * from './EventBus.js';