@web-ts-toolkit/http-errors 0.0.2

package/index.d.ts

@@ -0,0 +1,187 @@
+type HttpErrorMetadataValue = string | number | boolean | bigint | null | undefined;
+type HttpErrorOptions = ErrorOptions & {
+    status?: string;
+    reason?: string;
+    domain?: string;
+    metadata?: Record<string, HttpErrorMetadataValue>;
+    details?: unknown[];
+    errors?: unknown;
+};
+type HttpErrorShape = {
+    statusCode: number;
+    status?: string;
+    message: string;
+    reason?: string;
+    domain?: string;
+    metadata?: Record<string, string>;
+    details?: unknown[];
+    errors?: unknown;
+};
+type Aip193ErrorInfoDetail = {
+    type: 'error_info';
+    reason: string;
+    domain: string;
+    metadata?: Record<string, string>;
+};
+type Aip193ErrorPayload = {
+    error: {
+        code: number;
+        status: string;
+        message: string;
+        details?: unknown[];
+    };
+};
+
+declare const canonicalStatusByHttpStatus: {
+    readonly 400: "INVALID_ARGUMENT";
+    readonly 401: "UNAUTHENTICATED";
+    readonly 403: "PERMISSION_DENIED";
+    readonly 404: "NOT_FOUND";
+    readonly 409: "ABORTED";
+    readonly 412: "FAILED_PRECONDITION";
+    readonly 429: "RESOURCE_EXHAUSTED";
+    readonly 500: "INTERNAL";
+    readonly 501: "UNIMPLEMENTED";
+    readonly 503: "UNAVAILABLE";
+    readonly 504: "DEADLINE_EXCEEDED";
+};
+declare const getCanonicalStatus: (statusCode: number) => string;
+
+declare const createAip193ErrorInfoDetail: (reason: string, domain: string, metadata?: Record<string, string>) => Aip193ErrorInfoDetail;
+declare const toAip193ErrorPayload: (error: HttpErrorShape, fallbackDomain?: string) => Aip193ErrorPayload;
+
+declare class HttpError extends Error {
+    readonly statusCode: number;
+    readonly status: string;
+    readonly date: Date;
+    readonly reason?: string;
+    readonly domain?: string;
+    readonly metadata?: Record<string, string>;
+    readonly details?: unknown[];
+    readonly errors?: unknown;
+    constructor(statusCode?: number, message?: string, options?: HttpErrorOptions);
+}
+declare class ClientError extends HttpError {
+    constructor(statusCode?: number, message?: string, options?: HttpErrorOptions);
+}
+declare class ServerError extends HttpError {
+    constructor(statusCode?: number, message?: string, options?: HttpErrorOptions);
+}
+
+declare class BadRequestError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class UnauthorizedError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class ForbiddenError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class NotFoundError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class MethodNotAllowedError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class NotAcceptableError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class ProxyAuthRequiredError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class RequestTimeoutError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class ConflictError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class GoneError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class LengthRequiredError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class PreconditionFailedError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class PayloadTooLargeError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class UriTooLongError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class UnsupportedMediaTypeError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class RequestedRangeNotSatisfiableError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class ExpectationFailedError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class TeapotError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class MisdirectedRequestError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class UnprocessableEntityError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class LockedError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class FailedDependencyError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class UpgradeRequiredError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class PreconditionRequiredError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class TooManyRequestsError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class RequestHeaderFieldsTooLargeError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class UnavailableForLegalReasonsError extends ClientError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+
+declare class InternalServerError extends ServerError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class NotImplementedError extends ServerError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class BadGatewayError extends ServerError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class ServiceUnavailableError extends ServerError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class GatewayTimeoutError extends ServerError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class HttpVersionNotSupportedError extends ServerError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class VariantAlsoNegotiatesError extends ServerError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class InsufficientStorageError extends ServerError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class LoopDetectedError extends ServerError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class NotExtendedError extends ServerError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+declare class NetworkAuthenticationRequiredError extends ServerError {
+    constructor(message?: string, options?: HttpErrorOptions);
+}
+
+export { type Aip193ErrorInfoDetail, type Aip193ErrorPayload, BadGatewayError, BadRequestError, ClientError, ConflictError, ExpectationFailedError, FailedDependencyError, ForbiddenError, GatewayTimeoutError, GoneError, HttpError, type HttpErrorMetadataValue, type HttpErrorOptions, type HttpErrorShape, HttpVersionNotSupportedError, InsufficientStorageError, InternalServerError, LengthRequiredError, LockedError, LoopDetectedError, MethodNotAllowedError, MisdirectedRequestError, NetworkAuthenticationRequiredError, NotAcceptableError, NotExtendedError, NotFoundError, NotImplementedError, PayloadTooLargeError, PreconditionFailedError, PreconditionRequiredError, ProxyAuthRequiredError, RequestHeaderFieldsTooLargeError, RequestTimeoutError, RequestedRangeNotSatisfiableError, ServerError, ServiceUnavailableError, TeapotError, TooManyRequestsError, UnauthorizedError, UnavailableForLegalReasonsError, UnprocessableEntityError, UnsupportedMediaTypeError, UpgradeRequiredError, UriTooLongError, VariantAlsoNegotiatesError, canonicalStatusByHttpStatus, createAip193ErrorInfoDetail, getCanonicalStatus, toAip193ErrorPayload };

