n8n-nodes-semble/dist/core/EventSystem.d.ts

n8n community node for Semble practice management system - automate bookings, patients, and product/service catalog management

/**
 * @fileoverview EventSystem.ts
 * @description Type-safe event system for decoupled component communication. Provides event emitter/listener pattern with async event handling.
 * @author Mike Hatcher
 * @website https://progenious.com
 * @namespace N8nNodesSemble.Core.EventSystem
 * @since 2.0.0
 */
/**
 * Base event interface
 */
export interface BaseEvent {
    type: string;
    timestamp: number;
    source: string;
    id: string;
}
/**
 * Event listener function type
 */
export type EventListener<T extends BaseEvent = BaseEvent> = (event: T) => Promise<void> | void;
/**
 * Event listener registration
 */
export interface EventRegistration<T extends BaseEvent = BaseEvent> {
    id: string;
    type: string;
    listener: EventListener<T>;
    once: boolean;
    priority: number;
    source?: string;
}
/**
 * Event system interface
 */
export interface IEventSystem {
    emit<T extends BaseEvent>(event: T): Promise<void>;
    on<T extends BaseEvent>(type: string, listener: EventListener<T>, options?: EventListenerOptions): string;
    off(type: string, listenerId: string): boolean;
    once<T extends BaseEvent>(type: string, listener: EventListener<T>, options?: EventListenerOptions): string;
    clear(): void;
    getListeners(type: string): EventRegistration[];
}
/**
 * Event listener options
 */
export interface EventListenerOptions {
    priority?: number;
    source?: string;
}
/**
 * Predefined Semble event types
 */
export interface SembleEvents {
    'service.registered': ServiceRegisteredEvent;
    'service.resolved': ServiceResolvedEvent;
    'cache.hit': CacheHitEvent;
    'cache.miss': CacheMissEvent;
    'cache.invalidated': CacheInvalidatedEvent;
    'api.request': ApiRequestEvent;
    'api.response': ApiResponseEvent;
    'api.error': ApiErrorEvent;
    'field.discovered': FieldDiscoveredEvent;
    'field.validated': FieldValidatedEvent;
    'permission.checked': PermissionCheckedEvent;
    'schema.registered': SchemaRegisteredEvent;
    'schema.updated': SchemaUpdatedEvent;
    'node.executed': NodeExecutedEvent;
    'trigger.polled': TriggerPolledEvent;
}
/**
 * Service events
 */
export interface ServiceRegisteredEvent extends BaseEvent {
    type: 'service.registered';
    serviceName: string;
    lifetime: string;
}
export interface ServiceResolvedEvent extends BaseEvent {
    type: 'service.resolved';
    serviceName: string;
    scope?: string;
}
/**
 * Cache events
 */
export interface CacheHitEvent extends BaseEvent {
    type: 'cache.hit';
    key: string;
    ttl: number;
}
export interface CacheMissEvent extends BaseEvent {
    type: 'cache.miss';
    key: string;
}
export interface CacheInvalidatedEvent extends BaseEvent {
    type: 'cache.invalidated';
    key: string;
    reason: string;
}
/**
 * API events
 */
export interface ApiRequestEvent extends BaseEvent {
    type: 'api.request';
    endpoint: string;
    method: string;
    query?: string;
}
export interface ApiResponseEvent extends BaseEvent {
    type: 'api.response';
    endpoint: string;
    statusCode: number;
    duration: number;
}
export interface ApiErrorEvent extends BaseEvent {
    type: 'api.error';
    endpoint: string;
    error: string;
    statusCode?: number;
}
/**
 * Field and validation events
 */
export interface FieldDiscoveredEvent extends BaseEvent {
    type: 'field.discovered';
    resourceType: string;
    fieldCount: number;
}
export interface FieldValidatedEvent extends BaseEvent {
    type: 'field.validated';
    fieldName: string;
    isValid: boolean;
    errors?: string[];
}
export interface PermissionCheckedEvent extends BaseEvent {
    type: 'permission.checked';
    resourceType: string;
    operation: string;
    hasPermission: boolean;
}
/**
 * Schema events
 */
export interface SchemaRegisteredEvent extends BaseEvent {
    type: 'schema.registered';
    schemaName: string;
    version: string;
}
export interface SchemaUpdatedEvent extends BaseEvent {
    type: 'schema.updated';
    schemaName: string;
    oldVersion: string;
    newVersion: string;
}
/**
 * Node execution events
 */
export interface NodeExecutedEvent extends BaseEvent {
    type: 'node.executed';
    nodeType: string;
    operation: string;
    duration: number;
    success: boolean;
}
export interface TriggerPolledEvent extends BaseEvent {
    type: 'trigger.polled';
    resourceType: string;
    itemsFound: number;
    duration: number;
}
/**
 * Event system implementation
 */
export declare class EventSystem implements IEventSystem {
    private listeners;
    private eventHistory;
    private maxHistorySize;
    /**
     * Emit an event to all registered listeners
     */
    emit<T extends BaseEvent>(event: T): Promise<void>;
    /**
     * Register an event listener
     */
    on<T extends BaseEvent>(type: string, listener: EventListener<T>, options?: EventListenerOptions): string;
    /**
     * Register a one-time event listener
     */
    once<T extends BaseEvent>(type: string, listener: EventListener<T>, options?: EventListenerOptions): string;
    /**
     * Remove an event listener
     */
    off(type: string, listenerId: string): boolean;
    /**
     * Remove all listeners for an event type
     */
    removeAllListeners(type: string): void;
    /**
     * Get all listeners for an event type
     */
    getListeners(type: string): EventRegistration[];
    /**
     * Get all registered event types
     */
    getEventTypes(): string[];
    /**
     * Clear all listeners and history
     */
    clear(): void;
    /**
     * Get event history
     */
    getHistory(type?: string, limit?: number): BaseEvent[];
    /**
     * Get listener count for an event type
     */
    getListenerCount(type: string): number;
    /**
     * Wait for a specific event
     */
    waitFor<T extends BaseEvent>(type: string, timeout?: number, filter?: (event: T) => boolean): Promise<T>;
    /**
     * Add listener to registry
     */
    private addListener;
    /**
     * Remove listener from registry
     */
    private removeListener;
    /**
     * Generate unique listener ID
     */
    private generateListenerId;
    /**
     * Add event to history
     */
    private addToHistory;
    /**
     * Create typed event helper
     */
    createEvent<K extends keyof SembleEvents>(type: K, data: Omit<SembleEvents[K], keyof BaseEvent>, source?: string): SembleEvents[K];
}
/**
 * Default event system instance
 */
export declare const eventSystem: EventSystem;
/**
 * Event decorators for automatic event emission
 */
export declare function EmitEvent(eventType: string, source?: string): (target: any, propertyName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
/**
 * Utility functions for common event patterns
 */
export declare class EventSystemUtils {
    /**
     * Set up logging for all events
     */
    static setupEventLogging(eventSystem: EventSystem, logger?: Console): void;
    /**
     * Set up performance monitoring
     */
    static setupPerformanceMonitoring(eventSystem: EventSystem): void;
}