@orpc/server 1.14.5 → 2.0.0-beta.1

package/dist/shared/server.GDpX6Df8.mjs

@@ -0,0 +1,271 @@
+import { ORPCError, toORPCError, RPCSerializer, COMMON_ERROR_STATUS_MAP } from '@orpc/client';
+import { sortPlugins, getOpenTelemetryConfig, runWithSpan, toArray, matchesHttpPathPrefix, intercept, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, recordSpanError, pathToHttpPath, normalizeHttpPath, value, parseEmptyableJSON } from '@orpc/shared';
+import { flattenStandardHeader, parseStandardUrl } from '@standardserver/core';
+import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.CrlKQucM.mjs';
+import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BwHnWUuN.mjs';
+
+class CompositeStandardHandlerPlugin {
+  name = "~composite";
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = sortPlugins(plugins);
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      if (plugin.init) {
+        options = plugin.init(options);
+      }
+    }
+    return options;
+  }
+}
+
+class StandardHandler {
+  constructor(codec, options) {
+    this.codec = codec;
+    options = new CompositeStandardHandlerPlugin([
+      new OtelHandlerPlugin(),
+      ...toArray(options.plugins)
+    ]).init(options);
+    this.routingInterceptors = options.routingInterceptors;
+    this.interceptors = options.interceptors;
+    this.clientInterceptors = options.clientInterceptors;
+  }
+  routingInterceptors;
+  interceptors;
+  clientInterceptors;
+  async handle(request, { context, prefix }) {
+    if (prefix && !matchesHttpPathPrefix(request.url, prefix)) {
+      return { matched: false, response: void 0 };
+    }
+    return intercept(
+      this.routingInterceptors,
+      { context, prefix, request },
+      async ({ context: context2, prefix: prefix2, request: request2 }) => {
+        const span = getOpenTelemetryConfig()?.trace.getActiveSpan();
+        let step;
+        const matchedOrNot = await runWithSpan("find_procedure", () => this.codec.resolveProcedure(request2, { context: context2, prefix: prefix2 }));
+        if (!matchedOrNot) {
+          span?.updateName(`${ORPC_NAME}_no_match`);
+          span?.setAttribute("http.request.method", request2.method);
+          span?.setAttribute("url.path", request2.url);
+          return { matched: false };
+        }
+        const { path, procedure, decodeInput } = matchedOrNot;
+        span?.updateName(`${ORPC_NAME}.${path.join("/")}`);
+        span?.setAttribute("rpc.system", ORPC_NAME);
+        span?.setAttribute("rpc.method", path.join("."));
+        try {
+          const response = await intercept(
+            this.interceptors,
+            { context: context2, prefix: prefix2, request: request2, path, procedure, decodeInput },
+            async ({ context: context3, prefix: prefix3, request: request3, path: path2, procedure: procedure2, decodeInput: decodeInput2 }) => {
+              step = "decode_input";
+              let input = await runWithSpan("decode_input", decodeInput2);
+              step = void 0;
+              if (isAsyncIteratorObject(input)) {
+                input = override(input, traceAsyncIterator("consume_event_iterator_input", input));
+              }
+              const client = createProcedureClient(procedure2, {
+                context: context3,
+                path: path2,
+                interceptors: this.clientInterceptors
+              });
+              step = "call_procedure";
+              const output = await client(input, {
+                signal: request3.signal,
+                lastEventId: flattenStandardHeader(request3.headers["last-event-id"])
+              });
+              step = void 0;
+              const response2 = await this.codec.encodeOutput(output, procedure2, path2, { context: context3, prefix: prefix3 });
+              return response2;
+            }
+          );
+          return { matched: true, response };
+        } catch (e) {
+          if (step !== "call_procedure") {
+            recordSpanError(span, e);
+          }
+          const error = step === "decode_input" && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
+            message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+            cause: e
+          }) : toORPCError(e);
+          const response = await this.codec.encodeError(error, procedure, path, { context: context2, prefix: prefix2 });
+          return { matched: true, response };
+        }
+      }
+    );
+  }
+}
+class OtelHandlerPlugin {
+  name = "~opentelemetry";
+  init(options) {
+    return {
+      ...options,
+      routingInterceptors: [
+        // Should be placed before user-provided interceptors to help them access the current active context.
+        async ({ next, request }) => {
+          const otelConfig = getOpenTelemetryConfig();
+          let propagationContext;
+          if (otelConfig?.propagation) {
+            propagationContext = otelConfig.propagation.extract(otelConfig.context.active(), request.headers);
+          }
+          return runWithSpan(
+            { name: `${request.method} ${request.url}`, context: propagationContext },
+            () => next()
+          );
+        },
+        ...toArray(options.routingInterceptors)
+      ]
+    };
+  }
+}
+
+class RPCMatcher {
+  filter;
+  rootRouter;
+  tree = /* @__PURE__ */ new Map();
+  pendingLazyRouters = [];
+  constructor(router, options = {}) {
+    this.filter = options.filter ?? true;
+    this.rootRouter = router;
+    this.index(router);
+  }
+  index(router, path = []) {
+    const lazyResults = walkProcedureContractsSync(router, (procedure, procedurePath) => {
+      if (!value(this.filter, procedure, procedurePath)) {
+        return;
+      }
+      const httpPath = pathToHttpPath(procedurePath);
+      if (procedure instanceof Procedure) {
+        this.tree.set(httpPath, {
+          path: procedurePath,
+          contract: procedure,
+          procedure
+        });
+      } else {
+        this.tree.set(httpPath, {
+          path: procedurePath,
+          contract: procedure
+        });
+      }
+    }, path);
+    this.pendingLazyRouters.push(
+      ...lazyResults.map((result) => ({
+        ...result,
+        httpPathPrefix: pathToHttpPath(result.path)
+      }))
+    );
+  }
+  async match(_method, pathname, prefix) {
+    if (pathname.length > 1 && pathname.endsWith("/")) {
+      pathname = pathname.slice(0, -1);
+    }
+    if (prefix) {
+      if (!pathname.startsWith(prefix)) {
+        return void 0;
+      }
+      const charAfterPrefix = pathname[prefix.length];
+      if (charAfterPrefix === "/") {
+        pathname = pathname.slice(prefix.length);
+      } else if (charAfterPrefix === void 0) {
+        pathname = "/";
+      } else if (prefix[prefix.length - 1] === "/") {
+        pathname = pathname.slice(prefix.length - 1);
+      } else {
+        return void 0;
+      }
+    }
+    const result = await this.matchPathname(pathname);
+    if (!result && pathname.includes("%")) {
+      return this.matchPathname(normalizeHttpPath(pathname));
+    }
+    return result;
+  }
+  async matchPathname(pathname) {
+    await this.resolvePendingLazyRouters(pathname);
+    const entry = this.tree.get(pathname);
+    if (!entry) {
+      return void 0;
+    }
+    const procedure = await this.resolveProcedure(entry);
+    return { path: entry.path, procedure };
+  }
+  async resolvePendingLazyRouters(pathname) {
+    if (!this.pendingLazyRouters.length) {
+      return;
+    }
+    const stillPending = [];
+    for (const pending of this.pendingLazyRouters) {
+      if (pathname.startsWith(pending.httpPathPrefix)) {
+        const { default: router } = await unlazy(pending.router);
+        this.index(router, pending.path);
+      } else {
+        stillPending.push(pending);
+      }
+    }
+    this.pendingLazyRouters = stillPending;
+  }
+  async resolveProcedure(entry) {
+    if (entry.procedure) {
+      return entry.procedure;
+    }
+    const { default: maybeProcedure } = await unlazy(getRouter(this.rootRouter, entry.path));
+    if (!(maybeProcedure instanceof Procedure)) {
+      throw new TypeError(
+        `[Contract-First] Missing or invalid implementation for procedure at path: "${entry.path.join(".")}". Ensure the procedure is correctly implemented and matches its contract.`
+      );
+    }
+    entry.procedure = createContractProcedure(maybeProcedure, entry.contract);
+    return entry.procedure;
+  }
+}
+
+class RPCHandlerCodec {
+  matcher;
+  serializer;
+  errorStatusMap;
+  outputStatus;
+  constructor(router, options = {}) {
+    this.matcher = new RPCMatcher(router, options);
+    this.serializer = options.serializer ?? new RPCSerializer();
+    this.errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP;
+    this.outputStatus = options.outputStatus;
+  }
+  async resolveProcedure(request, options) {
+    const [pathname, query] = parseStandardUrl(request.url);
+    const matched = await this.matcher.match(request.method, pathname, options.prefix);
+    if (!matched) {
+      return void 0;
+    }
+    return {
+      procedure: matched.procedure,
+      path: matched.path,
+      decodeInput: async () => {
+        if (request.method === "GET") {
+          const dataString = new URLSearchParams(query).getAll("data").at(-1);
+          return this.serializer.deserialize(parseEmptyableJSON(dataString));
+        }
+        const body = await request.resolveBody();
+        return this.serializer.deserialize(body);
+      }
+    };
+  }
+  encodeOutput(output, procedure, path, options) {
+    return {
+      headers: {},
+      status: value(this.outputStatus, output, procedure, path, options) ?? DEFAULT_SUCCESS_STATUS,
+      body: this.serializer.serialize(output)
+    };
+  }
+  encodeError(error, _procedure, _path, _options) {
+    const status = this.errorStatusMap[error.code] ?? DEFAULT_ERROR_STATUS;
+    return {
+      headers: {},
+      status,
+      body: this.serializer.serialize(error.toJSON())
+    };
+  }
+}
+
+export { CompositeStandardHandlerPlugin as C, OtelHandlerPlugin as O, RPCHandlerCodec as R, StandardHandler as S, RPCMatcher as a };

