@parsrun/service 0.1.0

package/dist/events/index.d.ts

@@ -0,0 +1,285 @@
+import { m as TraceContext, P as ParsEvent, C as CompactEvent, b as ServiceDefinition, t as EventTransport, e as EventHandlerOptions, j as EventHandler, U as Unsubscribe } from '../types-n4LLSPQU.js';
+import { Logger } from '@parsrun/core';
+export { A as AddEntryOptions, d as DeadLetterEntry, D as DeadLetterQueue, e as DeadLetterQueueOptions, E as EventHandlerRegistry, a as EventHandlerRegistryOptions, H as HandlerRegistration, b as createDeadLetterQueue, c as createEventHandlerRegistry } from '../handler-CmiDUWZv.js';
+
+/**
+ * @parsrun/service - Event Format
+ * CloudEvents and compact event format utilities
+ */
+
+interface CreateEventOptions<T = unknown> {
+    /** Event type (e.g., "subscription.created") */
+    type: string;
+    /** Source service */
+    source: string;
+    /** Event data */
+    data: T;
+    /** Optional event ID (auto-generated if not provided) */
+    id?: string;
+    /** Optional subject */
+    subject?: string;
+    /** Tenant ID */
+    tenantId?: string;
+    /** Request ID for correlation */
+    requestId?: string;
+    /** Trace context */
+    traceContext?: TraceContext;
+    /** Delivery guarantee */
+    delivery?: "at-most-once" | "at-least-once";
+}
+/**
+ * Create a CloudEvents-compatible event
+ */
+declare function createEvent<T = unknown>(options: CreateEventOptions<T>): ParsEvent<T>;
+/**
+ * Convert to full CloudEvents format
+ */
+declare function toCloudEvent<T>(event: ParsEvent<T>): ParsEvent<T>;
+/**
+ * Convert to compact internal format
+ */
+declare function toCompactEvent<T>(event: ParsEvent<T>): CompactEvent<T>;
+/**
+ * Convert from compact format to CloudEvents
+ */
+declare function fromCompactEvent<T>(compact: CompactEvent<T>, source?: string): ParsEvent<T>;
+/**
+ * Format full event type with source prefix
+ *
+ * @example
+ * formatEventType('payments', 'subscription.created')
+ * // Returns: 'com.pars.payments.subscription.created'
+ */
+declare function formatEventType(source: string, type: string): string;
+/**
+ * Parse event type to extract source and type
+ *
+ * @example
+ * parseEventType('com.pars.payments.subscription.created')
+ * // Returns: { source: 'payments', type: 'subscription.created' }
+ */
+declare function parseEventType(fullType: string): {
+    source: string;
+    type: string;
+} | null;
+/**
+ * Check if event type matches a pattern
+ * Supports wildcards: * matches one segment, ** matches multiple segments
+ *
+ * @example
+ * matchEventType('subscription.created', 'subscription.*') // true
+ * matchEventType('payment.invoice.paid', 'payment.**') // true
+ * matchEventType('subscription.created', 'payment.*') // false
+ */
+declare function matchEventType(type: string, pattern: string): boolean;
+/**
+ * Validate CloudEvents structure
+ */
+declare function validateEvent(event: unknown): event is ParsEvent;
+/**
+ * Validate compact event structure
+ */
+declare function validateCompactEvent(event: unknown): event is CompactEvent;
+
+/**
+ * @parsrun/service - Event Emitter
+ * Service-level event emission
+ */
+
+interface EventEmitterOptions {
+    /** Service name (source) */
+    service: string;
+    /** Service definition (for validation) */
+    definition?: ServiceDefinition;
+    /** Event transport */
+    transport: EventTransport;
+    /** Logger */
+    logger?: Logger;
+    /** Default tenant ID */
+    defaultTenantId?: string;
+    /** Validate events against definition */
+    validateEvents?: boolean;
+}
+/**
+ * Event emitter for service events
+ */
+declare class EventEmitter {
+    private readonly service;
+    private readonly definition?;
+    private readonly transport;
+    private readonly logger;
+    private readonly defaultTenantId?;
+    private readonly validateEvents;
+    constructor(options: EventEmitterOptions);
+    /**
+     * Emit an event
+     */
+    emit<T = unknown>(type: string, data: T, options?: EmitOptions): Promise<string>;
+    /**
+     * Emit multiple events
+     */
+    emitBatch<T = unknown>(events: Array<{
+        type: string;
+        data: T;
+        options?: EmitOptions;
+    }>): Promise<string[]>;
+    /**
+     * Create a scoped emitter with preset options
+     */
+    scoped(options: Partial<EmitOptions>): ScopedEmitter;
+    /**
+     * Get service name
+     */
+    get serviceName(): string;
+}
+/**
+ * Emit options
+ */
+interface EmitOptions {
+    /** Custom event ID */
+    eventId?: string;
+    /** Event subject */
+    subject?: string;
+    /** Tenant ID */
+    tenantId?: string;
+    /** Request ID for correlation */
+    requestId?: string;
+    /** Trace context */
+    traceContext?: TraceContext;
+    /** Override delivery guarantee */
+    delivery?: "at-most-once" | "at-least-once";
+}
+/**
+ * Scoped emitter with preset options
+ */
+declare class ScopedEmitter {
+    private readonly emitter;
+    private readonly defaultOptions;
+    constructor(emitter: EventEmitter, defaultOptions: Partial<EmitOptions>);
+    emit<T = unknown>(type: string, data: T, options?: EmitOptions): Promise<string>;
+}
+/**
+ * Create an event emitter
+ */
+declare function createEventEmitter(options: EventEmitterOptions): EventEmitter;
+/**
+ * Create a typed event emitter from service definition
+ * Provides type-safe event emission
+ */
+declare function createTypedEmitter<TDef extends ServiceDefinition>(definition: TDef, options: Omit<EventEmitterOptions, "service" | "definition">): TypedEventEmitter<TDef>;
+/**
+ * Typed event emitter type
+ * Provides type-safe event emission with specific event types
+ */
+type TypedEventEmitter<TDef extends ServiceDefinition> = EventEmitter & {
+    emit<K extends keyof NonNullable<TDef["events"]>["emits"]>(type: K, data: NonNullable<TDef["events"]>["emits"][K] extends {
+        data?: infer D;
+    } ? D : unknown, options?: EmitOptions): Promise<string>;
+};
+
+/**
+ * @parsrun/service - Memory Event Transport
+ * In-memory event transport for embedded mode and testing
+ */
+
+interface MemoryEventTransportOptions {
+    /** Logger */
+    logger?: Logger;
+    /** Process events synchronously (default: false) */
+    sync?: boolean;
+    /** Default handler options */
+    defaultHandlerOptions?: EventHandlerOptions;
+}
+/**
+ * In-memory event transport
+ * Events are processed immediately without persistence
+ */
+declare class MemoryEventTransport implements EventTransport {
+    readonly name = "memory";
+    private readonly registry;
+    private readonly logger;
+    private readonly sync;
+    private readonly pendingEvents;
+    private processing;
+    constructor(options?: MemoryEventTransportOptions);
+    /**
+     * Emit an event
+     */
+    emit<T>(event: ParsEvent<T>): Promise<void>;
+    /**
+     * Subscribe to events
+     */
+    subscribe(eventType: string, handler: EventHandler, options?: EventHandlerOptions): Unsubscribe;
+    /**
+     * Process pending events asynchronously
+     */
+    private processQueue;
+    /**
+     * Wait for all pending events to be processed
+     */
+    flush(): Promise<void>;
+    /**
+     * Get pending event count
+     */
+    get pendingCount(): number;
+    /**
+     * Get registered patterns
+     */
+    getPatterns(): string[];
+    /**
+     * Clear all subscriptions
+     */
+    clear(): void;
+    /**
+     * Close the transport
+     */
+    close(): Promise<void>;
+}
+/**
+ * Create a memory event transport
+ */
+declare function createMemoryEventTransport(options?: MemoryEventTransportOptions): MemoryEventTransport;
+/**
+ * Global event bus for communication between embedded services
+ */
+declare class GlobalEventBus {
+    private static instance;
+    private readonly transports;
+    private readonly logger;
+    private constructor();
+    static getInstance(): GlobalEventBus;
+    /**
+     * Register a service's event transport
+     */
+    register(serviceName: string, transport: MemoryEventTransport): void;
+    /**
+     * Unregister a service
+     */
+    unregister(serviceName: string): boolean;
+    /**
+     * Broadcast an event to all services (except source)
+     */
+    broadcast(event: ParsEvent, excludeSource?: string): Promise<void>;
+    /**
+     * Send an event to a specific service
+     */
+    send(serviceName: string, event: ParsEvent): Promise<void>;
+    /**
+     * Get all registered service names
+     */
+    getServices(): string[];
+    /**
+     * Clear all registrations
+     */
+    clear(): void;
+    /**
+     * Reset singleton (for testing)
+     */
+    static reset(): void;
+}
+/**
+ * Get the global event bus
+ */
+declare function getGlobalEventBus(): GlobalEventBus;
+
+export { type EmitOptions, EventEmitter, type EventEmitterOptions, GlobalEventBus, MemoryEventTransport, type MemoryEventTransportOptions, ScopedEmitter, type TypedEventEmitter, createEvent, createEventEmitter, createMemoryEventTransport, createTypedEmitter, formatEventType, fromCompactEvent, getGlobalEventBus, matchEventType, parseEventType, toCloudEvent, toCompactEvent, validateCompactEvent, validateEvent };