@trpc/server 11.0.0-rc.645 → 11.0.0-rc.657

package/dist/unstable-core-do-not-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unstable-core-do-not-import.d.ts","sourceRoot":"","sources":["../src/unstable-core-do-not-import.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC;AACnE,cAAc,mDAAmD,CAAC;AAClE,cAAc,2CAA2C,CAAC;AAC1D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,mDAAmD,CAAC;AAClE,cAAc,+CAA+C,CAAC;AAC9D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,uDAAuD,CAAC;AACtE,cAAc,qDAAqD,CAAC;AACpE,cAAc,sDAAsD,CAAC;AACrE,cAAc,iDAAiD,CAAC;AAChE,cAAc,0DAA0D,CAAC;AACzE,cAAc,oDAAoD,CAAC;AACnE,cAAc,0CAA0C,CAAC;AACzD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0CAA0C,CAAC;AACzD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,2DAA2D,CAAC;AAC1E,cAAc,2CAA2C,CAAC;AAC1D,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC"}
+{"version":3,"file":"unstable-core-do-not-import.d.ts","sourceRoot":"","sources":["../src/unstable-core-do-not-import.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC;AACnE,cAAc,mDAAmD,CAAC;AAClE,cAAc,2CAA2C,CAAC;AAC1D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,mDAAmD,CAAC;AAClE,cAAc,+CAA+C,CAAC;AAC9D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,uDAAuD,CAAC;AACtE,cAAc,qDAAqD,CAAC;AACpE,cAAc,sDAAsD,CAAC;AACrE,cAAc,iDAAiD,CAAC;AAChE,cAAc,0DAA0D,CAAC;AACzE,cAAc,oDAAoD,CAAC;AACnE,cAAc,0CAA0C,CAAC;AACzD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0CAA0C,CAAC;AACzD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,2DAA2D,CAAC;AAC1E,cAAc,uDAAuD,CAAC;AACtE,cAAc,2CAA2C,CAAC;AAC1D,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC"}

package/dist/unstable-core-do-not-import.js

@@ -24,6 +24,7 @@ var jsonl = require('./unstable-core-do-not-import/stream/jsonl.js');
 var sse = require('./unstable-core-do-not-import/stream/sse.js');
 var tracked = require('./unstable-core-do-not-import/stream/tracked.js');
 var createDeferred = require('./unstable-core-do-not-import/stream/utils/createDeferred.js');
+var disposable = require('./unstable-core-do-not-import/stream/utils/disposable.js');
 var transformer = require('./unstable-core-do-not-import/transformer.js');
 var utils = require('./unstable-core-do-not-import/utils.js');
 
@@ -76,6 +77,8 @@ exports.isTrackedEnvelope = tracked.isTrackedEnvelope;
 exports.sse = tracked.sse;
 exports.tracked = tracked.tracked;
 exports.createDeferred = createDeferred.createDeferred;
+exports.makeAsyncResource = disposable.makeAsyncResource;
+exports.makeResource = disposable.makeResource;
 exports.defaultTransformer = transformer.defaultTransformer;
 exports.getDataTransformer = transformer.getDataTransformer;
 exports.transformResult = transformer.transformResult;

package/dist/unstable-core-do-not-import.mjs

@@ -22,5 +22,6 @@ export { isPromise, jsonlStreamConsumer, jsonlStreamProducer } from './unstable-
 export { sseHeaders, sseStreamConsumer, sseStreamProducer } from './unstable-core-do-not-import/stream/sse.mjs';
 export { isTrackedEnvelope, sse, tracked } from './unstable-core-do-not-import/stream/tracked.mjs';
 export { createDeferred } from './unstable-core-do-not-import/stream/utils/createDeferred.mjs';
+export { makeAsyncResource, makeResource } from './unstable-core-do-not-import/stream/utils/disposable.mjs';
 export { defaultTransformer, getDataTransformer, transformResult, transformTRPCResponse } from './unstable-core-do-not-import/transformer.mjs';
 export { abortSignalsAnyPonyfill, assert, identity, isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, noop, omitPrototype, run, sleep, unsetMarker } from './unstable-core-do-not-import/utils.mjs';

package/dist/vendor/unpromise/unpromise.js

@@ -1,7 +1,18 @@
 'use strict';
 
-var _define_property = require('../../node_modules/.pnpm/@swc_helpers@0.5.13/node_modules/@swc/helpers/esm/_define_property.js');
-
+/* eslint-disable @typescript-eslint/unbound-method */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 var _computedKey;
 /** Memory safe (weakmapped) cache of the ProxyPromise for each Promise,
  * which is retained for the lifetime of the original Promise.
@@ -188,13 +199,13 @@ let _computedKey1 = _computedKey;
         }
     }
     constructor(arg){
-        /** INSTANCE IMPLEMENTATION */ /** The promise shadowed by this Unpromise<T>  */ _define_property._(this, "promise", void 0);
+        /** INSTANCE IMPLEMENTATION */ /** The promise shadowed by this Unpromise<T>  */ _define_property(this, "promise", void 0);
         /** Promises expecting eventual settlement (unless unsubscribed first). This list is deleted
-   * after the original promise settles - no further notifications will be issued. */ _define_property._(this, "subscribers", []);
+   * after the original promise settles - no further notifications will be issued. */ _define_property(this, "subscribers", []);
         /** The Promise's settlement (recorded when it fulfils or rejects). This is consulted when
    * calling .subscribe() .then() .catch() .finally() to see if an immediately-resolving Promise
-   * can be returned, and therefore subscription can be bypassed. */ _define_property._(this, "settlement", null);
-        /** TOSTRING SUPPORT */ _define_property._(this, _computedKey1, "Unpromise");
+   * can be returned, and therefore subscription can be bypassed. */ _define_property(this, "settlement", null);
+        /** TOSTRING SUPPORT */ _define_property(this, _computedKey1, "Unpromise");
         // handle either a Promise or a Promise executor function
         if (typeof arg === "function") {
             this.promise = new Promise(arg);

package/dist/vendor/unpromise/unpromise.mjs

@@ -1,5 +1,16 @@
-import { _ as _define_property } from '../../node_modules/.pnpm/@swc_helpers@0.5.13/node_modules/@swc/helpers/esm/_define_property.mjs';
-
+/* eslint-disable @typescript-eslint/unbound-method */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 var _computedKey;
 /** Memory safe (weakmapped) cache of the ProxyPromise for each Promise,
  * which is retained for the lifetime of the original Promise.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-rc.645+b25f4f627",
+  "version": "11.0.0-rc.657+7a369faa3",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -139,9 +139,8 @@
     "rollup": "^4.24.4",
     "superjson": "^1.12.4",
     "superstruct": "^2.0.0",
-    "tslib": "^2.8.1",
     "tsx": "^4.0.0",
-    "typescript": "^5.6.2",
+    "typescript": "^5.7.0",
     "valibot": "^0.42.0",
     "ws": "^8.0.0",
     "yup": "^1.0.0",
@@ -153,5 +152,5 @@
   "peerDependencies": {
     "typescript": ">=5.6.2"
   },
-  "gitHead": "b25f4f627ed3ffa6b2180b1b22a629d7486f6f55"
+  "gitHead": "7a369faa3db8c59f694397c15f589b72ee0919b5"
 }

package/src/adapters/ws.ts

@@ -33,6 +33,8 @@ import {
   run,
   type MaybePromise,
 } from '../unstable-core-do-not-import';
+// eslint-disable-next-line no-restricted-imports
+import { iteratorResource } from '../unstable-core-do-not-import/stream/utils/asyncIterable';
 import { Unpromise } from '../vendor/unpromise';
 import { createURL, type NodeHTTPCreateContextFnOptions } from './node-http';
 
@@ -275,14 +277,12 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
           ? observableToAsyncIterable(result, abortController.signal)
           : result;
 
-        const iterator: AsyncIterator<unknown> =
-          iterable[Symbol.asyncIterator]();
-
-        const abortPromise = new Promise<'abort'>((resolve) => {
-          abortController.signal.onabort = () => resolve('abort');
-        });
-
         run(async () => {
+          await using iterator = iteratorResource(iterable);
+
+          const abortPromise = new Promise<'abort'>((resolve) => {
+            abortController.signal.onabort = () => resolve('abort');
+          });
           // We need those declarations outside the loop for garbage collection reasons. If they
           // were declared inside, they would not be freed until the next value is present.
           let next:
@@ -349,7 +349,6 @@ export function getWSConnectionHandler<TRouter extends AnyRouter>(
             result = null;
           }
 
-          await iterator.return?.();
           respond({
             id,
             jsonrpc,

package/src/unstable-core-do-not-import/http/resolveResponse.ts

@@ -25,15 +25,9 @@ import type {
 } from './types';
 
 function errorToAsyncIterable(err: TRPCError): AsyncIterable<never> {
-  return {
-    [Symbol.asyncIterator]: () => {
-      return {
-        next() {
-          throw err;
-        },
-      };
-    },
-  };
+  return run(async function* () {
+    throw err;
+  });
 }
 type HTTPMethods =
   | 'GET'

package/src/unstable-core-do-not-import/stream/jsonl.ts

@@ -1,7 +1,9 @@
 import { Unpromise } from '../../vendor/unpromise';
 import { isAsyncIterable, isFunction, isObject, run } from '../utils';
+import { iteratorResource } from './utils/asyncIterable';
 import type { Deferred } from './utils/createDeferred';
 import { createDeferred } from './utils/createDeferred';
+import { makeAsyncResource, makeResource } from './utils/disposable';
 import { readableStreamFrom } from './utils/readableStreamFrom';
 
 /**
@@ -126,10 +128,15 @@ async function* createBatchStreamProducer(
   let counter = 0 as ChunkIndex;
   const placeholder = 0 as PlaceholderValue;
 
-  const queue = new Set<{
-    iterator: AsyncIterator<ChunkData, ChunkData>;
-    nextPromise: Promise<IteratorResult<ChunkData, ChunkData>>;
-  }>();
+  await using queue = makeAsyncResource(
+    new Set<{
+      iterator: AsyncIterator<ChunkData, ChunkData>;
+      nextPromise: Promise<IteratorResult<ChunkData, ChunkData>>;
+    }>(),
+    async () => {
+      await Promise.all(Array.from(queue).map((it) => it.iterator.return?.()));
+    },
+  );
   function registerAsync(
     callback: (idx: ChunkIndex) => AsyncIterable<ChunkData, ChunkData>,
   ) {
@@ -183,7 +190,7 @@ async function* createBatchStreamProducer(
       if (error) {
         throw error;
       }
-      const iterator = iterable[Symbol.asyncIterator]();
+      await using iterator = iteratorResource(iterable);
 
       try {
         while (true) {
@@ -204,8 +211,6 @@ async function* createBatchStreamProducer(
           ASYNC_ITERABLE_STATUS_ERROR,
           opts.formatError?.({ error: cause, path }),
         ];
-      } finally {
-        await iterator.return?.();
       }
     });
   }
@@ -258,37 +263,28 @@ async function* createBatchStreamProducer(
     return [[newObj], ...asyncValues];
   }
 
-  try {
-    const newHead: Head = {};
-    for (const [key, item] of Object.entries(data)) {
-      newHead[key] = encode(item, [key]);
-    }
+  const newHead: Head = {};
+  for (const [key, item] of Object.entries(data)) {
+    newHead[key] = encode(item, [key]);
+  }
 
-    yield newHead;
+  yield newHead;
 
-    // Process all async iterables in parallel by racing their next values
-    while (queue.size > 0) {
-      // Race all iterators to get the next value from any of them
-      const [entry, res] = await Unpromise.race(
-        Array.from(queue).map(
-          async (it) => [it, await it.nextPromise] as const,
-        ),
-      );
+  // Process all async iterables in parallel by racing their next values
+  while (queue.size > 0) {
+    // Race all iterators to get the next value from any of them
+    const [entry, res] = await Unpromise.race(
+      Array.from(queue).map(async (it) => [it, await it.nextPromise] as const),
+    );
 
-      yield res.value;
+    yield res.value;
 
-      // Remove current iterator and re-add if not done
-      queue.delete(entry);
-      if (!res.done) {
-        entry.nextPromise = entry.iterator.next();
-        queue.add(entry);
-      }
+    // Remove current iterator and re-add if not done
+    queue.delete(entry);
+    if (!res.done) {
+      entry.nextPromise = entry.iterator.next();
+      queue.add(entry);
     }
-  } finally {
-    // Properly clean up any remaining iterators by calling return()
-    // Ensures resources are released if the loop exits early (e.g. due to error)
-    await Promise.all(Array.from(queue).map((it) => it.iterator.return?.()));
-    queue.clear();
   }
 }
 /**
@@ -419,40 +415,14 @@ function createConsumerStream<THead>(
  */
 type ControllerChunk = ChunkData | StreamInterruptedError;
 
-/**
- * Interface for a controller that can enqueue chunks and be closed
- */
-/**
- * Interface for controlling a stream's lifecycle and data flow
- */
-interface StreamController {
-  /**
-   * Enqueues a chunk of data or error into the stream
-   * @param chunk The data chunk or error to enqueue
-   */
-  enqueue: (chunk: ControllerChunk) => void;
-
-  /**
-   * Closes the stream and prevents further data from being enqueued
-   */
-  close: () => void;
-
-  /**
-   * Whether the stream has been closed
-   */
-  closed: boolean;
-
-  /**
-   * Gets a reader for consuming the stream's data
-   */
-  getReader: () => ReadableStreamDefaultReader<ControllerChunk>;
-}
-
 /**
  * Creates a handler for managing stream controllers and their lifecycle
  */
 function createStreamsManager(abortController: AbortController) {
-  const controllerMap = new Map<ChunkIndex, StreamController>();
+  const controllerMap = new Map<
+    ChunkIndex,
+    ReturnType<typeof createStreamController>
+  >();
 
   /**
    * Checks if there are no pending controllers or deferred promises
@@ -461,63 +431,79 @@ function createStreamsManager(abortController: AbortController) {
     return Array.from(controllerMap.values()).every((c) => c.closed);
   }
 
-  return {
-    getOrCreate(chunkId: ChunkIndex): StreamController {
-      const c = controllerMap.get(chunkId);
-      if (c) {
-        return c;
-      }
+  /**
+   * Creates a stream controller
+   */
+  function createStreamController() {
+    let originalController: ReadableStreamDefaultController<ControllerChunk>;
+    const stream = new ReadableStream<ControllerChunk>({
+      start(controller) {
+        originalController = controller;
+      },
+    });
 
-      let originalController: ReadableStreamDefaultController<ControllerChunk>;
-      const stream = new ReadableStream<ControllerChunk>({
-        start(controller) {
-          originalController = controller;
-        },
-      });
+    const streamController = {
+      enqueue: (v: ControllerChunk) => originalController.enqueue(v),
+      close: () => {
+        originalController.close();
+
+        // mark as closed and remove methods
+        Object.assign(streamController, {
+          closed: true,
+          close: () => {
+            // noop
+          },
+          enqueue: () => {
+            // noop
+          },
+          getReaderResource: null,
+        });
 
-      const controllerEsque: StreamController = {
-        enqueue: (v) => originalController.enqueue(v as ChunkData),
-        close: () => {
-          originalController.close();
-
-          // mark as closed and remove methods
-          Object.assign(controllerEsque, {
-            closed: true,
-            close: () => {
-              // noop
-            },
-            enqueue: () => {
-              // noop
-            },
-          });
+        if (isEmpty()) {
+          abortController.abort();
+        }
+      },
+      closed: false,
+      getReaderResource: () => {
+        const reader = stream.getReader();
 
-          if (isEmpty()) {
-            abortController.abort();
-          }
-        },
-        closed: false,
-        getReader: () => stream.getReader(),
-      };
-      controllerMap.set(chunkId, controllerEsque);
+        return makeResource(reader, () => {
+          reader.releaseLock();
+          streamController.close();
+        });
+      },
+    };
 
-      return controllerEsque;
-    },
+    return streamController;
+  }
 
-    /**
-     * Check if there are no pending controllers
-     **/
-    isEmpty,
+  /**
+   * Gets or creates a stream controller
+   */
+  function getOrCreate(chunkId: ChunkIndex) {
+    let c = controllerMap.get(chunkId);
+    if (!c) {
+      c = createStreamController();
+      controllerMap.set(chunkId, c);
+    }
+    return c;
+  }
 
-    /**
-     * Cancels all pending controllers and rejects deferred promises
-     */
-    cancelAll(reason: unknown) {
-      const error = new StreamInterruptedError(reason);
-      for (const controller of controllerMap.values()) {
-        controller.enqueue(error);
-        controller.close();
-      }
-    },
+  /**
+   * Cancels all pending controllers and rejects deferred promises
+   */
+  function cancelAll(reason: unknown) {
+    const error = new StreamInterruptedError(reason);
+    for (const controller of controllerMap.values()) {
+      controller.enqueue(error);
+      controller.close();
+    }
+  }
+
+  return {
+    getOrCreate,
+    isEmpty,
+    cancelAll,
   };
 }
 
@@ -559,58 +545,47 @@ export async function jsonlStreamConsumer<THead>(opts: {
     switch (type) {
       case CHUNK_VALUE_TYPE_PROMISE: {
         return run(async () => {
-          const reader = controller.getReader();
-          try {
+          using reader = controller.getReaderResource();
+
+          const { value } = await reader.read();
+          if (value instanceof StreamInterruptedError) {
+            throw value;
+          }
+          const [_chunkId, status, data] = value as PromiseChunk;
+          switch (status) {
+            case PROMISE_STATUS_FULFILLED:
+              return decode(data);
+            case PROMISE_STATUS_REJECTED:
+              throw opts.formatError?.({ error: data }) ?? new AsyncError(data);
+          }
+        });
+      }
+      case CHUNK_VALUE_TYPE_ASYNC_ITERABLE: {
+        return run(async function* () {
+          using reader = controller.getReaderResource();
+
+          while (true) {
             const { value } = await reader.read();
             if (value instanceof StreamInterruptedError) {
               throw value;
             }
-            const [_chunkId, status, data] = value as PromiseChunk;
+
+            const [_chunkId, status, data] = value as IterableChunk;
+
             switch (status) {
-              case PROMISE_STATUS_FULFILLED:
+              case ASYNC_ITERABLE_STATUS_YIELD:
+                yield decode(data);
+                break;
+              case ASYNC_ITERABLE_STATUS_RETURN:
                 return decode(data);
-              case PROMISE_STATUS_REJECTED:
+              case ASYNC_ITERABLE_STATUS_ERROR:
                 throw (
                   opts.formatError?.({ error: data }) ?? new AsyncError(data)
                 );
             }
-          } finally {
-            reader.releaseLock();
-            controller.close();
           }
         });
       }
-      case CHUNK_VALUE_TYPE_ASYNC_ITERABLE: {
-        async function* generator() {
-          const reader = controller.getReader();
-          try {
-            while (true) {
-              const { value } = await reader.read();
-              if (value instanceof StreamInterruptedError) {
-                throw value;
-              }
-
-              const [_chunkId, status, data] = value as IterableChunk;
-
-              switch (status) {
-                case ASYNC_ITERABLE_STATUS_YIELD:
-                  yield decode(data);
-                  break;
-                case ASYNC_ITERABLE_STATUS_RETURN:
-                  return decode(data);
-                case ASYNC_ITERABLE_STATUS_ERROR:
-                  throw (
-                    opts.formatError?.({ error: data }) ?? new AsyncError(data)
-                  );
-              }
-            }
-          } finally {
-            reader.releaseLock();
-            controller.close();
-          }
-        }
-        return generator();
-      }
     }
   }