@kevisual/router 0.0.10 → 0.0.12

package/src/static.ts

@@ -0,0 +1,97 @@
+const http = require('http');
+const fs = require('fs').promises;
+const path = require('path');
+const fetch = require('node-fetch'); // 如果使用 Node.js 18 以上版本，可以改用内置 fetch
+const url = require('url');
+
+// 配置远端静态文件服务器和本地缓存目录
+const remoteServer = 'https://example.com/static'; // 远端服务器的 URL
+const cacheDir = path.join(__dirname, 'cache'); // 本地缓存目录
+const PORT = process.env.PORT || 3000;
+
+// 确保本地缓存目录存在
+fs.mkdir(cacheDir, { recursive: true }).catch(console.error);
+
+// 获取文件的 content-type
+function getContentType(filePath) {
+  const extname = path.extname(filePath);
+  const contentType = {
+    '.html': 'text/html',
+    '.js': 'text/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.wav': 'audio/wav',
+    '.mp4': 'video/mp4'
+  };
+  return contentType[extname] || 'application/octet-stream';
+}
+
+// 处理请求文件
+async function serveFile(filePath, remoteUrl, res) {
+  try {
+    // 检查文件是否存在于本地缓存中
+    const fileContent = await fs.readFile(filePath);
+    res.writeHead(200, { 'Content-Type': getContentType(filePath) });
+    res.end(fileContent, 'utf-8');
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      // 本地缓存中不存在，向远端服务器请求文件
+      try {
+        const response = await fetch(remoteUrl);
+
+        if (response.ok) {
+          // 远端请求成功，获取文件内容
+          const data = await response.buffer();
+
+          // 将文件缓存到本地
+          await fs.writeFile(filePath, data);
+
+          // 返回文件内容
+          res.writeHead(200, { 'Content-Type': getContentType(filePath) });
+          res.end(data, 'utf-8');
+        } else {
+          // 远端文件未找到或错误，返回 404
+          res.writeHead(404, { 'Content-Type': 'text/plain' });
+          res.end(`Error 404: File not found at ${remoteUrl}`);
+        }
+      } catch (fetchErr) {
+        // 处理请求错误
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end(`Server Error: Unable to fetch ${remoteUrl}`);
+      }
+    } else {
+      // 其他文件系统错误
+      res.writeHead(500, { 'Content-Type': 'text/plain' });
+      res.end(`Server Error: ${err.message}`);
+    }
+  }
+}
+
+// 创建 HTTP 服务器
+http.createServer(async (req, res) => {
+  let reqPath = req.url;
+
+  // 如果路径是根路径 `/`，将其设置为 `index.html`
+  if (reqPath === '/') reqPath = '/index.html';
+
+  // 构建本地缓存路径和远端 URL
+  const localFilePath = path.join(cacheDir, reqPath); // 本地文件路径
+  const remoteFileUrl = url.resolve(remoteServer, reqPath); // 远端文件 URL
+
+  // 根据请求路径处理文件或返回 index.html（单页面应用处理）
+  await serveFile(localFilePath, remoteFileUrl, res);
+
+  // 单页面应用的路由处理
+  if (res.headersSent) return; // 如果响应已发送，不再处理
+
+  // 如果未匹配到任何文件，返回 index.html
+  const indexFilePath = path.join(cacheDir, 'index.html');
+  const indexRemoteUrl = url.resolve(remoteServer, '/index.html');
+  await serveFile(indexFilePath, indexRemoteUrl, res);
+}).listen(PORT, () => {
+  console.log(`Server running at http://localhost:${PORT}`);
+});

package/src/utils/parse.ts

@@ -0,0 +1,13 @@
+export const parseIfJson = (input: string): { [key: string]: any } | string => {
+  try {
+    // 尝试解析 JSON
+    const parsed = JSON.parse(input);
+    // 检查解析结果是否为对象（数组或普通对象）
+    if (typeof parsed === 'object' && parsed !== null) {
+      return parsed;
+    }
+  } catch (e) {
+    // 如果解析失败，直接返回原始字符串
+  }
+  return input;
+};

package/src/utils/pick.ts

