@uploadista/event-emitter-durable-object 0.0.8 → 0.0.9

package/dist/index.cjs

@@ -1 +1 @@
-var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,a)=>(a=n==null?{}:e(i(n)),o(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));let c=require(`@uploadista/core/errors`);c=s(c);let l=require(`@uploadista/core/types`);l=s(l);let u=require(`effect`);u=s(u);function d({durableObject:e}){function t(t){let n=e.idFromName(t);return e.get(n)}return{emit:(e,n)=>{let r=t(e);return u.Effect.tryPromise({try:async()=>{await r.emit(n)},catch:e=>c.UploadistaError.fromCode(`UNKNOWN_ERROR`,{cause:e})})},subscribe:(e,n)=>u.Effect.tryPromise({try:async()=>{await t(e).subscribe(n)},catch:e=>c.UploadistaError.fromCode(`UNKNOWN_ERROR`,{cause:e})}),unsubscribe:e=>u.Effect.tryPromise({try:async()=>{await t(e).unsubscribe()},catch:e=>c.UploadistaError.fromCode(`UNKNOWN_ERROR`,{cause:e})})}}const f=e=>u.Layer.succeed(l.UploadEventEmitter,d(e));exports.uploadEventEmitterDurableObjectStore=f;
+let e=require(`@uploadista/core/errors`),t=require(`@uploadista/core/types`),n=require(`effect`),r=require(`cloudflare:workers`);function i({durableObject:t}){function r(e){let n=t.idFromName(e);return t.get(n)}return{emit:(t,i)=>n.Effect.tryPromise({try:async()=>{console.log(`[DO EventEmitter] Emitting to eventKey: ${t}`,i.substring(0,200)),await r(t).emit(i),console.log(`[DO EventEmitter] Successfully emitted to eventKey: ${t}`)},catch:n=>(console.error(`[DO EventEmitter] Failed to emit to eventKey: ${t}`,n),e.UploadistaError.fromCode(`UNKNOWN_ERROR`,{cause:n}))}),subscribe:(t,i)=>n.Effect.tryPromise({try:async()=>{await r(t).subscribe(i)},catch:t=>e.UploadistaError.fromCode(`UNKNOWN_ERROR`,{cause:t})}),unsubscribe:t=>n.Effect.tryPromise({try:async()=>{await r(t).unsubscribe()},catch:t=>e.UploadistaError.fromCode(`UNKNOWN_ERROR`,{cause:t})})}}const a=e=>n.Layer.succeed(t.BaseEventEmitterService,i(e));var o=class extends r.DurableObject{async fetch(e){console.log(`[DO fetch] WebSocket connection request: ${e.url}`);let t=new WebSocketPair,[n,r]=Object.values(t);return this.ctx.acceptWebSocket(r),console.log(`[DO fetch] WebSocket accepted, total connections: ${this.ctx.getWebSockets().length}`),new Response(null,{status:101,webSocket:n})}async emit(e){let t=this.ctx.getWebSockets();console.log(`[DO emit] Broadcasting message to ${t.length} WebSocket(s):`,e.substring(0,200));for(let n of t)try{n.send(e)}catch(e){console.error(`Failed to send message to WebSocket:`,e)}}async subscribe(e){}async unsubscribe(){let e=this.ctx.getWebSockets();for(let t of e)t.close(1e3,`Unsubscribed`)}async webSocketMessage(e,t){console.log(`WebSocket message received: ${t}`)}async webSocketClose(e,t,n,r){if(e.readyState===WebSocket.OPEN){let n=t===1006||t<1e3||t>4999?1e3:t;e.close(n,`Durable Object closing WebSocket`)}}async webSocketError(e,t){console.error(`WebSocket error:`,t),e.readyState===WebSocket.OPEN&&e.close(1011,`WebSocket error occurred`)}};exports.UploadistaDurableObjectImpl=o,exports.durableObjectBaseEventEmitter=i,exports.durableObjectEventEmitter=a;

package/dist/index.d.cts

@@ -1,20 +1,136 @@
-import { UploadEvent, UploadEventEmitter, WebSocketConnection } from "@uploadista/core/types";
+import { BaseEventEmitter, WebSocketConnection } from "@uploadista/core/types";
 import { Layer } from "effect";
 import { DurableObjectNamespace, Rpc } from "@cloudflare/workers-types";
+import { DurableObject } from "cloudflare:workers";
 
 //#region src/event-emitter-durable-object.d.ts
+
+/**
+ * RPC interface for event emitter Durable Objects.
+ *
+ * Defines the methods that can be called on a Durable Object instance via RPC.
+ */
 type EventEmitterDurableObjectBranded<T> = Rpc.DurableObjectBranded & {
-  emit: (event: T) => Promise<void>;
+  /**
+   * Emit a message to all connected WebSocket clients.
+   * @param message - The message to broadcast (typically a JSON string)
+   */
+  emit: (message: T) => Promise<void>;
+  /**
+   * Subscribe a WebSocket connection to this DO instance.
+   * Note: The actual WebSocket connection is established via fetch()
+   * @param connection - WebSocket connection details
+   */
   subscribe: (connection: WebSocketConnection) => Promise<void>;
+  /**
+   * Unsubscribe from events by closing all WebSocket connections.
+   */
   unsubscribe: () => Promise<void>;
 };
+/**
+ * Durable Object namespace type for event emitters.
+ *
+ * @template T - Type of messages (typically string for JSON messages)
+ */
 type EventEmitterDurableObject<T> = DurableObjectNamespace<EventEmitterDurableObjectBranded<T>>;
 //#endregion
 //#region src/do-event-emitter.d.ts
