h3 0.5.1 → 0.5.4

package/dist/index.cjs

@@ -11,114 +11,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 const destr__default = /*#__PURE__*/_interopDefaultLegacy(destr);
 
-const defineHandler = (handler) => handler;
-const defineHandle = defineHandler;
-const defineMiddleware = (middleware) => middleware;
-function promisifyHandler(handler) {
-  return function(req, res) {
-    return callHandler(handler, req, res);
-  };
-}
-const promisifyHandle = promisifyHandler;
-function callHandler(handler, req, res) {
-  return new Promise((resolve, reject) => {
-    const next = (err) => err ? reject(err) : resolve(void 0);
-    try {
-      return resolve(handler(req, res, next));
-    } catch (err) {
-      next(err);
-    }
-  });
-}
-function defineLazyHandler(handler, promisify) {
-  let _promise;
-  const resolve = () => {
-    if (!_promise) {
-      _promise = Promise.resolve(handler()).then((r) => promisify ? promisifyHandler(r.default || r) : r.default || r);
-    }
-    return _promise;
-  };
-  return function(req, res) {
-    return resolve().then((h) => h(req, res));
-  };
-}
-const lazyHandle = defineLazyHandler;
-function useBase(base, handler) {
-  base = ufo.withoutTrailingSlash(base);
-  if (!base) {
-    return handler;
-  }
-  return function(req, res) {
-    req.originalUrl = req.originalUrl || req.url || "/";
-    req.url = ufo.withoutBase(req.url || "/", base);
-    return handler(req, res);
-  };
-}
-
-function defineEventHandler(handler) {
-  handler.__is_handler__ = true;
-  return handler;
-}
-function defineLazyEventHandler(factory) {
-  let _promise;
-  let _resolved;
-  const resolveHandler = () => {
-    if (_resolved) {
-      return Promise.resolve(_resolved);
-    }
-    if (!_promise) {
-      _promise = Promise.resolve(factory()).then((r) => {
-        const handler = r.default || r;
-        if (typeof handler !== "function") {
-          throw new TypeError("Invalid lazy handler result. It should be a function:", handler);
-        }
-        _resolved = toEventHandler(r.default || r);
-        return _resolved;
-      });
-    }
-    return _promise;
-  };
-  return defineEventHandler((event) => {
-    if (_resolved) {
-      return _resolved(event);
-    }
-    return resolveHandler().then((handler) => handler(event));
-  });
-}
-function isEventHandler(input) {
-  return "__is_handler__" in input;
-}
-function toEventHandler(handler) {
-  if (isEventHandler(handler)) {
-    return handler;
-  }
-  if (typeof handler !== "function") {
-    throw new TypeError("Invalid handler. It should be a function:", handler);
-  }
-  return defineEventHandler((event) => {
-    return callHandler(handler, event.req, event.res);
-  });
-}
-function createEvent(req, res) {
-  const event = {
-    __is_event__: true,
-    req,
-    res
-  };
-  event.event = event;
-  req.event = event;
-  req.req = req;
-  req.res = res;
-  res.event = event;
-  res.res = res;
-  res.req.res = res;
-  res.req.req = req;
-  return event;
-}
-function isEvent(input) {
-  return "__is_event__" in input;
-}
-
 function useQuery(event) {
   return ufo.getQuery(event.req.url || "");
 }
@@ -177,6 +69,10 @@ async function useBody(event) {
     return event.req[ParsedBodySymbol];
   }
   const body = await useRawBody(event);
+  if (event.req.headers["content-type"] === "application/x-www-form-urlencoded") {
+    const parsedForm = Object.fromEntries(new URLSearchParams(body));
+    return parsedForm;
+  }
   const json = destr__default(body);
   event.req[ParsedBodySymbol] = json;
   return json;
@@ -272,30 +168,152 @@ function createError(input) {
   return err;
 }
 function sendError(event, error, debug) {
-  let h3Error;
-  if (error instanceof H3Error) {
-    h3Error = error;
-  } else {
-    console.error(error);
-    h3Error = createError(error);
-  }
   if (event.res.writableEnded) {
     return;
   }
-  event.res.statusCode = h3Error.statusCode;
-  event.res.statusMessage = h3Error.statusMessage;
+  const h3Error = isError(error) ? error : createError(error);
   const responseBody = {
-    statusCode: event.res.statusCode,
-    statusMessage: event.res.statusMessage,
+    statusCode: h3Error.statusCode,
+    statusMessage: h3Error.statusMessage,
     stack: [],
     data: h3Error.data
   };
   if (debug) {
     responseBody.stack = (h3Error.stack || "").split("\n").map((l) => l.trim());
   }
+  if (event.res.writableEnded) {
+    return;
+  }
+  event.res.statusCode = h3Error.statusCode;
+  event.res.statusMessage = h3Error.statusMessage;
   event.res.setHeader("Content-Type", MIMES.json);
   event.res.end(JSON.stringify(responseBody, null, 2));
 }