package/index.js

@@ -0,0 +1,443 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BadGatewayError: () => BadGatewayError,
+  BadRequestError: () => BadRequestError,
+  ClientError: () => ClientError,
+  ConflictError: () => ConflictError,
+  ExpectationFailedError: () => ExpectationFailedError,
+  FailedDependencyError: () => FailedDependencyError,
+  ForbiddenError: () => ForbiddenError,
+  GatewayTimeoutError: () => GatewayTimeoutError,
+  GoneError: () => GoneError,
+  HttpError: () => HttpError,
+  HttpVersionNotSupportedError: () => HttpVersionNotSupportedError,
+  InsufficientStorageError: () => InsufficientStorageError,
+  InternalServerError: () => InternalServerError,
+  LengthRequiredError: () => LengthRequiredError,
+  LockedError: () => LockedError,
+  LoopDetectedError: () => LoopDetectedError,
+  MethodNotAllowedError: () => MethodNotAllowedError,
+  MisdirectedRequestError: () => MisdirectedRequestError,
+  NetworkAuthenticationRequiredError: () => NetworkAuthenticationRequiredError,
+  NotAcceptableError: () => NotAcceptableError,
+  NotExtendedError: () => NotExtendedError,
+  NotFoundError: () => NotFoundError,
+  NotImplementedError: () => NotImplementedError,
+  PayloadTooLargeError: () => PayloadTooLargeError,
+  PreconditionFailedError: () => PreconditionFailedError,
+  PreconditionRequiredError: () => PreconditionRequiredError,
+  ProxyAuthRequiredError: () => ProxyAuthRequiredError,
+  RequestHeaderFieldsTooLargeError: () => RequestHeaderFieldsTooLargeError,
+  RequestTimeoutError: () => RequestTimeoutError,
+  RequestedRangeNotSatisfiableError: () => RequestedRangeNotSatisfiableError,
+  ServerError: () => ServerError,
+  ServiceUnavailableError: () => ServiceUnavailableError,
+  TeapotError: () => TeapotError,
+  TooManyRequestsError: () => TooManyRequestsError,
+  UnauthorizedError: () => UnauthorizedError,
+  UnavailableForLegalReasonsError: () => UnavailableForLegalReasonsError,
+  UnprocessableEntityError: () => UnprocessableEntityError,
+  UnsupportedMediaTypeError: () => UnsupportedMediaTypeError,
+  UpgradeRequiredError: () => UpgradeRequiredError,
+  UriTooLongError: () => UriTooLongError,
+  VariantAlsoNegotiatesError: () => VariantAlsoNegotiatesError,
+  canonicalStatusByHttpStatus: () => canonicalStatusByHttpStatus,
+  createAip193ErrorInfoDetail: () => createAip193ErrorInfoDetail,
+  getCanonicalStatus: () => getCanonicalStatus,
+  toAip193ErrorPayload: () => toAip193ErrorPayload
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/status.ts
+var canonicalStatusByHttpStatus = {
+  400: "INVALID_ARGUMENT",
+  401: "UNAUTHENTICATED",
+  403: "PERMISSION_DENIED",
+  404: "NOT_FOUND",
+  409: "ABORTED",
+  412: "FAILED_PRECONDITION",
+  429: "RESOURCE_EXHAUSTED",
+  500: "INTERNAL",
+  501: "UNIMPLEMENTED",
+  503: "UNAVAILABLE",
+  504: "DEADLINE_EXCEEDED"
+};
+var getCanonicalStatus = (statusCode) => canonicalStatusByHttpStatus[statusCode] || "UNKNOWN";
+
+// src/serialize.ts
+var createAip193ErrorInfoDetail = (reason, domain, metadata) => ({
+  type: "error_info",
+  reason,
+  domain,
+  ...metadata ? { metadata } : {}
+});
+var toAip193ErrorPayload = (error, fallbackDomain = "http-errors") => {
+  const status = error.status || getCanonicalStatus(error.statusCode);
+  const details = [
+    createAip193ErrorInfoDetail(error.reason || status, error.domain || fallbackDomain, error.metadata),
+    ...error.errors !== void 0 ? [{ type: "bad_request", errors: error.errors }] : [],
+    ...error.details || []
+  ];
+  return {
+    error: {
+      code: error.statusCode,
+      status,
+      message: error.message,
+      ...details.length > 0 ? { details } : {}
+    }
+  };
+};
+
+// src/messages.ts
+var messages = {
+  400: "The server cannot process the request due to a client error",
+  401: "The user is not authorized",
+  403: "The server refused to authorize the request",
+  404: "The server did not find a current representation for the target resource",
+  405: "The method received is not allowed",
+  406: "The request is not acceptable to the user agent",
+  407: "The client needs to authenticate itself in order to use a proxy",
+  408: "The request was not completed in the expected time",
+  409: "The request was not completed due to a conflict with the target resource",
+  410: "The target resource is no longer available at the origin server",
+  411: "The server refuses to accept the request without a defined Content-Length",
+  412: "One or more conditions given in the request header fields evaluated to false",
+  413: "The request payload is too large",
+  414: "The request target is too long",
+  415: "The payload is in a format not supported",
+  416: "None of the ranges in the request's Range header field overlap the current extent of the selected resource",
+  417: "The expectation given in the request's Expect header field could not be met",
+  418: "I'm a teapot",
+  421: "The request was directed at a server that is not able to produce a response",
+  422: "The server is unable to process the request",
+  423: "The source or destination resource of a method is locked",
+  424: "The requested action depended on another action",
+  426: "This service requires use of a different protocol",
+  428: "This request is required to be conditional",
+  429: "The user has sent too many requests in a given amount of time",
+  431: "Request header fields too large",
+  451: "Denied access due to a consequence of a legal demand",
+  500: "The server encountered an unexpected condition",
+  501: "The server does not support the functionality required to fulfill the request",
+  502: "The server received an invalid response from an upstream server",
+  503: "The server is temporarily unable to handle the request",
+  504: "The server did not receive a timely response from an upstream server",
+  505: "The server does not support the HTTP protocol version used in the request",
+  506: "The server has an internal configuration error",
+  507: "The server is unable to store the representation needed to complete the request",
+  508: "The server detected an infinite loop while processing the request",
+  510: "Further extensions to the request are required for the server to fulfill it",
+  511: "The client needs to authenticate to gain network access"
+};
+var getDefaultMessage = (statusCode) => messages[statusCode] || messages[500];
+
+// src/base.ts
+var ErrorCtor = Error;
+var toMetadata = (metadata) => {
+  if (!metadata) {
+    return void 0;
+  }
+  return Object.entries(metadata).reduce((result, [key, value]) => {
+    result[key] = String(value);
+    return result;
+  }, {});
+};
+var HttpError = class extends Error {
+  constructor(statusCode = 500, message, options = {}) {
+    super(message || getDefaultMessage(statusCode), options);
+    if (ErrorCtor.captureStackTrace) {
+      ErrorCtor.captureStackTrace(this, this.constructor);
+    }
+    this.name = this.constructor.name;
+    this.statusCode = statusCode;
+    this.status = options.status || getCanonicalStatus(statusCode);
+    this.date = /* @__PURE__ */ new Date();
+    if (options.reason) {
+      this.reason = options.reason;
+    }
+    if (options.domain) {
+      this.domain = options.domain;
+    }
+    if (options.metadata) {
+      this.metadata = toMetadata(options.metadata);
+    }
+    if (options.details) {
+      this.details = options.details;
+    }
+    if (options.errors !== void 0) {
+      this.errors = options.errors;
+    }
+  }
+};
+var ClientError = class extends HttpError {
+  constructor(statusCode = 400, message, options = {}) {
+    super(statusCode, message, options);
+  }
+};
+var ServerError = class extends HttpError {
+  constructor(statusCode = 500, message, options = {}) {
+    super(statusCode, message, options);
+  }
+};
+
+// src/client-errors.ts
+var BadRequestError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(400, message, options);
+  }
+};
+var UnauthorizedError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(401, message, options);
+  }
+};
+var ForbiddenError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(403, message, options);
+  }
+};
+var NotFoundError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(404, message, options);
+  }
+};
+var MethodNotAllowedError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(405, message, options);
+  }
+};
+var NotAcceptableError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(406, message, options);
+  }
+};
+var ProxyAuthRequiredError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(407, message, options);
+  }
+};
+var RequestTimeoutError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(408, message, options);
+  }
+};
+var ConflictError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(409, message, options);
+  }
+};
+var GoneError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(410, message, options);
+  }
+};
+var LengthRequiredError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(411, message, options);
+  }
+};
+var PreconditionFailedError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(412, message, options);
+  }
+};
+var PayloadTooLargeError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(413, message, options);
+  }
+};
+var UriTooLongError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(414, message, options);
+  }
+};
+var UnsupportedMediaTypeError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(415, message, options);
+  }
+};
+var RequestedRangeNotSatisfiableError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(416, message, options);
+  }
+};
+var ExpectationFailedError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(417, message, options);
+  }
+};
+var TeapotError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(418, message, options);
+  }
+};
+var MisdirectedRequestError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(421, message, options);
+  }
+};
+var UnprocessableEntityError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(422, message, options);
+  }
+};
+var LockedError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(423, message, options);
+  }
+};
+var FailedDependencyError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(424, message, options);
+  }
+};
+var UpgradeRequiredError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(426, message, options);
+  }
+};
+var PreconditionRequiredError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(428, message, options);
+  }
+};
+var TooManyRequestsError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(429, message, options);
+  }
+};
+var RequestHeaderFieldsTooLargeError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(431, message, options);
+  }
+};
+var UnavailableForLegalReasonsError = class extends ClientError {
+  constructor(message, options = {}) {
+    super(451, message, options);
+  }
+};
+
+// src/server-errors.ts
+var InternalServerError = class extends ServerError {
+  constructor(message, options = {}) {
+    super(500, message, options);
+  }
+};
+var NotImplementedError = class extends ServerError {
+  constructor(message, options = {}) {
+    super(501, message, options);
+  }
+};
+var BadGatewayError = class extends ServerError {
+  constructor(message, options = {}) {
+    super(502, message, options);
+  }
+};
+var ServiceUnavailableError = class extends ServerError {
+  constructor(message, options = {}) {
+    super(503, message, options);
+  }
+};
+var GatewayTimeoutError = class extends ServerError {
+  constructor(message, options = {}) {
+    super(504, message, options);
+  }
+};
+var HttpVersionNotSupportedError = class extends ServerError {
+  constructor(message, options = {}) {
+    super(505, message, options);
+  }
+};
+var VariantAlsoNegotiatesError = class extends ServerError {
+  constructor(message, options = {}) {
+    super(506, message, options);
+  }
+};
+var InsufficientStorageError = class extends ServerError {
+  constructor(message, options = {}) {
+    super(507, message, options);
+  }
+};
+var LoopDetectedError = class extends ServerError {
+  constructor(message, options = {}) {
+    super(508, message, options);
+  }
+};
+var NotExtendedError = class extends ServerError {
+  constructor(message, options = {}) {
+    super(510, message, options);
+  }
+};
+var NetworkAuthenticationRequiredError = class extends ServerError {
+  constructor(message, options = {}) {
+    super(511, message, options);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BadGatewayError,
+  BadRequestError,
+  ClientError,
+  ConflictError,
+  ExpectationFailedError,
+  FailedDependencyError,
+  ForbiddenError,
+  GatewayTimeoutError,
+  GoneError,
+  HttpError,
+  HttpVersionNotSupportedError,
+  InsufficientStorageError,
+  InternalServerError,
+  LengthRequiredError,
+  LockedError,
+  LoopDetectedError,
+  MethodNotAllowedError,
+  MisdirectedRequestError,
+  NetworkAuthenticationRequiredError,
+  NotAcceptableError,
+  NotExtendedError,
+  NotFoundError,
+  NotImplementedError,
+  PayloadTooLargeError,
+  PreconditionFailedError,
+  PreconditionRequiredError,
+  ProxyAuthRequiredError,
+  RequestHeaderFieldsTooLargeError,
+  RequestTimeoutError,
+  RequestedRangeNotSatisfiableError,
+  ServerError,
+  ServiceUnavailableError,
+  TeapotError,
+  TooManyRequestsError,
+  UnauthorizedError,
+  UnavailableForLegalReasonsError,
+  UnprocessableEntityError,
+  UnsupportedMediaTypeError,
+  UpgradeRequiredError,
+  UriTooLongError,
+  VariantAlsoNegotiatesError,
+  canonicalStatusByHttpStatus,
+  createAip193ErrorInfoDetail,
+  getCanonicalStatus,
+  toAip193ErrorPayload
+});