@longzai-intelligence-transport/http-adapter-bun 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,357 @@
+import { ApiResponse, InferRouteBody, InferRouteParams, InferRouteQuery, InferRouteResponse, RouteDefinition } from "@longzai-intelligence-transport/http-core";
+
+//#region src/index.d.ts
+/**
+ * 验证错误详情
+ *
+ * 单个字段的验证错误信息
+ */
+type ValidationErrorDetail = {
+  /**
+   * 字段路径
+   */
+  path: string;
+  /**
+   * 错误信息
+   */
+  message: string;
+  /**
+   * 接收到的值
+   */
+  received: unknown;
+  /**
+   * 期望的类型
+   */
+  expected: string;
+};
+/**
+ * 验证错误数据
+ *
+ * 请求数据验证失败时返回的错误结构
+ */
+type ValidationErrorData = {
+  /**
+   * 错误代码，固定为 VALIDATION_ERROR
+   */
+  code: 'VALIDATION_ERROR';
+  /**
+   * 错误概述信息
+   */
+  message: string;
+  /**
+   * 各字段的具体验证错误列表
+   */
+  details: Array<ValidationErrorDetail>;
+};
+/**
+ * Bun 请求上下文
+ *
+ * 包含请求的基本信息和解析后的数据
+ *
+ * @typeParam TContext - 自定义上下文类型
+ */
+type BunRequestContext<TContext = unknown> = {
+  /**
+   * 原始请求对象
+   */
+  request: Request;
+  /**
+   * 解析后的路径参数
+   */
+  params: Record<string, string>;
+  /**
+   * 解析后的查询参数
+   */
+  query: Record<string, string | string[]>;
+  /**
+   * 解析后的请求体
+   */
+  body: unknown;
+  /**
+   * 自定义上下文数据
+   */
+  context?: TContext;
+};
+/**
+ * Bun 路由处理器
+ *
+ * Bun 原生路由处理函数类型
+ *
+ * @typeParam _TContext - 自定义上下文类型（保留用于类型一致性）
+ */
+type BunRouteHandler<_TContext = unknown> = (request: Request) => Promise<Response> | Response;
+/**
+ * Bun 路由处理器选项
+ *
+ * @typeParam TContext - 自定义上下文类型
+ */
+type BunRouteHandlerOptions<TContext = unknown> = {
+  /**
+   * 创建自定义上下文的工厂函数
+   *
+   * 可用于注入数据库连接、用户信息等
+   *
+   * @param ctx - 请求上下文
+   */
+  createContext?: (ctx: BunRequestContext) => Promise<TContext> | TContext;
+  /**
+   * 全局错误处理函数
+   *
+   * 当请求处理过程中发生未捕获的异常时调用
+   *
+   * @param error - 捕获的错误对象
+   * @param request - 原始请求对象
+   */
+  onError?: (error: unknown, request: Request) => Response | Promise<Response>;
+  /**
+   * 验证错误处理函数
+   *
+   * 当请求参数验证失败时调用，可用于自定义错误响应格式
+   *
+   * @param validationError - 验证错误详情
+   * @param request - 原始请求对象
+   */
+  onValidationError?: (validationError: ValidationErrorData, request: Request) => Response | Promise<Response>;
+};
+/**
+ * 已验证的路由上下文
+ *
+ * 包含经过验证后的强类型路由参数
+ *
+ * @typeParam TRoute - 路由定义类型
+ * @typeParam TContext - 自定义上下文类型
+ */
+type ValidatedRouteContext<TRoute extends RouteDefinition, TContext = unknown> = {
+  /**
+   * 原始请求对象
+   */
+  request: Request;
+  /**
+   * 已验证的路径参数
+   */
+  params: InferRouteParams<TRoute>;
+  /**
+   * 已验证的查询参数
+   */
+  query: InferRouteQuery<TRoute>;
+  /**
+   * 已验证的请求体
+   */
+  body: InferRouteBody<TRoute>;
+  /**
+   * 自定义上下文数据
+   */
+  context?: TContext;
+};
+/**
+ * 路由处理器函数类型
+ *
+ * 用户实现的具体业务逻辑处理函数
+ *
+ * @typeParam TRoute - 路由定义类型
+ * @typeParam TContext - 自定义上下文类型
+ * @param ctx - 请求上下文，包含已验证的参数数据
+ */
+type RouteHandlerFn<TRoute extends RouteDefinition, TContext = unknown> = (ctx: BunRequestContext<TContext>) => Promise<ApiResponse<InferRouteResponse<TRoute>>> | ApiResponse<InferRouteResponse<TRoute>>;
+/**
+ * 路径转正则表达式结果
+ *
+ * 包含转换后的正则表达式和提取的参数名
+ */
+type PathToRegexResult = {
+  /**
+   * 匹配路径的正则表达式
+   */
+  regex: RegExp;
+  /**
+   * 路径中提取的参数名称列表
+   */
+  paramNames: string[];
+};
+/**
+ * 路由映射条目
+ *
+ * 包含路由定义和对应的处理函数
+ *
+ * @typeParam TContext - 自定义上下文类型
+ */
+type RouteMapEntry<TContext = unknown> = {
+  /**
+   * 路由定义
+   */
+  route: RouteDefinition;
+  /**
+   * 处理函数
+   */
+  handler: RouteHandlerFn<RouteDefinition, TContext>;
+};
+/**
+ * 路由映射类型
+ *
+ * 路由名称到路由条目的映射
+ *
+ * @typeParam TRoutes - 路由定义映射类型
+ * @typeParam TContext - 自定义上下文类型
+ */
+type RoutesMap<TRoutes extends Record<string, RouteDefinition>, TContext = unknown> = { [K in keyof TRoutes]: RouteHandlerFn<TRoutes[K], TContext> };
+/**
+ * Fetch 处理器选项
+ *
+ * 自定义 fetch 处理器的错误处理行为
+ */
+type FetchHandlerOptions = {
+  /**
+   * 路由未找到时的处理函数
+   */
+  onNotFound?: (request: Request) => Response | Promise<Response>;
+  /**
+   * HTTP 方法不允许时的处理函数
+   */
+  onMethodNotAllowed?: (request: Request) => Response | Promise<Response>;
+};
+/**
+ * Fetch 处理器函数类型
+ *
+ * 接收 Request 并返回 Response 的异步函数
+ *
+ * @param request - HTTP 请求对象
+ */
+type FetchHandlerFn = (request: Request) => Promise<Response>;
+/**
+ * 将路径模式转换为正则表达式
+ *
+ * @param path - 路径模式，如 "/users/:id"
+ * @returns 正则表达式和参数名称数组
+ */
+declare function pathToRegex(path: string): PathToRegexResult;
+/**
+ * 从 URL 中提取路径参数
+ *
+ * @param url - 请求 URL
+ * @param pathPattern - 路径模式
+ * @returns 路径参数对象
+ */
+declare function extractPathParams(url: string, pathPattern: string): Record<string, string>;
+/**
+ * 从请求中提取查询参数
+ *
+ * @param request - 请求对象
+ * @returns 查询参数对象
+ */
+declare function extractQueryParams(request: Request): Record<string, string | string[]>;
+/**
+ * 解析请求体
+ *
+ * 根据 Content-Type 头部解析请求体内容
+ *
+ * @param request - 请求对象
+ * @returns 解析后的请求体
+ */
+declare function parseRequestBody(request: Request): Promise<unknown>;
+/**
+ * 创建路由处理器
+ *
+ * 将 RouteDefinition 转换为 Bun 原生路由处理函数
+ *
+ * @example
+ *   ```typescript
+ *   import {
+ *     createRouteHandler,
+ *     defineRoute,
+ *     ApiResponseSchema,
+ *     z,
+ *   } from '@longzai-intelligence-transport/http';
+ *
+ *   const userRoute = defineRoute({
+ *     method: 'GET',
+ *     path: '/users/:id',
+ *     params: z.object({ id: z.string() }),
+ *     response: ApiResponseSchema(z.object({ id: z.string(), name: z.string() })),
+ *   });
+ *
+ *   const handler = createRouteHandler(userRoute, async (ctx) => {
+ *     const user = await getUser(ctx.params.id);
+ *     return { success: true, data: user };
+ *   });
+ *
+ *   // 在 Bun 服务器中使用
+ *   const server = Bun.serve({
+ *     fetch: handler,
+ *   });
+ *   ```;
+ *
+ * @typeParam TRoute - 路由定义类型
+ * @typeParam TContext - 自定义上下文类型
+ * @param route - 路由定义
+ * @param handler - 业务逻辑处理函数
+ * @param options - 处理器选项
+ * @returns Bun 路由处理函数
+ */
+declare function createRouteHandler<TRoute extends RouteDefinition, TContext = unknown>(route: TRoute, handler: RouteHandlerFn<TRoute, TContext>, options?: BunRouteHandlerOptions<TContext>): BunRouteHandler<TContext>;
+/**
+ * 创建路由映射
+ *
+ * 批量将路由定义转换为 Bun 路由映射
+ *
+ * @example
+ *   ```typescript
+ *   import {
+ *     createRouteMap,
+ *     defineRoute,
+ *     ApiResponseSchema,
+ *     z,
+ *   } from '@longzai-intelligence-transport/http';
+ *
+ *   const routes = {
+ *     list: defineRoute({
+ *       method: 'GET',
+ *       path: '/users',
+ *       response: ApiResponseSchema(z.array(z.object({ id: z.string(), name: z.string() }))),
+ *     }),
+ *     detail: defineRoute({
+ *       method: 'GET',
+ *       path: '/users/:id',
+ *       params: z.object({ id: z.string() }),
+ *       response: ApiResponseSchema(z.object({ id: z.string(), name: z.string() })),
+ *     }),
+ *   };
+ *
+ *   const handlers = {
+ *     list: async () => ({ success: true, data: await getUsers() }),
+ *     detail: async (ctx) => ({ success: true, data: await getUser(ctx.params.id) }),
+ *   };
+ *
+ *   const routeMap = createRouteMap(routes, handlers);
+ *
+ *   // 在 Bun 服务器中使用
+ *   const server = Bun.serve({
+ *     fetch: (request) => {
+ *       const url = new URL(request.url);
+ *       const handler = routeMap[url.pathname]?.[request.method];
+ *       if (handler) return handler(request);
+ *       return new Response('Not Found', { status: 404 });
+ *     },
+ *   });
+ *   ```;
+ *
+ * @typeParam TRoutes - 路由定义映射类型
+ * @typeParam TContext - 自定义上下文类型
+ * @param routes - 路由定义映射
+ * @param handlers - 处理函数映射
+ * @param options - 处理器选项
+ * @returns Bun 路由映射，可用于 Bun.serve 的 fetch 处理
+ */
+declare function createRouteMap<TRoutes extends Record<string, RouteDefinition>, TContext = unknown>(routes: TRoutes, handlers: RoutesMap<TRoutes, TContext>, options?: BunRouteHandlerOptions<TContext>): Record<string, Record<string, BunRouteHandler<TContext>>>;
+/**
+ * 创建 Bun 服务器 fetch 处理器
+ *
+ * 将路由映射转换为 Bun.serve 可用的 fetch 函数
+ *
+ * @typeParam TContext - 自定义上下文类型
+ * @param routeMap - 路由映射
+ * @param options - 额外选项
+ * @returns fetch 处理函数
+ */
+declare function createFetchHandler<TContext = unknown>(routeMap: Record<string, Record<string, BunRouteHandler<TContext>>>, options?: FetchHandlerOptions): FetchHandlerFn;
+//#endregion
+export { type BunRequestContext, type BunRouteHandler, type BunRouteHandlerOptions, type FetchHandlerFn, type FetchHandlerOptions, type PathToRegexResult, type RouteHandlerFn, type RouteMapEntry, type RoutesMap, type ValidatedRouteContext, type ValidationErrorData, type ValidationErrorDetail, createFetchHandler, createRouteHandler, createRouteMap, extractPathParams, extractQueryParams, parseRequestBody, pathToRegex };

