@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/contentType.ts

@@ -1,16 +1,21 @@
 import { TRPCError } from '../error/TRPCError';
-import type { RootConfig } from '../rootConfig';
+import type { AnyProcedure, ProcedureType } from '../procedure';
+import type { AnyRouter } from '../router';
 import { isObject, unsetMarker } from '../utils';
-import type { TRPCRequestInfo } from './types';
+import { parseConnectionParamsFromString } from './parseConnectionParams';
+import type { TRPCAcceptHeader, TRPCRequestInfo } from './types';
+
+type GetRequestInfoOptions = {
+  path: string;
+  req: Request;
+  searchParams: URLSearchParams;
+  headers: Headers;
+  router: AnyRouter;
+};
 
 type ContentTypeHandler = {
   isMatch: (opts: Request) => boolean;
-  parse: (opts: {
-    path: string;
-    req: Request;
-    searchParams: URLSearchParams;
-    config: RootConfig<any>;
-  }) => TRPCRequestInfo;
+  parse: (opts: GetRequestInfoOptions) => TRPCRequestInfo;
 };
 
 /**
@@ -82,7 +87,7 @@ const jsonContentTypeHandler: ContentTypeHandler = {
 
       if (!isBatchCall) {
         return {
-          0: opts.config.transformer.input.deserialize(inputs),
+          0: opts.router._def._config.transformer.input.deserialize(inputs),
         };
       }
 
@@ -96,26 +101,80 @@ const jsonContentTypeHandler: ContentTypeHandler = {
       for (const index of paths.keys()) {
         const input = inputs[index];
         if (input !== undefined) {
-          acc[index] = opts.config.transformer.input.deserialize(input);
+          acc[index] =
+            opts.router._def._config.transformer.input.deserialize(input);
         }
       }
 
       return acc;
     });
 
-    return {
-      isBatchCall,
-      calls: paths.map((path, index) => ({
+    const calls = paths.map((path, index): TRPCRequestInfo['calls'][number] => {
+      const procedure: AnyProcedure | null =
+        opts.router._def.procedures[path] ?? null;
+      return {
         path,
+        procedure,
         getRawInput: async () => {
           const inputs = await getInputs.read();
-          return inputs[index];
+          let input = inputs[index];
+
+          if (procedure?._def.type === 'subscription') {
+            const lastEventId =
+              opts.headers.get('last-event-id') ??
+              opts.searchParams.get('lastEventId') ??
+              opts.searchParams.get('Last-Event-Id');
+
+            if (lastEventId) {
+              if (isObject(input)) {
+                input = {
+                  ...input,
+                  lastEventId: lastEventId,
+                };
+              } else {
+                input ??= {
+                  lastEventId: lastEventId,
+                };
+              }
+            }
+          }
+          return input;
         },
         result: () => {
           return getInputs.result()?.[index];
         },
-      })),
+      };
+    });
+
+    const types = new Set(
+      calls.map((call) => call.procedure?._def.type).filter(Boolean),
+    );
+
+    /* istanbul ignore if -- @preserve */
+    if (types.size > 1) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: `Cannot mix procedure types in call: ${Array.from(types).join(
+          ', ',
+        )}`,
+      });
+    }
+    const type: ProcedureType | 'unknown' =
+      types.values().next().value ?? 'unknown';
+
+    const connectionParamsStr = opts.searchParams.get('connectionParams');
+
+    const info: TRPCRequestInfo = {
+      isBatchCall,
+      accept: req.headers.get('trpc-accept') as TRPCAcceptHeader | null,
+      calls,
+      type,
+      connectionParams:
+        connectionParamsStr === null
+          ? null
+          : parseConnectionParamsFromString(connectionParamsStr),
     };
+    return info;
   },
 };
 
@@ -137,14 +196,18 @@ const formDataContentTypeHandler: ContentTypeHandler = {
       return fd;
     });
     return {
+      accept: null,
       calls: [
         {
           path: opts.path,
           getRawInput: getInputs.read,
           result: getInputs.result,
+          procedure: opts.router._def.procedures[opts.path] ?? null,
         },
       ],
       isBatchCall: false,
+      type: 'mutation',
+      connectionParams: null,
     };
   },
 };
@@ -173,9 +236,13 @@ const octetStreamContentTypeHandler: ContentTypeHandler = {
           path: opts.path,
           getRawInput: getInputs.read,
           result: getInputs.result,
+          procedure: opts.router._def.procedures[opts.path] ?? null,
         },
       ],
       isBatchCall: false,
