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

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

@@ -2,12 +2,17 @@ import { Unpromise } from '../../vendor/unpromise';
 import { getTRPCErrorFromUnknown } from '../error/TRPCError';
 import { isAbortError } from '../http/isAbortError';
 import type { MaybePromise } from '../types';
-import { identity } from '../utils';
+import { identity, run } from '../utils';
 import type { EventSourceLike } from './sse.types';
 import type { inferTrackedOutput } from './tracked';
 import { isTrackedEnvelope } from './tracked';
 import { takeWithGrace, withMaxDuration } from './utils/asyncIterable';
+import { makeAsyncResource } from './utils/disposable';
 import { readableStreamFrom } from './utils/readableStreamFrom';
+import {
+  disposablePromiseTimerResult,
+  timerResource,
+} from './utils/timerResource';
 import { PING_SYM, withPing } from './utils/withPing';
 
 type Serialize = (value: any) => any;
@@ -260,21 +265,10 @@ async function withTimeout<T>(opts: {
   timeoutMs: number;
   onTimeout: () => Promise<NoInfer<T>>;
 }): Promise<T> {
-  let timeoutId: ReturnType<typeof setTimeout>;
+  using timeoutPromise = timerResource(opts.timeoutMs);
+  const res = await Unpromise.race([opts.promise, timeoutPromise.start()]);
 
-  const timeoutPromise = new Promise<null>((resolve) => {
-    timeoutId = setTimeout(() => {
-      resolve(null);
-    }, opts.timeoutMs);
-  });
-  let res;
-  try {
-    res = await Unpromise.race([opts.promise, timeoutPromise]);
-  } finally {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    clearTimeout(timeoutId!);
-  }
-  if (res === null) {
+  if (res === disposablePromiseTimerResult) {
     return await opts.onTimeout();
   }
   return res;
@@ -381,76 +375,67 @@ export function sseStreamConsumer<TConfig extends ConsumerConfig>(
       },
     });
 