+function isError(input) {
+  return input instanceof H3Error;
+}
+
+const defineHandler = (handler) => handler;
+const defineHandle = defineHandler;
+const defineMiddleware = (middleware) => middleware;
+function promisifyHandler(handler) {
+  return function(req, res) {
+    return callHandler(handler, req, res);
+  };
+}
+const promisifyHandle = promisifyHandler;
+function callHandler(handler, req, res) {
+  const isMiddleware = handler.length > 2;
+  return new Promise((resolve, reject) => {
+    const next = (err) => {
+      if (isMiddleware) {
+        res.off("close", next);
+        res.off("error", next);
+      }
+      return err ? reject(createError(err)) : resolve(void 0);
+    };
+    try {
+      const returned = handler(req, res, next);
+      if (isMiddleware && returned === void 0) {
+        res.once("close", next);
+        res.once("error", next);
+      } else {
+        resolve(returned);
+      }
+    } catch (err) {
+      next(err);
+    }
+  });
+}
+function defineLazyHandler(handler, promisify) {
+  let _promise;
+  const resolve = () => {
+    if (!_promise) {
+      _promise = Promise.resolve(handler()).then((r) => promisify ? promisifyHandler(r.default || r) : r.default || r);
+    }
+    return _promise;
+  };
+  return function(req, res) {
+    return resolve().then((h) => h(req, res));
+  };
+}
+const lazyHandle = defineLazyHandler;
+function useBase(base, handler) {
+  base = ufo.withoutTrailingSlash(base);
+  if (!base) {
+    return handler;
+  }
+  return function(req, res) {
+    req.originalUrl = req.originalUrl || req.url || "/";
+    req.url = ufo.withoutBase(req.url || "/", base);
+    return handler(req, res);
+  };
+}
+
+function defineEventHandler(handler) {
+  handler.__is_handler__ = true;
+  return handler;
+}
+function defineLazyEventHandler(factory) {
+  let _promise;
+  let _resolved;
+  const resolveHandler = () => {
+    if (_resolved) {
+      return Promise.resolve(_resolved);
+    }
+    if (!_promise) {
+      _promise = Promise.resolve(factory()).then((r) => {
+        const handler = r.default || r;
+        if (typeof handler !== "function") {
+          throw new TypeError("Invalid lazy handler result. It should be a function:", handler);
+        }
+        _resolved = toEventHandler(r.default || r);
+        return _resolved;
+      });
+    }
+    return _promise;
+  };
+  return defineEventHandler((event) => {
+    if (_resolved) {
+      return _resolved(event);
+    }
+    return resolveHandler().then((handler) => handler(event));
+  });
+}
+function isEventHandler(input) {
+  return "__is_handler__" in input;
+}
+function toEventHandler(handler) {
+  if (isEventHandler(handler)) {
+    return handler;
+  }
+  if (typeof handler !== "function") {
+    throw new TypeError("Invalid handler. It should be a function:", handler);
+  }
+  return defineEventHandler((event) => {
+    return callHandler(handler, event.req, event.res);
+  });
+}
+function createEvent(req, res) {
+  const event = {
+    __is_event__: true,
+    req,
+    res
+  };
+  event.event = event;
+  req.event = event;
+  req.req = req;
+  req.res = res;
+  res.event = event;
+  res.res = res;
+  res.req = res.req || {};
+  res.req.res = res;
+  res.req.req = req;
+  return event;
+}
+function isEvent(input) {
+  return "__is_event__" in input;
+}
 
 function createApp(options = {}) {
   const stack = [];
@@ -307,8 +325,12 @@ function createApp(options = {}) {
     } catch (err) {
       if (options.onError) {
         await options.onError(err, event);
+      } else {
+        if (!isError(err)) {
+          console.error("[h3]", err);
+        }
+        await sendError(event, err, !!options.debug);
       }
-      await sendError(event, err, !!options.debug);
     }
   };
   const app = nodeHandler;
