@trpc/server 11.0.0-alpha-tmp-export-from-main.221 → 11.0.0-alpha-tmp-export-from-main.222

package/dist/adapters/aws-lambda/index.d.mts

@@ -0,0 +1,68 @@
+import { APIGatewayProxyEvent, APIGatewayProxyEventV2, APIGatewayProxyResult, APIGatewayProxyStructuredResultV2, Context } from 'aws-lambda';
+import { AnyRouter, inferRouterContext } from '@trpc/server';
+import { TRPCRequestInfo, OnErrorFunction, ResponseMetaFn, HTTPHeaders } from '@trpc/server/http';
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+type APIGatewayEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2;
+type APIGatewayResult = APIGatewayProxyResult | APIGatewayProxyStructuredResultV2;
+type CreateAWSLambdaContextOptions<TEvent extends APIGatewayEvent> = {
+    event: TEvent;
+    context: Context;
+    info: TRPCRequestInfo;
+};
+type AWSLambdaCreateContextFn<TRouter extends AnyRouter, TEvent extends APIGatewayEvent> = ({ event, context, info, }: CreateAWSLambdaContextOptions<TEvent>) => inferRouterContext<TRouter> | Promise<inferRouterContext<TRouter>>;
+type AWSLambdaOptions<TRouter extends AnyRouter, TEvent extends APIGatewayEvent> = {
+    router: TRouter;
+    batching?: {
+        enabled: boolean;
+    };
+    onError?: OnErrorFunction<TRouter, TEvent>;
+    responseMeta?: ResponseMetaFn<TRouter>;
+} & ({
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext: AWSLambdaCreateContextFn<TRouter, TEvent>;
+} | {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext?: AWSLambdaCreateContextFn<TRouter, TEvent>;
+});
+declare function isPayloadV1(event: APIGatewayEvent): event is APIGatewayProxyEvent;
+declare function isPayloadV2(event: APIGatewayEvent): event is APIGatewayProxyEventV2;
+declare function getHTTPMethod(event: APIGatewayEvent): string;
+declare function getPath(event: APIGatewayEvent): string;
+declare function transformHeaders(headers: HTTPHeaders): APIGatewayResult['headers'];
+type DefinedAPIGatewayPayloadFormats = '1.0' | '2.0';
+type APIGatewayPayloadFormatVersion = DefinedAPIGatewayPayloadFormats | 'custom';
+declare const UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE: string;
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+/** 1:1 mapping of v1 or v2 input events, deduces which is which.
+ * @internal
+ **/
+type inferAPIGWReturn<TType> = TType extends APIGatewayProxyEvent ? APIGatewayProxyResult : TType extends APIGatewayProxyEventV2 ? APIGatewayProxyStructuredResultV2 : never;
+declare function awsLambdaRequestHandler<TRouter extends AnyRouter, TEvent extends APIGatewayEvent, TResult extends inferAPIGWReturn<TEvent>>(opts: AWSLambdaOptions<TRouter, TEvent>): (event: TEvent, context: Context) => Promise<TResult>;
+
+export { type APIGatewayEvent, type APIGatewayPayloadFormatVersion, type APIGatewayResult, type AWSLambdaCreateContextFn, type AWSLambdaOptions, type CreateAWSLambdaContextOptions, type DefinedAPIGatewayPayloadFormats, UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE, awsLambdaRequestHandler, getHTTPMethod, getPath, isPayloadV1, isPayloadV2, transformHeaders };

package/dist/adapters/aws-lambda/index.d.ts

@@ -1,3 +1,7 @@
+import { APIGatewayProxyEvent, APIGatewayProxyEventV2, APIGatewayProxyResult, APIGatewayProxyStructuredResultV2, Context } from 'aws-lambda';
+import { AnyRouter, inferRouterContext } from '@trpc/server';
+import { TRPCRequestInfo, OnErrorFunction, ResponseMetaFn, HTTPHeaders } from '@trpc/server/http';
+
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
  *
