@web-ts-toolkit/http-errors 0.0.2

package/index.mjs

@@ -0,0 +1,372 @@
+// 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);
+  }
+};
+export {
+  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
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@web-ts-toolkit/http-errors",
+  "description": "HTTP error classes for backend APIs",
+  "version": "0.0.2",
+  "keywords": [
+    "http-errors",
+    "api-errors"
+  ],
+  "main": "./index.js",
+  "module": "./index.mjs",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "author": "Junmin Dev",
+  "bugs": {
+    "url": "https://github.com/egose/web-ts-toolkit/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/egose/web-ts-toolkit.git",
+    "directory": "packages/http-errors"
+  }
+}