@azure-net/kit 3.1.0 → 3.9.1

package/dist/core/infra/httpService/HttpService.d.ts

@@ -1,74 +0,0 @@
-import { type Options } from 'ky';
-export interface IHttpServiceResponse<T = unknown> {
-    headers: Record<string, string>;
-    status: number;
-    success: boolean;
-    data: T;
-    message: string;
-}
-export interface IHttpServiceError<T = unknown> extends IHttpServiceResponse<T> {
-    original?: Error;
-}
-export declare class HttpServiceResponse<T> implements IHttpServiceResponse<T> {
-    headers: Record<string, string>;
-    status: number;
-    success: boolean;
-    data: T;
-    message: string;
-    constructor({ headers, status, success, data, message }: IHttpServiceResponse<T>);
-}
-export declare class HttpServiceError<T> implements IHttpServiceError<T> {
-    headers: Record<string, string>;
-    status: number;
-    success: boolean;
-    data: T;
-    message: string;
-    original?: Error;
-    constructor({ headers, status, success, data, message, original }: IHttpServiceError<T>);
-}
-export interface IHttpServiceOptions extends Options {
-    responseFormat?: 'json' | 'blob' | 'text' | 'arrayBuffer' | 'body';
-}
-export interface IHttpServiceInstanceResponse<T = unknown> extends Response {
-    arrayBuffer: () => Promise<ArrayBuffer>;
-    blob: () => Promise<Blob>;
-    formData: () => Promise<FormData>;
-    json: <J = T>() => Promise<J>;
-    text: () => Promise<string>;
-}
-export interface IHttpServiceInstance {
-    get: <T>(url: string | URL | Request, options?: IHttpServiceOptions) => Promise<IHttpServiceInstanceResponse<T>>;
-    post: <T>(url: string | URL | Request, options?: IHttpServiceOptions) => Promise<IHttpServiceInstanceResponse<T>>;
-    put: <T>(url: string | URL | Request, options?: IHttpServiceOptions) => Promise<IHttpServiceInstanceResponse<T>>;
-    delete: <T>(url: string | URL | Request, options?: IHttpServiceOptions) => Promise<IHttpServiceInstanceResponse<T>>;
-    patch: <T>(url: string | URL | Request, options?: IHttpServiceOptions) => Promise<IHttpServiceInstanceResponse<T>>;
-    head?: (url: string | URL | Request, options?: IHttpServiceOptions) => Promise<IHttpServiceInstanceResponse>;
-    create: (defaultOptions?: IHttpServiceOptions) => IHttpServiceInstance;
-    extend?: (defaultOptions: IHttpServiceOptions | ((parentOptions: IHttpServiceOptions) => IHttpServiceOptions)) => IHttpServiceInstance;
-    readonly stop: typeof stop;
-}
-export declare class HttpService {
-    private baseUrl;
-    private readonly instance;
-    private readonly requestHandler?;
-    private readonly errorHandler?;
-    private readonly globalErrorHandler?;
-    constructor(opts: {
-        baseUrl: string;
-        instance?: IHttpServiceInstance;
-        baseOptions?: Options;
-        onRequest?: (options: Options) => void | Promise<void>;
-        onError?: (err: IHttpServiceError) => HttpServiceError<unknown>;
-        handleError?: (err: unknown) => Promise<HttpServiceError<unknown>>;
-    });
-    setBaseUrl(newBaseUrl: string): void;
-    private prepareOptions;
-    private prepareResponse;
-    post<T>(url: string, options?: IHttpServiceOptions): Promise<IHttpServiceResponse<T>>;
-    get<T>(url: string, options?: IHttpServiceOptions): Promise<IHttpServiceResponse<T>>;
-    patch<T>(url: string, options?: IHttpServiceOptions): Promise<IHttpServiceResponse<T>>;
-    delete<T>(url: string, options?: IHttpServiceOptions): Promise<IHttpServiceResponse<T>>;
-    put<T>(url: string, options?: IHttpServiceOptions): Promise<IHttpServiceResponse<T>>;
-    private handleError;
-    private baseErrorHandler;
-}

package/dist/core/infra/httpService/HttpService.js

