vafast 0.3.2 → 0.3.4

package/dist/utils/create-handler.js

@@ -1,234 +1,410 @@
-/**
- * 类型安全的路由处理器工厂
- *
- * 非柯里化设计，API 更简洁
- *
- * @author Framework Team
- * @version 3.0.0
- * @license MIT
- */
-import { parseBody, parseQuery, parseHeaders, parseCookies } from "./parsers";
-import { goAwait } from "./go-await";
-import { json } from "./response";
-import { validateAllSchemasUltra, precompileSchemasUltra, } from "./validators/schema-validators-ultra";
-/**
- * 自动响应转换
- * 将各种返回值类型转换为 Response 对象
- */
-function autoResponse(result) {
-    // 已经是 Response
-    if (result instanceof Response) {
-        return result;
-    }
-    // null/undefined -> 204
-    if (result === null || result === undefined) {
-        return new Response(null, { status: 204 });
+// src/utils/parsers.ts
+import qs from "qs";
+import cookie from "cookie";
+async function parseBody(req) {
+  const contentType = req.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    return await req.json();
+  }
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    const text = await req.text();
+    return Object.fromEntries(new URLSearchParams(text));
+  }
+  return await req.text();
+}
+function extractQueryString(url) {
+  const qIndex = url.indexOf("?");
+  if (qIndex === -1) return "";
+  const hashIndex = url.indexOf("#", qIndex);
+  return hashIndex === -1 ? url.substring(qIndex + 1) : url.substring(qIndex + 1, hashIndex);
+}
+function parseQuery(req) {
+  const queryString = extractQueryString(req.url);
+  if (!queryString) return {};
+  return qs.parse(queryString);
+}
+function parseHeaders(req) {
+  const headers = /* @__PURE__ */ Object.create(null);
+  req.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return headers;
+}
+function parseCookies(req) {
+  const cookieHeader = req.headers.get("cookie");
+  if (!cookieHeader) return {};
+  try {
+    const parsed = cookie.parse(cookieHeader);
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (value !== void 0 && value !== null) {
+        result[key] = value;
+      }
     }
-    // 字符串 -> text/plain
-    if (typeof result === "string") {
-        return new Response(result, {
-            headers: { "Content-Type": "text/plain; charset=utf-8" },
-        });
+    return result;
+  } catch {
+    return {};
+  }
+}
+
+// src/utils/go-await.ts
+function goAwait(promise) {
+  return promise.then((data) => [null, data]).catch((err) => [err instanceof Error ? err : new Error(String(err)), void 0]);
+}
+
+// src/utils/response.ts
+function json(data, status = 200, headers = {}) {
+  const body = JSON.stringify(data);
+  if (Object.keys(headers).length === 0) {
+    return new Response(body, {
+      status,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  const h = new Headers({
+    "Content-Type": "application/json",
+    ...headers
+  });
+  return new Response(body, {
+    status,
+    headers: h
+  });
+}
+
+// src/utils/validators/schema-validators-ultra.ts
+import { TypeCompiler } from "@sinclair/typebox/compiler";
+var SCHEMA_FLAGS = {
+  BODY: 1 << 0,
+  // 1
+  QUERY: 1 << 1,
+  // 2
+  PARAMS: 1 << 2,
+  // 4
+  HEADERS: 1 << 3,
+  // 8
+  COOKIES: 1 << 4
+  // 16
+};
+var ultraSchemaCache = /* @__PURE__ */ new Map();
+var schemaCacheHits = /* @__PURE__ */ new Map();
+var errorPool = [];
+var ERROR_POOL_SIZE = 200;
+var errorMessagePool = /* @__PURE__ */ new Map();
+var commonMessages = [
+  "\u8BF7\u6C42\u4F53\u9A8C\u8BC1\u5931\u8D25",
+  "Query\u53C2\u6570\u9A8C\u8BC1\u5931\u8D25",
+  "\u8DEF\u5F84\u53C2\u6570\u9A8C\u8BC1\u5931\u8D25",
+  "\u8BF7\u6C42\u5934\u9A8C\u8BC1\u5931\u8D25",
+  "Cookie\u9A8C\u8BC1\u5931\u8D25",
+  "\u7C7B\u578B\u9A8C\u8BC1\u5931\u8D25",
+  "Schema\u7F16\u8BD1\u5931\u8D25",
+  "\u672A\u77E5\u9519\u8BEF"
+];
+commonMessages.forEach((msg) => errorMessagePool.set(msg, msg));
+for (let i = 0; i < ERROR_POOL_SIZE; i++) {
+  errorPool.push(new Error());
+}
+var errorPoolIndex = 0;
+function getErrorFromPool(message) {
+  const error = errorPool[errorPoolIndex];
+  error.message = message;
+  errorPoolIndex = (errorPoolIndex + 1) % ERROR_POOL_SIZE;
+  return error;
+}
+function getPooledString(key) {
+  let pooled = errorMessagePool.get(key);
+  if (!pooled) {
+    pooled = key;
+    errorMessagePool.set(key, key);
+  }
+  return pooled;
+}
+function getUltraSchemaCompiler(schema) {
+  let compiler = ultraSchemaCache.get(schema);
+  if (compiler) {
+    schemaCacheHits.set(schema, (schemaCacheHits.get(schema) || 0) + 1);
+    return compiler;
+  }
+  try {
+    compiler = TypeCompiler.Compile(schema);
+    ultraSchemaCache.set(schema, compiler);
+    return compiler;
+  } catch (error) {
+    return null;
+  }
+}
+function getSchemaFlags(config) {
+  let flags = 0;
+  if (config.body) flags |= SCHEMA_FLAGS.BODY;
+  if (config.query) flags |= SCHEMA_FLAGS.QUERY;
+  if (config.params) flags |= SCHEMA_FLAGS.PARAMS;
+  if (config.headers) flags |= SCHEMA_FLAGS.HEADERS;
+  if (config.cookies) flags |= SCHEMA_FLAGS.COOKIES;
+  return flags;
+}
+function validateSchemaUltra(schema, data, context) {
+  if (!schema) return data;
+  try {
+    let compiler = ultraSchemaCache.get(schema);
+    if (!compiler) {
+      try {
+        compiler = TypeCompiler.Compile(schema);
+        ultraSchemaCache.set(schema, compiler);
+      } catch (error) {
+        const message = getPooledString(`${context}\u9A8C\u8BC1\u5931\u8D25: Schema\u7F16\u8BD1\u5931\u8D25`);
+        throw getErrorFromPool(message);
+      }
     }
-    // 数字/布尔 -> text/plain
-    if (typeof result === "number" || typeof result === "boolean") {
-        return new Response(String(result), {
-            headers: { "Content-Type": "text/plain; charset=utf-8" },
-        });
+    const result = compiler.Check(data);
+    if (!result) {
+      const message = getPooledString(`${context}\u9A8C\u8BC1\u5931\u8D25`);
+      throw getErrorFromPool(message);
     }
-    // 对象 -> 检查是否是 { data, status, headers } 格式
-    if (typeof result === "object") {
-        const obj = result;
-        if ("data" in obj && ("status" in obj || "headers" in obj)) {
-            const { data, status = 200, headers = {} } = obj;
-            if (data === null || data === undefined) {
-                return new Response(null, {
-                    status: status === 200 ? 204 : status,
-                    headers: headers,
-                });
-            }
-            if (typeof data === "string" ||
-                typeof data === "number" ||
-                typeof data === "boolean") {
-                return new Response(String(data), {
-                    status: status,
-                    headers: {
-                        "Content-Type": "text/plain; charset=utf-8",
-                        ...headers,
-                    },
-                });
-            }
-            return json(data, status, headers);
-        }
-        // 普通对象 -> JSON
-        return json(result);
+    return data;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("\u9A8C\u8BC1\u5931\u8D25")) {
+      throw error;
     }
-    // 其他类型 -> 204
+    const message = getPooledString(
+      `${context}\u9A8C\u8BC1\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+    );
+    throw getErrorFromPool(message);
+  }
+}
+function validateAllSchemasUltra(config, data) {
+  const flags = getSchemaFlags(config);
+  if (flags & SCHEMA_FLAGS.BODY) {
+    validateSchemaUltra(config.body, data.body, "\u8BF7\u6C42\u4F53");
+  }
+  if (flags & SCHEMA_FLAGS.QUERY) {
+    validateSchemaUltra(config.query, data.query, "Query\u53C2\u6570");
+  }
+  if (flags & SCHEMA_FLAGS.PARAMS) {
+    validateSchemaUltra(config.params, data.params, "\u8DEF\u5F84\u53C2\u6570");
+  }
+  if (flags & SCHEMA_FLAGS.HEADERS) {
+    validateSchemaUltra(config.headers, data.headers, "\u8BF7\u6C42\u5934");
+  }
+  if (flags & SCHEMA_FLAGS.COOKIES) {
+    validateSchemaUltra(config.cookies, data.cookies, "Cookie");
+  }
+  return data;
+}
+function precompileSchemasUltra(config) {
+  const flags = getSchemaFlags(config);
+  if (flags & SCHEMA_FLAGS.BODY && config.body) {
+    getUltraSchemaCompiler(config.body);
+  }
+  if (flags & SCHEMA_FLAGS.QUERY && config.query) {
+    getUltraSchemaCompiler(config.query);
+  }
+  if (flags & SCHEMA_FLAGS.PARAMS && config.params) {
+    getUltraSchemaCompiler(config.params);
+  }
+  if (flags & SCHEMA_FLAGS.HEADERS && config.headers) {
+    getUltraSchemaCompiler(config.headers);
+  }
+  if (flags & SCHEMA_FLAGS.COOKIES && config.cookies) {
+    getUltraSchemaCompiler(config.cookies);
+  }
+}
+
+// src/utils/create-handler.ts
+function autoResponse(result) {
+  if (result instanceof Response) {
+    return result;
+  }
+  if (result === null || result === void 0) {
     return new Response(null, { status: 204 });
+  }
+  if (typeof result === "string") {
+    return new Response(result, {
+      headers: { "Content-Type": "text/plain; charset=utf-8" }
+    });
+  }
+  if (typeof result === "number" || typeof result === "boolean") {
+    return new Response(String(result), {
+      headers: { "Content-Type": "text/plain; charset=utf-8" }
+    });
+  }
+  if (typeof result === "object") {
+    const obj = result;
+    if ("data" in obj && ("status" in obj || "headers" in obj)) {
+      const { data, status = 200, headers = {} } = obj;
+      if (data === null || data === void 0) {
+        return new Response(null, {
+          status: status === 200 ? 204 : status,
+          headers
+        });
+      }
+      if (typeof data === "string" || typeof data === "number" || typeof data === "boolean") {
+        return new Response(String(data), {
+          status,
+          headers: {
+            "Content-Type": "text/plain; charset=utf-8",
+            ...headers
+          }
+        });
+      }
+      return json(data, status, headers);
+    }
+    return json(result);
+  }
+  return new Response(null, { status: 204 });
 }
-/**
- * 处理验证错误
- */
 function handleValidationError(error) {
-    return json({
-        success: false,
-        error: "Validation Error",
-        message: error.message,
-        timestamp: new Date().toISOString(),
-    }, 400);
+  return json(
+    {
+      success: false,
+      error: "Validation Error",
+      message: error.message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    400
+  );
 }
-/**
- * 处理内部错误
- */
 function handleInternalError(error) {
-    return json({
-        success: false,
-        error: "Internal Error",
-        message: error instanceof Error ? error.message : "未知错误",
-    }, 500);
+  return json(
+    {
+      success: false,
+      error: "Internal Error",
+      message: error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"
+    },
+    500
+  );
 }
-/**
- * 判断是否为 handler 函数
- */
 function isHandler(value) {
-    return typeof value === "function";
-}
-// 实现
-export function createHandler(schemaOrHandler, maybeHandler) {
-    // 判断调用方式
-    const hasSchema = !isHandler(schemaOrHandler);
-    const schema = hasSchema ? schemaOrHandler : {};
-    const handler = hasSchema
-        ? maybeHandler
-        : schemaOrHandler;
-    // 预编译 schema
-    if (schema.body ||
-        schema.query ||
-        schema.params ||
-        schema.headers ||
-        schema.cookies) {
-        precompileSchemasUltra(schema);
+  return typeof value === "function";
+}
+function createHandler(schemaOrHandler, maybeHandler) {
+  const hasSchema = !isHandler(schemaOrHandler);
+  const schema = hasSchema ? schemaOrHandler : {};
+  const handler = hasSchema ? maybeHandler : schemaOrHandler;
+  if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+    precompileSchemasUltra(schema);
+  }
+  return async (req) => {
+    try {
+      const query = parseQuery(req);
+      const headers = parseHeaders(req);
+      const cookies = parseCookies(req);
+      const params = req.params || {};
+      let body = void 0;
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        const [, parsedBody] = await goAwait(parseBody(req));
+        body = parsedBody;
+      }
+      const data = { body, query, params, headers, cookies };
+      if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+        validateAllSchemasUltra(schema, data);
+      }
+      const result = await handler({
+        req,
+        body,
+        query,
+        params,
+        headers,
+        cookies
+      });
+      return autoResponse(result);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("\u9A8C\u8BC1\u5931\u8D25")) {
+        return handleValidationError(error);
+      }
+      return handleInternalError(error);
+    }
+  };
+}
+function createHandlerWithExtra(schemaOrHandler, maybeHandler) {
+  const hasSchema = !isHandler(schemaOrHandler);
+  const schema = hasSchema ? schemaOrHandler : {};
+  const handler = hasSchema ? maybeHandler : schemaOrHandler;
+  if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+    precompileSchemasUltra(schema);
+  }
+  return async (req) => {
+    try {
+      const query = parseQuery(req);
+      const headers = parseHeaders(req);
+      const cookies = parseCookies(req);
+      const params = req.params || {};
+      let body = void 0;
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        const [, parsedBody] = await goAwait(parseBody(req));
+        body = parsedBody;
+      }
+      const data = { body, query, params, headers, cookies };
+      if (schema.body || schema.query || schema.params || schema.headers || schema.cookies) {
+        validateAllSchemasUltra(schema, data);
+      }
+      const extras = req.__locals ?? {};
+      const result = await handler({
+        req,
+        body,
+        query,
+        params,
+        headers,
+        cookies,
+        ...extras
+      });
+      return autoResponse(result);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("\u9A8C\u8BC1\u5931\u8D25")) {
+        return handleValidationError(error);
+      }
+      return handleInternalError(error);
     }
-    return async (req) => {
-        try {
-            // 解析请求数据
-            const query = parseQuery(req);
-            const headers = parseHeaders(req);
-            const cookies = parseCookies(req);
-            const params = req.params || {};
-            // 解析请求体
-            let body = undefined;
-            if (req.method !== "GET" && req.method !== "HEAD") {
-                const [, parsedBody] = await goAwait(parseBody(req));
-                body = parsedBody;
-            }
-            // 验证 schema
-            const data = { body, query, params, headers, cookies };
-            if (schema.body ||
-                schema.query ||
-                schema.params ||
-                schema.headers ||
-                schema.cookies) {
-                validateAllSchemasUltra(schema, data);
-            }
-            // 调用 handler
-            const result = await handler({
-                req,
-                body: body,
-                query: query,
-                params: params,
-                headers: headers,
-                cookies: cookies,
-            });
-            return autoResponse(result);
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes("验证失败")) {
-                return handleValidationError(error);
-            }
-            return handleInternalError(error);
-        }
-    };
-}
-// 实现
-export function createHandlerWithExtra(schemaOrHandler, maybeHandler) {
-    // 判断调用方式
-    const hasSchema = !isHandler(schemaOrHandler);
-    const schema = hasSchema ? schemaOrHandler : {};
-    const handler = hasSchema
-        ? maybeHandler
-        : schemaOrHandler;
-    // 预编译 schema
-    if (schema.body ||
-        schema.query ||
-        schema.params ||
-        schema.headers ||
-        schema.cookies) {
-        precompileSchemasUltra(schema);
+  };
+}
+function simpleHandler(handler) {
+  return async (req) => {
+    try {
+      const result = await handler({ req });
+      return autoResponse(result);
+    } catch (error) {
+      return handleInternalError(error);
     }
-    return async (req) => {
-        try {
-            // 解析请求数据
-            const query = parseQuery(req);
-            const headers = parseHeaders(req);
-            const cookies = parseCookies(req);
-            const params = req.params || {};
-            // 解析请求体
-            let body = undefined;
-            if (req.method !== "GET" && req.method !== "HEAD") {
-                const [, parsedBody] = await goAwait(parseBody(req));
-                body = parsedBody;
-            }
-            // 验证 schema
-            const data = { body, query, params, headers, cookies };
-            if (schema.body ||
-                schema.query ||
-                schema.params ||
-                schema.headers ||
-                schema.cookies) {
-                validateAllSchemasUltra(schema, data);
-            }
-            // 获取中间件注入的额外数据
-            const extras = (req.__locals ??
-                {});
-            // 调用 handler
-            const result = await handler({
-                req,
-                body: body,
-                query: query,
-                params: params,
-                headers: headers,
-                cookies: cookies,
-                ...extras,
-            });
-            return autoResponse(result);
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes("验证失败")) {
-                return handleValidationError(error);
-            }
-            return handleInternalError(error);
-        }
-    };
+  };
 }
+export {
+  createHandler,
+  createHandlerWithExtra,
+  simpleHandler
+};
 /**
- * 简单的路由处理器 (无 schema 验证，只有 req)
+ * Go 风格的错误处理工具
+ * 将 Promise 转换为 [Error | null, T | undefined] 格式
  *
- * @example
- * ```typescript
- * simpleHandler(({ req }) => {
- *   return { message: "Hello World" };
- * })
- * ```
+ * @author Framework Team
+ * @version 1.0.0
+ * @license MIT
  */
-export function simpleHandler(handler) {
-    return async (req) => {
-        try {
-            const result = await handler({ req });
-            return autoResponse(result);
-        }
-        catch (error) {
-            return handleInternalError(error);
-        }
-    };
-}
+/**
+ * 超优化版Schema验证器 v5.0.0
+ *
+ * 使用经过验证的优化技术，确保极致性能
+ * - 内联函数调用
+ * - 预编译缓存优化
+ * - 内存池优化
+ * - 位运算优化
+ * - 类型特化优化
+ * - 循环展开优化
+ * - 位掩码优化
+ * - 字符串池优化
+ * - 内联缓存优化
+ * - 内存对齐优化
+ *
+ * @author Framework Team
+ * @version 5.0.0
+ * @license MIT
+ */
+/**
+ * 类型安全的路由处理器工厂
+ *
+ * 非柯里化设计，API 更简洁
+ *
+ * @author Framework Team
+ * @version 3.0.0
+ * @license MIT
+ */
+//# sourceMappingURL=create-handler.js.map