@periodic/obsidian 1.0.0

package/dist/index.js

@@ -0,0 +1,424 @@
+"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, {
+  HttpError: () => HttpError,
+  HttpStatusCode: () => HttpStatusCode,
+  HttpStatusMessage: () => HttpStatusMessage,
+  errorHandler: () => errorHandler,
+  obsidian: () => obsidian,
+  simpleErrorHandler: () => simpleErrorHandler,
+  titanium: () => obsidian
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/status-codes.ts
+var HttpStatusCode = {
+  // 1xx Informational
+  CONTINUE: 100,
+  SWITCHING_PROTOCOLS: 101,
+  PROCESSING: 102,
+  EARLY_HINTS: 103,
+  // 2xx Success
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NON_AUTHORITATIVE_INFORMATION: 203,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+  MULTI_STATUS: 207,
+  ALREADY_REPORTED: 208,
+  IM_USED: 226,
+  // 3xx Redirection
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  USE_PROXY: 305,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  // 4xx Client Errors
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  IM_A_TEAPOT: 418,
+  MISDIRECTED_REQUEST: 421,
+  UNPROCESSABLE_ENTITY: 422,
+  LOCKED: 423,
+  FAILED_DEPENDENCY: 424,
+  TOO_EARLY: 425,
+  UPGRADE_REQUIRED: 426,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  // 5xx Server Errors
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505,
+  VARIANT_ALSO_NEGOTIATES: 506,
+  INSUFFICIENT_STORAGE: 507,
+  LOOP_DETECTED: 508,
+  NOT_EXTENDED: 510,
+  NETWORK_AUTHENTICATION_REQUIRED: 511
+};
+var HttpStatusMessage = {
+  // 1xx Informational
+  100: "Continue",
+  101: "Switching Protocols",
+  102: "Processing",
+  103: "Early Hints",
+  // 2xx Success
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  207: "Multi-Status",
+  208: "Already Reported",
+  226: "IM Used",
+  // 3xx Redirection
+  300: "Multiple Choices",
+  301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  305: "Use Proxy",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
+  // 4xx Client Errors
+  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",
+  421: "Misdirected Request",
+  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",
+  // 5xx Server Errors
+  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"
+};
+
+// src/core/http-error.ts
+var HttpError = class _HttpError extends Error {
+  /**
+   * Creates a new HTTP error
+   *
+   * @param status - HTTP status code
+   * @param message - Human-readable error message
+   * @param options - Optional error metadata
+   */
+  constructor(status, message, options) {
+    super(message);
+    Object.setPrototypeOf(this, _HttpError.prototype);
+    this.name = "HttpError";
+    this.status = status;
+    this.code = options?.code;
+    this.details = options?.details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Serializes the error to a plain JSON object
+   *
+   * @returns JSON representation without stack trace
+   *
+   * @example
+   * ```ts
+   * const error = new HttpError(404, 'Not found');
+   * console.log(error.toJSON());
+   * // { status: 404, message: 'Not found' }
+   * ```
+   */
+  toJSON() {
+    const json = {
+      status: this.status,
+      message: this.message
+    };
+    if (this.code !== void 0) {
+      json.code = this.code;
+    }
+    if (this.details !== void 0) {
+      json.details = this.details;
+    }
+    return json;
+  }
+  /**
+   * Returns the default message for a given HTTP status code
+   *
+   * @param status - HTTP status code
+   * @returns Default status message or 'Unknown Error'
+   */
+  static getDefaultMessage(status) {
+    return HttpStatusMessage[status] || "Unknown Error";
+  }
+};
+
+// src/adapters/express.ts
+function errorHandler(options = {}) {
+  const { includeStack = process.env.NODE_ENV !== "production", logger, transform } = options;
+  return (err, req, res, _next) => {
+    if (logger) {
+      logger(err, req);
+    }
+    if (err instanceof HttpError) {
+      const response = transform ? transform(err) : err.toJSON();
+      res.status(err.status).json(response);
+      return;
+    }
+    if (!includeStack) {
+      res.status(500).json({
+        status: 500,
+        message: "Internal Server Error"
+      });
+      return;
+    }
+    res.status(500).json({
+      status: 500,
+      message: err.message,
+      stack: err.stack
+    });
+  };
+}
+function simpleErrorHandler() {
+  return (err, _req, res, next) => {
+    if (err instanceof HttpError) {
+      res.status(err.status).json(err.toJSON());
+      return;
+    }
+    next(err);
+  };
+}
+
+// src/core/factories.ts
+function createFactory(status) {
+  return (message, options) => {
+    const errorMessage = message || HttpError.getDefaultMessage(status);
+    return new HttpError(status, errorMessage, options);
+  };
+}
+var continueError = createFactory(HttpStatusCode.CONTINUE);
+var switchingProtocols = createFactory(HttpStatusCode.SWITCHING_PROTOCOLS);
+var processing = createFactory(HttpStatusCode.PROCESSING);
+var earlyHints = createFactory(HttpStatusCode.EARLY_HINTS);
+var ok = createFactory(HttpStatusCode.OK);
+var created = createFactory(HttpStatusCode.CREATED);
+var accepted = createFactory(HttpStatusCode.ACCEPTED);
+var nonAuthoritativeInformation = createFactory(
+  HttpStatusCode.NON_AUTHORITATIVE_INFORMATION
+);
+var noContent = createFactory(HttpStatusCode.NO_CONTENT);
+var resetContent = createFactory(HttpStatusCode.RESET_CONTENT);
+var partialContent = createFactory(HttpStatusCode.PARTIAL_CONTENT);
+var multiStatus = createFactory(HttpStatusCode.MULTI_STATUS);
+var alreadyReported = createFactory(HttpStatusCode.ALREADY_REPORTED);
+var imUsed = createFactory(HttpStatusCode.IM_USED);
+var multipleChoices = createFactory(HttpStatusCode.MULTIPLE_CHOICES);
+var movedPermanently = createFactory(HttpStatusCode.MOVED_PERMANENTLY);
+var found = createFactory(HttpStatusCode.FOUND);
+var seeOther = createFactory(HttpStatusCode.SEE_OTHER);
+var notModified = createFactory(HttpStatusCode.NOT_MODIFIED);
+var useProxy = createFactory(HttpStatusCode.USE_PROXY);
+var temporaryRedirect = createFactory(HttpStatusCode.TEMPORARY_REDIRECT);
+var permanentRedirect = createFactory(HttpStatusCode.PERMANENT_REDIRECT);
+var badRequest = createFactory(HttpStatusCode.BAD_REQUEST);
+var unauthorized = createFactory(HttpStatusCode.UNAUTHORIZED);
+var paymentRequired = createFactory(HttpStatusCode.PAYMENT_REQUIRED);
+var forbidden = createFactory(HttpStatusCode.FORBIDDEN);
+var notFound = createFactory(HttpStatusCode.NOT_FOUND);
+var methodNotAllowed = createFactory(HttpStatusCode.METHOD_NOT_ALLOWED);
+var notAcceptable = createFactory(HttpStatusCode.NOT_ACCEPTABLE);
+var proxyAuthenticationRequired = createFactory(
+  HttpStatusCode.PROXY_AUTHENTICATION_REQUIRED
+);
+var requestTimeout = createFactory(HttpStatusCode.REQUEST_TIMEOUT);
+var conflict = createFactory(HttpStatusCode.CONFLICT);
+var gone = createFactory(HttpStatusCode.GONE);
+var lengthRequired = createFactory(HttpStatusCode.LENGTH_REQUIRED);
+var preconditionFailed = createFactory(HttpStatusCode.PRECONDITION_FAILED);
+var payloadTooLarge = createFactory(HttpStatusCode.PAYLOAD_TOO_LARGE);
+var uriTooLong = createFactory(HttpStatusCode.URI_TOO_LONG);
+var unsupportedMediaType = createFactory(HttpStatusCode.UNSUPPORTED_MEDIA_TYPE);
+var rangeNotSatisfiable = createFactory(HttpStatusCode.RANGE_NOT_SATISFIABLE);
+var expectationFailed = createFactory(HttpStatusCode.EXPECTATION_FAILED);
+var imATeapot = createFactory(HttpStatusCode.IM_A_TEAPOT);
+var misdirectedRequest = createFactory(HttpStatusCode.MISDIRECTED_REQUEST);
+var unprocessableEntity = createFactory(HttpStatusCode.UNPROCESSABLE_ENTITY);
+var locked = createFactory(HttpStatusCode.LOCKED);
+var failedDependency = createFactory(HttpStatusCode.FAILED_DEPENDENCY);
+var tooEarly = createFactory(HttpStatusCode.TOO_EARLY);
+var upgradeRequired = createFactory(HttpStatusCode.UPGRADE_REQUIRED);
+var preconditionRequired = createFactory(HttpStatusCode.PRECONDITION_REQUIRED);
+var tooManyRequests = createFactory(HttpStatusCode.TOO_MANY_REQUESTS);
+var requestHeaderFieldsTooLarge = createFactory(
+  HttpStatusCode.REQUEST_HEADER_FIELDS_TOO_LARGE
+);
+var unavailableForLegalReasons = createFactory(
+  HttpStatusCode.UNAVAILABLE_FOR_LEGAL_REASONS
+);
+var internalServerError = createFactory(HttpStatusCode.INTERNAL_SERVER_ERROR);
+var notImplemented = createFactory(HttpStatusCode.NOT_IMPLEMENTED);
+var badGateway = createFactory(HttpStatusCode.BAD_GATEWAY);
+var serviceUnavailable = createFactory(HttpStatusCode.SERVICE_UNAVAILABLE);
+var gatewayTimeout = createFactory(HttpStatusCode.GATEWAY_TIMEOUT);
+var httpVersionNotSupported = createFactory(HttpStatusCode.HTTP_VERSION_NOT_SUPPORTED);
+var variantAlsoNegotiates = createFactory(HttpStatusCode.VARIANT_ALSO_NEGOTIATES);
+var insufficientStorage = createFactory(HttpStatusCode.INSUFFICIENT_STORAGE);
+var loopDetected = createFactory(HttpStatusCode.LOOP_DETECTED);
+var notExtended = createFactory(HttpStatusCode.NOT_EXTENDED);
+var networkAuthenticationRequired = createFactory(
+  HttpStatusCode.NETWORK_AUTHENTICATION_REQUIRED
+);
+
+// src/index.ts
+var obsidian = {
+  // 1xx Informational
+  continue: continueError,
+  switchingProtocols,
+  processing,
+  earlyHints,
+  // 2xx Success
+  ok,
+  created,
+  accepted,
+  nonAuthoritativeInformation,
+  noContent,
+  resetContent,
+  partialContent,
+  multiStatus,
+  alreadyReported,
+  imUsed,
+  // 3xx Redirection
+  multipleChoices,
+  movedPermanently,
+  found,
+  seeOther,
+  notModified,
+  useProxy,
+  temporaryRedirect,
+  permanentRedirect,
+  // 4xx Client Errors
+  badRequest,
+  unauthorized,
+  paymentRequired,
+  forbidden,
+  notFound,
+  methodNotAllowed,
+  notAcceptable,
+  proxyAuthenticationRequired,
+  requestTimeout,
+  conflict,
+  gone,
+  lengthRequired,
+  preconditionFailed,
+  payloadTooLarge,
+  uriTooLong,
+  unsupportedMediaType,
+  rangeNotSatisfiable,
+  expectationFailed,
+  imATeapot,
+  misdirectedRequest,
+  unprocessableEntity,
+  locked,
+  failedDependency,
+  tooEarly,
+  upgradeRequired,
+  preconditionRequired,
+  tooManyRequests,
+  requestHeaderFieldsTooLarge,
+  unavailableForLegalReasons,
+  // 5xx Server Errors
+  internalServerError,
+  badGateway,
+  serviceUnavailable,
+  gatewayTimeout,
+  notImplemented,
+  httpVersionNotSupported,
+  variantAlsoNegotiates,
+  insufficientStorage,
+  loopDetected,
+  notExtended,
+  networkAuthenticationRequired
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpError,
+  HttpStatusCode,
+  HttpStatusMessage,
+  errorHandler,
+  obsidian,
+  simpleErrorHandler,
+  titanium
+});