@trpc/server 11.0.0-rc.417 → 11.0.0-rc.419

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

@@ -1,5 +1,9 @@
 import type { TRPCError } from '../error/TRPCError';
-import type { ErrorHandlerOptions, ProcedureType } from '../procedure';
+import type {
+  AnyProcedure,
+  ErrorHandlerOptions,
+  ProcedureType,
+} from '../procedure';
 import type {
   AnyRouter,
   inferRouterContext,
@@ -51,6 +55,8 @@ export interface HTTPBaseHandlerOptions<TRouter extends AnyRouter, TRequest>
   responseMeta?: ResponseMetaFn<TRouter>;
 }
 
+export type TRPCAcceptHeader = 'application/jsonl';
+
 interface TRPCRequestInfoProcedureCall {
   path: string;
   /**
@@ -61,16 +67,47 @@ interface TRPCRequestInfoProcedureCall {
    * Get already parsed inputs - won't trigger reading the body or parsing the inputs
    */
   result: () => unknown;
+  /**
+   * The procedure being called, `null` if not found
+   * @internal
+   */
+  procedure: AnyProcedure | null;
+}
+
+export interface TRPCRequestInfoBase {
+  /**
+   * The `trpc-accept` header
+   */
+  accept: TRPCAcceptHeader | null;
+  /**
+   * The type of the request
+   */
+  type: ProcedureType | 'unknown';
+  /**
+   * If the content type handler has detected that this is a batch call
+   */
+  isBatchCall: boolean;
+  /**
+   * The calls being made
+   */
+  calls: TRPCRequestInfoProcedureCall[];
+}
+interface TRPCRequestInfoBatchCall extends TRPCRequestInfoBase {
+  isBatchCall: true;
+  calls: TRPCRequestInfoProcedureCall[];
+}
+interface TRPCRequestInfoSingleCall extends TRPCRequestInfoBase {
+  isBatchCall: false;
+  calls: [TRPCRequestInfoProcedureCall];
 }
 
 /**
  * Information about the incoming request
  * @public
  */
-export interface TRPCRequestInfo {
-  isBatchCall: boolean;
-  calls: TRPCRequestInfoProcedureCall[];
-}
+export type TRPCRequestInfo =
+  | TRPCRequestInfoBatchCall
+  | TRPCRequestInfoSingleCall;
 
 /**
  * Inner createContext function for `resolveResponse` used to forward `TRPCRequestInfo` to `createContext`

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

@@ -23,6 +23,7 @@ import type {
   QueryProcedure,
   SubscriptionProcedure,
 } from './procedure';
+import type { inferSSEOutput } from './stream/sse';
 import type {
   GetRawInputFn,
   MaybePromise,
@@ -43,6 +44,12 @@ type DefaultValue<TValue, TFallback> = TValue extends UnsetMarker
   ? TFallback
   : TValue;
 
+type inferSubscriptionOutput<TOutput> = TOutput extends AsyncIterable<
+  infer $Output
+>
+  ? inferSSEOutput<$Output>
+  : inferObservableValue<TOutput>;
+
 export type CallerOverride<TContext> = (opts: {
   args: unknown[];
   invoke: (opts: ProcedureCallOptions<TContext>) => Promise<unknown>;
@@ -347,7 +354,7 @@ export interface ProcedureBuilder<
     ? TypeError<'Not implemented'>
     : SubscriptionProcedure<{
         input: DefaultValue<TInputIn, void>;
-        output: DefaultValue<TOutputOut, inferObservableValue<$Output>>;
+        output: DefaultValue<TOutputOut, inferSubscriptionOutput<$Output>>;
       }>;
 
   /**

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

@@ -1,5 +1,6 @@
 import type { CombinedDataTransformer } from '../unstable-core-do-not-import';
 import type { DefaultErrorShape, ErrorFormatter } from './error/formatter';
+import type { SSEStreamProducerOptions } from './stream/sse';
 
 /**
  * The initial generics that are used in the init function
@@ -67,8 +68,19 @@ export interface RootConfig<TTypes extends RootTypes> {
   experimental?: {
     /**
      * Enable support for returning async iterables and returning deferred promises when using `httpBatchStreamLink`
+     * @default true
      */
     iterablesAndDeferreds?: boolean;
+    /**
+     * Enable support for server-sent events (SSE) subscriptions
+     */
+    sseSubscriptions?: {
+      /**
+       * Enable server-sent events (SSE) subscriptions
+       * @default true
+       */
+      enabled: boolean;
+    } & Omit<SSEStreamProducerOptions, 'maxDepth' | 'data' | 'serialize'>;
   };
 }
 

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

@@ -248,6 +248,18 @@ export function callProcedure(
     });
   }
 
