@thednp/rpc 0.2.0 → 0.3.0

package/dist/server/server.d.mts

@@ -1,15 +1,95 @@
-import { ResolvedConfig, ViteDevServer } from "vite";
+import { Connect, ResolvedConfig, ViteDevServer } from "vite";
 import "@thednp/rpc";
-import "express";
-import "hono";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { NextFunction, Request, Response as Response$1 } from "express";
+import { MiddlewareHandler } from "hono";
 import "@hono/node-server";
 import "hono/utils/http-status";
 import "hono/factory";
-import "fastify";
+import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from "fastify";
 import "fastify-plugin";
-import "koa";
-import "h3";
+import { Context, Next } from "koa";
+import { Middleware } from "h3";
+//#region src/express/types.d.ts
+/**
+ * Express/Connect middleware handler signature used by the RPC middleware.
+ */
+interface ExpressMiddlewareHooks {
+  /**
+   * The handler invoked for each matched request.
+   * @param req - Node or Express request object
+   * @param res - Node or Express response object
+   * @param next - Connect or Express next function
+   */
+  handler: (req: IncomingMessage | Request, res: ServerResponse | Response$1, next: Connect.NextFunction | NextFunction) => Promise<void>;
+}
+//#endregion
+//#region src/hono/types.d.ts
+/**
+ * Hono middleware handler signature used by the RPC middleware.
+ */
+interface HonoMiddlewareHooks {
+  /** Hono middleware handler */
+  handler: MiddlewareHandler;
+}
+//#endregion
+//#region src/fastify/types.d.ts
+/**
+ * Fastify middleware handler signature used by the RPC middleware.
+ */
+interface FastifyMiddlewareHooks {
+  /**
+   * The handler invoked for each matched request.
+   * @param req - Fastify request object
+   * @param res - Fastify reply object
+   * @param done - Fastify hook completion callback
+   */
+  handler: (req: FastifyRequest, res: FastifyReply, done: HookHandlerDoneFunction) => Promise<void>;
+}
+//#endregion
+//#region src/koa/types.d.ts
+/**
+ * Koa middleware handler signature used by the RPC middleware.
+ */
+interface KoaMiddlewareHooks {
+  /**
+   * The handler invoked for each matched request.
+   * @param ctx - Koa context object
+   * @param next - Koa next function
+   */
+  handler: (ctx: Context, next: Next) => Promise<void>;
+}
+//#endregion
+//#region src/h3/types.d.ts
+/**
+ * h3 middleware handler signature used by the RPC middleware.
+ */
+interface H3MiddlewareHooks {
+  /**
+   * The handler invoked for each matched request.
+   * @param event - h3 event object
+   * @param next - h3 next function
+   */
+  handler: Middleware;
+}
+//#endregion
 //#region src/types.d.ts
+/**
+ * Maps each supported framework adapter to its middleware hooks (handler signatures).
+ * Used to keep the middleware options type-safe per adapter.
+ */
+interface FrameworkHooks {
+  /** Express/Connect middleware handler signature */
+  express: ExpressMiddlewareHooks;
+  /** Hono middleware handler signature */
+  hono: HonoMiddlewareHooks;
+  /** Fastify middleware handler signature */
+  fastify: FastifyMiddlewareHooks;
+  /** Koa middleware handler signature */
+  koa: KoaMiddlewareHooks;
+  /** h3 middleware handler signature */
+  h3: H3MiddlewareHooks;
+}
 /**
  * Content types the RPC client modules send with each request.
  */
@@ -40,6 +120,11 @@ interface ServerFunctionOptions {
    * @default "POST"
    */
   method?: "GET" | "POST";
+  /**
+   * RPC endpoint prefix
+   * @default "__rpc"
+   */
+  rpcPrefix?: string;
 }
 // primitives and their compositions
 /**
@@ -98,12 +183,14 @@ interface RpcPluginOptionsInternal {
 /**
  * Partial Vite config used when scanning server files outside a running dev server.
  */
-type ScanConfig = Pick<ResolvedConfig, "base"> & {
+interface ScanConfig extends Pick<ResolvedConfig, "base"> {
   root?: string;
   server?: Partial<ResolvedConfig["server"]>;
   serverFiles?: "exact" | "glob";
   scanRoot?: string;
-};
+  /** Default rpcPrefix to register scanned functions under when a function does not declare its own. Defaults to `__rpc` for backward compatibility. */
+  rpcPrefix?: string;
+}
 /**
  * Entry in the server functions map: registered name, client handler,
  * optional per-function options, and the original export name.
@@ -158,8 +245,91 @@ interface RpcPluginOptions {
    */
   serverFiles?: "exact" | "glob";
 }
