rpc4next 0.1.0

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

@@ -0,0 +1,53 @@
+import type { Query, Params, RouteBindings, MethodRouteDefinition, RequiredRouteResponse, ErrorHandler } from "./types";
+/**
+ * A factory function that creates route handlers for various HTTP methods (GET, POST, etc.).
+ *
+ * Optionally accepts a global error handler that will be used if any route handler throws.
+ *
+ * Example usage:
+ * ```ts
+ * const createRouteHandler = routeHandlerFactory((err, rc) => rc.text("error", {status : 400}));
+ * export const { POST } = createRouteHandler<{ params: ..., query: ... }>().post((rc) => rc.json({success: true}));
+ * ```
+ *
+ * @template TOnErrorResponse Type of the response returned by the error handler (optional)
+ * @param onError Optional global error handler. If not provided, errors will be re-thrown.
+ * @returns An object with methods (`get`, `post`, `put`, etc.) to define route handlers for each HTTP method
+ */
+export declare const routeHandlerFactory: <TOnErrorResponse extends RequiredRouteResponse = never>(onError?: ErrorHandler<TOnErrorResponse>) => <TBindings extends RouteBindings>() => {
+    get: MethodRouteDefinition<"GET", TBindings, TOnErrorResponse, TBindings extends {
+        params: infer TValue;
+    } ? Awaited<TValue> : Params, TBindings extends {
+        query: infer TValue_1;
+    } ? TValue_1 : Query>;
+    post: MethodRouteDefinition<"POST", TBindings, TOnErrorResponse, TBindings extends {
+        params: infer TValue;
+    } ? Awaited<TValue> : Params, TBindings extends {
+        query: infer TValue_1;
+    } ? TValue_1 : Query>;
+    put: MethodRouteDefinition<"PUT", TBindings, TOnErrorResponse, TBindings extends {
+        params: infer TValue;
+    } ? Awaited<TValue> : Params, TBindings extends {
+        query: infer TValue_1;
+    } ? TValue_1 : Query>;
+    delete: MethodRouteDefinition<"DELETE", TBindings, TOnErrorResponse, TBindings extends {
+        params: infer TValue;
+    } ? Awaited<TValue> : Params, TBindings extends {
+        query: infer TValue_1;
+    } ? TValue_1 : Query>;
+    patch: MethodRouteDefinition<"PATCH", TBindings, TOnErrorResponse, TBindings extends {
+        params: infer TValue;
+    } ? Awaited<TValue> : Params, TBindings extends {
+        query: infer TValue_1;
+    } ? TValue_1 : Query>;
+    head: MethodRouteDefinition<"HEAD", TBindings, TOnErrorResponse, TBindings extends {
+        params: infer TValue;
+    } ? Awaited<TValue> : Params, TBindings extends {
+        query: infer TValue_1;
+    } ? TValue_1 : Query>;
+    options: MethodRouteDefinition<"OPTIONS", TBindings, TOnErrorResponse, TBindings extends {
+        params: infer TValue;
+    } ? Awaited<TValue> : Params, TBindings extends {
+        query: infer TValue_1;
+    } ? TValue_1 : Query>;
+};