+  /* istanbul ignore if -- @preserve */
+  if (
+    proc._def.type !== type &&
+    opts.allowMethodOverride &&
+    proc._def.type === 'subscription'
+  ) {
+    throw new TRPCError({
+      code: 'METHOD_NOT_SUPPORTED',
+      message: `Method override is not supported for subscriptions`,
+    });
+  }
+
   return proc(opts);
 }
 

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

@@ -1,19 +1,8 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { isAsyncIterable, isFunction, isObject } from '../utils';
-
-// ---------- utils
-
-function createReadableStream<TValue = unknown>() {
-  let controller: ReadableStreamDefaultController<TValue> =
-    null as unknown as ReadableStreamDefaultController<TValue>;
-  const stream = new ReadableStream<TValue>({
-    start(c) {
-      controller = c;
-    },
-  });
-
-  return [stream, controller] as const;
-}
+import { getTRPCErrorFromUnknown } from '../error/TRPCError';
+import { isAsyncIterable, isFunction, isObject, run } from '../utils';
+import type { Deferred } from './utils/createDeferred';
+import { createDeferred } from './utils/createDeferred';
+import { createReadableStream } from './utils/createReadableStream';
 
 /**
  * A subset of the standard ReadableStream properties needed by tRPC internally.
@@ -65,19 +54,19 @@ type ChunkDefinition = [
   type: ChunkValueType,
   chunkId: ChunkIndex,
 ];
-type HydratedValue = [
+type DehydratedValue = [
   // data
   [unknown],
   // chunk descriptions
   ...ChunkDefinition[],
 ];
 
-type Head = Record<string, HydratedValue>;
+type Head = Record<string, DehydratedValue>;
 type PromiseChunk =
   | [
       chunkIndex: ChunkIndex,
       status: PROMISE_STATUS_FULFILLED,
-      value: HydratedValue,
+      value: DehydratedValue,
     ]
   | [chunkIndex: ChunkIndex, status: PROMISE_STATUS_REJECTED, error: unknown];
 type IterableChunk =
@@ -85,7 +74,7 @@ type IterableChunk =
   | [
       chunkIndex: ChunkIndex,
       status: ASYNC_ITERABLE_STATUS_VALUE,
-      value: HydratedValue,
+      value: DehydratedValue,
     ]
   | [
       chunkIndex: ChunkIndex,
@@ -111,7 +100,7 @@ export type ProducerOnError = (opts: {
 }) => void;
 export interface ProducerOptions {
   serialize?: Serialize;
-  data: Record<number, unknown>;
+  data: Record<string, unknown> | unknown[];
   onError?: ProducerOnError;
   formatError?: (opts: {
     error: unknown;
@@ -131,14 +120,15 @@ function createBatchStreamProducer(opts: ProducerOptions) {
   let counter = 0 as ChunkIndex;
   const placeholder = 0 as PlaceholderValue;
 
-  const [stream, controller] = createReadableStream<ChunkData>();
+  const stream = createReadableStream<ChunkData>();
   const pending = new Set<ChunkIndex>();
+
   function maybeClose() {
-    if (pending.size === 0) {
-      controller.close();
+    if (pending.size === 0 && !stream.cancelled()) {
+      stream.controller.close();
     }
   }
-  function hydratePromise(
+  function dehydratePromise(
     promise: Promise<unknown>,
     path: (string | number)[],
   ) {
@@ -152,19 +142,24 @@ function createBatchStreamProducer(opts: ProducerOptions) {
     }
     const idx = counter++ as ChunkIndex;
     pending.add(idx);
-    const enqueue = (value: PromiseChunk) => {
-      controller.enqueue(value);
-    };
-    promise
+
+    Promise.race([promise, stream.cancelledPromise])
       .then((it) => {
-        enqueue([idx, PROMISE_STATUS_FULFILLED, hydrate(it, path)]);
+        if (it === null) {
+          return;
+        }
+        stream.controller.enqueue([
+          idx,
+          PROMISE_STATUS_FULFILLED,
+          dehydrate(it, path),
+        ]);
       })
-      .catch((error) => {
-        opts.onError?.({ error, path });
-        enqueue([
+      .catch((cause) => {
+        opts.onError?.({ error: cause, path });
+        stream.controller.enqueue([
           idx,
           PROMISE_STATUS_REJECTED,
-          opts.formatError?.({ error, path }),
+          opts.formatError?.({ error: cause, path }),
         ]);
       })
       .finally(() => {
@@ -173,7 +168,7 @@ function createBatchStreamProducer(opts: ProducerOptions) {
       });
     return idx;
   }
-  function hydrateAsyncIterable(
+  function dehydrateAsyncIterable(
     iterable: AsyncIterable<unknown>,
     path: (string | number)[],
   ) {
@@ -187,28 +182,56 @@ function createBatchStreamProducer(opts: ProducerOptions) {
     }
     const idx = counter++ as ChunkIndex;
     pending.add(idx);
-    void (async () => {
-      try {
-        for await (const item of iterable) {
-          controller.enqueue([
+    run(async () => {
+      const iterator = iterable[Symbol.asyncIterator]();
+
+      while (true) {
+        const next = await Promise.race([
+          iterator.next().catch(getTRPCErrorFromUnknown),
+          stream.cancelledPromise,
+        ]);
+
+        if (next instanceof Error) {
+          opts.onError?.({ error: next, path });
+
+          stream.controller.enqueue([
             idx,
-            ASYNC_ITERABLE_STATUS_VALUE,
-            hydrate(item, path),
+            ASYNC_ITERABLE_STATUS_ERROR,
+            opts.formatError?.({ error: next, path }),
           ]);
+          return;
         }
-        controller.enqueue([idx, ASYNC_ITERABLE_STATUS_DONE]);
-      } catch (error) {
-        opts.onError?.({ error, path });
-        controller.enqueue([
+        if (next === 'cancelled') {
+          await iterator.return?.();
+          break;
+        }
+        if (next.done) {
+          stream.controller.enqueue([idx, ASYNC_ITERABLE_STATUS_DONE]);
+          break;
+        }
+        stream.controller.enqueue([
           idx,
-          ASYNC_ITERABLE_STATUS_ERROR,
-          opts.formatError?.({ error, path }),
+          ASYNC_ITERABLE_STATUS_VALUE,
+          dehydrate(next.value, path),
         ]);
-      } finally {
-        pending.delete(idx);
-        maybeClose();
       }
-    })();
+
+      pending.delete(idx);
+      maybeClose();
+    }).catch((cause) => {
+      // this shouldn't happen, but node crashes if we don't catch it
+      opts.onError?.({
+        error: new Error(
+          'You found a bug - please report it on https://github.com/trpc/trpc',
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore https://github.com/tc39/proposal-error-cause
+          {
+            cause,
+          },
+        ),
+        path,
+      });
+    });
     return idx;
   }
   function checkMaxDepth(path: (string | number)[]) {
@@ -217,12 +240,12 @@ function createBatchStreamProducer(opts: ProducerOptions) {
     }
     return null;
   }
-  function hydrateChunk(
+  function dehydrateChunk(
     value: unknown,
     path: (string | number)[],
   ): null | [type: ChunkValueType, chunkId: ChunkIndex] {
     if (isPromise(value)) {
-      return [CHUNK_VALUE_TYPE_PROMISE, hydratePromise(value, path)];
+      return [CHUNK_VALUE_TYPE_PROMISE, dehydratePromise(value, path)];
     }
     if (isAsyncIterable(value)) {
       if (opts.maxDepth && path.length >= opts.maxDepth) {
@@ -230,13 +253,16 @@ function createBatchStreamProducer(opts: ProducerOptions) {
       }
       return [
         CHUNK_VALUE_TYPE_ASYNC_ITERABLE,
-        hydrateAsyncIterable(value, path),
+        dehydrateAsyncIterable(value, path),
       ];
     }
     return null;
   }
-  function hydrate(value: unknown, path: (string | number)[]): HydratedValue {
-    const reg = hydrateChunk(value, path);
+  function dehydrate(
+    value: unknown,
+    path: (string | number)[],
+  ): DehydratedValue {
+    const reg = dehydrateChunk(value, path);
     if (reg) {
       return [[placeholder], [null, ...reg]];
     }
@@ -246,7 +272,7 @@ function createBatchStreamProducer(opts: ProducerOptions) {
     const newObj = {} as Record<string, unknown>;
     const asyncValues: ChunkDefinition[] = [];
     for (const [key, item] of Object.entries(value)) {
-      const transformed = hydrateChunk(item, [...path, key]);
+      const transformed = dehydrateChunk(item, [...path, key]);
       if (!transformed) {
         newObj[key] = item;
         continue;
@@ -259,10 +285,10 @@ function createBatchStreamProducer(opts: ProducerOptions) {
 
   const newHead: Head = {};
   for (const [key, item] of Object.entries(data)) {
-    newHead[key] = hydrate(item, [key]);
+    newHead[key] = dehydrate(item, [key]);
   }
 
-  return [newHead, stream] as const;
+  return [newHead, stream.readable] as const;
 }
 /**
  * JSON Lines stream producer
@@ -296,6 +322,7 @@ export function jsonlStreamProducer(opts: ProducerOptions) {
     )
     .pipeThrough(new TextEncoderStream());
 }
+
 class StreamInterruptedError extends Error {
   constructor(cause?: unknown) {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -313,7 +340,7 @@ export type ConsumerOnError = (opts: { error: unknown }) => void;
 const nodeJsStreamToReaderEsque = (source: NodeJSReadableStreamEsque) => {
   return {
     getReader() {
-      const [stream, controller] = createReadableStream<Uint8Array>();
+      const { readable, controller } = createReadableStream<Uint8Array>();
       source.on('data', (chunk) => {
         controller.enqueue(chunk);
       });
@@ -323,7 +350,7 @@ const nodeJsStreamToReaderEsque = (source: NodeJSReadableStreamEsque) => {
       source.on('error', (error) => {
         controller.error(error);
       });
-      return stream.getReader();
+      return readable.getReader();
     },
   };
 };
@@ -388,19 +415,6 @@ function createConsumerStream<THead>(
   );
 }
 
-function createDeferred<TValue>() {
-  let resolve: (value: TValue) => void;
-  let reject: (error: unknown) => void;
-  const promise = new Promise<TValue>((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-
-  return { promise, resolve: resolve!, reject: reject! };
-}
-
-type Deferred<TValue> = ReturnType<typeof createDeferred<TValue>>;
-
 /**
  * JSON Lines stream consumer
  * @see https://jsonlines.org/
@@ -430,10 +444,10 @@ export async function jsonlStreamConsumer<THead>(opts: {
   const chunkDeferred = new Map<ChunkIndex, Deferred<ChunkController>>();
   const controllers = new Map<ChunkIndex, ChunkController>();
 
-  function dehydrateChunkDefinition(value: ChunkDefinition) {
+  function hydrateChunkDefinition(value: ChunkDefinition) {
     const [_path, type, chunkId] = value;
 
-    const [stream, controller] = createReadableStream<ChunkData>();
+    const { readable, controller } = createReadableStream<ChunkData>();
     controllers.set(chunkId, controller);
 
     // resolve chunk deferred if it exists
@@ -447,7 +461,7 @@ export async function jsonlStreamConsumer<THead>(opts: {
       case CHUNK_VALUE_TYPE_PROMISE: {
         return new Promise((resolve, reject) => {
           // listen for next value in the stream
-          const reader = stream.getReader();
+          const reader = readable.getReader();
           reader
             .read()
             .then((it) => {
@@ -463,7 +477,7 @@ export async function jsonlStreamConsumer<THead>(opts: {
               const [_chunkId, status, data] = value as PromiseChunk;
               switch (status) {
                 case PROMISE_STATUS_FULFILLED:
-                  resolve(dehydrate(data));
+                  resolve(hydrate(data));
                   break;
                 case PROMISE_STATUS_REJECTED:
                   reject(
@@ -482,7 +496,7 @@ export async function jsonlStreamConsumer<THead>(opts: {
       case CHUNK_VALUE_TYPE_ASYNC_ITERABLE: {
         return {
           [Symbol.asyncIterator]: async function* () {
-            const reader = stream.getReader();
+            const reader = readable.getReader();
             while (true) {
               const { done, value } = await reader.read();
               if (done) {
@@ -496,7 +510,7 @@ export async function jsonlStreamConsumer<THead>(opts: {
 
               switch (status) {
                 case ASYNC_ITERABLE_STATUS_VALUE:
-                  yield dehydrate(data);
+                  yield hydrate(data);
                   break;
                 case ASYNC_ITERABLE_STATUS_DONE:
                   controllers.delete(chunkId);
@@ -514,18 +528,18 @@ export async function jsonlStreamConsumer<THead>(opts: {
     }
   }
 
-  function dehydrate(value: HydratedValue): unknown {
+  function hydrate(value: DehydratedValue): unknown {
     const [[data], ...asyncProps] = value;
 
     for (const value of asyncProps) {
-      const dehydrated = dehydrateChunkDefinition(value);
+      const hydrated = hydrateChunkDefinition(value);
 
       const [path] = value;
       if (path === null) {
-        return dehydrated;
+        return hydrated;
       }
 
-      (data as any)[path] = dehydrated;
+      (data as any)[path] = hydrated;
     }
     return data;
   }
@@ -552,7 +566,7 @@ export async function jsonlStreamConsumer<THead>(opts: {
             const head = chunkOrHead as Record<number | string, unknown>;
 
             for (const [key, value] of Object.entries(chunkOrHead)) {
-              const parsed = dehydrate(value as any);
+              const parsed = hydrate(value as any);
               head[key] = parsed;
             }
             headDeferred.resolve(head as THead);