@trpc/server 11.0.0-rc.589 → 11.0.0-rc.591

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

@@ -41,5 +41,43 @@ function noop() {}
 function identity(it) {
     return it;
 }
+/**
+ * Generic runtime assertion function. Throws, if the condition is not `true`.
+ *
+ * Can be used as a slightly less dangerous variant of type assertions. Code
+ * mistakes would be revealed at runtime then (hopefully during testing).
+ */ function assert(condition, msg = 'no additional info') {
+    if (!condition) {
+        throw new Error(`AssertionError: ${msg}`);
+    }
+}
+function sleep(ms = 0) {
+    return new Promise((res)=>setTimeout(res, ms));
+}
+/**
+ * Ponyfill for
+ * [`AbortSignal.any`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any_static).
+ */ function abortSignalsAnyPonyfill(signals) {
+    if (typeof AbortSignal.any === 'function') {
+        return AbortSignal.any(signals);
+    }
+    const ac = new AbortController();
+    for (const signal of signals){
+        if (signal.aborted) {
+            trigger();
+        } else if (!ac.signal.aborted) {
+            signal.addEventListener('abort', trigger, {
+                once: true
+            });
+        }
+    }
+    return ac.signal;
+    function trigger() {
+        ac.abort();
+        for (const signal of signals){
+            signal.removeEventListener('abort', trigger);
+        }
+    }
+}
 
-export { identity, isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, noop, omitPrototype, run, unsetMarker };
+export { abortSignalsAnyPonyfill, assert, identity, isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, noop, omitPrototype, run, sleep, unsetMarker };

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

@@ -41,8 +41,12 @@ exports.getBatchStreamFormatter = batchStreamFormatter.getBatchStreamFormatter;
 exports.getRequestInfo = contentType.getRequestInfo;
 exports.octetInputParser = contentTypeParsers.octetInputParser;
 exports.formDataToObject = formDataToObject.formDataToObject;
+exports.HTTP_CODE_TO_JSONRPC2 = getHTTPStatusCode.HTTP_CODE_TO_JSONRPC2;
+exports.JSONRPC2_TO_HTTP_CODE = getHTTPStatusCode.JSONRPC2_TO_HTTP_CODE;
 exports.getHTTPStatusCode = getHTTPStatusCode.getHTTPStatusCode;
 exports.getHTTPStatusCodeFromError = getHTTPStatusCode.getHTTPStatusCodeFromError;
+exports.getStatusCodeFromKey = getHTTPStatusCode.getStatusCodeFromKey;
+exports.getStatusKeyFromCode = getHTTPStatusCode.getStatusKeyFromCode;
 exports.parseConnectionParamsFromString = parseConnectionParams.parseConnectionParamsFromString;
 exports.parseConnectionParamsFromUnknown = parseConnectionParams.parseConnectionParamsFromUnknown;
 exports.resolveResponse = resolveResponse.resolveResponse;
@@ -78,6 +82,8 @@ exports.defaultTransformer = transformer.defaultTransformer;
 exports.getDataTransformer = transformer.getDataTransformer;
 exports.transformResult = transformer.transformResult;
 exports.transformTRPCResponse = transformer.transformTRPCResponse;
+exports.abortSignalsAnyPonyfill = utils.abortSignalsAnyPonyfill;
+exports.assert = utils.assert;
 exports.identity = utils.identity;
 exports.isAsyncIterable = utils.isAsyncIterable;
 exports.isFunction = utils.isFunction;
@@ -86,4 +92,5 @@ exports.mergeWithoutOverrides = utils.mergeWithoutOverrides;
 exports.noop = utils.noop;
 exports.omitPrototype = utils.omitPrototype;
 exports.run = utils.run;
+exports.sleep = utils.sleep;
 exports.unsetMarker = utils.unsetMarker;

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

@@ -6,7 +6,7 @@ export { getBatchStreamFormatter } from './unstable-core-do-not-import/http/batc
 export { getRequestInfo } from './unstable-core-do-not-import/http/contentType.mjs';
 export { octetInputParser } from './unstable-core-do-not-import/http/contentTypeParsers.mjs';
 export { formDataToObject } from './unstable-core-do-not-import/http/formDataToObject.mjs';
