@nextrush/errors 3.0.0

package/dist/index.js

@@ -0,0 +1,1021 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/base.ts
+var V8Error = Error;
+var NextRushError = class extends Error {
+  static {
+    __name(this, "NextRushError");
+  }
+  /** HTTP status code */
+  status;
+  /** Error code for programmatic handling */
+  code;
+  /** Whether error message is safe to expose to client */
+  expose;
+  /** Additional error details */
+  details;
+  /** Original error that caused this error */
+  cause;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.status = options.status ?? 500;
+    this.code = options.code ?? "INTERNAL_ERROR";
+    this.expose = options.expose ?? this.status < 500;
+    this.details = options.details;
+    this.cause = options.cause;
+    if (V8Error.captureStackTrace && !(this.expose && this.status < 500)) {
+      V8Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+  * Convert error to JSON representation
+  */
+  toJSON() {
+    const json = {
+      error: this.name,
+      message: this.expose ? this.message : "Internal Server Error",
+      code: this.code,
+      status: this.status
+    };
+    if (this.expose && this.details) {
+      json.details = this.details;
+    }
+    return json;
+  }
+  /**
+  * Create a response-safe version of the error
+  */
+  toResponse() {
+    return {
+      status: this.status,
+      body: this.toJSON()
+    };
+  }
+};
+var HTTP_STATUS_MESSAGES = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a Teapot",
+  422: "Unprocessable Entity",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+};
+function getHttpStatusMessage(status) {
+  return HTTP_STATUS_MESSAGES[status] ?? `HTTP Error ${status}`;
+}
+__name(getHttpStatusMessage, "getHttpStatusMessage");
+var HttpError = class extends NextRushError {
+  static {
+    __name(this, "HttpError");
+  }
+  constructor(status, message, options = {}) {
+    super(message ?? getHttpStatusMessage(status), {
+      status,
+      code: options.code ?? `HTTP_${status}`,
+      expose: options.expose ?? status < 500,
+      details: options.details,
+      cause: options.cause
+    });
+  }
+};
+
+// src/http-errors.ts
+var BadRequestError = class extends HttpError {
+  static {
+    __name(this, "BadRequestError");
+  }
+  constructor(message = "Bad Request", options = {}) {
+    super(400, message, {
+      code: "BAD_REQUEST",
+      ...options
+    });
+  }
+};
+var UnauthorizedError = class extends HttpError {
+  static {
+    __name(this, "UnauthorizedError");
+  }
+  constructor(message = "Unauthorized", options = {}) {
+    super(401, message, {
+      code: "UNAUTHORIZED",
+      ...options
+    });
+  }
+};
+var PaymentRequiredError = class extends HttpError {
+  static {
+    __name(this, "PaymentRequiredError");
+  }
+  constructor(message = "Payment Required", options = {}) {
+    super(402, message, {
+      code: "PAYMENT_REQUIRED",
+      ...options
+    });
+  }
+};
+var ForbiddenError = class extends HttpError {
+  static {
+    __name(this, "ForbiddenError");
+  }
+  constructor(message = "Forbidden", options = {}) {
+    super(403, message, {
+      code: "FORBIDDEN",
+      ...options
+    });
+  }
+};
+var NotFoundError = class extends HttpError {
+  static {
+    __name(this, "NotFoundError");
+  }
+  constructor(message = "Not Found", options = {}) {
+    super(404, message, {
+      code: "NOT_FOUND",
+      ...options
+    });
+  }
+};
+var MethodNotAllowedError = class extends HttpError {
+  static {
+    __name(this, "MethodNotAllowedError");
+  }
+  allowedMethods;
+  constructor(allowedMethods = [], message = "Method Not Allowed", options = {}) {
+    super(405, message, {
+      code: "METHOD_NOT_ALLOWED",
+      details: {
+        allowedMethods
+      },
+      ...options
+    });
+    this.allowedMethods = allowedMethods;
+  }
+};
+var NotAcceptableError = class extends HttpError {
+  static {
+    __name(this, "NotAcceptableError");
+  }
+  constructor(message = "Not Acceptable", options = {}) {
+    super(406, message, {
+      code: "NOT_ACCEPTABLE",
+      ...options
+    });
+  }
+};
+var ProxyAuthRequiredError = class extends HttpError {
+  static {
+    __name(this, "ProxyAuthRequiredError");
+  }
+  constructor(message = "Proxy Authentication Required", options = {}) {
+    super(407, message, {
+      code: "PROXY_AUTH_REQUIRED",
+      ...options
+    });
+  }
+};
+var RequestTimeoutError = class extends HttpError {
+  static {
+    __name(this, "RequestTimeoutError");
+  }
+  constructor(message = "Request Timeout", options = {}) {
+    super(408, message, {
+      code: "REQUEST_TIMEOUT",
+      ...options
+    });
+  }
+};
+var ConflictError = class extends HttpError {
+  static {
+    __name(this, "ConflictError");
+  }
+  constructor(message = "Conflict", options = {}) {
+    super(409, message, {
+      code: "CONFLICT",
+      ...options
+    });
+  }
+};
+var GoneError = class extends HttpError {
+  static {
+    __name(this, "GoneError");
+  }
+  constructor(message = "Gone", options = {}) {
+    super(410, message, {
+      code: "GONE",
+      ...options
+    });
+  }
+};
+var LengthRequiredError = class extends HttpError {
+  static {
+    __name(this, "LengthRequiredError");
+  }
+  constructor(message = "Length Required", options = {}) {
+    super(411, message, {
+      code: "LENGTH_REQUIRED",
+      ...options
+    });
+  }
+};
+var PreconditionFailedError = class extends HttpError {
+  static {
+    __name(this, "PreconditionFailedError");
+  }
+  constructor(message = "Precondition Failed", options = {}) {
+    super(412, message, {
+      code: "PRECONDITION_FAILED",
+      ...options
+    });
+  }
+};
+var PayloadTooLargeError = class extends HttpError {
+  static {
+    __name(this, "PayloadTooLargeError");
+  }
+  constructor(message = "Payload Too Large", options = {}) {
+    super(413, message, {
+      code: "PAYLOAD_TOO_LARGE",
+      ...options
+    });
+  }
+};
+var UriTooLongError = class extends HttpError {
+  static {
+    __name(this, "UriTooLongError");
+  }
+  constructor(message = "URI Too Long", options = {}) {
+    super(414, message, {
+      code: "URI_TOO_LONG",
+      ...options
+    });
+  }
+};
+var UnsupportedMediaTypeError = class extends HttpError {
+  static {
+    __name(this, "UnsupportedMediaTypeError");
+  }
+  constructor(message = "Unsupported Media Type", options = {}) {
+    super(415, message, {
+      code: "UNSUPPORTED_MEDIA_TYPE",
+      ...options
+    });
+  }
+};
+var RangeNotSatisfiableError = class extends HttpError {
+  static {
+    __name(this, "RangeNotSatisfiableError");
+  }
+  constructor(message = "Range Not Satisfiable", options = {}) {
+    super(416, message, {
+      code: "RANGE_NOT_SATISFIABLE",
+      ...options
+    });
+  }
+};
+var ExpectationFailedError = class extends HttpError {
+  static {
+    __name(this, "ExpectationFailedError");
+  }
+  constructor(message = "Expectation Failed", options = {}) {
+    super(417, message, {
+      code: "EXPECTATION_FAILED",
+      ...options
+    });
+  }
+};
+var ImATeapotError = class extends HttpError {
+  static {
+    __name(this, "ImATeapotError");
+  }
+  constructor(message = "I'm a teapot", options = {}) {
+    super(418, message, {
+      code: "IM_A_TEAPOT",
+      ...options
+    });
+  }
+};
+var UnprocessableEntityError = class extends HttpError {
+  static {
+    __name(this, "UnprocessableEntityError");
+  }
+  constructor(message = "Unprocessable Entity", options = {}) {
+    super(422, message, {
+      code: "UNPROCESSABLE_ENTITY",
+      ...options
+    });
+  }
+};
+var LockedError = class extends HttpError {
+  static {
+    __name(this, "LockedError");
+  }
+  constructor(message = "Locked", options = {}) {
+    super(423, message, {
+      code: "LOCKED",
+      ...options
+    });
+  }
+};
+var FailedDependencyError = class extends HttpError {
+  static {
+    __name(this, "FailedDependencyError");
+  }
+  constructor(message = "Failed Dependency", options = {}) {
+    super(424, message, {
+      code: "FAILED_DEPENDENCY",
+      ...options
+    });
+  }
+};
+var TooEarlyError = class extends HttpError {
+  static {
+    __name(this, "TooEarlyError");
+  }
+  constructor(message = "Too Early", options = {}) {
+    super(425, message, {
+      code: "TOO_EARLY",
+      ...options
+    });
+  }
+};
+var UpgradeRequiredError = class extends HttpError {
+  static {
+    __name(this, "UpgradeRequiredError");
+  }
+  constructor(message = "Upgrade Required", options = {}) {
+    super(426, message, {
+      code: "UPGRADE_REQUIRED",
+      ...options
+    });
+  }
+};
+var PreconditionRequiredError = class extends HttpError {
+  static {
+    __name(this, "PreconditionRequiredError");
+  }
+  constructor(message = "Precondition Required", options = {}) {
+    super(428, message, {
+      code: "PRECONDITION_REQUIRED",
+      ...options
+    });
+  }
+};
+var TooManyRequestsError = class extends HttpError {
+  static {
+    __name(this, "TooManyRequestsError");
+  }
+  retryAfter;
+  constructor(message = "Too Many Requests", options = {}) {
+    super(429, message, {
+      code: "TOO_MANY_REQUESTS",
+      details: options.retryAfter ? {
+        retryAfter: options.retryAfter
+      } : void 0,
+      ...options
+    });
+    this.retryAfter = options.retryAfter;
+  }
+};
+var RequestHeaderFieldsTooLargeError = class extends HttpError {
+  static {
+    __name(this, "RequestHeaderFieldsTooLargeError");
+  }
+  constructor(message = "Request Header Fields Too Large", options = {}) {
+    super(431, message, {
+      code: "REQUEST_HEADER_FIELDS_TOO_LARGE",
+      ...options
+    });
+  }
+};
+var UnavailableForLegalReasonsError = class extends HttpError {
+  static {
+    __name(this, "UnavailableForLegalReasonsError");
+  }
+  constructor(message = "Unavailable For Legal Reasons", options = {}) {
+    super(451, message, {
+      code: "UNAVAILABLE_FOR_LEGAL_REASONS",
+      ...options
+    });
+  }
+};
+var InternalServerError = class extends HttpError {
+  static {
+    __name(this, "InternalServerError");
+  }
+  constructor(message = "Internal Server Error", options = {}) {
+    super(500, message, {
+      code: "INTERNAL_SERVER_ERROR",
+      expose: false,
+      ...options
+    });
+  }
+};
+var NotImplementedError = class extends HttpError {
+  static {
+    __name(this, "NotImplementedError");
+  }
+  constructor(message = "Not Implemented", options = {}) {
+    super(501, message, {
+      code: "NOT_IMPLEMENTED",
+      expose: false,
+      ...options
+    });
+  }
+};
+var BadGatewayError = class extends HttpError {
+  static {
+    __name(this, "BadGatewayError");
+  }
+  constructor(message = "Bad Gateway", options = {}) {
+    super(502, message, {
+      code: "BAD_GATEWAY",
+      expose: false,
+      ...options
+    });
+  }
+};
+var ServiceUnavailableError = class extends HttpError {
+  static {
+    __name(this, "ServiceUnavailableError");
+  }
+  retryAfter;
+  constructor(message = "Service Unavailable", options = {}) {
+    super(503, message, {
+      code: "SERVICE_UNAVAILABLE",
+      expose: false,
+      ...options
+    });
+    this.retryAfter = options.retryAfter;
+  }
+};
+var GatewayTimeoutError = class extends HttpError {
+  static {
+    __name(this, "GatewayTimeoutError");
+  }
+  constructor(message = "Gateway Timeout", options = {}) {
+    super(504, message, {
+      code: "GATEWAY_TIMEOUT",
+      expose: false,
+      ...options
+    });
+  }
+};
+var HttpVersionNotSupportedError = class extends HttpError {
+  static {
+    __name(this, "HttpVersionNotSupportedError");
+  }
+  constructor(message = "HTTP Version Not Supported", options = {}) {
+    super(505, message, {
+      code: "HTTP_VERSION_NOT_SUPPORTED",
+      expose: false,
+      ...options
+    });
+  }
+};
+var VariantAlsoNegotiatesError = class extends HttpError {
+  static {
+    __name(this, "VariantAlsoNegotiatesError");
+  }
+  constructor(message = "Variant Also Negotiates", options = {}) {
+    super(506, message, {
+      code: "VARIANT_ALSO_NEGOTIATES",
+      expose: false,
+      ...options
+    });
+  }
+};
+var InsufficientStorageError = class extends HttpError {
+  static {
+    __name(this, "InsufficientStorageError");
+  }
+  constructor(message = "Insufficient Storage", options = {}) {
+    super(507, message, {
+      code: "INSUFFICIENT_STORAGE",
+      expose: false,
+      ...options
+    });
+  }
+};
+var LoopDetectedError = class extends HttpError {
+  static {
+    __name(this, "LoopDetectedError");
+  }
+  constructor(message = "Loop Detected", options = {}) {
+    super(508, message, {
+      code: "LOOP_DETECTED",
+      expose: false,
+      ...options
+    });
+  }
+};
+var NotExtendedError = class extends HttpError {
+  static {
+    __name(this, "NotExtendedError");
+  }
+  constructor(message = "Not Extended", options = {}) {
+    super(510, message, {
+      code: "NOT_EXTENDED",
+      expose: false,
+      ...options
+    });
+  }
+};
+var NetworkAuthRequiredError = class extends HttpError {
+  static {
+    __name(this, "NetworkAuthRequiredError");
+  }
+  constructor(message = "Network Authentication Required", options = {}) {
+    super(511, message, {
+      code: "NETWORK_AUTH_REQUIRED",
+      expose: false,
+      ...options
+    });
+  }
+};
+
+// src/validation.ts
+var ValidationError = class _ValidationError extends NextRushError {
+  static {
+    __name(this, "ValidationError");
+  }
+  /** List of validation issues */
+  issues;
+  constructor(issues, message = "Validation failed") {
+    super(message, {
+      status: 400,
+      code: "VALIDATION_ERROR",
+      expose: true
+    });
+    this.issues = issues;
+  }
+  /**
+  * Create from a single field error
+  */
+  static fromField(path, message, rule) {
+    return new _ValidationError([
+      {
+        path,
+        message,
+        rule
+      }
+    ]);
+  }
+  /**
+  * Create from multiple field errors
+  */
+  static fromFields(errors) {
+    const issues = Object.entries(errors).map(([path, message]) => ({
+      path,
+      message
+    }));
+    return new _ValidationError(issues);
+  }
+  /**
+  * Check if a specific field has errors
+  */
+  hasErrorFor(path) {
+    return this.issues.some((issue) => issue.path === path);
+  }
+  /**
+  * Get errors for a specific field
+  */
+  getErrorsFor(path) {
+    return this.issues.filter((issue) => issue.path === path);
+  }
+  /**
+  * Get first error message for a field
+  */
+  getFirstError(path) {
+    return this.issues.find((issue) => issue.path === path)?.message;
+  }
+  /**
+  * Convert to flat error object
+  */
+  toFlatObject() {
+    const result = {};
+    for (const issue of this.issues) {
+      if (!result[issue.path]) {
+        result[issue.path] = issue.message;
+      }
+    }
+    return result;
+  }
+  toJSON() {
+    return {
+      error: this.name,
+      message: this.message,
+      code: this.code,
+      status: this.status,
+      // Strip `received` to prevent leaking sensitive input values (passwords, tokens)
+      issues: this.issues.map(({ path, message, rule, expected }) => ({
+        path,
+        message,
+        ...rule !== void 0 && {
+          rule
+        },
+        ...expected !== void 0 && {
+          expected
+        }
+      }))
+    };
+  }
+};
+var RequiredFieldError = class extends ValidationError {
+  static {
+    __name(this, "RequiredFieldError");
+  }
+  constructor(field) {
+    super([
+      {
+        path: field,
+        message: `${field} is required`,
+        rule: "required"
+      }
+    ], `${field} is required`);
+  }
+};
+var TypeMismatchError = class extends ValidationError {
+  static {
+    __name(this, "TypeMismatchError");
+  }
+  constructor(field, expected, received) {
+    super([
+      {
+        path: field,
+        message: `Expected ${expected}, received ${received}`,
+        rule: "type",
+        expected,
+        received
+      }
+    ], `${field} must be of type ${expected}`);
+  }
+};
+var RangeValidationError = class extends ValidationError {
+  static {
+    __name(this, "RangeValidationError");
+  }
+  constructor(field, min, max) {
+    const parts = [];
+    if (min !== void 0) parts.push(`at least ${min}`);
+    if (max !== void 0) parts.push(`at most ${max}`);
+    const message = `${field} must be ${parts.join(" and ")}`;
+    super([
+      {
+        path: field,
+        message,
+        rule: "range",
+        expected: {
+          min,
+          max
+        }
+      }
+    ], message);
+  }
+};
+var LengthError = class extends ValidationError {
+  static {
+    __name(this, "LengthError");
+  }
+  constructor(field, min, max) {
+    const parts = [];
+    if (min !== void 0) parts.push(`at least ${min} characters`);
+    if (max !== void 0) parts.push(`at most ${max} characters`);
+    const message = `${field} must be ${parts.join(" and ")}`;
+    super([
+      {
+        path: field,
+        message,
+        rule: "length",
+        expected: {
+          min,
+          max
+        }
+      }
+    ], message);
+  }
+};
+var PatternError = class extends ValidationError {
+  static {
+    __name(this, "PatternError");
+  }
+  constructor(field, pattern, message) {
+    super([
+      {
+        path: field,
+        message: message ?? `${field} does not match required pattern`,
+        rule: "pattern",
+        expected: pattern
+      }
+    ], message ?? `${field} does not match required pattern`);
+  }
+};
+var InvalidEmailError = class extends ValidationError {
+  static {
+    __name(this, "InvalidEmailError");
+  }
+  constructor(field = "email") {
+    super([
+      {
+        path: field,
+        message: "Invalid email address",
+        rule: "email"
+      }
+    ], "Invalid email address");
+  }
+};
+var InvalidUrlError = class extends ValidationError {
+  static {
+    __name(this, "InvalidUrlError");
+  }
+  constructor(field = "url") {
+    super([
+      {
+        path: field,
+        message: "Invalid URL",
+        rule: "url"
+      }
+    ], "Invalid URL");
+  }
+};
+
+// src/factory.ts
+var ERROR_MAP = {
+  400: BadRequestError,
+  401: UnauthorizedError,
+  403: ForbiddenError,
+  404: NotFoundError,
+  409: ConflictError,
+  422: UnprocessableEntityError,
+  429: TooManyRequestsError,
+  500: InternalServerError,
+  501: NotImplementedError,
+  502: BadGatewayError,
+  503: ServiceUnavailableError,
+  504: GatewayTimeoutError
+};
+function createError(status, message, options) {
+  if (status === 405) {
+    return new MethodNotAllowedError([], message, options);
+  }
+  const ErrorClass = ERROR_MAP[status];
+  if (ErrorClass) {
+    return new ErrorClass(message, options);
+  }
+  return new HttpError(status, message, options);
+}
+__name(createError, "createError");
+function badRequest(message, options) {
+  return new BadRequestError(message, options);
+}
+__name(badRequest, "badRequest");
+function unauthorized(message, options) {
+  return new UnauthorizedError(message, options);
+}
+__name(unauthorized, "unauthorized");
+function forbidden(message, options) {
+  return new ForbiddenError(message, options);
+}
+__name(forbidden, "forbidden");
+function notFound(message, options) {
+  return new NotFoundError(message, options);
+}
+__name(notFound, "notFound");
+function methodNotAllowed(allowedMethods, message, options) {
+  return new MethodNotAllowedError(allowedMethods, message, options);
+}
+__name(methodNotAllowed, "methodNotAllowed");
+function conflict(message, options) {
+  return new ConflictError(message, options);
+}
+__name(conflict, "conflict");
+function unprocessableEntity(message, options) {
+  return new UnprocessableEntityError(message, options);
+}
+__name(unprocessableEntity, "unprocessableEntity");
+function tooManyRequests(message, options) {
+  return new TooManyRequestsError(message, options);
+}
+__name(tooManyRequests, "tooManyRequests");
+function internalError(message, options) {
+  return new InternalServerError(message, options);
+}
+__name(internalError, "internalError");
+function badGateway(message, options) {
+  return new BadGatewayError(message, options);
+}
+__name(badGateway, "badGateway");
+function serviceUnavailable(message, options) {
+  return new ServiceUnavailableError(message, options);
+}
+__name(serviceUnavailable, "serviceUnavailable");
+function gatewayTimeout(message, options) {
+  return new GatewayTimeoutError(message, options);
+}
+__name(gatewayTimeout, "gatewayTimeout");
+function isHttpError(error) {
+  return error instanceof HttpError;
+}
+__name(isHttpError, "isHttpError");
+function getErrorStatus(error) {
+  if (error instanceof NextRushError) {
+    return error.status;
+  }
+  if (error != null && typeof error === "object" && "status" in error && typeof error.status === "number") {
+    const status = error.status;
+    return status >= 400 && status < 600 ? status : 500;
+  }
+  return 500;
+}
+__name(getErrorStatus, "getErrorStatus");
+function getSafeErrorMessage(error) {
+  if (error instanceof NextRushError && error.expose) {
+    return error.message;
+  }
+  return "Internal Server Error";
+}
+__name(getSafeErrorMessage, "getSafeErrorMessage");
+
+// src/middleware.ts
+function defaultLogger(error, ctx) {
+  const status = error instanceof HttpError ? error.status : 500;
+  if (status >= 500) {
+    console.error(`[ERROR] ${ctx.method} ${ctx.path}:`, error);
+  } else {
+    console.warn(`[WARN] ${ctx.method} ${ctx.path}: ${error.message}`);
+  }
+}
+__name(defaultLogger, "defaultLogger");
+function errorHandler(options = {}) {
+  const { includeStack = false, logger = defaultLogger, transform, handlers } = options;
+  return async (ctx, next) => {
+    try {
+      await next();
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      logger(err, ctx);
+      if (handlers) {
+        for (const [ErrorType, handler] of handlers) {
+          if (err instanceof ErrorType) {
+            handler(err, ctx);
+            return;
+          }
+        }
+      }
+      let status = 500;
+      let expose = false;
+      let code = "INTERNAL_ERROR";
+      let details;
+      if (err instanceof HttpError || err instanceof NextRushError) {
+        status = err.status;
+        expose = err.expose;
+        code = err.code;
+        details = err.details;
+      }
+      ctx.status = status;
+      let body;
+      if (transform) {
+        body = transform(err, ctx);
+      } else {
+        body = {
+          error: expose ? err.name : getHttpStatusMessage(status),
+          message: expose ? err.message : "Internal Server Error",
+          code,
+          status
+        };
+        if (expose && details) {
+          body.details = details;
+        }
+        if (includeStack && err.stack) {
+          body.stack = err.stack.split("\n").map((line) => line.trim());
+        }
+      }
+      ctx.json(body);
+    }
+  };
+}
+__name(errorHandler, "errorHandler");
+function notFoundHandler(message = "Not Found") {
+  return async (ctx, next) => {
+    await next();
+    if (!ctx.responded && ctx.status === 404) {
+      ctx.json({
+        error: "NotFoundError",
+        message,
+        code: "NOT_FOUND",
+        status: 404
+      });
+    }
+  };
+}
+__name(notFoundHandler, "notFoundHandler");
+function catchAsync(handler) {
+  return handler;
+}
+__name(catchAsync, "catchAsync");
+export {
+  BadGatewayError,
+  BadRequestError,
+  ConflictError,
+  ExpectationFailedError,
+  FailedDependencyError,
+  ForbiddenError,
+  GatewayTimeoutError,
+  GoneError,
+  HttpError,
+  HttpVersionNotSupportedError,
+  ImATeapotError,
+  InsufficientStorageError,
+  InternalServerError,
+  InvalidEmailError,
+  InvalidUrlError,
+  LengthError,
+  LengthRequiredError,
+  LockedError,
+  LoopDetectedError,
+  MethodNotAllowedError,
+  NetworkAuthRequiredError,
+  NextRushError,
+  NotAcceptableError,
+  NotExtendedError,
+  NotFoundError,
+  NotImplementedError,
+  PatternError,
+  PayloadTooLargeError,
+  PaymentRequiredError,
+  PreconditionFailedError,
+  PreconditionRequiredError,
+  ProxyAuthRequiredError,
+  RangeNotSatisfiableError,
+  RangeValidationError,
+  RequestHeaderFieldsTooLargeError,
+  RequestTimeoutError,
+  RequiredFieldError,
+  ServiceUnavailableError,
+  TooEarlyError,
+  TooManyRequestsError,
+  TypeMismatchError,
+  UnauthorizedError,
+  UnavailableForLegalReasonsError,
+  UnprocessableEntityError,
+  UnsupportedMediaTypeError,
+  UpgradeRequiredError,
+  UriTooLongError,
+  ValidationError,
+  VariantAlsoNegotiatesError,
+  badGateway,
+  badRequest,
+  catchAsync,
+  conflict,
+  createError,
+  errorHandler,
+  forbidden,
+  gatewayTimeout,
+  getErrorStatus,
+  getHttpStatusMessage,
+  getSafeErrorMessage,
+  internalError,
+  isHttpError,
+  methodNotAllowed,
+  notFound,
+  notFoundHandler,
+  serviceUnavailable,
+  tooManyRequests,
+  unauthorized,
+  unprocessableEntity
+};
+//# sourceMappingURL=index.js.map