@@ -8,13 +12,57 @@
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-import type { APIGatewayProxyEvent, APIGatewayProxyEventV2, APIGatewayProxyResult, APIGatewayProxyStructuredResultV2, Context as APIGWContext } from 'aws-lambda';
-import type { AnyRouter } from '../..';
-import type { APIGatewayEvent, AWSLambdaOptions } from './utils';
-export * from './utils';
+
+type APIGatewayEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2;
+type APIGatewayResult = APIGatewayProxyResult | APIGatewayProxyStructuredResultV2;
+type CreateAWSLambdaContextOptions<TEvent extends APIGatewayEvent> = {
+    event: TEvent;
+    context: Context;
+    info: TRPCRequestInfo;
+};
+type AWSLambdaCreateContextFn<TRouter extends AnyRouter, TEvent extends APIGatewayEvent> = ({ event, context, info, }: CreateAWSLambdaContextOptions<TEvent>) => inferRouterContext<TRouter> | Promise<inferRouterContext<TRouter>>;
+type AWSLambdaOptions<TRouter extends AnyRouter, TEvent extends APIGatewayEvent> = {
+    router: TRouter;
+    batching?: {
+        enabled: boolean;
+    };
+    onError?: OnErrorFunction<TRouter, TEvent>;
+    responseMeta?: ResponseMetaFn<TRouter>;
+} & ({
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext: AWSLambdaCreateContextFn<TRouter, TEvent>;
+} | {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext?: AWSLambdaCreateContextFn<TRouter, TEvent>;
+});
+declare function isPayloadV1(event: APIGatewayEvent): event is APIGatewayProxyEvent;
+declare function isPayloadV2(event: APIGatewayEvent): event is APIGatewayProxyEventV2;
+declare function getHTTPMethod(event: APIGatewayEvent): string;
+declare function getPath(event: APIGatewayEvent): string;
+declare function transformHeaders(headers: HTTPHeaders): APIGatewayResult['headers'];
+type DefinedAPIGatewayPayloadFormats = '1.0' | '2.0';
+type APIGatewayPayloadFormatVersion = DefinedAPIGatewayPayloadFormats | 'custom';
+declare const UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE: string;
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
 /** 1:1 mapping of v1 or v2 input events, deduces which is which.
  * @internal
  **/
 type inferAPIGWReturn<TType> = TType extends APIGatewayProxyEvent ? APIGatewayProxyResult : TType extends APIGatewayProxyEventV2 ? APIGatewayProxyStructuredResultV2 : never;
-export declare function awsLambdaRequestHandler<TRouter extends AnyRouter, TEvent extends APIGatewayEvent, TResult extends inferAPIGWReturn<TEvent>>(opts: AWSLambdaOptions<TRouter, TEvent>): (event: TEvent, context: APIGWContext) => Promise<TResult>;
-//# sourceMappingURL=index.d.ts.map
+declare function awsLambdaRequestHandler<TRouter extends AnyRouter, TEvent extends APIGatewayEvent, TResult extends inferAPIGWReturn<TEvent>>(opts: AWSLambdaOptions<TRouter, TEvent>): (event: TEvent, context: Context) => Promise<TResult>;
+
+export { type APIGatewayEvent, type APIGatewayPayloadFormatVersion, type APIGatewayResult, type AWSLambdaCreateContextFn, type AWSLambdaOptions, type CreateAWSLambdaContextOptions, type DefinedAPIGatewayPayloadFormats, UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE, awsLambdaRequestHandler, getHTTPMethod, getPath, isPayloadV1, isPayloadV2, transformHeaders };

package/dist/adapters/aws-lambda/index.js