-export { getHTTPStatusCode, getHTTPStatusCodeFromError } from './unstable-core-do-not-import/http/getHTTPStatusCode.mjs';
+export { HTTP_CODE_TO_JSONRPC2, JSONRPC2_TO_HTTP_CODE, getHTTPStatusCode, getHTTPStatusCodeFromError, getStatusCodeFromKey, getStatusKeyFromCode } from './unstable-core-do-not-import/http/getHTTPStatusCode.mjs';
 export { parseConnectionParamsFromString, parseConnectionParamsFromUnknown } from './unstable-core-do-not-import/http/parseConnectionParams.mjs';
 export { resolveResponse } from './unstable-core-do-not-import/http/resolveResponse.mjs';
 export { toURL } from './unstable-core-do-not-import/http/toURL.mjs';
@@ -24,4 +24,4 @@ export { sseHeaders, sseStreamConsumer, sseStreamProducer } from './unstable-cor
 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 { defaultTransformer, getDataTransformer, transformResult, transformTRPCResponse } from './unstable-core-do-not-import/transformer.mjs';
-export { identity, isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, noop, omitPrototype, run, unsetMarker } from './unstable-core-do-not-import/utils.mjs';
+export { abortSignalsAnyPonyfill, assert, identity, isAsyncIterable, isFunction, isObject, mergeWithoutOverrides, noop, omitPrototype, run, sleep, unsetMarker } from './unstable-core-do-not-import/utils.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-rc.589+79fa074bd",
+  "version": "11.0.0-rc.591+956d65f99",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -149,5 +149,5 @@
   "funding": [
     "https://trpc.io/sponsor"
   ],
-  "gitHead": "79fa074bd4ab01e2eebca47fe41fb1aeea87f24e"
+  "gitHead": "956d65f99bd9dd4b52343a4f406111079af0ce7f"
 }

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

@@ -1,9 +1,10 @@
 import type { TRPCError } from '../error/TRPCError';
 import type { TRPC_ERROR_CODES_BY_KEY, TRPCResponse } from '../rpc';
 import { TRPC_ERROR_CODES_BY_NUMBER } from '../rpc';
+import type { InvertKeyValue, ValueOf } from '../types';
 import { isObject } from '../utils';
 
-const JSONRPC2_TO_HTTP_CODE: Record<
+export const JSONRPC2_TO_HTTP_CODE: Record<
   keyof typeof TRPC_ERROR_CODES_BY_KEY,
   number
 > = {
@@ -28,11 +29,42 @@ const JSONRPC2_TO_HTTP_CODE: Record<
   GATEWAY_TIMEOUT: 504,
 };
 
