@trpc/server 11.0.0-rc.361 → 11.0.0-rc.363

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

@@ -0,0 +1,386 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { getErrorShape } from '../error/getErrorShape';
+import { getTRPCErrorFromUnknown, TRPCError } from '../error/TRPCError';
+import type { ProcedureType } from '../procedure';
+import {
+  callProcedure,
+  type AnyRouter,
+  type inferRouterContext,
+  type inferRouterError,
+} from '../router';
+import type { TRPCResponse } from '../rpc';
+import { transformTRPCResponse } from '../transformer';
+import { getBatchStreamFormatter } from './batchStreamFormatter';
+import { getRequestInfo } from './contentType';
+import { getHTTPStatusCode } from './getHTTPStatusCode';
+import type {
+  HTTPBaseHandlerOptions,
+  ResolveHTTPRequestOptionsContextFn,
+  TRPCRequestInfo,
+} from './types';
+
+const HTTP_METHOD_PROCEDURE_TYPE_MAP: Record<
+  string,
+  ProcedureType | undefined
+> = {
+  GET: 'query',
+  POST: 'mutation',
+};
+
+interface ResolveHTTPRequestOptions<TRouter extends AnyRouter>
+  extends HTTPBaseHandlerOptions<TRouter, Request> {
+  createContext: ResolveHTTPRequestOptionsContextFn<TRouter>;
+  req: Request;
+  path: string;
+  /**
+   * If the request had an issue before reaching the handler
+   */
+  error: TRPCError | null;
+}
+
+function initResponse<TRouter extends AnyRouter, TRequest>(initOpts: {
+  ctx: inferRouterContext<TRouter> | undefined;
+  info: TRPCRequestInfo | undefined;
+  type: ProcedureType | 'unknown';
+  responseMeta?: HTTPBaseHandlerOptions<TRouter, TRequest>['responseMeta'];
+  untransformedJSON?:
+    | TRPCResponse<unknown, inferRouterError<TRouter>>
+    | TRPCResponse<unknown, inferRouterError<TRouter>>[]
+    | undefined;
+  errors: TRPCError[];
+}) {
+  const {
+    ctx,
+    info,
+    type,
+    responseMeta,
+    untransformedJSON,
+    errors = [],
+  } = initOpts;
+
+  let status = untransformedJSON ? getHTTPStatusCode(untransformedJSON) : 200;
+
+  const headers = new Headers([['Content-Type', 'application/json']]);
+
+  const eagerGeneration = !untransformedJSON;
+  const data = eagerGeneration
+    ? []
+    : Array.isArray(untransformedJSON)
+    ? untransformedJSON
+    : [untransformedJSON];
+
+  const meta =
+    responseMeta?.({
+      ctx,
+      info,
+      paths: info?.calls.map((call) => call.path),
+      type,
+      data,
+      errors,
+      eagerGeneration,
+    }) ?? {};
+
+  if (meta.headers) {
+    if (meta.headers instanceof Headers) {
+      for (const [key, value] of meta.headers.entries()) {
+        headers.append(key, value);
+      }
+    } else {
+      /**
+       * @deprecated, delete in v12
+       */
+      for (const [key, value] of Object.entries(meta.headers)) {
+        if (Array.isArray(value)) {
+          for (const v of value) {
+            headers.append(key, v);
+          }
+        } else if (typeof value === 'string') {
+          headers.set(key, value);
+        }
+      }
+    }
+  }
+  if (meta.status) {
+    status = meta.status;
+  }
+
+  return {
+    status,
+    headers,
+  };
+}
+
+function caughtErrorToData<TRouter extends AnyRouter>(
+  cause: unknown,
+  errorOpts: {
+    opts: Pick<
+      ResolveHTTPRequestOptions<TRouter>,
+      'onError' | 'req' | 'router'
+    >;
+    ctx: inferRouterContext<TRouter> | undefined;
+    type: ProcedureType | 'unknown';
+    path?: string;
+    input?: unknown;
+  },
+) {
+  const { router, req, onError } = errorOpts.opts;
+  const error = getTRPCErrorFromUnknown(cause);
+  onError?.({
+    error,
+    path: errorOpts.path,
+    input: errorOpts.input,
+    ctx: errorOpts.ctx,
+    type: errorOpts.type,
+    req,
+  });
+  const untransformedJSON = {
+    error: getErrorShape({
+      config: router._def._config,
+      error,
+      type: errorOpts.type,
+      path: errorOpts.path,
+      input: errorOpts.input,
+      ctx: errorOpts.ctx,
+    }),
+  };
+  const transformedJSON = transformTRPCResponse(
+    router._def._config,
+    untransformedJSON,
+  );
+  const body = JSON.stringify(transformedJSON);
+  return {
+    error,
+    untransformedJSON,
+    body,
+  };
+}
+
+export async function resolveResponse<TRouter extends AnyRouter>(
+  opts: ResolveHTTPRequestOptions<TRouter>,
+): Promise<Response> {
+  const { router, req } = opts;
+
+  const url = new URL(req.url);
+
+  if (req.method === 'HEAD') {
+    // can be used for lambda warmup
+    return new Response(null, {
+      status: 204,
+    });
+  }
+  const allowBatching = opts.allowBatching ?? opts.batching?.enabled ?? true;
+  const allowMethodOverride =
+    (opts.allowMethodOverride ?? false) && req.method === 'POST';
+
+  const type =
+    HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? ('unknown' as const);
+  let ctx: inferRouterContext<TRouter> | undefined = undefined;
+  let info: TRPCRequestInfo | undefined = undefined;
+
+  const isStreamCall = req.headers.get('trpc-batch-mode') === 'stream';
+
+  try {
+    info = getRequestInfo({
+      req,
+      path: decodeURIComponent(opts.path),
+      config: router._def._config,
+      searchParams: url.searchParams,
+    });
+
+    // we create context early so that error handlers may access context information
+    ctx = await opts.createContext({
+      info,
+    });
+
+    if (opts.error) {
+      throw opts.error;
+    }
+    if (info.isBatchCall && !allowBatching) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: `Batching is not enabled on the server`,
+      });
+    }
+    if (type === 'unknown') {
+      throw new TRPCError({
+        message: `Unexpected request method ${req.method}`,
+        code: 'METHOD_NOT_SUPPORTED',
+      });
+    }
+
+    const errors: TRPCError[] = [];
+
+    const promises: Promise<
+      TRPCResponse<unknown, inferRouterError<TRouter>>
+    >[] = info.calls.map(async (call) => {
+      try {
+        const data = await callProcedure({
+          procedures: opts.router._def.procedures,
+          path: call.path,
+          getRawInput: call.getRawInput,
+          ctx,
+          type,
+          allowMethodOverride,
+        });
+        return {
+          result: {
+            data,
+          },
+        };
+      } catch (cause) {
+        const error = getTRPCErrorFromUnknown(cause);
+        errors.push(error);
+        const input = call.result();
+
+        opts.onError?.({
+          error,
+          path: call.path,
+          input,
+          ctx,
+          type: type,
+          req: opts.req,
+        });
+
+        return {
+          error: getErrorShape({
+            config: opts.router._def._config,
+            error,
+            type,
+            path: call.path,
+            input,
+            ctx,
+          }),
+        };
+      }
+    });
+    if (!isStreamCall) {
+      /**
+       * Non-streaming response:
+       * - await all responses in parallel, blocking on the slowest one
+       * - create headers with known response body
+       * - return a complete HTTPResponse
+       */
+
+      const untransformedJSON = await Promise.all(promises);
+      const errors = untransformedJSON.flatMap((response) =>
+        'error' in response ? [response.error] : [],
+      );
+
+      const headResponse = initResponse({
+        ctx,
+        info,
+        type,
+        responseMeta: opts.responseMeta,
+        untransformedJSON,
+        errors,
+      });
+
+      // return body stuff
+      const result = info.isBatchCall
+        ? untransformedJSON
+        : untransformedJSON[0]!;
+      const transformedJSON = transformTRPCResponse(
+        router._def._config,
+        result,
+      );
+      const body = JSON.stringify(transformedJSON);
+
+      return new Response(body, {
+        status: headResponse.status,
+        headers: headResponse.headers,
+      });
+    }
+
+    /**
+     * Streaming response:
+     * - block on none, call `onChunk` as soon as each response is ready
+     * - create headers with minimal data (cannot know the response body in advance)
+     * - return void
+     */
+    const headResponse = initResponse({
+      ctx,
+      info,
+      type,
+      responseMeta: opts.responseMeta,
+      errors: [],
+    });
+
+    const encoder = new TextEncoderStream();
+    const stream = encoder.readable;
+    const controller = encoder.writable.getWriter();
+    async function exec() {
+      const indexedPromises = new Map(
+        promises.map((promise, index) => [
+          index,
+          promise.then((r) => [index, r] as const),
+        ]),
+      );
+      const formatter = getBatchStreamFormatter();
+
+      while (indexedPromises.size > 0) {
+        const [index, untransformedJSON] = await Promise.race(
+          indexedPromises.values(),
+        );
+        indexedPromises.delete(index);
+
+        try {
+          const transformedJSON = transformTRPCResponse(
+            router._def._config,
+            untransformedJSON,
+          );
+          const body = JSON.stringify(transformedJSON);
+
+          await controller.write(formatter(index, body));
+        } catch (cause) {
+          const call = info!.calls[index]!;
+          const input = call.result();
+          const { body } = caughtErrorToData(cause, {
+            opts,
+            ctx,
+            type,
+            path: call.path,
+            input,
+          });
+
+          await controller.write(formatter(index, body));
+        }
+      }
+
+      await controller.write(formatter.end());
+      await controller.close();
+    }
+    exec().catch((err) => controller.abort(err));
+
+    return new Response(stream, {
+      headers: headResponse.headers,
+      status: headResponse.status,
+    });
+  } catch (cause) {
+    // we get here if
+    // - batching is called when it's not enabled
+    // - `createContext()` throws
+    // - `router._def._config.transformer.output.serialize()` throws
+    // - post body is too large
+    // - input deserialization fails
+    // - `errorFormatter` return value is malformed
+    const { error, untransformedJSON, body } = caughtErrorToData(cause, {
+      opts,
+      ctx,
+      type,
+    });
+
+    const headResponse = initResponse({
+      ctx,
+      info,
+      type,
+      responseMeta: opts.responseMeta,
+      untransformedJSON,
+      errors: [error],
+    });
+
+    return new Response(body, {
+      status: headResponse.status,
+      headers: headResponse.headers,
+    });
+  }
+}

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