+interface MiddlewareOptions<A extends RpcPluginOptions["adapter"] = "express"> {
+  /**
+   * Name for the middleware (used for identification in Express stack)
+   */
+  name?: string;
+  /**
+   * Path pattern to match for middleware execution.
+   * Accepts string or RegExp to filter requests based on URL path.
+   *
+   * @example
+   * // String path
+   * path: "/api/v1"
+   *
+   * // RegExp pattern
+   * path: /^\/api\/v[0-9]+/
+   */
+  path?: string | RegExp;
+  /**
+   * RPC prefix without leading slash (e.g. "__rpc")
+   * Leading slash will be added automatically by the middleware.
+   * This prefix defines the base path for all RPC endpoints.
+   * @default string
+   * @example
+   * // Results in endpoints like: /api/rpc/myFunction
+   * rpcPrefix: "api/rpc"
+   */
+  rpcPrefix?: string | false;
+  /**
+   * Allowed request origin (e.g. "https://example.com").
+   * When set, any request carrying an `Origin` header that does not match
+   * is rejected with a 403 Forbidden response. Requests without an `Origin`
+   * header (curl, native clients) pass through unchecked.
+   * When unset (default), no origin validation is performed.
+   */
+  origin?: string;
+  /**
+   * Server file matching mode. Use `"exact"` for `server.ts|js|mjs|mts`
+   * names, or `"glob"` to match `**\/*.server.{ts,js,mjs,mts}` inside the
+   * scan root. Only used for the lazy production scan when the middleware
+   * populates its prefix map on first request.
+   * @default "exact"
+   */
+  serverFiles?: "exact" | "glob";
+  /**
+   * Root directory for scanning server files. Defaults to `<root>/src/api`.
+   * Only used for the lazy production scan.
+   */
+  scanRoot?: string;
+  /**
+   * Async handler for request processing.
+   * Core middleware function that processes incoming requests.
+   *
+   * @param req - The incoming request object
+   * @param res - The server response object
+   * @param next - Function to pass control to the next middleware
+   *
+   * @example
+   * handler: async (req, res, next) => {
+   *   // Process request
+   *   const data = await processRequest(req);
+   *
+   *   // Send response
+   *   sendResponse(res, { data }, 200);
+   * }
+   */
+  handler?: FrameworkHooks[A]["handler"];
+}
 //#endregion
 //#region src/functionsMap.d.ts
+/**
+ * Map of rpcPrefix -> Map of function names -> ServerFnEntry
+ * Enables multiple RPC instances with different prefixes to coexist
+ * without name collisions.
+ */
+declare const serverFunctionsByPrefix: Map<string, Map<string, ServerFnEntry>>;
+/**
+ * Gets or creates the function map for a specific prefix.
+ * @param prefix - The RPC prefix (e.g., "__rpc", "v1:rpc", "admin:rpc")
+ * @returns Map of function names to ServerFnEntry for that prefix
+ */
+declare const getFunctionsForPrefix: (prefix: string) => Map<string, ServerFnEntry>;
+/**
+ * Backward compatibility: default map for the default prefix.
+ * Legacy code can still use serverFunctionsMap.set(name, entry).
+ */
 declare const serverFunctionsMap: Map<string, ServerFnEntry>;
 //#endregion
 //#region src/scanForServerFiles.d.ts
