jimpex 8.0.0 → 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

@@ -1,7 +1,6 @@
 import * as _homer0_jimple from '@homer0/jimple';
-import { J as Jimpex } from '../../jimpex-7eaee271.js';
+import { J as Jimpex } from '../../index-b2a04c78.js';
 import { Statuses } from '../../utils/fns/statuses.js';
-import '@homer0/events-hub';
 import '../../types/express.js';
 import 'express';
 import '../../types/http.js';
@@ -9,9 +8,11 @@ import 'https';
 import 'http';
 import 'spdy';
 import 'node-fetch';
-import '@homer0/simple-config';
 import '../../types/utils.js';
+import '@homer0/path-utils';
 import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
 import 'statuses';
 
 /**

package/dist/services/common/appError.js

@@ -30,34 +30,80 @@ __export(appError_exports, {
 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 = new Date();
+    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") {

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

@@ -1 +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,EAsBlC,YACE,SACA,UAA2B,CAAC,GAC5B,WAAqB,aAAAA,UACrB;AACA,UAAM,OAAO;AAvBf,wBAAS;AAKT,wBAAS;AAIT,wBAAU;AAeR,SAAK,OAAO,KAAK,YAAY;AAC7B,SAAK,QAAQ,IAAI,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,EAQA,cAAoB;AAClB,WAAO,KAAK;AAAA,EACd;AAAA,EAKA,IAAI,WAAoB;AACtB,WAAO,KAAK,SAAS,YAAY,CAAC;AAAA,EACpC;AAAA,EAKA,IAAI,SAA6B;AAC/B,WAAO,KAAK,SAAS;AAAA,EACvB;AAAA,EAIA,IAAI,UAAmB;AACrB,WAAO,KAAK;AAAA,EACd;AAAA,EAIA,IAAI,OAAa;AACf,WAAO,KAAK;AAAA,EACd;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,MAAM,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"]}
+{"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

@@ -1,8 +1,7 @@
 import * as _homer0_jimple from '@homer0/jimple';
-import { J as Jimpex } from '../../jimpex-7eaee271.js';
+import { J as Jimpex } from '../../index-b2a04c78.js';
 import { Statuses } from '../../utils/fns/statuses.js';
 import { AppError, AppErrorContext } from './appError.js';
-import '@homer0/events-hub';
 import '../../types/express.js';
 import 'express';
 import '../../types/http.js';
@@ -10,9 +9,11 @@ import 'https';
 import 'http';
 import 'spdy';
 import 'node-fetch';
-import '@homer0/simple-config';
 import '../../types/utils.js';
+import '@homer0/path-utils';
 import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
 import 'statuses';
 
 /**

package/dist/services/common/httpError.js

@@ -26,6 +26,15 @@ 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);
   }

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

@@ -1 +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,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"]}
+{"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"]}

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

@@ -0,0 +1,47 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-efeb437e.js';
+export { AppError, AppErrorClass, AppErrorContext, CreateAppErrorFn, appErrorProvider, createAppError } from './appError.mjs';
+export { CreateHTTPErrorFn, HTTPError, HTTPErrorClass, createHTTPError, httpErrorProvider } from './httpError.mjs';
+export { SendFile, SendFileGeneratorOptions, SendFileOptions, sendFile, sendFileProvider } from './sendFile.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 '../../utils/fns/statuses.mjs';
+import 'statuses';
+
+/**
+ * Registers all the common services on the container.
+ *
+ * - {@link AppError | appError}
+ * - {@link HTTPError | httpError}
+ * - {@link SendFile | sendFile}
+ *
+ * @example
+ *
+ *   // Register the collection on the container
+ *   container.register(commonServicesProvider);
+ *   // Getting access to one the services instance
+ *   const sendFile = container.get<SendFile>('sendFile');
+ *
+ * @group Providers
+ */
+declare const commonServicesProvider: {
+    appErrorProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+    httpErrorProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+    sendFileProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+} & Record<string, _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>> & {
+    provider: true;
+} & {
+    register: _homer0_jimple.ProviderRegisterFn<Jimpex>;
+} & Record<string, unknown>;
+
+export { commonServicesProvider };

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

@@ -1,9 +1,8 @@
 import * as _homer0_jimple from '@homer0/jimple';