package/dist/shared/server.Pa0F03f_.d.ts

@@ -0,0 +1,61 @@
+import { RouterContract, ProcedureContract, ORPCErrorFromErrorMap, ThrowableError, InferSchemaInput, InferSchemaOutput } from '@orpc/contract';
+import { C as Context, a as Procedure, L as Lazyable, M as MergedContext } from './server.BL22TloH.js';
+
+type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any, any, any> | {
+    [k: string]: Lazyable<Router<TInitialContext>>;
+};
+type ContractedRouter<T extends RouterContract, TInitialContext extends Context> = T extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? Procedure<TInitialContext, any, $InputSchema, $OutputSchema, $ErrorMap, never> : {
+    [K in keyof T]: T[K] extends RouterContract ? Lazyable<ContractedRouter<T[K], TInitialContext>> : never;
+};
+type AnyRouter = Router<any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer $> ? $ : never;
+/**
+ * Infer all initial context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
+};
+/**
+ * Infer all current context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterFinalContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, infer UInjectedContext, any, any, any, any> ? MergedContext<UInitialContext, UInjectedContext> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterFinalContexts<U> : never;
+};
+/**
+ * Infer all router inputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
+};
+/**
+ * Infer all router outputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
+};
+/**
+ * Infer the union of throwable errors for entire router.
+ */
+type InferRouterError<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterError<U> : never;
+}[keyof T];
+/**
+ * Infer throwable errors for each procedure, preserving the router shape.
+ */
+type InferRouterErrors<T extends AnyRouter> = T extends Procedure<any, any, any, any, infer UErrorMap, infer UReturnedError> ? ORPCErrorFromErrorMap<UErrorMap> | UReturnedError | ThrowableError : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterErrors<U> : never;
+};
+
+export type { AnyRouter as A, ContractedRouter as C, InferRouterInitialContext as I, Router as R, InferRouterError as a, InferRouterErrors as b, InferRouterFinalContexts as c, InferRouterInitialContexts as d, InferRouterInputs as e, InferRouterOutputs as f };

