jimpex 7.0.2 → 9.0.0

package/dist/services/common/appError.d.mts

@@ -0,0 +1,139 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-efeb437e.js';
+import { Statuses } from '../../utils/fns/statuses.mjs';
+import '../../types/express.mjs';
+import 'express';
+import '../../types/http.mjs';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.mjs';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import 'statuses';
+
+/**
+ * A dictionary with some context information that can be provided to {@link AppError}.
+ *
+ * @group Services/AppError
+ */
+type AppErrorContext = {
+    /**
+     * Extra information that the error handler can pick and include the response.
+     */
+    response?: unknown;
+    /**
+     * A status code or name for the error handler to set in the response.
+     */
+    status?: string | number;
+} & Record<string, unknown>;
+/**
+ * A simple subclass of `Error` but with support for context information.
+ *
+ * @group Services
+ * @group Services/AppError
+ */
+declare class AppError extends Error {
+    /**
+     * The date of when the error was generated.
+     */
+    readonly _date: Date;
+    /**
+     * The context information that can be provided to the error, and picked by the error
+     * handler.
+     */
+    readonly _context: AppErrorContext;
+    /**
+     * The service that generates HTTP status codes.
+     */
+    protected _statuses: Statuses;
+    /**
+     * @param message   The message of the error.
+     * @param context   The context information, for the error handler.
+     * @param statuses  A reference to the service that generates HTTP status codes. This
+     *                  is in case the implementation wants to use a special version from
+     *                  the container; otherwise, it will use the `statuses` library
+     *                  directly.
+     */
+    constructor(message: string, context?: AppErrorContext, statuses?: Statuses);
+    /**
+     * Gets an object that can be included in a response from the application. This method
+     * is a helper for the `response` getter, as it allows for the assertion of the response
+     * type.
+     *
+     * @template T  The type of the response.
+     */
+    getResponse<T>(): T;
+    /**
+     * Information about the error that can be included in a response. This is set using the
+     * `response` key in the `context` option.
+     */
+    get response(): unknown;
+    /**
+     * An HTTP status code related to the error. This is set using the `status` key on the
+     * `context`.
+     */
+    get status(): number | undefined;
+    /**
+     * Context information related to the error.
+     */
+    get context(): unknown;
+    /**
+     * The date of when the error was generated.
+     */
+    get date(): Date;
+    /**
+     * Utility method that formats the context before saving it in the instance:
+     * - If the context includes a `status` as a `string`, it will try to replace it with
+     * its actual status code from the `statuses `service.
+     *
+     * @param context  The original context sent to the constructor.
+     */
+    protected _parseContext(context: AppErrorContext): AppErrorContext;
+}
+/**
+ * Shorthand for `new AppError()`.
+ *
+ * @param args  The same parameters as the {@link AppError} constructor.
+ * @returns A new instance of {@link AppError}.
+ * @group Services
+ * @group Services/AppError
+ */
+declare const createAppError: (message: string, context?: AppErrorContext | undefined, statuses?: Statuses | undefined) => AppError;
+/**
+ * The type of the function that generates a new instance of {@link AppError}.
+ * This is exported to make it easy to type the dependency injection.
+ *
+ * @group Services/AppError
+ */
+type CreateAppErrorFn = typeof createAppError;
+/**
+ * THe type of the {@link AppError} class.
+ * This is exported to make it easy to type the dependency injection.
+ *
+ * @group Services/AppError
+ */
+type AppErrorClass = typeof AppError;
+/**
+ * A service provider that will register both, {@link AppError} and
+ * {@link createAppError}, on the container. `AppError` will be the key for class, and
+ * `appError` will be for the generator function.
+ *
+ * @example
+ *
+ *   // Register it on the container
+ *   container.register(appErrorProvider);
+ *   // Getting access to the class.
+ *   const AppError = container.get<AppErrorClass>('AppError');
+ *   // Getting access to the function.
+ *   const appError = container.get<CreateAppErrorFn>('appError');
+ *
+ * @group Providers
+ * @group Services/AppError
+ */
+declare const appErrorProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { AppError, AppErrorClass, AppErrorContext, CreateAppErrorFn, appErrorProvider, createAppError };

