@spfn/core 0.1.0-alpha.88 → 0.2.0-beta.10

package/dist/event/index.d.ts

@@ -0,0 +1,41 @@
+import { TSchema, Static } from '@sinclair/typebox';
+import { a as EventDef } from '../router-Di7ENoah.js';
+export { e as EventHandler, E as EventRouterDef, I as InferEventNames, f as InferEventPayload, c as InferEventPayloads, b as InferRouterEventPayload, J as JobQueueSender, P as PubSubCache, d as defineEventRouter } from '../router-Di7ENoah.js';
+
+/**
+ * Event System
+ *
+ * Decoupled pub/sub event system with optional cache integration for multi-instance support
+ *
+ * @example
+ * ```typescript
+ * // Define event
+ * const userCreated = defineEvent('user.created', Type.Object({
+ *     userId: Type.String(),
+ * }));
+ *
+ * // Subscribe (in-memory)
+ * userCreated.subscribe((payload) => {
+ *     console.log('User created:', payload.userId);
+ * });
+ *
+ * // Emit
+ * await userCreated.emit({ userId: '123' });
+ *
+ * // With cache for multi-instance
+ * const event = defineEvent('user.created', schema);
+ * await event.useCache(cache);  // Must await before emitting
+ * await event.emit({ userId: '123' });  // Broadcast to all instances
+ * ```
+ */
+
+/**
+ * Define an event without payload
+ */
+declare function defineEvent(name: string): EventDef<void>;
+/**
+ * Define an event with typed payload
+ */
+declare function defineEvent<T extends TSchema>(name: string, schema: T): EventDef<Static<T>>;
+
+export { EventDef, defineEvent };

package/dist/event/index.js

