rpc4next 0.4.14 → 0.5.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 watanabe-1
+
+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,377 @@
+# rpc4next
+
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/watanabe-1/rpc4next)
+
+Lightweight, type-safe RPC system for Next.js App Router projects.
+
+Inspired by Hono RPC and Pathpida, **rpc4next** automatically generates a type-safe client for your existing `route.ts` **and** `page.tsx` files, enabling seamless server-client communication with full type inference.
+
+---
+
+## Development Notes
+
+This repository is a monorepo.
+
+- `packages/rpc4next` contains the runtime client/server helpers.
+- `packages/rpc4next-cli` contains the Next.js scanner and type generator.
+- `integration/next-app` is the real end-to-end fixture app used to verify generated artifacts, runtime behavior, and browser usage together.
+
+When a change affects scanner behavior, generated path structure output, params generation, or integration fixture routes, regenerate the integration artifacts and review those diffs as part of the change.
+
+---
+
+## ✨ Features
+
+- ✅ ルート、パラメータ、クエリパラメータ、 リクエストボディ、レスポンスの型安全なクライアント生成
+- ✅ 既存の `app/**/route.ts` および `app/**/page.tsx` を活用するため、新たなハンドラファイルの作成は不要
+- ✅ 最小限のセットアップで、カスタムサーバー不要
+- ✅ 動的ルート（`[id]`、`[...slug]` など）に対応
+- ✅ CLI による自動クライアント用型定義生成
+
+---
+
+## 🚀 Getting Started
+
+### 1. Install Packages
+
+```bash
+npm install rpc4next
+npm install -D rpc4next-cli
+```
+
+### 2. Define API Routes in Next.js
+
+Next.js プロジェクト内の既存の `app/**/route.ts` と `app/**/page.tsx` ファイルをそのまま利用できます。
+さらに、クエリパラメータ（searchParams）の型安全性を有効にするには、対象のファイル内で `Query` 型を定義し、`export` してください。
+
+```ts
+// app/api/user/[id]/route.ts
+import { NextRequest, NextResponse } from "next/server";
+
+// searchParams用の型定義
+export type Query = {
+  q: string; // 必須
+  page?: number; // 任意
+};
+
+export async function GET(
+  req: NextRequest,
+  segmentData: { params: Promise<{ id: string }> },
+) {
+  const { id } = await segmentData.params;
+  const q = req.nextUrl.searchParams.get("q");
+  return NextResponse.json({ id, q });
+}
+```
+
+🚩 Query 型を export することで、searchParams の型も自動的にクライアントに反映されます。
+
+- **RPCとしてresponseの戻り値の推論が機能するのは、対象となる `route.ts` の HTTPメソッドハンドラ内で`NextResponse.json()` をしている関数のみになります**
+
+---
+
+### 3. Generate Type Definitions with CLI
+
+CLI を利用して、Next.js のルート構造から型安全な RPC クライアントの定義を自動生成します。
+
+```bash
+npx rpc4next <baseDir> <outputPath>
+```
+
+`rpc4next` command is provided by the `rpc4next-cli` package.
+
+```json
+{
+  "baseDir": "app",
+  "outputPath": "src/generated/rpc.ts",
+  "paramsFile": "params.ts"
+}
+```
+
+`rpc4next.config.json` を実行ディレクトリに置くと、固定値を CLI 引数に繰り返し書かずに済みます。
+
+```bash
+npx rpc4next
+npx rpc4next --watch
+```
+
+- `<baseDir>`: Next.js の Appルータが配置されたベースディレクトリ
+- `<outputPath>`: 生成された型定義ファイルの出力先
+
+#### オプション
+
+- **ウォッチモード**  
+  ファイル変更を検知して自動的に再生成する場合は `--watch` or `-w` オプションを付けます。
+
+  ```bash
+  npx rpc4next <baseDir> <outputPath> --watch
+  ```
+
+- **パラメータ型ファイルの生成**  
+  各ルートに対して個別のパラメータ型定義ファイルを生成する場合は、`--params-file` or `-p` オプションにファイル名を指定します。
+
+  ```bash
+  npx rpc4next <baseDir> <outputPath> --params-file <paramsFileName>
+  ```
+
+---
+
+### 4. Create Your RPC Client
+
+生成された型定義ファイルを基に、RPC クライアントを作成します。
+
+```ts
+// lib/rpcClient.ts
+import { createClient } from "rpc4next/client";
+import type { PathStructure } from "あなたが生成した型定義ファイル";
+
+export const rpc = createClient<PathStructure>();
+```
+
+---
+
+### 5. Use It in Your Components
+
+コンポーネント内で生成された RPC クライアントを使用します。
+
+```tsx
+// app/page.tsx
+import { rpc } from "@/lib/rpcClient";
+
+export default async function Page() {
+  const res = await rpc.api.user._id("123").$get({
+    query: { q: "hello", page: 1 },
+  });
+  const json = await res.json();
+  return <div>{json.q}</div>;
+}
+```
+
+- エディタの補完機能により、利用可能なエンドポイントが自動的に表示されます。
+- リクエストの構造（params, query）はサーバーコードから推論され、レスポンスも型安全に扱えます。
+
+---
+
+## ✅ さらに型安全にしたい場合 `createRouteHandler` による Next.js の型安全強化
+
+### 📌 主なメリット
+
+1. **レスポンス型安全**
+   - ステータス、Content-Type、Body がすべて型で保証される
+   - クライアントは受け取るレスポンス型を完全に推論可能
+
+2. **クライアント側補完強化**
+   - `status`, `content-type`, `json()`, `text()` などが適切に補完される
+
+3. **サーバー側 params / query も型安全**
+   - `createRouteHandler()` + `zValidator()` を使えば、`params`, `query`, `headers`, `cookies`, `json` も型推論・バリデーション可能
+   - `createRouteHandler()` + `zValidator()` を使えば、`Query` 型もexportする必要なし
+
+---
+
+### ✅ 基本的な使い方
+
+```ts
+const createRouteHandler = routeHandlerFactory((err, rc) =>
+  rc.text("error", { status: 400 }),
+);
+
+const { POST } = createRouteHandler().post(async (rc) => rc.text("plain text"));
+```
+
+これだけで、POSTリクエストの返り値に、レスポンスの内容 (`json`, `text`など)、`status`, `content-type` が型付けされるようになります。
+
+---
+
+### 👤 サーバー側でのより型安全なルート作成
+
+`createRouteHandler()` と `zValidator()` を使うことで、各リクエストパーツに対して **型安全なバリデーション** をかけられます。
+
+#### シンプルな例
+
+```ts
+import { createRouteHandler } from "@/path/to/createRouteHandler";
+import { zValidator } from "@/path/to/zValidator";
+import { z } from "zod";
+
+// Zodスキーマを定義
+const paramsSchema = z.object({
+  userId: z.string(),
+});
+
+// バリデーション付きルートハンドラを作成
+export const { GET } = createRouteHandler<{
+  params: z.infer<typeof paramsSchema>;
+}>().get(
+  zValidator("params", paramsSchema), // paramsを検証
+  async (rc) => {
+    const params = rc.req.valid("params"); // バリデーション済みparamsを取得
+    return rc.json({ message: `User ID is ${params.userId}` });
+  },
+);
+```
+
+## ✅ サポートされているバリデーションターゲット
+
+サーバー側では，次のリクエスト部分を型安全に検証できます：
+
+| ターゲット | 説明                                                |
+| :--------- | :-------------------------------------------------- |
+| `params`   | URLパラメータ ( `/user/:id` の `id`など)            |
+| `query`    | クエリパラメータ (`?q=xxx&page=1`など)              |
+| `headers`  | リクエストヘッダー                                  |
+| `cookies`  | クッキー                                            |
+| `json`     | リクエストボディ (Content-Type: `application/json`) |
+
+---
+
+### 🔥 複数ターゲットを同時に検証する例
+
+```ts
+import { createRouteHandler } from "@/path/to/createRouteHandler";
+import { zValidator } from "@/path/to/zValidator";
+import { z } from "zod";
+
+const querySchema = z.object({
+  page: z.string().regex(/^\d+$/),
+});
+
+const jsonSchema = z.object({
+  name: z.string(),
+  age: z.number(),
+});
+
+export const { POST } = createRouteHandler<{
+  query: z.infer<typeof querySchema>;
+}>().post(
+  zValidator("query", querySchema),
+  zValidator("json", jsonSchema),
+  async (rc) => {
+    const query = rc.req.valid("query");
+    const body = rc.req.valid("json");
+    return rc.json({ query, body });
+  },
+);
+```
+
+- `query`と`json`を別々のスキーマで検証
+- **成功時は型安全に取得可能** (`rc.req.valid('query')`, `rc.req.valid('json')`)
+
+---
+
+これにより，クライアント側とサーバー側が、全面的に**型でつながる**ので，ミスを何次も防げ，開発体験を大幅に向上できます。
+
+---
+
+### ⚡ バリデーション失敗時のカスタムエラーハンドリング
+
+- デフォルトでは、バリデーション失敗時に自動で `400 Bad Request` を返します。
+- 必要に応じて、**カスタムフック**でエラー対応を制御できます。
+
+```ts
+zValidator("params", paramsSchema, (result, rc) => {
+  if (!result.success) {
+    return rc.json({ error: result.error.errors }, { status: 422 });
+  }
+});
+```
+
+> （フック内でレスポンスを返さない場合は、通常通り例外がスローされます）
+
+---
+
+## 📡 クライアント側での使い方
+
+`rpc4next`で作成したクライアントは、`createRouteHandler` と `zValidator` で作成したルートハンドラの内容にしたがって　**params, query, headers, cookies, json** を型安全に送信できます。
+
+例：
+
+```ts
+import { createRpcClient } from "@/path/to/rpc-client";
+import type { PathStructure } from "@/path/to/generated-types";
+
+const client = createRpcClient<PathStructure>("http://localhost:3000");
+
+async function callUserApi() {
+  const res = await client.api.menu.test.$post({
+    body: { json: { age: 20, name: "foo" } },
+    url: { query: { page: "1" } },
+  });
+
+  if (res.ok) {
+    const json = await res.json();
+
+    // ✅ 正常時は次の型が推論されます
+    // const json: {
+    //   query: {
+    //     page: string;
+    //   };
+    //   body: {
+    //     name: string;
+    //     age: number;
+    //   };
+    // }
+  } else {
+    const error = await res.json();
+
+    // ⚠️ バリデーションエラー時は次の型が推論されます
+    // const error:
+    //   | SafeParseError<{
+    //       page: string;
+    //     }>
+    //   | SafeParseError<{
+    //       name: string;
+    //       age: number;
+    //     }>;
+  }
+}
+```
+
+- エディタの補完機能により、送信できるターゲットが明示されます
+- サーバー側の型定義に基づいて、**型のズレを防止**できます
+
+---
+
+これらのように、リクエスト時にはさまざまなターゲット (`params`, `query`, `headers`, `cookies`, `json`) を送信できます。
+
+さらに、サーバー側では、これらを**個別に型付け、バリデーション**できます。
+
+---
+
+## 🧭 Monorepo Layout
+
+- `packages/rpc4next`: Core library modules (client, server, validators, shared types)
+- `packages/rpc4next-cli`: CLI generator that exposes the `rpc4next` binary
+- Install once at the repo root: `bun install`
+- Build everything: `bun run build`
+- Run all tests: `bun run test`
+- Lint all packages: `bun run lint`
+
+## 🚧 Requirements
+
+- Next.js 14+ (App Router 使用)
+- Node.js 20.19.2+
+- aqua (Node.js / Bun のバージョン管理)
+
+```bash
+aqua i
+```
+
+- `aqua/aqua.yaml` を更新したら、チェックサムを更新してください
+
+```bash
+aqua update-checksum
+```
+
+- CI / ローカルで設定を強制する場合は以下を利用してください
+
+```bash
+export AQUA_ENFORCE_CHECKSUM=true
+export AQUA_ENFORCE_REQUIRE_CHECKSUM=true
+```
+
+---
+
+## 💼 License
+
+MIT

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./rpc/server";
 export * from "./rpc/client";