-type UploadEventEmitterDurableObjectStoreConfig = {
-  durableObject: EventEmitterDurableObject<UploadEvent>;
+type DurableObjectEventEmitterConfig = {
+  durableObject: EventEmitterDurableObject<string>;
 };
-declare const uploadEventEmitterDurableObjectStore: (config: UploadEventEmitterDurableObjectStoreConfig) => Layer.Layer<UploadEventEmitter, never, never>;
+/**
+ * Creates a BaseEventEmitter implementation using Cloudflare Durable Objects.
+ *
+ * This implementation:
+ * - Routes events to Durable Object instances by eventKey
+ * - Each eventKey gets its own DO instance
+ * - WebSocket connections are managed by the DO
+ * - No external broadcaster needed - DO is single source of truth
+ *
+ * @param config - Configuration with Durable Object namespace
+ * @returns BaseEventEmitter implementation
+ */
+declare function durableObjectBaseEventEmitter({
+  durableObject
+}: DurableObjectEventEmitterConfig): BaseEventEmitter;
+/**
+ * Creates a Layer for BaseEventEmitterService using Durable Objects.
+ *
+ * Use this when creating an Uploadista server with Durable Objects:
+ *
+ * @example
+ * ```typescript
+ * const server = await createUploadistaServer({
+ *   eventEmitter: durableObjectEventEmitter({
+ *     durableObject: env.UPLOADISTA_DO,
+ *   }),
+ *   // ... other config
+ * });
+ * ```
+ */
+declare const durableObjectEventEmitter: (config: DurableObjectEventEmitterConfig) => Layer.Layer<unknown, never, never>;
+//#endregion
+//#region src/durable-object-impl.d.ts
+/**
+ * Base Durable Object implementation for Uploadista event emission.
+ *
+ * This class provides:
+ * - Hibernatable WebSocket connections
+ * - Event broadcasting to all connected clients
+ * - Automatic connection management
+ * - RPC methods for emit/subscribe/unsubscribe
+ *
+ * Extend this class in your Worker to create event emitter Durable Objects:
+ *
+ * @example
+ * ```typescript
+ * export class UploadistaDurableObject extends UploadistaDurableObjectImpl {}
+ * ```
+ */
+declare class UploadistaDurableObjectImpl extends DurableObject {
+  /**
+   * Handles WebSocket upgrade requests.
+   * Creates a hibernatable WebSocket connection.
+   */
+  fetch(request: Request): Promise<Response>;
+  /**
+   * RPC method: Emit a message to all connected WebSocket clients.
+   *
+   * @param message - The message to broadcast (typically a JSON string)
+   */
+  emit(message: string): Promise<void>;
+  /**
+   * RPC method: Subscribe a WebSocket connection.
+   *
+   * Note: This is called via RPC, the actual WebSocket connection
+   * is established via the fetch() handler.
+   */
+  subscribe(_connection: WebSocketConnection): Promise<void>;
+  /**
+   * RPC method: Unsubscribe from events.
+   *
+   * Closes all WebSocket connections for this DO instance.
+   */
+  unsubscribe(): Promise<void>;
+  /**
+   * Hibernation API: Handle incoming WebSocket messages.
+   *
+   * Called automatically when a message arrives on a hibernated WebSocket.
+   */
+  webSocketMessage(_ws: WebSocket, message: ArrayBuffer | string): Promise<void>;
+  /**
+   * Hibernation API: Handle WebSocket close events.
+   *
+   * Called automatically when a WebSocket connection closes.
+   */
+  webSocketClose(ws: WebSocket, code: number, _reason: string, _wasClean: boolean): Promise<void>;
+  /**
+   * Hibernation API: Handle WebSocket errors.
+   *
+   * Called automatically when a WebSocket error occurs.
+   */
+  webSocketError(ws: WebSocket, error: unknown): Promise<void>;
+}
 //#endregion
-export { type EventEmitterDurableObject, uploadEventEmitterDurableObjectStore };
+export { type DurableObjectEventEmitterConfig, type EventEmitterDurableObject, UploadistaDurableObjectImpl, durableObjectBaseEventEmitter, durableObjectEventEmitter };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/event-emitter-durable-object.ts","../src/do-event-emitter.ts"],"sourcesContent":[],"mappings":";;;;;KAGY,sCAAsC,GAAA,CAAI;gBACtC,MAAM;0BACI,wBAAwB;EAFtC,WAAA,EAAA,GAAA,GAGS,OAHT,CAAA,IAAA,CAAA;CAAsC;AAClC,KAMJ,yBANI,CAAA,CAAA,CAAA,GAM2B,sBAN3B,CAOd,gCAPc,CAOmB,CAPnB,CAAA,CAAA;;;KCQJ,0CAAA;iBACK,0BAA0B;ADV3C,CAAA;AACgB,cC8DH,oCD9DG,EAAA,CAAA,MAAA,EC+DN,0CD/DM,EAAA,GC+DoC,KAAA,CAAA,KD/DpC,CC+DoC,kBD/DpC,EAAA,KAAA,EAAA,KAAA,CAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/event-emitter-durable-object.ts","../src/do-event-emitter.ts","../src/durable-object-impl.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AAQA;AAAsD,KAA1C,gCAA0C,CAAA,CAAA,CAAA,GAAJ,GAAA,CAAI,oBAAA,GAAA;EAKpC;;;;EAYG,IAAA,EAAA,CAAA,OAAA,EAZH,CAYG,EAAA,GAZG,OAYH,CAAA,IAAA,CAAA;EAAO;AAQ5B;;;;EAAiE,SAAA,EAAA,CAAA,UAAA,EAbvC,mBAauC,EAAA,GAbf,OAae,CAAA,IAAA,CAAA;;;;ECxBrD,WAAA,EAAA,GAAA,GDgBS,OChBT,CAAA,IAAA,CAAA;AAgBZ,CAAA;;;;;AAkEA;KD1DY,+BAA+B,uBACzC,iCAAiC;;;KCzBvB,+BAAA;iBACK;;ADFjB;;;;;;;;AAyBA;;;;AAAiE,iBCRjD,6BAAA,CDQiD;EAAA;AAAA,CAAA,ECN9D,+BDM8D,CAAA,ECN5B,gBDM4B;;;;ACxBjE;AAgBA;;;;;AAkEA;;;;ACnEA;;AAKyC,cD8D5B,yBC9D4B,EAAA,CAAA,MAAA,ED+D/B,+BC/D+B,EAAA,GD+DA,KAAA,CAAA,KC/DA,CAAA,OAAA,EAAA,KAAA,EAAA,KAAA,CAAA;;;;;;;AFrBzC;;;;;;;;AAyBA;;;;AAAiE,cETpD,2BAAA,SAAoC,aAAA,CFSgB;;;;ACxBjE;EAgBgB,KAAA,CAAA,OAAA,ECIO,ODJP,CAAA,ECIiB,ODJY,CCIJ,QDJI,CAAA;EAC3C;;;;AAiEF;yBCtC+B;;;AA7B/B;;;;EA6B+B,SAAA,CAAA,WAAA,EAmBA,mBAnBA,CAAA,EAmBsB,OAnBtB,CAAA,IAAA,CAAA;EAmBA;;;;;EAuBuC,WAAA,CAAA,CAAA,EAZ/C,OAY+C,CAAA,IAAA,CAAA;EAW9D;;;;;EAlFsD,gBAAA,CAAA,GAAA,EAuEhC,SAvEgC,EAAA,OAAA,EAuEZ,WAvEY,GAAA,MAAA,CAAA,EAuEQ,OAvER,CAAA,IAAA,CAAA;;;;;;qBAkFtD,+DAGc;;;;;;qBAgBK,4BAAyB"}

package/dist/index.d.mts

@@ -0,0 +1,136 @@
+import { BaseEventEmitter, WebSocketConnection } from "@uploadista/core/types";
+import { Layer } from "effect";
+import { DurableObject } from "cloudflare:workers";
+import { DurableObjectNamespace, Rpc } from "@cloudflare/workers-types";
+
+//#region src/event-emitter-durable-object.d.ts
+
+/**
+ * RPC interface for event emitter Durable Objects.
+ *
+ * Defines the methods that can be called on a Durable Object instance via RPC.
+ */
+type EventEmitterDurableObjectBranded<T> = Rpc.DurableObjectBranded & {
+  /**
+   * Emit a message to all connected WebSocket clients.
+   * @param message - The message to broadcast (typically a JSON string)
+   */
+  emit: (message: T) => Promise<void>;
+  /**
+   * Subscribe a WebSocket connection to this DO instance.
+   * Note: The actual WebSocket connection is established via fetch()
+   * @param connection - WebSocket connection details
+   */
+  subscribe: (connection: WebSocketConnection) => Promise<void>;
+  /**
+   * Unsubscribe from events by closing all WebSocket connections.
+   */
+  unsubscribe: () => Promise<void>;
+};
+/**
+ * Durable Object namespace type for event emitters.
+ *
+ * @template T - Type of messages (typically string for JSON messages)
+ */
+type EventEmitterDurableObject<T> = DurableObjectNamespace<EventEmitterDurableObjectBranded<T>>;
+//#endregion
+//#region src/do-event-emitter.d.ts
+type DurableObjectEventEmitterConfig = {
+  durableObject: EventEmitterDurableObject<string>;
+};
+/**
+ * Creates a BaseEventEmitter implementation using Cloudflare Durable Objects.
+ *
+ * This implementation:
+ * - Routes events to Durable Object instances by eventKey
+ * - Each eventKey gets its own DO instance
+ * - WebSocket connections are managed by the DO
+ * - No external broadcaster needed - DO is single source of truth
+ *
+ * @param config - Configuration with Durable Object namespace
+ * @returns BaseEventEmitter implementation
+ */
+declare function durableObjectBaseEventEmitter({
+  durableObject
+}: DurableObjectEventEmitterConfig): BaseEventEmitter;
+/**
+ * Creates a Layer for BaseEventEmitterService using Durable Objects.
+ *
+ * Use this when creating an Uploadista server with Durable Objects:
+ *
+ * @example
+ * ```typescript
+ * const server = await createUploadistaServer({
+ *   eventEmitter: durableObjectEventEmitter({
+ *     durableObject: env.UPLOADISTA_DO,
+ *   }),
+ *   // ... other config
+ * });
+ * ```
+ */
+declare const durableObjectEventEmitter: (config: DurableObjectEventEmitterConfig) => Layer.Layer<unknown, never, never>;
+//#endregion
+//#region src/durable-object-impl.d.ts
+/**
+ * Base Durable Object implementation for Uploadista event emission.
+ *
+ * This class provides:
+ * - Hibernatable WebSocket connections
+ * - Event broadcasting to all connected clients
+ * - Automatic connection management
+ * - RPC methods for emit/subscribe/unsubscribe
+ *
+ * Extend this class in your Worker to create event emitter Durable Objects:
+ *
+ * @example
+ * ```typescript
+ * export class UploadistaDurableObject extends UploadistaDurableObjectImpl {}
+ * ```
+ */
+declare class UploadistaDurableObjectImpl extends DurableObject {
+  /**
+   * Handles WebSocket upgrade requests.
+   * Creates a hibernatable WebSocket connection.
+   */
+  fetch(request: Request): Promise<Response>;
+  /**
+   * RPC method: Emit a message to all connected WebSocket clients.
+   *
+   * @param message - The message to broadcast (typically a JSON string)
+   */
+  emit(message: string): Promise<void>;
+  /**
+   * RPC method: Subscribe a WebSocket connection.
+   *
+   * Note: This is called via RPC, the actual WebSocket connection
+   * is established via the fetch() handler.
+   */
+  subscribe(_connection: WebSocketConnection): Promise<void>;
+  /**
+   * RPC method: Unsubscribe from events.
+   *
+   * Closes all WebSocket connections for this DO instance.
+   */
+  unsubscribe(): Promise<void>;
+  /**
+   * Hibernation API: Handle incoming WebSocket messages.
+   *
+   * Called automatically when a message arrives on a hibernated WebSocket.
+   */
+  webSocketMessage(_ws: WebSocket, message: ArrayBuffer | string): Promise<void>;
+  /**
+   * Hibernation API: Handle WebSocket close events.
+   *
+   * Called automatically when a WebSocket connection closes.
+   */
+  webSocketClose(ws: WebSocket, code: number, _reason: string, _wasClean: boolean): Promise<void>;
+  /**
+   * Hibernation API: Handle WebSocket errors.
+   *
+   * Called automatically when a WebSocket error occurs.
+   */
+  webSocketError(ws: WebSocket, error: unknown): Promise<void>;
+}
+//#endregion
+export { type DurableObjectEventEmitterConfig, type EventEmitterDurableObject, UploadistaDurableObjectImpl, durableObjectBaseEventEmitter, durableObjectEventEmitter };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/event-emitter-durable-object.ts","../src/do-event-emitter.ts","../src/durable-object-impl.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AAQA;AAAsD,KAA1C,gCAA0C,CAAA,CAAA,CAAA,GAAJ,GAAA,CAAI,oBAAA,GAAA;EAKpC;;;;EAYG,IAAA,EAAA,CAAA,OAAA,EAZH,CAYG,EAAA,GAZG,OAYH,CAAA,IAAA,CAAA;EAAO;AAQ5B;;;;EAAiE,SAAA,EAAA,CAAA,UAAA,EAbvC,mBAauC,EAAA,GAbf,OAae,CAAA,IAAA,CAAA;;;;ECxBrD,WAAA,EAAA,GAAA,GDgBS,OChBT,CAAA,IAAA,CAAA;AAgBZ,CAAA;;;;;AAkEA;KD1DY,+BAA+B,uBACzC,iCAAiC;;;KCzBvB,+BAAA;iBACK;;ADFjB;;;;;;;;AAyBA;;;;AAAiE,iBCRjD,6BAAA,CDQiD;EAAA;AAAA,CAAA,ECN9D,+BDM8D,CAAA,ECN5B,gBDM4B;;;;ACxBjE;AAgBA;;;;;AAkEA;;;;ACnEA;;AAKyC,cD8D5B,yBC9D4B,EAAA,CAAA,MAAA,ED+D/B,+BC/D+B,EAAA,GD+DA,KAAA,CAAA,KC/DA,CAAA,OAAA,EAAA,KAAA,EAAA,KAAA,CAAA;;;;;;;AFrBzC;;;;;;;;AAyBA;;;;AAAiE,cETpD,2BAAA,SAAoC,aAAA,CFSgB;;;;ACxBjE;EAgBgB,KAAA,CAAA,OAAA,ECIO,ODJP,CAAA,ECIiB,ODJY,CCIJ,QDJI,CAAA;EAC3C;;;;AAiEF;yBCtC+B;;;AA7B/B;;;;EA6B+B,SAAA,CAAA,WAAA,EAmBA,mBAnBA,CAAA,EAmBsB,OAnBtB,CAAA,IAAA,CAAA;EAmBA;;;;;EAuBuC,WAAA,CAAA,CAAA,EAZ/C,OAY+C,CAAA,IAAA,CAAA;EAW9D;;;;;EAlFsD,gBAAA,CAAA,GAAA,EAuEhC,SAvEgC,EAAA,OAAA,EAuEZ,WAvEY,GAAA,MAAA,CAAA,EAuEQ,OAvER,CAAA,IAAA,CAAA;;;;;;qBAkFtD,+DAGc;;;;;;qBAgBK,4BAAyB"}

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import{UploadistaError as e}from"@uploadista/core/errors";import{BaseEventEmitterService as t}from"@uploadista/core/types";import{Effect as n,Layer as r}from"effect";import{DurableObject as i}from"cloudflare:workers";function a({durableObject:t}){function r(e){let n=t.idFromName(e);return t.get(n)}return{emit:(t,i)=>n.tryPromise({try:async()=>{console.log(`[DO EventEmitter] Emitting to eventKey: ${t}`,i.substring(0,200)),await r(t).emit(i),console.log(`[DO EventEmitter] Successfully emitted to eventKey: ${t}`)},catch:n=>(console.error(`[DO EventEmitter] Failed to emit to eventKey: ${t}`,n),e.fromCode(`UNKNOWN_ERROR`,{cause:n}))}),subscribe:(t,i)=>n.tryPromise({try:async()=>{await r(t).subscribe(i)},catch:t=>e.fromCode(`UNKNOWN_ERROR`,{cause:t})}),unsubscribe:t=>n.tryPromise({try:async()=>{await r(t).unsubscribe()},catch:t=>e.fromCode(`UNKNOWN_ERROR`,{cause:t})})}}const o=e=>r.succeed(t,a(e));var s=class extends i{async fetch(e){console.log(`[DO fetch] WebSocket connection request: ${e.url}`);let t=new WebSocketPair,[n,r]=Object.values(t);return this.ctx.acceptWebSocket(r),console.log(`[DO fetch] WebSocket accepted, total connections: ${this.ctx.getWebSockets().length}`),new Response(null,{status:101,webSocket:n})}async emit(e){let t=this.ctx.getWebSockets();console.log(`[DO emit] Broadcasting message to ${t.length} WebSocket(s):`,e.substring(0,200));for(let n of t)try{n.send(e)}catch(e){console.error(`Failed to send message to WebSocket:`,e)}}async subscribe(e){}async unsubscribe(){let e=this.ctx.getWebSockets();for(let t of e)t.close(1e3,`Unsubscribed`)}async webSocketMessage(e,t){console.log(`WebSocket message received: ${t}`)}async webSocketClose(e,t,n,r){if(e.readyState===WebSocket.OPEN){let n=t===1006||t<1e3||t>4999?1e3:t;e.close(n,`Durable Object closing WebSocket`)}}async webSocketError(e,t){console.error(`WebSocket error:`,t),e.readyState===WebSocket.OPEN&&e.close(1011,`WebSocket error occurred`)}};export{s as UploadistaDurableObjectImpl,a as durableObjectBaseEventEmitter,o as durableObjectEventEmitter};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/do-event-emitter.ts","../src/durable-object-impl.ts"],"sourcesContent":["import { UploadistaError } from \"@uploadista/core/errors\";\nimport type { WebSocketConnection } from \"@uploadista/core/types\";\nimport {\n  type BaseEventEmitter,\n  BaseEventEmitterService,\n} from \"@uploadista/core/types\";\nimport { Effect, Layer } from \"effect\";\nimport type { EventEmitterDurableObject } from \"./event-emitter-durable-object\";\n\nexport type DurableObjectEventEmitterConfig = {\n  durableObject: EventEmitterDurableObject<string>;\n};\n\n/**\n * Creates a BaseEventEmitter implementation using Cloudflare Durable Objects.\n *\n * This implementation:\n * - Routes events to Durable Object instances by eventKey\n * - Each eventKey gets its own DO instance\n * - WebSocket connections are managed by the DO\n * - No external broadcaster needed - DO is single source of truth\n *\n * @param config - Configuration with Durable Object namespace\n * @returns BaseEventEmitter implementation\n */\nexport function durableObjectBaseEventEmitter({\n  durableObject,\n}: DurableObjectEventEmitterConfig): BaseEventEmitter {\n  function getStub(eventKey: string) {\n    const id = durableObject.idFromName(eventKey);\n    return durableObject.get(id);\n  }\n\n  return {\n    emit: (eventKey: string, message: string) => {\n      return Effect.tryPromise({\n        try: async () => {\n          console.log(`[DO EventEmitter] Emitting to eventKey: ${eventKey}`, message.substring(0, 200));\n          const stub = getStub(eventKey);\n          // Call the emit RPC method on the Durable Object\n          await (stub as any).emit(message);\n          console.log(`[DO EventEmitter] Successfully emitted to eventKey: ${eventKey}`);\n        },\n        catch: (cause) => {\n          console.error(`[DO EventEmitter] Failed to emit to eventKey: ${eventKey}`, cause);\n          return UploadistaError.fromCode(\"UNKNOWN_ERROR\", { cause });\n        },\n      });\n    },\n    subscribe: (eventKey: string, connection: WebSocketConnection) => {\n      return Effect.tryPromise({\n        try: async () => {\n          const stub = getStub(eventKey);\n          // Call the subscribe RPC method on the Durable Object\n          await (stub as any).subscribe(connection);\n        },\n        catch: (cause) => {\n          return UploadistaError.fromCode(\"UNKNOWN_ERROR\", { cause });\n        },\n      });\n    },\n    unsubscribe: (eventKey: string) => {\n      return Effect.tryPromise({\n        try: async () => {\n          const stub = getStub(eventKey);\n          // Call the unsubscribe RPC method on the Durable Object\n          await (stub as any).unsubscribe();\n        },\n        catch: (cause) => {\n          return UploadistaError.fromCode(\"UNKNOWN_ERROR\", { cause });\n        },\n      });\n    },\n  };\n}\n\n/**\n * Creates a Layer for BaseEventEmitterService using Durable Objects.\n *\n * Use this when creating an Uploadista server with Durable Objects:\n *\n * @example\n * ```typescript\n * const server = await createUploadistaServer({\n *   eventEmitter: durableObjectEventEmitter({\n *     durableObject: env.UPLOADISTA_DO,\n *   }),\n *   // ... other config\n * });\n * ```\n */\nexport const durableObjectEventEmitter = (\n  config: DurableObjectEventEmitterConfig,\n) =>\n  Layer.succeed(\n    BaseEventEmitterService,\n    durableObjectBaseEventEmitter(config),\n  );\n","import { DurableObject } from \"cloudflare:workers\";\nimport type { WebSocketConnection } from \"@uploadista/core/types\";\n\n// WebSocketPair is available globally in Cloudflare Workers\ndeclare const WebSocketPair: {\n  new (): { 0: WebSocket; 1: WebSocket };\n};\n\n/**\n * Base Durable Object implementation for Uploadista event emission.\n *\n * This class provides:\n * - Hibernatable WebSocket connections\n * - Event broadcasting to all connected clients\n * - Automatic connection management\n * - RPC methods for emit/subscribe/unsubscribe\n *\n * Extend this class in your Worker to create event emitter Durable Objects:\n *\n * @example\n * ```typescript\n * export class UploadistaDurableObject extends UploadistaDurableObjectImpl {}\n * ```\n */\nexport class UploadistaDurableObjectImpl extends DurableObject {\n  /**\n   * Handles WebSocket upgrade requests.\n   * Creates a hibernatable WebSocket connection.\n   */\n  async fetch(request: Request): Promise<Response> {\n    console.log(`[DO fetch] WebSocket connection request: ${request.url}`);\n\n    // Creates two ends of a WebSocket connection\n    const pair = new WebSocketPair();\n    const [client, server] = Object.values(pair);\n\n    // Accept WebSocket with hibernation support\n    // This allows the DO to be evicted from memory during idle periods\n    this.ctx.acceptWebSocket(server);\n\n    console.log(`[DO fetch] WebSocket accepted, total connections: ${this.ctx.getWebSockets().length}`);\n\n    return new Response(null, {\n      status: 101,\n      webSocket: client as unknown,\n    } as ResponseInit);\n  }\n\n  /**\n   * RPC method: Emit a message to all connected WebSocket clients.\n   *\n   * @param message - The message to broadcast (typically a JSON string)\n   */\n  async emit(message: string): Promise<void> {\n    const websockets = this.ctx.getWebSockets();\n    console.log(`[DO emit] Broadcasting message to ${websockets.length} WebSocket(s):`, message.substring(0, 200));\n\n    for (const ws of websockets) {\n      try {\n        ws.send(message);\n      } catch (error) {\n        console.error(\"Failed to send message to WebSocket:\", error);\n      }\n    }\n  }\n\n  /**\n   * RPC method: Subscribe a WebSocket connection.\n   *\n   * Note: This is called via RPC, the actual WebSocket connection\n   * is established via the fetch() handler.\n   */\n  async subscribe(_connection: WebSocketConnection): Promise<void> {\n    // The connection is already established via fetch()\n    // This method exists for API compatibility\n    return;\n  }\n\n  /**\n   * RPC method: Unsubscribe from events.\n   *\n   * Closes all WebSocket connections for this DO instance.\n   */\n  async unsubscribe(): Promise<void> {\n    const websockets = this.ctx.getWebSockets();\n    for (const ws of websockets) {\n      ws.close(1000, \"Unsubscribed\");\n    }\n  }\n\n  /**\n   * Hibernation API: Handle incoming WebSocket messages.\n   *\n   * Called automatically when a message arrives on a hibernated WebSocket.\n   */\n  async webSocketMessage(_ws: WebSocket, message: ArrayBuffer | string) {\n    // Log message for debugging\n    console.log(`WebSocket message received: ${message}`);\n  }\n\n  /**\n   * Hibernation API: Handle WebSocket close events.\n   *\n   * Called automatically when a WebSocket connection closes.\n   */\n  async webSocketClose(\n    ws: WebSocket,\n    code: number,\n    _reason: string,\n    _wasClean: boolean,\n  ) {\n    // Clean up the connection\n    if (ws.readyState === WebSocket.OPEN) {\n      // Use a valid close code instead of potentially reserved ones\n      const validCloseCode =\n        code === 1006 || code < 1000 || code > 4999 ? 1000 : code;\n      ws.close(validCloseCode, \"Durable Object closing WebSocket\");\n    }\n  }\n\n  /**\n   * Hibernation API: Handle WebSocket errors.\n   *\n   * Called automatically when a WebSocket error occurs.\n   */\n  async webSocketError(ws: WebSocket, error: unknown) {\n    console.error(\"WebSocket error:\", error);\n    if (ws.readyState === WebSocket.OPEN) {\n      ws.close(1011, \"WebSocket error occurred\");\n    }\n  }\n}\n"],"mappings":"yNAyBA,SAAgB,EAA8B,CAC5C,iBACoD,CACpD,SAAS,EAAQ,EAAkB,CACjC,IAAM,EAAK,EAAc,WAAW,EAAS,CAC7C,OAAO,EAAc,IAAI,EAAG,CAG9B,MAAO,CACL,MAAO,EAAkB,IAChB,EAAO,WAAW,CACvB,IAAK,SAAY,CACf,QAAQ,IAAI,2CAA2C,IAAY,EAAQ,UAAU,EAAG,IAAI,CAAC,CAG7F,MAFa,EAAQ,EAAS,CAEV,KAAK,EAAQ,CACjC,QAAQ,IAAI,uDAAuD,IAAW,EAEhF,MAAQ,IACN,QAAQ,MAAM,iDAAiD,IAAY,EAAM,CAC1E,EAAgB,SAAS,gBAAiB,CAAE,QAAO,CAAC,EAE9D,CAAC,CAEJ,WAAY,EAAkB,IACrB,EAAO,WAAW,CACvB,IAAK,SAAY,CAGf,MAFa,EAAQ,EAAS,CAEV,UAAU,EAAW,EAE3C,MAAQ,GACC,EAAgB,SAAS,gBAAiB,CAAE,QAAO,CAAC,CAE9D,CAAC,CAEJ,YAAc,GACL,EAAO,WAAW,CACvB,IAAK,SAAY,CAGf,MAFa,EAAQ,EAAS,CAEV,aAAa,EAEnC,MAAQ,GACC,EAAgB,SAAS,gBAAiB,CAAE,QAAO,CAAC,CAE9D,CAAC,CAEL,CAkBH,MAAa,EACX,GAEA,EAAM,QACJ,EACA,EAA8B,EAAO,CACtC,CCzEH,IAAa,EAAb,cAAiD,CAAc,CAK7D,MAAM,MAAM,EAAqC,CAC/C,QAAQ,IAAI,4CAA4C,EAAQ,MAAM,CAGtE,IAAM,EAAO,IAAI,cACX,CAAC,EAAQ,GAAU,OAAO,OAAO,EAAK,CAQ5C,OAJA,KAAK,IAAI,gBAAgB,EAAO,CAEhC,QAAQ,IAAI,qDAAqD,KAAK,IAAI,eAAe,CAAC,SAAS,CAE5F,IAAI,SAAS,KAAM,CACxB,OAAQ,IACR,UAAW,EACZ,CAAiB,CAQpB,MAAM,KAAK,EAAgC,CACzC,IAAM,EAAa,KAAK,IAAI,eAAe,CAC3C,QAAQ,IAAI,qCAAqC,EAAW,OAAO,gBAAiB,EAAQ,UAAU,EAAG,IAAI,CAAC,CAE9G,IAAK,IAAM,KAAM,EACf,GAAI,CACF,EAAG,KAAK,EAAQ,OACT,EAAO,CACd,QAAQ,MAAM,uCAAwC,EAAM,EAWlE,MAAM,UAAU,EAAiD,EAWjE,MAAM,aAA6B,CACjC,IAAM,EAAa,KAAK,IAAI,eAAe,CAC3C,IAAK,IAAM,KAAM,EACf,EAAG,MAAM,IAAM,eAAe,CASlC,MAAM,iBAAiB,EAAgB,EAA+B,CAEpE,QAAQ,IAAI,+BAA+B,IAAU,CAQvD,MAAM,eACJ,EACA,EACA,EACA,EACA,CAEA,GAAI,EAAG,aAAe,UAAU,KAAM,CAEpC,IAAM,EACJ,IAAS,MAAQ,EAAO,KAAQ,EAAO,KAAO,IAAO,EACvD,EAAG,MAAM,EAAgB,mCAAmC,EAShE,MAAM,eAAe,EAAe,EAAgB,CAClD,QAAQ,MAAM,mBAAoB,EAAM,CACpC,EAAG,aAAe,UAAU,MAC9B,EAAG,MAAM,KAAM,2BAA2B"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uploadista/event-emitter-durable-object",
   "type": "module",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Durable Object event emitter for Uploadista",
   "license": "MIT",
   "author": "Uploadista",