package/dist/helper/server/route-handler-factory.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeHandlerFactory = void 0;
+const create_route_context_1 = require("./create-route-context");
+const composeHandlersWithError = (handlers, onError) => {
+    return (req, segmentData) => __awaiter(void 0, void 0, void 0, function* () {
+        const routeContext = (0, create_route_context_1.createRouteContext)(req, segmentData);
+        try {
+            for (const handler of handlers) {
+                const result = yield handler(routeContext);
+                if (result instanceof Response) {
+                    return result;
+                }
+            }
+            throw new Error("No handler returned a response");
+        }
+        catch (error) {
+            return yield onError(error, routeContext);
+        }
+    });
+};
+/**
+ * A factory function that creates route handlers for various HTTP methods (GET, POST, etc.).
+ *
+ * Optionally accepts a global error handler that will be used if any route handler throws.
+ *
+ * Example usage:
+ * ```ts
+ * const createRouteHandler = routeHandlerFactory((err, rc) => rc.text("error", {status : 400}));
+ * export const { POST } = createRouteHandler<{ params: ..., query: ... }>().post((rc) => rc.json({success: true}));
+ * ```
+ *
+ * @template TOnErrorResponse Type of the response returned by the error handler (optional)
+ * @param onError Optional global error handler. If not provided, errors will be re-thrown.
+ * @returns An object with methods (`get`, `post`, `put`, etc.) to define route handlers for each HTTP method
+ */
+const routeHandlerFactory = (onError) => () => {
+    const defineRouteForMethod = (method) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return ((...handlers) => {
+            const resolvedOnError = onError !== null && onError !== void 0 ? onError : ((error, _) => {
+                throw error;
+            });
+            const routeHandler = composeHandlersWithError(handlers, resolvedOnError);
+            return { [method]: routeHandler };
+        });
+    };
+    return {
+        get: defineRouteForMethod("GET"),
+        post: defineRouteForMethod("POST"),
+        put: defineRouteForMethod("PUT"),
+        delete: defineRouteForMethod("DELETE"),
+        patch: defineRouteForMethod("PATCH"),
+        head: defineRouteForMethod("HEAD"),
+        options: defineRouteForMethod("OPTIONS"),
+    };
+};
+exports.routeHandlerFactory = routeHandlerFactory;

package/dist/helper/server/search-params-to-object.d.ts

@@ -0,0 +1 @@
+export declare const searchParamsToObject: <T extends Record<string, string | string[] | undefined>>(searchParams: URLSearchParams) => T;

package/dist/helper/server/search-params-to-object.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchParamsToObject = void 0;
+const searchParamsToObject = (searchParams) => {
+    const params = {};
+    searchParams.forEach((value, key) => {
+        if (key in params) {
+            params[key] = Array.isArray(params[key])
+                ? [...params[key], value]
+                : [params[key], value];
+        }
+        else {
+            params[key] = value;
+        }
+    });
+    return params;
+};
+exports.searchParamsToObject = searchParamsToObject;

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