package/dist/shared/server.T9F3bzZx.d.ts

@@ -0,0 +1,66 @@
+import { RPCSerializer, AnyORPCError } from '@orpc/client';
+import { Value, Promisable } from '@orpc/shared';
+import { StandardMethod, StandardLazyRequest, StandardResponse } from '@standardserver/core';
+import { A as AnyProcedure, C as Context } from './server.BL22TloH.js';
+import { A as AnyRouter } from './server.Pa0F03f_.js';
+import { AnyProcedureContract } from '@orpc/contract';
+import { b as StandardHandlerHandleOptions, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure } from './server.EOHJ3NJr.js';
+
+interface RPCMatcherOptions {
+    /**
+     * Filter which procedures are exposed for matching. Return `false` to exclude.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]>;
+}
+declare class RPCMatcher {
+    private readonly filter;
+    private readonly rootRouter;
+    private readonly tree;
+    private pendingLazyRouters;
+    constructor(router: AnyRouter, options?: RPCMatcherOptions);
+    private index;
+    match(_method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
+        path: string[];
+        procedure: AnyProcedure;
+    } | undefined>;
+    private matchPathname;
+    private resolvePendingLazyRouters;
+    private resolveProcedure;
+}
+
+interface RPCHandlerCodecOptions<T extends Context> extends RPCMatcherOptions {
+    /**
+     * Override the default RPC serializer.
+     */
+    serializer?: Pick<RPCSerializer, keyof RPCSerializer>;
+    /**
+     * Resolve HTTP status for encoded successful outputs.
+     *
+     * Value should be in range `200-299`
+     * Return `undefined` or `null` to fallback to default
+     *
+     * @default DEFAULT_ERROR_STATUS, DEFAULT_ERROR_STATUS
+     */
+    outputStatus?: Value<number | undefined | null, [output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>]>;
+    /**
+     * Mapping ORPCError Code -> HTTP Status Code
+     *
+     * @default COMMON_ERROR_STATUS_MAP
+     */
+    errorStatusMap?: Record<string, number> | undefined;
+}
+declare class RPCHandlerCodec<T extends Context> implements StandardHandlerCodec<T> {
+    private readonly matcher;
+    private readonly serializer;
+    private readonly errorStatusMap;
+    private readonly outputStatus;
+    constructor(router: AnyRouter, options?: RPCHandlerCodecOptions<T>);
+    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, _procedure: AnyProcedure, _path: string[], _options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+}
+
+export { RPCHandlerCodec as a, RPCMatcher as b };
+export type { RPCHandlerCodecOptions as R, RPCMatcherOptions as c };