@@ -0,0 +1,131 @@
+import { logger } from '@spfn/core/logger';
+
+// src/event/event.ts
+var eventLogger = logger.child("@spfn/core:event");
+function logHandlerError(eventName, error) {
+  eventLogger.error(`Event handler error: ${eventName}`, {
+    error: error instanceof Error ? error.message : String(error)
+  });
+}
+function logJobQueueError(queueName, error) {
+  eventLogger.error(`Failed to send event to job queue: ${queueName}`, {
+    error: error instanceof Error ? error.message : String(error)
+  });
+}
+function createHandlerManager(name) {
+  const handlers = /* @__PURE__ */ new Set();
+  return {
+    add: (handler) => {
+      handlers.add(handler);
+      eventLogger.debug(`Subscribed to event: ${name}`, { handlerCount: handlers.size });
+      return () => {
+        handlers.delete(handler);
+        eventLogger.debug(`Unsubscribed from event: ${name}`, { handlerCount: handlers.size });
+      };
+    },
+    clear: () => {
+      handlers.clear();
+      eventLogger.debug(`Unsubscribed all from event: ${name}`);
+    },
+    trigger: async (payload) => {
+      const results = await Promise.allSettled(
+        [...handlers].map((handler) => handler(payload))
+      );
+      for (const result of results) {
+        if (result.status === "rejected") {
+          logHandlerError(name, result.reason);
+        }
+      }
+    }
+  };
+}
+function createJobQueueManager(name) {
+  const jobQueues = /* @__PURE__ */ new Map();
+  return {
+    register: (queueName, sender) => {
+      jobQueues.set(queueName, sender);
+      eventLogger.debug(`Registered job queue for event: ${name}`, { queueName });
+    },
+    send: async (payload) => {
+      if (jobQueues.size === 0) {
+        return;
+      }
+      const entries = [...jobQueues.entries()];
+      const results = await Promise.allSettled(
+        entries.map(([queueName, sender]) => sender(queueName, payload))
+      );
+      for (const [i, result] of results.entries()) {
+        if (result.status === "rejected") {
+          logJobQueueError(entries[i][0], result.reason);
+        }
+      }
+    },
+    get size() {
+      return jobQueues.size;
+    }
+  };
+}
+function createEventImpl(name, schema) {
+  const handlerManager = createHandlerManager(name);
+  const jobQueueManager = createJobQueueManager(name);
+  let cache;
+  let cacheSubscribed = false;
+  const emit = async (payload) => {
+    eventLogger.debug(`Emitting event: ${name}`, {
+      payload,
+      hasCache: !!cache,
+      jobQueueCount: jobQueueManager.size
+    });
+    if (cache) {
+      await cache.publish(name, payload);
+    } else {
+      await handlerManager.trigger(payload);
+    }
+    await jobQueueManager.send(payload);
+    eventLogger.debug(`Event emitted: ${name}`);
+  };
+  const useCache = async (newCache) => {
+    if (cacheSubscribed) {
+      eventLogger.warn(`Cache already configured for event: ${name}`);
+      return self;
+    }
+    cache = newCache;
+    cacheSubscribed = true;
+    await newCache.subscribe(name, async (message) => {
+      eventLogger.debug(`Received event from cache: ${name}`);
+      await handlerManager.trigger(message);
+    });
+    eventLogger.debug(`Cache subscription ready for event: ${name}`);
+    return self;
+  };
+  const self = {
+    name,
+    schema,
+    subscribe: handlerManager.add,
+    unsubscribeAll: handlerManager.clear,
+    emit,
+    useCache,
+    _registerJobQueue: jobQueueManager.register,
+    _payload: void 0
+  };
+  return self;
+}
+function defineEvent(name, schema) {
+  if (schema) {
+    return createEventImpl(name, schema);
+  }
+  return createEventImpl(name);
+}
+
+// src/event/router.ts
+function defineEventRouter(events) {
+  return {
+    events,
+    eventNames: Object.keys(events),
+    _types: {}
+  };
+}
+
+export { defineEvent, defineEventRouter };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/event/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/event/event.ts","../../src/event/router.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Event System\n *\n * Decoupled pub/sub event system with optional cache integration for multi-instance support\n *\n * @example\n * ```typescript\n * // Define event\n * const userCreated = defineEvent('user.created', Type.Object({\n *     userId: Type.String(),\n * }));\n *\n * // Subscribe (in-memory)\n * userCreated.subscribe((payload) => {\n *     console.log('User created:', payload.userId);\n * });\n *\n * // Emit\n * await userCreated.emit({ userId: '123' });\n *\n * // With cache for multi-instance\n * const event = defineEvent('user.created', schema);\n * await event.useCache(cache);  // Must await before emitting\n * await event.emit({ userId: '123' });  // Broadcast to all instances\n * ```\n */\n\nimport type { TSchema, Static } from '@sinclair/typebox';\nimport { logger } from '@spfn/core/logger';\nimport type { EventDef, EventHandler, JobQueueSender, PubSubCache } from './types';\n\nconst eventLogger = logger.child('@spfn/core:event');\n\n/**\n * Log handler error with consistent format\n */\nfunction logHandlerError(eventName: string, error: unknown): void\n{\n    eventLogger.error(`Event handler error: ${eventName}`, {\n        error: error instanceof Error ? error.message : String(error),\n    });\n}\n\n/**\n * Log job queue error with consistent format\n */\nfunction logJobQueueError(queueName: string, error: unknown): void\n{\n    eventLogger.error(`Failed to send event to job queue: ${queueName}`, {\n        error: error instanceof Error ? error.message : String(error),\n    });\n}\n\n/**\n * Create handler subscription manager\n */\nfunction createHandlerManager<TPayload>(name: string)\n{\n    const handlers: Set<EventHandler<TPayload>> = new Set();\n\n    return {\n        add: (handler: EventHandler<TPayload>): (() => void) =>\n        {\n            handlers.add(handler);\n            eventLogger.debug(`Subscribed to event: ${name}`, { handlerCount: handlers.size });\n\n            return () =>\n            {\n                handlers.delete(handler);\n                eventLogger.debug(`Unsubscribed from event: ${name}`, { handlerCount: handlers.size });\n            };\n        },\n\n        clear: (): void =>\n        {\n            handlers.clear();\n            eventLogger.debug(`Unsubscribed all from event: ${name}`);\n        },\n\n        trigger: async (payload: TPayload): Promise<void> =>\n        {\n            const results = await Promise.allSettled(\n                [...handlers].map((handler) => handler(payload))\n            );\n\n            for (const result of results)\n            {\n                if (result.status === 'rejected')\n                {\n                    logHandlerError(name, result.reason);\n                }\n            }\n        },\n    };\n}\n\n/**\n * Create job queue manager\n */\nfunction createJobQueueManager(name: string)\n{\n    const jobQueues: Map<string, JobQueueSender> = new Map();\n\n    return {\n        register: (queueName: string, sender: JobQueueSender): void =>\n        {\n            jobQueues.set(queueName, sender);\n            eventLogger.debug(`Registered job queue for event: ${name}`, { queueName });\n        },\n\n        send: async (payload: unknown): Promise<void> =>\n        {\n            if (jobQueues.size === 0)\n            {\n                return;\n            }\n\n            const entries = [...jobQueues.entries()];\n            const results = await Promise.allSettled(\n                entries.map(([queueName, sender]) => sender(queueName, payload))\n            );\n\n            for (const [i, result] of results.entries())\n            {\n                if (result.status === 'rejected')\n                {\n                    logJobQueueError(entries[i][0], result.reason);\n                }\n            }\n        },\n\n        get size(): number\n        {\n            return jobQueues.size;\n        },\n    };\n}\n\n/**\n * Internal: Create event implementation\n */\nfunction createEventImpl<TPayload>(\n    name: string,\n    schema?: TSchema\n): EventDef<TPayload>\n{\n    const handlerManager = createHandlerManager<TPayload>(name);\n    const jobQueueManager = createJobQueueManager(name);\n    let cache: PubSubCache | undefined;\n    let cacheSubscribed = false;\n\n    const emit = async (payload?: TPayload): Promise<void> =>\n    {\n        eventLogger.debug(`Emitting event: ${name}`, {\n            payload,\n            hasCache: !!cache,\n            jobQueueCount: jobQueueManager.size,\n        });\n\n        if (cache)\n        {\n            await cache.publish(name, payload);\n        }\n        else\n        {\n            await handlerManager.trigger(payload as TPayload);\n        }\n\n        await jobQueueManager.send(payload);\n        eventLogger.debug(`Event emitted: ${name}`);\n    };\n\n    const useCache = async (newCache: PubSubCache): Promise<EventDef<TPayload>> =>\n    {\n        if (cacheSubscribed)\n        {\n            eventLogger.warn(`Cache already configured for event: ${name}`);\n            return self;\n        }\n\n        cache = newCache;\n        cacheSubscribed = true;\n\n        await newCache.subscribe(name, async (message: unknown) =>\n        {\n            eventLogger.debug(`Received event from cache: ${name}`);\n            await handlerManager.trigger(message as TPayload);\n        });\n\n        eventLogger.debug(`Cache subscription ready for event: ${name}`);\n        return self;\n    };\n\n    const self: EventDef<TPayload> = {\n        name,\n        schema,\n        subscribe: handlerManager.add,\n        unsubscribeAll: handlerManager.clear,\n        emit: emit as EventDef<TPayload>['emit'],\n        useCache,\n        _registerJobQueue: jobQueueManager.register,\n        _payload: undefined as unknown as TPayload,\n    };\n\n    return self;\n}\n\n/**\n * Define an event without payload\n */\nexport function defineEvent(name: string): EventDef<void>;\n\n/**\n * Define an event with typed payload\n */\nexport function defineEvent<T extends TSchema>(\n    name: string,\n    schema: T\n): EventDef<Static<T>>;\n\n/**\n * Define an event for decoupled pub/sub\n *\n * @example\n * ```typescript\n * // Define event with payload\n * export const userCreated = defineEvent('user.created', Type.Object({\n *     userId: Type.String(),\n * }));\n *\n * // Subscribe to event (in-memory)\n * const unsubscribe = userCreated.subscribe((payload) => {\n *     console.log('User created:', payload.userId);\n * });\n *\n * // Emit event\n * await userCreated.emit({ userId: '123' });\n *\n * // Unsubscribe when done\n * unsubscribe();\n *\n * // Multi-instance with cache\n * await userCreated.useCache(cache);\n * await userCreated.emit({ userId: '123' });  // Broadcast to all instances\n * ```\n */\nexport function defineEvent<T extends TSchema>(\n    name: string,\n    schema?: T\n): EventDef<Static<T>> | EventDef\n{\n    if (schema)\n    {\n        return createEventImpl<Static<T>>(name, schema);\n    }\n\n    return createEventImpl<void>(name);\n}\n","/**\n * Event Router\n *\n * Type-safe event router for SSE subscription\n *\n * @example\n * ```typescript\n * import { defineEvent, defineEventRouter } from '@spfn/core/event';\n * import { Type } from '@sinclair/typebox';\n *\n * const userCreated = defineEvent('user.created', Type.Object({\n *     userId: Type.String(),\n * }));\n *\n * const orderPlaced = defineEvent('order.placed', Type.Object({\n *     orderId: Type.String(),\n *     amount: Type.Number(),\n * }));\n *\n * export const eventRouter = defineEventRouter({\n *     userCreated,\n *     orderPlaced,\n * });\n *\n * export type EventRouter = typeof eventRouter;\n * ```\n */\n\nimport type { EventDef } from './types';\n\n/**\n * Event Router Definition\n */\nexport interface EventRouterDef<TEvents extends Record<string, EventDef<any>>>\n{\n    /**\n     * Event definitions\n     */\n    readonly events: TEvents;\n\n    /**\n     * Event names as array\n     */\n    readonly eventNames: (keyof TEvents)[];\n\n    /**\n     * Type inference helper - payload types by event name\n     */\n    readonly _types: {\n        [K in keyof TEvents]: TEvents[K]['_payload'];\n    };\n}\n\n/**\n * Infer event names from EventRouter\n */\nexport type InferEventNames<T> = T extends EventRouterDef<infer E>\n    ? keyof E & string\n    : never;\n\n/**\n * Infer payload type for specific event\n */\nexport type InferEventPayload<\n    T extends EventRouterDef<any>,\n    K extends InferEventNames<T>\n> = T['_types'][K];\n\n/**\n * Infer all event payloads map\n */\nexport type InferEventPayloads<T extends EventRouterDef<any>> = T['_types'];\n\n/**\n * Define an event router for SSE subscription\n *\n * @example\n * ```typescript\n * export const eventRouter = defineEventRouter({\n *     userCreated,\n *     orderPlaced,\n * });\n *\n * // Type inference\n * type Names = InferEventNames<typeof eventRouter>;\n * // 'userCreated' | 'orderPlaced'\n *\n * type Payload = InferEventPayload<typeof eventRouter, 'userCreated'>;\n * // { userId: string }\n * ```\n */\nexport function defineEventRouter<\n    TEvents extends Record<string, EventDef<any>>\n>(events: TEvents): EventRouterDef<TEvents>\n{\n    return {\n        events,\n        eventNames: Object.keys(events) as (keyof TEvents)[],\n        _types: {} as EventRouterDef<TEvents>['_types'],\n    };\n}"]}