@@ -456,6 +478,7 @@ exports.defineLazyEventHandler = defineLazyEventHandler;
 exports.defineLazyHandler = defineLazyHandler;
 exports.defineMiddleware = defineMiddleware;
 exports.deleteCookie = deleteCookie;
+exports.isError = isError;
 exports.isEvent = isEvent;
 exports.isEventHandler = isEventHandler;
 exports.isMethod = isMethod;

package/dist/index.d.ts

@@ -121,6 +121,7 @@ declare function createError(input: Partial<H3Error>): H3Error;
  *  In the debug mode the stack trace of errors will be return in response.
  */
 declare function sendError(event: CompatibilityEvent, error: Error | H3Error, debug?: boolean): void;
+declare function isError(input: any): input is H3Error;
 
 declare const defineHandler: <T>(handler: Handler<T, {}>) => Handler<T, {}>;
 /** @deprecated Use defineHandler */
@@ -224,4 +225,4 @@ interface Router extends AddRouteShortcuts {
 }
 declare function createRouter(): Router;
 
-export { AddRouteShortcuts, App, AppOptions, AppUse, CompatibilityEvent, CompatibilityEventHandler, Encoding, EventHandler, H3Error, H3Event, H3Response, HTTPMethod, Handler, IncomingMessage, InputLayer, InputStack, JSONValue, Layer, LazyEventHandler, LazyHandler, MIMES, Matcher, Middleware, NodeHandler, PromisifiedHandler, Router, RouterMethod, RouterUse, ServerResponse, Stack, _JSONValue, appendHeader, assertMethod, callHandler, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineHandle, defineHandler, defineLazyEventHandler, defineLazyHandler, defineMiddleware, deleteCookie, isEvent, isEventHandler, isMethod, isStream, lazyHandle, promisifyHandle, promisifyHandler, send, sendError, sendRedirect, sendStream, setCookie, toEventHandler, use, useBase, useBody, useCookie, useCookies, useMethod, useQuery, useRawBody };
+export { AddRouteShortcuts, App, AppOptions, AppUse, CompatibilityEvent, CompatibilityEventHandler, Encoding, EventHandler, H3Error, H3Event, H3Response, HTTPMethod, Handler, IncomingMessage, InputLayer, InputStack, JSONValue, Layer, LazyEventHandler, LazyHandler, MIMES, Matcher, Middleware, NodeHandler, PromisifiedHandler, Router, RouterMethod, RouterUse, ServerResponse, Stack, _JSONValue, appendHeader, assertMethod, callHandler, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineHandle, defineHandler, defineLazyEventHandler, defineLazyHandler, defineMiddleware, deleteCookie, isError, isEvent, isEventHandler, isMethod, isStream, lazyHandle, promisifyHandle, promisifyHandler, send, sendError, sendRedirect, sendStream, setCookie, toEventHandler, use, useBase, useBody, useCookie, useCookies, useMethod, useQuery, useRawBody };

package/dist/index.mjs

@@ -1,116 +1,8 @@
-import { withoutTrailingSlash, withoutBase, getQuery } from 'ufo';
+import { getQuery, withoutTrailingSlash, withoutBase } from 'ufo';
 import { createRouter as createRouter$1 } from 'radix3';
 import destr from 'destr';
 import { parse, serialize } from 'cookie-es';
 