package/dist/index.js

@@ -0,0 +1 @@
+import{createValidationErrorResponseFromError as e,validateRequest as t}from"@longzai-intelligence-transport/http-core";function n(e){let t=[],n=/:([^/]+)/g,r=n.exec(e);for(;r!==null;)r[1]&&t.push(r[1]),r=n.exec(e);return t}function r(e){let t=n(e),r=e.replace(/:([^/]+)/g,`(?<$1>[^/]+)`);return{regex:RegExp(`^${r}$`),paramNames:t}}function i(e,t){let{regex:n}=r(t),i=new URL(e).pathname,a=n.exec(i);return!a||!a.groups?{}:a.groups}function a(e){let t=new URL(e.url),n={};return t.searchParams.forEach((e,t)=>{let r=n[t];r===void 0?n[t]=e:typeof r==`string`?n[t]=[r,e]:r.push(e)}),n}async function o(e){let t=e.headers.get(`content-type`);if(t){if(t.includes(`application/json`))try{return await e.json()}catch{return}if(t.includes(`multipart/form-data`)){let t=await e.formData(),n={};return t.forEach((e,t)=>{n[t]=e}),n}if(t.includes(`application/x-www-form-urlencoded`)){let t=await e.formData(),n={};return t.forEach((e,t)=>{n[t]=e}),n}if(t.includes(`text/`))return await e.text()}}function s(e){let t=e instanceof Error?e.message:`服务器内部错误`;return new Response(JSON.stringify({success:!1,error:{code:`INTERNAL_ERROR`,message:t},message:t,timestamp:Date.now()}),{status:500,headers:{"Content-Type":`application/json`}})}async function c(e,t,n,r,i,a){let o={request:t,params:n,query:r,body:i};a?.createContext&&(o.context=await a.createContext(o));let s=await e(o);return new Response(JSON.stringify(s),{status:200,headers:{"Content-Type":`application/json`}})}function l(n,r,l){return async u=>{try{let d=t(n,{params:i(u.url,n.path),query:a(u),body:await o(u)});if(!d.success){if(!d.error)return s(Error(`验证失败但未提供错误详情`));if(l?.onValidationError)return await l.onValidationError(d.error,u);let t=e(d.error);return new Response(JSON.stringify(t),{status:400,headers:{"Content-Type":`application/json`}})}return await c(r,u,d.params??{},d.query??{},d.body,l)}catch(e){return l?.onError?l.onError(e,u):s(e)}}}function u(e,t,n){let r={};for(let[i,a]of Object.entries(e)){let e=t[i];if(e){let t=l(a,e,n),i=a.path;r[i]||(r[i]={}),r[i][a.method]=t}}return r}function d(e,t){return async n=>{let r=e[new URL(n.url).pathname];if(!r)return t?.onNotFound?t.onNotFound(n):new Response(JSON.stringify({success:!1,error:{code:`NOT_FOUND`,message:`资源不存在`},message:`资源不存在`,timestamp:Date.now()}),{status:404,headers:{"Content-Type":`application/json`}});let i=r[n.method];return i?i(n):t?.onMethodNotAllowed?t.onMethodNotAllowed(n):new Response(JSON.stringify({success:!1,error:{code:`METHOD_NOT_ALLOWED`,message:`方法不允许`},message:`方法不允许`,timestamp:Date.now()}),{status:405,headers:{"Content-Type":`application/json`}})}}export{d as createFetchHandler,l as createRouteHandler,u as createRouteMap,i as extractPathParams,a as extractQueryParams,o as parseRequestBody,r as pathToRegex};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@longzai-intelligence-transport/http-adapter-bun",
+  "version": "0.1.0",
+  "keywords": [
+    "adapter",
+    "bun",
+    "http",
+    "route-handler",
+    "server",
+    "utils"
+  ],
+  "license": "UNLICENSED",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsgo --build tsconfig/build.json && resolve-aliases -p tsconfig/build.json",
+    "build:prod": "NODE_ENV=production tsdown",
+    "prepublishOnly": "bun run build:prod",
+    "typecheck": "bun run typecheck:app && bun run typecheck:node && bun run typecheck:test",
+    "typecheck:app": "tsgo --noEmit -p tsconfig/app.json",
+    "typecheck:node": "tsgo --noEmit -p tsconfig/node.json",
+    "typecheck:test": "tsgo --noEmit -p tsconfig/test.json",
+    "lint": "oxlint && oxfmt --check",
+    "lint:fix": "oxlint --fix && oxfmt",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "test:coverage": "bun test --coverage",
+    "clean": "rimraf dist out .cache"
+  },
+  "dependencies": {
+    "@longzai-intelligence-transport/http-core": "0.1.0"
+  },
+  "devDependencies": {
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "bun": ">=1.0.0",
+    "zod": "^4.4.3"
+  }
+}