-  const getNewStreamAndReader = () => {
-    const stream = createStream();
-    const reader = stream.getReader();
+  const getStreamResource = () => {
+    let stream = createStream();
+    let reader = stream.getReader();
+
+    async function dispose() {
+      await reader.cancel();
+      _es = null;
+    }
 
-    return {
-      reader,
-      cancel: () => {
-        reader.releaseLock();
-        return stream.cancel();
+    return makeAsyncResource(
+      {
+        read() {
+          return reader.read();
+        },
+        async recreate() {
+          await dispose();
+
+          stream = createStream();
+          reader = stream.getReader();
+        },
       },
-    };
+      dispose,
+    );
   };
-  return {
-    [Symbol.asyncIterator]() {
-      let stream = getNewStreamAndReader();
-
-      const iterator: AsyncIterator<ConsumerStreamResult<TConfig>> = {
-        async next() {
-          let promise = stream.reader.read();
-
-          const timeoutMs = clientOptions.reconnectAfterInactivityMs;
-          if (timeoutMs) {
-            promise = withTimeout({
-              promise,
-              timeoutMs,
-              onTimeout: async () => {
-                const res: Awaited<typeof promise> = {
-                  value: {
-                    type: 'timeout',
-                    ms: timeoutMs,
-                    eventSource: _es,
-                  },
-                  done: false,
-                };
-                // Close and release old reader
-                await stream.cancel();
-
-                // Create new reader
-                stream = getNewStreamAndReader();
-
-                return res;
+
+  return run(async function* () {
+    await using stream = getStreamResource();
+
+    while (true) {
+      let promise = stream.read();
+
+      const timeoutMs = clientOptions.reconnectAfterInactivityMs;
+      if (timeoutMs) {
+        promise = withTimeout({
+          promise,
+          timeoutMs,
+          onTimeout: async () => {
+            const res: Awaited<typeof promise> = {
+              value: {
+                type: 'timeout',
+                ms: timeoutMs,
+                eventSource: _es,
               },
-            });
-          }
+              done: false,
+            };
+            // Close and release old reader
+            await stream.recreate();
 
-          const result = await promise;
+            return res;
+          },
+        });
+      }
 
-          // console.debug('result', result, 'done', result.done);
-          if (result.done) {
-            return {
-              value: result.value,
-              done: true,
-            };
-          }
-          return {
-            value: result.value,
-            done: false,
-          };
-        },
-        async return() {
-          await stream.cancel();
-          return {
-            value: undefined,
-            done: true,
-          };
-        },
-      };
-      return iterator;
-    },
-  };
+      const result = await promise;
+
+      if (result.done) {
+        return result.value;
+      }
+      yield result.value;
+    }
+  });
 }
 
 export const sseHeaders = {

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

@@ -1,6 +1,16 @@
 import { Unpromise } from '../../../vendor/unpromise';
+import { makeAsyncResource } from './disposable';
 import { disposablePromiseTimerResult, timerResource } from './timerResource';
 
+export function iteratorResource<TYield, TReturn, TNext>(
+  iterable: AsyncIterable<TYield, TReturn, TNext>,
+): AsyncIterator<TYield, TReturn, TNext> & AsyncDisposable {
+  const iterator = iterable[Symbol.asyncIterator]();
+
+  return makeAsyncResource(iterator, async () => {
+    await iterator.return?.();
+  });
+}
 /**
  * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
  */
@@ -8,34 +18,29 @@ export async function* withMaxDuration<T>(
   iterable: AsyncIterable<T>,
   opts: { maxDurationMs: number },
 ): AsyncGenerator<T> {
-  const iterator = iterable[Symbol.asyncIterator]();
+  await using iterator = iteratorResource(iterable);
+
+  using timer = timerResource(opts.maxDurationMs);
 
-  const timer = timerResource(opts.maxDurationMs);
-  try {
-    const timerPromise = timer.start();
+  const timerPromise = timer.start();
 
-    // declaration outside the loop for garbage collection reasons
-    let result: null | IteratorResult<T> | typeof disposablePromiseTimerResult;
+  // declaration outside the loop for garbage collection reasons
+  let result: null | IteratorResult<T> | typeof disposablePromiseTimerResult;
 
-    while (true) {
-      result = await Unpromise.race([iterator.next(), timerPromise]);
-      if (result === disposablePromiseTimerResult) {
-        // cancelled due to timeout
+  while (true) {
+    result = await Unpromise.race([iterator.next(), timerPromise]);
+    if (result === disposablePromiseTimerResult) {
+      // cancelled due to timeout
 
-        const res = await iterator.return?.();
-        return res?.value;
-      }
-      if (result.done) {
-        return result;
-      }
-      yield result.value;
-      // free up reference for garbage collection
-      result = null;
+      const res = await iterator.return?.();
+      return res?.value;
+    }
+    if (result.done) {
+      return result;
     }
-  } finally {
-    // dispose timer
-    // Shouldn't be needed, but build breaks with `using` keyword
-    timer[Symbol.dispose]();
+    yield result.value;
+    // free up reference for garbage collection
+    result = null;
   }
 }
 
@@ -51,37 +56,34 @@ export async function* takeWithGrace<T>(
     gracePeriodMs: number;
   },
 ): AsyncGenerator<T> {
-  const iterator = iterable[Symbol.asyncIterator]();
+  await using iterator = iteratorResource(iterable);
 
   // declaration outside the loop for garbage collection reasons
   let result: null | IteratorResult<T> | typeof disposablePromiseTimerResult;
 
-  const timer = timerResource(opts.gracePeriodMs);
-  try {
-    let count = opts.count;
+  using timer = timerResource(opts.gracePeriodMs);
 
-    let timerPromise = new Promise<typeof disposablePromiseTimerResult>(() => {
-      // never resolves
-    });
+  let count = opts.count;
 
-    while (true) {
-      result = await Unpromise.race([iterator.next(), timerPromise]);
-      if (result === disposablePromiseTimerResult) {
-        // cancelled
-        const res = await iterator.return?.();
-        return res?.value;
-      }
-      if (result.done) {
-        return result.value;
-      }
-      yield result.value;
-      if (--count === 0) {
-        timerPromise = timer.start();
-      }
-      // free up reference for garbage collection
-      result = null;
+  let timerPromise = new Promise<typeof disposablePromiseTimerResult>(() => {
+    // never resolves
+  });
+
+  while (true) {
+    result = await Unpromise.race([iterator.next(), timerPromise]);
+    if (result === disposablePromiseTimerResult) {
+      // cancelled
+      const res = await iterator.return?.();
+      return res?.value;
+    }
+    if (result.done) {
+      return result.value;
+    }
+    yield result.value;
+    if (--count === 0) {
+      timerPromise = timer.start();
     }
-  } finally {
-    timer[Symbol.dispose]();
+    // free up reference for garbage collection
+    result = null;
   }
 }

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

@@ -0,0 +1,52 @@
+// @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+Symbol.dispose ??= Symbol();
+
+// @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+Symbol.asyncDispose ??= Symbol();
+
+/**
+ * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
+ * The returned object is the original value augmented with a Symbol.dispose method.
+ * @param thing The value to make disposable
+ * @param dispose Function to call when disposing the resource
+ * @returns The original value with Symbol.dispose method added
+ */
+export function makeResource<T>(thing: T, dispose: () => void): T & Disposable {
+  const it = thing as T & Disposable;
+
+  // eslint-disable-next-line no-restricted-syntax
+  if (it[Symbol.dispose]) {
+    throw new Error('Symbol.dispose already exists');
+  }
+
+  // eslint-disable-next-line no-restricted-syntax
+  it[Symbol.dispose] = dispose;
+
+  return it;
+}
+
+/**
+ * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
+ * The returned object is the original value augmented with a Symbol.asyncDispose method.
+ * @param thing The value to make async disposable
+ * @param dispose Async function to call when disposing the resource
+ * @returns The original value with Symbol.asyncDispose method added
+ */
+export function makeAsyncResource<T>(
+  thing: T,
+  dispose: () => Promise<void>,
+): T & AsyncDisposable {
+  const it = thing as T & AsyncDisposable;
+
+  // eslint-disable-next-line no-restricted-syntax
+  if (it[Symbol.asyncDispose]) {
+    throw new Error('Symbol.asyncDispose already exists');
+  }
+
+  // eslint-disable-next-line no-restricted-syntax
+  it[Symbol.asyncDispose] = dispose;
+
+  return it;
+}

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

@@ -1,27 +1,29 @@
-// @ts-expect-error polyfill
-Symbol.dispose ??= Symbol();
+import { makeResource } from './disposable';
 
 export const disposablePromiseTimerResult = Symbol();
+
 export function timerResource(ms: number) {
   let timer: ReturnType<typeof setTimeout> | null = null;
 
-  return {
-    start() {
-      if (timer) {
-        throw new Error('Timer already started');
-      }
+  return makeResource(
+    {
+      start() {
+        if (timer) {
+          throw new Error('Timer already started');
+        }
 
-      const promise = new Promise<typeof disposablePromiseTimerResult>(
-        (resolve) => {
-          timer = setTimeout(() => resolve(disposablePromiseTimerResult), ms);
-        },
-      );
-      return promise;
+        const promise = new Promise<typeof disposablePromiseTimerResult>(
+          (resolve) => {
+            timer = setTimeout(() => resolve(disposablePromiseTimerResult), ms);
+          },
+        );
+        return promise;
+      },
     },
-    [Symbol.dispose]: () => {
+    () => {
       if (timer) {
         clearTimeout(timer);
       }
     },
-  };
+  );
 }

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

@@ -1,4 +1,5 @@
 import { Unpromise } from '../../../vendor/unpromise';
+import { iteratorResource } from './asyncIterable';
 import { disposablePromiseTimerResult, timerResource } from './timerResource';
 
 export const PING_SYM = Symbol('ping');
@@ -11,7 +12,8 @@ export async function* withPing<TValue>(
   iterable: AsyncIterable<TValue>,
   pingIntervalMs: number,
 ): AsyncGenerator<TValue | typeof PING_SYM> {
-  const iterator = iterable[Symbol.asyncIterator]();
+  await using iterator = iteratorResource(iterable);
+
   // declaration outside the loop for garbage collection reasons
   let result:
     | null
@@ -19,30 +21,27 @@ export async function* withPing<TValue>(
     | typeof disposablePromiseTimerResult;
 
   let nextPromise = iterator.next();
+
   while (true) {
-    const pingPromise = timerResource(pingIntervalMs);
+    using pingPromise = timerResource(pingIntervalMs);
 
-    try {
-      result = await Unpromise.race([nextPromise, pingPromise.start()]);
+    result = await Unpromise.race([nextPromise, pingPromise.start()]);
 
-      if (result === disposablePromiseTimerResult) {
-        // cancelled
+    if (result === disposablePromiseTimerResult) {
+      // cancelled
 
-        yield PING_SYM;
-        continue;
-      }
+      yield PING_SYM;
+      continue;
+    }
 
-      if (result.done) {
-        return result.value;
-      }
+    if (result.done) {
+      return result.value;
+    }
 
-      nextPromise = iterator.next();
-      yield result.value;
+    nextPromise = iterator.next();
+    yield result.value;
 
-      // free up reference for garbage collection
-      result = null;
-    } finally {
-      pingPromise[Symbol.dispose]();
-    }
+    // free up reference for garbage collection
+    result = null;
   }
 }

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

@@ -36,6 +36,7 @@ export * from './unstable-core-do-not-import/stream/sse.types';
 export * from './unstable-core-do-not-import/stream/sse';
 export * from './unstable-core-do-not-import/stream/tracked';
 export * from './unstable-core-do-not-import/stream/utils/createDeferred';
+export * from './unstable-core-do-not-import/stream/utils/disposable';
 export * from './unstable-core-do-not-import/transformer';
 export * from './unstable-core-do-not-import/types';
 export * from './unstable-core-do-not-import/utils';

package/dist/node_modules/.pnpm/@swc_helpers@0.5.13/node_modules/@swc/helpers/esm/_define_property.js

@@ -1,11 +0,0 @@
-'use strict';
-
-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;
-}
-
-exports._ = _define_property;

package/dist/node_modules/.pnpm/@swc_helpers@0.5.13/node_modules/@swc/helpers/esm/_define_property.mjs

@@ -1,9 +0,0 @@
-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;
-}
-
-export { _define_property as _ };