@thednp/rpc 0.0.1

package/dist/hono/hono.mjs

@@ -0,0 +1,153 @@
+import { scanForServerFiles, serverFunctionsMap } from "@thednp/rpc/server";
+//#region node_modules/.pnpm/hono@4.12.32/node_modules/hono/dist/helper/factory/index.js
+var createMiddleware$1 = (middleware) => middleware;
+//#endregion
+//#region src/options.ts
+const defaultRPCOptions = {
+	rpcPreffix: "__rpc",
+	adapter: "express"
+};
+const defaultMiddlewareOptions = {
+	rpcPreffix: void 0,
+	path: void 0
+};
+//#endregion
+//#region src/tools.ts
+function escapeRegExp(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/hono/helpers.ts
+async function attachRPC(app) {
+	const { loadRPCConfig } = await import("@thednp/rpc");
+	const { adapter: _adapter, ...options } = await loadRPCConfig();
+	app.use(createRPCMiddleware(options));
+}
+function attachVite(app, vite) {
+	app.use(viteMiddleware(vite));
+}
+/**
+* Creates a hono compatible middleware for a given vite development server.
+* @see https://github.com/honojs/hono/issues/3162#issuecomment-2331118049
+* @param vite the vite development server
+*/
+const viteMiddleware = (vite) => {
+	return createMiddleware$1((c, next) => {
+		return new Promise((resolve) => {
+			if (typeof Bun === "undefined") {
+				vite.middlewares(c.env.incoming, c.env.outgoing, () => resolve(next()));
+				return;
+			}
+			{
+				let sent = false;
+				const headers = new Headers();
+				vite.middlewares({
+					url: new URL(c.req.path, "http://localhost").pathname,
+					method: c.req.raw.method,
+					headers: Object.fromEntries(c.req.raw.headers)
+				}, {
+					setHeader(name, value) {
+						headers.set(name, value);
+						return this;
+					},
+					end(body) {
+						sent = true;
+						resolve(c.body(body, c.res.status, headers));
+					}
+				}, () => sent || resolve(next()));
+			}
+		});
+	});
+};
+const readBody = async (c) => {
+	const isJSON = (c.req.header("content-type")?.toLowerCase() || "").includes("json");
+	const incoming = c.env.incoming;
+	if (incoming?.body !== void 0) {
+		const reqBody = incoming.body;
+		return {
+			contentType: isJSON ? "application/json" : "text/plain",
+			data: isJSON ? reqBody : String(reqBody)
+		};
+	}
+	if (isJSON) return {
+		contentType: "application/json",
+		data: await c.req.json()
+	};
+	const text = await c.req.text();
+	return {
+		contentType: "text/plain",
+		data: String(text)
+	};
+};
+//#endregion
+//#region src/hono/createMiddleware.ts
+let middlewareCount = 0;
+const middlewareStack = /* @__PURE__ */ new Set();
+const createMiddleware = (initialOptions = {}) => {
+	const options = Object.assign({}, defaultMiddlewareOptions, initialOptions);
+	const middlewareName = options.name;
+	const rpcPreffix = options.rpcPreffix;
+	const path = options.path;
+	const handler = options.handler;
+	let name = middlewareName;
+	if (!name) {
+		name = "viteRPCMiddleware-" + middlewareCount;
+		middlewareCount += 1;
+	}
+	if (middlewareStack.has(name)) throw new Error(`The middleware name "${name}" is already used.`);
+	middlewareStack.add(name);
+	const prefixRegex = rpcPreffix ? new RegExp(`^/${escapeRegExp(rpcPreffix)}/`) : null;
+	const pathMatcher = path ? typeof path === "string" ? new RegExp(path) : path : null;
+	const middlewareHandler = createMiddleware$1(async (c, next) => {
+		const url = new URL(c.req.path, "http://localhost").pathname;
+		if (serverFunctionsMap.size === 0) await scanForServerFiles();
+		if (!handler) {
+			await next();
+			return;
+		}
+		if (pathMatcher && !pathMatcher.test(url)) {
+			await next();
+			return;
+		}
+		if (prefixRegex && !prefixRegex.test(url)) {
+			await next();
+			return;
+		}
+		return await handler(c, next);
+	});
+	Object.defineProperty(middlewareHandler, "name", { value: name });
+	return middlewareHandler;
+};
+const createRPCMiddleware = (initialOptions = {}) => {
+	const options = Object.assign({}, defaultMiddlewareOptions, { rpcPreffix: defaultRPCOptions.rpcPreffix }, initialOptions);
+	const rpcPreffix = options.rpcPreffix;
+	const prefixRegex = rpcPreffix ? new RegExp(`^/${escapeRegExp(rpcPreffix)}/`) : null;
+	const prefixReplace = `/${rpcPreffix}/`;
+	return createMiddleware({
+		...options,
+		handler: async (c, _next) => {
+			const { path: reqPath } = c.req;
+			if (prefixRegex && !prefixRegex.test(reqPath)) return;
+			const functionName = reqPath.replace(prefixReplace, "");
+			const serverFunction = serverFunctionsMap.get(functionName);
+			if (!serverFunction) return c.json({ error: "Function not found" }, 404);
+			try {
+				const body = await readBody(c);
+				const args = Array.isArray(body.data) ? body.data : [body.data];
+				const fnResult = serverFunction.handler(...args);
+				const onAbort = () => fnResult.cancel("client disconnected");
+				c.env.incoming.on("close", onAbort);
+				const result = await fnResult.data;
+				c.env.incoming.off("close", onAbort);
+				return c.json({ data: result }, 200);
+			} catch (err) {
+				console.error(String(err));
+				return c.json({ error: "Internal Server Error" }, 500);
+			}
+		}
+	});
+};
+//#endregion
+export { attachRPC, attachVite, createMiddleware, createRPCMiddleware, readBody, viteMiddleware };
+
+//# sourceMappingURL=hono.mjs.map

package/dist/hono/hono.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono.mjs","names":["createMiddleware","createMiddleware","createHonoMiddleware"],"sources":["../../node_modules/.pnpm/hono@4.12.32/node_modules/hono/dist/helper/factory/index.js","../../src/options.ts","../../src/tools.ts","../../src/hono/helpers.ts","../../src/hono/createMiddleware.ts"],"sourcesContent":["// src/helper/factory/index.ts\nimport { Hono } from \"../../hono.js\";\nvar Factory = class {\n  initApp;\n  #defaultAppOptions;\n  constructor(init) {\n    this.initApp = init?.initApp;\n    this.#defaultAppOptions = init?.defaultAppOptions;\n  }\n  createApp = (options) => {\n    const app = new Hono(\n      options && this.#defaultAppOptions ? { ...this.#defaultAppOptions, ...options } : options ?? this.#defaultAppOptions\n    );\n    if (this.initApp) {\n      this.initApp(app);\n    }\n    return app;\n  };\n  createMiddleware = (middleware) => middleware;\n  createHandlers = (...handlers) => {\n    return handlers.filter((handler) => handler !== void 0);\n  };\n};\nvar createFactory = (init) => new Factory(init);\nvar createMiddleware = (middleware) => middleware;\nexport {\n  Factory,\n  createFactory,\n  createMiddleware\n};\n","import type {\n  MiddlewareOptions,\n  RpcPluginOptions,\n  ServerFunctionOptions,\n} from \"./types.d.ts\";\n\nexport const defaultServerFnOptions = {\n  contentType: \"application/json\",\n} satisfies ServerFunctionOptions;\n\nexport const defaultRPCOptions: RpcPluginOptions = {\n  rpcPreffix: \"__rpc\",\n  adapter: \"express\",\n};\n\nexport const defaultMiddlewareOptions = {\n  rpcPreffix: undefined,\n  path: undefined,\n} satisfies MiddlewareOptions;\n","export function escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n","// src/hono/helpers.ts\nimport type { IncomingMessage, ServerResponse } from \"node:http\";\nimport { type HttpBindings } from \"@hono/node-server\";\nimport type { Context, Hono } from \"hono\";\nimport { createMiddleware } from \"hono/factory\";\nimport { type ViteDevServer } from \"vite\";\nimport type { ContentfulStatusCode } from \"hono/utils/http-status\";\nimport { createRPCMiddleware } from \"./createMiddleware.ts\";\nimport type { BodyResult } from \"../types.d.ts\";\n\nexport async function attachRPC(app: Hono) {\n  const { loadRPCConfig } = await import(\"@thednp/rpc\");\n  const { adapter: _adapter, ...options } = await loadRPCConfig();\n\n  app.use(createRPCMiddleware(options));\n}\n\nexport function attachVite(app: Hono, vite: ViteDevServer): void {\n  app.use(viteMiddleware(vite));\n}\n\n/**\n * Creates a hono compatible middleware for a given vite development server.\n * @see https://github.com/honojs/hono/issues/3162#issuecomment-2331118049\n * @param vite the vite development server\n */\nexport const viteMiddleware = (vite: ViteDevServer) => {\n  return createMiddleware<{ Bindings: HttpBindings }>((c, next) => {\n    return new Promise((resolve) => {\n      // Node.js\n      // @ts-expect-error - NodeJS is different\n      // istanbul ignore if\n      if (typeof Bun === \"undefined\") {\n        vite.middlewares(c.env.incoming, c.env.outgoing, () => resolve(next()));\n        return;\n      }\n\n      /* istanbul ignore next */ {\n        // Bun\n        let sent = false;\n        const headers = new Headers();\n        // Polyfill the node:http IncommingMessage and ServerResponse\n        vite.middlewares(\n          {\n            url: new URL(c.req.path, \"http://localhost\").pathname,\n            method: c.req.raw.method,\n            headers: Object.fromEntries(c.req.raw.headers),\n          } as IncomingMessage,\n          {\n            setHeader(name, value: string) {\n              headers.set(name, value);\n              return this;\n            },\n            end(body) {\n              sent = true;\n              resolve(\n                // @ts-expect-error - weird\n                c.body(body, c.res.status as ContentfulStatusCode, headers),\n              );\n            },\n          } as ServerResponse,\n          () => sent || resolve(next()),\n        );\n      }\n    });\n  });\n};\n\nexport const readBody = async (\n  c: Context,\n): Promise<BodyResult> => {\n  const contentType = c.req.header(\"content-type\")?.toLowerCase() || \"\";\n  const isJSON = contentType.includes(\"json\");\n  type IncomingWithBody = IncomingMessage & { body?: unknown };\n  const incoming = (c.env as HttpBindings).incoming as\n    | IncomingWithBody\n    | undefined;\n  if (incoming?.body !== undefined) {\n    const reqBody = incoming.body;\n    return {\n      contentType: isJSON ? \"application/json\" : \"text/plain\",\n      data: isJSON ? reqBody : String(reqBody),\n    } as BodyResult;\n  }\n  if (isJSON) {\n    const data = await c.req.json();\n    return {\n      contentType: \"application/json\",\n      data,\n    };\n  }\n\n  const text = await c.req.text();\n  return { contentType: \"text/plain\", data: String(text) };\n};\n","// src/hono/createMiddleware.ts\nimport type { Context, Next } from \"hono\";\n// import type { JsonArray, JsonValue } from \"@thednp/rpc\";\nimport type { HonoMiddlewareFn, HonoMiddlewareOptions } from \"./types.d.ts\";\nimport { createMiddleware as createHonoMiddleware } from \"hono/factory\";\nimport { scanForServerFiles, serverFunctionsMap } from \"@thednp/rpc/server\";\nimport { defaultMiddlewareOptions, defaultRPCOptions } from \"../options.ts\";\nimport { escapeRegExp } from \"../tools.ts\";\nimport { readBody } from \"./helpers.ts\";\n\nlet middlewareCount = 0;\nconst middlewareStack = new Set<string>();\n\nexport const createMiddleware: HonoMiddlewareFn = (initialOptions = {}) => {\n  const options = Object.assign(\n    {},\n    defaultMiddlewareOptions,\n    initialOptions,\n  ) as HonoMiddlewareOptions;\n\n  const middlewareName = options.name;\n  const rpcPreffix = options.rpcPreffix;\n  const path = options.path;\n  const handler = options.handler;\n\n  let name = middlewareName;\n  if (!name) {\n    name = \"viteRPCMiddleware-\" + middlewareCount;\n    middlewareCount += 1;\n  }\n  if (middlewareStack.has(name)) {\n    throw new Error(`The middleware name \"${name}\" is already used.`);\n  }\n  middlewareStack.add(name);\n\n  // Hoist regex compilation out of per-request path. Escape the prefix to\n  // prevent regex injection via metacharacters in the config string.\n  const prefixRegex: RegExp | null = rpcPreffix\n    ? new RegExp(`^/${escapeRegExp(rpcPreffix)}/`)\n    : null;\n  const pathMatcher: RegExp | null = path\n    ? (typeof path === \"string\" ? new RegExp(path) : path)\n    : null;\n\n  const middlewareHandler = createHonoMiddleware(\n    async (c: Context, next: Next) => {\n      const reqUrl = new URL(c.req.path, \"http://localhost\");\n      const url = reqUrl.pathname;\n\n      if (serverFunctionsMap.size === 0) {\n        await scanForServerFiles();\n      }\n\n      // No need to continue when no handler provided\n      if (!handler) {\n        await next();\n        return;\n      }\n\n      if (pathMatcher && !pathMatcher.test(url)) {\n        await next();\n        return;\n      }\n\n      if (prefixRegex && !prefixRegex.test(url)) {\n        await next();\n        return;\n      }\n\n      return await handler(c, next);\n    },\n  );\n\n  Object.defineProperty(middlewareHandler, \"name\", {\n    value: name,\n  });\n\n  return middlewareHandler;\n};\n\nexport const createRPCMiddleware: HonoMiddlewareFn = (initialOptions = {}) => {\n  const options = Object.assign(\n    {},\n    defaultMiddlewareOptions,\n    { rpcPreffix: defaultRPCOptions.rpcPreffix },\n    initialOptions,\n  ) as HonoMiddlewareOptions;\n\n  // Hoist prefix regex (escaped) and the literal prefix-for-replace out of the\n  // per-request handler to avoid regex injection and per-request compilation.\n  const rpcPreffix = options.rpcPreffix;\n  const prefixRegex = rpcPreffix\n    ? new RegExp(`^/${escapeRegExp(rpcPreffix)}/`)\n    : /* istanbul ignore next */ null;\n  const prefixReplace = `/${rpcPreffix}/`;\n\n  return createMiddleware({\n    ...options,\n    handler: async (c: Context, _next: Next) => {\n      const { path: reqPath } = c.req;\n      // const { rpcPreffix: prefix } = options;\n\n      // Defense-in-depth: validate prefix match via escaped regex even though\n      // the outer createMiddleware gates on the same prefix already.\n      // istanbul ignore if\n      if (prefixRegex && !prefixRegex.test(reqPath)) {\n        /* istanbul ignore next */\n        return;\n      }\n\n      const functionName = reqPath.replace(prefixReplace, \"\");\n      const serverFunction = serverFunctionsMap.get(functionName);\n\n      if (!serverFunction) {\n        return c.json({ error: \"Function not found\" }, 404);\n      }\n\n      try {\n        const body = await readBody(c);\n        const args = Array.isArray(body.data) ? body.data : [body.data];\n        const fnResult = serverFunction.handler(...args);\n        const onAbort = () => fnResult.cancel(\"client disconnected\");\n        c.env.incoming.on(\"close\", onAbort);\n        const result = await fnResult.data;\n        c.env.incoming.off(\"close\", onAbort);\n\n        return c.json({ data: result }, 200);\n      } catch (err) {\n        console.error(String(err));\n        return c.json({ error: \"Internal Server Error\" }, 500);\n      }\n    },\n  });\n};\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/index.d.mts

@@ -0,0 +1,192 @@
+import { Connect, Plugin } from "vite";
+import { MiddlewareOptions as MiddlewareOptions$1, RpcPluginOptions as RpcPluginOptions$1 } from "@thednp/rpc";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { NextFunction, Request, Response as Response$1 } from "express";
+import { MiddlewareHandler } from "hono";
+import "@hono/node-server";
+import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from "fastify";
+import { Context, Next } from "koa";
+//#region src/express/types.d.ts
+type ExpressMiddlewareOptions = MiddlewareOptions$1<"express">;
+type ExpressMiddlewareFn = <A extends RpcPluginOptions$1["adapter"] = "express">(initialOptions?: Partial<ExpressMiddlewareOptions>) => ExpressMiddlewareHooks["handler"];
+interface ExpressMiddlewareHooks {
+  handler: (req: IncomingMessage | Request, res: ServerResponse | Response$1, next: Connect.NextFunction | NextFunction) => Promise<void>;
+}
+//#endregion
+//#region src/hono/types.d.ts
+interface HonoMiddlewareHooks {
+  handler: MiddlewareHandler;
+}
+type HonoMiddlewareFn = <A extends RpcPluginOptions$1["adapter"] = "hono">(initialOptions?: Partial<MiddlewareOptions$1<A>>) => HonoMiddlewareHooks["handler"];
+//#endregion
+//#region src/fastify/types.d.ts
+type FastifyMiddlewareOptions = MiddlewareOptions$1<"fastify">;
+type FastifyMiddlewareFn = <A extends RpcPluginOptions$1["adapter"] = "fastify">(initialOptions?: Partial<FastifyMiddlewareOptions>) => FastifyMiddlewareHooks["handler"];
+interface FastifyMiddlewareHooks {
+  handler: (req: FastifyRequest, res: FastifyReply, done: HookHandlerDoneFunction) => Promise<void>;
+}
+//#endregion
+//#region src/koa/types.d.ts
+type KoaMiddlewareOptions = MiddlewareOptions$1<"koa">;
+interface KoaMiddlewareHooks {
+  handler: (ctx: Context, next: Next) => Promise<void>;
+}
+type KoaMiddlewareFn = <A extends RpcPluginOptions$1["adapter"] = "koa">(initialOptions?: Partial<KoaMiddlewareOptions>) => KoaMiddlewareHooks["handler"];
+//#endregion
+//#region src/types.d.ts
+interface FrameworkHooks {
+  express: ExpressMiddlewareHooks;
+  hono: HonoMiddlewareHooks;
+  fastify: FastifyMiddlewareHooks;
+  koa: KoaMiddlewareHooks;
+}
+interface FrameworkMiddlewareFn {
+  express: ExpressMiddlewareFn;
+  hono: HonoMiddlewareFn;
+  fastify: FastifyMiddlewareFn;
+  koa: KoaMiddlewareFn;
+}
+type SupportableContentType = "multipart/form-data" | "application/json" | "text/plain" | "application/octet-stream";
+type ContentType = "application/json" | "text/plain";
+type BodyResult = {
+  contentType: "application/json";
+  data: JsonValue;
+} | {
+  contentType: "text/plain";
+  data: string;
+};
+interface ServerFunctionOptions {
+  contentType: ContentType;
+}
+// primitives and their compositions
+type JsonPrimitive = string | number | boolean | null | undefined;
+type JsonObject = {
+  [key: string]: JsonValue | JsonArray;
+};
+type JsonArray = JsonValue[];
+type JsonValue = JsonPrimitive | JsonArray | JsonObject;
+// Keep these as a refference
+// Date strings are common in APIs
+// export type ISODateString = string; // for dates in ISO format
+// Special types that might be useful
+// export type Base64String = string; // for binary data encoded as base64
+// export type URLString = string; // for URLs
+// export type EmailString = string; // for email addresses
+// export type RPCValue =
+//   | JsonValue
+//   | Date // will be serialized as ISOString
+//   | Uint8Array // will be serialized as base64
+//   | File // for file uploads
+//   | Blob // for binary data
+//   | URLSearchParams; // for query parameters
+// export type ServerFnArgs = [JsonObject | JsonPrimitive, ...JsonArray];
+type ServerFnArgs = [...JsonArray];
+type ServerFunction<TArgs extends JsonArray = JsonArray, TResult extends JsonValue = JsonValue> = (signal: AbortSignal, ...args: TArgs) => Promise<TResult>;
+type ServerFunctionInit<TArgs extends JsonArray = JsonArray, TResult extends JsonValue = JsonValue> = (signal: AbortSignal, ...args: TArgs) => Promise<TResult>;
+type ClientFunction<TArgs extends JsonArray = JsonArray, TResult extends JsonValue = JsonValue> = (...args: TArgs) => {
+  data: Promise<TResult>;
+  cancel: (reason: string) => void;
+};
+type ClientFunctionWithOptions = ClientFunction & {
+  name: string;
+  options?: ServerFunctionOptions;
+};
+interface ServerFnEntry {
+  name: string;
+  handler: ClientFunctionWithOptions;
+  options?: ServerFunctionOptions;
+  exportName?: string;
+}
+interface CacheEntry<T> {
+  data?: T;
+  timestamp: number;
+  promise?: Promise<T>;
+}
+/**
+ * ### @thednp/rpc
+ * The plugin configuration allows for granular control of your
+ * application RPC calls. The default settings are optimized for development
+ * environments while providing a secure foundation for production use.
+ */
+interface RpcPluginOptions {
+  // RPC Middleware Options
+  /**
+   * 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 "__rpc"
+   * @example
+   * // Results in endpoints like: /api/rpc/myFunction
+   * rpcPreffix: "api/rpc"
+   */
+  rpcPreffix: "__rpc" | string;
+  /**
+   * Option to set an adapter for the middleware connection. The default is _express_,
+   * which is the most popular and battle tested server app. The _express_ adapter is
+   * also compatible with the vite's Connect development server.
+   * @default express
+   */
+  adapter: "express" | "hono" | "fastify" | "koa";
+}
+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
+   * rpcPreffix: "api/rpc"
+   */
+  rpcPreffix?: string | false;
+  /**
+   * 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/index.d.ts
+/**
+ * Utility to define `@thednp/rpc` configuration file similar to vite.
+ * @param uniConfig a system wide RPC configuration
+ */
+declare const defineConfig: (uniConfig: Partial<RpcPluginOptions>) => RpcPluginOptions;
+/**
+ * Utility to load `@thednp/rpc` configuration file system wide.
+ * @param configFile an optional parameter to specify a file within your project scope
+ */
+declare function loadRPCConfig(configFile?: string): Promise<RpcPluginOptions>;
+declare function rpcPlugin(devOptions?: Partial<RpcPluginOptions>): Plugin<unknown>;
+//#endregion
+export { type BodyResult, type CacheEntry, type ClientFunction, type ClientFunctionWithOptions, type ContentType, type FrameworkHooks, type FrameworkMiddlewareFn, type JsonArray, type JsonObject, type JsonPrimitive, type JsonValue, type MiddlewareOptions, type RpcPluginOptions, type ServerFnArgs, type ServerFnEntry, type ServerFunction, type ServerFunctionInit, type ServerFunctionOptions, type SupportableContentType, rpcPlugin as default, defineConfig, loadRPCConfig };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.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/types.d.ts","../src/index.ts"],"mappings":";;;;;;;;;KAKY,2BAA2B;KAE3B,uBACV,UAAU,2CAEV,iBAAiB,QAAQ,8BACtB;UAEY;EACf,UACE,KAAK,kBAAkB,SACvB,KAAK,iBAAiB,YACtB,MAAM,QAAQ,eAAe,iBAC1B;;;;UCbU;EACf,SAAS;;KAGC,oBAAoB,UAAU,wCACxC,iBAAiB,QAAQ,oBAAkB,QACxC;;;KCJO,2BAA2B;KAE3B,uBACV,UAAU,2CAEV,iBAAiB,QAAQ,8BACtB;UAEY;EACf,UACE,KAAK,gBACL,KAAK,cACL,MAAM,4BACH;;;;KCZK,uBAAuB;UAMlB;EACf,UAAU,KAAK,SAAS,MAAM,SAAS;;KAG7B,mBAAmB,UAAU,uCACvC,iBAAiB,QAAQ,0BACtB;;;UCLY;EACf,SAAS;EACT,MAAM;EACN,SAAS;EACT,KAAK;;UAGU;EACf,SAAS;EACT,MAAM;EACN,SAAS;EACT,KAAK;;KAGK;KAMA;KAEA;EACN;EAAiC,MAAM;;EACvC;EAA2B;;UAEhB;EACf,aAAa;;;KAIH;KACA;GAAgB,cAAc,YAAY;;KAC1C,YAAY;KACZ,YAAY,gBAAgB,YAAY;;;;;;;;;;;;;;;;KAoBxC,mBAAmB;KAEnB,eACV,cAAc,YAAY,WAC1B,gBAAgB,YAAY,cACzB,QAAQ,gBAAgB,MAAM,UAAU,QAAQ;KAEzC,mBACV,cAAc,YAAY,WAC1B,gBAAgB,YAAY,cACzB,QAAQ,gBAAgB,MAAM,UAAU,QAAQ;KAEzC,eACV,cAAc,YAAY,WAC1B,gBAAgB,YAAY,iBACtB,MAAM;EACZ,MAAM,QAAQ;EACd,SAAS;;KAGC,4BAA4B;EACtC;EACA,UAAU;;UAGK;EACf;EACA,SAAS;EACT,UAAU;EACV;;UAGe,WAAW;EAC1B,OAAO;EACP;EACA,UAAU,QAAQ;;;;;;;;UASH;;;;;;;;;;;EAWf;;;;;;;EAQA;;UAGe,kBACf,UAAU;;;;EAKV;;;;;;;;;;;;EAaA,gBAAgB;;;;;;;;;;EAWhB;;;;;;;;;;;;;;;;;;EAmBA,UAAU,eAAe;;;;;;;;cC1JrB,eAAY,WAAe,QAAQ,sBACa;;;;;iBASvC,cAAc,sBAAmB,QAAA;iBA0FvC,UACP,aAAY,QAAQ,oBACnB"}

package/dist/index.mjs

@@ -0,0 +1,296 @@
+import { loadConfigFromFile, mergeConfig } from "vite";
+import { resolve } from "node:path";
+import process from "node:process";
+import { existsSync } from "node:fs";
+import { getClientModules, scanForServerFiles, serverFunctionsMap } from "@thednp/rpc/server";
+//#region src/options.ts
+const defaultRPCOptions = {
+	rpcPreffix: "__rpc",
+	adapter: "express"
+};
+const defaultMiddlewareOptions = {
+	rpcPreffix: void 0,
+	path: void 0
+};
+//#endregion
+//#region src/express/helpers.ts
+const readBody = (req) => {
+	return new Promise((resolve, reject) => {
+		if (hasPreParsedBody(req) && req.body !== void 0) {
+			const isJSON = (req.headers["content-type"]?.toLowerCase() || "").includes("json");
+			resolve({
+				contentType: isJSON ? "application/json" : "text/plain",
+				data: isJSON ? req.body : String(req.body)
+			});
+			return;
+		}
+		let body = "";
+		const toggleListeners = (add) => {
+			const method = add ? "on" : "off";
+			req[method]("data", onData);
+			req[method]("end", onEnd);
+			req[method]("error", onError);
+		};
+		const onData = (chunk) => {
+			body += chunk.toString();
+		};
+		const onEnd = () => {
+			toggleListeners();
+			const isJSON = (req.headers["content-type"]?.toLowerCase() || "").includes("json");
+			try {
+				const data = JSON.parse(body);
+				resolve({
+					contentType: isJSON ? "application/json" : "text/plain",
+					data
+				});
+			} catch (_e) {
+				resolve({
+					contentType: "text/plain",
+					data: String(body)
+				});
+			}
+		};
+		const onError = (err) => {
+			toggleListeners();
+			reject(err);
+		};
+		toggleListeners(true);
+	});
+};
+const isExpressRequest = (req) => {
+	return "originalUrl" in req;
+};
+const isExpressResponse = (res) => {
+	return "json" in res && "send" in res;
+};
+const hasPreParsedBody = (req) => {
+	return "body" in req;
+};
+const getRequestDetails = (request) => {
+	const rawUrl = isExpressRequest(request) ? request.originalUrl : request.url;
+	const url = new URL(rawUrl, "http://localhost");
+	return {
+		url: url.pathname,
+		search: url.search,
+		searchParams: url.searchParams,
+		headers: request.headers,
+		method: request.method
+	};
+};
+const getResponseDetails = (response) => {
+	const isResponseSent = response.headersSent || response.writableEnded;
+	const setHeader = (name, value) => {
+		if (isExpressResponse(response)) response.header(name, value);
+		else response.setHeader(name, value);
+	};
+	const setStatusCode = (code) => {
+		if (isExpressResponse(response)) response.status(code);
+		else response.statusCode = code;
+	};
+	const sendResponse = (code, output) => {
+		setStatusCode(code);
+		setHeader("Content-Type", "application/json");
+		if (isExpressResponse(response)) response.send(JSON.stringify(output));
+		else response.end(JSON.stringify(output));
+	};
+	return {
+		isResponseSent,
+		setHeader,
+		statusCode: response.statusCode,
+		setStatusCode,
+		sendResponse
+	};
+};
+//#endregion
+//#region src/tools.ts
+function escapeRegExp(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/express/createMiddleware.ts
+let middlewareCount = 0;
+const middlewareStack = /* @__PURE__ */ new Set();
+const createMiddleware = (initialOptions = {}) => {
+	const options = Object.assign({}, defaultMiddlewareOptions, initialOptions);
+	const middlewareName = options.name;
+	const rpcPreffix = options.rpcPreffix;
+	const path = options.path;
+	const handler = options.handler;
+	let name = middlewareName;
+	if (!name) {
+		name = "viteRPCMiddleware-" + middlewareCount;
+		middlewareCount += 1;
+	}
+	if (middlewareStack.has(name)) throw new Error(`The middleware name "${name}" is already used.`);
+	middlewareStack.add(name);
+	const prefixRegex = rpcPreffix ? new RegExp(`^/${escapeRegExp(rpcPreffix)}/`) : null;
+	const pathMatcher = path ? typeof path === "string" ? new RegExp(path) : path : null;
+	const middlewareHandler = async (req, _res, next) => {
+		const { url } = getRequestDetails(req);
+		if (serverFunctionsMap.size === 0) await scanForServerFiles();
+		if (!handler) return next?.();
+		if (pathMatcher && !pathMatcher.test(url)) return next?.();
+		if (prefixRegex && !prefixRegex.test(url)) return next?.();
+		await handler(req, _res, next);
+	};
+	Object.defineProperty(middlewareHandler, "name", { value: name });
+	return middlewareHandler;
+};
+const createRPCMiddleware = (initialOptions = {}) => {
+	const options = Object.assign({}, defaultMiddlewareOptions, { rpcPreffix: defaultRPCOptions.rpcPreffix }, initialOptions);
+	const rpcPreffix = options.rpcPreffix;
+	const prefixRegex = rpcPreffix ? new RegExp(`^/${escapeRegExp(rpcPreffix)}/`) : null;
+	const prefixReplace = `/${rpcPreffix}/`;
+	return createMiddleware({
+		...options,
+		handler: async (req, res, _next) => {
+			const { url } = getRequestDetails(req);
+			const { sendResponse } = getResponseDetails(res);
+			if (prefixRegex && !prefixRegex.test(url)) return;
+			const functionName = url.replace(prefixReplace, "");
+			const serverFunction = serverFunctionsMap.get(functionName);
+			if (!serverFunction) {
+				sendResponse(404, { error: "Function not found" });
+				return;
+			}
+			try {
+				const body = await readBody(req);
+				const args = Array.isArray(body.data) ? body.data : [body.data];
+				const { data, cancel } = serverFunction.handler(...args);
+				const onClose = () => cancel("client disconnected");
+				req.on("close", onClose);
+				const result = await data;
+				req.off("close", onClose);
+				if (!res.headersSent) sendResponse(200, { data: result });
+			} catch (err) {
+				console.error(String(err));
+				sendResponse(500, { error: "Internal Server Error" });
+			}
+		}
+	});
+};
+//#endregion
+//#region src/index.ts
+const loadConfigFile = async (env, file) => {
+	const result = await loadConfigFromFile(env, file);
+	return result ? {
+		...result,
+		config: {
+			...result.config,
+			configFile: file
+		}
+	} : null;
+};
+/**
+* Utility to define `@thednp/rpc` configuration file similar to vite.
+* @param uniConfig a system wide RPC configuration
+*/
+const defineConfig = (uniConfig) => {
+	return mergeConfig(defaultRPCOptions, uniConfig);
+};
+let RPCConfig;
+/**
+* Utility to load `@thednp/rpc` configuration file system wide.
+* @param configFile an optional parameter to specify a file within your project scope
+*/
+async function loadRPCConfig(configFile) {
+	try {
+		const env = {
+			command: "serve",
+			root: process.cwd(),
+			mode: process.env.NODE_ENV || "development"
+		};
+		const defaultConfigFiles = [
+			"rpc.config.ts",
+			"rpc.config.js",
+			"rpc.config.mjs",
+			"rpc.config.mts",
+			".rpcrc.ts",
+			".rpcrc.js"
+		];
+		if (configFile) {
+			const configFilePath = resolve(env.root, configFile);
+			if (!existsSync(configFilePath)) {
+				console.warn(`  ⚠︎ The specified RPC config file ${configFile} cannot be found at ${configFilePath}, loading the defaults..`);
+				RPCConfig = defaultRPCOptions;
+				return defaultRPCOptions;
+			}
+			const result = await loadConfigFile(env, configFile);
+			if (result && typeof result === "object") {
+				RPCConfig = mergeConfig({
+					...defaultRPCOptions,
+					configFile: configFilePath
+				}, result.config);
+				return RPCConfig;
+			}
+			RPCConfig = defaultRPCOptions;
+		}
+		if (RPCConfig !== void 0) return RPCConfig;
+		for (const file of defaultConfigFiles) {
+			const configFilePath = resolve(env.root, file);
+			if (!existsSync(configFilePath)) continue;
+			const result = await loadConfigFile(env, file);
+			if (result) {
+				RPCConfig = mergeConfig({
+					...defaultRPCOptions,
+					configFile: configFilePath
+				}, result.config);
+				return RPCConfig;
+			}
+		}
+		RPCConfig = defaultRPCOptions;
+		console.warn(` ⚡︎ No RPC config found, loading the defaults..`);
+	} catch (error) {
+		RPCConfig = defaultRPCOptions;
+		console.warn(` ⚠︎ Failed to load RPC config:`, error);
+	}
+	return RPCConfig;
+}
+function rpcPlugin(devOptions = {}) {
+	let options;
+	let config;
+	let viteServer;
+	let isOxc = true;
+	return {
+		name: "vite-plugin-universal-rpc",
+		enforce: "pre",
+		async configResolved(resolvedConfig) {
+			options = mergeConfig(await loadRPCConfig(), devOptions);
+			config = resolvedConfig;
+		},
+		async configureServer(server) {
+			viteServer = server;
+			const { adapter: _adapter, ...rest } = options;
+			if (serverFunctionsMap.size === 0) await scanForServerFiles(config, viteServer);
+			server.middlewares.use(createRPCMiddleware(rest));
+		},
+		async buildStart() {
+			const viteVersion = this.meta?.viteVersion;
+			isOxc = Number(viteVersion[0]) >= 8;
+			if (!viteServer && config) await scanForServerFiles(config);
+		},
+		async transform(code, id, ops) {
+			if (!code.includes("createServerFunction") || ops?.ssr || code.includes("createServerFunction") && typeof process === "undefined") return null;
+			if (serverFunctionsMap.size === 0) await scanForServerFiles(config);
+			const vite = await import("vite");
+			const transformer = isOxc ? "transformWithOxc" : "transformWithEsbuild";
+			const langProp = isOxc ? "lang" : "loader";
+			const source = getClientModules({
+				rpcPreffix: options.rpcPreffix,
+				adapter: options.adapter
+			});
+			const result = await vite[transformer](source, id, {
+				[langProp]: "js",
+				sourcemap: true
+			});
+			return {
+				code: result.code,
+				map: result.map ? typeof result.map === "string" ? JSON.parse(result.map) : result.map : null
+			};
+		}
+	};
+}
+//#endregion
+export { rpcPlugin as default, defineConfig, loadRPCConfig };
+
+//# sourceMappingURL=index.mjs.map