@@ -1,7 +1,97 @@
-'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-var core = require('@trpc/core');
-var utils = require('./utils.js');
+var server = require('@trpc/server');
+var http = require('@trpc/server/http');
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */ // @trpc/server
+function isPayloadV1(event) {
+    return determinePayloadFormat(event) == '1.0';
+}
+function isPayloadV2(event) {
+    return determinePayloadFormat(event) == '2.0';
+}
+function determinePayloadFormat(event) {
+    // https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+    // According to AWS support, version is is extracted from the version property in the event.
+    // If there is no version property, then the version is implied as 1.0
+    const unknownEvent = event;
+    if (typeof unknownEvent.version === 'undefined') {
+        return '1.0';
+    } else {
+        if ([
+            '1.0',
+            '2.0'
+        ].includes(unknownEvent.version)) {
+            return unknownEvent.version;
+        } else {
+            return 'custom';
+        }
+    }
+}
+function getHTTPMethod(event) {
+    if (isPayloadV1(event)) {
+        return event.httpMethod;
+    }
+    if (isPayloadV2(event)) {
+        return event.requestContext.http.method;
+    }
+    throw new server.TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE
+    });
+}
+function getPath(event) {
+    if (isPayloadV1(event)) {
+        if (!event.pathParameters) {
+            // Then this event was not triggered by a resource denoted with {proxy+}
+            return event.path.split('/').pop() ?? '';
+        }
+        const matches = event.resource.matchAll(/\{(.*?)\}/g);
+        for (const match of matches){
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const group = match[1];
+            if (group.includes('+') && event.pathParameters) {
+                return event.pathParameters[group.replace('+', '')] ?? '';
+            }
+        }
+        return event.path.slice(1);
+    }
+    if (isPayloadV2(event)) {
+        const matches = event.routeKey.matchAll(/\{(.*?)\}/g);
+        for (const match of matches){
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const group = match[1];
+            if (group.includes('+') && event.pathParameters) {
+                return event.pathParameters[group.replace('+', '')] ?? '';
+            }
+        }
+        return event.rawPath.slice(1);
+    }
+    throw new server.TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE
+    });
+}
+function transformHeaders(headers) {
+    const obj = {};
+    for (const [key, value] of Object.entries(headers)){
+        if (typeof value === 'undefined') {
+            continue;
+        }
+        obj[key] = Array.isArray(value) ? value.join(',') : value;
+    }
+    return obj;
+}
+const UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE = 'Custom payload format version not handled by this adapter. Please use either 1.0 or 2.0. More information here' + 'https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html';
 
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
@@ -27,38 +117,38 @@ function lambdaEventToHTTPRequest(event) {
         body = event.body;
     }
     return {
-        method: utils.getHTTPMethod(event),
+        method: getHTTPMethod(event),
         query: query,
         headers: event.headers,
         body: body
     };
 }
 function tRPCOutputToAPIGatewayOutput(event, response) {
-    if (utils.isPayloadV1(event)) {
+    if (isPayloadV1(event)) {
         const resp = {
             statusCode: response.status,
             body: response.body ?? '',
-            headers: utils.transformHeaders(response.headers ?? {})
+            headers: transformHeaders(response.headers ?? {})
         };
         return resp;
-    } else if (utils.isPayloadV2(event)) {
-        const resp1 = {
+    } else if (isPayloadV2(event)) {
+        const resp = {
             statusCode: response.status,
             body: response.body ?? undefined,
-            headers: utils.transformHeaders(response.headers ?? {})
+            headers: transformHeaders(response.headers ?? {})
         };
-        return resp1;
+        return resp;
     } else {
-        throw new core.TRPCError({
+        throw new server.TRPCError({
             code: 'INTERNAL_SERVER_ERROR',
-            message: utils.UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE
+            message: UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE
         });
     }
 }
 function awsLambdaRequestHandler(opts) {
     return async (event, context)=>{
         const req = lambdaEventToHTTPRequest(event);
-        const path = utils.getPath(event);
+        const path = getPath(event);
         const createContext = async (innerOpts)=>{
             return await opts.createContext?.({
                 event,
@@ -66,7 +156,7 @@ function awsLambdaRequestHandler(opts) {
                 ...innerOpts
             });
         };
-        const response = await core.resolveHTTPResponse({
+        const response = await http.resolveHTTPResponse({
             router: opts.router,
             batching: opts.batching,
             responseMeta: opts?.responseMeta,
@@ -85,10 +175,10 @@ function awsLambdaRequestHandler(opts) {
     };
 }
 
-exports.UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE = utils.UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE;
-exports.getHTTPMethod = utils.getHTTPMethod;
-exports.getPath = utils.getPath;
-exports.isPayloadV1 = utils.isPayloadV1;
-exports.isPayloadV2 = utils.isPayloadV2;
-exports.transformHeaders = utils.transformHeaders;
+exports.UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE = UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE;
 exports.awsLambdaRequestHandler = awsLambdaRequestHandler;
+exports.getHTTPMethod = getHTTPMethod;
+exports.getPath = getPath;
+exports.isPayloadV1 = isPayloadV1;
+exports.isPayloadV2 = isPayloadV2;
+exports.transformHeaders = transformHeaders;

package/dist/adapters/aws-lambda/index.mjs

@@ -1,5 +1,95 @@
-import { resolveHTTPResponse, TRPCError } from '@trpc/core';
-import { getPath, getHTTPMethod, isPayloadV1, transformHeaders, isPayloadV2, UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE } from './utils.mjs';
+import { TRPCError } from '@trpc/server';
+import { resolveHTTPResponse } from '@trpc/server/http';
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */ // @trpc/server
+function isPayloadV1(event) {
+    return determinePayloadFormat(event) == '1.0';
+}
+function isPayloadV2(event) {
+    return determinePayloadFormat(event) == '2.0';
+}
+function determinePayloadFormat(event) {
+    // https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+    // According to AWS support, version is is extracted from the version property in the event.
+    // If there is no version property, then the version is implied as 1.0
+    const unknownEvent = event;
+    if (typeof unknownEvent.version === 'undefined') {
+        return '1.0';
+    } else {
+        if ([
+            '1.0',
+            '2.0'
+        ].includes(unknownEvent.version)) {
+            return unknownEvent.version;
+        } else {
+            return 'custom';
+        }
+    }
+}
+function getHTTPMethod(event) {
+    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) {
+    if (isPayloadV1(event)) {
+        if (!event.pathParameters) {
+            // Then this event was not triggered by a resource denoted with {proxy+}
+            return event.path.split('/').pop() ?? '';
+        }
+        const matches = event.resource.matchAll(/\{(.*?)\}/g);
+        for (const match of matches){
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const group = match[1];
+            if (group.includes('+') && event.pathParameters) {
+                return event.pathParameters[group.replace('+', '')] ?? '';
+            }
+        }
+        return event.path.slice(1);
+    }
+    if (isPayloadV2(event)) {
+        const matches = event.routeKey.matchAll(/\{(.*?)\}/g);
+        for (const match of matches){
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const group = match[1];
+            if (group.includes('+') && event.pathParameters) {
+                return event.pathParameters[group.replace('+', '')] ?? '';
+            }
+        }
+        return event.rawPath.slice(1);
+    }
+    throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE
+    });
+}
+function transformHeaders(headers) {
+    const obj = {};
+    for (const [key, value] of Object.entries(headers)){
+        if (typeof value === 'undefined') {
+            continue;
+        }
+        obj[key] = Array.isArray(value) ? value.join(',') : value;
+    }
+    return obj;
+}
+const UNKNOWN_PAYLOAD_FORMAT_VERSION_ERROR_MESSAGE = 'Custom payload format version not handled by this adapter. Please use either 1.0 or 2.0. More information here' + 'https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html';
 
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
@@ -40,12 +130,12 @@ function tRPCOutputToAPIGatewayOutput(event, response) {
         };
         return resp;
     } else if (isPayloadV2(event)) {
-        const resp1 = {
+        const resp = {
             statusCode: response.status,
             body: response.body ?? undefined,
             headers: transformHeaders(response.headers ?? {})
         };
-        return resp1;
+        return resp;
     } else {
         throw new TRPCError({
             code: 'INTERNAL_SERVER_ERROR',

package/dist/adapters/express.d.mts

@@ -0,0 +1,19 @@
+import * as express from 'express';
+import { AnyRouter } from '@trpc/server';
+import { NodeHTTPCreateContextFnOptions, NodeHTTPHandlerOptions } from '@trpc/server/adapters/node-http';
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+type CreateExpressContextOptions = NodeHTTPCreateContextFnOptions<express.Request, express.Response>;
+declare function createExpressMiddleware<TRouter extends AnyRouter>(opts: NodeHTTPHandlerOptions<TRouter, express.Request, express.Response>): express.Handler;
+
+export { type CreateExpressContextOptions, createExpressMiddleware };

package/dist/adapters/express.d.ts

@@ -1,3 +1,7 @@
+import * as express from 'express';
+import { AnyRouter } from '@trpc/server';
+import { NodeHTTPCreateContextFnOptions, NodeHTTPHandlerOptions } from '@trpc/server/adapters/node-http';
+
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
  *
@@ -8,9 +12,8 @@
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-import type * as express from 'express';
-import type { AnyRouter } from '..';
-import type { NodeHTTPCreateContextFnOptions, NodeHTTPHandlerOptions } from './node-http';
-export type CreateExpressContextOptions = NodeHTTPCreateContextFnOptions<express.Request, express.Response>;
-export declare function createExpressMiddleware<TRouter extends AnyRouter>(opts: NodeHTTPHandlerOptions<TRouter, express.Request, express.Response>): express.Handler;
-//# sourceMappingURL=express.d.ts.map
+
+type CreateExpressContextOptions = NodeHTTPCreateContextFnOptions<express.Request, express.Response>;
+declare function createExpressMiddleware<TRouter extends AnyRouter>(opts: NodeHTTPHandlerOptions<TRouter, express.Request, express.Response>): express.Handler;
+
+export { type CreateExpressContextOptions, createExpressMiddleware };

package/dist/adapters/express.js

@@ -1,11 +1,11 @@
-'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-var nodeHTTPRequestHandler = require('./node-http/nodeHTTPRequestHandler.js');
+var nodeHttp = require('@trpc/server/adapters/node-http');
 
 function createExpressMiddleware(opts) {
     return async (req, res)=>{
         const endpoint = req.path.slice(1);
-        await nodeHTTPRequestHandler.nodeHTTPRequestHandler({
+        await nodeHttp.nodeHTTPRequestHandler({
             // FIXME: no typecasting should be needed here
             ...opts,
             req,

package/dist/adapters/express.mjs

@@ -1,4 +1,4 @@
-import { nodeHTTPRequestHandler } from './node-http/nodeHTTPRequestHandler.mjs';
+import { nodeHTTPRequestHandler } from '@trpc/server/adapters/node-http';
 
 function createExpressMiddleware(opts) {
     return async (req, res)=>{

package/dist/adapters/fastify/index.d.mts

@@ -0,0 +1,33 @@
+import { FastifyRequest, FastifyReply, FastifyInstance } from 'fastify';
+import { AnyRouter } from '@trpc/server';
+import { HTTPBaseHandlerOptions } from '@trpc/server/http';
+import { NodeHTTPCreateContextOption, NodeHTTPCreateContextFnOptions } from '@trpc/server/adapters/node-http';
+
+type FastifyHandlerOptions<TRouter extends AnyRouter, TRequest extends FastifyRequest, TResponse extends FastifyReply> = HTTPBaseHandlerOptions<TRouter, TRequest> & NodeHTTPCreateContextOption<TRouter, TRequest, TResponse>;
+type FastifyRequestHandlerOptions<TRouter extends AnyRouter, TRequest extends FastifyRequest, TResponse extends FastifyReply> = FastifyHandlerOptions<TRouter, TRequest, TResponse> & {
+    req: TRequest;
+    res: TResponse;
+    path: string;
+};
+declare function fastifyRequestHandler<TRouter extends AnyRouter, TRequest extends FastifyRequest, TResponse extends FastifyReply>(opts: FastifyRequestHandlerOptions<TRouter, TRequest, TResponse>): Promise<never>;
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+interface FastifyTRPCPluginOptions<TRouter extends AnyRouter> {
+    prefix?: string;
+    useWSS?: boolean;
+    trpcOptions: FastifyHandlerOptions<TRouter, FastifyRequest, FastifyReply>;
+}
+type CreateFastifyContextOptions = NodeHTTPCreateContextFnOptions<FastifyRequest, FastifyReply>;
+declare function fastifyTRPCPlugin<TRouter extends AnyRouter>(fastify: FastifyInstance, opts: FastifyTRPCPluginOptions<TRouter>, done: (err?: Error) => void): void;
+
+export { type CreateFastifyContextOptions, type FastifyHandlerOptions, type FastifyTRPCPluginOptions, fastifyRequestHandler, fastifyTRPCPlugin };

package/dist/adapters/fastify/index.d.ts

@@ -1,3 +1,33 @@
-export * from './fastifyRequestHandler';
-export * from './fastifyTRPCPlugin';
-//# sourceMappingURL=index.d.ts.map
+import { FastifyRequest, FastifyReply, FastifyInstance } from 'fastify';
+import { AnyRouter } from '@trpc/server';
+import { HTTPBaseHandlerOptions } from '@trpc/server/http';
+import { NodeHTTPCreateContextOption, NodeHTTPCreateContextFnOptions } from '@trpc/server/adapters/node-http';
+
+type FastifyHandlerOptions<TRouter extends AnyRouter, TRequest extends FastifyRequest, TResponse extends FastifyReply> = HTTPBaseHandlerOptions<TRouter, TRequest> & NodeHTTPCreateContextOption<TRouter, TRequest, TResponse>;
+type FastifyRequestHandlerOptions<TRouter extends AnyRouter, TRequest extends FastifyRequest, TResponse extends FastifyReply> = FastifyHandlerOptions<TRouter, TRequest, TResponse> & {
+    req: TRequest;
+    res: TResponse;
+    path: string;
+};
+declare function fastifyRequestHandler<TRouter extends AnyRouter, TRequest extends FastifyRequest, TResponse extends FastifyReply>(opts: FastifyRequestHandlerOptions<TRouter, TRequest, TResponse>): Promise<never>;
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+interface FastifyTRPCPluginOptions<TRouter extends AnyRouter> {
+    prefix?: string;
+    useWSS?: boolean;
+    trpcOptions: FastifyHandlerOptions<TRouter, FastifyRequest, FastifyReply>;
+}
+type CreateFastifyContextOptions = NodeHTTPCreateContextFnOptions<FastifyRequest, FastifyReply>;
+declare function fastifyTRPCPlugin<TRouter extends AnyRouter>(fastify: FastifyInstance, opts: FastifyTRPCPluginOptions<TRouter>, done: (err?: Error) => void): void;
+
+export { type CreateFastifyContextOptions, type FastifyHandlerOptions, type FastifyTRPCPluginOptions, fastifyRequestHandler, fastifyTRPCPlugin };