@@ -8,19 +8,14 @@ import type {
 import type { TRPCResponse } from '../rpc';
 import type { Dict } from '../types';
 
-export type HTTPHeaders = Dict<string[] | string>;
-
-export interface HTTPResponse {
-  status: number;
-  headers?: HTTPHeaders;
-  body?: string;
-}
-
-export type ResponseChunk = [procedureIndex: number, responseBody: string];
+/**
+ * @deprecated use `Headers` instead, this will be removed in v12
+ */
+type HTTPHeaders = Dict<string[] | string>;
 
 export interface ResponseMeta {
   status?: number;
-  headers?: HTTPHeaders;
+  headers?: Headers | HTTPHeaders;
 }
 
 /**
@@ -31,24 +26,18 @@ export type ResponseMetaFn<TRouter extends AnyRouter> = (opts: {
   ctx?: inferRouterContext<TRouter>;
   /**
    * The different tRPC paths requested
+   * @deprecated use `info` instead, this will be removed in v12
    **/
-  paths?: string[];
+  paths: string[] | undefined;
+  info: TRPCRequestInfo | undefined;
   type: ProcedureType | 'unknown';
   errors: TRPCError[];
   /**
-   * `true` if the `ResponseMeta` are being
-   * generated without knowing the response data
-   * (e.g. for streaming requests).
+   * `true` if the `ResponseMeta` is being generated without knowing the response data (e.g. for streamed requests).
    */
-  eagerGeneration?: boolean;
+  eagerGeneration: boolean;
 }) => ResponseMeta;
 