@@ -0,0 +1,250 @@
+import { HttpMethod } from "../../lib/types";
+import type { NextResponse, NextRequest } from "next/server";
+type KnownContentType = "application/json" | "text/html" | "text/plain" | "application/javascript" | "text/css" | "image/png" | "image/jpeg" | "image/svg+xml" | "application/pdf" | "application/octet-stream" | "multipart/form-data" | "application/x-www-form-urlencoded";
+/**
+ * A content type that can be either one of the predefined `KnownContentType` values,
+ * or any other custom string.
+ */
+export type ContentType = KnownContentType | (string & {});
+/**
+ * Informational responses (100–199)
+ */
+type InformationalHttpStatusCode = 100 | 101 | 102 | 103;
+/**
+ * Successful responses (200–299)
+ */
+type SuccessfulHttpStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+/**
+ * Redirection messages (300–399)
+ */
+export type RedirectionHttpStatusCode = 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
+/**
+ * Client error responses (400–499)
+ */
+type ClientErrorHttpStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
+/**
+ * Server error responses (500–599)
+ */
+type ServerErrorHttpStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+/**
+ * Http status code (100～599)
+ */
+export type HttpStatusCode = InformationalHttpStatusCode | SuccessfulHttpStatusCode | RedirectionHttpStatusCode | ClientErrorHttpStatusCode | ServerErrorHttpStatusCode;
+/**
+ * Represents the result of an HTTP response status check.
+ *
+ * If the status code is in the range of successful HTTP status codes (e.g., 200–299),
+ * `ok` is `true` and `status` is set to the given successful status code.
+ *
+ * Otherwise, `ok` is `false` and `status` is set to a non-successful status code
+ * (i.e., `T` excluding successful status codes).
+ *
+ * @template T - An HTTP status code to classify.
+ */
+type HttpStatus<T extends HttpStatusCode> = T extends SuccessfulHttpStatusCode ? {
+    ok: true;
+    status: T;
+} : {
+    ok: false;
+    status: Exclude<T, SuccessfulHttpStatusCode>;
+};
+/**
+ * Represents HTTP response headers with optional fields, parameterized by the content type.
+ * This type includes common headers used for caching, content description, CORS, authentication, security, cookies, redirects, connection, and server information.
+ *
+ * @template TContentType - The specific content type for the `Content-Type` header.
+ */
+type HttpResponseHeaders<TContentType extends ContentType> = Partial<{
+    "Cache-Control": string;
+    Expires: string;
+    ETag: string;
+    "Last-Modified": string;
+    "Content-Type": TContentType;
+    "Content-Length": string;
+    "Content-Encoding": string;
+    "Content-Language": string;
+    "Content-Location": string;
+    "Content-Disposition": string;
+    "Access-Control-Allow-Origin": string;
+    "Access-Control-Allow-Credentials": string;
+    "Access-Control-Allow-Headers": string;
+    "Access-Control-Allow-Methods": string;
+    "Access-Control-Expose-Headers": string;
+    "WWW-Authenticate": string;
+    Authorization: string;
+    "Strict-Transport-Security": string;
+    "Content-Security-Policy": string;
+    "X-Content-Type-Options": string;
+    "X-Frame-Options": string;
+    "X-XSS-Protection": string;
+    "Referrer-Policy": string;
+    "Permissions-Policy": string;
+    "Cross-Origin-Opener-Policy": string;
+    "Cross-Origin-Embedder-Policy": string;
+    "Cross-Origin-Resource-Policy": string;
+    "Set-Cookie": string;
+    Location: string;
+    Connection: string;
+    "Keep-Alive": string;
+    "Transfer-Encoding": string;
+    Upgrade: string;
+    Vary: string;
+    Date: string;
+    Server: string;
+    "X-Powered-By": string;
+}>;
+/**
+ * Extension of the standard `ResponseInit` interface with strongly typed status and headers.
+ *
+ * @template TStatus - The HTTP status code.
+ * @template TContentType - The content type of the response.
+ */
+export interface TypedResponseInit<TStatus extends HttpStatusCode, TContentType extends ContentType> extends ResponseInit {
+    headers?: HttpResponseHeaders<TContentType> | HeadersInit;
+    status?: TStatus;
+}
+/**
+ * A strongly typed wrapper around the standard Next.js `NextResponse` object,
+ * with additional type information for status code, content type, and response body.
+ *
+ * @template TData - The type of the response body (e.g., a JSON object or string).
+ * @template TStatus - The HTTP status code type of the response.
+ * @template TContentType - The content type of the response (e.g., "application/json" or "text/plain").
+ */
+export interface TypedNextResponse<TData = unknown, TStatus extends HttpStatusCode = HttpStatusCode, TContentType extends ContentType = ContentType> extends NextResponse {
+    /**
+     * Returns the parsed response body as JSON, if the content type is "application/json".
+     * Otherwise, returns a `Promise<never>`.
+     */
+    json: TContentType extends "application/json" ? () => Promise<TData> : () => Promise<never>;
+    /**
+     * Returns the response body as plain text, if the content type is "text/plain".
+     * If the expected type `T` is not a string, returns `Promise<never>`.
+     * Otherwise, returns the raw string body.
+     */
+    text: TContentType extends "text/plain" ? TData extends string ? () => Promise<TData> : () => Promise<never> : () => Promise<string>;
+    /**
+     * Indicates whether the HTTP status code represents a successful response.
+     */
+    readonly ok: HttpStatus<TStatus>["ok"];
+    /**
+     * The HTTP status code of the response, typed based on the given `TStatus`.
+     */
+    readonly status: HttpStatus<TStatus>["status"];
+}
+export type Params = Record<string, string | string[]>;
+export type Query = Record<string, string | string[]>;
+/**
+ * A typed wrapper around Next.js request/response utilities for API route handling.
+ *
+ * ## Features:
+ * - Enhanced `req` with helpers to parse query parameters, route params, and perform schema validation.
+ * - Typed response helpers (`json`, `text`, `body`) that return custom `TypedNextResponse` objects.
+ *
+ * @template TParams - Shape of dynamic route parameters.
+ * @template TQuery - Shape of parsed URL query parameters.
+ * @template TValidationSchema - Validation schema used to validate body/query/params.
+ */
+export interface RouteContext<TParams = Params, TQuery = Query, TValidationSchema extends ValidationSchema = ValidationSchema> {
+    /**
+     * The original `NextRequest` object, extended with helper methods
+     * for parsing parameters, query, and managing validation.
+     */
+    req: NextRequest & {
+        /**
+         * Parses and returns typed query parameters from `req.nextUrl.searchParams`.
+         *
+         * @returns Query parameters
+         */
+        query: () => TQuery;
+        /**
+         * Resolves and returns dynamic route parameters.
+         * Typically sourced from the Next.js segment config.
+         *
+         * @returns Route parameters
+         */
+        params: () => Promise<TParams>;
+        /**
+         * Retrieves validated data for a specific request part (e.g., `body`, `query`, `params`)
+         * that has been previously stored via `addValidatedData`.
+         *
+         * @param target - The part of the request to validate.
+         * @returns The validation result of the target.
+         */
+        valid: <TValidationTarget extends ValidationTarget>(target: TValidationTarget) => ValidationOutputFor<TValidationTarget, TValidationSchema>;
+        /**
+         * Stores validated data for a specific part of the request.
+         * This data can be retrieved later using `valid(...)`.
+         *
+         * @param target - The request part to associate the value with.
+         * @param value - The validated data.
+         */
+        addValidatedData: (target: ValidationTarget, value: object) => void;
+    };
+    /**
+     * Creates a typed response with an optional status.
+     * Internally wraps `new NextResponse(...)`.
+     *
+     * @param data - The response body.
+     * @param init - Optional response init.
+     * @returns A typed response.
+     */
+    body: <TData extends BodyInit | null, TContentType extends ContentType, TStatus extends HttpStatusCode = 200>(data: TData, init?: TypedResponseInit<TStatus, TContentType>) => TypedNextResponse<TData, TStatus, TContentType>;
+    /**
+     * Creates a typed JSON response using `NextResponse.json(...)`.
+     *
+     * @param data - The response body as JSON.
+     * @param init - Optional response init.
+     * @returns A JSON response.
+     */
+    json: <TData, TStatus extends HttpStatusCode = 200>(data: TData, init?: TypedResponseInit<TStatus, "application/json">) => TypedNextResponse<TData, TStatus, "application/json">;
+    /**
+     * Creates a plain text response with `Content-Type: text/plain`.
+     * Internally uses `new NextResponse(...)` with headers.
+     *
+     * @param data - The response body as plain text.
+     * @param init - Optional response init.
+     * @returns A plain text response.
+     */
+    text: <TData extends string, TStatus extends HttpStatusCode = 200>(data: TData, init?: TypedResponseInit<TStatus, "text/plain">) => TypedNextResponse<TData, TStatus, "text/plain">;
+    /**
+     * Issues a redirect response.
+     * Internally wraps `NextResponse.redirect(...)`.
+     *
+     * @param url - The URL to redirect to.
+     * @param init - Optional redirect status code (default: 302).
+     * @returns A redirect response.
+     */
+    redirect: <TStatus extends RedirectionHttpStatusCode = 302>(url: string, init?: TStatus | TypedResponseInit<TStatus, "">) => TypedNextResponse<undefined, TStatus, "">;
+}
+export type RouteResponse = TypedNextResponse | Promise<TypedNextResponse | void>;
+export type RequiredRouteResponse = TypedNextResponse | Promise<TypedNextResponse>;
+export interface RouteBindings {
+    params?: Params | Promise<Params>;
+    query?: Query;
+}
+export type ValidationTarget = "params" | "query";
+export interface ValidationSchema {
+    input: {};
+    output: {};
+}
+type ValidationFor<TDirection extends keyof ValidationSchema, TTarget extends ValidationTarget, TSchema extends ValidationSchema> = TTarget extends keyof TSchema[TDirection] ? TSchema[TDirection][TTarget] : never;
+type ValidationInputFor<TTarget extends ValidationTarget, TSchema extends ValidationSchema> = ValidationFor<"input", TTarget, TSchema>;
+type ValidationOutputFor<TTarget extends ValidationTarget, TSchema extends ValidationSchema> = ValidationFor<"output", TTarget, TSchema>;
+export type ConditionalValidationInput<TTarget extends ValidationTarget, TExpected extends ValidationTarget, TSchema extends ValidationSchema, TFallback> = TTarget extends TExpected ? ValidationInputFor<TTarget, TSchema> : TFallback;
+export type Handler<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;
+type RouteHandler<TParams extends RouteBindings["params"], TRouteResponse extends RouteResponse> = (req: NextRequest, segmentData: {
+    params: Promise<TParams>;
+}) => Promise<Exclude<Awaited<TRouteResponse>, void | undefined>>;
+type HttpMethodMapping<THttpMethod extends HttpMethod, TParams extends RouteBindings["params"], TRouteResponse extends RouteResponse> = Record<THttpMethod, RouteHandler<TParams, TRouteResponse>>;
+export interface MethodRouteDefinition<THttpMethod extends HttpMethod, TBindings extends RouteBindings, TOnErrorResponse extends RequiredRouteResponse, TParams extends TBindings["params"] = TBindings extends {
+    params: infer TValue;
+} ? Awaited<TValue> : Params, TQuery extends TBindings["query"] = TBindings extends {
+    query: infer TValue;
+} ? TValue : Query> {
+    <TV1 extends ValidationSchema = ValidationSchema, TR1 extends RequiredRouteResponse = RequiredRouteResponse>(handler: Handler<TParams, TQuery, TV1, TR1>): HttpMethodMapping<THttpMethod, TParams, TR1 | TOnErrorResponse>;
+    <TV1 extends ValidationSchema = ValidationSchema, TV2 extends ValidationSchema = TV1, TR1 extends RouteResponse = RouteResponse, TR2 extends RequiredRouteResponse = RequiredRouteResponse>(handler1: Handler<TParams, TQuery, TV1, TR1>, handler2: Handler<TParams, TQuery, TV2, TR2>): HttpMethodMapping<THttpMethod, TParams, TR1 | TR2 | TOnErrorResponse>;
+    <TV1 extends ValidationSchema = ValidationSchema, TV2 extends ValidationSchema = TV1, TV3 extends ValidationSchema = TV1 & TV2, TR1 extends RouteResponse = RouteResponse, TR2 extends RouteResponse = RouteResponse, TR3 extends RequiredRouteResponse = RequiredRouteResponse>(handler1: Handler<TParams, TQuery, TV1, TR1>, handler2: Handler<TParams, TQuery, TV2, TR2>, handler3: Handler<TParams, TQuery, TV3, TR3>): HttpMethodMapping<THttpMethod, TParams, TR1 | TR2 | TR3 | TOnErrorResponse>;
+}
+export {};

