keq 5.0.0-alpha.24 → 5.0.0-alpha.25

package/dist/index.js

@@ -67,11 +67,6 @@ __export(index_exports, {
   composeRoute: () => composeRoute,
   createProxyResponse: () => createProxyResponse,
   createRequest: () => createRequest,
-  keqHostRoute: () => keqHostRoute,
-  keqLocationRoute: () => keqLocationRoute,
-  keqMethodRoute: () => keqMethodRoute,
-  keqModuleRoute: () => keqModuleRoute,
-  keqPathnameRoute: () => keqPathnameRoute,
   request: () => request
 });
 module.exports = __toCommonJS(index_exports);
@@ -109,52 +104,54 @@ var TimeoutException = class extends AbortException {
 
 // src/exception/http-exceptions/request.exception.ts
 var RequestException = class extends Exception {
-  constructor(statusCode, message, retry = true) {
+  constructor(statusCode, message, options) {
     super(message);
     __publicField(this, "statusCode");
     __publicField(this, "retry");
+    __publicField(this, "response");
     this.statusCode = statusCode;
-    this.retry = retry;
+    this.retry = !(options == null ? void 0 : options.fatal);
+    this.response = options == null ? void 0 : options.response;
     Object.defineProperty(this, "name", { value: "RequestException" });
   }
 };
 
 // src/exception/http-exceptions/bad-request.exception.ts
 var BadRequestException = class extends RequestException {
-  constructor(message = "Bad Request", retry = false) {
-    super(400, message, retry);
+  constructor(message = "Bad Request", options) {
+    super(400, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", { value: "BadRequestException" });
   }
 };
 
 // src/exception/http-exceptions/unauthorized.exception.ts
 var UnauthorizedException = class extends RequestException {
-  constructor(message = "Unauthorized", retry = false) {
-    super(401, message, retry);
+  constructor(message = "Unauthorized", options) {
+    super(401, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", { value: "UnauthorizedException" });
   }
 };
 
 // src/exception/http-exceptions/forbidden.exception.ts
 var ForbiddenException = class extends RequestException {
-  constructor(message = "Forbidden", retry = false) {
-    super(403, message, retry);
+  constructor(message = "Forbidden", options) {
+    super(403, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", { value: "ForbiddenException" });
   }
 };
 
 // src/exception/http-exceptions/not-founded.exception.ts
 var NotFoundedException = class extends RequestException {
-  constructor(message = "Not Founded", retry = false) {
-    super(404, message, retry);
+  constructor(message = "Not Founded", options) {
+    super(404, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", { value: "NotFoundedException" });
   }
 };
 
 // src/exception/http-exceptions/method-not-allowed.exception.ts
 var MethodNotAllowedException = class extends RequestException {
-  constructor(message = "Method Not Allowed", retry = false) {
-    super(405, message, retry);
+  constructor(message = "Method Not Allowed", options) {
+    super(405, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", {
       value: "MethodNotAllowedException"
     });
@@ -163,16 +160,16 @@ var MethodNotAllowedException = class extends RequestException {
 
 // src/exception/http-exceptions/not-acceptable.exception.ts
 var NotAcceptableException = class extends RequestException {
-  constructor(message = "Not Acceptable", retry = false) {
-    super(406, message, retry);
+  constructor(message = "Not Acceptable", options) {
+    super(406, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", { value: "NotAcceptableException" });
   }
 };
 
 // src/exception/http-exceptions/proxy-authentication-required.exception.ts
 var ProxyAuthenticationRequiredException = class extends RequestException {
-  constructor(message = "Proxy Authentication Required", retry = false) {
-    super(407, message, retry);
+  constructor(message = "Proxy Authentication Required", options) {
+    super(407, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", {
       value: "ProxyAuthenticationRequiredException"
     });
@@ -181,8 +178,8 @@ var ProxyAuthenticationRequiredException = class extends RequestException {
 
 // src/exception/http-exceptions/request-timeout.exception.ts
 var RequestTimeoutException = class extends RequestException {
-  constructor(message = "Request Timeout", retry = true) {
-    super(408, message, retry);
+  constructor(message = "Request Timeout", options) {
+    super(408, message, { fatal: false, ...options });
     Object.defineProperty(this, "name", {
       value: "RequestTimeoutException"
     });
@@ -191,16 +188,16 @@ var RequestTimeoutException = class extends RequestException {
 
 // src/exception/http-exceptions/conflict.exception.ts
 var ConflictException = class extends RequestException {
-  constructor(message = "Conflict", retry = false) {
-    super(409, message, retry);
+  constructor(message = "Conflict", options) {
+    super(409, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", { value: "ConflictException" });
   }
 };
 
 // src/exception/http-exceptions/precondition-failed.exception.ts
 var PreconditionFailedException = class extends RequestException {
-  constructor(message = "Precondition Failed", retry = false) {
-    super(412, message, retry);
+  constructor(message = "Precondition Failed", options) {
+    super(412, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", {
       value: "PreconditionFailedException"
     });
@@ -209,8 +206,8 @@ var PreconditionFailedException = class extends RequestException {
 
 // src/exception/http-exceptions/content-too-large.exception.ts
 var ContentTooLargeException = class extends RequestException {
-  constructor(message = "Content Too Large", retry = false) {
-    super(413, message, retry);
+  constructor(message = "Content Too Large", options) {
+    super(413, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", {
       value: "ContentTooLargeException"
     });
@@ -219,40 +216,40 @@ var ContentTooLargeException = class extends RequestException {
 
 // src/exception/http-exceptions/uri-too-long.exception.ts
 var UriTooLongException = class extends RequestException {
-  constructor(message = "URI Too Long", retry = false) {
-    super(414, message, retry);
+  constructor(message = "URI Too Long", options) {
+    super(414, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", { value: "UriTooLongException" });
   }
 };
 
 // src/exception/http-exceptions/unsupported-media-type.exception.ts
 var UnsupportedMediaTypeException = class extends RequestException {
-  constructor(message = "Unsupported Media Type", retry = false) {
-    super(415, message, retry);
+  constructor(message = "Unsupported Media Type", options) {
+    super(415, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", { value: "UnsupportedMediaTypeException" });
   }
 };
 
 // src/exception/http-exceptions/im-a-teapot.exception.ts
 var ImATeapotException = class extends RequestException {
-  constructor(message = "I'm a teapot", retry = false) {
-    super(418, message, retry);
+  constructor(message = "I'm a teapot", options) {
+    super(418, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", { value: "ImATeapotException" });
   }
 };
 
 // src/exception/http-exceptions/too-many-requests.exception.ts
 var TooManyRequestsException = class extends RequestException {
-  constructor(message = "Too Many Requests", retry = true) {
-    super(429, message, retry);
+  constructor(message = "Too Many Requests", options) {
+    super(429, message, { fatal: false, ...options });
     Object.defineProperty(this, "name", { value: "TooManyRequestsException" });
   }
 };
 
 // src/exception/http-exceptions/internal-server-error.exception.ts
 var InternalServerErrorException = class extends RequestException {
-  constructor(message = "Internal Server Error", retry = true) {
-    super(500, message, retry);
+  constructor(message = "Internal Server Error", options) {
+    super(500, message, { fatal: false, ...options });
     Object.defineProperty(this, "name", {
       value: "InternalServerErrorException"
     });
@@ -261,24 +258,24 @@ var InternalServerErrorException = class extends RequestException {
 
 // src/exception/http-exceptions/not-implemented.exception.ts
 var NotImplementedException = class extends RequestException {
-  constructor(message = "Not Implemented", retry = false) {
-    super(501, message, retry);
+  constructor(message = "Not Implemented", options) {
+    super(501, message, { fatal: true, ...options });
     Object.defineProperty(this, "name", { value: "NotImplementedException" });
   }
 };
 
 // src/exception/http-exceptions/bad-gateway.exception.ts
 var BadGatewayException = class extends RequestException {
-  constructor(message = "Bad Gateway", retry = true) {
-    super(502, message, retry);
+  constructor(message = "Bad Gateway", options) {
+    super(502, message, { fatal: false, ...options });
     Object.defineProperty(this, "name", { value: "BadGatewayException" });
   }
 };
 
 // src/exception/http-exceptions/service-unavailable.exception.ts
 var ServiceUnavailableException = class extends RequestException {
-  constructor(message = "Service Unavailable", retry = true) {
-    super(503, message, retry);
+  constructor(message = "Service Unavailable", options) {
+    super(503, message, { fatal: false, ...options });
     Object.defineProperty(this, "name", {
       value: "ServiceUnavailableException"
     });
@@ -287,8 +284,8 @@ var ServiceUnavailableException = class extends RequestException {
 
 // src/exception/http-exceptions/gateway-timeout.exception.ts
 var GatewayTimeoutException = class extends RequestException {
-  constructor(message = "Gateway Timeout", retry = true) {
-    super(504, message, retry);
+  constructor(message = "Gateway Timeout", options) {
+    super(504, message, { fatal: false, ...options });
     Object.defineProperty(this, "name", { value: "GatewayTimeoutException" });
   }
 };
@@ -1670,11 +1667,11 @@ function keqPathnameRoute(pathname) {
 }
 
 // src/router/keq-router.ts
-var KeqRouter = class {
+var KeqRouter = class _KeqRouter {
   constructor(middlewares = []) {
     this.middlewares = middlewares;
   }
-  buildMiddleware(route, middlewares) {
+  static buildMiddleware(route, middlewares) {
     if (middlewares.length === 0) {
       throw new TypeException("At least one middleware is required to build a route middleware");
     }
@@ -1685,42 +1682,72 @@ var KeqRouter = class {
     };
     return middleware;
   }
-  route(route, ...middlewares) {
-    const middleware = this.buildMiddleware(route, middlewares);
-    middleware.__keqMiddlewareName__ = "route(".concat(route.__keqRouteName__ || route.name, ", ").concat(middlewares.map(getMiddlewareName).join(", "), ")");
-    this.middlewares.push(middleware);
+  route(route, middleware, ...additionalMiddlewares) {
+    const mid = _KeqRouter.route(route, middleware, ...additionalMiddlewares);
+    this.middlewares.push(mid);
     return this;
   }
-  host(host, ...middlewares) {
-    const middleware = this.buildMiddleware(keqHostRoute(host), middlewares);
-    middleware.__keqMiddlewareName__ = "host(".concat(JSON.stringify(host), ", ").concat(middlewares.map(getMiddlewareName).join(", "), ")");
-    this.middlewares.push(middleware);
+  host(host, middleware, ...additionalMiddlewares) {
+    const mid = _KeqRouter.host(host, middleware, ...additionalMiddlewares);
+    this.middlewares.push(mid);
     return this;
   }
-  method(method, ...middlewares) {
-    const middleware = this.buildMiddleware(keqMethodRoute(method), middlewares);
-    middleware.__keqMiddlewareName__ = "method(".concat(JSON.stringify(method), ", ").concat(middlewares.map(getMiddlewareName).join(", "), ")");
-    this.middlewares.push(middleware);
+  method(method, middleware, ...additionalMiddlewares) {
+    const mid = _KeqRouter.method(method, middleware, ...additionalMiddlewares);
+    this.middlewares.push(mid);
     return this;
   }
-  pathname(pathname, ...middlewares) {
-    const middleware = this.buildMiddleware(keqPathnameRoute(pathname), middlewares);
-    middleware.__keqMiddlewareName__ = "pathname(".concat(JSON.stringify(pathname), ", ").concat(middlewares.map(getMiddlewareName).join(", "), ")");
-    this.middlewares.push(middleware);
+  pathname(pathname, middleware, ...additionalMiddlewares) {
+    const mid = _KeqRouter.pathname(pathname, middleware, ...additionalMiddlewares);
+    this.middlewares.push(mid);
     return this;
   }
-  location(...middlewares) {
-    const middleware = this.buildMiddleware(keqLocationRoute(), middlewares);
-    middleware.__keqMiddlewareName__ = "location(".concat(middlewares.map(getMiddlewareName).join(", "), ")");
-    this.middlewares.push(middleware);
+  location(middleware, ...additionalMiddlewares) {
+    const mid = _KeqRouter.location(middleware, ...additionalMiddlewares);
+    this.middlewares.push(mid);
     return this;
   }
-  module(moduleName, ...middlewares) {
-    const middleware = this.buildMiddleware(keqModuleRoute(moduleName), middlewares);
-    middleware.__keqMiddlewareName__ = "module(".concat(JSON.stringify(moduleName), ", ").concat(middlewares.map(getMiddlewareName).join(", "), ")");
-    this.middlewares.push(middleware);
+  module(moduleName, middleware, ...additionalMiddlewares) {
+    const mid = _KeqRouter.module(moduleName, middleware, ...additionalMiddlewares);
+    this.middlewares.push(mid);
     return this;
   }
+  static route(route, middleware, ...additionalMiddlewares) {
+    const list = Array.isArray(middleware) ? middleware : [middleware, ...additionalMiddlewares];
+    const mid = _KeqRouter.buildMiddleware(route, list);
+    mid.__keqMiddlewareName__ = "route(".concat(route.__keqRouteName__ || route.name, ", ").concat(list.map(getMiddlewareName).join(", "), ")");
+    return mid;
+  }
+  static host(host, middleware, ...additionalMiddlewares) {
+    const list = Array.isArray(middleware) ? middleware : [middleware, ...additionalMiddlewares];
+    const mid = _KeqRouter.buildMiddleware(keqHostRoute(host), list);
+    mid.__keqMiddlewareName__ = "host(".concat(JSON.stringify(host), ", ").concat(list.map(getMiddlewareName).join(", "), ")");
+    return mid;
+  }
+  static method(method, middleware, ...additionalMiddlewares) {
+    const list = Array.isArray(middleware) ? middleware : [middleware, ...additionalMiddlewares];
+    const mid = _KeqRouter.buildMiddleware(keqMethodRoute(method), list);
+    mid.__keqMiddlewareName__ = "method(".concat(JSON.stringify(method), ", ").concat(list.map(getMiddlewareName).join(", "), ")");
+    return mid;
+  }
+  static pathname(pathname, middleware, ...additionalMiddlewares) {
+    const list = Array.isArray(middleware) ? middleware : [middleware, ...additionalMiddlewares];
+    const mid = _KeqRouter.buildMiddleware(keqPathnameRoute(pathname), list);
+    mid.__keqMiddlewareName__ = "pathname(".concat(JSON.stringify(pathname), ", ").concat(list.map(getMiddlewareName).join(", "), ")");
+    return mid;
+  }
+  static location(middleware, ...additionalMiddlewares) {
+    const list = Array.isArray(middleware) ? middleware : [middleware, ...additionalMiddlewares];
+    const mid = _KeqRouter.buildMiddleware(keqLocationRoute(), list);
+    mid.__keqMiddlewareName__ = "location(".concat(list.map(getMiddlewareName).join(", "), ")");
+    return mid;
+  }
+  static module(moduleName, middleware, ...additionalMiddlewares) {
+    const list = Array.isArray(middleware) ? middleware : [middleware, ...additionalMiddlewares];
+    const mid = _KeqRouter.buildMiddleware(keqModuleRoute(moduleName), list);
+    mid.__keqMiddlewareName__ = "module(".concat(JSON.stringify(moduleName), ", ").concat(list.map(getMiddlewareName).join(", "), ")");
+    return mid;
+  }
 };
 
 // src/middlewares/timeout-middleware/index.ts
@@ -1922,6 +1949,14 @@ var KeqRequest = class {
   useRouter() {
     return new KeqRouter(this.preMiddlewares);
   }
+  on(event, listener) {
+    const middleware = async (context, next) => {
+      context.emitter.on(event, listener);
+      await next();
+    };
+    this.use(middleware);
+    return this;
+  }
 };
 var request = new KeqRequest();