@rest-rpc/next 0.1.0-beta.0 → 0.1.0-beta.10

package/README.md

@@ -2,44 +2,80 @@
 
 REST-shaped APIs with function-shaped TypeScript.
 
-`rest-rpc` lets you define HTTP routes in a shared TypeScript contract, then use
-that contract to derive typed server handlers, typed fetch clients, TanStack Query
-options, and OpenAPI documents.
+Define your HTTP API once as a shared TypeScript contract, then derive typed
+server handlers, fetch clients, openAPI documents, and more from it.
 
-The API stays REST-shaped. Everyday application code can feel like function
-calls.
+## Features
+
+- Shared TypeScript contracts for HTTP APIs.
+- Typed server handlers for Express, Hono, Fastify, 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
-const todo = await api.todos.get.fetch({ id: "todo_1" });
+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(),
+			}),
+		},
+	},
+});
 ```
 
-That call is still a normal HTTP request:
+Implement the contract on the server
 
-```http
-GET /todos/todo_1
-```
+```ts
+const routes = router(api, {
+	todos: {
+		get({ id }) {
+			return getTodo(id);
+		},
+	},
+});
 
-## Packages
+registerRoutes(app, routes);
+```
 
-- `@rest-rpc/core`: contracts, fetch client, OpenAPI generation, core helpers.
-- `@rest-rpc/express`: Express server adapter.
-- `@rest-rpc/hono`: Hono server adapter.
-- `@rest-rpc/fastify`: Fastify server adapter.
-- `@rest-rpc/web`: Web `Request`/`Response` HTTP handler adapter.
-- `@rest-rpc/next`: Next.js server/client adapter.
-- `@rest-rpc/tanstack-query`: TanStack Query options and key helpers.
+use the contract on the client with RPC-style function calls
 
-`@rest-rpc/server` contains shared adapter infrastructure and is mainly useful
-for adapter authors.
+```ts
+import { initClient } from "@rest-rpc/core";
+import { api } from "./contract";
 
-## Design
+const client = initClient(api, {
+	baseUrl: "https://api.example.com",
+});
 