+      accept: null,
+      type: 'mutation',
+      connectionParams: null,
     };
   },
 };
@@ -205,12 +272,7 @@ function getContentTypeHandler(req: Request): ContentTypeHandler {
   });
 }
 
-export function getRequestInfo(opts: {
-  path: string;
-  req: Request;
-  searchParams: URLSearchParams;
-  config: RootConfig<any>;
-}): TRPCRequestInfo {
+export function getRequestInfo(opts: GetRequestInfoOptions): TRPCRequestInfo {
   const handler = getContentTypeHandler(opts.req);
   return handler.parse(opts);
 }

package/src/{adapters/next-app-dir → unstable-core-do-not-import/http}/formDataToObject.ts

@@ -1,18 +1,25 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+const isNumberString = (str: string) => /^\d+$/.test(str);
+
 function set(
   obj: Record<string, any>,
-  path: string[] | string,
+  path: readonly string[],
   value: unknown,
 ): void {
-  if (typeof path === 'string') {
-    path = path.split(/[\.\[\]]/).filter(Boolean);
-  }
-
   if (path.length > 1) {
-    const p = path.shift()!;
-    const isArrayIndex = /^\d+$/.test(path[0]!);
-    obj[p] = obj[p] || (isArrayIndex ? [] : {});
-    set(obj[p], path, value);
+    const newPath = [...path];
+    const key = newPath.shift()!;
+    const nextKey = newPath[0]!;
+
+    if (!obj[key]) {
+      obj[key] = isNumberString(nextKey) ? [] : {};
+    } else if (Array.isArray(obj[key]) && !isNumberString(nextKey)) {
+      obj[key] = Object.fromEntries(Object.entries(obj[key]));
+    }
+
+    set(obj[key], newPath, value);
+
     return;
   }
   const p = path[0]!;
@@ -29,7 +36,8 @@ export function formDataToObject(formData: FormData) {
   const obj: Record<string, unknown> = {};
 
   for (const [key, value] of formData.entries()) {
-    set(obj, key, value);
+    const parts = key.split(/[\.\[\]]/).filter(Boolean);
+    set(obj, parts, value);
   }
 
   return obj;

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

@@ -1,7 +1,7 @@
-import type { DefaultErrorData } from '../error/formatter';
 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 { isObject } from '../utils';
 
 const JSONRPC2_TO_HTTP_CODE: Record<
   keyof typeof TRPC_ERROR_CODES_BY_KEY,
@@ -33,12 +33,9 @@ export function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]): number {
   const arr = Array.isArray(json) ? json : [json];
   const httpStatuses = new Set<number>(
     arr.map((res) => {
-      if ('error' in res) {
-        const data = res.error.data as
-          | Record<string, unknown>
-          | DefaultErrorData;
-        if (typeof data.httpStatus === 'number') {
-          return data.httpStatus;
+      if ('error' in res && isObject(res.error.data)) {
+        if (typeof res.error.data?.['httpStatus'] === 'number') {
+          return res.error.data['httpStatus'];
         }
         const code = TRPC_ERROR_CODES_BY_NUMBER[res.error.code];
         return getStatusCodeFromKey(code);

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

@@ -0,0 +1,49 @@
+import { TRPCError } from '../error/TRPCError';
+import { isObject } from '../utils';
+import type { TRPCRequestInfo } from './types';
+
+export function parseConnectionParamsFromUnknown(
+  parsed: unknown,
+): TRPCRequestInfo['connectionParams'] {
+  try {
+    if (parsed === null) {
+      return null;
+    }
+    if (!isObject(parsed)) {
+      throw new Error('Expected object');
+    }
+    const nonStringValues = Object.entries(parsed).filter(
+      ([_key, value]) => typeof value !== 'string',
+    );
+
+    if (nonStringValues.length > 0) {
+      throw new Error(
+        `Expected connectionParams to be string values. Got ${nonStringValues
+          .map(([key, value]) => `${key}: ${typeof value}`)
+          .join(', ')}`,
+      );
+    }
+    return parsed as Record<string, string>;
+  } catch (cause) {
+    throw new TRPCError({
+      code: 'PARSE_ERROR',
+      message: 'Invalid connection params shape',
+      cause,
+    });
+  }
+}
+export function parseConnectionParamsFromString(
+  str: string,
+): TRPCRequestInfo['connectionParams'] {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(str);
+  } catch (cause) {
+    throw new TRPCError({
+      code: 'PARSE_ERROR',
+      message: 'Not JSON-parsable query params',
+      cause,
+    });
+  }
+  return parseConnectionParamsFromUnknown(parsed);
+}