package/dist/event/sse/client.d.ts

@@ -0,0 +1,82 @@
+import { E as EventRouterDef, I as InferEventNames } from '../../router-Di7ENoah.js';
+import { e as SSESubscribeOptions, g as SSEUnsubscribe, f as SSEConnectionState, b as SSEClientConfig } from '../../types-B-e_f2dQ.js';
+import '@sinclair/typebox';
+
+/**
+ * SSE Client
+ *
+ * Type-safe EventSource wrapper for event subscription
+ *
+ * @example
+ * ```typescript
+ * import { createSSEClient } from '@spfn/core/event/sse/client';
+ * import type { EventRouter } from '@/server/events';
+ *
+ * // Uses defaults: NEXT_PUBLIC_SPFN_API_URL + /events/stream
+ * const client = createSSEClient<EventRouter>();
+ *
+ * // Or with custom host/pathname
+ * const client = createSSEClient<EventRouter>({
+ *     host: 'https://api.example.com',
+ *     pathname: '/sse',
+ * });
+ *
+ * const unsubscribe = client.subscribe({
+ *     events: ['userCreated', 'orderPlaced'],
+ *     handlers: {
+ *         userCreated: (payload) => console.log('User:', payload.userId),
+ *         orderPlaced: (payload) => console.log('Order:', payload.orderId),
+ *     },
+ * });
+ *
+ * // Later: cleanup
+ * unsubscribe();
+ * ```
+ */
+
+/**
+ * SSE Client instance
+ */
+interface SSEClient<TRouter extends EventRouterDef<any>> {
+    /**
+     * Subscribe to events
+     */
+    subscribe(options: SSESubscribeOptions<TRouter>): SSEUnsubscribe;
+    /**
+     * Get current connection state
+     */
+    getState(): SSEConnectionState;
+    /**
+     * Close all connections
+     */
+    close(): void;
+}
+declare function createSSEClient<TRouter extends EventRouterDef<any>>(config?: SSEClientConfig): SSEClient<TRouter>;
+/**
+ * Simple subscribe function for one-off subscriptions
+ *
+ * @example
+ * ```typescript
+ * import { subscribeToEvents } from '@spfn/core/event/sse/client';
+ * import type { EventRouter } from '@/server/events';
+ *
+ * // Using defaults
+ * const unsubscribe = subscribeToEvents<EventRouter>(
+ *     ['userCreated', 'orderPlaced'],
+ *     {
+ *         userCreated: (payload) => console.log('User:', payload),
+ *         orderPlaced: (payload) => console.log('Order:', payload),
+ *     }
+ * );
+ *
+ * // With custom host
+ * const unsubscribe = subscribeToEvents<EventRouter>(
+ *     ['userCreated'],
+ *     { userCreated: (payload) => console.log('User:', payload) },
+ *     { host: 'https://api.example.com' }
+ * );
+ * ```
+ */
+declare function subscribeToEvents<TRouter extends EventRouterDef<any>>(events: InferEventNames<TRouter>[], handlers: SSESubscribeOptions<TRouter>['handlers'], options?: SSEClientConfig): SSEUnsubscribe;
+
+export { type SSEClient, createSSEClient, subscribeToEvents };