-import { J as Jimpex } from '../../jimpex-7eaee271.js';
+import { J as Jimpex } from '../../index-b2a04c78.js';
 export { AppError, AppErrorClass, AppErrorContext, CreateAppErrorFn, appErrorProvider, createAppError } from './appError.js';
 export { CreateHTTPErrorFn, HTTPError, HTTPErrorClass, createHTTPError, httpErrorProvider } from './httpError.js';
 export { SendFile, SendFileGeneratorOptions, SendFileOptions, sendFile, sendFileProvider } from './sendFile.js';
-import '@homer0/events-hub';
 import '../../types/express.js';
 import 'express';
 import '../../types/http.js';
@@ -11,12 +10,13 @@ import 'https';
 import 'http';
 import 'spdy';
 import 'node-fetch';
-import '@homer0/simple-config';
 import '../../types/utils.js';
+import '@homer0/path-utils';
 import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
 import '../../utils/fns/statuses.js';
 import 'statuses';
-import '@homer0/path-utils';
 
 /**
  * Registers all the common services on the container.

package/dist/services/common/index.js

@@ -36,6 +36,9 @@ const commonServicesProvider = (0, import_utils.providers)({
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  commonServicesProvider
+  commonServicesProvider,
+  ...require("./appError"),
+  ...require("./httpError"),
+  ...require("./sendFile")
 });
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,102 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-efeb437e.js';
+import { Response, NextFunction } from 'express';
+import { PathUtils } from '@homer0/path-utils';
+import '../../types/express.mjs';
+import '../../types/http.mjs';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import '../../types/utils.mjs';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+
+/**
+ * The options to create a {@link SendFile} function.
+ *
+ * @group Services/SendFile
+ */
+type SendFileGeneratorOptions = {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        pathUtils: PathUtils;
+    };
+};
+/**
+ * The options for the function that actually serves a file.
+ *
+ * @group Services/SendFile
+ */
+type SendFileOptions = {
+    /**
+     * The response object sent by the application. Necessary to write the file.
+     */
+    res: Response;
+    /**
+     * The path of the file to serve. Depending on the `from` option, it will be either
+     * relative to the project root, or the application executable.
+     */
+    filepath: string;
+    /**
+     * The name of a location on the `pathUtils` service from where the `filepath` is
+     * relative to. It can be `app` for the directory containing the application executable,
+     * or `project` for the project root. It could also be any other location that the
+     * implementation may have registered.
+     *
+     * @default 'app'
+     */
+    from?: string;
+    /**
+     * The function to move to the next middleware. It can be used to report an error in
+     * case the file can't be served.
+     *
+     * @default {() => {}}
+     */
+    next?: NextFunction;
+};
+/**
+ * The type of the function that serves a file.
+ * This is exported to make it easy to type the dependency injection.
+ *
+ * @group Services/SendFile
+ */
+type SendFile = (options: SendFileOptions) => void;
+/**
+ * Generates a function to send files on the application response.
+ *
+ * @param options  To inject the required dependencies.
+ * @example
+ *
+ * <caption>Basic usage</caption>
+ *
+ *   // Let's say this is inside an Express middleware.
+ *   // Get the function
+ *   const send = sendFile(pathUtils);
+ *   send({ res, filepath: 'some-file.html', next });
+ *   // If your app is on "/app/index.js", this will send "/app/some-file.html".
+ *
+ * @group Services
+ * @group Services/SendFile
+ */
+declare const sendFile: ({ inject: { pathUtils } }: SendFileGeneratorOptions) => SendFile;
+/**
+ * The service provider that once registered on the container will set the result of
+ * {@link sendFile} as the `sendFile` service.
+ *
+ * @example
+ *
+ *   // Register it on the container
+ *   container.register(sendFileProvider);
+ *   // Getting access to the service instance
+ *   const sendFile = container.get<SendFile>('sendFile');
+ *
+ * @group Providers
+ * @group Services/SendFile
+ */
+declare const sendFileProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { SendFile, SendFileGeneratorOptions, SendFileOptions, sendFile, sendFileProvider };

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

@@ -1,17 +1,17 @@
 import * as _homer0_jimple from '@homer0/jimple';
-import { J as Jimpex } from '../../jimpex-7eaee271.js';
+import { J as Jimpex } from '../../index-b2a04c78.js';
 import { Response, NextFunction } from 'express';
 import { PathUtils } from '@homer0/path-utils';
-import '@homer0/events-hub';
 import '../../types/express.js';
 import '../../types/http.js';
 import 'https';
 import 'http';
 import 'spdy';
 import 'node-fetch';
-import '@homer0/simple-config';
 import '../../types/utils.js';
 import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
 
 /**
  * The options to create a {@link SendFile} function.