-const defineHandler = (handler) => handler;
-const defineHandle = defineHandler;
-const defineMiddleware = (middleware) => middleware;
-function promisifyHandler(handler) {
-  return function(req, res) {
-    return callHandler(handler, req, res);
-  };
-}
-const promisifyHandle = promisifyHandler;
-function callHandler(handler, req, res) {
-  return new Promise((resolve, reject) => {
-    const next = (err) => err ? reject(err) : resolve(void 0);
-    try {
-      return resolve(handler(req, res, next));
-    } catch (err) {
-      next(err);
-    }
-  });
-}
-function defineLazyHandler(handler, promisify) {
-  let _promise;
-  const resolve = () => {
-    if (!_promise) {
-      _promise = Promise.resolve(handler()).then((r) => promisify ? promisifyHandler(r.default || r) : r.default || r);
-    }
-    return _promise;
-  };
-  return function(req, res) {
-    return resolve().then((h) => h(req, res));
-  };
-}
-const lazyHandle = defineLazyHandler;
-function useBase(base, handler) {
-  base = withoutTrailingSlash(base);
-  if (!base) {
-    return handler;
-  }
-  return function(req, res) {
-    req.originalUrl = req.originalUrl || req.url || "/";
-    req.url = withoutBase(req.url || "/", base);
-    return handler(req, res);
-  };
-}
-
-function defineEventHandler(handler) {
-  handler.__is_handler__ = true;
-  return handler;
-}
-function defineLazyEventHandler(factory) {
-  let _promise;
-  let _resolved;
-  const resolveHandler = () => {
-    if (_resolved) {
-      return Promise.resolve(_resolved);
-    }
-    if (!_promise) {
-      _promise = Promise.resolve(factory()).then((r) => {
-        const handler = r.default || r;
-        if (typeof handler !== "function") {
-          throw new TypeError("Invalid lazy handler result. It should be a function:", handler);
-        }
-        _resolved = toEventHandler(r.default || r);
-        return _resolved;
-      });
-    }
-    return _promise;
-  };
-  return defineEventHandler((event) => {
-    if (_resolved) {
-      return _resolved(event);
-    }
-    return resolveHandler().then((handler) => handler(event));
-  });
-}
-function isEventHandler(input) {
-  return "__is_handler__" in input;
-}
-function toEventHandler(handler) {
-  if (isEventHandler(handler)) {
-    return handler;
-  }
-  if (typeof handler !== "function") {
-    throw new TypeError("Invalid handler. It should be a function:", handler);
-  }
-  return defineEventHandler((event) => {
-    return callHandler(handler, event.req, event.res);
-  });
-}
-function createEvent(req, res) {
-  const event = {
-    __is_event__: true,
-    req,
-    res
-  };
-  event.event = event;
-  req.event = event;
-  req.req = req;
-  req.res = res;
-  res.event = event;
-  res.res = res;
-  res.req.res = res;
-  res.req.req = req;
-  return event;
-}
-function isEvent(input) {
-  return "__is_event__" in input;
-}
-
 function useQuery(event) {
   return getQuery(event.req.url || "");
 }
@@ -169,6 +61,10 @@ async function useBody(event) {
     return event.req[ParsedBodySymbol];
   }
   const body = await useRawBody(event);