package/dist/event/sse/client.js

@@ -0,0 +1,115 @@
+// src/event/sse/client.ts
+var SSE_DEFAULTS = {
+  host: typeof process !== "undefined" ? process.env.NEXT_PUBLIC_SPFN_API_URL || "http://localhost:8790" : "http://localhost:8790",
+  pathname: "/events/stream"
+};
+function createSSEClient(config = {}) {
+  const {
+    url,
+    host = SSE_DEFAULTS.host,
+    pathname = SSE_DEFAULTS.pathname,
+    reconnect = true,
+    reconnectDelay = 3e3,
+    maxReconnectAttempts = 0,
+    withCredentials = false
+  } = config;
+  const baseUrl = url || `${host}${pathname}`;
+  let eventSource = null;
+  let state = "closed";
+  let reconnectAttempts = 0;
+  let reconnectTimer = null;
+  function subscribe(options) {
+    const { events, handlers, onOpen, onError, onReconnect } = options;
+    const eventNames = events;
+    const streamUrl = `${baseUrl}?events=${eventNames.join(",")}`;
+    function connect() {
+      state = "connecting";
+      eventSource = new EventSource(streamUrl, {
+        withCredentials
+      });
+      eventSource.onopen = () => {
+        state = "open";
+        reconnectAttempts = 0;
+        onOpen?.();
+      };
+      eventSource.onerror = (error) => {
+        state = "error";
+        onError?.(error);
+        if (reconnect && eventSource?.readyState === EventSource.CLOSED) {
+          if (maxReconnectAttempts === 0 || reconnectAttempts < maxReconnectAttempts) {
+            reconnectAttempts++;
+            onReconnect?.(reconnectAttempts);
+            reconnectTimer = setTimeout(() => {
+              connect();
+            }, reconnectDelay);
+          }
+        }
+      };
+      eventSource.addEventListener("connected", (e) => {
+        try {
+          const data = JSON.parse(e.data);
+          console.debug("[SSE] Connected:", data);
+        } catch {
+        }
+      });
+      eventSource.addEventListener("ping", () => {
+      });
+      for (const eventName of eventNames) {
+        const handler = handlers[eventName];
+        if (!handler) {
+          continue;
+        }
+        eventSource.addEventListener(eventName, (e) => {
+          try {
+            const message = JSON.parse(e.data);
+            handler(message.data);
+          } catch (err) {
+            console.error(`[SSE] Failed to parse event "${eventName}":`, err);
+          }
+        });
+      }
+    }
+    connect();
+    return () => {
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      if (eventSource) {
+        eventSource.close();
+        eventSource = null;
+      }
+      state = "closed";
+    };
+  }
+  function getState() {
+    return state;
+  }
+  function close() {
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    if (eventSource) {
+      eventSource.close();
+      eventSource = null;
+    }
+    state = "closed";
+  }
+  return {
+    subscribe,
+    getState,
+    close
+  };
+}
+function subscribeToEvents(events, handlers, options) {
+  const client = createSSEClient(options);
+  return client.subscribe({
+    events,
+    handlers
+  });
+}
+
+export { createSSEClient, subscribeToEvents };
+//# sourceMappingURL=client.js.map
+//# sourceMappingURL=client.js.map