package/dist/shared/{server.DZ5BIITo.mjs → server.W91HSRkE.mjs}

@@ -1,4 +1,4 @@
-function resolveFriendlyStandardHandleOptions(options) {
+function resolveFriendlyStandardHandlerHandleOptions(options) {
   return {
     ...options,
     context: options.context ?? {}
@@ -6,4 +6,4 @@ function resolveFriendlyStandardHandleOptions(options) {
   };
 }
 
-export { resolveFriendlyStandardHandleOptions as r };
+export { resolveFriendlyStandardHandlerHandleOptions as r };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "1.14.5",
+  "version": "2.0.0-beta.1",
   "license": "MIT",
   "homepage": "https://orpc.dev",
   "repository": {
@@ -12,8 +12,11 @@
   "keywords": [
     "orpc"
   ],
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/extensions/callable.mjs"
+  ],
   "exports": {
+    "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs",
@@ -29,11 +32,6 @@
       "import": "./dist/plugins/index.mjs",
       "default": "./dist/plugins/index.mjs"
     },
-    "./hibernation": {
-      "types": "./dist/hibernation/index.d.mts",
-      "import": "./dist/hibernation/index.mjs",
-      "default": "./dist/hibernation/index.mjs"
-    },
     "./standard": {
       "types": "./dist/adapters/standard/index.d.mts",
       "import": "./dist/adapters/standard/index.mjs",
@@ -54,83 +52,56 @@
       "import": "./dist/adapters/node/index.mjs",
       "default": "./dist/adapters/node/index.mjs"
     },
-    "./fastify": {
-      "types": "./dist/adapters/fastify/index.d.mts",
-      "import": "./dist/adapters/fastify/index.mjs",
-      "default": "./dist/adapters/fastify/index.mjs"
-    },
-    "./aws-lambda": {
-      "types": "./dist/adapters/aws-lambda/index.d.mts",
-      "import": "./dist/adapters/aws-lambda/index.mjs",
-      "default": "./dist/adapters/aws-lambda/index.mjs"
-    },
     "./websocket": {
       "types": "./dist/adapters/websocket/index.d.mts",
       "import": "./dist/adapters/websocket/index.mjs",
       "default": "./dist/adapters/websocket/index.mjs"
     },
+    "./message-port": {
+      "types": "./dist/adapters/message-port/index.d.mts",
+      "import": "./dist/adapters/message-port/index.mjs",
+      "default": "./dist/adapters/message-port/index.mjs"
+    },
     "./crossws": {
       "types": "./dist/adapters/crossws/index.d.mts",
       "import": "./dist/adapters/crossws/index.mjs",
       "default": "./dist/adapters/crossws/index.mjs"
     },
-    "./ws": {
-      "types": "./dist/adapters/ws/index.d.mts",
-      "import": "./dist/adapters/ws/index.mjs",
-      "default": "./dist/adapters/ws/index.mjs"
-    },
-    "./bun-ws": {
-      "types": "./dist/adapters/bun-ws/index.d.mts",
-      "import": "./dist/adapters/bun-ws/index.mjs",
-      "default": "./dist/adapters/bun-ws/index.mjs"
-    },
-    "./message-port": {
-      "types": "./dist/adapters/message-port/index.d.mts",
-      "import": "./dist/adapters/message-port/index.mjs",
-      "default": "./dist/adapters/message-port/index.mjs"
+    "./extensions/callable": {
+      "types": "./dist/extensions/callable.d.mts",
+      "import": "./dist/extensions/callable.mjs",
+      "default": "./dist/extensions/callable.mjs"
     }
   },
   "files": [
     "dist"
   ],
   "peerDependencies": {
-    "crossws": ">=0.3.4",
-    "ws": ">=8.18.1"
+    "crossws": ">=0.3.4"
   },
   "peerDependenciesMeta": {
     "crossws": {
       "optional": true
-    },
-    "ws": {
-      "optional": true
     }
   },
   "dependencies": {
+    "@standardserver/core": "^0.0.24",
+    "@standardserver/fetch": "^0.0.24",
+    "@standardserver/node": "^0.0.24",
+    "@standardserver/peer": "^0.0.24",
     "cookie": "^1.1.1",
-    "@orpc/interop": "1.14.5",
-    "@orpc/client": "1.14.5",
-    "@orpc/contract": "1.14.5",
-    "@orpc/shared": "1.14.5",
-    "@orpc/standard-server": "1.14.5",
-    "@orpc/standard-server-aws-lambda": "1.14.5",
-    "@orpc/standard-server-fastify": "1.14.5",
-    "@orpc/standard-server-fetch": "1.14.5",
-    "@orpc/standard-server-peer": "1.14.5",
-    "@orpc/standard-server-node": "1.14.5"
+    "@orpc/client": "2.0.0-beta.1",
+    "@orpc/interop": "2.0.0-beta.1",
+    "@orpc/contract": "2.0.0-beta.1",
+    "@orpc/shared": "2.0.0-beta.1"
   },
   "devDependencies": {
-    "@tanstack/router-core": "^1.166.7",
-    "@types/ws": "^8.18.1",
-    "crossws": "^0.4.4",
-    "fastify": "^5.8.3",
-    "next": "^16.2.3",
-    "supertest": "^7.1.4",
-    "ws": "^8.18.3",
-    "zod": "^4.3.6"
+    "crossws": "^0.4.6",
+    "supertest": "^7.2.2",
+    "zod": "^4.4.3"
   },
   "scripts": {
     "build": "unbuild",
-    "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }
 }

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

@@ -1,46 +0,0 @@
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { SendStandardResponseOptions, APIGatewayProxyEventV2, ResponseStream } from '@orpc/standard-server-aws-lambda';
-import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.mjs';
-import { F as FriendlyStandardHandleOptions } from '../../shared/server.B8gYOD5g.mjs';
-import { f as StandardHandler } from '../../shared/server.BqadksTP.mjs';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.ChUyt5-i.mjs';
-import '@orpc/client';
-import '@orpc/contract';
-import '@orpc/standard-server';
-import '@orpc/client/standard';
-import '../../shared/server.C8_sRzQB.mjs';
-
-interface AwsLambdaHandlerOptions extends SendStandardResponseOptions {
-}
-type AwsLambdaHandleResult = {
-    matched: true;
-} | {
-    matched: false;
-};
-declare class AwsLambdaHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: AwsLambdaHandlerOptions);
-    handle(event: APIGatewayProxyEventV2, responseStream: ResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<AwsLambdaHandleResult>;
-}
-
-type RPCHandlerOptions<T extends Context> = AwsLambdaHandlerOptions & StandardRPCHandlerOptions<T> & {
-    /**
-     * Enables or disables the StrictGetMethodPlugin.
-     *
-     * @default true
-     */
-    strictGetMethodPluginEnabled?: boolean;
-};
-/**
- * RPC Handler for AWS Lambda.
- *
- * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
- * @see {@link https://orpc.dev/docs/adapters/http HTTP Adapter Docs}
- */
-declare class RPCHandler<T extends Context> extends AwsLambdaHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { AwsLambdaHandler, RPCHandler };
-export type { AwsLambdaHandleResult, AwsLambdaHandlerOptions, RPCHandlerOptions };

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

@@ -1,46 +0,0 @@
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { SendStandardResponseOptions, APIGatewayProxyEventV2, ResponseStream } from '@orpc/standard-server-aws-lambda';
-import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.js';
-import { F as FriendlyStandardHandleOptions } from '../../shared/server.EfTOZ2Q7.js';
-import { f as StandardHandler } from '../../shared/server.7cEtMB30.js';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.yoEB3Fx4.js';
-import '@orpc/client';
-import '@orpc/contract';
-import '@orpc/standard-server';
-import '@orpc/client/standard';
-import '../../shared/server.ChyoA9XY.js';
-
-interface AwsLambdaHandlerOptions extends SendStandardResponseOptions {
-}
-type AwsLambdaHandleResult = {
-    matched: true;
-} | {
-    matched: false;
-};
-declare class AwsLambdaHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: AwsLambdaHandlerOptions);
-    handle(event: APIGatewayProxyEventV2, responseStream: ResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<AwsLambdaHandleResult>;
-}
-
-type RPCHandlerOptions<T extends Context> = AwsLambdaHandlerOptions & StandardRPCHandlerOptions<T> & {
-    /**
-     * Enables or disables the StrictGetMethodPlugin.
-     *
-     * @default true
-     */
-    strictGetMethodPluginEnabled?: boolean;
-};
-/**
- * RPC Handler for AWS Lambda.
- *
- * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
- * @see {@link https://orpc.dev/docs/adapters/http HTTP Adapter Docs}
- */
-declare class RPCHandler<T extends Context> extends AwsLambdaHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { AwsLambdaHandler, RPCHandler };
-export type { AwsLambdaHandleResult, AwsLambdaHandlerOptions, RPCHandlerOptions };