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

package/dist/index.mjs

@@ -35,52 +35,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"
     });
@@ -89,16 +91,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"
     });
@@ -107,8 +109,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"
     });
@@ -117,16 +119,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"
     });
@@ -135,8 +137,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"
     });
@@ -145,40 +147,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"
     });
@@ -187,24 +189,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"
     });
@@ -213,8 +215,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" });
   }
 };
@@ -1596,11 +1598,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");
     }
@@ -1611,42 +1613,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
@@ -1848,6 +1880,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();
 
@@ -1891,11 +1931,6 @@ export {
   composeRoute,
   createProxyResponse,
   createRequest,
-  keqHostRoute,
-  keqLocationRoute,
-  keqMethodRoute,
-  keqModuleRoute,
-  keqPathnameRoute,
   request
 };
 //# sourceMappingURL=index.mjs.map