package/dist/event/sse/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/event/sse/client.ts"],"names":[],"mappings":"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","file":"client.js","sourcesContent":["/**\n * SSE Client\n *\n * Type-safe EventSource wrapper for event subscription\n *\n * @example\n * ```typescript\n * import { createSSEClient } from '@spfn/core/event/sse/client';\n * import type { EventRouter } from '@/server/events';\n *\n * // Uses defaults: NEXT_PUBLIC_SPFN_API_URL + /events/stream\n * const client = createSSEClient<EventRouter>();\n *\n * // Or with custom host/pathname\n * const client = createSSEClient<EventRouter>({\n *     host: 'https://api.example.com',\n *     pathname: '/sse',\n * });\n *\n * const unsubscribe = client.subscribe({\n *     events: ['userCreated', 'orderPlaced'],\n *     handlers: {\n *         userCreated: (payload) => console.log('User:', payload.userId),\n *         orderPlaced: (payload) => console.log('Order:', payload.orderId),\n *     },\n * });\n *\n * // Later: cleanup\n * unsubscribe();\n * ```\n */\n\nimport type { EventRouterDef, InferEventNames } from '../router';\nimport type {\n    SSEClientConfig,\n    SSESubscribeOptions,\n    SSEUnsubscribe,\n    SSEConnectionState,\n    SSEMessage,\n} from './types';\n\n/**\n * SSE Client instance\n */\nexport interface SSEClient<TRouter extends EventRouterDef<any>>\n{\n    /**\n     * Subscribe to events\n     */\n    subscribe(options: SSESubscribeOptions<TRouter>): SSEUnsubscribe;\n\n    /**\n     * Get current connection state\n     */\n    getState(): SSEConnectionState;\n\n    /**\n     * Close all connections\n     */\n    close(): void;\n}\n\n/**\n * Create type-safe SSE client\n *\n * @example\n * ```typescript\n * // Uses defaults (NEXT_PUBLIC_SPFN_API_URL + /events/stream)\n * const client = createSSEClient<EventRouter>();\n *\n * // Or with custom configuration\n * const client = createSSEClient<EventRouter>({\n *     host: 'https://api.example.com',\n *     pathname: '/sse',\n *     reconnect: true,\n *     reconnectDelay: 3000,\n * });\n *\n * // Subscribe to events\n * const unsubscribe = client.subscribe({\n *     events: ['userCreated', 'orderPlaced'],\n *     handlers: {\n *         userCreated: (payload) => {\n *             console.log('New user:', payload.userId);\n *         },\n *         orderPlaced: (payload) => {\n *             console.log('New order:', payload.orderId);\n *         },\n *     },\n *     onOpen: () => console.log('Connected'),\n *     onError: (err) => console.error('Error:', err),\n *     onReconnect: (attempt) => console.log('Reconnecting...', attempt),\n * });\n *\n * // Cleanup\n * unsubscribe();\n * ```\n */\n/**\n * Default SSE configuration\n */\nconst SSE_DEFAULTS = {\n    host: typeof process !== 'undefined'\n        ? (process.env.NEXT_PUBLIC_SPFN_API_URL || 'http://localhost:8790')\n        : 'http://localhost:8790',\n    pathname: '/events/stream',\n} as const;\n\nexport function createSSEClient<TRouter extends EventRouterDef<any>>(\n    config: SSEClientConfig = {}\n): SSEClient<TRouter>\n{\n    const {\n        url,\n        host = SSE_DEFAULTS.host,\n        pathname = SSE_DEFAULTS.pathname,\n        reconnect = true,\n        reconnectDelay = 3000,\n        maxReconnectAttempts = 0,\n        withCredentials = false,\n    } = config;\n\n    // Build base URL: url takes precedence, otherwise host + pathname\n    const baseUrl = url || `${host}${pathname}`;\n\n    let eventSource: EventSource | null = null;\n    let state: SSEConnectionState = 'closed';\n    let reconnectAttempts = 0;\n    let reconnectTimer: ReturnType<typeof setTimeout> | null = null;\n\n    function subscribe(options: SSESubscribeOptions<TRouter>): SSEUnsubscribe\n    {\n        const { events, handlers, onOpen, onError, onReconnect } = options;\n\n        // Build URL with events query parameter\n        const eventNames = events as string[];\n        const streamUrl = `${baseUrl}?events=${eventNames.join(',')}`;\n\n        function connect()\n        {\n            state = 'connecting';\n\n            eventSource = new EventSource(streamUrl, {\n                withCredentials,\n            });\n\n            // Handle open\n            eventSource.onopen = () =>\n            {\n                state = 'open';\n                reconnectAttempts = 0;\n                onOpen?.();\n            };\n\n            // Handle errors\n            eventSource.onerror = (error) =>\n            {\n                state = 'error';\n                onError?.(error);\n\n                // Auto reconnect\n                if (reconnect && eventSource?.readyState === EventSource.CLOSED)\n                {\n                    if (maxReconnectAttempts === 0 || reconnectAttempts < maxReconnectAttempts)\n                    {\n                        reconnectAttempts++;\n                        onReconnect?.(reconnectAttempts);\n\n                        reconnectTimer = setTimeout(() =>\n                        {\n                            connect();\n                        }, reconnectDelay);\n                    }\n                }\n            };\n\n            // Handle connected event (server sends this on connection)\n            eventSource.addEventListener('connected', (e: MessageEvent) =>\n            {\n                try\n                {\n                    const data = JSON.parse(e.data);\n                    console.debug('[SSE] Connected:', data);\n                }\n                catch\n                {\n                    // Ignore parse errors\n                }\n            });\n\n            // Handle ping (keep-alive)\n            eventSource.addEventListener('ping', () =>\n            {\n                // Ping received, connection is alive\n            });\n\n            // Register handlers for each event\n            for (const eventName of eventNames)\n            {\n                // Type assertion needed here - runtime type safety is ensured by EventRouter\n                const handler = (handlers as Record<string, ((payload: unknown) => void) | undefined>)[eventName];\n\n                if (!handler)\n                {\n                    continue;\n                }\n\n                eventSource.addEventListener(eventName, (e: MessageEvent) =>\n                {\n                    try\n                    {\n                        const message: SSEMessage = JSON.parse(e.data);\n                        handler(message.data);\n                    }\n                    catch (err)\n                    {\n                        console.error(`[SSE] Failed to parse event \"${eventName}\":`, err);\n                    }\n                });\n            }\n        }\n\n        // Start connection\n        connect();\n\n        // Return unsubscribe function\n        return () =>\n        {\n            if (reconnectTimer)\n            {\n                clearTimeout(reconnectTimer);\n                reconnectTimer = null;\n            }\n\n            if (eventSource)\n            {\n                eventSource.close();\n                eventSource = null;\n            }\n\n            state = 'closed';\n        };\n    }\n\n    function getState(): SSEConnectionState\n    {\n        return state;\n    }\n\n    function close()\n    {\n        if (reconnectTimer)\n        {\n            clearTimeout(reconnectTimer);\n            reconnectTimer = null;\n        }\n\n        if (eventSource)\n        {\n            eventSource.close();\n            eventSource = null;\n        }\n\n        state = 'closed';\n    }\n\n    return {\n        subscribe,\n        getState,\n        close,\n    };\n}\n\n/**\n * Simple subscribe function for one-off subscriptions\n *\n * @example\n * ```typescript\n * import { subscribeToEvents } from '@spfn/core/event/sse/client';\n * import type { EventRouter } from '@/server/events';\n *\n * // Using defaults\n * const unsubscribe = subscribeToEvents<EventRouter>(\n *     ['userCreated', 'orderPlaced'],\n *     {\n *         userCreated: (payload) => console.log('User:', payload),\n *         orderPlaced: (payload) => console.log('Order:', payload),\n *     }\n * );\n *\n * // With custom host\n * const unsubscribe = subscribeToEvents<EventRouter>(\n *     ['userCreated'],\n *     { userCreated: (payload) => console.log('User:', payload) },\n *     { host: 'https://api.example.com' }\n * );\n * ```\n */\nexport function subscribeToEvents<TRouter extends EventRouterDef<any>>(\n    events: InferEventNames<TRouter>[],\n    handlers: SSESubscribeOptions<TRouter>['handlers'],\n    options?: SSEClientConfig\n): SSEUnsubscribe\n{\n    const client = createSSEClient<TRouter>(options);\n\n    return client.subscribe({\n        events,\n        handlers,\n    });\n}\n"]}

package/dist/event/sse/index.d.ts

@@ -0,0 +1,40 @@
+import { Context } from 'hono';
+import { E as EventRouterDef } from '../../router-Di7ENoah.js';
+import { S as SSEHandlerConfig } from '../../types-B-e_f2dQ.js';
+export { b as SSEClientConfig, f as SSEConnectionState, c as SSEEventHandler, d as SSEEventHandlers, a as SSEMessage, e as SSESubscribeOptions, g as SSEUnsubscribe } from '../../types-B-e_f2dQ.js';
+import '@sinclair/typebox';
+
+/**
+ * SSE Handler for Hono
+ *
+ * Creates SSE stream endpoint for event subscription
+ *
+ * @example
+ * ```typescript
+ * import { Hono } from 'hono';
+ * import { createSSEHandler } from '@spfn/core/event/sse';
+ * import { eventRouter } from './events';
+ *
+ * const app = new Hono();
+ *
+ * // GET /events/stream?events=userCreated,orderPlaced
+ * app.get('/events/stream', createSSEHandler(eventRouter));
+ * ```
+ */
+
+/**
+ * Create SSE handler for Hono
+ *
+ * Query parameters:
+ * - events: Comma-separated list of event names to subscribe
+ *
+ * @example
+ * ```typescript
+ * app.get('/events/stream', createSSEHandler(eventRouter, {
+ *     pingInterval: 30000,
+ * }));
+ * ```
+ */
+declare function createSSEHandler<TRouter extends EventRouterDef<any>>(router: TRouter, config?: SSEHandlerConfig): (c: Context) => Promise<Response>;
+
+export { SSEHandlerConfig, createSSEHandler };

package/dist/event/sse/index.js

@@ -0,0 +1,92 @@
+import { streamSSE } from 'hono/streaming';
+import { logger } from '@spfn/core/logger';
+
+// src/event/sse/handler.ts
+var sseLogger = logger.child("@spfn/core:sse");
+function createSSEHandler(router, config = {}) {
+  const {
+    pingInterval = 3e4
+    // headers: customHeaders = {},  // Reserved for future use
+  } = config;
+  return async (c) => {
+    const eventsParam = c.req.query("events");
+    if (!eventsParam) {
+      return c.json({ error: "Missing events parameter" }, 400);
+    }
+    const requestedEvents = eventsParam.split(",").map((e) => e.trim());
+    const validEventNames = router.eventNames;
+    const invalidEvents = requestedEvents.filter((e) => !validEventNames.includes(e));
+    if (invalidEvents.length > 0) {
+      return c.json({
+        error: "Invalid event names",
+        invalidEvents,
+        validEvents: validEventNames
+      }, 400);
+    }
+    sseLogger.debug("SSE connection requested", {
+      events: requestedEvents,
+      clientIp: c.req.header("x-forwarded-for") || c.req.header("x-real-ip")
+    });
+    return streamSSE(c, async (stream) => {
+      const unsubscribes = [];
+      let messageId = 0;
+      for (const eventName of requestedEvents) {
+        const eventDef = router.events[eventName];
+        if (!eventDef) {
+          continue;
+        }
+        const unsubscribe = eventDef.subscribe((payload) => {
+          messageId++;
+          const message = {
+            event: eventName,
+            data: payload
+          };
+          sseLogger.debug("SSE sending event", {
+            event: eventName,
+            messageId
+          });
+          void stream.writeSSE({
+            id: String(messageId),
+            event: eventName,
+            data: JSON.stringify(message)
+          });
+        });
+        unsubscribes.push(unsubscribe);
+      }
+      sseLogger.info("SSE connection established", {
+        events: requestedEvents,
+        subscriptionCount: unsubscribes.length
+      });
+      await stream.writeSSE({
+        event: "connected",
+        data: JSON.stringify({
+          subscribedEvents: requestedEvents,
+          timestamp: Date.now()
+        })
+      });
+      const pingTimer = setInterval(() => {
+        void stream.writeSSE({
+          event: "ping",
+          data: JSON.stringify({ timestamp: Date.now() })
+        });
+      }, pingInterval);
+      const abortSignal = c.req.raw.signal;
+      while (!abortSignal.aborted) {
+        await stream.sleep(pingInterval);
+      }
+      clearInterval(pingTimer);
+      unsubscribes.forEach((fn) => fn());
+      sseLogger.info("SSE connection closed", {
+        events: requestedEvents
+      });
+    }, async (err) => {
+      sseLogger.error("SSE stream error", {
+        error: err.message
+      });
+    });
+  };
+}
+
+export { createSSEHandler };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/event/sse/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/event/sse/handler.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * SSE Handler for Hono\n *\n * Creates SSE stream endpoint for event subscription\n *\n * @example\n * ```typescript\n * import { Hono } from 'hono';\n * import { createSSEHandler } from '@spfn/core/event/sse';\n * import { eventRouter } from './events';\n *\n * const app = new Hono();\n *\n * // GET /events/stream?events=userCreated,orderPlaced\n * app.get('/events/stream', createSSEHandler(eventRouter));\n * ```\n */\n\nimport type { Context } from 'hono';\nimport { streamSSE } from 'hono/streaming';\nimport { logger } from '@spfn/core/logger';\nimport type { EventRouterDef, InferEventNames } from '../router';\nimport type { SSEHandlerConfig } from './types';\n\nconst sseLogger = logger.child('@spfn/core:sse');\n\n/**\n * Create SSE handler for Hono\n *\n * Query parameters:\n * - events: Comma-separated list of event names to subscribe\n *\n * @example\n * ```typescript\n * app.get('/events/stream', createSSEHandler(eventRouter, {\n *     pingInterval: 30000,\n * }));\n * ```\n */\nexport function createSSEHandler<TRouter extends EventRouterDef<any>>(\n    router: TRouter,\n    config: SSEHandlerConfig = {}\n)\n{\n    const {\n        pingInterval = 30000,\n        // headers: customHeaders = {},  // Reserved for future use\n    } = config;\n\n    return async (c: Context) =>\n    {\n        // Parse events from query parameter\n        const eventsParam = c.req.query('events');\n\n        if (!eventsParam)\n        {\n            return c.json({ error: 'Missing events parameter' }, 400);\n        }\n\n        const requestedEvents = eventsParam.split(',').map(e => e.trim());\n\n        // Validate event names\n        const validEventNames = router.eventNames as string[];\n        const invalidEvents = requestedEvents.filter(e => !validEventNames.includes(e));\n\n        if (invalidEvents.length > 0)\n        {\n            return c.json({\n                error: 'Invalid event names',\n                invalidEvents,\n                validEvents: validEventNames,\n            }, 400);\n        }\n\n        sseLogger.debug('SSE connection requested', {\n            events: requestedEvents,\n            clientIp: c.req.header('x-forwarded-for') || c.req.header('x-real-ip'),\n        });\n\n        // Start SSE stream\n        return streamSSE(c, async (stream) =>\n        {\n            const unsubscribes: (() => void)[] = [];\n            let messageId = 0;\n\n            // Subscribe to each requested event\n            for (const eventName of requestedEvents as InferEventNames<TRouter>[])\n            {\n                const eventDef = router.events[eventName];\n\n                if (!eventDef)\n                {\n                    continue;\n                }\n\n                const unsubscribe = eventDef.subscribe((payload: unknown) =>\n                {\n                    messageId++;\n\n                    const message = {\n                        event: eventName,\n                        data: payload,\n                    };\n\n                    sseLogger.debug('SSE sending event', {\n                        event: eventName,\n                        messageId,\n                    });\n\n                    // Fire-and-forget in sync callback\n                    void stream.writeSSE({\n                        id: String(messageId),\n                        event: eventName as string,\n                        data: JSON.stringify(message),\n                    });\n                });\n\n                unsubscribes.push(unsubscribe);\n            }\n\n            sseLogger.info('SSE connection established', {\n                events: requestedEvents,\n                subscriptionCount: unsubscribes.length,\n            });\n\n            // Send initial connection message\n            await stream.writeSSE({\n                event: 'connected',\n                data: JSON.stringify({\n                    subscribedEvents: requestedEvents,\n                    timestamp: Date.now(),\n                }),\n            });\n\n            // Keep-alive ping\n            const pingTimer = setInterval(() =>\n            {\n                // Fire-and-forget in sync callback\n                void stream.writeSSE({\n                    event: 'ping',\n                    data: JSON.stringify({ timestamp: Date.now() }),\n                });\n            }, pingInterval);\n\n            // Wait for client disconnect using abort signal\n            const abortSignal = c.req.raw.signal;\n\n            while (!abortSignal.aborted)\n            {\n                await stream.sleep(pingInterval);\n            }\n\n            // Cleanup\n            clearInterval(pingTimer);\n            unsubscribes.forEach(fn => fn());\n\n            sseLogger.info('SSE connection closed', {\n                events: requestedEvents,\n            });\n        }, async (err: Error) =>\n        {\n            sseLogger.error('SSE stream error', {\n                error: err.message,\n            });\n        });\n    };\n}\n\n"]}