@azure-net/kit 0.4.0 → 0.5.1

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

@@ -0,0 +1,91 @@
+export declare enum EventBusLayers {
+    DOMAIN = "domain",
+    APPLICATION = "application",
+    PRESENTATION = "presentation"
+}
+export interface IEvent<T = unknown> {
+    aggregateId: string;
+    eventType: string;
+    eventVersion: number;
+    occurredAt: Date;
+    metadata: IEventMetadata;
+    eventLayer: EventBusLayers;
+    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 layer;
+    constructor(options?: {
+        layer?: EventBusLayers;
+        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>(layer: EventBusLayers, opts: {
+    history?: boolean;
+    asyncProcessing?: boolean;
+    historySize?: number;
+    middlewares?: (<T = unknown>(event: IEvent<T>, next: () => Promise<void>) => Promise<void>)[];
+    debug?: boolean;
+}) => {
+    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/eventBus/EventBus.js

@@ -0,0 +1,233 @@
+export var EventBusLayers;
+(function (EventBusLayers) {
+    EventBusLayers["DOMAIN"] = "domain";
+    EventBusLayers["APPLICATION"] = "application";
+    EventBusLayers["PRESENTATION"] = "presentation";
+})(EventBusLayers || (EventBusLayers = {}));
+export class EventBus {
+    options;
+    handlers = new Map();
+    wildcardHandlers = new Set();
+    middleware = [];
+    eventQueue = [];
+    isProcessing = false;
+    eventHistory = [];
+    priorities = new Map();
+    debug = false;
+    maxHistorySize = 1000;
+    layer;
+    constructor(options = { layer: EventBusLayers.PRESENTATION, debug: false }) {
+        this.options = options;
+        this.layer = options.layer ?? EventBusLayers.PRESENTATION;
+        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
+            },
+            eventLayer: this.layer,
+            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(),
+            eventLayer: this.layer,
+            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.eventLayer.toUpperCase()}Event] ${event.eventType} at ${event.occurredAt.toISOString()}`);
+    console.log(`[${event.eventLayer.toUpperCase()}Event] data:`, event);
+    const start = performance.now();
+    await next();
+    const duration = performance.now() - start;
+    console.log(`[${event.eventLayer.toUpperCase()}Event] ${event.eventType} processed in ${duration.toFixed(2)}ms`);
+};
+export const createEventBus = (layer, opts) => {
+    const { history = true, asyncProcessing = true, historySize = 1000, middlewares = [], debug = false } = opts;
+    const eventBus = new EventBus({
+        layer,
+        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/eventBus/index.d.ts

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

package/dist/core/eventBus/index.js

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

package/dist/svelte/ActiveForm/ActiveForm.svelte.d.ts

@@ -0,0 +1,24 @@
+import { type RequestErrors, BaseRequest } from '../../core/index.js';
+export interface FormConfig<T> {
+    onSubmit: (data: T) => Promise<void> | void;
+    initialData?: T;
+    validation?: {
+        schema?: new (data: Partial<T>) => BaseRequest<T, T>;
+        validateOnChange?: boolean;
+        validateOnBlur?: boolean;
+    };
+}
+export interface ActiveForm<T> {
+    data: Partial<T>;
+    errors: RequestErrors<T>;
+    touched: Partial<Record<keyof T, boolean>>;
+    pending: boolean;
+    dirty: boolean;
+    valid: boolean;
+    submit: () => Promise<void>;
+    validate: (field?: keyof T) => void;
+    reset: () => void;
+    setField: <K extends keyof T>(field: K, value: T[K]) => void;
+    setErrors: (errors: RequestErrors<T>) => void;
+    touchField: (field: keyof T) => void;
+}

package/dist/svelte/ActiveForm/ActiveForm.svelte.js

@@ -0,0 +1,163 @@
+import { BaseRequest } from '../../core/index.js';
+// export function createActiveForm<T extends object>(config: FormConfig<T>): ActiveForm<T> {
+// 	const initial: Partial<T> = config.initialData ?? {};
+// 	let data = $state<Partial<T>>(structuredClone(initial));
+// 	let errors = $state<RequestErrors<T>>({});
+// 	let touched = $state<Partial<Record<keyof T, boolean>>>({});
+// 	let pending = $state(false);
+//
+// 	const dirty = $derived(JSON.stringify(data) !== JSON.stringify(config.initialData));
+//
+// 	const valid = $derived(() => {
+// 		if (Object.keys(errors).length > 0) return false;
+//
+// 		if (config.validation?.schema) {
+// 			try {
+// 				const request = new config.validation.schema(data);
+// 				request.validated();
+// 				return true;
+// 			} catch {
+// 				return false;
+// 			}
+// 		}
+//
+// 		return true;
+// 	});
+//
+// 	function validateForm(): boolean {
+// 		if (!config.validation?.schema) return true;
+//
+// 		try {
+// 			const request = new config.validation.schema(data);
+// 			request.validated();
+// 			errors = {};
+// 			return true;
+// 		} catch (error) {
+// 			if (error instanceof config.validation.schema) {
+// 				errors = error.getErrors();
+// 				return false;
+// 			}
+// 			throw error;
+// 		}
+// 	}
+//
+// 	function validateField(field: keyof T): void {
+// 		if (!config.validation?.schema) return;
+//
+// 		try {
+// 			const request = new config.validation.schema(data);
+// 			request.validated();
+//
+// 			const newErrors = { ...errors };
+// 			delete newErrors[field];
+// 			errors = newErrors;
+// 		} catch (error) {
+// 			if (error instanceof config.validation.schema) {
+// 				const allErrors = error.getErrors();
+// 				if (field in allErrors) {
+// 					errors = { ...errors, [field]: allErrors[field] };
+// 				} else {
+// 					const newErrors = { ...errors };
+// 					delete newErrors[field];
+// 					errors = newErrors;
+// 				}
+// 			}
+// 		}
+// 	}
+//
+// 	if (config.validation?.validateOnChange) {
+// 		$effect(() => {
+// 			JSON.stringify(data);
+//
+// 			const touchedFields = Object.keys(touched) as (keyof T)[];
+// 			if (touchedFields.length > 0) {
+// 				touchedFields.forEach((field) => {
+// 					if (touched[field]) {
+// 						validateField(field);
+// 					}
+// 				});
+// 			}
+// 		});
+// 	}
+//
+// 	async function submit(): Promise<void> {
+// 		pending = true;
+//
+// 		try {
+// 			if (!validateForm()) {
+// 				return;
+// 			}
+//
+// 			errors = {};
+//
+// 			await config.onSubmit(data);
+// 		} catch (error) {
+// 			throw error;
+// 		} finally {
+// 			pending = false;
+// 		}
+// 	}
+//
+// 	function setField<K extends keyof T>(field: K, value: T[K]): void {
+// 		data = { ...data, [field]: value };
+// 		touched = { ...touched, [field]: true };
+//
+// 		if (config.validation?.validateOnBlur && touched[field]) {
+// 			validateField(field);
+// 		}
+// 	}
+//
+// 	function touchField(field: keyof T): void {
+// 		touched = { ...touched, [field]: true };
+//
+// 		if (config.validation?.validateOnBlur) {
+// 			validateField(field);
+// 		}
+// 	}
+//
+// 	function reset(): void {
+// 		data = structuredClone(config.initialData);
+// 		errors = {};
+// 		touched = {};
+// 	}
+//
+// 	return {
+// 		get data() {
+// 			return data;
+// 		},
+// 		get errors() {
+// 			return errors;
+// 		},
+// 		get touched() {
+// 			return touched;
+// 		},
+// 		get pending() {
+// 			return pending;
+// 		},
+// 		get dirty() {
+// 			return dirty;
+// 		},
+// 		get valid() {
+// 			return valid();
+// 		},
+//
+// 		submit,
+// 		validate: (field?: keyof T) => {
+// 			if (field) {
+// 				validateField(field);
+// 			} else {
+// 				validateForm();
+// 			}
+// 		},
+// 		reset,
+// 		setField,
+// 		setErrors: (newErrors: RequestErrors<T>) => {
+// 			errors = newErrors;
+// 		},
+// 		touchField
+// 	};
+// }
+//
+// function structuredClone<T>(obj: T): T {
+// 	return JSON.parse(JSON.stringify(obj));
+// }

package/dist/svelte/ActiveForm/index.d.ts

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

package/dist/svelte/ActiveForm/index.js

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

package/dist/svelte/AsyncSignal/AsyncSignal.svelte.d.ts

@@ -15,4 +15,4 @@ export interface AsyncSignalSvelte<TData, TError = Error> {
     reset: () => void;
     abort: () => void;
 }
-export declare function createAsyncSignal<TData, TError = Error>(handler: (signal?: AbortSignal) => Promise<TData>, options?: AsyncSignalOptions<TData>): AsyncSignalSvelte<TData, TError>;
+export declare const createAsyncSignal: <TData, TError = Error>(handler: (signal?: AbortSignal) => Promise<TData>, options?: AsyncSignalOptions<TData>) => AsyncSignalSvelte<TData, TError>;

package/dist/svelte/AsyncSignal/AsyncSignal.svelte.js

@@ -1,10 +1,10 @@
 import { untrack } from 'svelte';
 import { browser } from '$app/environment';
-export function createAsyncSignal(handler, options = {}) {
+export const createAsyncSignal = (handler, options = {}) => {
     const { server = false, immediate = true, watch = [], initialData = null } = options;
-    let data = $state.raw(initialData);
-    let error = $state.raw(null);
-    let status = $state.raw('idle');
+    let data = $state(initialData);
+    let error = $state(null);
+    let status = $state('idle');
     const pending = $derived(status === 'pending');
     let abortController = null;
     async function execute() {
@@ -84,4 +84,4 @@ export function createAsyncSignal(handler, options = {}) {
             }
         }
     };
-}
+};

package/dist/svelte/index.d.ts

@@ -1 +1,2 @@
 export * from './AsyncSignal/index.js';
+export * from './ActiveForm/index.js';

package/dist/svelte/index.js

@@ -1 +1,2 @@
 export * from './AsyncSignal/index.js';
+export * from './ActiveForm/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "files": [
     "dist",
     "!dist/**/*.test.*",
@@ -128,7 +128,6 @@
     "test:unit": "vitest",
     "test": "npm run test:unit -- --run && npm run test:e2e",
     "test:e2e": "playwright test",
-    "precommit": "pnpm lint && pnpm check",
     "semantic-release": "env-cmd semantic-release",
     "commit": "pnpm format && git add . && git-cz && git push",
     "release": "pnpm commit && pnpm semantic-release"