@orpc/standard-server-peer 0.0.0 → 1.3.0

package/README.md

@@ -49,6 +49,7 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
 - [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
 - [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with NestJS.
 - [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
 - [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
 - [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).

package/dist/index.d.mts

@@ -1,5 +1,32 @@
-import { EventMeta, StandardRequest, StandardResponse, StandardHeaders } from '@orpc/standard-server';
-import { CreateAsyncIteratorObjectOptions } from '@orpc/shared';
+import { Promisable, AsyncIdQueueCloseOptions as AsyncIdQueueCloseOptions$1, CreateAsyncIteratorObjectCleanupFn } from '@orpc/shared';
+import { StandardRequest, StandardResponse, EventMeta, StandardHeaders } from '@orpc/standard-server';
+
+type EncodedMessage = string | ArrayBufferLike | Blob;
+interface EncodedMessageSendFn {
+    (message: EncodedMessage): Promisable<void>;
+}
+
+interface ClientPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
+    /**
+     * Should abort or not?
+     *
+     * @default true
+     */
+    abort?: boolean;
+}
+declare class ClientPeer {
+    private readonly idGenerator;
+    private readonly responseQueue;
+    private readonly serverEventIteratorQueue;
+    private readonly serverControllers;
+    private readonly send;
+    constructor(send: EncodedMessageSendFn);
+    get length(): number;
+    open(id: number): AbortController;
+    request(request: StandardRequest): Promise<StandardResponse>;
+    message(raw: EncodedMessage): Promise<void>;
+    close(options?: AsyncIdQueueCloseOptions$1): void;
+}
 
 declare enum MessageType {
     REQUEST = 1,
@@ -7,7 +34,6 @@ declare enum MessageType {
     EVENT_ITERATOR = 3,
     ABORT_SIGNAL = 4
 }
-type RawMessage = string | ArrayBufferLike | Blob;
 type EventIteratorEvent = 'message' | 'error' | 'done';
 interface EventIteratorPayload {
     event: EventIteratorEvent;
@@ -29,63 +55,51 @@ type DecodedMessageUnion<TMap extends RequestMessageMap | ResponseMessageMap> =
 }[keyof TMap];
 type DecodedRequestMessage = DecodedMessageUnion<RequestMessageMap>;
 type DecodedResponseMessage = DecodedMessageUnion<ResponseMessageMap>;
-declare function encodeRequestMessage<T extends keyof RequestMessageMap>(id: number, type: T, payload: RequestMessageMap[T]): Promise<RawMessage>;
-declare function decodeRequestMessage(raw: RawMessage): Promise<DecodedRequestMessage>;
-declare function encodeResponseMessage<T extends keyof ResponseMessageMap>(id: number, type: T, payload: ResponseMessageMap[T]): Promise<RawMessage>;
-declare function decodeResponseMessage(raw: RawMessage): Promise<DecodedResponseMessage>;
+declare function encodeRequestMessage<T extends keyof RequestMessageMap>(id: number, type: T, payload: RequestMessageMap[T]): Promise<EncodedMessage>;
+declare function decodeRequestMessage(raw: EncodedMessage): Promise<DecodedRequestMessage>;
+declare function encodeResponseMessage<T extends keyof ResponseMessageMap>(id: number, type: T, payload: ResponseMessageMap[T]): Promise<EncodedMessage>;
+declare function decodeResponseMessage(raw: EncodedMessage): Promise<DecodedResponseMessage>;
 declare function isEventIteratorHeaders(headers: StandardHeaders): boolean;
 
-declare class ClientPeer {
-    private readonly idGenerator;
-    private readonly clientRequestQueue;
-    private readonly clientEventIteratorQueue;
-    private readonly clientSignalQueue;
-    private readonly serverResponseQueue;
-    private readonly serverEventIterator;
-    private readonly serverSignalQueue;
-    constructor(send: (message: RawMessage) => void);
-    request(request: StandardRequest): Promise<StandardResponse>;
-    message(raw: RawMessage): Promise<void>;
-    open(id: number): void;
-    close(id?: number, reason?: any): void;
+interface AsyncIdQueueCloseOptions {
+    id?: number;
+    reason?: Error;
 }
-
-declare abstract class AsyncIdQueue<T> {
+declare class AsyncIdQueue<T> {
     private readonly openIds;
-    abstract push(id: number, item: T): void;
-    open(id: number): void;
-    close(id: number): void;
-    closeAll(): void;
-    isOpen(id: number): boolean;
-    assertOpen(id: number): void;
-}
-declare class PullableAsyncIdQueue<T> extends AsyncIdQueue<T> {
     private readonly items;
     private readonly pendingPulls;
+    get length(): number;
+    open(id: number): void;
+    isOpen(id: number): boolean;
     push(id: number, item: T): void;
     pull(id: number): Promise<T>;
-    close(id: number, reason?: any): void;
+    close({ id, reason }?: AsyncIdQueueCloseOptions): void;
+    assertOpen(id: number): void;
 }
 
-declare function toEventIterator(queue: PullableAsyncIdQueue<EventIteratorPayload>, id: number, options?: CreateAsyncIteratorObjectOptions): AsyncGenerator;
-declare function sendEventIterator(queue: AsyncIdQueue<EventIteratorPayload>, id: number, iterator: AsyncIterator<any>, options?: {
-    onComplete?: () => void;
-}): Promise<void>;
+declare function toEventIterator(queue: AsyncIdQueue<EventIteratorPayload>, id: number, cleanup: CreateAsyncIteratorObjectCleanupFn): AsyncGenerator;
+declare function resolveEventIterator(iterator: AsyncIterator<any>, callback: (payload: EventIteratorPayload) => Promise<'next' | 'abort'>): Promise<void>;
 
+interface ServerPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
+    /**
+     * Should abort or not?
+     *
+     * @default true
+     */
+    abort?: boolean;
+}
 declare class ServerPeer {
-    private readonly serverResponseQueue;
-    private readonly serverEventIteratorQueue;
-    private readonly serverSignalQueue;
     private readonly clientEventIteratorQueue;
-    private readonly clientSignalQueue;
-    constructor(send: (message: RawMessage) => void);
-    message(raw: RawMessage): Promise<[id: number, StandardRequest | undefined]>;
+    private readonly clientControllers;
+    private readonly send;
+    constructor(send: EncodedMessageSendFn);
+    get length(): number;
+    open(id: number): AbortController;
+    message(raw: EncodedMessage): Promise<[id: number, StandardRequest | undefined]>;
     response(id: number, response: StandardResponse): Promise<void>;
-    open(id: number): void;
-    close(id?: number, reason?: any): void;
+    close({ abort, ...options }?: ServerPeerCloseOptions): void;
 }
 
-declare function toAbortSignal(queue: PullableAsyncIdQueue<void>, id: number): AbortSignal;
-
-export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, encodeRequestMessage, encodeResponseMessage, isEventIteratorHeaders, sendEventIterator, toAbortSignal, toEventIterator };
-export type { DecodedRequestMessage, DecodedResponseMessage, EventIteratorEvent, EventIteratorPayload, RawMessage, RequestMessageMap, ResponseMessageMap };
+export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, encodeRequestMessage, encodeResponseMessage, isEventIteratorHeaders, resolveEventIterator, toEventIterator };
+export type { ClientPeerCloseOptions, DecodedRequestMessage, DecodedResponseMessage, EncodedMessage, EncodedMessageSendFn, EventIteratorEvent, EventIteratorPayload, RequestMessageMap, ResponseMessageMap, ServerPeerCloseOptions };

package/dist/index.d.ts

@@ -1,5 +1,32 @@
-import { EventMeta, StandardRequest, StandardResponse, StandardHeaders } from '@orpc/standard-server';
-import { CreateAsyncIteratorObjectOptions } from '@orpc/shared';
+import { Promisable, AsyncIdQueueCloseOptions as AsyncIdQueueCloseOptions$1, CreateAsyncIteratorObjectCleanupFn } from '@orpc/shared';
+import { StandardRequest, StandardResponse, EventMeta, StandardHeaders } from '@orpc/standard-server';
+
+type EncodedMessage = string | ArrayBufferLike | Blob;
+interface EncodedMessageSendFn {
+    (message: EncodedMessage): Promisable<void>;
+}
+
+interface ClientPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
+    /**
+     * Should abort or not?
+     *
+     * @default true
+     */
+    abort?: boolean;
+}
+declare class ClientPeer {
+    private readonly idGenerator;
+    private readonly responseQueue;
+    private readonly serverEventIteratorQueue;
+    private readonly serverControllers;
+    private readonly send;
+    constructor(send: EncodedMessageSendFn);
+    get length(): number;
+    open(id: number): AbortController;
+    request(request: StandardRequest): Promise<StandardResponse>;
+    message(raw: EncodedMessage): Promise<void>;
+    close(options?: AsyncIdQueueCloseOptions$1): void;
+}
 
 declare enum MessageType {
     REQUEST = 1,
@@ -7,7 +34,6 @@ declare enum MessageType {
     EVENT_ITERATOR = 3,
     ABORT_SIGNAL = 4
 }
-type RawMessage = string | ArrayBufferLike | Blob;
 type EventIteratorEvent = 'message' | 'error' | 'done';
 interface EventIteratorPayload {
     event: EventIteratorEvent;
@@ -29,63 +55,51 @@ type DecodedMessageUnion<TMap extends RequestMessageMap | ResponseMessageMap> =
 }[keyof TMap];
 type DecodedRequestMessage = DecodedMessageUnion<RequestMessageMap>;
 type DecodedResponseMessage = DecodedMessageUnion<ResponseMessageMap>;
-declare function encodeRequestMessage<T extends keyof RequestMessageMap>(id: number, type: T, payload: RequestMessageMap[T]): Promise<RawMessage>;
-declare function decodeRequestMessage(raw: RawMessage): Promise<DecodedRequestMessage>;
-declare function encodeResponseMessage<T extends keyof ResponseMessageMap>(id: number, type: T, payload: ResponseMessageMap[T]): Promise<RawMessage>;
-declare function decodeResponseMessage(raw: RawMessage): Promise<DecodedResponseMessage>;
+declare function encodeRequestMessage<T extends keyof RequestMessageMap>(id: number, type: T, payload: RequestMessageMap[T]): Promise<EncodedMessage>;
+declare function decodeRequestMessage(raw: EncodedMessage): Promise<DecodedRequestMessage>;
+declare function encodeResponseMessage<T extends keyof ResponseMessageMap>(id: number, type: T, payload: ResponseMessageMap[T]): Promise<EncodedMessage>;
+declare function decodeResponseMessage(raw: EncodedMessage): Promise<DecodedResponseMessage>;
 declare function isEventIteratorHeaders(headers: StandardHeaders): boolean;
 
-declare class ClientPeer {
-    private readonly idGenerator;
-    private readonly clientRequestQueue;
-    private readonly clientEventIteratorQueue;
-    private readonly clientSignalQueue;
-    private readonly serverResponseQueue;
-    private readonly serverEventIterator;
-    private readonly serverSignalQueue;
-    constructor(send: (message: RawMessage) => void);
-    request(request: StandardRequest): Promise<StandardResponse>;
-    message(raw: RawMessage): Promise<void>;
-    open(id: number): void;
-    close(id?: number, reason?: any): void;
+interface AsyncIdQueueCloseOptions {
+    id?: number;
+    reason?: Error;
 }
-
-declare abstract class AsyncIdQueue<T> {
+declare class AsyncIdQueue<T> {
     private readonly openIds;
-    abstract push(id: number, item: T): void;
-    open(id: number): void;
-    close(id: number): void;
-    closeAll(): void;
-    isOpen(id: number): boolean;
-    assertOpen(id: number): void;
-}
-declare class PullableAsyncIdQueue<T> extends AsyncIdQueue<T> {
     private readonly items;
     private readonly pendingPulls;
+    get length(): number;
+    open(id: number): void;
+    isOpen(id: number): boolean;
     push(id: number, item: T): void;
     pull(id: number): Promise<T>;
-    close(id: number, reason?: any): void;
+    close({ id, reason }?: AsyncIdQueueCloseOptions): void;
+    assertOpen(id: number): void;
 }
 
-declare function toEventIterator(queue: PullableAsyncIdQueue<EventIteratorPayload>, id: number, options?: CreateAsyncIteratorObjectOptions): AsyncGenerator;
-declare function sendEventIterator(queue: AsyncIdQueue<EventIteratorPayload>, id: number, iterator: AsyncIterator<any>, options?: {
-    onComplete?: () => void;
-}): Promise<void>;
+declare function toEventIterator(queue: AsyncIdQueue<EventIteratorPayload>, id: number, cleanup: CreateAsyncIteratorObjectCleanupFn): AsyncGenerator;
+declare function resolveEventIterator(iterator: AsyncIterator<any>, callback: (payload: EventIteratorPayload) => Promise<'next' | 'abort'>): Promise<void>;
 
+interface ServerPeerCloseOptions extends AsyncIdQueueCloseOptions$1 {
+    /**
+     * Should abort or not?
+     *
+     * @default true
+     */
+    abort?: boolean;
+}
 declare class ServerPeer {
-    private readonly serverResponseQueue;
-    private readonly serverEventIteratorQueue;
-    private readonly serverSignalQueue;
     private readonly clientEventIteratorQueue;
-    private readonly clientSignalQueue;
-    constructor(send: (message: RawMessage) => void);
-    message(raw: RawMessage): Promise<[id: number, StandardRequest | undefined]>;
+    private readonly clientControllers;
+    private readonly send;
+    constructor(send: EncodedMessageSendFn);
+    get length(): number;
+    open(id: number): AbortController;
+    message(raw: EncodedMessage): Promise<[id: number, StandardRequest | undefined]>;
     response(id: number, response: StandardResponse): Promise<void>;
-    open(id: number): void;
-    close(id?: number, reason?: any): void;
+    close({ abort, ...options }?: ServerPeerCloseOptions): void;
 }
 
-declare function toAbortSignal(queue: PullableAsyncIdQueue<void>, id: number): AbortSignal;
-
-export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, encodeRequestMessage, encodeResponseMessage, isEventIteratorHeaders, sendEventIterator, toAbortSignal, toEventIterator };
-export type { DecodedRequestMessage, DecodedResponseMessage, EventIteratorEvent, EventIteratorPayload, RawMessage, RequestMessageMap, ResponseMessageMap };
+export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, encodeRequestMessage, encodeResponseMessage, isEventIteratorHeaders, resolveEventIterator, toEventIterator };
+export type { ClientPeerCloseOptions, DecodedRequestMessage, DecodedResponseMessage, EncodedMessage, EncodedMessageSendFn, EventIteratorEvent, EventIteratorPayload, RequestMessageMap, ResponseMessageMap, ServerPeerCloseOptions };

package/dist/index.mjs

@@ -1,88 +1,5 @@
-import { toArray, stringifyJSON, isAsyncIteratorObject, createAsyncIteratorObject, isTypescriptObject, SequentialIdGenerator, PullableAsyncIdQueue as PullableAsyncIdQueue$1, ConsumableAsyncIdQueue as ConsumableAsyncIdQueue$1 } from '@orpc/shared';
-import { getFilenameFromContentDisposition, generateContentDisposition, withEventMeta, ErrorEvent, getEventMeta } from '@orpc/standard-server';
-
-class AsyncIdQueue {
-  openIds = /* @__PURE__ */ new Set();
-  open(id) {
-    this.openIds.add(id);
-  }
-  close(id) {
-    this.openIds.delete(id);
-  }
-  closeAll() {
-    this.openIds.forEach((id) => this.close(id));
-  }
-  isOpen(id) {
-    return this.openIds.has(id);
-  }
-  assertOpen(id) {
-    if (!this.isOpen(id)) {
-      throw new Error(`[AsyncIdQueue] Cannot access queue[${id}] because it is not open.`);
-    }
-  }
-}
-class PullableAsyncIdQueue extends AsyncIdQueue {
-  items = /* @__PURE__ */ new Map();
-  pendingPulls = /* @__PURE__ */ new Map();
-  push(id, item) {
-    this.assertOpen(id);
-    const pending = this.pendingPulls.get(id);
-    if (pending?.length) {
-      pending.shift()[0](item);
-      if (pending.length === 0) {
-        this.pendingPulls.delete(id);
-      }
-    } else {
-      const items = this.items.get(id);
-      if (items) {
-        items.push(item);
-      } else {
-        this.items.set(id, [item]);
-      }
-    }
-  }
-  async pull(id) {
-    this.assertOpen(id);
-    const items = this.items.get(id);
-    if (items?.length) {
-      const item = items.shift();
-      if (items.length === 0) {
-        this.items.delete(id);
-      }
-      return item;
-    }
-    return new Promise((resolve, reject) => {
-      const waitingPulls = this.pendingPulls.get(id);
-      const pending = [resolve, reject];
-      if (waitingPulls) {
-        waitingPulls.push(pending);
-      } else {
-        this.pendingPulls.set(id, [pending]);
-      }
-    });
-  }
-  close(id, reason) {
-    const pendingPulls = this.pendingPulls.get(id);
-    if (pendingPulls) {
-      pendingPulls.forEach(([, reject]) => {
-        reject(reason ?? new Error(`[PullableAsyncIdQueue] Queue[${id}] was closed while waiting for pulling.`));
-      });
-      this.pendingPulls.delete(id);
-    }
-    super.close(id);
-    this.items.delete(id);
-  }
-}
-class ConsumableAsyncIdQueue extends AsyncIdQueue {
-  constructor(consume) {
-    super();
-    this.consume = consume;
-  }
-  push(id, item) {
-    this.assertOpen(id);
-    this.consume(id, item);
-  }
-}
+import { isAsyncIteratorObject, stringifyJSON, createAsyncIteratorObject, isTypescriptObject, SequentialIdGenerator, AsyncIdQueue } from '@orpc/shared';
+import { flattenHeader, getFilenameFromContentDisposition, generateContentDisposition, withEventMeta, ErrorEvent, getEventMeta } from '@orpc/standard-server';
 
 var MessageType = /* @__PURE__ */ ((MessageType2) => {
   MessageType2[MessageType2["REQUEST"] = 1] = "REQUEST";
@@ -138,9 +55,9 @@ async function decodeRequestMessage(raw) {
   const payload = message.p;
   const headers = payload.h ?? {};
   let body = payload.b;
-  const contentType = toArray(headers["content-type"])[0];
+  const contentType = flattenHeader(headers["content-type"]);
   if (blobData) {
-    const contentDisposition = toArray(headers["content-disposition"])[0];
+    const contentDisposition = flattenHeader(headers["content-disposition"]);
     if (contentDisposition === void 0 && contentType?.startsWith("multipart/form-data")) {
       const tempRes = new Response(blobData, { headers: { "content-type": contentType } });
       body = await tempRes.formData();
@@ -199,9 +116,9 @@ async function decodeResponseMessage(raw) {
   const payload = message.p;
   const headers = payload.h ?? {};
   let body = payload.b;
-  const contentType = toArray(headers["content-type"])[0];
+  const contentType = flattenHeader(headers["content-type"]);
   if (blobData) {
-    const contentDisposition = toArray(headers["content-disposition"])[0];
+    const contentDisposition = flattenHeader(headers["content-disposition"]);
     if (contentDisposition === void 0 && contentType?.startsWith("multipart/form-data")) {
       const tempRes = new Response(blobData, { headers: { "content-type": contentType } });
       body = await tempRes.formData();
@@ -228,8 +145,8 @@ async function prepareBodyAndHeadersForSerialization(body, originalHeaders) {
   }
   if (body instanceof FormData) {
     const tempRes = new Response(body);
-    const formDataBlob = await tempRes.blob();
     headers["content-type"] = tempRes.headers.get("content-type");
+    const formDataBlob = await tempRes.blob();
     return { body: formDataBlob, headers };
   }
   if (body instanceof URLSearchParams) {
@@ -243,7 +160,7 @@ async function prepareBodyAndHeadersForSerialization(body, originalHeaders) {
   return { body, headers };
 }
 function isEventIteratorHeaders(headers) {
-  return Boolean(toArray(headers["content-type"])[0]?.startsWith("text/event-stream") && headers["content-disposition"] === void 0);
+  return Boolean(flattenHeader(headers["content-type"])?.startsWith("text/event-stream") && headers["content-disposition"] === void 0);
 }
 const JSON_AND_BINARY_DELIMITER = 255;
 async function encodeRawMessage(data, blobData) {
@@ -275,7 +192,7 @@ async function decodeRawMessage(raw) {
   };
 }
 
-function toEventIterator(queue, id, options = {}) {
+function toEventIterator(queue, id, cleanup) {
   return createAsyncIteratorObject(async () => {
     const item = await queue.pull(id);
     switch (item.event) {
@@ -303,216 +220,174 @@ function toEventIterator(queue, id, options = {}) {
         return { value: data, done: true };
       }
     }
-  }, options);
+  }, cleanup);
 }
-async function sendEventIterator(queue, id, iterator, options = {}) {
-  let isInternal = false;
-  try {
-    while (true) {
-      isInternal = false;
-      const { value, done } = await iterator.next();
-      isInternal = true;
-      if (!queue.isOpen(id)) {
-        if (!done) {
-          isInternal = false;
-          await iterator.return?.();
-          isInternal = true;
+async function resolveEventIterator(iterator, callback) {
+  while (true) {
+    const payload = await (async () => {
+      try {
+        const { value, done } = await iterator.next();
+        if (done) {
+          return { event: "done", data: value, meta: getEventMeta(value) };
         }
+        return { event: "message", data: value, meta: getEventMeta(value) };
+      } catch (err) {
+        return {
+          meta: getEventMeta(err),
+          event: "error",
+          data: err instanceof ErrorEvent ? err.data : void 0
+        };
+      }
+    })();
+    try {
+      const direction = await callback(payload);
+      if (payload.event === "done" || payload.event === "error") {
         return;
       }
-      queue.push(id, {
-        event: done ? "done" : "message",
-        data: value,
-        meta: getEventMeta(value)
-      });
-      if (done) {
+      if (direction === "abort") {
+        try {
+          await iterator.return?.();
+        } catch {
+        }
         return;
       }
-    }
-  } catch (err) {
-    let currentError = err;
-    if (isInternal) {
+    } catch (err) {
       try {
-        await iterator.throw?.(currentError);
-      } catch (err2) {
-        currentError = err2;
+        await iterator.return?.();
+      } catch {
       }
+      throw err;
     }
-    if (queue.isOpen(id)) {
-      queue.push(id, {
-        meta: getEventMeta(currentError),
-        event: "error",
-        data: currentError instanceof ErrorEvent ? currentError.data : void 0
-      });
-    }
-  } finally {
-    options.onComplete?.();
   }
 }
 
-function toAbortSignal(queue, id) {
-  const controller = new AbortController();
-  queue.pull(id).then(() => {
-    controller.abort();
-  }).catch(() => {
-  });
-  return controller.signal;
-}
-
 class ClientPeer {
   idGenerator = new SequentialIdGenerator();
-  clientRequestQueue;
-  clientEventIteratorQueue;
-  clientSignalQueue;
-  serverResponseQueue = new PullableAsyncIdQueue();
-  serverEventIterator = new PullableAsyncIdQueue();
-  serverSignalQueue = new PullableAsyncIdQueue();
+  responseQueue = new AsyncIdQueue();
+  serverEventIteratorQueue = new AsyncIdQueue();
+  serverControllers = /* @__PURE__ */ new Map();
+  send;
   constructor(send) {
-    this.clientRequestQueue = new ConsumableAsyncIdQueue((id, { signal, ...request }) => {
-      encodeRequestMessage(id, MessageType.REQUEST, request).then((raw) => {
-        send(raw);
-        if (signal) {
-          if (signal.aborted) {
-            this.clientSignalQueue.push(id);
-            this.close(id, signal.reason);
-          }
-          signal.addEventListener("abort", () => {
-            this.clientSignalQueue.push(id);
-            this.close(id, signal.reason);
-          }, { once: true });
-        }
-        if (isAsyncIteratorObject(request.body)) {
-          sendEventIterator(this.clientEventIteratorQueue, id, request.body);
-          const serverSignal = toAbortSignal(this.serverSignalQueue, id);
-          serverSignal.addEventListener("abort", () => {
-            this.clientEventIteratorQueue.close(id);
-          }, { once: true });
-        }
-      }).catch((err) => {
-        this.close(id, err);
-      });
-    });
-    this.clientEventIteratorQueue = new ConsumableAsyncIdQueue((id, payload) => {
-      encodeRequestMessage(id, MessageType.EVENT_ITERATOR, payload).then(send).catch((err) => {
-        this.close(id, err);
-      });
-    });
-    this.clientSignalQueue = new ConsumableAsyncIdQueue((id, payload) => {
-      encodeRequestMessage(id, MessageType.ABORT_SIGNAL, payload).then(send).catch((err) => {
-        this.close(id, err);
-      });
+    this.send = async (id, ...rest) => encodeRequestMessage(id, ...rest).then(async (raw) => {
+      if (this.serverControllers.has(id)) {
+        await send(raw);
+      }
     });
   }
+  get length() {
+    return (+this.responseQueue.length + this.serverEventIteratorQueue.length + this.serverControllers.size) / 3;
+  }
+  open(id) {
+    this.serverEventIteratorQueue.open(id);
+    this.responseQueue.open(id);
+    const controller = new AbortController();
+    this.serverControllers.set(id, controller);
+    return controller;
+  }
   async request(request) {
     const signal = request.signal;
     if (signal?.aborted) {
       throw signal.reason;
     }
     const id = this.idGenerator.generate();
-    this.open(id);
-    this.clientRequestQueue.push(id, request);
+    const serverController = this.open(id);
     return new Promise((resolve, reject) => {
-      this.serverResponseQueue.pull(id).then(resolve).catch(reject);
+      this.send(id, MessageType.REQUEST, request).then(async () => {
+        if (signal?.aborted) {
+          await this.send(id, MessageType.ABORT_SIGNAL, void 0);
+          this.close({ id, reason: signal.reason });
+          return;
+        }
+        signal?.addEventListener("abort", async () => {
+          await this.send(id, MessageType.ABORT_SIGNAL, void 0);
+          this.close({ id, reason: signal.reason });
+        }, { once: true });
+        if (isAsyncIteratorObject(request.body)) {
+          await resolveEventIterator(request.body, async (payload) => {
+            if (serverController.signal.aborted) {
+              return "abort";
+            }
+            await this.send(id, MessageType.EVENT_ITERATOR, payload);
+            return "next";
+          });
+        }
+      }).catch((err) => {
+        this.close({ id, reason: err });
+        reject(err);
+      });
+      this.responseQueue.pull(id).then(resolve).catch(reject);
     });
   }
   async message(raw) {
     const [id, type, payload] = await decodeResponseMessage(raw);
+    if (type === MessageType.ABORT_SIGNAL) {
+      this.serverControllers.get(id)?.abort();
+      return;
+    }
     if (type === MessageType.EVENT_ITERATOR) {
-      if (this.serverEventIterator.isOpen(id)) {
-        this.serverEventIterator.push(id, payload);
+      if (this.serverEventIteratorQueue.isOpen(id)) {
+        this.serverEventIteratorQueue.push(id, payload);
       }
       return;
     }
-    if (type === MessageType.ABORT_SIGNAL) {
-      if (this.serverSignalQueue.isOpen(id)) {
-        this.serverSignalQueue.push(id, payload);
-      }
+    if (!this.responseQueue.isOpen(id)) {
       return;
     }
     if (isEventIteratorHeaders(payload.headers)) {
-      this.serverResponseQueue.push(id, {
+      this.responseQueue.push(id, {
         ...payload,
-        body: toEventIterator(this.serverEventIterator, id, {
-          onComplete: (reason) => {
+        body: toEventIterator(this.serverEventIteratorQueue, id, async (reason) => {
+          try {
             if (reason !== "next") {
-              this.clientSignalQueue.push(id);
+              await this.send(id, MessageType.ABORT_SIGNAL, void 0);
             }
-            this.close(id);
+          } finally {
+            this.close({ id });
           }
         })
       });
     } else {
-      this.serverResponseQueue.push(id, payload);
-      this.close(id);
+      this.responseQueue.push(id, payload);
+      this.close({ id });
     }
   }
-  open(id) {
-    this.clientSignalQueue.open(id);
-    this.clientEventIteratorQueue.open(id);
-    this.clientRequestQueue.open(id);
-    this.serverSignalQueue.open(id);
-    this.serverEventIterator.open(id);
-    this.serverResponseQueue.open(id);
-  }
-  close(id, reason) {
-    if (id !== void 0) {
-      this.clientRequestQueue.close(id);
-      this.clientEventIteratorQueue.close(id);
-      this.clientSignalQueue.close(id);
-      this.serverResponseQueue.close(id, reason);
-      this.serverEventIterator.close(id, reason);
-      this.serverResponseQueue.close(id, reason);
+  close(options = {}) {
+    if (options.id !== void 0) {
+      this.serverControllers.get(options.id)?.abort(options.reason);
+      this.serverControllers.delete(options.id);
     } else {
-      this.clientRequestQueue.closeAll();
-      this.clientEventIteratorQueue.closeAll();
-      this.clientSignalQueue.closeAll();
-      this.serverResponseQueue.closeAll();
-      this.serverEventIterator.closeAll();
-      this.serverResponseQueue.closeAll();
+      this.serverControllers.forEach((c) => c.abort(options.reason));
+      this.serverControllers.clear();
     }
+    this.responseQueue.close(options);
+    this.serverEventIteratorQueue.close(options);
   }
 }
 
 class ServerPeer {
-  serverResponseQueue;
-  serverEventIteratorQueue;
-  serverSignalQueue;
-  clientEventIteratorQueue = new PullableAsyncIdQueue$1();
-  clientSignalQueue = new PullableAsyncIdQueue$1();
+  clientEventIteratorQueue = new AsyncIdQueue();
+  clientControllers = /* @__PURE__ */ new Map();
+  send;
   constructor(send) {
-    this.serverResponseQueue = new ConsumableAsyncIdQueue$1((id, response) => {
-      encodeResponseMessage(id, MessageType.RESPONSE, response).then(async (raw) => {
-        send(raw);
-        if (isAsyncIteratorObject(response.body)) {
-          await sendEventIterator(this.serverEventIteratorQueue, id, response.body, {
-            onComplete: () => {
-              this.close(id);
-            }
-          });
-        } else {
-          this.close(id);
-        }
-      }).catch((err) => {
-        this.close(id, err);
-      });
-    });
-    this.serverEventIteratorQueue = new ConsumableAsyncIdQueue$1((id, payload) => {
-      encodeResponseMessage(id, MessageType.EVENT_ITERATOR, payload).then(send).catch((err) => {
-        this.close(id, err);
-      });
-    });
-    this.serverSignalQueue = new ConsumableAsyncIdQueue$1((id, payload) => {
-      encodeResponseMessage(id, MessageType.ABORT_SIGNAL, payload).then(send).catch((err) => {
-        this.close(id, err);
-      });
+    this.send = (id, ...rest) => encodeResponseMessage(id, ...rest).then(async (raw) => {
+      if (this.clientControllers.has(id)) {
+        await send(raw);
+      }
     });
   }
+  get length() {
+    return (this.clientEventIteratorQueue.length + this.clientControllers.size) / 2;
+  }
+  open(id) {
+    this.clientEventIteratorQueue.open(id);
+    const controller = new AbortController();
+    this.clientControllers.set(id, controller);
+    return controller;
+  }
   async message(raw) {
     const [id, type, payload] = await decodeRequestMessage(raw);
     if (type === MessageType.ABORT_SIGNAL) {
-      if (this.clientSignalQueue.isOpen(id)) {
-        this.clientSignalQueue.push(id, payload);
-      }
+      this.close({ id });
       return [id, void 0];
     }
     if (type === MessageType.EVENT_ITERATOR) {
@@ -521,51 +396,53 @@ class ServerPeer {
       }
       return [id, void 0];
     }
-    this.open(id);
-    const clientSignal = toAbortSignal(this.clientSignalQueue, id);
-    clientSignal.addEventListener("abort", () => {
-      this.close(id, clientSignal.reason);
-    }, { once: true });
+    const clientController = this.open(id);
     const request = {
       ...payload,
-      signal: clientSignal,
-      body: isEventIteratorHeaders(payload.headers) ? toEventIterator(this.clientEventIteratorQueue, id, {
-        onComplete: (reason) => {
-          if (reason !== "next") {
-            this.serverSignalQueue.push(id);
-          }
+      signal: clientController.signal,
+      body: isEventIteratorHeaders(payload.headers) ? toEventIterator(this.clientEventIteratorQueue, id, async (reason) => {
+        if (reason !== "next") {
+          await this.send(id, MessageType.ABORT_SIGNAL, void 0);
         }
       }) : payload.body
     };
     return [id, request];
   }
   async response(id, response) {
-    if (this.serverResponseQueue.isOpen(id)) {
-      this.serverResponseQueue.push(id, response);
+    const signal = this.clientControllers.get(id)?.signal;
+    if (!signal || signal.aborted) {
+      return;
     }
+    await this.send(id, MessageType.RESPONSE, response).then(async () => {
+      if (!signal.aborted && isAsyncIteratorObject(response.body)) {
+        await resolveEventIterator(response.body, async (payload) => {
+          if (signal.aborted) {
+            return "abort";
+          }
+          await this.send(id, MessageType.EVENT_ITERATOR, payload);
+          return "next";
+        });
+      }
+      this.close({ id, abort: false });
+    }).catch((reason) => {
+      this.close({ id, reason, abort: false });
+      throw reason;
+    });
   }
-  open(id) {
-    this.serverSignalQueue.open(id);
-    this.serverEventIteratorQueue.open(id);
-    this.serverResponseQueue.open(id);
-    this.clientEventIteratorQueue.open(id);
-    this.clientSignalQueue.open(id);
-  }
-  close(id, reason) {
-    if (id !== void 0) {
-      this.serverResponseQueue.close(id);
-      this.serverEventIteratorQueue.close(id);
-      this.serverResponseQueue.close(id);
-      this.clientEventIteratorQueue.close(id, reason);
-      this.clientSignalQueue.close(id, reason);
+  close({ abort = true, ...options } = {}) {
+    if (options.id === void 0) {
+      if (abort) {
+        this.clientControllers.forEach((c) => c.abort());
+      }
+      this.clientControllers.clear();
     } else {
-      this.serverResponseQueue.closeAll();
-      this.serverEventIteratorQueue.closeAll();
-      this.serverResponseQueue.closeAll();
-      this.clientEventIteratorQueue.closeAll();
-      this.clientSignalQueue.closeAll();
+      if (abort) {
+        this.clientControllers.get(options.id)?.abort();
+      }
+      this.clientControllers.delete(options.id);
     }
+    this.clientEventIteratorQueue.close(options);
   }
 }
 
-export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, encodeRequestMessage, encodeResponseMessage, isEventIteratorHeaders, sendEventIterator, toAbortSignal, toEventIterator };
+export { ClientPeer, MessageType, ServerPeer, decodeRequestMessage, decodeResponseMessage, encodeRequestMessage, encodeResponseMessage, isEventIteratorHeaders, resolveEventIterator, toEventIterator };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/standard-server-peer",
   "type": "module",
-  "version": "0.0.0",
+  "version": "1.3.0",
   "license": "MIT",
   "homepage": "https://unnoq.com",
   "repository": {
@@ -23,8 +23,8 @@
     "dist"
   ],
   "dependencies": {
-    "@orpc/shared": "1.1.1",
-    "@orpc/standard-server": "1.1.1"
+    "@orpc/shared": "1.3.0",
+    "@orpc/standard-server": "1.3.0"
   },
   "scripts": {
     "build": "unbuild",