@@ -167,7 +337,7 @@ declare const serverFunctionsMap: Map<string, ServerFnEntry>;
 declare const scannedServerFiles: Set<string>;
 /**
  * Scans `src/api/` (or an explicit `scanRoot`) for server function files
- * and populates the global `serverFunctionsMap` with their exported functions.
+ * and populates the server functions map (scoped by rpcPrefix) with their exported functions.
  * Uses Vite's SSR module loading to resolve and execute each file.
  *
  * Supports two matching modes via `config.serverFiles`:
@@ -179,22 +349,49 @@ declare const scannedServerFiles: Set<string>;
 declare const scanForServerFiles: (initialCfg?: ScanConfig, devServer?: ViteDevServer) => Promise<void>;
 //#endregion
 //#region src/createFunction.d.ts
+/**
+ * Extended options for createServerFunction, including rpcPrefix for multi-instance support.
+ */
+interface CreateServerFunctionOptions extends Partial<ServerFunctionOptions> {
+  /**
+   * RPC prefix for this function. Enables multiple RPC instances with different prefixes.
+   * When using multi-prefix setup, functions with the same name but different prefixes
+   * can coexist without collision.
+   * @default "__rpc"
+   * @example
+   * // v1 API
+   * export const login = createServerFunction(
+   *   "login",
+   *   async (signal, email, password) => ({...}),
+   *   { rpcPrefix: "v1:rpc" },
+   * );
+   *
+   * // v2 API - same function name, different prefix
+   * export const login = createServerFunction(
+   *   "login",
+   *   async (signal, credentials) => ({...}),
+   *   { rpcPrefix: "v2:rpc" },
+   * );
+   */
+  rpcPrefix?: string;
+}
 /**
  * Creates a server-side RPC function.
- * Registers the function in the server functions map and returns a client-compatible
- * wrapper that exposes `data` (Promise) and `cancel` (function) for request lifecycle control.
+ * Registers the function in the server functions map (scoped by rpcPrefix) and returns
+ * a client-compatible wrapper that exposes `data` (Promise) and `cancel` (function)
+ * for request lifecycle control.
  * @param name - Unique identifier used by the RPC router to dispatch requests
  * @param handler - The actual implementation receiving an AbortSignal followed by JSON-serializable arguments
- * @param fnOptions - Optional contentType and credentials settings
+ * @param fnOptions - Optional contentType, credentials, and rpcPrefix settings
  * @returns A client stub with `data` promise and `cancel` method, auto-registered in the server map
  */
-declare function createServerFunction<TArgs extends JsonArray = JsonArray, TResult extends JsonValue = JsonValue>(name: string, handler: ServerFunctionInit<TArgs, TResult>, fnOptions?: Partial<ServerFunctionOptions>): ClientFunction<TArgs, TResult>;
+declare function createServerFunction<TArgs extends JsonArray = JsonArray, TResult extends JsonValue = JsonValue>(name: string, handler: ServerFunctionInit<TArgs, TResult>, fnOptions?: CreateServerFunctionOptions): ClientFunction<TArgs, TResult>;
 //#endregion
 //#region src/getClientModules.d.ts
 /**
  * Generates the complete client-side module bundle by iterating all registered server functions
- * and producing fetch-based stubs for each. The result is transformed by Vite (or Oxc) during
- * the dev server or production build.
+ * for a specific prefix and producing fetch-based stubs for each. The result is transformed by Vite
+ * (or Oxc) during the dev server or production build.
  * @param initialOptions - Plugin options containing rpcPrefix and optional adapter
  * @returns A string of JavaScript code with all client RPC modules and their import dependencies
  */
