keq 5.0.0-alpha.24 → 5.0.0-alpha.26

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" });
   }
 };
@@ -719,15 +721,16 @@ function fork(original) {
     return current;
   };
   const createProxy = (path = []) => {
-    return new Proxy({}, {
-      get(_, prop) {
-        const target = objectPath(current, path);
-        if (prop === UnWrapPropertyKey) return target;
-        const value = target[prop];
+    const getTarget = () => objectPath(current, path);
+    return new Proxy(getTarget(), {
+      get(target, prop) {
+        const realTarget = getTarget();
+        if (prop === UnWrapPropertyKey) return realTarget;
+        const value = realTarget[prop];
         if (current !== original) {
           return value;
         }
-        if (Array.isArray(target) && ARRAY_MUTATORS.has(prop)) {
+        if (Array.isArray(realTarget) && ARRAY_MUTATORS.has(prop)) {
           return new Proxy(value, {
             apply(fn, thisArg, args) {
               ensureCopy();
@@ -741,15 +744,23 @@ function fork(original) {
         }
         return value;
       },
-      set(_, prop, value) {
+      set(target, prop, value) {
         ensureCopy();
         objectPath(current, path)[prop] = value;
         return true;
       },
-      deleteProperty(_, prop) {
+      deleteProperty(target, prop) {
         ensureCopy();
         delete objectPath(current, path)[prop];
         return true;
+      },
+      ownKeys(target) {
+        const realTarget = getTarget();
+        return Reflect.ownKeys(realTarget);
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        const realTarget = getTarget();
+        return Reflect.getOwnPropertyDescriptor(realTarget, prop);
       }
     });
   };
@@ -1528,13 +1539,15 @@ var Keq = class extends Core {
     this.requestInit.mode = mod;
     return this;
   }
-  flowControl(mode, signal) {
-    const sig = signal ? signal : this.__locationId__;
+  flowControl(mode, arg2, arg3) {
+    const concurrencyLimit = typeof arg2 === "number" ? arg2 : void 0;
+    const sig = typeof arg2 === "function" || typeof arg2 === "string" ? arg2 : arg3 && (typeof arg3 === "function" || typeof arg3 === "string") ? arg3 : this.__locationId__;
     if (!sig) {
       throw new Exception("please set signal to .flowControl()");
     }
     const flowControl = {
       mode,
+      concurrencyLimit,
       signal: sig
     };
     this.option("flowControl", flowControl);
@@ -1596,11 +1609,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 +1624,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
@@ -1675,17 +1718,18 @@ function keqTimeoutMiddleware() {
 import * as fastq from "fastq";
 function keqSerialFlowControlMiddleware() {
   return async function serialFlowControlMiddleware(ctx, next) {
-    if (!ctx.options.flowControl || ctx.options.flowControl.mode !== "serial") {
+    if (!ctx.options.flowControl || !["serial", "concurrent"].includes(ctx.options.flowControl.mode)) {
       await next();
       return;
     }
     const { signal } = ctx.options.flowControl;
+    const concurrent = ctx.options.flowControl.mode === "serial" ? 1 : !ctx.options.flowControl.concurrencyLimit ? 1 : ctx.options.flowControl.concurrencyLimit < 1 ? 1 : parseInt(ctx.options.flowControl.concurrencyLimit, 10);
     const key = typeof signal === "string" ? signal : signal(ctx);
     if (!ctx.global.serialFlowControl) ctx.global.serialFlowControl = {};
     if (!ctx.global.serialFlowControl[key]) {
       ctx.global.serialFlowControl[key] = fastq.promise(async (next2) => {
         await next2();
-      }, 1);
+      }, concurrent);
     }
     const queue = ctx.global.serialFlowControl[key];
     await queue.push(next);
@@ -1848,6 +1892,15 @@ var KeqRequest = class {
   useRouter() {
     return new KeqRouter(this.preMiddlewares);
   }
+  on(event, listener) {
+    const middleware = async (context, next) => {
+      context.emitter.on(event, listener);
+      await next();
+    };
+    middleware.__keqMiddlewareName__ = "listen(".concat(event, ", ").concat(listener.name || "anonymous", ")");
+    this.use(middleware);
+    return this;
+  }
 };
 var request = new KeqRequest();
 
@@ -1891,11 +1944,6 @@ export {
   composeRoute,
   createProxyResponse,
   createRequest,
-  keqHostRoute,
-  keqLocationRoute,
-  keqMethodRoute,
-  keqModuleRoute,
-  keqPathnameRoute,
   request
 };
 //# sourceMappingURL=index.mjs.map