-export interface HTTPRequest {
-  method: string;
-  query: URLSearchParams;
-  headers: HTTPHeaders;
-}
-
 /**
  * Base interface for anything using HTTP
  */
@@ -62,23 +51,29 @@ export interface HTTPBaseHandlerOptions<TRouter extends AnyRouter, TRequest>
   responseMeta?: ResponseMetaFn<TRouter>;
 }
 
-/** @internal */
-export type ProcedureCall = {
-  type: ProcedureType;
+interface TRPCRequestInfoProcedureCall {
   path: string;
-};
+  /**
+   * Read the raw input (deduped and memoized)
+   */
+  getRawInput: () => Promise<unknown>;
+  /**
+   * Get already parsed inputs - won't trigger reading the body or parsing the inputs
+   */
+  result: () => unknown;
+}
 
 /**
  * Information about the incoming request
- * @internal
+ * @public
  */
-export type TRPCRequestInfo = {
+export interface TRPCRequestInfo {
   isBatchCall: boolean;
-  calls: ProcedureCall[];
-};
+  calls: TRPCRequestInfoProcedureCall[];
+}
 
 /**
- * Inner createContext function for `resolveHTTPResponse` used to forward `TRPCRequestInfo` to `createContext`
+ * Inner createContext function for `resolveResponse` used to forward `TRPCRequestInfo` to `createContext`
  * @internal
  */
 export type ResolveHTTPRequestOptionsContextFn<TRouter extends AnyRouter> =

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

@@ -30,6 +30,7 @@ import type {
   Simplify,
   TypeError,
 } from './types';
+import type { UnsetMarker } from './utils';
 import { mergeWithoutOverrides } from './utils';
 
 type IntersectIfDefined<TType, TWith> = TType extends UnsetMarker
@@ -37,10 +38,7 @@ type IntersectIfDefined<TType, TWith> = TType extends UnsetMarker
   : TWith extends UnsetMarker
   ? TType
   : Simplify<TType & TWith>;
-
-/** @internal */
-export const unsetMarker = Symbol('unsetMarker');
-type UnsetMarker = typeof unsetMarker;
+``;
 type DefaultValue<TValue, TFallback> = TValue extends UnsetMarker
   ? TFallback
   : TValue;

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

@@ -97,13 +97,3 @@ export type CreateContextCallback<
     createContext: TFunction;
   }
 >;
-
-/**
- * @internal
- */
-export type WrapCreateContext<TFunction extends (...args: any[]) => any> = {
-  /**
-   * @link https://trpc.io/docs/v11/context
-   **/
-  createContext?: TFunction;
-};

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

@@ -1,3 +1,7 @@
+/** @internal */
+export const unsetMarker = Symbol('unsetMarker');
+export type UnsetMarker = typeof unsetMarker;
+
 /**
  * Ensures there are no duplicate keys when building a procedure.
  * @internal

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

@@ -1,5 +1,5 @@
 /**
- * **DO NOT IMPORT FROM HERE FILE**
+ * **DO NOT IMPORT FROM THIS FILE**
  *
  * This file is here to:
  * - make TypeScript happy and prevent _"The inferred type of 'createContext' cannot be named without a reference to [...]"_.
@@ -12,10 +12,16 @@ export * from './unstable-core-do-not-import/clientish/inference';
 export * from './unstable-core-do-not-import/clientish/inferrable';
 export * from './unstable-core-do-not-import/clientish/serialize';
 export * from './unstable-core-do-not-import/createProxy';
+export * from './unstable-core-do-not-import/error/TRPCError';
 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';
+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/getHTTPStatusCode';
+export * from './unstable-core-do-not-import/http/resolveResponse';
+export * from './unstable-core-do-not-import/http/toURL';
+export * from './unstable-core-do-not-import/http/types';
 export * from './unstable-core-do-not-import/initTRPC';
 export * from './unstable-core-do-not-import/middleware';
 export * from './unstable-core-do-not-import/parser';

package/adapters/node-http/content-type/form-data/index.d.ts

@@ -1 +0,0 @@
-export * from '../../../../dist/adapters/node-http/content-type/form-data';

package/adapters/node-http/content-type/form-data/index.js

@@ -1 +0,0 @@
-module.exports = require('../../../../dist/adapters/node-http/content-type/form-data');

package/adapters/node-http/content-type/json/index.d.ts

@@ -1 +0,0 @@
-export * from '../../../../dist/adapters/node-http/content-type/json';

package/adapters/node-http/content-type/json/index.js

@@ -1 +0,0 @@
-module.exports = require('../../../../dist/adapters/node-http/content-type/json');

package/dist/adapters/aws-lambda/content-type/json/index.d.ts

@@ -1,10 +0,0 @@
-import type { AnyRouter } from '../../../../@trpc/server';
-import type { BaseContentTypeHandler, HTTPRequest } from '../../../../@trpc/server/http';
-import { type APIGatewayEvent, type AWSLambdaOptions } from '../../utils';
-export interface LambdaHTTPContentTypeHandler<TRouter extends AnyRouter, TEvent extends APIGatewayEvent> extends BaseContentTypeHandler<AWSLambdaOptions<TRouter, TEvent> & {
-    event: TEvent;
-    req: HTTPRequest;
-}> {
-}
-export declare const getLambdaHTTPJSONContentTypeHandler: <TRouter extends AnyRouter, TEvent extends APIGatewayEvent>() => LambdaHTTPContentTypeHandler<TRouter, TEvent>;
-//# sourceMappingURL=index.d.ts.map

package/dist/adapters/aws-lambda/content-type/json/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/adapters/aws-lambda/content-type/json/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,SAAS,EAEV,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,sBAAsB,EACtB,WAAW,EACZ,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACtB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,4BAA4B,CAC3C,OAAO,SAAS,SAAS,EACzB,MAAM,SAAS,eAAe,CAC9B,SAAQ,sBAAsB,CAC5B,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,WAAW,CAAC;CAClB,CACF;CAAG;AAEN,eAAO,MAAM,mCAAmC,EAAE,CAChD,OAAO,SAAS,SAAS,EACzB,MAAM,SAAS,eAAe,OACzB,4BAA4B,CAAC,OAAO,EAAE,MAAM,CA6ElD,CAAC"}

package/dist/adapters/aws-lambda/content-type/json/index.js

@@ -1,62 +0,0 @@
-'use strict';
-
-var TRPCError = require('../../../../unstable-core-do-not-import/error/TRPCError.js');
-require('../../../../unstable-core-do-not-import/rootConfig.js');
-var concurrentCache = require('../../../content-handlers/concurrentCache.js');
-var utils = require('../../utils.js');
-
-// @trpc/server
-const getLambdaHTTPJSONContentTypeHandler = ()=>{
-    const cache = concurrentCache.createConcurrentCache();
-    return {
-        name: 'lambda-json',
-        isMatch: (headers)=>{
-            return !!headers.get('content-type')?.startsWith('application/json');
-        },
-        getInputs: async (opts, info)=>{
-            function getRawProcedureInputOrThrow() {
-                const { event , req  } = opts;
-                try {
-                    if (req.query.has('input')) {
-                        const input = req.query.get('input');
-                        if (!input) {
-                            return undefined;
-                        }
-                        return JSON.parse(input);
-                    }
-                    const body = utils.lambdaEventToHTTPBody(opts.event);
-                    if (typeof body === 'string') {
-                        // A mutation with no inputs will have req.body === ''
-                        return body.length === 0 ? undefined : JSON.parse(body);
-                    }
-                    return event.body;
-                } catch (cause) {
-                    throw new TRPCError.TRPCError({
-                        code: 'PARSE_ERROR',
-                        cause
-                    });
-                }
-            }
-            const deserializeInputValue = (rawValue, transformer)=>{
-                return typeof rawValue !== 'undefined' ? transformer.input.deserialize(rawValue) : rawValue;
-            };
-            const rawInput = await cache.concurrentSafeGet('rawInput', ()=>getRawProcedureInputOrThrow());
-            if (rawInput === undefined) {
-                return undefined;
-            }
-            const transformer = opts.router._def._config.transformer;
-            if (!info.isBatchCall) {
-                return cache.concurrentSafeGet('input', ()=>deserializeInputValue(rawInput, transformer));
-            }
-            /* istanbul ignore if  */ if (rawInput == null || typeof rawInput !== 'object' || Array.isArray(rawInput)) {
-                throw new TRPCError.TRPCError({
-                    code: 'BAD_REQUEST',
-                    message: '"input" needs to be an object when doing a batch call'
-                });
-            }
-            return cache.concurrentSafeGet(String(info.batch), ()=>deserializeInputValue(rawInput[info.batch], transformer));
-        }
-    };
-};
-
-exports.getLambdaHTTPJSONContentTypeHandler = getLambdaHTTPJSONContentTypeHandler;