@kevisual/router 0.0.22 → 0.0.24

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@kevisual/router",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "",
   "type": "module",
   "main": "./dist/router.js",
@@ -10,7 +10,9 @@
     "build": "npm run clean && rollup -c",
     "build:app": "npm run build && rsync dist/*browser* ../deploy/dist",
     "watch": "rollup -c -w",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "auto:bun": "bun test/auto/app.ts",
+    "auto:deno": "bun test/auto/app.ts"
   },
   "files": [
     "dist",
@@ -21,19 +23,24 @@
   "author": "abearxiong",
   "license": "MIT",
   "devDependencies": {
-    "@kevisual/query": "^0.0.25",
+    "@kevisual/local-proxy": "^0.0.3",
+    "@kevisual/query": "^0.0.29",
     "@rollup/plugin-alias": "^5.1.1",
-    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-commonjs": "^28.0.6",
     "@rollup/plugin-node-resolve": "^16.0.1",
-    "@rollup/plugin-typescript": "^12.1.2",
+    "@rollup/plugin-typescript": "^12.1.3",
+    "@types/bun": "^1.2.10",
+    "@types/deno": "^2.3.0",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^22.15.29",
+    "@types/node": "^24.0.3",
+    "@types/send": "^0.17.5",
     "@types/ws": "^8.18.1",
     "@types/xml2js": "^0.4.14",
     "cookie": "^1.0.2",
+    "deno": "^2.4.3",
     "lodash-es": "^4.17.21",
     "nanoid": "^5.1.5",
-    "rollup": "^4.41.1",
+    "rollup": "^4.44.0",
     "rollup-plugin-dts": "^6.2.1",
     "ts-loader": "^9.5.2",
     "ts-node": "^10.9.2",
@@ -41,7 +48,7 @@
     "typescript": "^5.8.3",
     "ws": "npm:@kevisual/ws",
     "xml2js": "^0.6.2",
-    "zod": "^3.25.51"
+    "zod": "^3.25.67"
   },
   "repository": {
     "type": "git",
@@ -49,7 +56,8 @@
   },
   "dependencies": {
     "path-to-regexp": "^8.2.0",
-    "selfsigned": "^2.4.1"
+    "selfsigned": "^2.4.1",
+    "send": "^1.2.0"
   },
   "publishConfig": {
     "access": "public"
@@ -90,6 +98,11 @@
       "require": "./mod.ts",
       "types": "./mod.d.ts"
     },
+    "./auto.ts": {
+      "import": "./auto.ts",
+      "require": "./auto.ts",
+      "types": "./auto.ts"
+    },
     "./src/*": {
       "import": "./src/*",
       "require": "./src/*"

package/readme.md

@@ -20,3 +20,17 @@ app
   })
   .addTo(app);
 ```
+## 兼容服务器
+```
+import { App } from '@kevisual/router';
+
+const app = new App();
+app.listen(4002);
+import { proxyRoute, initProxy } from '@kevisual/local-proxy/proxy.ts';
+initProxy({
+  pagesDir: './demo',
+  watch: true,
+});
+
+app.onServerRequest(proxyRoute);
+```

package/src/app-browser.ts

@@ -0,0 +1,5 @@
+import { QueryRouterServer } from './browser.ts';
+
+export const App = QueryRouterServer;
+
+export * from './browser.ts';

package/src/app.ts

@@ -3,7 +3,7 @@ import { Server, ServerOpts, HandleCtx } from './server/server.ts';
 import { WsServer } from './server/ws-server.ts';
 import { CustomError } from './result/error.ts';
 import { handleServer } from './server/handle-server.ts';
-import { IncomingMessage, ServerResponse } from 'http';
+import { IncomingMessage, ServerResponse } from 'node:http';
 
 type RouterHandle = (msg: { path: string; [key: string]: any }) => { code: string; data?: any; message?: string; [key: string]: any };
 type AppOptions<T = {}> = {
@@ -105,6 +105,12 @@ export class App<T = {}, U = AppReqRes> {
   static handleRequest(req: IncomingMessage, res: ServerResponse) {
     return handleServer(req, res);
   }
+  onServerRequest(fn: (req: IncomingMessage, res: ServerResponse) => void) {
+    if (!this.server) {
+      throw new Error('Server is not initialized');
+    }
+    this.server.on(fn);
+  }
 }
 
 export * from './browser.ts';

package/src/auto/call-sock.ts

@@ -0,0 +1,151 @@
+import { createConnection } from 'node:net';
+
+type QueryData = {
+  path?: string;
+  key?: string;
+  payload?: any;
+  [key: string]: any;
+};
+
+type CallSockOptions = {
+  socketPath?: string;
+  timeout?: number;
+  method?: 'GET' | 'POST';
+};
+
+export const callSock = async (data: QueryData, options: CallSockOptions = {}): Promise<any> => {
+  const { socketPath = './app.sock', timeout = 5000, method = 'POST' } = options;
+
+  return new Promise((resolve, reject) => {
+    const client = createConnection(socketPath);
+    let responseData = '';
+    let timer: NodeJS.Timeout;
+
+    // 设置超时
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        client.destroy();
+        reject(new Error(`Socket call timeout after ${timeout}ms`));
+      }, timeout);
+    }
+
+    client.on('connect', () => {
+      try {
+        let request: string;
+
+        if (method === 'GET') {
+          // GET 请求：参数放在 URL 中
+          const searchParams = new URLSearchParams();
+          Object.entries(data).forEach(([key, value]) => {
+            if (key === 'payload' && typeof value === 'object') {
+              searchParams.append(key, JSON.stringify(value));
+            } else {
+              searchParams.append(key, String(value));
+            }
+          });
+
+          const queryString = searchParams.toString();
+          const url = queryString ? `/?${queryString}` : '/';
+
+          request = [`GET ${url} HTTP/1.1`, 'Host: localhost', 'Connection: close', '', ''].join('\r\n');
+        } else {
+          // POST 请求：数据放在 body 中
+          const body = JSON.stringify(data);
+          const contentLength = Buffer.byteLength(body, 'utf8');
+
+          request = [
+            'POST / HTTP/1.1',
+            'Host: localhost',
+            'Content-Type: application/json',
+            `Content-Length: ${contentLength}`,
+            'Connection: close',
+            '',
+            body,
+          ].join('\r\n');
+        }
+
+        client.write(request);
+      } catch (error) {
+        if (timer) clearTimeout(timer);
+        client.destroy();
+        reject(error);
+      }
+    });
+
+    client.on('data', (chunk) => {
+      responseData += chunk.toString();
+    });
+
+    client.on('end', () => {
+      if (timer) clearTimeout(timer);
+
+      try {
+        // 解析 HTTP 响应
+        const response = parseHttpResponse(responseData);
+
+        if (response.statusCode >= 400) {
+          reject(new Error(`HTTP ${response.statusCode}: ${response.body}`));
+          return;
+        }
+
+        // 尝试解析 JSON 响应
+        try {
+          const result = JSON.parse(response.body);
+          resolve(result);
+        } catch {
+          // 如果不是 JSON，直接返回文本
+          resolve(response.body);
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+
+    client.on('error', (error) => {
+      if (timer) clearTimeout(timer);
+      reject(error);
+    });
+
+    client.on('timeout', () => {
+      if (timer) clearTimeout(timer);
+      client.destroy();
+      reject(new Error('Socket connection timeout'));
+    });
+  });
+};
+
+// 解析 HTTP 响应的辅助函数
+function parseHttpResponse(responseData: string) {
+  const [headerSection, ...bodyParts] = responseData.split('\r\n\r\n');
+  const body = bodyParts.join('\r\n\r\n');
+
+  const lines = headerSection.split('\r\n');
+  const statusLine = lines[0];
+  const statusMatch = statusLine.match(/HTTP\/\d\.\d (\d+)/);
+  const statusCode = statusMatch ? parseInt(statusMatch[1]) : 200;
+
+  const headers: Record<string, string> = {};
+  for (let i = 1; i < lines.length; i++) {
+    const [key, ...valueParts] = lines[i].split(':');
+    if (key && valueParts.length > 0) {
+      headers[key.trim().toLowerCase()] = valueParts.join(':').trim();
+    }
+  }
+
+  return {
+    statusCode,
+    headers,
+    body: body || '',
+  };
+}
+
+// 便捷方法
+export const callSockGet = (data: QueryData, options?: Omit<CallSockOptions, 'method'>) => {
+  return callSock(data, { ...options, method: 'GET' });
+};
+
+export const callSockPost = (data: QueryData, options?: Omit<CallSockOptions, 'method'>) => {
+  return callSock(data, { ...options, method: 'POST' });
+};
+
+export const autoCall = callSockPost;

package/src/auto/listen/cleanup.ts

@@ -0,0 +1,102 @@
+import { getRuntime } from '../runtime.ts';
+
+let isClean = false;
+export const deleteFileDetached = async (path: string, pidPath: string = './app.pid') => {
+  const runtime = getRuntime();
+  if (runtime.isDeno) {
+    // Deno 实现 - 启动后不等待结果
+    const process = new Deno.Command('sh', {
+      args: ['-c', `rm -f "${path}" & rm -f "${pidPath}"`],
+      stdout: 'null',
+      stderr: 'null',
+    });
+    process.spawn(); // 不等待结果
+    console.log(`[DEBUG] Fire-and-forget delete initiated for ${path}`);
+    return;
+  }
+  const { spawn } = await import('node:child_process');
+  const child = spawn('sh', ['-c', `rm -f "${path}" & rm -f "${pidPath}"`], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref(); // 完全分离
+  console.log(`[DEBUG] Fire-and-forget delete initiated for ${path}`);
+};
+
+type CleanupOptions = {
+  path: string;
+  close?: () => Promise<void>;
+  pidPath?: string;
+};
+export const cleanup = async ({ path, close = async () => {}, pidPath = './app.pid' }: CleanupOptions) => {
+  const runtime = getRuntime();
+
+  // 检查文件是否存在并删除
+  const cleanupFile = async () => {
+    if (isClean) return;
+    isClean = true;
+    if (runtime.isDeno) {
+      await deleteFileDetached(path, pidPath);
+    }
+    await close();
+    if (!runtime.isDeno) {
+      await deleteFileDetached(path, pidPath);
+    }
+  };
+
+  // 根据运行时环境注册不同的退出监听器
+  if (runtime.isDeno) {
+    // Deno 环境
+    const handleSignal = () => {
+      cleanupFile();
+      Deno.exit(0);
+    };
+
+    try {
+      Deno.addSignalListener('SIGINT', handleSignal);
+      Deno.addSignalListener('SIGTERM', handleSignal);
+    } catch (error) {
+      console.warn('[DEBUG] Failed to add signal listeners:', error);
+    }
+
+    // 对于 beforeunload 和 unload，使用异步清理
+    const handleUnload = () => {
+      cleanupFile();
+    };
+
+    globalThis.addEventListener('beforeunload', handleUnload);
+    globalThis.addEventListener('unload', handleUnload);
+  } else if (runtime.isNode || runtime.isBun) {
+    // Node.js 和 Bun 环境
+    import('process').then(({ default: process }) => {
+      // 信号处理使用同步清理，然后退出
+      const signalHandler = async (signal: string) => {
+        await cleanupFile();
+        process.exit(0);
+      };
+
+      process.on('SIGINT', () => signalHandler('SIGINT'));
+      process.on('SIGTERM', () => signalHandler('SIGTERM'));
+      process.on('SIGUSR1', () => signalHandler('SIGUSR1'));
+      process.on('SIGUSR2', () => signalHandler('SIGUSR2'));
+
+      process.on('exit', async () => {
+        await cleanupFile();
+      });
+
+      process.on('uncaughtException', async (error) => {
+        console.error('Uncaught Exception:', error);
+        await cleanupFile();
+        process.exit(1);
+      });
+
+      process.on('unhandledRejection', async (reason, promise) => {
+        console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+        await cleanupFile();
+      });
+    });
+  }
+
+  // 返回手动清理函数，以便需要时主动调用
+  return cleanupFile;
+};

package/src/auto/listen/run-check.ts

@@ -0,0 +1,50 @@
+import { getRuntime } from '../runtime.ts';
+
+export const getPid = async () => {
+  const runtime = getRuntime();
+
+  let pid = 0;
+  if (runtime.isDeno) {
+    pid = Deno.pid;
+  } else {
+    pid = process.pid;
+  }
+  return pid;
+};
+export const writeAppid = async (pidPath = './app.pid') => {
+  const fs = await import('node:fs');
+  const pid = await getPid();
+  fs.writeFileSync(pidPath, pid + '');
+};
+
+export const getPidFromFileAndStop = async () => {
+  const fs = await import('node:fs');
+  if (fs.existsSync('./app.pid')) {
+    const pid = parseInt(fs.readFileSync('./app.pid', 'utf-8'), 10);
+    if (!isNaN(pid)) {
+      if (pid === 0) {
+        return;
+      }
+      try {
+        process.kill(pid);
+        console.log(`Stopped process with PID ${pid}`);
+      } catch (error) {
+        console.error(`Failed to stop process with PID ${pid}:`, error);
+      }
+    }
+  }
+};
+
+export const runFirstCheck = async (path: string, pidPath: string) => {
+  await getPidFromFileAndStop();
+  await writeAppid(pidPath);
+  try {
+    const fs = await import('node:fs');
+    if (fs.existsSync(path)) {
+      fs.unlinkSync(path);
+      console.log(`Socket file ${path} cleaned up during first check`);
+    }
+  } catch (error) {
+    console.error(`Failed to clean up socket file ${path} during first check:`, error);
+  }
+};

package/src/auto/listen-sock.ts

@@ -0,0 +1,245 @@
+import type { IncomingMessage } from 'http';
+import { QueryRouterServer } from '../index.ts';
+import { getRuntime } from './runtime.ts';
+import { runFirstCheck } from './listen/run-check.ts';
+import { cleanup } from './listen/cleanup.ts';
+
+type ListenSocketOptions = {
+  path?: string;
+  app?: QueryRouterServer;
+  pidPath?: string;
+};
+const server = async (req, app: QueryRouterServer) => {
+  const runtime = getRuntime();
+  let data;
+  if (!runtime.isNode) {
+    data = await getRequestParams(req);
+  } else {
+    data = await parseBody(req);
+  }
+
+  const result = await app.queryRoute(data as any);
+  const response = new Response(JSON.stringify(result));
+  response.headers.set('Content-Type', 'application/json');
+  return response;
+};
+
+export const listenSocket = async (options?: ListenSocketOptions) => {
+  const path = options?.path || './app.sock';
+  const pidPath = options?.pidPath || './app.pid';
+  const runtime = getRuntime();
+  let app = options?.app || globalThis.context?.app;
+  if (!app) {
+    app = new QueryRouterServer();
+  }
+  await runFirstCheck(path, pidPath);
+  let close = async () => {};
+  cleanup({ path, close });
+  if (runtime.isDeno) {
+    // 检查 Deno 版本是否支持 Unix domain socket
+    try {
+      // @ts-ignore
+      const listener = Deno.listen({
+        transport: 'unix',
+        path: path,
+      });
+
+      // 处理连接
+      (async () => {
+        for await (const conn of listener) {
+          (async () => {
+            // @ts-ignore
+            const httpConn = Deno.serveHttp(conn);
+            for await (const requestEvent of httpConn) {
+              try {
+                const response = await server(requestEvent.request, app);
+                await requestEvent.respondWith(response);
+              } catch (error) {
+                await requestEvent.respondWith(new Response('Internal Server Error', { status: 500 }));
+              }
+            }
+          })();
+        }
+      })();
+      close = async () => {
+        listener.close();
+      };
+      return listener;
+    } catch (error) {
+      // 如果 Unix socket 不支持，回退到 HTTP 服务器
+      console.warn('Unix socket not supported in this Deno environment, falling back to HTTP server');
+
+      // @ts-ignore
+      const listener = Deno.listen({ port: 0 }); // 使用随机端口
+
+      // @ts-ignore
+      console.log(`Deno server listening on port ${listener.addr.port}`);
+
+      (async () => {
+        for await (const conn of listener) {
+          (async () => {
+            // @ts-ignore
+            const httpConn = Deno.serveHttp(conn);
+            for await (const requestEvent of httpConn) {
+              try {
+                const response = await server(requestEvent.request, app);
+                await requestEvent.respondWith(response);
+              } catch (error) {
+                await requestEvent.respondWith(new Response('Internal Server Error', { status: 500 }));
+              }
+            }
+          })();
+        }
+      })();
+
+      return listener;
+    }
+  }
+
+  if (runtime.isBun) {
+    const bunServer = Bun.serve({
+      unix: path,
+      fetch(req) {
+        return server(req, app);
+      },
+    });
+    close = async () => {
+      await bunServer.stop();
+    };
+    return bunServer;
+  }
+
+  // Node.js 环境
+  const http = await import('http');
+
+  const httpServer = http.createServer(async (req, res) => {
+    try {
+      const response = await server(req, app);
+
+      // 设置响应头
+      response.headers.forEach((value, key) => {
+        res.setHeader(key, value);
+      });
+
+      // 设置状态码
+      res.statusCode = response.status;
+
+      // 读取响应体并写入
+      const body = await response.text();
+      res.end(body);
+    } catch (error) {
+      console.error('Error handling request:', error);
+      res.statusCode = 500;
+      res.end('Internal Server Error');
+    }
+  });
+
+  httpServer.listen(path);
+  close = async () => {
+    httpServer.close();
+  };
+  return httpServer;
+};
+
+export const getRequestParams = async (req: Request) => {
+  let urlParams: Record<string, any> = {};
+  let bodyParams: Record<string, any> = {};
+
+  // 获取URL参数
+  const url = new URL(req.url);
+  for (const [key, value] of url.searchParams.entries()) {
+    // 尝试解析JSON payload
+    if (key === 'payload') {
+      try {
+        urlParams[key] = JSON.parse(value);
+      } catch {
+        urlParams[key] = value;
+      }
+    } else {
+      urlParams[key] = value;
+    }
+  }
+
+  // 获取body参数
+  if (req.method.toLowerCase() === 'post' && req.body) {
+    const contentType = req.headers.get('content-type') || '';
+    if (contentType.includes('application/json')) {
+      try {
+        bodyParams = await req.json();
+      } catch {
+        // 如果解析失败，保持空对象
+      }
+    } else if (contentType.includes('application/x-www-form-urlencoded')) {
+      const formData = await req.text();
+      const params = new URLSearchParams(formData);
+      for (const [key, value] of params.entries()) {
+        bodyParams[key] = value;
+      }
+    } else if (contentType.includes('multipart/form-data')) {
+      try {
+        const formData = await req.formData();
+        for (const [key, value] of formData.entries()) {
+          // @ts-ignore
+          bodyParams[key] = value instanceof File ? value : value.toString();
+        }
+      } catch {
+        // 如果解析失败，保持空对象
+      }
+    }
+  }
+
+  // body参数优先，合并数据
+  return {
+    ...urlParams,
+    ...bodyParams,
+  };
+};
+
+export const parseBody = async <T = Record<string, any>>(req: IncomingMessage) => {
+  return new Promise<T>((resolve, reject) => {
+    const arr: any[] = [];
+    req.on('data', (chunk) => {
+      arr.push(chunk);
+    });
+    req.on('end', () => {
+      try {
+        const body = Buffer.concat(arr).toString();
+
+        // 获取 Content-Type 头信息
+        const contentType = req.headers['content-type'] || '';
+
+        // 处理 application/json
+        if (contentType.includes('application/json')) {
+          resolve(JSON.parse(body) as T);
+          return;
+        }
+        // 处理 application/x-www-form-urlencoded
+        if (contentType.includes('application/x-www-form-urlencoded')) {
+          const formData = new URLSearchParams(body);
+          const result: Record<string, any> = {};
+
+          formData.forEach((value, key) => {
+            // 尝试将值解析为 JSON，如果失败则保留原始字符串
+            try {
+              result[key] = JSON.parse(value);
+            } catch {
+              result[key] = value;
+            }
+          });
+
+          resolve(result as T);
+          return;
+        }
+
+        // 默认尝试 JSON 解析
+        try {
+          resolve(JSON.parse(body) as T);
+        } catch {
+          resolve({} as T);
+        }
+      } catch (e) {
+        resolve({} as T);
+      }
+    });
+  });
+};