package/dist/services/common/appError.d.ts

@@ -0,0 +1,139 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-b2a04c78.js';
+import { Statuses } from '../../utils/fns/statuses.js';
+import '../../types/express.js';
+import 'express';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.js';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import 'statuses';
+
+/**
+ * A dictionary with some context information that can be provided to {@link AppError}.
+ *
+ * @group Services/AppError
+ */
+type AppErrorContext = {
+    /**
+     * Extra information that the error handler can pick and include the response.
+     */
+    response?: unknown;
+    /**
+     * A status code or name for the error handler to set in the response.
+     */
+    status?: string | number;
+} & Record<string, unknown>;
+/**
+ * A simple subclass of `Error` but with support for context information.
+ *
+ * @group Services
+ * @group Services/AppError
+ */
+declare class AppError extends Error {
+    /**
+     * The date of when the error was generated.
+     */
+    readonly _date: Date;
+    /**
+     * The context information that can be provided to the error, and picked by the error
+     * handler.
+     */
+    readonly _context: AppErrorContext;
+    /**
+     * The service that generates HTTP status codes.
+     */
+    protected _statuses: Statuses;
+    /**
+     * @param message   The message of the error.
+     * @param context   The context information, for the error handler.
+     * @param statuses  A reference to the service that generates HTTP status codes. This
+     *                  is in case the implementation wants to use a special version from
+     *                  the container; otherwise, it will use the `statuses` library
+     *                  directly.
+     */
+    constructor(message: string, context?: AppErrorContext, statuses?: Statuses);
+    /**
+     * Gets an object that can be included in a response from the application. This method
+     * is a helper for the `response` getter, as it allows for the assertion of the response
+     * type.
+     *
+     * @template T  The type of the response.
+     */
+    getResponse<T>(): T;
+    /**
+     * Information about the error that can be included in a response. This is set using the
+     * `response` key in the `context` option.
+     */
+    get response(): unknown;
+    /**
+     * An HTTP status code related to the error. This is set using the `status` key on the
+     * `context`.
+     */
+    get status(): number | undefined;
+    /**
+     * Context information related to the error.
+     */
+    get context(): unknown;
+    /**
+     * The date of when the error was generated.
+     */
+    get date(): Date;
+    /**
+     * Utility method that formats the context before saving it in the instance:
+     * - If the context includes a `status` as a `string`, it will try to replace it with
+     * its actual status code from the `statuses `service.
+     *
+     * @param context  The original context sent to the constructor.
+     */
+    protected _parseContext(context: AppErrorContext): AppErrorContext;
+}
+/**
+ * Shorthand for `new AppError()`.
+ *
+ * @param args  The same parameters as the {@link AppError} constructor.
+ * @returns A new instance of {@link AppError}.
+ * @group Services
+ * @group Services/AppError
+ */
+declare const createAppError: (message: string, context?: AppErrorContext | undefined, statuses?: Statuses | undefined) => AppError;
+/**
+ * The type of the function that generates a new instance of {@link AppError}.
+ * This is exported to make it easy to type the dependency injection.
+ *
+ * @group Services/AppError
+ */
+type CreateAppErrorFn = typeof createAppError;
+/**
+ * THe type of the {@link AppError} class.
+ * This is exported to make it easy to type the dependency injection.
+ *
+ * @group Services/AppError
+ */
+type AppErrorClass = typeof AppError;
+/**
+ * A service provider that will register both, {@link AppError} and
+ * {@link createAppError}, on the container. `AppError` will be the key for class, and
+ * `appError` will be for the generator function.
+ *
+ * @example
+ *
+ *   // Register it on the container
+ *   container.register(appErrorProvider);
+ *   // Getting access to the class.
+ *   const AppError = container.get<AppErrorClass>('AppError');
+ *   // Getting access to the function.
+ *   const appError = container.get<CreateAppErrorFn>('appError');
+ *
+ * @group Providers
+ * @group Services/AppError
+ */
+declare const appErrorProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { AppError, AppErrorClass, AppErrorContext, CreateAppErrorFn, appErrorProvider, createAppError };