@@ -253,9 +450,25 @@ declare const hasContentTypeMismatch: (declared: ContentType, rawHeader: string
  * @returns The escaped string safe for use in new RegExp()
  */
 declare function escapeRegExp(s: string): string;
+/**
+ * Parses a raw request URL against a fixed base without ever throwing.
+ * Malformed request-targets (e.g. `/\`, `//`, `/\/`) make the WHATWG URL
+ * parser throw `TypeError: Invalid URL`; the adapters call this while
+ * building the per-request URL **before** their dispatch `try` block, so an
+ * unhandled rejection there crashes raw `node:http` hosts (and Express 4).
+ * On failure we fall back to the base root: the resulting pathname never
+ * matches the RPC prefix, so the request is treated as non-RPC and falls
+ * through to `next()` / 404 instead of crashing the process.
+ * @param rawUrl - Raw request URL (path + optional query string)
+ * @param base - Optional base URL, defaults to a fixed localhost origin
+ * @returns A URL object; never throws
+ */
+declare const safeURL: (rawUrl: string, base?: string) => URL;
+/** Global rpcPrefix from the last loaded config / middleware — fallback for functions without explicit prefix. */
+declare const getGlobalPrefix: () => string | undefined;
+declare const setGlobalPrefix: (prefix: string | undefined) => void;
 //#endregion
 //#region src/context.d.ts
-/** @module Server-side request context. Exports the `RequestEvent` shape, `provideRequestContext` to establish it around a dispatch, `getRequestContext` to read it from anywhere inside the async tree, and `redirect` for framework-level redirects. Never import this module in client code — it is server-only. */
 /**
  * A per-request context established by the framework adapters around
  * server-function dispatch, mirroring Solid Start's `FetchEvent`. Any code
@@ -293,6 +506,30 @@ interface RequestEvent {
     location: string;
     status: number;
   };
+  /**
+   * Bound adapter-native response short-circuit. Writes the given status and
+   * JSON body (plus optional headers) directly, bypassing the standard
+   * `{ data }` response. Setting `sent` makes the middleware skip the JSON
+   * `{ data }` send, mirroring `redirect`/`redirected`.
+   * @param status - HTTP status code (e.g. 401, 413, 429)
+   * @param body - JSON-serializable response body
+   * @param headers - Optional response headers (e.g. `{ "Retry-After": "60" }`)
+   */
+  send: (status: number, body: JsonValue, headers?: Record<string, string>) => void;
+  /**
+   * Set by `send` once a response has been issued. The middleware checks this
+   * after `await`ing the server function to avoid double-responding.
+   */
+  sent?: {
+    status: number;
+    body: JsonValue;
+    headers?: Record<string, string>;
+  };
+  /**
+   * The matched RPC function name for the current request, when available.
+   * Useful for per-function rate limiting or auditing inside middleware.
+   */
+  functionName?: string;
   /** Per-request app data shared across the async tree of the dispatch */
   locals: Record<string, unknown>;
   [prop: string]: unknown;
@@ -320,19 +557,57 @@ declare const getRequestContext: () => RequestEvent;
  * @throws When called outside of a request
  */
 declare const redirect: (location: string, status?: number) => void;
+/**
+ * Sends a raw JSON response for the current request, bypassing the standard
+ * `{ data }` shape. Reads the adapter-bound `send` from the current request
+ * context — callable from anywhere inside a server-function tree. Any code in
+ * the async tree of a dispatch can call this (e.g. custom middleware) to
+ * short-circuit with a specific status code (401, 413, 429, ...).
+ * @param status - HTTP status code
+ * @param body - JSON-serializable response body
+ * @param headers - Optional response headers
+ * @throws When called outside of a request
+ */
+declare const sendResponse: (status: number, body: JsonValue, headers?: Record<string, string>) => void;
+/**
+ * Normalized, adapter-agnostic view of the current request. Reads the request
+ * object off the current request context and normalizes it across the five
+ * adapter request shapes (Express `req`, Fastify `req`, Koa `ctx.req`,
+ * Hono `c.req`, h3 `event.req`) so middleware can be written once.
+ */
+interface RequestMeta {
+  /** HTTP method, upper-cased (e.g. "GET", "POST") */
+  method: string;
+  /** URL pathname (e.g. "/__rpc/greet") */
+  pathname: string;
+  /** Raw search string including the leading "?", or "" when absent */
+  search: string;
+  /** Parsed search params */
+  searchParams: URLSearchParams;
+  /** Request headers, lower-cased */
+  headers: Record<string, string | string[] | undefined>;
+  /** Host header value (e.g. "localhost:5173"), when present */
+  host?: string;
+  /** Client IP when the framework exposes it (e.g. Fastify `req.ip`) */
+  ip?: string;
+  /** Request protocol ("http" or "https"), when determinable */
+  protocol?: string;
+}
+/**
+ * Reads normalized, adapter-agnostic request metadata from the current request
+ * context. Works with Express `req`, Fastify `req`, Koa `ctx.req`,
+ * Hono `c.req` and h3 `event.req` by feature-detecting the request shape
+ * (`originalUrl`/`url`/`path`, raw `headers` map vs `Headers`-like API).
+ * @param event - The request context to read, typically the result of
+ *   {@link getRequestContext}
+ */
+declare const getRequestMeta: (event: RequestEvent) => RequestMeta;
 //#endregion
 //#region src/options.d.ts
-declare const defaultServerFnOptions: {
-  contentType: "application/json";
-  credentials: "same-origin";
-  method: "POST";
-};
+declare const defaultServerFnOptions: ServerFunctionOptions;
+declare const defaultPrefix = "__rpc";
 declare const defaultRPCOptions: RpcPluginOptions;
-declare const defaultMiddlewareOptions: {
-  rpcPrefix: undefined;
-  path: undefined;
-  origin: undefined;
-};
+declare const defaultMiddlewareOptions: MiddlewareOptions;
 //#endregion
-export { RPCError, RequestEvent, createServerFunction, defaultMiddlewareOptions, defaultRPCOptions, defaultServerFnOptions, escapeRegExp, formatError, getClientModules, getRequestContext, hasContentTypeMismatch, isFormContentType, provideRequestContext, redirect, scanForServerFiles, scannedServerFiles, serverFunctionsMap, walkGlobFiles };
+export { CreateServerFunctionOptions, RPCError, RequestEvent, RequestMeta, createServerFunction, defaultMiddlewareOptions, defaultPrefix, defaultRPCOptions, defaultServerFnOptions, escapeRegExp, formatError, getClientModules, getFunctionsForPrefix, getGlobalPrefix, getRequestContext, getRequestMeta, hasContentTypeMismatch, isFormContentType, provideRequestContext, redirect, safeURL, scanForServerFiles, scannedServerFiles, sendResponse, serverFunctionsByPrefix, serverFunctionsMap, setGlobalPrefix, walkGlobFiles };
 //# sourceMappingURL=server.d.mts.map

package/dist/server/server.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.mts","names":[],"sources":["../../src/types.d.ts","../../src/functionsMap.ts","../../src/scanForServerFiles.ts","../../src/createFunction.ts","../../src/getClientModules.ts","../../src/server-helpers.ts","../../src/context.ts","../../src/options.ts"],"mappings":";;;;;;;;;;;;;;;KAkEY;;;;KASA;;;;;UAkBK;;;;;EAKf,aAAa;;;;;EAKb,cAAc;;;;;;;EAOd;;;;;;KAOU;;;;KAIA;GAAgB,cAAc,YAAY;;;;;KAI1C,aAAa,WAAW;;;;KAIxB,YAAY,gBAAgB,YAAY;;;;;KAsCxC,mBACV,cAAc,WAAW,YAAY,WACrC,gBAAgB,YAAY,cACzB,QAAQ,gBAAgB,MAAM,UAAU,QAAQ;;;;;;KAOzC,eACV,cAAc,YAAY,WAC1B,gBAAgB,YAAY,iBACtB,MAAM;;EAEZ,MAAM,QAAQ;;EAEd,SAAS;;;;;;KAOC,4BAA4B;;EAEtC;;EAEA,UAAU;;;;;UAMK;;EAEf;;EAEA;;;;;KAMU,aAAa,KAAK;EAC5B;EACA,SAAS,QAAQ;EACjB;EACA;;;;;;UAOe;;EAEf;;EAEA,SAAS;;EAET,UAAU;;EAEV;;;;;;;;UASe;;;;;;;;;;;EAWf;;;;;;;EAQA;;;;;;;EAQA;;;;;;;EAQA;;;;cChRW,oBAAoB,YAAY;;;;cCehC,oBAAoB;;;;;;;;;;;;cAepB,qBAAkB,aAChB,YAAU,YACX,kBACX;;;;;;;;;;;;iBCda,qBACd,cAAc,YAAY,WAC1B,gBAAgB,YAAY,WAE5B,cACA,SAAS,mBAAmB,OAAO,UACnC,YAAW,QAAQ,yBAClB,eAAe,OAAO;;;;;;;;;;cCgEZ,mBAAgB,gBACX;;;;;;;cChFL,gBAAa,gBAAwB;;;;;;cA4BrC,iBAAiB;;EAE5B;;EAEA,OAAO;EACP,YAAY,iBAAiB,eAAmB,OAAO;;;;;;;;;;cAgB5C,cAAW,cACV,0BAEX;;;;;;;cAqBU,oBAAiB;;;;;;;;;;;cAcjB,yBAAsB,UACvB,aAAW;;;;;;;;iBAqBP,aAAa;;;;;;;;;;;;;;;;;;;UC9FZ;;EAEf;;EAEA;;EAEA;;;;;;;EAOA,WAAW,kBAAkB;;;;;EAK7B;IAAe;IAAkB;;;EAEjC,QAAQ;GACP;;;;;;;;;cAiBU,wBAAyB,GAAC,MAC/B,cAAY,UACR,MACT;;;;;;cAOU,yBAAwB;;;;;;;;;cAgBxB,WAAQ,kBAAoB;;;cCtF5B;;;;;cAMA,mBAAmB;cAOnB"}
+{"version":3,"file":"server.d.mts","names":[],"sources":["../../src/express/types.d.ts","../../src/hono/types.d.ts","../../src/fastify/types.d.ts","../../src/koa/types.d.ts","../../src/h3/types.d.ts","../../src/types.d.ts","../../src/functionsMap.ts","../../src/scanForServerFiles.ts","../../src/createFunction.ts","../../src/getClientModules.ts","../../src/server-helpers.ts","../../src/context.ts","../../src/options.ts"],"mappings":"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"}