h3 0.8.6 → 1.0.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Nuxt Contrib
+Copyright (c) Pooya Parsa <pooya@pi0.io>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -40,7 +40,7 @@ pnpm add h3
 
 ```ts
 import { createServer } from 'http'
-import { createApp, eventHandler } from 'h3'
+import { createApp, eventHandler, toNodeListener } from 'h3'
 
 const app = createApp()
 app.use('/', eventHandler(() => 'Hello world!'))
@@ -88,7 +88,7 @@ Routes are internally stored in a [Radix Tree](https://en.wikipedia.org/wiki/Rad
 
 ```js
 // Handle can directly return object or Promise<object> for JSON response
-app.use('/api', eventHandler((event) => ({ url: event.req.url }))
+app.use('/api', eventHandler((event) => ({ url: event.node.req.url }))
 
 // We can have better matching other than quick prefix match
 app.use('/odd', eventHandler(() => 'Is odd!'), { match: url => url.substr(1) % 2 })
@@ -137,6 +137,7 @@ H3 has concept of compasable utilities that accept `event` (from `eventHandler((
 - `assertMethod(event, expected, allowHead?)`
 - `createError({ statusCode, statusMessage, data? })`
 - `sendProxy(event, { target, headers?, fetchOptions?, fetch?, sendStream? })`
+- `proxyRequest(event, { target, headers?, fetchOptions?, fetch?, sendStream? })`
 
 👉 You can learn more about usage in [JSDocs Documentation](https://www.jsdocs.io/package/h3#package-functions).
 
@@ -146,6 +147,8 @@ More composable utilities can be found in community packages.
 
 - `validateBody(event, schema)` from [h3-typebox](https://github.com/kevinmarrec/h3-typebox)
 - `validateQuery(event, schema)` from [h3-typebox](https://github.com/kevinmarrec/h3-typebox)
+- `useValidatedBody(event, schema)` from [h3-zod](https://github.com/wobsoriano/h3-zod)
+- `useValidatedQuery(event, schema)` from [h3-zod](https://github.com/wobsoriano/h3-zod)
 
 ## License
 

package/dist/index.cjs

@@ -11,8 +11,8 @@ function useBase(base, handler) {
     return handler;
   }
   return eventHandler((event) => {
-    event.req.originalUrl = event.req.originalUrl || event.req.url || "/";
-    event.req.url = ufo.withoutBase(event.req.url || "/", base);
+    event.node.req.originalUrl = event.node.req.originalUrl || event.node.req.url || "/";
+    event.node.req.url = ufo.withoutBase(event.node.req.url || "/", base);
     return handler(event);
   });
 }
@@ -82,7 +82,7 @@ function createError(input) {
   return err;
 }
 function sendError(event, error, debug) {
-  if (event.res.writableEnded) {
+  if (event.node.res.writableEnded) {
     return;
   }
   const h3Error = isError(error) ? error : createError(error);
@@ -95,27 +95,26 @@ function sendError(event, error, debug) {
   if (debug) {
     responseBody.stack = (h3Error.stack || "").split("\n").map((l) => l.trim());
   }
-  if (event.res.writableEnded) {
+  if (event.node.res.writableEnded) {
     return;
   }
-  const _code = parseInt(h3Error.statusCode);
+  const _code = Number.parseInt(h3Error.statusCode);
   if (_code) {
-    event.res.statusCode = _code;
+    event.node.res.statusCode = _code;
   }
   if (h3Error.statusMessage) {
-    event.res.statusMessage = h3Error.statusMessage;
+    event.node.res.statusMessage = h3Error.statusMessage;
   }
-  event.res.setHeader("content-type", MIMES.json);
-  event.res.end(JSON.stringify(responseBody, null, 2));
+  event.node.res.setHeader("content-type", MIMES.json);
+  event.node.res.end(JSON.stringify(responseBody, void 0, 2));
 }
 function isError(input) {
   return input?.constructor?.__h3_error__ === true;
 }
 
 function getQuery(event) {
-  return ufo.getQuery(event.req.url || "");
+  return ufo.getQuery(event.node.req.url || "");
 }
-const useQuery = getQuery;
 function getRouterParams(event) {
   return event.context.params || {};
 }
@@ -124,9 +123,8 @@ function getRouterParam(event, name) {
   return params[name];
 }
 function getMethod(event, defaultMethod = "GET") {
-  return (event.req.method || defaultMethod).toUpperCase();
+  return (event.node.req.method || defaultMethod).toUpperCase();
 }
-const useMethod = getMethod;
 function isMethod(event, expected, allowHead) {
   const method = getMethod(event);
   if (allowHead && method === "HEAD") {
@@ -151,8 +149,8 @@ function assertMethod(event, expected, allowHead) {
 }
 function getRequestHeaders(event) {
   const _headers = {};
-  for (const key in event.req.headers) {
-    const val = event.req.headers[key];
+  for (const key in event.node.req.headers) {
+    const val = event.node.req.headers[key];
     _headers[key] = Array.isArray(val) ? val.filter(Boolean).join(", ") : val;
   }
   return _headers;
@@ -167,22 +165,22 @@ const getHeader = getRequestHeader;
 
 const RawBodySymbol = Symbol.for("h3RawBody");
 const ParsedBodySymbol = Symbol.for("h3ParsedBody");
-const PayloadMethods = ["PATCH", "POST", "PUT", "DELETE"];
-function readRawBody(event, encoding = "utf-8") {
-  assertMethod(event, PayloadMethods);
-  if (RawBodySymbol in event.req) {
-    const promise2 = Promise.resolve(event.req[RawBodySymbol]);
+const PayloadMethods$1 = ["PATCH", "POST", "PUT", "DELETE"];
+function readRawBody(event, encoding = "utf8") {
+  assertMethod(event, PayloadMethods$1);
+  if (RawBodySymbol in event.node.req) {
+    const promise2 = Promise.resolve(event.node.req[RawBodySymbol]);
     return encoding ? promise2.then((buff) => buff.toString(encoding)) : promise2;
   }
-  if ("body" in event.req) {
-    return Promise.resolve(event.req.body);
+  if ("body" in event.node.req) {
+    return Promise.resolve(event.node.req.body);
   }
-  if (!parseInt(event.req.headers["content-length"] || "")) {
+  if (!Number.parseInt(event.node.req.headers["content-length"] || "")) {
     return Promise.resolve(void 0);
   }
-  const promise = event.req[RawBodySymbol] = new Promise((resolve, reject) => {
+  const promise = event.node.req[RawBodySymbol] = new Promise((resolve, reject) => {
     const bodyData = [];
-    event.req.on("error", (err) => {
+    event.node.req.on("error", (err) => {
       reject(err);
     }).on("data", (chunk) => {
       bodyData.push(chunk);
@@ -192,49 +190,45 @@ function readRawBody(event, encoding = "utf-8") {
   });
   return encoding ? promise.then((buff) => buff.toString(encoding)) : promise;
 }
-const useRawBody = readRawBody;
 async function readBody(event) {
-  if (ParsedBodySymbol in event.req) {
-    return event.req[ParsedBodySymbol];
+  if (ParsedBodySymbol in event.node.req) {
+    return event.node.req[ParsedBodySymbol];
   }
   const body = await readRawBody(event);
-  if (event.req.headers["content-type"] === "application/x-www-form-urlencoded") {
+  if (event.node.req.headers["content-type"] === "application/x-www-form-urlencoded") {
     const parsedForm = Object.fromEntries(new URLSearchParams(body));
     return parsedForm;
   }
   const json = destr(body);
-  event.req[ParsedBodySymbol] = json;
+  event.node.req[ParsedBodySymbol] = json;
   return json;
 }
-const useBody = readBody;
 
 function handleCacheHeaders(event, opts) {
-  const cacheControls = ["public"].concat(opts.cacheControls || []);
+  const cacheControls = ["public", ...opts.cacheControls || []];
   let cacheMatched = false;
   if (opts.maxAge !== void 0) {
     cacheControls.push(`max-age=${+opts.maxAge}`, `s-maxage=${+opts.maxAge}`);
   }
   if (opts.modifiedTime) {
     const modifiedTime = new Date(opts.modifiedTime);
-    const ifModifiedSince = event.req.headers["if-modified-since"];
-    event.res.setHeader("last-modified", modifiedTime.toUTCString());
-    if (ifModifiedSince) {
-      if (new Date(ifModifiedSince) >= opts.modifiedTime) {
-        cacheMatched = true;
-      }
+    const ifModifiedSince = event.node.req.headers["if-modified-since"];
+    event.node.res.setHeader("last-modified", modifiedTime.toUTCString());
+    if (ifModifiedSince && new Date(ifModifiedSince) >= opts.modifiedTime) {
+      cacheMatched = true;
     }
   }
   if (opts.etag) {
-    event.res.setHeader("etag", opts.etag);
-    const ifNonMatch = event.req.headers["if-none-match"];
+    event.node.res.setHeader("etag", opts.etag);
+    const ifNonMatch = event.node.req.headers["if-none-match"];
     if (ifNonMatch === opts.etag) {
       cacheMatched = true;
     }
   }
-  event.res.setHeader("cache-control", cacheControls.join(", "));
+  event.node.res.setHeader("cache-control", cacheControls.join(", "));
   if (cacheMatched) {
-    event.res.statusCode = 304;
-    event.res.end();
+    event.node.res.statusCode = 304;
+    event.node.res.end();
     return true;
   }
   return false;
@@ -252,51 +246,55 @@ function send(event, data, type) {
   }
   return new Promise((resolve) => {
     defer(() => {
-      event.res.end(data);
-      resolve(void 0);
+      event.node.res.end(data);
+      resolve();
     });
   });
 }
 function defaultContentType(event, type) {
-  if (type && !event.res.getHeader("content-type")) {
-    event.res.setHeader("content-type", type);
+  if (type && !event.node.res.getHeader("content-type")) {
+    event.node.res.setHeader("content-type", type);
   }
 }
 function sendRedirect(event, location, code = 302) {
-  event.res.statusCode = code;
-  event.res.setHeader("location", location);
+  event.node.res.statusCode = code;
+  event.node.res.setHeader("location", location);
   const encodedLoc = location.replace(/"/g, "%22");
   const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${encodedLoc}"></head></html>`;
   return send(event, html, MIMES.html);
 }
 function getResponseHeaders(event) {
-  return event.res.getHeaders();
+  return event.node.res.getHeaders();
 }
 function getResponseHeader(event, name) {
-  return event.res.getHeader(name);
+  return event.node.res.getHeader(name);
 }
 function setResponseHeaders(event, headers) {
-  Object.entries(headers).forEach(([name, value]) => event.res.setHeader(name, value));
+  for (const [name, value] of Object.entries(headers)) {
+    event.node.res.setHeader(name, value);
+  }
 }
 const setHeaders = setResponseHeaders;
 function setResponseHeader(event, name, value) {
-  event.res.setHeader(name, value);
+  event.node.res.setHeader(name, value);
 }
 const setHeader = setResponseHeader;
 function appendResponseHeaders(event, headers) {
-  Object.entries(headers).forEach(([name, value]) => appendResponseHeader(event, name, value));
+  for (const [name, value] of Object.entries(headers)) {
+    appendResponseHeader(event, name, value);
+  }
 }
 const appendHeaders = appendResponseHeaders;
 function appendResponseHeader(event, name, value) {
-  let current = event.res.getHeader(name);
+  let current = event.node.res.getHeader(name);
   if (!current) {
-    event.res.setHeader(name, value);
+    event.node.res.setHeader(name, value);
     return;
   }
   if (!Array.isArray(current)) {
     current = [current.toString()];
   }
-  event.res.setHeader(name, current.concat(value));
+  event.node.res.setHeader(name, [...current, value]);
 }
 const appendHeader = appendResponseHeader;
 function isStream(data) {
@@ -304,15 +302,15 @@ function isStream(data) {
 }
 function sendStream(event, data) {
   return new Promise((resolve, reject) => {
-    data.pipe(event.res);
-    data.on("end", () => resolve(void 0));
+    data.pipe(event.node.res);
+    data.on("end", () => resolve());
     data.on("error", (error) => reject(createError(error)));
   });
 }
 const noop = () => {
 };
 function writeEarlyHints(event, hints, cb = noop) {
-  if (!event.res.socket) {
+  if (!event.node.res.socket) {
     cb();
     return;
   }
@@ -323,7 +321,7 @@ function writeEarlyHints(event, hints, cb = noop) {
     hints.link = Array.isArray(hints.link) ? hints.link : hints.link.split(",");
   }
   const headers = Object.entries(hints).map((e) => [e[0].toLowerCase(), e[1]]);
-  if (!headers.length) {
+  if (headers.length === 0) {
     cb();
     return;
   }
@@ -339,19 +337,17 @@ Link: ${hints.link.join(", ")}`;
     hint += `\r
 ${header}: ${value}`;
   }
-  event.res.socket.write(`${hint}\r
+  event.node.res.socket.write(`${hint}\r
 \r
-`, "utf-8", cb);
+`, "utf8", cb);
 }
 
 function parseCookies(event) {
-  return cookieEs.parse(event.req.headers.cookie || "");
+  return cookieEs.parse(event.node.req.headers.cookie || "");
 }
-const useCookies = parseCookies;
 function getCookie(event, name) {
   return parseCookies(event)[name];
 }
-const useCookie = getCookie;
 function setCookie(event, name, value, serializeOptions) {
   const cookieStr = cookieEs.serialize(name, value, {
     path: "/",
@@ -366,6 +362,43 @@ function deleteCookie(event, name, serializeOptions) {
   });
 }
 
+const PayloadMethods = /* @__PURE__ */ new Set(["PATCH", "POST", "PUT", "DELETE"]);
+const ignoredHeaders = /* @__PURE__ */ new Set([
+  "transfer-encoding",
+  "connection",
+  "keep-alive",
+  "upgrade",
+  "expect"
+]);
+async function proxyRequest(event, target, opts = {}) {
+  const method = getMethod(event);
+  let body;
+  if (PayloadMethods.has(method)) {
+    body = await readRawBody(event).catch(() => void 0);
+  }
+  const headers = /* @__PURE__ */ Object.create(null);
+  const reqHeaders = getRequestHeaders(event);
+  for (const name in reqHeaders) {
+    if (!ignoredHeaders.has(name)) {
+      headers[name] = reqHeaders[name];
+    }
+  }
+  if (opts.fetchOptions?.headers) {
+    Object.assign(headers, opts.fetchOptions.headers);
+  }
+  if (opts.headers) {
+    Object.assign(headers, opts.headers);
+  }
+  return sendProxy(event, target, {
+    ...opts,
+    fetchOptions: {
+      headers,
+      method,
+      body,
+      ...opts.fetchOptions
+    }
+  });
+}
 async function sendProxy(event, target, opts = {}) {
   const _fetch = opts.fetch || globalThis.fetch;
   if (!_fetch) {
@@ -375,8 +408,8 @@ async function sendProxy(event, target, opts = {}) {
     headers: opts.headers,
     ...opts.fetchOptions
   });
-  event.res.statusCode = response.status;
-  event.res.statusMessage = response.statusText;
+  event.node.res.statusCode = response.status;
+  event.node.res.statusMessage = response.statusText;
   for (const [key, value] of response.headers.entries()) {
     if (key === "content-encoding") {
       continue;
@@ -384,23 +417,23 @@ async function sendProxy(event, target, opts = {}) {
     if (key === "content-length") {
       continue;
     }
-    event.res.setHeader(key, value);
+    event.node.res.setHeader(key, value);
   }
   try {
     if (response.body) {
       if (opts.sendStream === false) {
         const data = new Uint8Array(await response.arrayBuffer());
-        event.res.end(data);
+        event.node.res.end(data);
       } else {
         for await (const chunk of response.body) {
-          event.res.write(chunk);
+          event.node.res.write(chunk);
         }
-        event.res.end();
+        event.node.res.end();
       }
     }
-  } catch (err) {
-    event.res.end();
-    throw err;
+  } catch (error) {
+    event.node.res.end();
+    throw error;
   }
 }
 
@@ -411,7 +444,7 @@ class H3Headers {
     } else if (Array.isArray(init)) {
       this._headers = Object.fromEntries(init.map(([key, value]) => [key.toLowerCase(), value]));
     } else if (init && "append" in init) {
-      this._headers = Object.fromEntries([...init.entries()]);
+      this._headers = Object.fromEntries(init.entries());
     } else {
       this._headers = Object.fromEntries(Object.entries(init).map(([key, value]) => [key.toLowerCase(), value]));
     }
@@ -445,7 +478,9 @@ class H3Headers {
     this._headers[name.toLowerCase()] = String(value);
   }
   forEach(callbackfn) {
-    Object.entries(this._headers).forEach(([key, value]) => callbackfn(value, key, this));
+    for (const [key, value] of Object.entries(this._headers)) {
+      callbackfn(value, key, this);
+    }
   }
 }
 
@@ -490,8 +525,16 @@ class H3Event {
   constructor(req, res) {
     this["__is_event__"] = true;
     this.context = {};
-    this.req = req;
-    this.res = res;
+    this.node = { req, res };
+  }
+  get path() {
+    return this.req.url;
+  }
+  get req() {
+    return this.node.req;
+  }
+  get res() {
+    return this.node.res;
   }
   respondWith(r) {
     Promise.resolve(r).then((_response) => {
@@ -499,9 +542,9 @@ class H3Event {
         return;
       }
       const response = _response instanceof H3Response ? _response : new H3Response(_response);
-      response.headers.forEach((value, key) => {
+      for (const [key, value] of response.headers.entries()) {
         this.res.setHeader(key, value);
-      });
+      }
       if (response.status) {
         this.res.statusCode = response.status;
       }
@@ -604,9 +647,13 @@ function createApp(options = {}) {
 }
 function use(app, arg1, arg2, arg3) {
   if (Array.isArray(arg1)) {
-    arg1.forEach((i) => use(app, i, arg2, arg3));
+    for (const i of arg1) {
+      use(app, i, arg2, arg3);
+    }
   } else if (Array.isArray(arg2)) {
-    arg2.forEach((i) => use(app, arg1, i, arg3));
+    for (const i of arg2) {
+      use(app, arg1, i, arg3);
+    }
   } else if (typeof arg1 === "string") {
     app.stack.push(normalizeLayer({ ...arg3, route: arg1, handler: arg2 }));
   } else if (typeof arg1 === "function") {
@@ -619,22 +666,22 @@ function use(app, arg1, arg2, arg3) {
 function createAppEventHandler(stack, options) {
   const spacing = options.debug ? 2 : void 0;
   return eventHandler(async (event) => {
-    event.req.originalUrl = event.req.originalUrl || event.req.url || "/";
-    const reqUrl = event.req.url || "/";
+    event.node.req.originalUrl = event.node.req.originalUrl || event.node.req.url || "/";
+    const reqUrl = event.node.req.url || "/";
     for (const layer of stack) {
       if (layer.route.length > 1) {
         if (!reqUrl.startsWith(layer.route)) {
           continue;
         }
-        event.req.url = reqUrl.slice(layer.route.length) || "/";
+        event.node.req.url = reqUrl.slice(layer.route.length) || "/";
       } else {
-        event.req.url = reqUrl;
+        event.node.req.url = reqUrl;
       }
-      if (layer.match && !layer.match(event.req.url, event)) {
+      if (layer.match && !layer.match(event.node.req.url, event)) {
         continue;
       }
       const val = await layer.handler(event);
-      if (event.res.writableEnded) {
+      if (event.node.res.writableEnded) {
         return;
       }
       const type = typeof val;
@@ -643,7 +690,7 @@ function createAppEventHandler(stack, options) {
       } else if (isStream(val)) {
         return sendStream(event, val);
       } else if (val === null) {
-        event.res.statusCode = 204;
+        event.node.res.statusCode = 204;
         return send(event);
       } else if (type === "object" || type === "boolean" || type === "number") {
         if (val.buffer) {
@@ -651,14 +698,14 @@ function createAppEventHandler(stack, options) {
         } else if (val instanceof Error) {
           throw createError(val);
         } else {
-          return send(event, JSON.stringify(val, null, spacing), MIMES.json);
+          return send(event, JSON.stringify(val, void 0, spacing), MIMES.json);
         }
       }
     }
-    if (!event.res.writableEnded) {
+    if (!event.node.res.writableEnded) {
       throw createError({
         statusCode: 404,
-        statusMessage: `Cannot find any route matching ${event.req.url || "/"}.`
+        statusMessage: `Cannot find any route matching ${event.node.req.url || "/"}.`
       });
     }
   });
@@ -671,7 +718,7 @@ function normalizeLayer(input) {
   if (input.lazy) {
     handler = lazyEventHandler(handler);
   } else if (!isEventHandler(handler)) {
-    handler = toEventHandler(handler, null, input.route);
+    handler = toEventHandler(handler, void 0, input.route);
   }
   return {
     route: ufo.withoutTrailingSlash(input.route),
@@ -690,7 +737,7 @@ function fromNodeMiddleware(handler) {
     throw new TypeError("Invalid handler. It should be a function:", handler);
   }
   return eventHandler((event) => {
-    return callNodeListener(handler, event.req, event.res);
+    return callNodeListener(handler, event.node.req, event.node.res);
   });
 }
 function toNodeListener(app) {
@@ -738,8 +785,8 @@ function callNodeListener(handler, req, res) {
       } else {
         resolve(returned);
       }
-    } catch (err) {
-      next(err);
+    } catch (error) {
+      next(error);
     }
   });
 }
@@ -756,9 +803,11 @@ function createRouter(opts = {}) {
       _router.insert(path, route);
     }
     if (Array.isArray(method)) {
-      method.forEach((m) => addRoute(path, handler, m));
+      for (const m of method) {
+        addRoute(path, handler, m);
+      }
     } else {
-      route.handlers[method] = toEventHandler(handler, null, path);
+      route.handlers[method] = toEventHandler(handler, void 0, path);
     }
     return router;
   };
@@ -767,10 +816,10 @@ function createRouter(opts = {}) {
     router[method] = (path, handle) => router.add(path, handle, method);
   }
   router.handler = eventHandler((event) => {
-    let path = event.req.url || "/";
+    let path = event.node.req.url || "/";
     const qIndex = path.indexOf("?");
     if (qIndex !== -1) {
-      path = path.substring(0, qIndex);
+      path = path.slice(0, Math.max(0, qIndex));
     }
     const matched = _router.lookup(path);
     if (!matched) {
@@ -778,13 +827,13 @@ function createRouter(opts = {}) {
         throw createError({
           statusCode: 404,
           name: "Not Found",
-          statusMessage: `Cannot find any route matching ${event.req.url || "/"}.`
+          statusMessage: `Cannot find any route matching ${event.node.req.url || "/"}.`
         });
       } else {
         return;
       }
     }
-    const method = (event.req.method || "get").toLowerCase();
+    const method = (event.node.req.method || "get").toLowerCase();
     const handler = matched.handlers[method] || matched.handlers.all;
     if (!handler) {
       throw createError({
@@ -845,6 +894,7 @@ exports.isStream = isStream;
 exports.lazyEventHandler = lazyEventHandler;
 exports.parseCookies = parseCookies;
 exports.promisifyNodeListener = promisifyNodeListener;
+exports.proxyRequest = proxyRequest;
 exports.readBody = readBody;
 exports.readRawBody = readRawBody;
 exports.send = send;
@@ -861,10 +911,4 @@ exports.toEventHandler = toEventHandler;
 exports.toNodeListener = toNodeListener;
 exports.use = use;
 exports.useBase = useBase;
-exports.useBody = useBody;
-exports.useCookie = useCookie;
-exports.useCookies = useCookies;
-exports.useMethod = useMethod;
-exports.useQuery = useQuery;
-exports.useRawBody = useRawBody;
 exports.writeEarlyHints = writeEarlyHints;