@@ -1,164 +0,0 @@
-import ky, {} from 'ky';
-export class HttpServiceResponse {
-    headers;
-    status;
-    success;
-    data;
-    message;
-    constructor({ headers, status, success, data, message }) {
-        this.headers = headers;
-        this.status = status;
-        this.success = success;
-        this.data = data;
-        this.message = message;
-    }
-}
-export class HttpServiceError {
-    headers;
-    status;
-    success;
-    data;
-    message;
-    original;
-    constructor({ headers, status, success, data, message, original }) {
-        this.headers = headers;
-        this.status = status;
-        this.success = success;
-        this.data = data;
-        this.message = message;
-        this.original = original;
-    }
-}
-export class HttpService {
-    baseUrl;
-    instance;
-    requestHandler;
-    errorHandler;
-    globalErrorHandler;
-    constructor(opts) {
-        this.baseUrl = opts.baseUrl;
-        this.instance = opts.instance ? opts.instance.create(opts?.baseOptions) : ky.create(opts?.baseOptions);
-        this.errorHandler = opts?.onError ?? undefined;
-        this.requestHandler = opts?.onRequest ?? undefined;
-        this.globalErrorHandler = opts?.handleError ?? undefined;
-    }
-    setBaseUrl(newBaseUrl) {
-        this.baseUrl = newBaseUrl;
-    }
-    async prepareOptions(requestOptions) {
-        const options = typeof requestOptions === 'object' ? { ...requestOptions } : {};
-        if (this.requestHandler) {
-            await this.requestHandler(options);
-        }
-        return options;
-    }
-    async prepareResponse(request, format = 'json') {
-        let data;
-        try {
-            switch (format) {
-                case 'blob':
-                    data = (await request.blob());
-                    break;
-                case 'text':
-                    data = (await request.text());
-                    break;
-                case 'arrayBuffer':
-                    data = (await request.arrayBuffer());
-                    break;
-                case 'body':
-                    data = request.body;
-                    break;
-                case 'json':
-                    data = (await request.json());
-                    break;
-                default:
-                    data = (await request.json());
-                    break;
-            }
-        }
-        catch {
-            data = null;
-        }
-        return new HttpServiceResponse({
-            headers: request.headers instanceof Headers ? Object.fromEntries(request.headers.entries()) : {},
-            status: request.status,
-            success: request.status < 400,
-            data,
-            message: 'Request completed'
-        });
-    }
-    async post(url, options) {
-        return await this.instance
-            .post(this.baseUrl + url, await this.prepareOptions(options))
-            .then((response) => {
-            return this.prepareResponse(response, options?.responseFormat);
-        })
-            .catch(async (error) => {
-            throw await this.handleError(error);
-        });
-    }
-    async get(url, options) {
-        return await this.instance
-            .get(this.baseUrl + url, await this.prepareOptions(options))
-            .then((response) => {
-            return this.prepareResponse(response, options?.responseFormat);
-        })
-            .catch(async (error) => {
-            throw await this.handleError(error);
-        });
-    }
-    async patch(url, options) {
-        return await this.instance
-            .patch(this.baseUrl + url, await this.prepareOptions(options))
-            .then((response) => {
-            return this.prepareResponse(response, options?.responseFormat);
-        })
-            .catch(async (error) => {
-            throw await this.handleError(error);
-        });
-    }
-    async delete(url, options) {
-        return await this.instance
-            .delete(this.baseUrl + url, await this.prepareOptions(options))
-            .then((response) => {
-            return this.prepareResponse(response, options?.responseFormat);
-        })
-            .catch(async (error) => {
-            throw await this.handleError(error);
-        });
-    }
-    async put(url, options) {
-        return await this.instance
-            .put(this.baseUrl + url, await this.prepareOptions(options))
-            .then((response) => {
-            return this.prepareResponse(response, options?.responseFormat);
-        })
-            .catch(async (error) => {
-            throw await this.handleError(error);
-        });
-    }
-    async handleError(error) {
-        return this.globalErrorHandler ? await this.globalErrorHandler(error) : await this.baseErrorHandler(error);
-    }
-    async baseErrorHandler(err) {
-        let headers;
-        let response;
-        try {
-            headers = err?.response?.headers && err?.response?.headers instanceof Headers ? Object.fromEntries(err?.response?.headers.entries()) : {};
-            response = await err?.response?.json();
-        }
-        catch {
-            headers = {};
-            response = {};
-        }
-        const error = new HttpServiceError({
-            data: response,
-            status: err?.response?.status ?? 500,
-            headers,
-            success: false,
-            original: err,
-            message: 'Request failed'
-        });
-        return this.errorHandler ? this.errorHandler(error) : error;
-    }
-}

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';