@@ -0,0 +1,9 @@
+export function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {
+  const result = {} as Pick<T, K>;
+  keys.forEach((key) => {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+}

package/src/utils/route-map.ts

@@ -0,0 +1,47 @@
+export type RouteMapInfo = {
+  pathKey?: string;
+  id: string;
+};
+
+export class RouteMap {
+  private keyMap: Map<string, RouteMapInfo> = new Map(); // 通过 path key 查找
+  private idMap: Map<string, RouteMapInfo> = new Map(); // 通过 id 查找
+  // 添加数据
+  add(info: RouteMapInfo) {
+    if (!info.pathKey && !info.id) {
+      console.error('appKey 和 appId 不能同时为空');
+      return;
+    }
+    this.keyMap.set(info.pathKey, info);
+    if (info.id) {
+      this.idMap.set(info.id, info);
+    }
+  }
+  // 删除数据
+  removeByKey(key: string) {
+    const info = this.keyMap.get(key);
+    if (info) {
+      this.keyMap.delete(info.pathKey);
+      this.idMap.delete(info.id);
+      return true;
+    }
+    return false;
+  }
+
+  removeByAppId(appId: string) {
+    const info = this.idMap.get(appId);
+    if (info) {
+      this.keyMap.delete(info.pathKey);
+      this.idMap.delete(info.id);
+      return true;
+    }
+    return false;
+  }
+  // 查询数据
+  getByKey(key: string): RouteMapInfo | undefined {
+    return this.keyMap.get(key);
+  }
+  getByAppId(appId: string): RouteMapInfo | undefined {
+    return this.idMap.get(appId);
+  }
+}

package/src/validator/index.ts

@@ -0,0 +1 @@
+export * from './rule.ts';

package/src/validator/rule.ts

@@ -0,0 +1,95 @@
+import { z, ZodError, Schema } from 'zod';
+export { Schema };
+type BaseRule = {
+  value?: any;
+  required?: boolean;
+  message?: string;
+};
+
+type RuleString = {
+  type: 'string';
+  minLength?: number;
+  maxLength?: number;
+  regex?: string;
+} & BaseRule;
+
+type RuleNumber = {
+  type: 'number';
+  min?: number;
+  max?: number;
+} & BaseRule;
+
+type RuleBoolean = {
+  type: 'boolean';
+} & BaseRule;
+
+type RuleArray = {
+  type: 'array';
+  items: Rule;
+  minItems?: number;
+  maxItems?: number;
+} & BaseRule;
+
+type RuleObject = {
+  type: 'object';
+  properties: { [key: string]: Rule };
+} & BaseRule;
+
+type RuleAny = {
+  type: 'any';
+} & BaseRule;
+
+export type Rule = RuleString | RuleNumber | RuleBoolean | RuleArray | RuleObject | RuleAny;
+
+export const schemaFormRule = (rule: Rule): z.ZodType<any, any, any> => {
+  switch (rule.type) {
+    case 'string':
+      let stringSchema = z.string();
+      if (rule.minLength) stringSchema = stringSchema.min(rule.minLength, `String must be at least ${rule.minLength} characters long.`);
+      if (rule.maxLength) stringSchema = stringSchema.max(rule.maxLength, `String must not exceed ${rule.maxLength} characters.`);
+      if (rule.regex) stringSchema = stringSchema.regex(new RegExp(rule.regex), 'Invalid format');
+      return stringSchema;
+    case 'number':
+      let numberSchema = z.number();
+      if (rule.min) numberSchema = numberSchema.min(rule.min, `Number must be at least ${rule.min}.`);
+      if (rule.max) numberSchema = numberSchema.max(rule.max, `Number must not exceed ${rule.max}.`);
+      return numberSchema;
+    case 'boolean':
+      return z.boolean();
+    case 'array':
+      return z.array(createSchema(rule.items));
+    case 'object':
+      return z.object(Object.fromEntries(Object.entries(rule.properties).map(([key, value]) => [key, createSchema(value)])));
+    case 'any':
+      return z.any();
+    default:
+      throw new Error(`Unknown rule type: ${(rule as any)?.type}`);
+  }
+};
+export const createSchema = (rule: Rule): Schema => {
+  try {
+    rule.required = rule.required ?? false;
+    if (!rule.required) {
+      // nullable is null
+      // nullish is null or undefined
+      // optional is undefined
+      return schemaFormRule(rule).optional();
+    }
+    return schemaFormRule(rule);
+  } catch (e) {
+    if (e instanceof ZodError) {
+      console.error(e.format());
+    }
+    throw e;
+  }
+};
+
+export const createSchemaList = (rules: Rule[]) => {
+  try {
+    return rules.map((rule) => createSchema(rule));
+  } catch (e) {
+    if (e instanceof ZodError) {
+      console.error(e.format());
+    }
+  }
+};