@rest-rpc/fetch 0.1.0-beta.14

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 rest-rpc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# rest-rpc
+
+REST-shaped APIs with function-shaped TypeScript.
+
+Define your HTTP API once as a shared TypeScript contract, then derive typed
+server handlers, fetch clients, openAPI documents, and more from it.
+
+## Features
+
+- Shared TypeScript contracts for HTTP APIs.
+- Typed server handlers for Express, Hono, Fastify, NestJS, Next.js, and Fetch runtimes.
+- Typed fetch client.
+- Typed TanStack Query helpers.
+- Typed WebSockets, streaming, non-JSON requests/responses.
+- OpenAPI documents generated from the TypeScript contract.
+- Standard Schema support.
+
+## Minimal Example
+
+Define a contract
+
+```ts
+import { router } from "@rest-rpc/core";
+import { z } from "zod";
+
+export const api = router({
+	todos: {
+		get: {
+			method: "GET",
+			path: "/todos/:id",
+			response: z.object({
+				id: z.string(),
+				title: z.string(),
+			}),
+		},
+	},
+});
+```
+
+Implement the contract on the server
+
+```ts
+const routes = router(api, {
+	todos: {
+		get({ id }) {
+			return getTodo(id);
+		},
+	},
+});
+
+registerRoutes(app, routes);
+```
+
+use the contract on the client with RPC-style function calls
+
+```ts
+import { initClient } from "@rest-rpc/core";
+import { api } from "./contract";
+
+const client = initClient(api, {
+	baseUrl: "https://api.example.com",
+});
+
+const todo = await client.todos.get.fetch({
+	id: "todo_1",
+});
+```
+
+## Documentation
+
+Full documentation is available at [rest-rpc.dev](https://rest-rpc.dev)
+
+## Packages
+
+- [`@rest-rpc/core`](https://npmx.dev/package/@rest-rpc/core): API contract, client and openAPI generation.
+- [`@rest-rpc/express`](https://npmx.dev/package/@rest-rpc/express): Express server adapter.
+- [`@rest-rpc/fastify`](https://npmx.dev/package/@rest-rpc/fastify): Fastify server adapter.
+- [`@rest-rpc/hono`](https://npmx.dev/package/@rest-rpc/hono): Hono server adapter.
+- [`@rest-rpc/nest`](https://npmx.dev/package/@rest-rpc/nest): NestJS server adapter.
+- [`@rest-rpc/next`](https://npmx.dev/package/@rest-rpc/next): Next.js adapter.
+- [`@rest-rpc/fetch`](https://npmx.dev/package/@rest-rpc/fetch): Fetch runtime adapter
+- [`@rest-rpc/tanstack-query`](https://npmx.dev/package/@rest-rpc/tanstack-query): TanStack Query adapter.

package/dist/http.d.ts

@@ -0,0 +1,20 @@
+import type { HttpRouteDeclaration, RequestBodySchema } from "@rest-rpc/core/contract";
+import { type RouteImplementation, type ServerErrorHandlers } from "@rest-rpc/server";
+/**
+ * Input passed to a custom Fetch runtime request body parser.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch#body-parsing}
+ */
+export type FetchRouteParseBodyInput = {
+    request: Request;
+    route: HttpRouteDeclaration;
+    body: RequestBodySchema;
+};
+/**
+ * Custom request body parser for the Fetch runtime.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch#body-parsing}
+ */
+export type FetchRouteParseBody = (input: FetchRouteParseBodyInput) => unknown | Promise<unknown>;
+export declare const defaultParseBody: ({ request, body, }: FetchRouteParseBodyInput) => Promise<any> | undefined;
+export declare const handleFetchRoute: <TContext extends Record<string, unknown>>(request: Request, context: TContext, implementation: RouteImplementation<HttpRouteDeclaration>, params: Record<string, string>, parseBody: FetchRouteParseBody, usesDefaultParseBody: boolean, errorHandlers: ServerErrorHandlers<Record<never, never>> | undefined) => Promise<Response>;

package/dist/http.js

@@ -0,0 +1,63 @@
+import { isCustomBody, isFormBody, isMultipartBody, isNoBody, } from "@rest-rpc/core/contract";
+import { createRequestParsingErrorResponse, createFetchResponse, handleHttpRoute, } from "@rest-rpc/server";
+const isJsonContentType = (contentType) => contentType.split(";")[0]?.trim().toLowerCase() === "application/json";
+const isFormUrlEncodedContentType = (contentType) => contentType.split(";")[0]?.trim().toLowerCase() ===
+    "application/x-www-form-urlencoded";
+const isMultipartFormDataContentType = (contentType) => contentType.split(";")[0]?.trim().toLowerCase() === "multipart/form-data";
+const readQuery = (url) => Object.fromEntries(url.searchParams.entries());
+const readHeaders = (headers) => Object.fromEntries(headers.entries());
+export const defaultParseBody = ({ request, body, }) => {
+    if (!body || isNoBody(body))
+        return undefined;
+    if (isFormBody(body)) {
+        const contentType = request.headers.get("content-type") ?? "";
+        return isFormUrlEncodedContentType(contentType)
+            ? request.text().then((text) => new URLSearchParams(text))
+            : undefined;
+    }
+    if (isMultipartBody(body)) {
+        const contentType = request.headers.get("content-type") ?? "";
+        return isMultipartFormDataContentType(contentType)
+            ? request.formData()
+            : undefined;
+    }
+    if (isCustomBody(body)) {
+        const contentType = request.headers.get("content-type") ??
+            (Array.isArray(body.contentType)
+                ? body.contentType[0]
+                : body.contentType);
+        return contentType && isJsonContentType(contentType)
+            ? request.json()
+            : request.text();
+    }
+    return request.json();
+};
+export const handleFetchRoute = async (request, context, implementation, params, parseBody, usesDefaultParseBody, errorHandlers) => {
+    const url = new URL(request.url);
+    let body;
+    try {
+        body = await parseBody({
+            request,
+            route: implementation.route,
+            body: implementation.route.body,
+        });
+    }
+    catch (error) {
+        if (!usesDefaultParseBody)
+            throw error;
+        return Response.json(createRequestParsingErrorResponse().body, {
+            status: 400,
+        });
+    }
+    const result = await handleHttpRoute(implementation.route, implementation.handler, {
+        request: {
+            body,
+            query: readQuery(url),
+            pathParams: params,
+            headers: readHeaders(request.headers),
+        },
+        context,
+        errorHandlers,
+    });
+    return createFetchResponse(result);
+};

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import type { HttpRouteDeclaration } from "@rest-rpc/core/contract";
+import { clearCookie, RouteResponseError, type ServerErrorHandlers, setCookie, sseEvent } from "@rest-rpc/server";
+import { type FetchRouteParseBody } from "./http.ts";
+import { type FetchContract, type FetchImplementationTree, type FetchRouteBuilder, type FetchRouterBuilder } from "./routeBuilder.ts";
+export type { ClearCookieOptions, RouteErrors, RouteHandler, RouteRequestData, RouteResponse, RouteResponseShorthand, SetCookieOptions, SseEvent, } from "@rest-rpc/server";
+export type { FetchRouteParseBody, FetchRouteParseBodyInput } from "./http.ts";
+export type { RouteHandlers, RouteRequest, FetchContract, FetchImplementationTree, FetchRouteBuilder, FetchRouteContext, FetchRouteMiddleware, FetchRouteMiddlewareInput, FetchRouteMiddlewareResult, FetchRouterBuilder, } from "./routeBuilder.ts";
+export { clearCookie, RouteResponseError, setCookie, sseEvent };
+/**
+ * Default runtime context passed to Fetch runtime route handlers.
+ *
+ * @remarks Augment this interface to set the runtime context for
+ * `createRouteHandler()`, `route()`, and `router()` across a project.
+ *
+ * @example
+ * ```ts
+ * declare module "@rest-rpc/fetch" {
+ *   interface DefaultRuntimeContext {
+ *     env: Env;
+ *     ctx: ExecutionContext;
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch#framework-context}
+ */
+export interface DefaultRuntimeContext {
+}
+interface ContextShape {
+    [key: string]: any;
+}
+/**
+ * Default request type passed to Fetch runtime route handlers.
+ *
+ * @remarks Augment this interface when using a `Request` subclass such as
+ * `NextRequest`.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch#framework-context}
+ */
+export interface DefaultRequest extends Request {
+}
+/**
+ * Options for creating a Fetch runtime `Request` to `Response` route handler.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch#options}
+ */
+export type CreateFetchHandlerOptions = {
+    errorHandlers?: ServerErrorHandlers<Record<never, never>>;
+    parseBody?: FetchRouteParseBody;
+};
+/**
+ * Creates a Fetch runtime route implementation builder for a single HTTP route.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch}
+ */
+export declare function route<const TRoute extends HttpRouteDeclaration, TRuntimeContext extends ContextShape = DefaultRuntimeContext, TRequest extends Request = DefaultRequest>(contract: TRoute): FetchRouteBuilder<TRoute, TRuntimeContext, TRequest>;
+/**
+ * Creates a Fetch runtime router implementation builder for a contract tree.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch}
+ */
+export declare function router<const TContract extends FetchContract, TRuntimeContext extends ContextShape = DefaultRuntimeContext, TRequest extends Request = DefaultRequest>(contract: TContract): FetchRouterBuilder<TContract, TRuntimeContext, TRequest>;
+/**
+ * Creates a Fetch runtime `Request` handler from route implementations.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch}
+ */
+export declare function createRouteHandler<TRuntimeContext extends ContextShape = DefaultRuntimeContext, TRequest extends Request = DefaultRequest>(implementations: FetchImplementationTree, options?: CreateFetchHandlerOptions): (request: TRequest, runtime: TRuntimeContext) => Promise<Response>;

package/dist/index.js

@@ -0,0 +1,57 @@
+import { clearCookie, RouteResponseError, setCookie, sseEvent, } from "@rest-rpc/server";
+import { defaultParseBody, handleFetchRoute, } from "./http.js";
+import { createFetchRouteMatcher } from "./match.js";
+import { createFetchRouteBuilder, createFetchRouterBuilder, } from "./routeBuilder.js";
+export { clearCookie, RouteResponseError, setCookie, sseEvent };
+/**
+ * Creates a Fetch runtime route implementation builder for a single HTTP route.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch}
+ */
+export function route(contract) {
+    return createFetchRouteBuilder(contract);
+}
+/**
+ * Creates a Fetch runtime router implementation builder for a contract tree.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch}
+ */
+export function router(contract) {
+    return createFetchRouterBuilder(contract);
+}
+/**
+ * Creates a Fetch runtime `Request` handler from route implementations.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch}
+ */
+export function createRouteHandler(implementations, options = {}) {
+    const matchRoute = createFetchRouteMatcher(implementations);
+    const usesDefaultParseBody = options.parseBody === undefined;
+    const parseBody = options.parseBody ?? defaultParseBody;
+    return async (request, runtime) => {
+        const match = matchRoute(request);
+        if (match instanceof Response)
+            return match;
+        const implementation = match.implementation;
+        let middlewareContext = {};
+        for (const middleware of implementation.middleware ?? []) {
+            const middlewareResult = await middleware({
+                context: middlewareContext,
+                request,
+                route: implementation.route,
+                runtime,
+            });
+            if (middlewareResult instanceof Response)
+                return middlewareResult;
+            middlewareContext = {
+                ...middlewareContext,
+                ...middlewareResult,
+            };
+        }
+        const context = {
+            ...middlewareContext,
+            request,
+        };
+        return handleFetchRoute(request, context, implementation, match.params, parseBody, usesDefaultParseBody, options.errorHandlers);
+    };
+}

package/dist/match.d.ts

@@ -0,0 +1,7 @@
+import type { HttpRouteDeclaration } from "@rest-rpc/core/contract";
+import { type ImplementationTree } from "@rest-rpc/server";
+export declare const createFetchRouteMatcher: (implementations: ImplementationTree<HttpRouteDeclaration>) => (request: Request) => Response | {
+    type: "match";
+    implementation: import("@rest-rpc/server").RouteImplementation<HttpRouteDeclaration>;
+    params: Record<string, string>;
+};

package/dist/match.js

@@ -0,0 +1,30 @@
+import { createRouteMatcher, flattenRouteImplementations, } from "@rest-rpc/server";
+export const createFetchRouteMatcher = (implementations) => {
+    const routes = flattenRouteImplementations(implementations);
+    const routeContract = Object.fromEntries(routes.map((implementation, index) => [
+        String(index),
+        implementation.route,
+    ]));
+    const matchRoute = createRouteMatcher(routeContract);
+    const implementationsByRoute = new Map(routes.map((implementation) => [implementation.route, implementation]));
+    return (request) => {
+        const url = new URL(request.url);
+        const match = matchRoute({
+            method: request.method,
+            path: url.pathname,
+        });
+        if (!match)
+            return new Response(null, { status: 404 });
+        if (match.type === "methodNotAllowed") {
+            return new Response(null, { status: 405 });
+        }
+        const implementation = implementationsByRoute.get(match.route);
+        if (!implementation)
+            return new Response(null, { status: 404 });
+        return {
+            type: "match",
+            implementation,
+            params: match.params,
+        };
+    };
+};

package/dist/routeBuilder.d.ts

@@ -0,0 +1,105 @@
+import type { HttpRouteDeclaration } from "@rest-rpc/core/contract";
+import { type Contract, type ImplementationTree, type ImplementationTreeFor, type RouteHandler, type RouteImplementation, type RouteHandlers as ServerRouteHandlers, type RouteRequest as ServerRouteRequest } from "@rest-rpc/server";
+type MaybePromise<T> = T | Promise<T>;
+type Merge<T> = {
+    [K in keyof T]: T[K];
+};
+type MergeContext<TContext extends Record<string, unknown>, TNextContext extends Record<string, unknown>> = Merge<Omit<TContext, keyof TNextContext> & TNextContext>;
+/**
+ * A contract tree containing only HTTP routes for the Fetch runtime.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch}
+ */
+export type FetchContract = Contract<HttpRouteDeclaration>;
+/**
+ * An HTTP-only implementation tree for the Fetch runtime.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch}
+ */
+export type FetchImplementationTree = ImplementationTree<HttpRouteDeclaration>;
+/**
+ * The context object passed to Fetch runtime route handlers.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch#framework-context}
+ */
+export type FetchRouteContext<TContext extends Record<string, unknown>, TRequest extends Request = Request> = Merge<TContext & {
+    request: TRequest;
+}>;
+/**
+ * Input passed to Fetch runtime middleware.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch#framework-context}
+ */
+export type FetchRouteMiddlewareInput<TRuntimeContext extends Record<string, unknown>, TRequest extends Request = Request, TContext extends Record<string, unknown> = Record<never, never>> = {
+    context: TContext;
+    request: TRequest;
+    route: HttpRouteDeclaration;
+    runtime: TRuntimeContext;
+};
+/**
+ * Result returned by Fetch runtime middleware.
+ *
+ * @remarks Returning a `Response` short-circuits the route handler.
+ * @see {@link https://rest-rpc.dev/docs/server/fetch#framework-context}
+ */
+export type FetchRouteMiddlewareResult<TContext extends Record<string, unknown>> = Response | TContext | undefined;
+/**
+ * Middleware function shape for Fetch runtime routes.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch#framework-context}
+ */
+export type FetchRouteMiddleware<TRuntimeContext extends Record<string, unknown>, TContext extends Record<string, unknown>, TRequest extends Request = Request, TInputContext extends Record<string, unknown> = Record<never, never>> = (input: FetchRouteMiddlewareInput<TRuntimeContext, TRequest, TInputContext>) => MaybePromise<FetchRouteMiddlewareResult<TContext>>;
+export type FetchRouteImplementation<TRuntimeContext extends Record<string, unknown>, TRequest extends Request = Request> = RouteImplementation<HttpRouteDeclaration> & {
+    middleware?: FetchRouteMiddleware<TRuntimeContext, Record<string, unknown>, TRequest, Record<string, unknown>>[];
+};
+/**
+ * Infers the Fetch runtime route handler request type for a route declaration.
+ *
+ * @see {@link https://rest-rpc.dev/docs/type-helpers#server}
+ */
+export type RouteRequest<E extends HttpRouteDeclaration, TContext extends Record<string, unknown> = Record<string, unknown>, TRequest extends Request = Request> = ServerRouteRequest<E, FetchRouteContext<TContext, TRequest>>;
+/**
+ * Handler tree accepted by `router().handlers()` when building a Fetch runtime implementation tree.
+ *
+ * @remarks Use this type with `implements` to check class-based route handler
+ * services against a contract tree.
+ *
+ * @example
+ * ```ts
+ * class TodoHandlers implements RouteHandlers<typeof api.todos> {
+ *   get(request: RouteRequest<typeof api.todos.get>) {
+ *     return { id: request.id };
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link https://rest-rpc.dev/docs/recipes/organizing-route-handlers#service-classes-as-handlers}
+ */
+export type RouteHandlers<TContract extends FetchContract, TContext extends Record<string, unknown> = Record<string, unknown>, TRequest extends Request = Request> = ServerRouteHandlers<TContract, FetchRouteContext<TContext, TRequest>, Record<never, never>>;
+type FetchRouteBuilderWithMiddleware<TRoute extends HttpRouteDeclaration, TContext extends Record<string, unknown>, TRequest extends Request> = {
+    handler(handler: RouteHandler<TRoute, FetchRouteContext<TContext, TRequest>>): RouteImplementation<TRoute> & FetchImplementationTree;
+};
+/**
+ * Builder for a single Fetch runtime route implementation.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch}
+ */
+export type FetchRouteBuilder<TRoute extends HttpRouteDeclaration, TRuntimeContext extends Record<string, unknown>, TRequest extends Request = Request> = FetchRouteBuilderWithStackedMiddleware<TRoute, TRuntimeContext, Record<never, never>, TRequest>;
+type FetchRouterBuilderWithMiddleware<TContract extends FetchContract, TContext extends Record<string, unknown>, TRequest extends Request> = {
+    handlers(handlers: RouteHandlers<TContract, TContext, TRequest>): ImplementationTreeFor<TContract, HttpRouteDeclaration> & FetchImplementationTree;
+};
+/**
+ * Builder for a Fetch runtime implementation tree.
+ *
+ * @see {@link https://rest-rpc.dev/docs/server/fetch}
+ */
+export type FetchRouterBuilder<TContract extends FetchContract, TRuntimeContext extends Record<string, unknown>, TRequest extends Request = Request> = FetchRouterBuilderWithMiddleware<TContract, Record<never, never>, TRequest> & FetchRouterBuilderWithStackedMiddleware<TContract, TRuntimeContext, Record<never, never>, TRequest>;
+type FetchRouteBuilderWithStackedMiddleware<TRoute extends HttpRouteDeclaration, TRuntimeContext extends Record<string, unknown>, TContext extends Record<string, unknown>, TRequest extends Request> = FetchRouteBuilderWithMiddleware<TRoute, TContext, TRequest> & {
+    middleware<TNextContext extends Record<string, unknown>>(middleware: FetchRouteMiddleware<TRuntimeContext, TNextContext, TRequest, TContext>): FetchRouteBuilderWithStackedMiddleware<TRoute, TRuntimeContext, MergeContext<TContext, TNextContext>, TRequest>;
+};
+type FetchRouterBuilderWithStackedMiddleware<TContract extends FetchContract, TRuntimeContext extends Record<string, unknown>, TContext extends Record<string, unknown>, TRequest extends Request> = FetchRouterBuilderWithMiddleware<TContract, TContext, TRequest> & {
+    middleware<TNextContext extends Record<string, unknown>>(middleware: FetchRouteMiddleware<TRuntimeContext, TNextContext, TRequest, TContext>): FetchRouterBuilderWithStackedMiddleware<TContract, TRuntimeContext, MergeContext<TContext, TNextContext>, TRequest>;
+};
+export declare const createFetchRouteBuilder: <const TRoute extends HttpRouteDeclaration, TRuntimeContext extends Record<string, unknown>, TRequest extends Request = Request, TContext extends Record<string, unknown> = Record<never, never>>(contract: TRoute, middlewares?: FetchRouteMiddleware<TRuntimeContext, Record<string, unknown>, TRequest, Record<string, unknown>>[]) => FetchRouteBuilder<TRoute, TRuntimeContext, TRequest> & FetchRouteBuilderWithStackedMiddleware<TRoute, TRuntimeContext, TContext, TRequest>;
+export declare const createFetchRouterBuilder: <const TContract extends FetchContract, TRuntimeContext extends Record<string, unknown>, TRequest extends Request = Request, TContext extends Record<string, unknown> = Record<never, never>>(contract: TContract, middlewares?: FetchRouteMiddleware<TRuntimeContext, Record<string, unknown>, TRequest, Record<string, unknown>>[]) => FetchRouterBuilder<TContract, TRuntimeContext, TRequest> & FetchRouterBuilderWithStackedMiddleware<TContract, TRuntimeContext, TContext, TRequest>;
+export {};

package/dist/routeBuilder.js

@@ -0,0 +1,29 @@
+import { route as serverRoute, router as serverRouter, } from "@rest-rpc/server";
+const attachMiddleware = (implementation, middleware) => {
+    if ("route" in implementation && "handler" in implementation) {
+        return {
+            ...implementation,
+            middleware,
+        };
+    }
+    return Object.fromEntries(Object.entries(implementation).map(([key, child]) => [
+        key,
+        attachMiddleware(child, middleware),
+    ]));
+};
+export const createFetchRouteBuilder = (contract, middlewares = []) => ({
+    middleware: (nextMiddleware) => createFetchRouteBuilder(contract, [
+        ...middlewares,
+        nextMiddleware,
+    ]),
+    handler: (handler) => attachMiddleware(serverRoute(contract, handler), middlewares),
+});
+export const createFetchRouterBuilder = (contract, middlewares = []) => ({
+    middleware: (nextMiddleware) => createFetchRouterBuilder(contract, [
+        ...middlewares,
+        nextMiddleware,
+    ]),
+    handlers: (handlers) => serverRouter(contract, handlers, {
+        createRouteImplementation: ({ route, handler }) => attachMiddleware({ route: route, handler }, middlewares),
+    }),
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@rest-rpc/fetch",
+  "version": "0.1.0-beta.14",
+  "description": "Fetch runtime adapter for serving rest-rpc contracts with Request and Response handlers.",
+  "keywords": [
+    "api-contract",
+    "contract-first",
+    "edge",
+    "fetch",
+    "http",
+    "request",
+    "response",
+    "rest",
+    "rest-rpc",
+    "rpc",
+    "serverless",
+    "type-safe-api",
+    "typescript"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rest-rpc/rest-rpc.git",
+    "directory": "packages/fetch"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@rest-rpc/core": "0.1.0-beta.14",
+    "@rest-rpc/server": "0.1.0-beta.14"
+  },
+  "tsd": {
+    "directory": "test-d"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "node --test src/**/*.test.ts",
+    "typecheck": "pnpm run build && tsc -p tsconfig.json && tsd"
+  }
+}