+export * from "./rpc/server";

package/dist/index.js

@@ -1 +1 @@
-export*from"./rpc/server";export*from"./rpc/client";
+export*from"./rpc/client";export*from"./rpc/server";

package/dist/rpc/client/client-utils.d.ts

@@ -7,5 +7,9 @@ export declare const isDynamic: (key: string) => boolean;
  * Returns true if the key represents a catch-all or optional catch-all segment.
  */
 export declare const isCatchAllOrOptional: (key: string) => boolean;
+/**
+ * Returns true if the key represents an optional catch-all segment.
+ */
+export declare const isOptionalCatchAll: (key: string) => boolean;
 export declare const isHttpMethod: (value: string) => value is HttpMethodFuncKey;
-export declare const deepMerge: <T extends object, U extends object>(target: T, source: U) => T;
+export declare const deepMerge: <T extends object, U extends object>(target: T, source: U) => T & U;

package/dist/rpc/client/client-utils.js

@@ -1 +1 @@
-import{DYNAMIC_PREFIX as i,CATCH_ALL_PREFIX as a,OPTIONAL_CATCH_ALL_PREFIX as p,HTTP_METHOD_FUNC_KEYS as u}from"rpc4next-shared";const T=t=>t.startsWith(i),l=t=>t.startsWith(a)||t.startsWith(p),y=new Set(u),A=t=>y.has(t),c=t=>typeof t=="object"&&t!==null&&!Array.isArray(t),d=(t,n)=>{const s={...t};for(const e in n)if(Object.prototype.hasOwnProperty.call(n,e)){const r=t[e],o=n[e];c(r)&&c(o)?s[e]=d(r,o):s[e]=o}return s};export{d as deepMerge,l as isCatchAllOrOptional,T as isDynamic,A as isHttpMethod};
+import{CATCH_ALL_PREFIX as a,DYNAMIC_PREFIX as p,HTTP_METHOD_FUNC_KEYS as h,OPTIONAL_CATCH_ALL_PREFIX as i}from"rpc4next-shared";const g=t=>t.startsWith(p),y=t=>t.startsWith(a)||t.startsWith(i),A=t=>t.startsWith(i),u=new Set(h),T=t=>u.has(t),c=t=>typeof t=="object"&&t!==null&&!Array.isArray(t),d=(t,s)=>{const e={...t};for(const n in s)if(Object.hasOwn(s,n)){const r=t[n],o=s[n];c(r)&&c(o)?e[n]=d(r,o):e[n]=o}return e};export{d as deepMerge,y as isCatchAllOrOptional,g as isDynamic,T as isHttpMethod,A as isOptionalCatchAll};