-function getStatusCodeFromKey(code: keyof typeof TRPC_ERROR_CODES_BY_KEY) {
+export const HTTP_CODE_TO_JSONRPC2: InvertKeyValue<
+  typeof JSONRPC2_TO_HTTP_CODE
+> = {
+  400: 'BAD_REQUEST',
+  401: 'UNAUTHORIZED',
+  403: 'FORBIDDEN',
+  404: 'NOT_FOUND',
+  405: 'METHOD_NOT_SUPPORTED',
+  408: 'TIMEOUT',
+  409: 'CONFLICT',
+  412: 'PRECONDITION_FAILED',
+  413: 'PAYLOAD_TOO_LARGE',
+  415: 'UNSUPPORTED_MEDIA_TYPE',
+  422: 'UNPROCESSABLE_CONTENT',
+  429: 'TOO_MANY_REQUESTS',
+  499: 'CLIENT_CLOSED_REQUEST',
+  500: 'INTERNAL_SERVER_ERROR',
+  501: 'NOT_IMPLEMENTED',
+  502: 'BAD_GATEWAY',
+  503: 'SERVICE_UNAVAILABLE',
+  504: 'GATEWAY_TIMEOUT',
+} as const;
+
+export function getStatusCodeFromKey(
+  code: keyof typeof TRPC_ERROR_CODES_BY_KEY,
+) {
   return JSONRPC2_TO_HTTP_CODE[code] ?? 500;
 }
 
-export function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]): number {
+export function getStatusKeyFromCode(
+  code: keyof typeof HTTP_CODE_TO_JSONRPC2,
+): ValueOf<typeof HTTP_CODE_TO_JSONRPC2> {
+  return HTTP_CODE_TO_JSONRPC2[code] ?? 'INTERNAL_SERVER_ERROR';
+}
+
+export function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]) {
   const arr = Array.isArray(json) ? json : [json];
   const httpStatuses = new Set<number>(
     arr.map((res) => {

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

@@ -15,7 +15,7 @@ import type { TRPCResponse } from '../rpc';
 import { isPromise, jsonlStreamProducer } from '../stream/jsonl';
 import { sseHeaders, sseStreamProducer } from '../stream/sse';
 import { transformTRPCResponse } from '../transformer';
-import { isAsyncIterable, isObject } from '../utils';
+import { abortSignalsAnyPonyfill, assert, isAsyncIterable, isObject } from '../utils';
 import { getRequestInfo } from './contentType';
 import { getHTTPStatusCode } from './getHTTPStatusCode';
 import type {
@@ -260,9 +260,13 @@ export async function resolveResponse<TRouter extends AnyRouter>(
       });
     }
 
+    interface RPCResultOk {
+      data: unknown;
+      abortCtrl?: AbortController;
+    }
     type RPCResult =
       | [result: null, error: TRPCError]
-      | [result: unknown, error?: never];
+      | [result: RPCResultOk, error?: never];
     const rpcCalls = info.calls.map(async (call): Promise<RPCResult> => {
       const proc = call.procedure;
       try {
@@ -279,21 +283,28 @@ export async function resolveResponse<TRouter extends AnyRouter>(
             message: `Unsupported ${req.method}-request to ${proc._def.type} procedure at path "${call.path}"`,
           });
         }
-        /* istanbul ignore if -- @preserve */
-        if (proc._def.type === 'subscription' && info!.isBatchCall) {
-          throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: `Cannot batch subscription calls`,
-          });
+        let abortCtrl: AbortController | undefined;
+        if (proc._def.type === 'subscription') {
+          /* istanbul ignore if -- @preserve */
+          if (info!.isBatchCall) {
+            throw new TRPCError({
+              code: 'BAD_REQUEST',
+              message: `Cannot batch subscription calls`,
+            });
+          }
+          abortCtrl = new AbortController();
         }
+
         const data: unknown = await proc({
           path: call.path,
           getRawInput: call.getRawInput,
           ctx,
           type: proc._def.type,
-          signal: opts.req.signal,
+          signal: abortCtrl
+            ? abortSignalsAnyPonyfill([opts.req.signal, abortCtrl.signal])
+            : opts.req.signal,
         });
-        return [data];
+        return [{ data, abortCtrl }];
       } catch (cause) {
         const error = getTRPCErrorFromUnknown(cause);
         const input = call.result();
@@ -314,7 +325,7 @@ export async function resolveResponse<TRouter extends AnyRouter>(
     // ----------- response handlers -----------
     if (!info.isBatchCall) {
       const [call] = info.calls;
-      const [data, error] = await rpcCalls[0]!;
+      const [result, error] = await rpcCalls[0]!;
 
       switch (info.type) {
         case 'unknown':
@@ -323,7 +334,7 @@ export async function resolveResponse<TRouter extends AnyRouter>(
           // httpLink
           headers.set('content-type', 'application/json');
 
-          if (isDataStream(data)) {
+          if (isDataStream(result?.data)) {
             throw new TRPCError({
               code: 'UNSUPPORTED_MEDIA_TYPE',
               message:
@@ -341,7 +352,7 @@ export async function resolveResponse<TRouter extends AnyRouter>(
                   type: info.type,
                 }),
               }
-            : { result: { data } };
+            : { result: { data: result.data } };
 
           const headResponse = initResponse({
             ctx,
@@ -372,6 +383,11 @@ export async function resolveResponse<TRouter extends AnyRouter>(
           if (error) {
             throw error;
           }
+          const { data, abortCtrl } = result;
+          assert(
+            abortCtrl !== undefined,
+            'subscription type must have an AbortController',
+          );
 
           if (!isObservable(data) && !isAsyncIterable(data)) {
             throw new TRPCError({
@@ -388,6 +404,7 @@ export async function resolveResponse<TRouter extends AnyRouter>(
           const stream = sseStreamProducer({
             ...config.experimental?.sseSubscriptions,
             data: dataAsIterable,
+            abortCtrl,
             serialize: (v) => config.transformer.output.serialize(v),
             formatError(errorOpts) {
               const error = getTRPCErrorFromUnknown(errorOpts.error);
@@ -481,17 +498,18 @@ export async function resolveResponse<TRouter extends AnyRouter>(
               }),
             };
           }
+          const { data } = result;
 
           /**
            * Not very pretty, but we need to wrap nested data in promises
            * Our stream producer will only resolve top-level async values or async values that are directly nested in another async value
            */
-          const data = isObservable(result)
-            ? observableToAsyncIterable(result)
-            : Promise.resolve(result);
+          const dataAsPromiseOrIterable = isObservable(data)
+            ? observableToAsyncIterable(data)
+            : Promise.resolve(data);
           return {
             result: Promise.resolve({
-              data,
+              data: dataAsPromiseOrIterable,
             }),
           };
         }),
@@ -539,12 +557,12 @@ export async function resolveResponse<TRouter extends AnyRouter>(
     headers.set('content-type', 'application/json');
     const results: RPCResult[] = (await Promise.all(rpcCalls)).map(
       (res): RPCResult => {
-        const [data, error] = res;
+        const [result, error] = res;
         if (error) {
           return res;
         }
 
-        if (isDataStream(data)) {
+        if (isDataStream(result.data)) {
           return [
             null,
             new TRPCError({
@@ -559,7 +577,7 @@ export async function resolveResponse<TRouter extends AnyRouter>(
     );
     const resultAsRPCResponse = results.map(
       (
-        [data, error],
+        [result, error],
         index,
       ): TRPCResponse<unknown, inferRouterError<TRouter>> => {
         const call = info!.calls[index]!;
@@ -576,7 +594,7 @@ export async function resolveResponse<TRouter extends AnyRouter>(
           };
         }
         return {
-          result: { data },
+          result: { data: result.data },
         };
       },
     );

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

@@ -1,4 +1,4 @@
-import type { ValueOf } from '../types';
+import type { InvertKeyValue, ValueOf } from '../types';
 
 // reference: https://www.jsonrpc.org/specification
 
@@ -41,16 +41,8 @@ export const TRPC_ERROR_CODES_BY_KEY = {
   CLIENT_CLOSED_REQUEST: -32099, // 499
 } as const;
 
-type KeyFromValue<TValue, TType extends Record<PropertyKey, PropertyKey>> = {
-  [K in keyof TType]: TValue extends TType[K] ? K : never;
-}[keyof TType];
-
-type Invert<TType extends Record<PropertyKey, PropertyKey>> = {
-  [TValue in TType[keyof TType]]: KeyFromValue<TValue, TType>;
-};
-
 // pure
-export const TRPC_ERROR_CODES_BY_NUMBER: Invert<
+export const TRPC_ERROR_CODES_BY_NUMBER: InvertKeyValue<
   typeof TRPC_ERROR_CODES_BY_KEY
 > = {
   [-32700]: 'PARSE_ERROR',

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

@@ -32,6 +32,7 @@ export interface PingOptions {
 export interface SSEStreamProducerOptions<TValue = unknown> {
   serialize?: Serialize;
   data: AsyncIterable<TValue>;
+  abortCtrl: AbortController;
   maxDepth?: number;
   ping?: PingOptions;
   /**
@@ -61,7 +62,9 @@ type SSEvent = Partial<{
  *
  * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */
-export function sseStreamProducer<TValue = unknown>(opts: SSEStreamProducerOptions<TValue>) {
+export function sseStreamProducer<TValue = unknown>(
+  opts: SSEStreamProducerOptions<TValue>,
+) {
   const stream = createReadableStream<SSEvent>();
   stream.controller.enqueue({ comment: 'connected' });
 
@@ -74,11 +77,15 @@ export function sseStreamProducer<TValue = unknown>(opts: SSEStreamProducerOptio
 
   run(async () => {
     let iterable: AsyncIterable<TValue | typeof PING_SYM> = opts.data;
-    
+
     iterable = withCancel(iterable, stream.cancelledPromise);
 
     if (opts.emitAndEndImmediately) {
-      iterable = takeWithGrace(iterable, { count: 1, gracePeriodMs: 1 });
+      iterable = takeWithGrace(iterable, {
+        count: 1,
+        gracePeriodMs: 1,
+        onCancel: () => opts.abortCtrl.abort(),
+      });
     }
 
     let maxDurationTimer: PromiseTimer | null = null;
@@ -88,7 +95,10 @@ export function sseStreamProducer<TValue = unknown>(opts: SSEStreamProducerOptio
       opts.maxDurationMs !== Infinity
     ) {
       maxDurationTimer = createPromiseTimer(opts.maxDurationMs).start();
-      iterable = withCancel(iterable, maxDurationTimer.promise);
+      iterable = withCancel(
+        iterable,
+        maxDurationTimer.promise.then(() => opts.abortCtrl.abort()),
+      );
     }
 
     if (ping.enabled && ping.intervalMs !== Infinity && ping.intervalMs > 0) {

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

@@ -27,6 +27,7 @@ export async function* withCancel<T>(
 interface TakeWithGraceOptions {
   count: number;
   gracePeriodMs: number;
+  onCancel?: () => void;
 }
 
 /**
@@ -36,7 +37,7 @@ interface TakeWithGraceOptions {
  */
 export async function* takeWithGrace<T>(
   iterable: AsyncIterable<T>,
-  { count, gracePeriodMs }: TakeWithGraceOptions,
+  { count, gracePeriodMs, onCancel }: TakeWithGraceOptions,
 ): AsyncGenerator<T> {
   const iterator = iterable[Symbol.asyncIterator]();
   const timer = createPromiseTimer(gracePeriodMs);
@@ -53,7 +54,7 @@ export async function* takeWithGrace<T>(
       }
       yield result.value;
       if (--count === 0) {
-        timer.start();
+        timer.start().promise.then(onCancel, noop);
       }
     }
   } finally {

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

@@ -17,7 +17,7 @@ export function createPromiseTimer(ms: number) {
 
   function start(): PromiseTimer {
     if (timeout != null) {
-      throw new Error("PromiseTimer already started.");
+      throw new Error('PromiseTimer already started.');
     }
     timeout = setTimeout(deferred.resolve, ms);
     return timer;

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

@@ -131,6 +131,17 @@ export type PickFirstDefined<TType, TPick> = undefined extends TType
     : TPick
   : TType;
 
+export type KeyFromValue<
+  TValue,
+  TType extends Record<PropertyKey, PropertyKey>,
+> = {
+  [K in keyof TType]: TValue extends TType[K] ? K : never;
+}[keyof TType];
+
+export type InvertKeyValue<TType extends Record<PropertyKey, PropertyKey>> = {
+  [TValue in TType[keyof TType]]: KeyFromValue<TValue, TType>;
+};
+
 /**
  * ================================
  * tRPC specific types

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

@@ -68,3 +68,51 @@ export function noop(): void {}
 export function identity<T>(it: T): T {
   return it;
 }
+
+/**
+ * Generic runtime assertion function. Throws, if the condition is not `true`.
+ *
+ * Can be used as a slightly less dangerous variant of type assertions. Code
+ * mistakes would be revealed at runtime then (hopefully during testing).
+ */
+export function assert(
+  condition: boolean,
+  msg = 'no additional info',
+): asserts condition {
+  if (!condition) {
+    throw new Error(`AssertionError: ${msg}`);
+  }
+}
+
+export function sleep(ms = 0): Promise<void> {
+  return new Promise<void>((res) => setTimeout(res, ms));
+}
+
+/**
+ * Ponyfill for
+ * [`AbortSignal.any`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any_static).
+ */
+export function abortSignalsAnyPonyfill(signals: AbortSignal[]): AbortSignal {
+  if (typeof AbortSignal.any === 'function') {
+    return AbortSignal.any(signals);
+  }
+
+  const ac = new AbortController();
+
+  for (const signal of signals) {
+    if (signal.aborted) {
+      trigger();
+    } else if (!ac.signal.aborted) {
+      signal.addEventListener('abort', trigger, { once: true });
+    }
+  }
+
+  return ac.signal;
+
+  function trigger() {
+    ac.abort();
+    for (const signal of signals) {
+      signal.removeEventListener('abort', trigger);
+    }
+  }
+}