package/dist/helper/server/types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Inspired by Hono (https://github.com/honojs/hono)
+// Some parts of this code are based on or adapted from the Hono project
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/helper/server/validators/zod/index.d.ts

@@ -0,0 +1 @@
+export { zodValidator } from "./zod-validator";

package/dist/helper/server/validators/zod/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodValidator = void 0;
+var zod_validator_1 = require("./zod-validator");
+Object.defineProperty(exports, "zodValidator", { enumerable: true, get: function () { return zod_validator_1.zodValidator; } });

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

@@ -0,0 +1,6 @@
+import type { RouteContext, Params, Query, TypedNextResponse, ValidationSchema, ConditionalValidationInput, ValidationTarget } from "../../types";
+import type { z, ZodSchema } from "zod";
+export declare const zodValidator: <TValidationTarget extends ValidationTarget, 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.SafeParseError<TInput>, 400, "application/json"> | void>(target: TValidationTarget, schema: TSchema, hook?: (result: z.SafeParseReturnType<TInput, TOutput>, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => THookReturn) => import("../../types").Handler<TParams, TQuery, TValidationSchema, Promise<Exclude<THookReturn, void> | undefined>>;

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

@@ -0,0 +1,44 @@
+"use strict";
+// Inspired by Hono (https://github.com/honojs/middleware/tree/main/packages/zod-validator)
+// Some parts of this code are based on or adapted from the Hono project
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodValidator = void 0;
+const create_handler_1 = require("../../create-handler");
+const zodValidator = (target, schema, hook) => {
+    const resolvedHook = hook !== null && hook !== void 0 ? hook : ((result, rc) => {
+        if (!result.success) {
+            return rc.json(result, { status: 400 });
+        }
+    });
+    return (0, create_handler_1.createHandler)()((rc) => __awaiter(void 0, void 0, void 0, function* () {
+        const value = yield (() => __awaiter(void 0, void 0, void 0, function* () {
+            if (target === "params") {
+                return yield rc.req.params();
+            }
+            if (target === "query") {
+                return rc.req.query();
+            }
+        }))();
+        const result = yield schema.safeParseAsync(value);
+        const hookResult = resolvedHook(result, rc);
+        if (hookResult instanceof Response) {
+            // If it's of type Response, it won't be void, so we're excluding void here
+            return hookResult;
+        }
+        if (!result.success) {
+            throw new Error("If you provide a custom hook, you must explicitly return a response when validation fails.");
+        }
+        // If validation succeeds, register it as validatedData
+        rc.req.addValidatedData(target, result.data);
+    }));
+};
+exports.zodValidator = zodValidator;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./helper/server"), exports);
+__exportStar(require("./helper/client"), exports);

package/dist/lib/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const OPTIONAL_CATCH_ALL_PREFIX = "_____";
+export declare const CATCH_ALL_PREFIX = "___";
+export declare const DYNAMIC_PREFIX = "_";
+export declare const HTTP_METHODS_EXCLUDE_OPTIONS: ("GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "PATCH")[];
+export declare const HTTP_METHOD_FUNC_KEYS: ("$delete" | "$get" | "$head" | "$post" | "$put" | "$patch")[];

package/dist/lib/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_METHOD_FUNC_KEYS = exports.HTTP_METHODS_EXCLUDE_OPTIONS = exports.DYNAMIC_PREFIX = exports.CATCH_ALL_PREFIX = exports.OPTIONAL_CATCH_ALL_PREFIX = void 0;
+const http_1 = require("next/dist/server/web/http");
+exports.OPTIONAL_CATCH_ALL_PREFIX = "_____";
+exports.CATCH_ALL_PREFIX = "___";
+exports.DYNAMIC_PREFIX = "_";
+exports.HTTP_METHODS_EXCLUDE_OPTIONS = http_1.HTTP_METHODS.filter((method) => method !== "OPTIONS");
+exports.HTTP_METHOD_FUNC_KEYS = exports.HTTP_METHODS_EXCLUDE_OPTIONS.map((method) => `$${method.toLowerCase()}`);

package/dist/lib/types.d.ts

@@ -0,0 +1 @@
+export type { HTTP_METHOD as HttpMethod } from "next/dist/server/web/http";

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "rpc4next",
+  "version": "0.1.0",
+  "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",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/watanabe-1/rpc4next"
+  },
+  "homepage": "https://github.com/watanabe-1/rpc4next#readme",
+  "bugs": {
+    "url": "https://github.com/watanabe-1/rpc4next/issues"
+  },
+  "keywords": [
+    "next.js",
+    "rpc",
+    "typescript",
+    "cli"
+  ],
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "rpc4next": "dist/cli/cli.js"
+  },
+  "exports": {
+    "./client": {
+      "import": {
+        "types": "./dist/helper/client/index.d.ts",
+        "default": "./dist/helper/client/index.js"
+      }
+    },
+    "./server": {
+      "import": {
+        "types": "./dist/helper/server/index.d.ts",
+        "default": "./dist/helper/server/index.js"
+      }
+    },
+    "./server/validators/zod": {
+      "import": {
+        "types": "./dist/helper/server/validators/zod/index.d.ts",
+        "default": "./dist/helper/server/validators/zod/index.js"
+      }
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
+    "lint": "eslint \"**/*.ts\"",
+    "lint:fix": "eslint \"**/*.ts\" --fix"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.14",
+    "@vitest/eslint-plugin": "^1.1.38",
+    "eslint": "^9.23.0",
+    "eslint-config-prettier": "^10.1.1",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-unused-imports": "^4.1.4",
+    "mock-fs": "^5.5.0",
+    "msw": "^2.7.3",
+    "next": "15.2.4",
+    "prettier": "^3.5.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2",
+    "typescript-eslint": "^8.28.0",
+    "vitest": "^3.0.9",
+    "zod": "^3.24.2"
+  },
+  "peerDependencies": {
+    "next": "^14.0.0 || ^15.0.0"
+  }
+}