rpc4next 0.3.7 → 0.3.8

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

@@ -1,2 +1,3 @@
-export { createRpcClient, createRpcHelper } from "./rpc";
+export { createRpcClient } from "./rpc-client";
+export { createRpcHelper } from "./rpc-helper";
 export type { Endpoint, ParamsKey, QueryKey, OptionalQueryKey } from "./types";

package/dist/rpc/client/index.js

@@ -1 +1 @@
-import{createRpcClient as p,createRpcHelper as t}from"./rpc";export{p as createRpcClient,t as createRpcHelper};
+import{createRpcClient as p}from"./rpc-client";import{createRpcHelper as o}from"./rpc-helper";export{p as createRpcClient,o as createRpcHelper};

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

@@ -0,0 +1,32 @@
+import type { ClientOptions, DynamicPathProxyAsFunction } from "./types";
+/**
+ * Creates an RPC client proxy for making HTTP requests with a strongly typed API.
+ *
+ * @template T - The type defining the RPC endpoint structure.
+ * @param baseUrl - The base URL for the RPC client. This URL will be used as the root for all generated endpoint URLs.
+ * @param options - (Optional) Client options to customize the behavior of the RPC client. These options may include a custom fetch function and default request initialization options.
+ * @returns An object that enables you to dynamically build endpoint URLs and execute HTTP requests (such as GET, POST, DELETE, etc.) with full type support.
+ *
+ * @example
+ * ```ts
+ * import { createRpcClient } from "./rpc";
+ * import type { PathStructure } from "./types";
+ *
+ * // Create an RPC client with a base URL
+ * const client = createRpcClient<PathStructure>("http://localhost:3000");
+ *
+ * // Generate a URL for a dynamic endpoint
+ * const urlResult = client.fuga._foo("test").$url();
+ * console.log(urlResult.path);         // "http://localhost:3000/fuga/test"
+ * console.log(urlResult.relativePath);   // "/fuga/test"
+ * console.log(urlResult.pathname);       // "/fuga/[foo]"
+ * console.log(urlResult.params);         // { foo: "test" }
+ *
+ * // Execute a GET request on an endpoint
+ * const response = await client.api.hoge._foo("test").$get();
+ * console.log(await response.json());    // Expected response: { method: "get" }
+ * ```
+ *
+ * The above example demonstrates how to generate URLs with dynamic segments and how to execute HTTP requests.
+ */
+export declare const createRpcClient: <T extends object>(baseUrl: string, options?: ClientOptions) => DynamicPathProxyAsFunction<T>;

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

@@ -0,0 +1 @@
+import{httpMethod as n}from"./http-method";import{makeCreateRpc as p}from"./rpc";import{createUrl as m}from"./url";import{isHttpMethod as c}from"./utils";const l=p((t,{paths:r,params:o,dynamicKeys:e,options:i})=>{if(t==="$url")return m([...r],o,e);if(c(t))return n(t,[...r],o,e,i)});export{l as createRpcClient};

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

@@ -0,0 +1,23 @@
+import type { DynamicPathProxyAsProperty } from "./types";
+/**
+ * Creates an RPC helper proxy for dynamic path matching based on a given endpoint structure.
+ *
+ * @template T - The type defining the RPC endpoint structure.
+ *
+ * @returns  An object that provides dynamic RPC helper methods for the defined endpoints.
+ *
+ * @example
+ * ```ts
+ * // Create the RPC helper
+ * const rpcHelper = createRpcHelper<PathStructure>();
+ *
+ * // Use the $match method to extract dynamic parameters from a URL path
+ * const match = rpcHelper.fuga._foo.$match("/fuga/test");
+ * // Expected output: { foo: "test" }
+ *
+ * // If the path does not match, it returns null
+ * const noMatch = rpcHelper.fuga._foo.$match("/hoge/test");
+ * // Expected output: null
+ * ```
+ */
+export declare const createRpcHelper: <T extends object>() => DynamicPathProxyAsProperty<T>;

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

@@ -0,0 +1 @@
+import{matchPath as o}from"./match";import{makeCreateRpc as a}from"./rpc";const c=a((r,{paths:t,dynamicKeys:e})=>{if(r==="$match")return o([...t],e)});export{c as createRpcHelper};

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