package/dist/services/common/appError.js

@@ -0,0 +1,126 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var appError_exports = {};
+__export(appError_exports, {
+  AppError: () => AppError,
+  appErrorProvider: () => appErrorProvider,
+  createAppError: () => createAppError
+});
+module.exports = __toCommonJS(appError_exports);
+var import_utils = require("../../utils");
+class AppError extends Error {
+  /**
+   * @param message   The message of the error.
+   * @param context   The context information, for the error handler.
+   * @param statuses  A reference to the service that generates HTTP status codes. This
+   *                  is in case the implementation wants to use a special version from
+   *                  the container; otherwise, it will use the `statuses` library
+   *                  directly.
+   */
+  constructor(message, context = {}, statuses = import_utils.statuses) {
+    super(message);
+    /**
+     * The date of when the error was generated.
+     */
+    __publicField(this, "_date");
+    /**
+     * The context information that can be provided to the error, and picked by the error
+     * handler.
+     */
+    __publicField(this, "_context");
+    /**
+     * The service that generates HTTP status codes.
+     */
+    __publicField(this, "_statuses");
+    this.name = this.constructor.name;
+    this._date = /* @__PURE__ */ new Date();
+    this._statuses = statuses;
+    this._context = this._parseContext(context);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Gets an object that can be included in a response from the application. This method
+   * is a helper for the `response` getter, as it allows for the assertion of the response
+   * type.
+   *
+   * @template T  The type of the response.
+   */
+  getResponse() {
+    return this.response;
+  }
+  /**
+   * Information about the error that can be included in a response. This is set using the
+   * `response` key in the `context` option.
+   */
+  get response() {
+    return this._context.response || {};
+  }
+  /**
+   * An HTTP status code related to the error. This is set using the `status` key on the
+   * `context`.
+   */
+  get status() {
+    return this._context.status;
+  }
+  /**
+   * Context information related to the error.
+   */
+  get context() {
+    return this._context;
+  }
+  /**
+   * The date of when the error was generated.
+   */
+  get date() {
+    return this._date;
+  }
+  /**
+   * Utility method that formats the context before saving it in the instance:
+   * - If the context includes a `status` as a `string`, it will try to replace it with
+   * its actual status code from the `statuses `service.
+   *
+   * @param context  The original context sent to the constructor.
+   */
+  _parseContext(context) {
+    const result = { ...context };
+    if (result.status && typeof result.status === "string") {
+      result.status = this._statuses.code[result.status.toLowerCase()] || result.status;
+    }
+    return result;
+  }
+}
+const createAppError = (...args) => new AppError(...args);
+const appErrorProvider = (0, import_utils.provider)((app) => {
+  app.set("AppError", () => AppError);
+  app.set("appError", () => createAppError);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppError,
+  appErrorProvider,
+  createAppError
+});
+//# sourceMappingURL=appError.js.map

package/dist/services/common/appError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/common/appError.ts"],"sourcesContent":["import { provider, statuses as statusesFn, type Statuses } from '../../utils';\n/**\n * A dictionary with some context information that can be provided to {@link AppError}.\n *\n * @group Services/AppError\n */\nexport type AppErrorContext = {\n  /**\n   * Extra information that the error handler can pick and include the response.\n   */\n  response?: unknown;\n  /**\n   * A status code or name for the error handler to set in the response.\n   */\n  status?: string | number;\n} & Record<string, unknown>;\n/**\n * A simple subclass of `Error` but with support for context information.\n *\n * @group Services\n * @group Services/AppError\n */\nexport class AppError extends Error {\n  /**\n   * The date of when the error was generated.\n   */\n  readonly _date: Date;\n  /**\n   * The context information that can be provided to the error, and picked by the error\n   * handler.\n   */\n  readonly _context: AppErrorContext;\n  /**\n   * The service that generates HTTP status codes.\n   */\n  protected _statuses: Statuses;\n  /**\n   * @param message   The message of the error.\n   * @param context   The context information, for the error handler.\n   * @param statuses  A reference to the service that generates HTTP status codes. This\n   *                  is in case the implementation wants to use a special version from\n   *                  the container; otherwise, it will use the `statuses` library\n   *                  directly.\n   */\n  constructor(\n    message: string,\n    context: AppErrorContext = {},\n    statuses: Statuses = statusesFn,\n  ) {\n    super(message);\n    this.name = this.constructor.name;\n    this._date = new Date();\n    this._statuses = statuses;\n    this._context = this._parseContext(context);\n\n    // Limit the stack trace if possible.\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  }\n  /**\n   * Gets an object that can be included in a response from the application. This method\n   * is a helper for the `response` getter, as it allows for the assertion of the response\n   * type.\n   *\n   * @template T  The type of the response.\n   */\n  getResponse<T>(): T {\n    return this.response as T;\n  }\n  /**\n   * Information about the error that can be included in a response. This is set using the\n   * `response` key in the `context` option.\n   */\n  get response(): unknown {\n    return this._context.response || {};\n  }\n  /**\n   * An HTTP status code related to the error. This is set using the `status` key on the\n   * `context`.\n   */\n  get status(): number | undefined {\n    return this._context.status as number | undefined;\n  }\n  /**\n   * Context information related to the error.\n   */\n  get context(): unknown {\n    return this._context;\n  }\n  /**\n   * The date of when the error was generated.\n   */\n  get date(): Date {\n    return this._date;\n  }\n  /**\n   * Utility method that formats the context before saving it in the instance:\n   * - If the context includes a `status` as a `string`, it will try to replace it with\n   * its actual status code from the `statuses `service.\n   *\n   * @param context  The original context sent to the constructor.\n   */\n  protected _parseContext(context: AppErrorContext): AppErrorContext {\n    const result = { ...context };\n    if (result.status && typeof result.status === 'string') {\n      result.status = this._statuses.code[result.status.toLowerCase()] || result.status;\n    }\n\n    return result;\n  }\n}\n/**\n * Shorthand for `new AppError()`.\n *\n * @param args  The same parameters as the {@link AppError} constructor.\n * @returns A new instance of {@link AppError}.\n * @group Services\n * @group Services/AppError\n */\nexport const createAppError = (\n  ...args: ConstructorParameters<typeof AppError>\n): AppError => new AppError(...args);\n/**\n * The type of the function that generates a new instance of {@link AppError}.\n * This is exported to make it easy to type the dependency injection.\n *\n * @group Services/AppError\n */\nexport type CreateAppErrorFn = typeof createAppError;\n/**\n * THe type of the {@link AppError} class.\n * This is exported to make it easy to type the dependency injection.\n *\n * @group Services/AppError\n */\nexport type AppErrorClass = typeof AppError;\n/**\n * A service provider that will register both, {@link AppError} and\n * {@link createAppError}, on the container. `AppError` will be the key for class, and\n * `appError` will be for the generator function.\n *\n * @example\n *\n *   // Register it on the container\n *   container.register(appErrorProvider);\n *   // Getting access to the class.\n *   const AppError = container.get<AppErrorClass>('AppError');\n *   // Getting access to the function.\n *   const appError = container.get<CreateAppErrorFn>('appError');\n *\n * @group Providers\n * @group Services/AppError\n */\nexport const appErrorProvider = provider((app) => {\n  app.set('AppError', () => AppError);\n  app.set('appError', () => createAppError);\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAgE;AAsBzD,MAAM,iBAAiB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBlC,YACE,SACA,UAA2B,CAAC,GAC5B,WAAqB,aAAAA,UACrB;AACA,UAAM,OAAO;AAvBf;AAAA;AAAA;AAAA,wBAAS;AAKT;AAAA;AAAA;AAAA;AAAA,wBAAS;AAIT;AAAA;AAAA;AAAA,wBAAU;AAeR,SAAK,OAAO,KAAK,YAAY;AAC7B,SAAK,QAAQ,oBAAI,KAAK;AACtB,SAAK,YAAY;AACjB,SAAK,WAAW,KAAK,cAAc,OAAO;AAG1C,QAAI,MAAM,mBAAmB;AAC3B,YAAM,kBAAkB,MAAM,KAAK,WAAW;AAAA,IAChD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,cAAoB;AAClB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,WAAoB;AACtB,WAAO,KAAK,SAAS,YAAY,CAAC;AAAA,EACpC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,SAA6B;AAC/B,WAAO,KAAK,SAAS;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,UAAmB;AACrB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,OAAa;AACf,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,cAAc,SAA2C;AACjE,UAAM,SAAS,EAAE,GAAG,QAAQ;AAC5B,QAAI,OAAO,UAAU,OAAO,OAAO,WAAW,UAAU;AACtD,aAAO,SAAS,KAAK,UAAU,KAAK,OAAO,OAAO,YAAY,CAAC,KAAK,OAAO;AAAA,IAC7E;AAEA,WAAO;AAAA,EACT;AACF;AASO,MAAM,iBAAiB,IACzB,SACU,IAAI,SAAS,GAAG,IAAI;AAgC5B,MAAM,uBAAmB,uBAAS,CAAC,QAAQ;AAChD,MAAI,IAAI,YAAY,MAAM,QAAQ;AAClC,MAAI,IAAI,YAAY,MAAM,cAAc;AAC1C,CAAC;","names":["statusesFn"]}

package/dist/services/common/httpError.d.mts

@@ -0,0 +1,80 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-efeb437e.js';
+import { Statuses } from '../../utils/fns/statuses.mjs';
+import { AppError, AppErrorContext } from './appError.mjs';
+import '../../types/express.mjs';
+import 'express';
+import '../../types/http.mjs';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.mjs';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import 'statuses';
+
+/**
+ * A type of error to be used on HTTP requests. This is the most common type of error used
+ * by Jimpex.
+ *
+ * @group Services
+ * @group Services/HTTPError
+ */
+declare class HTTPError extends AppError {
+    /**
+     * @param message   The error message.
+     * @param status    The HTTP status code.
+     * @param context   Context information related to the error.
+     * @param statuses  A reference to the service that generates HTTP status codes. This
+     *                  is in case the implementation wants to use a special version from
+     *                  the container; otherwise, it will use the `statuses` library
+     *                  directly.
+     */
+    constructor(message: string, status?: number | string, context?: AppErrorContext, statuses?: Statuses);
+}
+/**
+ * Shorthand for `new HTTPError()`.
+ *
+ * @param args  The same parameters as the {@link HTTPError} constructor.
+ * @returns A new instance of {@link HTTPError}.
+ * @group Services
+ * @group Services/HTTPError
+ */
+declare const createHTTPError: (message: string, status?: string | number | undefined, context?: AppErrorContext | undefined, statuses?: Statuses | undefined) => HTTPError;
+/**
+ * The type of the function that generates a new instance of {@link HTTPError}.
+ * This is exported to make it easy to type the dependency injection.
+ *
+ * @group Services/HTTPError
+ */
+type CreateHTTPErrorFn = typeof createHTTPError;
+/**
+ * THe type of the {@link HTTPError} class.
+ * This is exported to make it easy to type the dependency injection.
+ *
+ * @group Services/HTTPError
+ */
+type HTTPErrorClass = typeof HTTPError;
+/**
+ * A service provider that will register both the {@link HTTPError} and a generator
+ * function on the container. `HTTPError` will be the key for class, and `httpError` will
+ * be for the generator function.
+ *
+ * @example
+ *
+ *   // Register it on the container
+ *   container.register(httpErrorProvider);
+ *   // Getting access to the class.
+ *   const HTTPError = container.get<HTTPErrorClass>('HTTPError');
+ *   // Getting access to the function.
+ *   const httpError = container.get<CreateHTTPErrorFn>('httpError');
+ *
+ * @group Providers
+ * @group Services/HTTPError
+ */
+declare const httpErrorProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { CreateHTTPErrorFn, HTTPError, HTTPErrorClass, createHTTPError, httpErrorProvider };

package/dist/services/common/httpError.d.ts

@@ -0,0 +1,80 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-b2a04c78.js';
+import { Statuses } from '../../utils/fns/statuses.js';
+import { AppError, AppErrorContext } from './appError.js';
+import '../../types/express.js';
+import 'express';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.js';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import 'statuses';
+
+/**
+ * A type of error to be used on HTTP requests. This is the most common type of error used
+ * by Jimpex.
+ *
+ * @group Services
+ * @group Services/HTTPError
+ */
+declare class HTTPError extends AppError {
+    /**
+     * @param message   The error message.
+     * @param status    The HTTP status code.
+     * @param context   Context information related to the error.
+     * @param statuses  A reference to the service that generates HTTP status codes. This
+     *                  is in case the implementation wants to use a special version from
+     *                  the container; otherwise, it will use the `statuses` library
+     *                  directly.
+     */
+    constructor(message: string, status?: number | string, context?: AppErrorContext, statuses?: Statuses);
+}
+/**
+ * Shorthand for `new HTTPError()`.
+ *
+ * @param args  The same parameters as the {@link HTTPError} constructor.
+ * @returns A new instance of {@link HTTPError}.
+ * @group Services
+ * @group Services/HTTPError
+ */
+declare const createHTTPError: (message: string, status?: string | number | undefined, context?: AppErrorContext | undefined, statuses?: Statuses | undefined) => HTTPError;
+/**
+ * The type of the function that generates a new instance of {@link HTTPError}.
+ * This is exported to make it easy to type the dependency injection.
+ *
+ * @group Services/HTTPError
+ */
+type CreateHTTPErrorFn = typeof createHTTPError;
+/**
+ * THe type of the {@link HTTPError} class.
+ * This is exported to make it easy to type the dependency injection.
+ *
+ * @group Services/HTTPError
+ */
+type HTTPErrorClass = typeof HTTPError;
+/**
+ * A service provider that will register both the {@link HTTPError} and a generator
+ * function on the container. `HTTPError` will be the key for class, and `httpError` will
+ * be for the generator function.
+ *
+ * @example
+ *
+ *   // Register it on the container
+ *   container.register(httpErrorProvider);
+ *   // Getting access to the class.
+ *   const HTTPError = container.get<HTTPErrorClass>('HTTPError');
+ *   // Getting access to the function.
+ *   const httpError = container.get<CreateHTTPErrorFn>('httpError');
+ *
+ * @group Providers
+ * @group Services/HTTPError
+ */
+declare const httpErrorProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { CreateHTTPErrorFn, HTTPError, HTTPErrorClass, createHTTPError, httpErrorProvider };

package/dist/services/common/httpError.js

@@ -0,0 +1,53 @@
+"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);
+var httpError_exports = {};
+__export(httpError_exports, {
+  HTTPError: () => HTTPError,
+  createHTTPError: () => createHTTPError,
+  httpErrorProvider: () => httpErrorProvider
+});
+module.exports = __toCommonJS(httpError_exports);
+var import_utils = require("../../utils");
+var import_appError = require("./appError");
+class HTTPError extends import_appError.AppError {
+  /**
+   * @param message   The error message.
+   * @param status    The HTTP status code.
+   * @param context   Context information related to the error.
+   * @param statuses  A reference to the service that generates HTTP status codes. This
+   *                  is in case the implementation wants to use a special version from
+   *                  the container; otherwise, it will use the `statuses` library
+   *                  directly.
+   */
+  constructor(message, status = (0, import_utils.statuses)("ok"), context = {}, statuses = import_utils.statuses) {
+    super(message, { ...context, status }, statuses);
+  }
+}
+const createHTTPError = (...args) => new HTTPError(...args);
+const httpErrorProvider = (0, import_utils.provider)((app) => {
+  app.set("HTTPError", () => HTTPError);
+  app.set("httpError", () => createHTTPError);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HTTPError,
+  createHTTPError,
+  httpErrorProvider
+});
+//# sourceMappingURL=httpError.js.map

package/dist/services/common/httpError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/common/httpError.ts"],"sourcesContent":["import { provider, statuses as statusesFn, type Statuses } from '../../utils';\nimport { AppError, type AppErrorContext } from './appError';\n/**\n * A type of error to be used on HTTP requests. This is the most common type of error used\n * by Jimpex.\n *\n * @group Services\n * @group Services/HTTPError\n */\nexport class HTTPError extends AppError {\n  /**\n   * @param message   The error message.\n   * @param status    The HTTP status code.\n   * @param context   Context information related to the error.\n   * @param statuses  A reference to the service that generates HTTP status codes. This\n   *                  is in case the implementation wants to use a special version from\n   *                  the container; otherwise, it will use the `statuses` library\n   *                  directly.\n   */\n  constructor(\n    message: string,\n    status: number | string = statusesFn('ok'),\n    context: AppErrorContext = {},\n    statuses: Statuses = statusesFn,\n  ) {\n    super(message, { ...context, status }, statuses);\n  }\n}\n/**\n * Shorthand for `new HTTPError()`.\n *\n * @param args  The same parameters as the {@link HTTPError} constructor.\n * @returns A new instance of {@link HTTPError}.\n * @group Services\n * @group Services/HTTPError\n */\nexport const createHTTPError = (\n  ...args: ConstructorParameters<typeof HTTPError>\n): HTTPError => new HTTPError(...args);\n/**\n * The type of the function that generates a new instance of {@link HTTPError}.\n * This is exported to make it easy to type the dependency injection.\n *\n * @group Services/HTTPError\n */\nexport type CreateHTTPErrorFn = typeof createHTTPError;\n/**\n * THe type of the {@link HTTPError} class.\n * This is exported to make it easy to type the dependency injection.\n *\n * @group Services/HTTPError\n */\nexport type HTTPErrorClass = typeof HTTPError;\n/**\n * A service provider that will register both the {@link HTTPError} and a generator\n * function on the container. `HTTPError` will be the key for class, and `httpError` will\n * be for the generator function.\n *\n * @example\n *\n *   // Register it on the container\n *   container.register(httpErrorProvider);\n *   // Getting access to the class.\n *   const HTTPError = container.get<HTTPErrorClass>('HTTPError');\n *   // Getting access to the function.\n *   const httpError = container.get<CreateHTTPErrorFn>('httpError');\n *\n * @group Providers\n * @group Services/HTTPError\n */\nexport const httpErrorProvider = provider((app) => {\n  app.set('HTTPError', () => HTTPError);\n  app.set('httpError', () => createHTTPError);\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAgE;AAChE,sBAA+C;AAQxC,MAAM,kBAAkB,yBAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUtC,YACE,SACA,aAA0B,aAAAA,UAAW,IAAI,GACzC,UAA2B,CAAC,GAC5B,WAAqB,aAAAA,UACrB;AACA,UAAM,SAAS,EAAE,GAAG,SAAS,OAAO,GAAG,QAAQ;AAAA,EACjD;AACF;AASO,MAAM,kBAAkB,IAC1B,SACW,IAAI,UAAU,GAAG,IAAI;AAgC9B,MAAM,wBAAoB,uBAAS,CAAC,QAAQ;AACjD,MAAI,IAAI,aAAa,MAAM,SAAS;AACpC,MAAI,IAAI,aAAa,MAAM,eAAe;AAC5C,CAAC;","names":["statusesFn"]}