@@ -14,12 +14,12 @@
   },
   "dependencies": {
     "@cloudflare/workers-types": "4.20251014.0",
-    "effect": "3.18.4",
-    "@uploadista/core": "0.0.8"
+    "effect": "3.19.0",
+    "@uploadista/core": "0.0.9"
   },
   "devDependencies": {
-    "tsdown": "0.15.10",
-    "@uploadista/typescript-config": "0.0.8"
+    "tsdown": "0.16.0",
+    "@uploadista/typescript-config": "0.0.9"
   },
   "scripts": {
     "build": "tsdown",

package/src/do-event-emitter.ts

@@ -1,60 +1,70 @@
 import { UploadistaError } from "@uploadista/core/errors";
+import type { WebSocketConnection } from "@uploadista/core/types";
 import {
-  type EventEmitter,
-  type UploadEvent,
-  UploadEventEmitter,
+  type BaseEventEmitter,
+  BaseEventEmitterService,
 } from "@uploadista/core/types";
 import { Effect, Layer } from "effect";
-import type {
-  EventEmitterDurableObject,
-  EventEmitterDurableObjectBranded,
-} from "./event-emitter-durable-object";
+import type { EventEmitterDurableObject } from "./event-emitter-durable-object";
 
-export type UploadEventEmitterDurableObjectStoreConfig = {
-  durableObject: EventEmitterDurableObject<UploadEvent>;
+export type DurableObjectEventEmitterConfig = {
+  durableObject: EventEmitterDurableObject<string>;
 };
 
-export function makeEventEmitterDurableObjectStore<T>({
+/**
+ * Creates a BaseEventEmitter implementation using Cloudflare Durable Objects.
+ *
+ * This implementation:
+ * - Routes events to Durable Object instances by eventKey
+ * - Each eventKey gets its own DO instance
+ * - WebSocket connections are managed by the DO
+ * - No external broadcaster needed - DO is single source of truth
+ *
+ * @param config - Configuration with Durable Object namespace
+ * @returns BaseEventEmitter implementation
+ */
+export function durableObjectBaseEventEmitter({
   durableObject,
-}: UploadEventEmitterDurableObjectStoreConfig): EventEmitter<T> {
-  function getStub(key: string) {
-    const id = durableObject.idFromName(key);
-    return durableObject.get(
-      id,
-    ) as unknown as EventEmitterDurableObjectBranded<T>;
+}: DurableObjectEventEmitterConfig): BaseEventEmitter {
+  function getStub(eventKey: string) {
+    const id = durableObject.idFromName(eventKey);
+    return durableObject.get(id);
   }
 
   return {
-    emit: (key: string, event: T) => {
-      const stub = getStub(key);
+    emit: (eventKey: string, message: string) => {
       return Effect.tryPromise({
         try: async () => {
-          await stub.emit(event);
-          return;
+          console.log(`[DO EventEmitter] Emitting to eventKey: ${eventKey}`, message.substring(0, 200));
+          const stub = getStub(eventKey);
+          // Call the emit RPC method on the Durable Object
+          await (stub as any).emit(message);
+          console.log(`[DO EventEmitter] Successfully emitted to eventKey: ${eventKey}`);
         },
         catch: (cause) => {
+          console.error(`[DO EventEmitter] Failed to emit to eventKey: ${eventKey}`, cause);
           return UploadistaError.fromCode("UNKNOWN_ERROR", { cause });
         },
       });
     },
-    subscribe: (key: string, connection) => {
+    subscribe: (eventKey: string, connection: WebSocketConnection) => {
       return Effect.tryPromise({
         try: async () => {
-          const stub = getStub(key);
-          await stub.subscribe(connection);
-          return;
+          const stub = getStub(eventKey);
+          // Call the subscribe RPC method on the Durable Object
+          await (stub as any).subscribe(connection);
         },
         catch: (cause) => {
           return UploadistaError.fromCode("UNKNOWN_ERROR", { cause });
         },
       });
     },
-    unsubscribe: (key: string) => {
+    unsubscribe: (eventKey: string) => {
       return Effect.tryPromise({
         try: async () => {
-          const stub = getStub(key);
-          await stub.unsubscribe();
-          return;
+          const stub = getStub(eventKey);
+          // Call the unsubscribe RPC method on the Durable Object
+          await (stub as any).unsubscribe();
         },
         catch: (cause) => {
           return UploadistaError.fromCode("UNKNOWN_ERROR", { cause });
@@ -64,10 +74,25 @@ export function makeEventEmitterDurableObjectStore<T>({
   };
 }
 
-export const uploadEventEmitterDurableObjectStore = (
-  config: UploadEventEmitterDurableObjectStoreConfig,
+/**
+ * Creates a Layer for BaseEventEmitterService using Durable Objects.
+ *
+ * Use this when creating an Uploadista server with Durable Objects:
+ *
+ * @example
+ * ```typescript
+ * const server = await createUploadistaServer({
+ *   eventEmitter: durableObjectEventEmitter({
+ *     durableObject: env.UPLOADISTA_DO,
+ *   }),
+ *   // ... other config
+ * });
+ * ```
+ */
+export const durableObjectEventEmitter = (
+  config: DurableObjectEventEmitterConfig,
 ) =>
   Layer.succeed(
-    UploadEventEmitter,
-    makeEventEmitterDurableObjectStore<UploadEvent>(config),
+    BaseEventEmitterService,
+    durableObjectBaseEventEmitter(config),
   );

package/src/durable-object-impl.ts

@@ -1,58 +1,132 @@
-// import { DurableObject } from "cloudflare:workers";
-// import { WebSocketPair } from "@cloudflare/workers-types";
-// import type { UploadEvent } from "@uploadista/core/types";
-
-// export class UploadEventDurableObject extends DurableObject {
-//   async fetch(_request: Request): Promise<Response> {
-//     // Creates two ends of a WebSocket connection.
-//     const webSocketPair = new WebSocketPair();
-//     const [client, server] = Object.values(webSocketPair);
-
-//     // Calling `acceptWebSocket()` informs the runtime that this WebSocket is to begin terminating
-//     // request within the Durable Object. It has the effect of "accepting" the connection,
-//     // and allowing the WebSocket to send and receive messages.
-//     // Unlike `ws.accept()`, `state.acceptWebSocket(ws)` informs the Workers Runtime that the WebSocket
-//     // is "hibernatable", so the runtime does not need to pin this Durable Object to memory while
-//     // the connection is open. During periods of inactivity, the Durable Object can be evicted
-//     // from memory, but the WebSocket connection will remain open. If at some later point the
-//     // WebSocket receives a message, the runtime will recreate the Durable Object
-//     // (run the `constructor`) and deliver the message to the appropriate handler.
-//     this.ctx.acceptWebSocket(server);
-
-//     return new Response(null, {
-//       status: 101,
-//       webSocket: client,
-//     });
-//   }
-
-//   emit(event: UploadEvent) {
-//     for (const ws of this.ctx.getWebSockets()) {
-//       ws.send(JSON.stringify(event satisfies UploadEvent));
-//     }
-//   }
-
-//   async webSocketMessage(ws: WebSocket, message: ArrayBuffer | string) {
-//     // Upon receiving a message from the client, the server replies with the same message,
-//     // and the total number of connections with the "[Durable Object]: " prefix
-//     ws.send(
-//       `[Durable Object] message: ${message}, connections: ${this.ctx.getWebSockets().length}`,
-//     );
-//   }
-
-//   async webSocketClose(
-//     ws: WebSocket,
-//     code: number,
-//     _reason: string,
-//     _wasClean: boolean,
-//   ) {
-//     // If the client closes the connection, the runtime will invoke the webSocketClose() handler.
-//     // Don't try to close an already closed WebSocket or use reserved close codes
-//     if (ws.readyState === WebSocket.OPEN) {
-//       // Use a valid close code instead of the potentially reserved one from the client
-//       // 1000 = Normal Closure, 1001 = Going Away are safe codes to use
-//       const validCloseCode =
-//         code === 1006 || code < 1000 || code > 4999 ? 1000 : code;
-//       ws.close(validCloseCode, "Durable Object is closing WebSocket");
-//     }
-//   }
-// }
+import { DurableObject } from "cloudflare:workers";
+import type { WebSocketConnection } from "@uploadista/core/types";
+
+// WebSocketPair is available globally in Cloudflare Workers
+declare const WebSocketPair: {
+  new (): { 0: WebSocket; 1: WebSocket };
+};
+
+/**
+ * Base Durable Object implementation for Uploadista event emission.
+ *
+ * This class provides:
+ * - Hibernatable WebSocket connections
+ * - Event broadcasting to all connected clients
+ * - Automatic connection management
+ * - RPC methods for emit/subscribe/unsubscribe
+ *
+ * Extend this class in your Worker to create event emitter Durable Objects:
+ *
+ * @example
+ * ```typescript
+ * export class UploadistaDurableObject extends UploadistaDurableObjectImpl {}
+ * ```
+ */
+export class UploadistaDurableObjectImpl extends DurableObject {
+  /**
+   * Handles WebSocket upgrade requests.
+   * Creates a hibernatable WebSocket connection.
+   */
+  async fetch(request: Request): Promise<Response> {
+    console.log(`[DO fetch] WebSocket connection request: ${request.url}`);
+
+    // Creates two ends of a WebSocket connection
+    const pair = new WebSocketPair();
+    const [client, server] = Object.values(pair);
+
+    // Accept WebSocket with hibernation support
+    // This allows the DO to be evicted from memory during idle periods
+    this.ctx.acceptWebSocket(server);
+
+    console.log(`[DO fetch] WebSocket accepted, total connections: ${this.ctx.getWebSockets().length}`);
+
+    return new Response(null, {
+      status: 101,
+      webSocket: client as unknown,
+    } as ResponseInit);
+  }
+
+  /**
+   * RPC method: Emit a message to all connected WebSocket clients.
+   *
+   * @param message - The message to broadcast (typically a JSON string)
+   */
+  async emit(message: string): Promise<void> {
+    const websockets = this.ctx.getWebSockets();
+    console.log(`[DO emit] Broadcasting message to ${websockets.length} WebSocket(s):`, message.substring(0, 200));
+
+    for (const ws of websockets) {
+      try {
+        ws.send(message);
+      } catch (error) {
+        console.error("Failed to send message to WebSocket:", error);
+      }
+    }
+  }
+
+  /**
+   * RPC method: Subscribe a WebSocket connection.
+   *
+   * Note: This is called via RPC, the actual WebSocket connection
+   * is established via the fetch() handler.
+   */
+  async subscribe(_connection: WebSocketConnection): Promise<void> {
+    // The connection is already established via fetch()
+    // This method exists for API compatibility
+    return;
+  }
+
+  /**
+   * RPC method: Unsubscribe from events.
+   *
+   * Closes all WebSocket connections for this DO instance.
+   */
+  async unsubscribe(): Promise<void> {
+    const websockets = this.ctx.getWebSockets();
+    for (const ws of websockets) {
+      ws.close(1000, "Unsubscribed");
+    }
+  }
+
+  /**
+   * Hibernation API: Handle incoming WebSocket messages.
+   *
+   * Called automatically when a message arrives on a hibernated WebSocket.
+   */
+  async webSocketMessage(_ws: WebSocket, message: ArrayBuffer | string) {
+    // Log message for debugging
+    console.log(`WebSocket message received: ${message}`);
+  }
+
+  /**
+   * Hibernation API: Handle WebSocket close events.
+   *
+   * Called automatically when a WebSocket connection closes.
+   */
+  async webSocketClose(
+    ws: WebSocket,
+    code: number,
+    _reason: string,
+    _wasClean: boolean,
+  ) {
+    // Clean up the connection
+    if (ws.readyState === WebSocket.OPEN) {
+      // Use a valid close code instead of potentially reserved ones
+      const validCloseCode =
+        code === 1006 || code < 1000 || code > 4999 ? 1000 : code;
+      ws.close(validCloseCode, "Durable Object closing WebSocket");
+    }
+  }
+
+  /**
+   * Hibernation API: Handle WebSocket errors.
+   *
+   * Called automatically when a WebSocket error occurs.
+   */
+  async webSocketError(ws: WebSocket, error: unknown) {
+    console.error("WebSocket error:", error);
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.close(1011, "WebSocket error occurred");
+    }
+  }
+}

package/src/event-emitter-durable-object.ts

@@ -1,13 +1,36 @@
 import type { DurableObjectNamespace, Rpc } from "@cloudflare/workers-types";
 import type { WebSocketConnection } from "@uploadista/core/types";
 
+/**
+ * RPC interface for event emitter Durable Objects.
+ *
+ * Defines the methods that can be called on a Durable Object instance via RPC.
+ */
 export type EventEmitterDurableObjectBranded<T> = Rpc.DurableObjectBranded & {
-  emit: (event: T) => Promise<void>;
+  /**
+   * Emit a message to all connected WebSocket clients.
+   * @param message - The message to broadcast (typically a JSON string)
+   */
+  emit: (message: T) => Promise<void>;
+
+  /**
+   * Subscribe a WebSocket connection to this DO instance.
+   * Note: The actual WebSocket connection is established via fetch()
+   * @param connection - WebSocket connection details
+   */
   subscribe: (connection: WebSocketConnection) => Promise<void>;
+
+  /**
+   * Unsubscribe from events by closing all WebSocket connections.
+   */
   unsubscribe: () => Promise<void>;
 };
 
-// Durable Object
+/**
+ * Durable Object namespace type for event emitters.
+ *
+ * @template T - Type of messages (typically string for JSON messages)
+ */
 export type EventEmitterDurableObject<T> = DurableObjectNamespace<
   EventEmitterDurableObjectBranded<T>
 >;

package/src/index.ts

@@ -1,3 +1,7 @@
-export { uploadEventEmitterDurableObjectStore } from "./do-event-emitter";
-// export { UploadEventDurableObject } from "./durable-object-impl";
+export {
+  durableObjectEventEmitter,
+  durableObjectBaseEventEmitter,
+  type DurableObjectEventEmitterConfig,
+} from "./do-event-emitter";
+export { UploadistaDurableObjectImpl } from "./durable-object-impl";
 export type { EventEmitterDurableObject } from "./event-emitter-durable-object";

package/dist/index.d.ts

@@ -1,20 +0,0 @@
-import { UploadEvent, UploadEventEmitter, WebSocketConnection } from "@uploadista/core/types";
-import { Layer } from "effect";
-import { DurableObjectNamespace, Rpc } from "@cloudflare/workers-types";
-
-//#region src/event-emitter-durable-object.d.ts
-type EventEmitterDurableObjectBranded<T> = Rpc.DurableObjectBranded & {
-  emit: (event: T) => Promise<void>;
-  subscribe: (connection: WebSocketConnection) => Promise<void>;
-  unsubscribe: () => Promise<void>;
-};
-type EventEmitterDurableObject<T> = DurableObjectNamespace<EventEmitterDurableObjectBranded<T>>;
-//#endregion
-//#region src/do-event-emitter.d.ts
-type UploadEventEmitterDurableObjectStoreConfig = {
-  durableObject: EventEmitterDurableObject<UploadEvent>;
-};
-declare const uploadEventEmitterDurableObjectStore: (config: UploadEventEmitterDurableObjectStoreConfig) => Layer.Layer<UploadEventEmitter, never, never>;
-//#endregion
-export { type EventEmitterDurableObject, uploadEventEmitterDurableObjectStore };
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/event-emitter-durable-object.ts","../src/do-event-emitter.ts"],"sourcesContent":[],"mappings":";;;;;KAGY,sCAAsC,GAAA,CAAI;gBACtC,MAAM;0BACI,wBAAwB;EAFtC,WAAA,EAAA,GAAA,GAGS,OAHT,CAAA,IAAA,CAAA;CAAsC;AAClC,KAMJ,yBANI,CAAA,CAAA,CAAA,GAM2B,sBAN3B,CAOd,gCAPc,CAOmB,CAPnB,CAAA,CAAA;;;KCQJ,0CAAA;iBACK,0BAA0B;ADV3C,CAAA;AACgB,cC8DH,oCD9DG,EAAA,CAAA,MAAA,EC+DN,0CD/DM,EAAA,GC+DoC,KAAA,CAAA,KD/DpC,CC+DoC,kBD/DpC,EAAA,KAAA,EAAA,KAAA,CAAA"}

package/dist/index.js

@@ -1,2 +0,0 @@
-import{UploadistaError as e}from"@uploadista/core/errors";import{UploadEventEmitter as t}from"@uploadista/core/types";import{Effect as n,Layer as r}from"effect";function i({durableObject:t}){function r(e){let n=t.idFromName(e);return t.get(n)}return{emit:(t,i)=>{let a=r(t);return n.tryPromise({try:async()=>{await a.emit(i)},catch:t=>e.fromCode(`UNKNOWN_ERROR`,{cause:t})})},subscribe:(t,i)=>n.tryPromise({try:async()=>{await r(t).subscribe(i)},catch:t=>e.fromCode(`UNKNOWN_ERROR`,{cause:t})}),unsubscribe:t=>n.tryPromise({try:async()=>{await r(t).unsubscribe()},catch:t=>e.fromCode(`UNKNOWN_ERROR`,{cause:t})})}}const a=e=>r.succeed(t,i(e));export{a as uploadEventEmitterDurableObjectStore};
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/do-event-emitter.ts"],"sourcesContent":["import { UploadistaError } from \"@uploadista/core/errors\";\nimport {\n  type EventEmitter,\n  type UploadEvent,\n  UploadEventEmitter,\n} from \"@uploadista/core/types\";\nimport { Effect, Layer } from \"effect\";\nimport type {\n  EventEmitterDurableObject,\n  EventEmitterDurableObjectBranded,\n} from \"./event-emitter-durable-object\";\n\nexport type UploadEventEmitterDurableObjectStoreConfig = {\n  durableObject: EventEmitterDurableObject<UploadEvent>;\n};\n\nexport function makeEventEmitterDurableObjectStore<T>({\n  durableObject,\n}: UploadEventEmitterDurableObjectStoreConfig): EventEmitter<T> {\n  function getStub(key: string) {\n    const id = durableObject.idFromName(key);\n    return durableObject.get(\n      id,\n    ) as unknown as EventEmitterDurableObjectBranded<T>;\n  }\n\n  return {\n    emit: (key: string, event: T) => {\n      const stub = getStub(key);\n      return Effect.tryPromise({\n        try: async () => {\n          await stub.emit(event);\n          return;\n        },\n        catch: (cause) => {\n          return UploadistaError.fromCode(\"UNKNOWN_ERROR\", { cause });\n        },\n      });\n    },\n    subscribe: (key: string, connection) => {\n      return Effect.tryPromise({\n        try: async () => {\n          const stub = getStub(key);\n          await stub.subscribe(connection);\n          return;\n        },\n        catch: (cause) => {\n          return UploadistaError.fromCode(\"UNKNOWN_ERROR\", { cause });\n        },\n      });\n    },\n    unsubscribe: (key: string) => {\n      return Effect.tryPromise({\n        try: async () => {\n          const stub = getStub(key);\n          await stub.unsubscribe();\n          return;\n        },\n        catch: (cause) => {\n          return UploadistaError.fromCode(\"UNKNOWN_ERROR\", { cause });\n        },\n      });\n    },\n  };\n}\n\nexport const uploadEventEmitterDurableObjectStore = (\n  config: UploadEventEmitterDurableObjectStoreConfig,\n) =>\n  Layer.succeed(\n    UploadEventEmitter,\n    makeEventEmitterDurableObjectStore<UploadEvent>(config),\n  );\n"],"mappings":"iKAgBA,SAAgB,EAAsC,CACpD,iBAC8D,CAC9D,SAAS,EAAQ,EAAa,CAC5B,IAAM,EAAK,EAAc,WAAW,EAAI,CACxC,OAAO,EAAc,IACnB,EACD,CAGH,MAAO,CACL,MAAO,EAAa,IAAa,CAC/B,IAAM,EAAO,EAAQ,EAAI,CACzB,OAAO,EAAO,WAAW,CACvB,IAAK,SAAY,CACf,MAAM,EAAK,KAAK,EAAM,EAGxB,MAAQ,GACC,EAAgB,SAAS,gBAAiB,CAAE,QAAO,CAAC,CAE9D,CAAC,EAEJ,WAAY,EAAa,IAChB,EAAO,WAAW,CACvB,IAAK,SAAY,CAEf,MADa,EAAQ,EAAI,CACd,UAAU,EAAW,EAGlC,MAAQ,GACC,EAAgB,SAAS,gBAAiB,CAAE,QAAO,CAAC,CAE9D,CAAC,CAEJ,YAAc,GACL,EAAO,WAAW,CACvB,IAAK,SAAY,CAEf,MADa,EAAQ,EAAI,CACd,aAAa,EAG1B,MAAQ,GACC,EAAgB,SAAS,gBAAiB,CAAE,QAAO,CAAC,CAE9D,CAAC,CAEL,CAGH,MAAa,EACX,GAEA,EAAM,QACJ,EACA,EAAgD,EAAO,CACxD"}