@@ -3,58 +3,5 @@
  * and pathpida (https://github.com/aspida/pathpida)
  * particularly their routing structures and developer experience.
  */
-import type { FuncParams, DynamicPathProxyAsFunction, ClientOptions, DynamicPathProxyAsProperty } from "./types";
-export declare const createRpcProxy: <T extends object>(options: ClientOptions, paths?: string[], params?: FuncParams, dynamicKeys?: string[]) => T;
-/**
- * Creates an RPC client proxy for making HTTP requests with a strongly typed API.
- *
- * @template T - The type defining the RPC endpoint structure.
- * @param baseUrl - The base URL for the RPC client. This URL will be used as the root for all generated endpoint URLs.
- * @param options - (Optional) Client options to customize the behavior of the RPC client. These options may include a custom fetch function and default request initialization options.
- * @returns An object that enables you to dynamically build endpoint URLs and execute HTTP requests (such as GET, POST, DELETE, etc.) with full type support.
- *
- * @example
- * ```ts
- * import { createRpcClient } from "./rpc";
- * import type { PathStructure } from "./types";
- *
- * // Create an RPC client with a base URL
- * const client = createRpcClient<PathStructure>("http://localhost:3000");
- *
- * // Generate a URL for a dynamic endpoint
- * const urlResult = client.fuga._foo("test").$url();
- * console.log(urlResult.path);         // "http://localhost:3000/fuga/test"
- * console.log(urlResult.relativePath);   // "/fuga/test"
- * console.log(urlResult.pathname);       // "/fuga/[foo]"
- * console.log(urlResult.params);         // { foo: "test" }
- *
- * // Execute a GET request on an endpoint
- * const response = await client.api.hoge._foo("test").$get();
- * console.log(await response.json());    // Expected response: { method: "get" }
- * ```
- *
- * The above example demonstrates how to generate URLs with dynamic segments and how to execute HTTP requests.
- */
-export declare const createRpcClient: <T extends object>(baseUrl: string, options?: ClientOptions) => DynamicPathProxyAsFunction<T>;
-/**
- * Creates an RPC helper proxy for dynamic path matching based on a given endpoint structure.
- *
- * @template T - The type defining the RPC endpoint structure.
- *
- * @returns  An object that provides dynamic RPC helper methods for the defined endpoints.
- *
- * @example
- * ```ts
- * // Create the RPC helper
- * const rpcHelper = createRpcHelper<PathStructure>();
- *
- * // Use the $match method to extract dynamic parameters from a URL path
- * const match = rpcHelper.fuga._foo.$match("/fuga/test");
- * // Expected output: { foo: "test" }
- *
- * // If the path does not match, it returns null
- * const noMatch = rpcHelper.fuga._foo.$match("/hoge/test");
- * // Expected output: null
- * ```
- */
-export declare const createRpcHelper: <T extends object>() => DynamicPathProxyAsProperty<T>;
+import type { ClientOptions, RpcHandler } from "./types";
+export declare const makeCreateRpc: (handler: RpcHandler) => <T extends object>(base?: string, options?: ClientOptions) => T;

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{httpMethod as m}from"./http-method";import{matchPath as f}from"./match";import{createUrl as p}from"./url";import{isDynamic as u,isHttpMethod as P}from"./utils";const i=(e,t=[],o={},n=[])=>new Proxy(c=>{const r=t.at(-1),a=n.at(-1);if(c===void 0)throw new Error(`An argument is required when calling the function for paramKey: ${a}`);if(r&&a&&u(r))return i(e,[...t],{...o,[a]:c},n);throw new Error(`paramKey: ${r} is not a dynamic parameter and cannot be called as a function`)},{get:(c,r)=>r==="$url"?p([...t],o,n):r==="$match"?f([...t],n):P(r)?m(r,[...t],o,n,{...e}):u(r)?i(e,[...t,r],o,[...n,r]):i(e,[...t,r],o,n)}),w=(e,t={})=>i(t,[e]),T=()=>i({},["/"]);export{w as createRpcClient,T as createRpcHelper,i as createRpcProxy};
+ */import{isDynamic as f}from"./utils";const s=(n,e,t,c,o)=>new Proxy(u=>{const r=t.at(-1),i=o.at(-1);if(u===void 0)throw new Error(`Missing value for dynamic parameter: ${i}`);if(r&&i&&f(r))return s(n,e,[...t],{...c,[i]:u},o);throw new Error(`${r} is not dynamic`)},{get(u,r){const i=n(r,{paths:t,params:c,dynamicKeys:o,options:e});return i!==void 0?i:f(r)?s(n,e,[...t,r],c,[...o,r]):s(n,e,[...t,r],c,o)}}),l=n=>(e="/",t={})=>s(n,t,[e],{},[]);export{l as makeCreateRpc};

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

@@ -100,4 +100,10 @@ export type DynamicPathProxyAsFunction<T> = Omit<(T extends Endpoint ? PathProxy
 export type DynamicPathProxyAsProperty<T> = Omit<(T extends Endpoint ? PathProxyAsProperty<T> : unknown) & {
     [K in keyof T]: K extends unknown ? DynamicPathProxyAsProperty<T[K]> : DynamicPathProxyAsProperty<T[K]>;
 }, QueryKey | OptionalQueryKey | ParamsKey>;
+export type RpcHandler = (key: string, context: {
+    paths: string[];
+    params: FuncParams;
+    dynamicKeys: string[];
+    options: ClientOptions;
+}) => unknown | undefined;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rpc4next",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "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",
@@ -77,22 +77,22 @@
   },
   "devDependencies": {
     "@types/node": "^22.14.1",
-    "@vitest/coverage-v8": "^3.1.1",
+    "@vitest/coverage-v8": "^3.1.2",
     "@vitest/eslint-plugin": "^1.1.43",
-    "@vitest/ui": "^3.1.1",
-    "esbuild": "^0.25.2",
-    "eslint": "^9.24.0",
+    "@vitest/ui": "^3.1.2",
+    "esbuild": "^0.25.3",
+    "eslint": "^9.25.1",
     "eslint-config-prettier": "^10.1.2",
     "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-unused-imports": "^4.1.4",
     "mock-fs": "^5.5.0",
-    "msw": "^2.7.4",
+    "msw": "^2.7.5",
     "next": "15.3.1",
     "prettier": "^3.5.3",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3",
-    "typescript-eslint": "^8.30.1",
-    "vitest": "^3.1.1",
+    "typescript-eslint": "^8.31.0",
+    "vitest": "^3.1.2",
     "zod": "^3.24.3"
   },
   "peerDependencies": {

package/dist/rpc/server/route-types.js

@@ -1,8 +0,0 @@
-/*!
- * Portions of this code are based on the Hono project (https://github.com/honojs/hono),
- * originally created by Yusuke Wada (https://github.com/yusukebe) and developed with
- * contributions from the Hono community.
- * 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.
- */