+  if (event.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;
   return json;
@@ -264,30 +160,152 @@ function createError(input) {
   return err;
 }
 function sendError(event, error, debug) {
-  let h3Error;
-  if (error instanceof H3Error) {
-    h3Error = error;
-  } else {
-    console.error(error);
-    h3Error = createError(error);
-  }
   if (event.res.writableEnded) {
     return;
   }
-  event.res.statusCode = h3Error.statusCode;
-  event.res.statusMessage = h3Error.statusMessage;
+  const h3Error = isError(error) ? error : createError(error);
   const responseBody = {
-    statusCode: event.res.statusCode,
-    statusMessage: event.res.statusMessage,
+    statusCode: h3Error.statusCode,
+    statusMessage: h3Error.statusMessage,
     stack: [],
     data: h3Error.data
   };
   if (debug) {
     responseBody.stack = (h3Error.stack || "").split("\n").map((l) => l.trim());
   }
+  if (event.res.writableEnded) {
+    return;
+  }
+  event.res.statusCode = h3Error.statusCode;
+  event.res.statusMessage = h3Error.statusMessage;
   event.res.setHeader("Content-Type", MIMES.json);
   event.res.end(JSON.stringify(responseBody, null, 2));
 }
+function isError(input) {
+  return input instanceof H3Error;
+}
+
+const defineHandler = (handler) => handler;
+const defineHandle = defineHandler;
+const defineMiddleware = (middleware) => middleware;
+function promisifyHandler(handler) {
+  return function(req, res) {
+    return callHandler(handler, req, res);
+  };
+}
+const promisifyHandle = promisifyHandler;
+function callHandler(handler, req, res) {
+  const isMiddleware = handler.length > 2;
+  return new Promise((resolve, reject) => {
+    const next = (err) => {
+      if (isMiddleware) {
+        res.off("close", next);
+        res.off("error", next);
+      }
+      return err ? reject(createError(err)) : resolve(void 0);
+    };
+    try {
+      const returned = handler(req, res, next);
+      if (isMiddleware && returned === void 0) {
+        res.once("close", next);
+        res.once("error", next);
+      } else {
+        resolve(returned);
+      }
+    } catch (err) {
+      next(err);
+    }
+  });
+}
+function defineLazyHandler(handler, promisify) {
+  let _promise;
+  const resolve = () => {
+    if (!_promise) {
+      _promise = Promise.resolve(handler()).then((r) => promisify ? promisifyHandler(r.default || r) : r.default || r);
+    }
+    return _promise;
+  };
+  return function(req, res) {
+    return resolve().then((h) => h(req, res));
+  };
+}
+const lazyHandle = defineLazyHandler;
+function useBase(base, handler) {
+  base = withoutTrailingSlash(base);
+  if (!base) {
+    return handler;
+  }
+  return function(req, res) {
+    req.originalUrl = req.originalUrl || req.url || "/";
+    req.url = withoutBase(req.url || "/", base);
+    return handler(req, res);
+  };
+}
+
+function defineEventHandler(handler) {
+  handler.__is_handler__ = true;
+  return handler;
+}
+function defineLazyEventHandler(factory) {
+  let _promise;
+  let _resolved;
+  const resolveHandler = () => {
+    if (_resolved) {
+      return Promise.resolve(_resolved);
+    }
+    if (!_promise) {
+      _promise = Promise.resolve(factory()).then((r) => {
+        const handler = r.default || r;
+        if (typeof handler !== "function") {
+          throw new TypeError("Invalid lazy handler result. It should be a function:", handler);
+        }
+        _resolved = toEventHandler(r.default || r);
+        return _resolved;
+      });
+    }
+    return _promise;
+  };
+  return defineEventHandler((event) => {
+    if (_resolved) {
+      return _resolved(event);
+    }
+    return resolveHandler().then((handler) => handler(event));
+  });
+}
+function isEventHandler(input) {
+  return "__is_handler__" in input;
+}
+function toEventHandler(handler) {
+  if (isEventHandler(handler)) {
+    return handler;
+  }
+  if (typeof handler !== "function") {
+    throw new TypeError("Invalid handler. It should be a function:", handler);
+  }
+  return defineEventHandler((event) => {
+    return callHandler(handler, event.req, event.res);
+  });
+}
+function createEvent(req, res) {
+  const event = {
+    __is_event__: true,
+    req,
+    res
+  };
+  event.event = event;
+  req.event = event;
+  req.req = req;
+  req.res = res;
+  res.event = event;
+  res.res = res;
+  res.req = res.req || {};
+  res.req.res = res;
+  res.req.req = req;
+  return event;
+}
+function isEvent(input) {
+  return "__is_event__" in input;
+}
 
 function createApp(options = {}) {
   const stack = [];
@@ -299,8 +317,12 @@ function createApp(options = {}) {
     } catch (err) {
       if (options.onError) {
         await options.onError(err, event);
+      } else {
+        if (!isError(err)) {
+          console.error("[h3]", err);
+        }
+        await sendError(event, err, !!options.debug);
       }
-      await sendError(event, err, !!options.debug);
     }
   };
   const app = nodeHandler;
@@ -430,4 +452,4 @@ function createRouter() {
   return router;
 }
 
-export { H3Error, MIMES, appendHeader, assertMethod, callHandler, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineHandle, defineHandler, defineLazyEventHandler, defineLazyHandler, defineMiddleware, deleteCookie, isEvent, isEventHandler, isMethod, isStream, lazyHandle, promisifyHandle, promisifyHandler, send, sendError, sendRedirect, sendStream, setCookie, toEventHandler, use, useBase, useBody, useCookie, useCookies, useMethod, useQuery, useRawBody };
+export { H3Error, MIMES, appendHeader, assertMethod, callHandler, createApp, createAppEventHandler, createError, createEvent, createRouter, defaultContentType, defineEventHandler, defineHandle, defineHandler, defineLazyEventHandler, defineLazyHandler, defineMiddleware, deleteCookie, isError, isEvent, isEventHandler, isMethod, isStream, lazyHandle, promisifyHandle, promisifyHandler, send, sendError, sendRedirect, sendStream, setCookie, toEventHandler, use, useBase, useBody, useCookie, useCookies, useMethod, useQuery, useRawBody };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "h3",
-  "version": "0.5.1",
+  "version": "0.5.4",
   "description": "Tiny JavaScript Server",
   "repository": "unjs/h3",
   "license": "MIT",