@trpc/server 11.0.0-alpha-tmp-app-router-example.388 → 11.0.0-alpha-tmp-issues-5851-take-two.448

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,
@@ -28,7 +32,7 @@ export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
    * The different tRPC paths requested
    * @deprecated use `info` instead, this will be removed in v12
    **/
-  paths: string[] | undefined;
+  paths: readonly string[] | undefined;
   info: TRPCRequestInfo | undefined;
   type: ProcedureType | 'unknown';
   errors: TRPCError[];
@@ -51,6 +55,8 @@ export interface HTTPBaseHandlerOptions<TRouter extends AnyRouter, TRequest>
   responseMeta?: ResponseMetaFn<TRouter>;
 }
 
+export type TRPCAcceptHeader = 'application/jsonl';
+
 interface TRPCRequestInfoProcedureCall {
   path: string;
   /**
@@ -61,6 +67,11 @@ 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;
 }
 
 /**
@@ -68,8 +79,26 @@ interface TRPCRequestInfoProcedureCall {
  * @public
  */
 export interface TRPCRequestInfo {
+  /**
+   * 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[];
+  /**
+   * Connection params when using `httpSubscriptionLink` or `createWSClient`
+   */
+  connectionParams: Dict<string> | null;
 }
 
 /**

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

@@ -174,7 +174,7 @@ export function createRouterFactory<TRoot extends AnyRootTypes>(
 
     const procedures: Record<string, AnyProcedure> = omitPrototype({});
 
-    function step(from: CreateRouterOptions, path: string[] = []) {
+    function step(from: CreateRouterOptions, path: readonly string[] = []) {
       const aggregate: RouterRecord = omitPrototype({});
       for (const [key, item] of Object.entries(from ?? {})) {
         if (isRouter(item)) {
@@ -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);
 }
 
@@ -264,40 +276,40 @@ export function createCallerFactory<TRoot extends AnyRootTypes>() {
         onError?: RouterCallerErrorHandler<Context>;
       },
     ) {
-      const proxy = createRecursiveProxy(async ({ path, args }) => {
-        const fullPath = path.join('.');
-
-        if (path.length === 1 && path[0] === '_def') {
-          return _def;
-        }
-
-        const procedure = _def.procedures[fullPath] as AnyProcedure;
-
-        let ctx: Context | undefined = undefined;
-        try {
-          ctx = isFunction(ctxOrCallback)
-            ? await Promise.resolve(ctxOrCallback())
-            : ctxOrCallback;
-
-          return await procedure({
-            path: fullPath,
-            getRawInput: async () => args[0],
-            ctx,
-            type: procedure._def.type,
-          });
-        } catch (cause) {
-          options?.onError?.({
-            ctx,
-            error: getTRPCErrorFromUnknown(cause),
-            input: args[0],
-            path: fullPath,
-            type: procedure._def.type,
-          });
-          throw cause;
-        }
-      });
-
-      return proxy as ReturnType<RouterCaller<any, any>>;
+      return createRecursiveProxy<ReturnType<RouterCaller<any, any>>>(
+        async ({ path, args }) => {
+          const fullPath = path.join('.');
+
+          if (path.length === 1 && path[0] === '_def') {
+            return _def;
+          }
+
+          const procedure = _def.procedures[fullPath] as AnyProcedure;
+
+          let ctx: Context | undefined = undefined;
+          try {
+            ctx = isFunction(ctxOrCallback)
+              ? await Promise.resolve(ctxOrCallback())
+              : ctxOrCallback;
+
+            return await procedure({
+              path: fullPath,
+              getRawInput: async () => args[0],
+              ctx,
+              type: procedure._def.type,
+            });
+          } catch (cause) {
+            options?.onError?.({
+              ctx,
+              error: getTRPCErrorFromUnknown(cause),
+              input: args[0],
+              path: fullPath,
+              type: procedure._def.type,
+            });
+            throw cause;
+          }
+        },
+      );
     };
   };
 }

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

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/no-namespace */
+import type { TRPCRequestInfo } from '../http/types';
 import type { ProcedureType } from '../procedure';
 import type { TRPC_ERROR_CODE_NUMBER } from './codes';
 
@@ -131,3 +132,11 @@ export type TRPCClientIncomingMessage<
   TResult = unknown,
   TError extends TRPCErrorShape = TRPCErrorShape,
 > = TRPCClientIncomingRequest | TRPCResponseMessage<TResult, TError>;
+
+/**
+ * The client sends connection params - always sent as the first message
+ */
+export interface TRPCConnectionParamsMessage
+  extends JSONRPC2.BaseRequest<'connectionParams'> {
+  data: TRPCRequestInfo['connectionParams'];
+}

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

@@ -17,5 +17,6 @@ export type {
   TRPCResultMessage,
   TRPCSubscriptionStopNotification,
   TRPCSuccessResponse,
+  TRPCConnectionParamsMessage,
 } from './envelopes';
 export { parseTRPCMessage } from './parseTRPCMessage';