-- REST routes remain explicit in the contract.
-- Handler and client calls use flattened request input.
-- Responses are keyed by HTTP status.
-- Server adapters are thin integrations with existing frameworks.
-- Schema libraries, OpenAPI UI, middleware, auth, and app structure stay your choice.
+const todo = await client.todos.get.fetch({
+	id: "todo_1",
+});
+```
 
 ## Documentation
 
-Full documentation will live at [rest-rpc.dev](https://rest-rpc.dev).
+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/next`](https://npmx.dev/package/@rest-rpc/next): Next.js adapter.
+- [`@rest-rpc/web`](https://npmx.dev/package/@rest-rpc/web): Fetch runtime adapter
+- [`@rest-rpc/tanstack-query`](https://npmx.dev/package/@rest-rpc/tanstack-query): TanStack Query adapter.

package/dist/index.d.ts

@@ -1,4 +1,2 @@
-export { ContractResponseError } from "@rest-rpc/web";
-export type { NextClientOptions } from "./client.ts";
-export { getGeneratedTagsForRoute, initNextClient, } from "./client.ts";
-export { type CreateRouteHandlerOptions, createRouteHandler, createRouterHandler, type NextRouteHandlerContext, type NextRouteParseBody, type NextRouteParseBodyInput, type RouteHandler, type RouteRequest, type RouteResponse, } from "./server.ts";
+export { type ClearCookieOptions, ContractResponseError, type CookiePriority, clearCookie, type SameSite, type SetCookieOptions, setCookie, } from "@rest-rpc/web";
+export { type CreateRouteHandlerOptions, createRouteHandler, type NextRouteMiddleware, type RouteRequest, type RouteResponse, route, router, } from "./server.ts";

package/dist/index.js

@@ -1,3 +1,2 @@
-export { ContractResponseError } from "@rest-rpc/web";
-export { getGeneratedTagsForRoute, initNextClient, } from "./client.js";
-export { createRouteHandler, createRouterHandler, } from "./server.js";
+export { ContractResponseError, clearCookie, setCookie, } from "@rest-rpc/web";
+export { createRouteHandler, route, router, } from "./server.js";

package/dist/server.d.ts

@@ -1,30 +1,19 @@
-import type { HttpMethod, HttpRouteDeclaration, RequestBodySchema } from "@rest-rpc/core/contract";
-import { type CreateWebHandlerOptions, type RouteHandler as WebRouteHandler, type WebRouteParseBodyInput, type RouteRequest as WebRouteRequest, type RouteResponse as WebRouteResponse } from "@rest-rpc/web";
-type WebContract = HttpRouteDeclaration | {
-    [key: string]: WebContract;
-};
-type WebRequestHandler = (request: Request) => Promise<Response>;
-type WebRouterHandlers<TContract extends WebContract> = TContract extends HttpRouteDeclaration ? RouteHandler<TContract> : {
-    [K in keyof TContract]: TContract[K] extends WebContract ? WebRouterHandlers<TContract[K]> : never;
-};
-type RouteHandlerMap<E extends HttpRouteDeclaration> = {
-    [K in E["method"]]: WebRequestHandler;
-};
-type RouterHandlerMap = {
-    [K in HttpMethod]: WebRequestHandler;
-};
-export type NextRouteHandlerContext = {
-    request: Request;
-};
-export type RouteRequest<E extends HttpRouteDeclaration> = WebRouteRequest<E, NextRouteHandlerContext>;
+import type { HttpRouteDeclaration } from "@rest-rpc/core/contract";
+import { type CreateWebHandlerOptions, type WebContract, type WebImplementationTree, type WebRouteBuilder, type WebRouteMiddleware, type WebRouteParseBodyInput, type RouteRequest as WebRouteRequest, type RouteResponse as WebRouteResponse, type WebRouterBuilder } from "@rest-rpc/web";
+import type { NextRequest } from "next/server.js";
+export type NextRouteMiddleware<TContext extends Record<string, unknown>> = WebRouteMiddleware<Record<never, never>, TContext, NextRequest>;
+export type RouteRequest<E extends HttpRouteDeclaration, TContext extends Record<string, unknown> = Record<string, unknown>> = WebRouteRequest<E, TContext, NextRequest>;
 export type RouteResponse<E extends HttpRouteDeclaration> = WebRouteResponse<E>;
-export type RouteHandler<E extends HttpRouteDeclaration> = WebRouteHandler<E, NextRouteHandlerContext>;
-export type NextRouteParseBodyInput = WebRouteParseBodyInput;
-export type NextRouteParseBody = (input: NextRouteParseBodyInput) => unknown | Promise<unknown>;
 export type CreateRouteHandlerOptions = {
-    errorHandlers?: CreateWebHandlerOptions<NextRouteHandlerContext>["errorHandlers"];
-    parseBody?: NextRouteParseBody;
+    errorHandlers?: CreateWebHandlerOptions["errorHandlers"];
+    parseBody?: (input: WebRouteParseBodyInput) => unknown | Promise<unknown>;
+};
+export declare const route: <const TRoute extends HttpRouteDeclaration>(contract: TRoute) => WebRouteBuilder<TRoute, Record<never, never>, NextRequest>;
+export declare const router: <const TContract extends WebContract>(contract: TContract) => WebRouterBuilder<TContract, Record<never, never>, NextRequest>;
+export declare const createRouteHandler: (implementations: WebImplementationTree, options?: CreateRouteHandlerOptions) => {
+    DELETE: (request: Request) => Promise<Response>;
+    GET: (request: Request) => Promise<Response>;
+    PATCH: (request: Request) => Promise<Response>;
+    POST: (request: Request) => Promise<Response>;
+    PUT: (request: Request) => Promise<Response>;
 };
-export declare function createRouteHandler<E extends HttpRouteDeclaration>(route: E, handler: RouteHandler<E>, options?: CreateRouteHandlerOptions): RouteHandlerMap<E>;
-export declare const createRouterHandler: <const TContract extends WebContract>(contract: TContract, handlers: WebRouterHandlers<TContract>, options?: CreateRouteHandlerOptions) => RouterHandlerMap;
-export type { RequestBodySchema };

package/dist/server.js

@@ -1,21 +1,12 @@
-import { initWeb, } from "@rest-rpc/web";
-export function createRouteHandler(route, handler, options) {
-    const web = initWeb();
-    const handle = web.createHandler(web.route(route, handler), {
+import { createRouteHandler as createWebRouteHandler, route as webRoute, router as webRouter, } from "@rest-rpc/web";
+export const route = (contract) => webRoute(contract);
+export const router = (contract) => webRouter(contract);
+export const createRouteHandler = (implementations, options) => {
+    const handle = createWebRouteHandler(implementations, {
         errorHandlers: options?.errorHandlers,
         parseBody: options?.parseBody,
     });
-    return {
-        [route.method]: (request) => handle(request, { request }),
-    };
-}
-export const createRouterHandler = (contract, handlers, options) => {
-    const web = initWeb();
-    const handle = web.createHandler(web.router(contract, handlers), {
-        errorHandlers: options?.errorHandlers,
-        parseBody: options?.parseBody,
-    });
-    const nextHandler = (request) => handle(request, { request });
+    const nextHandler = (request) => handle(request, {});
     return {
         DELETE: nextHandler,
         GET: nextHandler,

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@rest-rpc/next",
-  "version": "0.1.0-beta.0",
+  "version": "0.1.0-beta.10",
   "type": "module",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rest-rpc/rest-rpc.git"
+  },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -14,13 +18,22 @@
   "files": [
     "dist"
   ],
+  "tsd": {
+    "directory": "test-d"
+  },
   "dependencies": {
-    "@rest-rpc/core": "^0.1.0-beta.0",
-    "@rest-rpc/web": "^0.1.0-beta.0"
+    "@rest-rpc/core": "^0.1.0-beta.10",
+    "@rest-rpc/web": "^0.1.0-beta.10"
+  },
+  "peerDependencies": {
+    "next": ">=15"
+  },
+  "devDependencies": {
+    "next": "16.3.1"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "test": "node --test src/*.test.ts src/**/*.test.ts",
-    "typecheck": "pnpm run build && tsc -p tsconfig.json"
+    "typecheck": "pnpm run build && tsc -p tsconfig.json && tsd"
   }
 }

package/dist/client.d.ts

@@ -1,22 +0,0 @@
-import type { ApiClientFor, ApiClientOptions, Contract } from "@rest-rpc/core";
-import type { HttpRouteDeclaration } from "@rest-rpc/core/contract";
-type NextFetchOptions = RequestInit & {
-    next?: {
-        tags?: string[];
-        [key: string]: unknown;
-    };
-};
-export type NextClientFetchOptions = Omit<NextFetchOptions, "method" | "body" | "headers" | "signal">;
-export type NextClientOptions = Omit<ApiClientOptions, "fetchOptions"> & {
-    automaticFetchTags?: {
-        enabled: boolean;
-        tagPrefix?: string;
-    };
-    fetchOptions?: NextClientFetchOptions;
-};
-export declare const initNextClient: <TContract extends Contract>(contract: TContract, options: NextClientOptions) => ApiClientFor<TContract>;
-export declare const getGeneratedTagsForRoute: (route: HttpRouteDeclaration, options?: {
-    request?: Record<string, unknown>;
-    tagPrefix?: string;
-}) => string[];
-export {};

package/dist/client.js

@@ -1,41 +0,0 @@
-import { getRouteCacheTags, initClient } from "@rest-rpc/core";
-const createRouteCacheTagsForUrl = (url, prefix) => {
-    const parsed = new URL(url instanceof Request ? url.url : String(url));
-    return Array.from(new Set([
-        `${prefix ?? "rest-rpc"}:${parsed.pathname}${parsed.search}`,
-        `${prefix ?? "rest-rpc"}:${parsed.pathname}`,
-    ]));
-};
-const fetchWithTags = (fetchImpl, tagPrefix) => {
-    return (url, init) => {
-        if (init?.method !== "GET")
-            return fetchImpl(url, init);
-        const nextInit = init;
-        const taggedInit = {
-            ...nextInit,
-            next: {
-                ...nextInit.next,
-                tags: [
-                    ...(nextInit.next?.tags ?? []),
-                    ...createRouteCacheTagsForUrl(url, tagPrefix),
-                ],
-            },
-        };
-        return fetchImpl(url, taggedInit);
-    };
-};
-export const initNextClient = (contract, options) => {
-    const { automaticFetchTags, fetch, ...clientOptions } = options;
-    if (!automaticFetchTags?.enabled) {
-        return initClient(contract, options);
-    }
-    const fetchImpl = fetch ?? ((url, init) => globalThis.fetch(url, init));
-    return initClient(contract, {
-        ...clientOptions,
-        fetch: fetchWithTags(fetchImpl, automaticFetchTags.tagPrefix),
-    });
-};
-export const getGeneratedTagsForRoute = (route, options) => getRouteCacheTags(route, {
-    request: options?.request,
-    prefix: options?.tagPrefix,
-});

package/dist/tags.d.ts

@@ -1,4 +0,0 @@
-import type { HttpRouteDeclaration } from "@rest-rpc/core/contract";
-export declare const getUrlTag: (url: string) => string;
-export declare const getRouteTags: (route: HttpRouteDeclaration, request?: Record<string, unknown>) => string[];
-//# sourceMappingURL=tags.d.ts.map

package/dist/tags.js

@@ -1,11 +0,0 @@
-import { constructBaseRequest } from "@rest-rpc/core";
-const tagPrefix = "rest-rpc";
-export const getUrlTag = (url) => {
-    const parsed = new URL(url, "http://rest-rpc.local");
-    return `${tagPrefix}:${parsed.pathname}${parsed.search}`;
-};
-export const getRouteTags = (route, request) => {
-    const { url } = constructBaseRequest("", route, request, "strip");
-    return [getUrlTag(url)];
-};
-//# sourceMappingURL=tags.js.map