@trpc/server 11.0.0-rc.621 → 11.0.0-rc.632

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

@@ -1,40 +1,47 @@
 import { Unpromise } from '../../../vendor/unpromise';
-import { noop } from '../../utils';
-import { createPromiseTimer } from './promiseTimer';
+import {
+  disposablePromiseTimer,
+  disposablePromiseTimerResult,
+} from './disposablePromiseTimer';
 
 /**
- * Derives a new {@link AsyncGenerator} based of {@link iterable}, that automatically stops with the
- * passed {@link cancel} promise.
+ * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
  */
-export async function* withCancel<T>(
+export async function* withMaxDuration<T>(
   iterable: AsyncIterable<T>,
-  cancel: Promise<unknown>,
+  opts: { maxDurationMs: number; abortCtrl: AbortController },
 ): AsyncGenerator<T> {
-  const cancelPromise = cancel.then(noop);
   const iterator = iterable[Symbol.asyncIterator]();
-  // declaration outside the loop for garbage collection reasons
-  let result: null | IteratorResult<T> | void;
-  while (true) {
-    result = await Unpromise.race([iterator.next(), cancelPromise]);
-    if (result == null) {
-      await iterator.return?.();
-      break;
-    }
-    if (result.done) {
-      break;
+
+  const timer = disposablePromiseTimer(opts.maxDurationMs);
+  try {
+    const timerPromise = timer.start();
+
+    // 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
+        opts.abortCtrl.abort();
+        const res = await iterator.return?.();
+        return res?.value;
+      }
+      if (result.done) {
+        return result;
+      }
+      yield result.value;
+      // free up reference for garbage collection
+      result = null;
     }
-    yield result.value;
-    // free up reference for garbage collection
-    result = null;
+  } finally {
+    // dispose timer
+    // Shouldn't be needed, but build breaks with `using` keyword
+    timer[Symbol.dispose]();
   }
 }
 
-interface TakeWithGraceOptions {
-  count: number;
-  gracePeriodMs: number;
-  onCancel: () => void;
-}
-
 /**
  * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields its first
  * {@link count} values. Then, a grace period of {@link gracePeriodMs} is started in which further
@@ -42,31 +49,45 @@ interface TakeWithGraceOptions {
  */
 export async function* takeWithGrace<T>(
   iterable: AsyncIterable<T>,
-  { count, gracePeriodMs, onCancel }: TakeWithGraceOptions,
+  opts: {
+    count: number;
+    gracePeriodMs: number;
+    abortCtrl: AbortController;
+  },
 ): AsyncGenerator<T> {
   const iterator = iterable[Symbol.asyncIterator]();
-  const timer = createPromiseTimer(gracePeriodMs);
+
+  // declaration outside the loop for garbage collection reasons
+  let result: null | IteratorResult<T> | typeof disposablePromiseTimerResult;
+
+  const timer = disposablePromiseTimer(opts.gracePeriodMs);
   try {
-    // declaration outside the loop for garbage collection reasons
-    let result: null | IteratorResult<T> | void;
+    let count = opts.count;
+
+    let timerPromise = new Promise<typeof disposablePromiseTimerResult>(() => {
+      // never resolves
+    });
+
     while (true) {
-      result = await Unpromise.race([iterator.next(), timer.promise]);
-      if (result == null) {
+      result = await Unpromise.race([iterator.next(), timerPromise]);
+      if (result === disposablePromiseTimerResult) {
         // cancelled
-        await iterator.return?.();
-        break;
+        const res = await iterator.return?.();
+        return res?.value;
       }
       if (result.done) {
-        break;
+        return result.value;
       }
       yield result.value;
       if (--count === 0) {
-        timer.start().promise.then(onCancel, noop);
+        timerPromise = timer.start();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        timerPromise.then(() => opts.abortCtrl.abort());
       }
       // free up reference for garbage collection
       result = null;
     }
   } finally {
-    timer.clear();
+    timer[Symbol.dispose]();
   }
 }

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

@@ -1,8 +1,3 @@
-import { createDeferred } from './createDeferred';
-
-// ---------- utils
-
-const cancelledStreamSymbol = Symbol();
 /**
  * One-off readable stream
  */
@@ -10,14 +5,12 @@ export function createReadableStream<TValue = unknown>() {
   let controller: ReadableStreamDefaultController<TValue> =
     null as unknown as ReadableStreamDefaultController<TValue>;
 
-  const deferred = createDeferred<typeof cancelledStreamSymbol>();
   let cancelled = false;
   const readable = new ReadableStream<TValue>({
     start(c) {
       controller = c;
     },
     cancel() {
-      deferred.resolve(cancelledStreamSymbol);
       cancelled = true;
     },
   });
@@ -25,14 +18,8 @@ export function createReadableStream<TValue = unknown>() {
   return {
     readable,
     controller,
-    cancelledPromise: deferred.promise,
     cancelled() {
       return cancelled;
     },
   } as const;
 }
-export function isCancelledStreamResult(
-  v: unknown,
-): v is typeof cancelledStreamSymbol {
-  return v === cancelledStreamSymbol;
-}

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

@@ -0,0 +1,27 @@
+// @ts-expect-error polyfill
+Symbol.dispose ??= Symbol();
+
+export const disposablePromiseTimerResult = Symbol();
+export function disposablePromiseTimer(ms: number) {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  return {
+    start() {
+      if (timer) {
+        throw new Error('Timer already started');
+      }
+
+      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,13 +1,11 @@
 import { Unpromise } from '../../../vendor/unpromise';
-import { createPromiseTimer } from './promiseTimer';
+import {
+  disposablePromiseTimer,
+  disposablePromiseTimerResult,
+} from './disposablePromiseTimer';
 
 export const PING_SYM = Symbol('ping');
 
-const PING_RESULT: IteratorResult<typeof PING_SYM> = {
-  value: PING_SYM,
-  done: false,
-};
-
 /**
  * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields {@link PING_SYM}
  * whenever no value has been yielded for {@link pingIntervalMs}.
@@ -16,24 +14,38 @@ export async function* withPing<TValue>(
   iterable: AsyncIterable<TValue>,
   pingIntervalMs: number,
 ): AsyncGenerator<TValue | typeof PING_SYM> {
-  const timer = createPromiseTimer(pingIntervalMs);
   const iterator = iterable[Symbol.asyncIterator]();
   // declaration outside the loop for garbage collection reasons
-  let result: null | IteratorResult<TValue | typeof PING_SYM>;
+  let result:
+    | null
+    | IteratorResult<TValue>
+    | typeof disposablePromiseTimerResult;
+
+  let nextPromise = iterator.next();
   while (true) {
-    const nextPromise = iterator.next();
-    const pingPromise = timer.start().promise.then(() => PING_RESULT);
+    const pingPromise = disposablePromiseTimer(pingIntervalMs);
+
     try {
-      result = await Unpromise.race([nextPromise, pingPromise]);
+      result = await Unpromise.race([nextPromise, pingPromise.start()]);
+
+      if (result === disposablePromiseTimerResult) {
+        // cancelled
+
+        yield PING_SYM;
+        continue;
+      }
+
+      if (result.done) {
+        return result.value;
+      }
+
+      nextPromise = iterator.next();
+      yield result.value;
+
+      // free up reference for garbage collection
+      result = null;
     } finally {
-      timer.clear();
-    }
-    if (result.done) {
-      return result.value;
+      pingPromise[Symbol.dispose]();
     }
-    yield result.value;
-    timer.reset();
-    // free up reference for garbage collection
-    result = null;
   }
 }

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

@@ -0,0 +1,93 @@
+// Callback function type that is called when a collection is drained
+type OnDrain = () => void;
+
+// Interface for objects that can be activated
+export interface RefCount {
+  activate(): void;
+}
+
+// Map type that includes ref counting capabilities
+export interface RefCountMap<TKey, TValue>
+  extends Map<TKey, TValue>,
+    RefCount {}
+
+// Set type that includes ref counting capabilities
+export interface RefCountSet<TValue> extends Set<TValue>, RefCount {}
+
+/**
+ * Adds reference counting capabilities to a Map or Set collection.
+ * The collection can be activated, after which it will trigger a drain callback when emptied.
+ * Once drained, the collection cannot be modified further.
+ */
+export function withRefCount<TKey, TValue>(
+  map: Map<TKey, TValue>,
+  onDrain: OnDrain,
+): RefCountMap<TKey, TValue>;
+export function withRefCount<TValue>(
+  set: Set<TValue>,
+  onDrain: OnDrain,
+): RefCountSet<TValue>;
+export function withRefCount(
+  _obj: Set<any> | Map<any, any>,
+  onDrain: OnDrain,
+): RefCountMap<any, any> & RefCountSet<any> {
+  const obj = _obj as any;
+
+  // Track whether the collection has been drained
+  let drained = false;
+  // Track whether the collection has been activated
+  let active = false;
+
+  // Check if collection should be drained (empty and active)
+  const checkDrain = () => {
+    if (!drained && active && obj.size === 0) {
+      onDrain();
+      drained = true;
+    }
+  };
+
+  // Create proxy to intercept collection operations
+  return new Proxy(obj, {
+    get(_, prop) {
+      // Handle activation
+      if (prop === 'activate') {
+        return () => {
+          active = true;
+          checkDrain();
+        };
+      }
+
+      // Handle adding items - prevent if already drained
+      if (prop === 'set' || prop === 'add') {
+        return (...args: any[]) => {
+          if (drained) {
+            throw new Error('Already drained');
+          }
+
+          return obj[prop](...args);
+        };
+      }
+
+      // Handle removing items - check if should drain after
+      if (prop === 'delete' || prop === 'clear') {
+        return (...args: any[]) => {
+          try {
+            return obj[prop](...args);
+          } finally {
+            checkDrain();
+          }
+        };
+      }
+      // Pass through other method calls
+      const target = obj[prop];
+      if (typeof target === 'function') {
+        return (...args: any[]) => {
+          return obj[prop](...args);
+        };
+      }
+
+      // Pass through property access
+      return target;
+    },
+  }) as never as RefCountMap<any, any> & RefCountSet<any>;
+}

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

@@ -15,11 +15,11 @@ export * from './unstable-core-do-not-import/createProxy';
 export * from './unstable-core-do-not-import/error/formatter';
 export * from './unstable-core-do-not-import/error/getErrorShape';
 export * from './unstable-core-do-not-import/error/TRPCError';
-export * from './unstable-core-do-not-import/http/batchStreamFormatter';
 export * from './unstable-core-do-not-import/http/contentType';
 export * from './unstable-core-do-not-import/http/contentTypeParsers';
 export * from './unstable-core-do-not-import/http/formDataToObject';
 export * from './unstable-core-do-not-import/http/getHTTPStatusCode';
+export * from './unstable-core-do-not-import/http/isAbortError';
 export * from './unstable-core-do-not-import/http/parseConnectionParams';
 export * from './unstable-core-do-not-import/http/resolveResponse';
 export * from './unstable-core-do-not-import/http/types';
@@ -32,8 +32,8 @@ export * from './unstable-core-do-not-import/rootConfig';
 export * from './unstable-core-do-not-import/router';
 export * from './unstable-core-do-not-import/rpc';
 export * from './unstable-core-do-not-import/stream/jsonl';
-export * from './unstable-core-do-not-import/stream/sse';
 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/transformer';

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

@@ -1,24 +0,0 @@
-/**
- * Format a batch response as a line-delimited JSON stream
- * that the `unstable_httpBatchStreamLink` can parse:
- *
- * @example
- * ```ts
- * const formatter = getBatchStreamFormatter();
- * res.send(formatter(1, 'response #2'));
- * res.send(formatter(0, 'response #1'));
- * res.send(formatter.end());
- * ```
- *
- * Expected format:
- * ```json
- * {"1":"response #2"
- * ,"0":"response #1"
- * }
- * ```
- */
-export declare function getBatchStreamFormatter(): {
-    (index: number, string: string): string;
-    end(): string;
-};
-//# sourceMappingURL=batchStreamFormatter.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"batchStreamFormatter.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/http/batchStreamFormatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB;YAEd,MAAM,UAAU,MAAM;;EAO9C"}

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

@@ -1,32 +0,0 @@
-'use strict';
-
-/**
- * Format a batch response as a line-delimited JSON stream
- * that the `unstable_httpBatchStreamLink` can parse:
- *
- * @example
- * ```ts
- * const formatter = getBatchStreamFormatter();
- * res.send(formatter(1, 'response #2'));
- * res.send(formatter(0, 'response #1'));
- * res.send(formatter.end());
- * ```
- *
- * Expected format:
- * ```json
- * {"1":"response #2"
- * ,"0":"response #1"
- * }
- * ```
- */ function getBatchStreamFormatter() {
-    let first = true;
-    function format(index, string) {
-        const prefix = first ? '{' : ',';
-        first = false;
-        return `${prefix}"${index}":${string}\n`;
-    }
-    format.end = ()=>'}';
-    return format;
-}
-
-exports.getBatchStreamFormatter = getBatchStreamFormatter;

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

@@ -1,30 +0,0 @@
-/**
- * Format a batch response as a line-delimited JSON stream
- * that the `unstable_httpBatchStreamLink` can parse:
- *
- * @example
- * ```ts
- * const formatter = getBatchStreamFormatter();
- * res.send(formatter(1, 'response #2'));
- * res.send(formatter(0, 'response #1'));
- * res.send(formatter.end());
- * ```
- *
- * Expected format:
- * ```json
- * {"1":"response #2"
- * ,"0":"response #1"
- * }
- * ```
- */ function getBatchStreamFormatter() {
-    let first = true;
-    function format(index, string) {
-        const prefix = first ? '{' : ',';
-        first = false;
-        return `${prefix}"${index}":${string}\n`;
-    }
-    format.end = ()=>'}';
-    return format;
-}
-
-export { getBatchStreamFormatter };

package/dist/unstable-core-do-not-import/stream/utils/promiseTimer.d.ts

@@ -1,8 +0,0 @@
-export declare function createPromiseTimer(ms: number): {
-    readonly promise: Promise<void>;
-    start: () => PromiseTimer;
-    reset: () => PromiseTimer;
-    clear: () => PromiseTimer;
-};
-export type PromiseTimer = ReturnType<typeof createPromiseTimer>;
-//# sourceMappingURL=promiseTimer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"promiseTimer.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/promiseTimer.ts"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM;;iBAezB,YAAY;iBAQZ,YAAY;iBAMZ,YAAY;EAO/B;AACD,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/unstable-core-do-not-import/stream/utils/promiseTimer.js

@@ -1,38 +0,0 @@
-'use strict';
-
-var createDeferred = require('./createDeferred.js');
-
-function createPromiseTimer(ms) {
-    let deferred = createDeferred.createDeferred();
-    let timeout = null;
-    const timer = {
-        get promise () {
-            return deferred.promise;
-        },
-        start,
-        reset,
-        clear
-    };
-    return timer;
-    function start() {
-        if (timeout != null) {
-            throw new Error('PromiseTimer already started.');
-        }
-        timeout = setTimeout(deferred.resolve, ms);
-        return timer;
-    }
-    function reset() {
-        clear();
-        deferred = createDeferred.createDeferred();
-        return timer;
-    }
-    function clear() {
-        if (timeout != null) {
-            clearTimeout(timeout);
-            timeout = null;
-        }
-        return timer;
-    }
-}
-
-exports.createPromiseTimer = createPromiseTimer;

package/dist/unstable-core-do-not-import/stream/utils/promiseTimer.mjs

@@ -1,36 +0,0 @@
-import { createDeferred } from './createDeferred.mjs';
-
-function createPromiseTimer(ms) {
-    let deferred = createDeferred();
-    let timeout = null;
-    const timer = {
-        get promise () {
-            return deferred.promise;
-        },
-        start,
-        reset,
-        clear
-    };
-    return timer;
-    function start() {
-        if (timeout != null) {
-            throw new Error('PromiseTimer already started.');
-        }
-        timeout = setTimeout(deferred.resolve, ms);
-        return timer;
-    }
-    function reset() {
-        clear();
-        deferred = createDeferred();
-        return timer;
-    }
-    function clear() {
-        if (timeout != null) {
-            clearTimeout(timeout);
-            timeout = null;
-        }
-        return timer;
-    }
-}
-
-export { createPromiseTimer };

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

@@ -1,29 +0,0 @@
-/**
- * Format a batch response as a line-delimited JSON stream
- * that the `unstable_httpBatchStreamLink` can parse:
- *
- * @example
- * ```ts
- * const formatter = getBatchStreamFormatter();
- * res.send(formatter(1, 'response #2'));
- * res.send(formatter(0, 'response #1'));
- * res.send(formatter.end());
- * ```
- *
- * Expected format:
- * ```json
- * {"1":"response #2"
- * ,"0":"response #1"
- * }
- * ```
- */
-export function getBatchStreamFormatter() {
-  let first = true;
-  function format(index: number, string: string) {
-    const prefix = first ? '{' : ',';
-    first = false;
-    return `${prefix}"${index}":${string}\n`;
-  }
-  format.end = () => '}';
-  return format;
-}

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

@@ -1,40 +0,0 @@
-import { createDeferred } from './createDeferred';
-
-export function createPromiseTimer(ms: number) {
-  let deferred = createDeferred<void>();
-  let timeout: ReturnType<typeof setTimeout> | null = null;
-
-  const timer = {
-    get promise() {
-      return deferred.promise;
-    },
-
-    start,
-    reset,
-    clear,
-  };
-  return timer;
-
-  function start(): PromiseTimer {
-    if (timeout != null) {
-      throw new Error('PromiseTimer already started.');
-    }
-    timeout = setTimeout(deferred.resolve, ms);
-    return timer;
-  }
-
-  function reset(): PromiseTimer {
-    clear();
-    deferred = createDeferred();
-    return timer;
-  }
-
-  function clear(): PromiseTimer {
-    if (timeout != null) {
-      clearTimeout(timeout);
-      timeout = null;
-    }
-    return timer;
-  }
-}
-export type PromiseTimer = ReturnType<typeof createPromiseTimer>;