package/dist/rpc/client/http-method.d.ts

@@ -1,4 +1,4 @@
-import type { FuncParams, UrlOptions, ClientOptions, BodyOptions, HeadersOptions } from "./types";
+import type { BodyOptions, ClientOptions, FuncParams, HeadersOptions, UrlOptions } from "./types";
 /** Local, non-breaking extension for future body shapes */
 type ExtendedBodyOptions = BodyOptions & {
     text?: string;

package/dist/rpc/client/http-method.js

@@ -1 +1 @@
-import{deepMerge as x}from"./client-utils";import{createUrl as R}from"./url";import{normalizeHeaders as l}from"../lib/headers";const H=n=>{if(!n)return{};const{headers:i,headersInit:m,...p}=n;return p},U=n=>"content-type"in n?!0:Object.keys(n).some(i=>i.toLowerCase()==="content-type"),B=(n,i,m,p,g)=>async(d,O)=>{const a=n.replace(/^\$/,"").toUpperCase(),I=R([...i],m,p)(d?.url),C=O?.fetch??g.fetch??fetch,f=g.init,u=O?.init,w=l(f?.headers??f?.headersInit),T=l(u?.headers??u?.headersInit),j=l(d?.requestHeaders?.headers),o={...w,...T,...j},b=o.cookie,y=d?.requestHeaders?.cookies;if(y&&Object.keys(y).length>0){const s=Object.entries(y).map(([h,k])=>`${h}=${k}`).join("; ");o.cookie=b?`${b}; ${s}`:s}let t,r;const e=d?.body;e?.json!==void 0?(t=JSON.stringify(e.json),r="application/json"):typeof e?.text=="string"?(t=e.text,r="text/plain; charset=utf-8"):e?.formData instanceof FormData?(t=e.formData,r=void 0):e?.urlencoded instanceof URLSearchParams?(t=e.urlencoded,r="application/x-www-form-urlencoded; charset=UTF-8"):e?.raw!==void 0&&(t=e.raw,r=void 0),(a==="GET"||a==="HEAD")&&(t=void 0),!U(o)&&t&&r&&(o["content-type"]=r);const c=x(H(f),H(u));c.method=a,Object.keys(o).length>0&&(c.headers=o),t!==void 0&&(c.body=t);try{return await C(I.path,c)}catch(s){const h=s instanceof Error?s.message:String(s);throw new Error(`[httpMethod] ${a} ${I.path} failed: ${h}`,{cause:s})}};export{B as httpMethod};
+import{normalizeHeaders as l}from"../lib/headers";import{deepMerge as x}from"./client-utils";import{createUrl as R}from"./url";const H=n=>{if(!n)return{};const{headers:i,headersInit:m,...p}=n;return p},U=n=>"content-type"in n?!0:Object.keys(n).some(i=>i.toLowerCase()==="content-type"),B=(n,i,m,p,g)=>async(d,O)=>{const a=n.replace(/^\$/,"").toUpperCase(),I=R([...i],m,p)(d?.url),C=O?.fetch??g.fetch??fetch,f=g.init,u=O?.init,w=l(f?.headers??f?.headersInit),T=l(u?.headers??u?.headersInit),j=l(d?.requestHeaders?.headers),o={...w,...T,...j},b=o.cookie,y=d?.requestHeaders?.cookies;if(y&&Object.keys(y).length>0){const s=Object.entries(y).map(([h,k])=>`${h}=${k}`).join("; ");o.cookie=b?`${b}; ${s}`:s}let t,r;const e=d?.body;e?.json!==void 0?(t=JSON.stringify(e.json),r="application/json"):typeof e?.text=="string"?(t=e.text,r="text/plain; charset=utf-8"):e?.formData instanceof FormData?(t=e.formData,r=void 0):e?.urlencoded instanceof URLSearchParams?(t=e.urlencoded,r="application/x-www-form-urlencoded; charset=UTF-8"):e?.raw!==void 0&&(t=e.raw,r=void 0),(a==="GET"||a==="HEAD")&&(t=void 0),!U(o)&&t&&r&&(o["content-type"]=r);const c=x(H(f),H(u));c.method=a,Object.keys(o).length>0&&(c.headers=o),t!==void 0&&(c.body=t);try{return await C(I.path,c)}catch(s){const h=s instanceof Error?s.message:String(s);throw new Error(`[httpMethod] ${a} ${I.path} failed: ${h}`,{cause:s})}};export{B as httpMethod};

package/dist/rpc/client/match.js

@@ -1 +1 @@
-import{isCatchAllOrOptional as w}from"./client-utils";import{replaceDynamicSegments as x}from"./url";import{searchParamsToObject as L}from"../lib/search-params";const o=n=>{if(n!=null)try{return decodeURIComponent(n)}catch{return n}},$=n=>{const e=n.join("/").replace(/\/+/g,"/");return(e.startsWith("/")?e:`/${e}`).replace(/\/+$/,"")||"/"},O=(n,e)=>{const l=$(n),u=x(l,{optionalCatchAll:"(?:/(.*))?",catchAll:"/([^/]+(?:/[^/]+)*)",dynamic:"/([^/]+)"}),m=new RegExp(`^${u}(?:/)?$`);return p=>{let t;try{t=new URL(p,"http://dummy")}catch{return null}const f=t.pathname,d=m.exec(f);if(!d)return null;const a={};for(let s=0;s<e.length;s++){const h=e[s],i=h.replace(/^_+/,""),r=d[s+1];if(w(h))if(r==null||r==="")a[i]=void 0;else{const R=r.split("/").filter(Boolean).map(c=>o(c)).filter(c=>c!==void 0);a[i]=R}else a[i]=o(r)}const g=L(t.searchParams),P=t.hash?t.hash.slice(1):void 0,y=o(P);return{params:a,query:g,hash:y}}};export{O as matchPath};
+import{searchParamsToObject as P}from"../lib/search-params";import{isCatchAllOrOptional as x}from"./client-utils";function a(n){if(n!=null)try{return decodeURIComponent(n)}catch{return n}}const D=n=>n.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"),O=(n,u)=>{const c=n.map(t=>t.replace(/^\/+|\/+$/g,"")).filter(Boolean),h=c.length===0?"/":c.reduce((t,e)=>u.includes(e)?e.startsWith("_____")?`${t}(?:/(.*))?`:e.startsWith("___")?`${t}/([^/]+(?:/[^/]+)*)`:`${t}/([^/]+)`:`${t}/${D(a(e))}`,""),g=new RegExp(`^${h}(?:/)?$`);return t=>{let e;try{e=new URL(t,"http://dummy")}catch{return null}const p=e.pathname,l=g.exec(p);if(!l)return null;const i={};for(let s=0;s<u.length;s++){const f=u[s],o=f.replace(/^_+/,""),r=l[s+1];if(x(f))if(r==null||r==="")i[o]=void 0;else{const R=r.split("/").filter(Boolean).map(d=>a(d)).filter(d=>d!==void 0);i[o]=R}else i[o]=a(r)}const m=P(e.searchParams),$=e.hash?e.hash.slice(1):void 0,_=a($);return{params:i,query:m,hash:_}}};export{O as matchPath};

package/dist/rpc/client/rpc.js

@@ -2,4 +2,4 @@
  * Inspired by the design of Hono (https://github.com/honojs/hono)
  * and pathpida (https://github.com/aspida/pathpida)
  * particularly their routing structures and developer experience.
- */import{isDynamic as g}from"./client-utils";const l=(r,e,n,s,o)=>{const p=function(){};return new Proxy(p,{apply(a,u,t){const i=t[0],c=n[n.length-1],f=o[o.length-1];if(!c||!g(c))throw new Error(`Cannot apply a value: "${c??""}" is not a dynamic segment.`);if(i===void 0){const d=f??c;throw new Error(`Missing value for dynamic parameter: ${String(d)}`)}return l(r,e,n,{...s,[f]:i},o)},get(a,u){if(u==="then"||typeof u=="symbol")return;const t=String(u),i=r(t,{paths:n,params:s,dynamicKeys:o,options:e});return i!==void 0?i:g(t)?l(r,e,[...n,t],s,[...o,t]):l(r,e,[...n,t],s,o)}})},T=r=>(e="/",n={})=>l(r,n,[e],{},[]);export{T as makeCreateRpc};
+ */import{isDynamic as g,isOptionalCatchAll as w}from"./client-utils";const a=(r,e,n,l,o)=>{const p=function(){};return new Proxy(p,{apply(c,u,t){const i=t[0],s=n[n.length-1],f=o[o.length-1];if(!s||!g(s))throw new Error(`Cannot apply a value: "${s??""}" is not a dynamic segment.`);if(i===void 0&&!w(s)){const d=f??s;throw new Error(`Missing value for dynamic parameter: ${String(d)}`)}return a(r,e,n,{...l,[f]:i},o)},get(c,u){if(u==="then"||typeof u=="symbol")return;const t=String(u),i=r(t,{paths:n,params:l,dynamicKeys:o,options:e});return i!==void 0?i:g(t)?a(r,e,[...n,t],l,[...o,t]):a(r,e,[...n,t],l,o)}})},x=r=>(e="/",n={})=>a(r,n,[e],{},[]);export{x as makeCreateRpc};

package/dist/rpc/client/types.d.ts

@@ -1,10 +1,10 @@
+import type { NextResponse } from "next/server";
+import type { CATCH_ALL_PREFIX, DYNAMIC_PREFIX, HTTP_METHOD_FUNC_KEYS, OPTIONAL_CATCH_ALL_PREFIX } from "rpc4next-shared";
 import type { ContentType } from "../lib/content-type-types";
 import type { HttpRequestHeaders } from "../lib/http-request-headers-types";
 import type { HttpStatusCode } from "../lib/http-status-code-types";
 import type { RouteHandlerResponse, RouteResponse, ValidationSchema } from "../server/route-types";
 import type { TypedNextResponse, ValidationInputFor } from "../server/types";
-import type { NextResponse } from "next/server";
-import type { OPTIONAL_CATCH_ALL_PREFIX, CATCH_ALL_PREFIX, DYNAMIC_PREFIX, HTTP_METHOD_FUNC_KEYS } from "rpc4next-shared";
 type DistributeOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
 /**
  * Extension of the standard `RequestInit` interface with strongly typed headers.

package/dist/rpc/client/url.d.ts

@@ -1,4 +1,4 @@
-import type { UrlOptions, UrlResult, FuncParams } from "./types";
+import type { FuncParams, UrlOptions, UrlResult } from "./types";
 /**
  * Builds a URL suffix string from optional query and hash values.
  *

package/dist/rpc/client/url.js

@@ -1 +1 @@
-const m=t=>{if(!t)return"";const n=t.query?"?"+new URLSearchParams(t.query).toString():"",c=t.hash?`#${t.hash}`:"";return n+c},u=(t,n)=>t.replace(/\/_{5}(\w+)/g,n.optionalCatchAll).replace(/\/_{3}(\w+)/g,n.catchAll).replace(/\/_(\w+)/g,n.dynamic),$=(t,n,c)=>{const s=t.shift(),o=`/${t.join("/")}`,p=c.reduce((a,r)=>{const e=n[r];return Array.isArray(e)?a.replace(`/${r}`,`/${e.map(encodeURIComponent).join("/")}`):e===void 0?a.replace(`/${r}`,""):a.replace(`/${r}`,`/${encodeURIComponent(e)}`)},o);return a=>{const r=`${p}${m(a)}`,e=u(o,{optionalCatchAll:"/[[...$1]]",catchAll:"/[...$1]",dynamic:"/[$1]"}),i={};for(const l in n){const h=l.replace(/^_+/,"");i[h]=n[l]}return{pathname:e,params:i,path:s?`${s.replace(/\/$/,"")}${r}`:r,relativePath:r}}};export{m as buildUrlSuffix,$ as createUrl,u as replaceDynamicSegments};
+const $=t=>{if(!t)return"";const r=t.query?`?${new URLSearchParams(t.query).toString()}`:"",c=t.hash?`#${t.hash}`:"";return r+c},f=(t,r)=>t.replace(/\/_{5}(\w+)/g,r.optionalCatchAll).replace(/\/_{3}(\w+)/g,r.catchAll).replace(/\/_(\w+)/g,r.dynamic),l=t=>{try{return decodeURIComponent(t)}catch{return t}},p=t=>{const r=t.join("/");return(r?`/${r}`:"/").replace(/\/+/g,"/").replace(/\/+$/,"")||"/"},g=t=>t.startsWith("_____")?`[[...${t.slice(5)}]]`:t.startsWith("___")?`[...${t.slice(3)}]`:t.startsWith("_")?`[${t.slice(1)}]`:l(t),m=(t,r,c)=>{const s=t.shift(),h=p(t.map(n=>c.includes(n)?n:l(n))),u=c.reduce((n,e)=>{const a=r[e];return Array.isArray(a)?n.replace(`/${e}`,`/${a.map(encodeURIComponent).join("/")}`):a===void 0?n.replace(`/${e}`,""):n.replace(`/${e}`,`/${encodeURIComponent(a)}`)},h);return n=>{const e=`${u}${$(n)}`,a=p(t.map(g)),i={};for(const o in r){const d=o.replace(/^_+/,"");i[d]=r[o]}return{pathname:a,params:i,path:s?`${s.replace(/\/$/,"")}${e}`:e,relativePath:e}}};export{$ as buildUrlSuffix,m as createUrl,f as replaceDynamicSegments};

package/dist/rpc/server/handler.d.ts

@@ -1,4 +1,4 @@
-import type { ValidationSchema, RouteResponse, Handler } from "./route-types";
-import type { Params, Query } from "./types";
 import type { HttpMethod } from "rpc4next-shared";
+import type { Handler, RouteResponse, ValidationSchema } from "./route-types";
+import type { Params, Query } from "./types";
 export declare const createHandler: <THttpMethod extends HttpMethod, TParams extends Params, TQuery extends Query, TValidationSchema extends ValidationSchema>() => <TRouteResponse extends RouteResponse>(handler: Handler<THttpMethod, TParams, TQuery, TValidationSchema, TRouteResponse>) => Handler<THttpMethod, TParams, TQuery, TValidationSchema, TRouteResponse>;

package/dist/rpc/server/index.d.ts

@@ -1,4 +1,4 @@
-export { routeHandlerFactory } from "./route-handler-factory";
-export type { TypedNextResponse } from "./types";
 export type { ContentType } from "../lib/content-type-types";
 export type { HttpStatusCode } from "../lib/http-status-code-types";
+export { routeHandlerFactory } from "./route-handler-factory";
+export type { TypedNextResponse } from "./types";

package/dist/rpc/server/route-context.d.ts

@@ -1,6 +1,6 @@
-import type { ValidationSchema } from "./route-types";
-import type { RouteContext, Query, Params } from "./types";
 import type { NextRequest } from "next/server";
+import type { ValidationSchema } from "./route-types";
+import type { Params, Query, RouteContext } from "./types";
 export declare const createRouteContext: <TParams extends Params, TQuery extends Query, TValidationSchema extends ValidationSchema>(req: NextRequest, segmentData: {
     params: Promise<TParams>;
 }) => RouteContext<TParams, TQuery, TValidationSchema>;

package/dist/rpc/server/route-handler-factory.d.ts

@@ -2,8 +2,8 @@
  * Inspired by Hono (https://github.com/honojs/hono),
  * particularly its routing design and handler interface.
  */
-import type { RequiredRouteResponse, ErrorHandler, RouteBindings, MethodRouteDefinition } from "./route-types";
-import type { Query, Params } from "./types";
+import type { ErrorHandler, MethodRouteDefinition, RequiredRouteResponse, RouteBindings } from "./route-types";
+import type { Params, Query } from "./types";
 /**
  * A factory function that creates route handlers for various HTTP methods (GET, POST, etc.).
  *

package/dist/rpc/server/route-types.d.ts

@@ -6,10 +6,10 @@
  * Original copyright belongs to Yusuke Wada and the Hono project contributors.
  * Hono is licensed under the MIT License.
  */
-import type { TypedNextResponse, Query, RouteContext, Params } from "./types";
 import type { NextRequest } from "next/server";
 import type { HttpMethod } from "rpc4next-shared";
-export type RouteResponse = TypedNextResponse | Promise<TypedNextResponse | void>;
+import type { Params, Query, RouteContext, TypedNextResponse } from "./types";
+export type RouteResponse = TypedNextResponse | Promise<TypedNextResponse | undefined>;
 export type RequiredRouteResponse = TypedNextResponse | Promise<TypedNextResponse>;
 export interface RouteBindings {
     params?: Params | Promise<Params>;
@@ -21,7 +21,7 @@ export interface ValidationSchema {
 }
 export type Handler<_THttpMethod extends HttpMethod, TParams = Params, TQuery = Query, TValidationSchema extends ValidationSchema = ValidationSchema, TRouteResponse extends RouteResponse = RouteResponse> = (routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => TRouteResponse;
 export type ErrorHandler<TRouteResponse extends RequiredRouteResponse, TParams = Params, TQuery = Query, TValidationSchema extends ValidationSchema = ValidationSchema> = (error: unknown, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => TRouteResponse;
-export type RouteHandlerResponse<TRouteResponse extends RouteResponse, _TValidationSchema extends ValidationSchema> = Promise<Exclude<Awaited<TRouteResponse>, void | undefined>>;
+export type RouteHandlerResponse<TRouteResponse extends RouteResponse, _TValidationSchema extends ValidationSchema> = Promise<Exclude<Awaited<TRouteResponse>, undefined | undefined>>;
 export type RouteHandler<TParams extends RouteBindings["params"], TRouteResponse extends RouteResponse, TValidationSchema extends ValidationSchema> = (req: NextRequest, segmentData: {
     params: Promise<TParams>;
 }) => RouteHandlerResponse<TRouteResponse, TValidationSchema>;

package/dist/rpc/server/types.d.ts

@@ -1,9 +1,9 @@
-import type { ValidationSchema } from "./route-types";
+import type { NextRequest, NextResponse } from "next/server";
+import type { HttpMethod } from "rpc4next-shared";
 import type { ContentType } from "../lib/content-type-types";
 import type { HttpResponseHeaders } from "../lib/http-response-headers-types";
 import type { HttpStatusCode, RedirectionHttpStatusCode, SuccessfulHttpStatusCode } from "../lib/http-status-code-types";
-import type { NextResponse, NextRequest } from "next/server";
-import type { HttpMethod } from "rpc4next-shared";
+import type { ValidationSchema } from "./route-types";
 /**
  * Represents the result of an HTTP response status check.
  *

package/dist/rpc/server/validators/validator.d.ts

@@ -6,7 +6,7 @@
  * Original copyright belongs to Yusuke Wada and the Hono project contributors.
  * Hono is licensed under the MIT License.
  */
+import type { HttpMethod } from "rpc4next-shared";
 import type { ValidationSchema } from "../route-types";
 import type { Params, Query, RouteContext, TypedNextResponse, ValidatedData, ValidationTarget } from "../types";
-import type { HttpMethod } from "rpc4next-shared";
 export declare const validator: <THttpMethod extends HttpMethod, TValidationTarget extends ValidationTarget<THttpMethod>, TParams extends Params, TQuery extends Query, TValidationSchema extends ValidationSchema>() => <TTypedNextResponse extends TypedNextResponse>(target: TValidationTarget, validateHandler: (value: object, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => Promise<ValidatedData | TTypedNextResponse>) => import("../route-types").Handler<THttpMethod, TParams, TQuery, TValidationSchema, Promise<TTypedNextResponse | undefined>>;

package/dist/rpc/server/validators/zod/zod-validator.d.ts

@@ -6,11 +6,11 @@
  * Original copyright belongs to Yusuke Wada and the Hono project contributors.
  * Hono is licensed under the MIT License.
  */
-import type { ValidationSchema } from "../../route-types";
-import type { RouteContext, Params, Query, TypedNextResponse, ConditionalValidationInput, ValidationTarget } from "../../types";
 import type { HttpMethod } from "rpc4next-shared";
-import type { z, ZodSchema } from "zod";
+import type { ZodSchema, z } from "zod";
+import type { ValidationSchema } from "../../route-types";
+import type { ConditionalValidationInput, Params, Query, RouteContext, TypedNextResponse, ValidationTarget } from "../../types";
 export declare const zValidator: <THttpMethod extends HttpMethod, TValidationTarget extends ValidationTarget<THttpMethod>, TSchema extends ZodSchema<any>, TParams extends ConditionalValidationInput<TValidationTarget, "params", TValidationSchema, Params> & Params, TQuery extends ConditionalValidationInput<TValidationTarget, "query", TValidationSchema, Query> & Query, TInput = z.input<TSchema>, TOutput = z.output<TSchema>, TValidationSchema extends ValidationSchema = {
     input: Record<TValidationTarget, TInput>;
     output: Record<TValidationTarget, TOutput>;
-}, THookReturn extends TypedNextResponse | void = TypedNextResponse<z.ZodSafeParseError<TInput>, 400, "application/json"> | void>(target: TValidationTarget, schema: TSchema, hook?: (result: z.ZodSafeParseResult<TOutput>, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => THookReturn) => import("../../route-types").Handler<THttpMethod, TParams, TQuery, TValidationSchema, Promise<Exclude<THookReturn, void> | undefined>>;
+}, THookReturn extends TypedNextResponse | undefined = TypedNextResponse<z.ZodSafeParseError<TInput>, 400, "application/json"> | undefined>(target: TValidationTarget, schema: TSchema, hook?: (result: z.ZodSafeParseResult<TOutput>, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => THookReturn) => import("../../route-types").Handler<THttpMethod, TParams, TQuery, TValidationSchema, Promise<Exclude<THookReturn, void> | undefined>>;

package/dist/rpc/server/validators/zod/zod-validator.js

@@ -5,4 +5,4 @@
  * This code has been adapted and modified for this project.
  * Original copyright belongs to Yusuke Wada and the Hono project contributors.
  * Hono is licensed under the MIT License.
- */import{validator as s}from"../validator";const T=(n,i,r)=>{const d=r??((t,a)=>{if(!t.success)return a.json(t,{status:400})});return s()(n,async(t,a)=>{const e=await i.safeParseAsync(t),o=d(e,a);if(o instanceof Response)return o;if(!e.success)throw new Error("If you provide a custom hook, you must explicitly return a response when validation fails.");return e.data})};export{T as zValidator};
+ */import{validator as s}from"../validator";const T=(n,i,r)=>{const d=r??((t,e)=>{if(!t.success)return e.json(t,{status:400})});return s()(n,async(t,e)=>{const a=await i.safeParseAsync(t),o=d(a,e);if(o instanceof Response)return o;if(!a.success)throw new Error("If you provide a custom hook, you must explicitly return a response when validation fails.");return a.data})};export{T as zValidator};

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "rpc4next",
-  "version": "0.4.14",
+  "version": "0.5.1",
   "description": "Inspired by Hono RPC and Pathpida, rpc4next brings a lightweight and intuitive RPC solution to Next.js, making server-client communication seamless",
-  "author": "watanabe-1",
-  "license": "MIT",
+  "keywords": [
+    "next.js",
+    "rpc",
+    "typescript"
+  ],
   "homepage": "https://github.com/watanabe-1/rpc4next#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/watanabe-1/rpc4next.git",
     "directory": "packages/rpc4next"
   },
-  "publishConfig": {
-    "access": "public"
-  },
-  "keywords": [
-    "next.js",
-    "rpc",
-    "typescript"
-  ],
+  "license": "MIT",
+  "author": "watanabe-1",
   "type": "module",
+  "engines": {
+    "node": ">=20.19.2"
+  },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -94,14 +94,17 @@
     "test:coverage": "vitest run --coverage.enabled true",
     "test:ui": "vitest --ui --coverage.enabled true",
     "test:watch": "vitest --watch",
-    "lint": "eslint src",
-    "lint:fix": "eslint src --fix",
-    "typecheck": "tsc -b tsconfig.build.json --noEmit"
+    "lint": "biome check src",
+    "lint:fix": "biome check --write src",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit"
   },
   "dependencies": {
-    "rpc4next-shared": "^0.1.5"
+    "rpc4next-shared": "^0.3.0"
   },
   "peerDependencies": {
     "next": "^14.0.0 || ^15.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }