@trpc/server 9.23.6 → 9.25.1

package/dist/trpc-server.esm.js

@@ -1,17 +1,14 @@
-import { a as assertNotBrowser, g as getHTTPStatusCodeFromError } from './resolveHTTPResponse-ddb56677.esm.js';
 export { a as assertNotBrowser, r as resolveHTTPResponse } from './resolveHTTPResponse-ddb56677.esm.js';
+export { L as LegacyRouter, L as Router, r as router } from './router-93491dae.esm.js';
 export { S as Subscription, s as subscriptionPullFactory } from './subscription-2ea469a3.esm.js';
-import { T as TRPCError, g as getErrorFromUnknown } from './transformTRPCResponse-45c225c3.esm.js';
 export { T as TRPCError } from './transformTRPCResponse-45c225c3.esm.js';
 import { createHTTPServer, createHTTPHandler } from '../adapters/standalone/dist/trpc-server-adapters-standalone.esm.js';
 import { n as nodeHTTPRequestHandler } from './nodeHTTPRequestHandler-372a4a4f.esm.js';
-import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-5678cc97.esm.js';
+import './codes-5678cc97.esm.js';
 import 'events';
 import 'http';
 import 'url';
 
-assertNotBrowser();
-
 // this has been moved to separate package
 
 /**
@@ -36,501 +33,4 @@ const requestHandler = nodeHTTPRequestHandler;
  * @deprecated use `NodeHTTPCreateContextFn` from `@trpc/server/adapters/node-http`
  */
 
-const middlewareMarker = 'middlewareMarker';
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-assertNotBrowser();
-
-function getParseFn(procedureParser) {
-  const parser = procedureParser;
-
-  if (typeof parser === 'function') {
-    // ProcedureParserCustomValidatorEsque
-    return parser;
-  }
-
-  if (typeof parser.parseAsync === 'function') {
-    // ProcedureParserZodEsque
-    return parser.parseAsync.bind(parser);
-  }
-
-  if (typeof parser.parse === 'function') {
-    // ProcedureParserZodEsque
-    return parser.parse.bind(parser);
-  }
-
-  if (typeof parser.validateSync === 'function') {
-    // ProcedureParserYupEsque
-    return parser.validateSync.bind(parser);
-  }
-
-  if (typeof parser.create === 'function') {
-    // ProcedureParserSuperstructEsque
-    return parser.create.bind(parser);
-  }
-
-  throw new Error('Could not find a validator fn');
-}
-/**
- * @internal
- */
-
-
-class Procedure {
-  constructor(opts) {
-    this.middlewares = void 0;
-    this.resolver = void 0;
-    this.inputParser = void 0;
-    this.parseInputFn = void 0;
-    this.outputParser = void 0;
-    this.parseOutputFn = void 0;
-    this.meta = void 0;
-    this.middlewares = opts.middlewares;
-    this.resolver = opts.resolver;
-    this.inputParser = opts.inputParser;
-    this.parseInputFn = getParseFn(this.inputParser);
-    this.outputParser = opts.outputParser;
-    this.parseOutputFn = getParseFn(this.outputParser);
-    this.meta = opts.meta;
-  }
-
-  async parseInput(rawInput) {
-    try {
-      return await this.parseInputFn(rawInput);
-    } catch (cause) {
-      throw new TRPCError({
-        code: 'BAD_REQUEST',
-        cause
-      });
-    }
-  }
-
-  async parseOutput(rawOutput) {
-    try {
-      return await this.parseOutputFn(rawOutput);
-    } catch (cause) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        cause,
-        message: 'Output validation failed'
-      });
-    }
-  }
-  /**
-   * Trigger middlewares in order, parse raw input, call resolver & parse raw output
-   * @internal
-   */
-
-
-  async call(opts) {
-    // wrap the actual resolver and treat as the last "middleware"
-    const middlewaresWithResolver = this.middlewares.concat([async ({
-      ctx
-    }) => {
-      const input = await this.parseInput(opts.rawInput);
-      const rawOutput = await this.resolver({ ...opts,
-        ctx,
-        input
-      });
-      const data = await this.parseOutput(rawOutput);
-      return {
-        marker: middlewareMarker,
-        ok: true,
-        data,
-        ctx
-      };
-    }]); // run the middlewares recursively with the resolver as the last one
-
-    const callRecursive = async (callOpts = {
-      index: 0,
-      ctx: opts.ctx
-    }) => {
-      try {
-        const result = await middlewaresWithResolver[callOpts.index]({
-          ctx: callOpts.ctx,
-          type: opts.type,
-          path: opts.path,
-          rawInput: opts.rawInput,
-          meta: this.meta,
-          next: async nextOpts => {
-            return await callRecursive({
-              index: callOpts.index + 1,
-              ctx: nextOpts ? nextOpts.ctx : callOpts.ctx
-            });
-          }
-        });
-        return result;
-      } catch (cause) {
-        return {
-          ctx: callOpts.ctx,
-          ok: false,
-          error: getErrorFromUnknown(cause),
-          marker: middlewareMarker
-        };
-      }
-    }; // there's always at least one "next" since we wrap this.resolver in a middleware
-
-
-    const result = await callRecursive();
-
-    if (!result) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: 'No result from middlewares - did you forget to `return next()`?'
-      });
-    }
-
-    if (!result.ok) {
-      // re-throw original error
-      throw result.error;
-    }
-
-    return result.data;
-  }
-  /**
-   * Create new procedure with passed middlewares
-   * @param middlewares
-   */
-
-
-  inheritMiddlewares(middlewares) {
-    const Constructor = this.constructor;
-    const instance = new Constructor({
-      middlewares: [...middlewares, ...this.middlewares],
-      resolver: this.resolver,
-      inputParser: this.inputParser,
-      outputParser: this.outputParser,
-      meta: this.meta
-    });
-    return instance;
-  }
-
-}
-function createProcedure(opts) {
-  const inputParser = 'input' in opts ? opts.input : input => {
-    if (input != null) {
-      throw new TRPCError({
-        code: 'BAD_REQUEST',
-        message: 'No input expected'
-      });
-    }
-
-    return undefined;
-  };
-  const outputParser = 'output' in opts && opts.output ? opts.output : output => output;
-  return new Procedure({
-    inputParser: inputParser,
-    resolver: opts.resolve,
-    middlewares: [],
-    outputParser: outputParser,
-    meta: opts.meta
-  });
-}
-
-/* eslint-disable @typescript-eslint/ban-types */
-assertNotBrowser();
-/**
- * @public
- */
-
-function getDataTransformer(transformer) {
-  if ('input' in transformer) {
-    return transformer;
-  }
-
-  return {
-    input: transformer,
-    output: transformer
-  };
-}
-/**
- * @internal
- */
-
-
-const PROCEDURE_DEFINITION_MAP = {
-  query: 'queries',
-  mutation: 'mutations',
-  subscription: 'subscriptions'
-};
-/**
- * @internal
- */
-
-function safeObject(...args) {
-  return Object.assign(Object.create(null), ...args);
-}
-
-const defaultFormatter = ({
-  shape
-}) => {
-  return shape;
-};
-
-const defaultTransformer = {
-  input: {
-    serialize: obj => obj,
-    deserialize: obj => obj
-  },
-  output: {
-    serialize: obj => obj,
-    deserialize: obj => obj
-  }
-};
-
-/**
- * @internal The type signature of this class may change without warning.
- */
-class Router {
-  constructor(def) {
-    var _def$queries, _def$mutations, _def$subscriptions, _def$middlewares, _def$errorFormatter, _def$transformer;
-
-    this._def = void 0;
-    this._def = {
-      queries: (_def$queries = def === null || def === void 0 ? void 0 : def.queries) !== null && _def$queries !== void 0 ? _def$queries : safeObject(),
-      mutations: (_def$mutations = def === null || def === void 0 ? void 0 : def.mutations) !== null && _def$mutations !== void 0 ? _def$mutations : safeObject(),
-      subscriptions: (_def$subscriptions = def === null || def === void 0 ? void 0 : def.subscriptions) !== null && _def$subscriptions !== void 0 ? _def$subscriptions : safeObject(),
-      middlewares: (_def$middlewares = def === null || def === void 0 ? void 0 : def.middlewares) !== null && _def$middlewares !== void 0 ? _def$middlewares : [],
-      errorFormatter: (_def$errorFormatter = def === null || def === void 0 ? void 0 : def.errorFormatter) !== null && _def$errorFormatter !== void 0 ? _def$errorFormatter : defaultFormatter,
-      transformer: (_def$transformer = def === null || def === void 0 ? void 0 : def.transformer) !== null && _def$transformer !== void 0 ? _def$transformer : defaultTransformer
-    };
-  }
-
-  static prefixProcedures(procedures, prefix) {
-    const eps = safeObject();
-
-    for (const key in procedures) {
-      eps[prefix + key] = procedures[key];
-    }
-
-    return eps;
-  }
-
-  query(path, procedure) {
-    const router = new Router({
-      queries: safeObject({
-        [path]: createProcedure(procedure)
-      })
-    });
-    return this.merge(router);
-  }
-
-  mutation(path, procedure) {
-    const router = new Router({
-      mutations: safeObject({
-        [path]: createProcedure(procedure)
-      })
-    });
-    return this.merge(router);
-  }
-  /**
-   * @beta Might change without a major version bump
-   */
-
-
-  subscription(path, procedure) {
-    const router = new Router({
-      subscriptions: safeObject({
-        [path]: createProcedure(procedure)
-      })
-    });
-    return this.merge(router);
-  }
-  /**
-   * Merge router with other router
-   * @param router
-   */
-
-
-  merge(prefixOrRouter, maybeRouter) {
-    let prefix = '';
-    let childRouter;
-
-    if (typeof prefixOrRouter === 'string' && maybeRouter instanceof Router) {
-      prefix = prefixOrRouter;
-      childRouter = maybeRouter;
-    } else if (prefixOrRouter instanceof Router) {
-      childRouter = prefixOrRouter;
-    }
-    /* istanbul ignore next */
-    else {
-      throw new Error('Invalid args');
-    }
-
-    const duplicateQueries = Object.keys(childRouter._def.queries).filter(key => !!this._def['queries'][prefix + key]);
-    const duplicateMutations = Object.keys(childRouter._def.mutations).filter(key => !!this._def['mutations'][prefix + key]);
-    const duplicateSubscriptions = Object.keys(childRouter._def.subscriptions).filter(key => !!this._def['subscriptions'][prefix + key]);
-    const duplicates = [...duplicateQueries, ...duplicateMutations, ...duplicateSubscriptions];
-
-    if (duplicates.length) {
-      throw new Error(`Duplicate endpoint(s): ${duplicates.join(', ')}`);
-    }
-
-    const mergeProcedures = defs => {
-      const newDefs = safeObject();
-
-      for (const key in defs) {
-        const procedure = defs[key];
-        const newProcedure = procedure.inheritMiddlewares(this._def.middlewares);
-        newDefs[key] = newProcedure;
-      }
-
-      return Router.prefixProcedures(newDefs, prefix);
-    };
-
-    return new Router({ ...this._def,
-      queries: safeObject(this._def.queries, mergeProcedures(childRouter._def.queries)),
-      mutations: safeObject(this._def.mutations, mergeProcedures(childRouter._def.mutations)),
-      subscriptions: safeObject(this._def.subscriptions, mergeProcedures(childRouter._def.subscriptions))
-    });
-  }
-  /**
-   * Invoke procedure. Only for internal use within library.
-   */
-
-
-  async call(opts) {
-    const {
-      type,
-      path
-    } = opts;
-    const defTarget = PROCEDURE_DEFINITION_MAP[type];
-    const defs = this._def[defTarget];
-    const procedure = defs[path];
-
-    if (!procedure) {
-      throw new TRPCError({
-        code: 'NOT_FOUND',
-        message: `No "${type}"-procedure on path "${path}"`
-      });
-    }
-
-    return procedure.call(opts);
-  }
-
-  createCaller(ctx) {
-    return {
-      query: (path, ...args) => {
-        return this.call({
-          type: 'query',
-          ctx,
-          path,
-          rawInput: args[0]
-        });
-      },
-      mutation: (path, ...args) => {
-        return this.call({
-          type: 'mutation',
-          ctx,
-          path,
-          rawInput: args[0]
-        });
-      },
-      subscription: (path, ...args) => {
-        return this.call({
-          type: 'subscription',
-          ctx,
-          path,
-          rawInput: args[0]
-        });
-      }
-    };
-  }
-  /**
-   * Function to be called before any procedure is invoked
-   * @link https://trpc.io/docs/middlewares
-   */
-
-
-  middleware(middleware) {
-    return new Router({ ...this._def,
-      middlewares: [...this._def.middlewares, middleware]
-    });
-  }
-  /**
-   * Format errors
-   * @link https://trpc.io/docs/error-formatting
-   */
-
-
-  formatError(errorFormatter) {
-    if (this._def.errorFormatter !== defaultFormatter) {
-      throw new Error('You seem to have double `formatError()`-calls in your router tree');
-    }
-
-    return new Router({ ...this._def,
-      errorFormatter: errorFormatter
-    });
-  }
-
-  getErrorShape(opts) {
-    const {
-      path,
-      error
-    } = opts;
-    const {
-      code
-    } = opts.error;
-    const shape = {
-      message: error.message,
-      code: TRPC_ERROR_CODES_BY_KEY[code],
-      data: {
-        code,
-        httpStatus: getHTTPStatusCodeFromError(error)
-      }
-    };
-
-    if (process.env.NODE_ENV !== 'production' && typeof opts.error.stack === 'string') {
-      shape.data.stack = opts.error.stack;
-    }
-
-    if (typeof path === 'string') {
-      shape.data.path = path;
-    }
-
-    return this._def.errorFormatter({ ...opts,
-      shape
-    });
-  }
-  /**
-   * Add data transformer to serialize/deserialize input args + output
-   * @link https://trpc.io/docs/data-transformers
-   */
-
-
-  transformer(_transformer) {
-    const transformer = getDataTransformer(_transformer);
-
-    if (this._def.transformer !== defaultTransformer) {
-      throw new Error('You seem to have double `transformer()`-calls in your router tree');
-    }
-
-    return new Router({ ...this._def,
-      transformer
-    });
-  }
-  /**
-   * Flattens the generics of TQueries/TMutations/TSubscriptions.
-   * ⚠️ Experimental - might disappear. ⚠️
-   *
-   * @alpha
-   */
-
-
-  flat() {
-    return this;
-  }
-
-}
-/**
- * Subclass of `VNextRouter` with `TInputContext` and `TContext` set to the same type, for backcompat.
- *
- * @deprecated
- */
-
-class LegacyRouter extends Router {}
-function router() {
-  return new Router();
-}
-
-export { LegacyRouter, LegacyRouter as Router, createHttpHandler, createHttpServer, requestHandler, router };
+export { createHttpHandler, createHttpServer, requestHandler };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "9.23.6",
+  "version": "9.25.1",
   "description": "tRPC Server",
   "author": "KATT",
   "license": "MIT",
@@ -24,6 +24,8 @@
       "adapters/node-http/index.ts",
       "adapters/standalone.ts",
       "adapters/ws.ts",
+      "adapters/lambda/index.ts",
+      "adapters/aws-lambda/index.ts",
       "ws/index.ts",
       "rpc/index.ts"
     ]
@@ -47,6 +49,7 @@
   },
   "devDependencies": {
     "@fastify/websocket": "^5.0.0",
+    "@types/aws-lambda": "^8.10.97",
     "@types/express": "^4.17.12",
     "@types/hash-sum": "^1.0.0",
     "@types/ws": "^8.2.0",
@@ -67,5 +70,5 @@
     "yup": "^0.32.8",
     "zod": "^3.0.0"
   },
-  "gitHead": "c4138897578949d910dd0bce9e1471a6ae73137e"
+  "gitHead": "2f26e632a648ebfdc9da10f57a127d588162b976"
 }

package/src/adapters/aws-lambda/index.ts

@@ -0,0 +1,156 @@
+import type {
+  Context as APIGWContext,
+  APIGatewayProxyEvent,
+  APIGatewayProxyEventV2,
+  APIGatewayProxyResult,
+  APIGatewayProxyStructuredResultV2,
+} from 'aws-lambda';
+import { TRPCError, resolveHTTPResponse } from '../..';
+import { HTTPHeaders, HTTPRequest } from '../../http/internals/types';
+import type { HTTPResponse } from '../../http/internals/types';
+import { AnyRouter, inferRouterContext } from '../../router';
+import {
+  APIGatewayEvent,
+  APIGatewayResult,
+  AWSLambdaOptions,
+  UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE,
+  isPayloadV1,
+  isPayloadV2,
+} from './utils';
+
+export type { CreateAWSLambdaContextOptions, AWSLambdaOptions } from './utils';
+
+function lambdaEventToHTTPRequest(event: APIGatewayEvent): HTTPRequest {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(
+    event.queryStringParameters ?? {},
+  )) {
+    if (typeof value !== 'undefined') {
+      query.append(key, value);
+    }
+  }
+
+  return {
+    method: getHTTPMethod(event),
+    query: query,
+    headers: event.headers,
+    body: event.body,
+  };
+}
+
+function getHTTPMethod(event: APIGatewayEvent) {
+  if (isPayloadV1(event)) {
+    return event.httpMethod;
+  }
+  if (isPayloadV2(event)) {
+    return event.requestContext.http.method;
+  }
+  throw new TRPCError({
+    code: 'INTERNAL_SERVER_ERROR',
+    message: UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE,
+  });
+}
+function getPath(event: APIGatewayEvent) {
+  if (isPayloadV1(event)) {
+    return event.path.slice(1);
+  }
+  if (isPayloadV2(event)) {
+    return event.rawPath.slice(1);
+  }
+  throw new TRPCError({
+    code: 'INTERNAL_SERVER_ERROR',
+    message: UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE,
+  });
+}
+function transformHeaders(headers: HTTPHeaders): APIGatewayResult['headers'] {
+  const obj: APIGatewayResult['headers'] = {};
+
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === 'undefined') {
+      continue;
+    }
+    obj[key] = Array.isArray(value) ? value.join(',') : value;
+  }
+  return obj;
+}
+function tRPCOutputToAPIGatewayOutput<
+  TEvent extends APIGatewayEvent,
+  TResult extends APIGatewayResult,
+>(event: TEvent, response: HTTPResponse): TResult {
+  if (isPayloadV1(event)) {
+    const resp: APIGatewayProxyResult = {
+      statusCode: response.status,
+      body: response.body ?? '',
+      headers: transformHeaders(response.headers ?? {}),
+    };
+    return resp as TResult;
+  } else if (isPayloadV2(event)) {
+    const resp: APIGatewayProxyStructuredResultV2 = {
+      statusCode: response.status,
+      body: response.body ?? undefined,
+      headers: transformHeaders(response.headers ?? {}),
+    };
+    return resp as TResult;
+  } else {
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE,
+    });
+  }
+}
+
+/** Will check the createContext of the TRouter and get the parameter of event.
+ * @internal
+ **/
+type inferAPIGWEvent<
+  TRouter extends AnyRouter,
+  TEvent extends APIGatewayEvent,
+> = AWSLambdaOptions<TRouter, TEvent>['createContext'] extends NonNullable<
+  AWSLambdaOptions<TRouter, TEvent>['createContext']
+>
+  ? Parameters<AWSLambdaOptions<TRouter, TEvent>['createContext']>[0]['event']
+  : APIGatewayEvent;
+
+/** 1:1 mapping of v1 or v2 input events, deduces which is which.
+ * @internal
+ **/
+type inferAPIGWReturn<T> = T extends APIGatewayProxyEvent
+  ? APIGatewayProxyResult
+  : T extends APIGatewayProxyEventV2
+  ? APIGatewayProxyStructuredResultV2
+  : never;
+export function awsLambdaRequestHandler<
+  TRouter extends AnyRouter,
+  TEvent extends inferAPIGWEvent<TRouter, TEvent>,
+  TResult extends inferAPIGWReturn<TEvent>,
+>(
+  opts: AWSLambdaOptions<TRouter, TEvent>,
+): (event: TEvent, context: APIGWContext) => Promise<TResult> {
+  return async (event, context) => {
+    const req = lambdaEventToHTTPRequest(event);
+    const path = getPath(event);
+    const createContext = async function _createContext(): Promise<
+      inferRouterContext<TRouter>
+    > {
+      return await opts.createContext?.({ event, context });
+    };
+
+    const response = await resolveHTTPResponse({
+      router: opts.router,
+      batching: opts.batching,
+      responseMeta: opts?.responseMeta,
+      createContext,
+      req,
+      path,
+      error: null,
+      onError(o) {
+        opts?.onError?.({
+          ...o,
+          req: event,
+        });
+      },
+    });
+
+    return tRPCOutputToAPIGatewayOutput<TEvent, TResult>(event, response);
+  };
+}