jimpex 7.0.2 → 9.0.0

package/dist/services/utils/ensureBearerToken.d.mts

@@ -0,0 +1,158 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-efeb437e.js';
+import { ExpressMiddleware } from '../../types/express.mjs';
+import { Statuses } from '../../utils/fns/statuses.mjs';
+import { DeepPartial } from '../../types/utils.mjs';
+import { HTTPErrorClass } from '../common/httpError.mjs';
+import '../../types/http.mjs';
+import 'https';
+import 'http';
+import 'spdy';
+import 'express';
+import 'node-fetch';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import 'statuses';
+import '../common/appError.mjs';
+
+/**
+ * The options for the error the middleare can generate.
+ *
+ * @group Services/EnsureBearerToken
+ */
+type EnsureBearerTokenErrorOptions = {
+    /**
+     * The error message for the response.
+     *
+     * @default 'Unauthorized'
+     */
+    message: string;
+    /**
+     * The HTTP status that will be added to the error context.
+     *
+     * @default 401
+     */
+    status: number;
+    /**
+     * Context information for the error handler and that can be added to the actual
+     * response.
+     */
+    response: unknown;
+};
+/**
+ * The options to customize the service/middleware.
+ *
+ * @group Services/EnsureBearerToken
+ */
+type EnsureBearerTokenOptions = {
+    error: EnsureBearerTokenErrorOptions;
+    expression: RegExp;
+    local: string;
+};
+/**
+ * The options to construct a {@link EnsureBearerToken}.
+ *
+ * @group Services/EnsureBearerToken
+ */
+type EnsureBearerConstructorOptions = DeepPartial<EnsureBearerTokenOptions> & {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        HTTPError: HTTPErrorClass;
+        statuses: Statuses;
+    };
+};
+/**
+ * Custom options for the provider that will register an instance of
+ * {@link EnsureBearerToken}
+ * as a service.
+ *
+ * @group Services/EnsureBearerToken
+ */
+type EnsureBearerTokenProviderOptions = DeepPartial<EnsureBearerTokenOptions> & {
+    /**
+     * The name that will be used to register the service on the container. This is to allow
+     * multiple "instances" of the service to be created.
+     *
+     * @default 'ensureBearerToken'
+     */
+    serviceName?: string;
+};
+/**
+ * This service gives you a middleware that verifies if a request has an `Authorization`
+ * header with a bearer token; if it does, the token will be saved on the `res.locals`,
+ * otherwise, it will generate an error.
+ *
+ * This is a "service middleware" to allow certain flexibility: you can have controllers
+ * where some routes are protected and others are not. For those cases, you get the
+ * service from the container, and include it only in the routes that need it.
+ *
+ * @group Services
+ * @group Services/EnsureBearerToken
+ */
+declare class EnsureBearerToken {
+    /**
+     * To generate the errors when the validation fails.
+     */
+    protected readonly _HTTPError: HTTPErrorClass;
+    /**
+     * The customization options for the service.
+     */
+    protected readonly _options: EnsureBearerTokenOptions;
+    /**
+     * @param options  The options to construct the class.
+     */
+    constructor({ inject: { HTTPError, statuses }, ...options }: EnsureBearerConstructorOptions);
+    /**
+     * Generates the middleware that verifies if a request has an `Authorization` header
+     * with a bearer token.
+     */
+    getMiddleware(): ExpressMiddleware;
+    /**
+     * The customization options.
+     */
+    get options(): Readonly<EnsureBearerTokenOptions>;
+}
+/**
+ * Generates a "service middleware" that can be used on route controllers in order to
+ * validate the presence of a bearer token on the requests authorization header.
+ *
+ * The registered service is an instance of {@link EnsureBearerToken}, and it uses the key
+ * `ensureBearerToken`.
+ *
+ * Since it's a "provider creator", when registering it, you can pass custom options.
+ *
+ * @example
+ *
+ * <caption>Basic usage</caption>
+ *
+ *   // Register it on the container
+ *   container.register(ensureBearerTokenProvider);
+ *
+ *   // Let's assume we are in a controller now...
+ *   // Getting access to the middleware.
+ *   const ensureBearerToken = container.get<ExpressMiddleware>('ensureBearerToken');
+ *
+ * @example
+ *
+ * <caption>Customizing the service</caption>
+ *
+ *   // Register it on the container
+ *   container.register(
+ *     ensureBearerTokenProvider({
+ *       serviceName: 'ensureBearerTokenCustom',
+ *       error: {
+ *         message: 'Missing token!',
+ *       },
+ *     }),
+ *   );
+ *
+ * @group Providers
+ * @group Services/EnsureBearerToken
+ */
+declare const ensureBearerTokenProvider: _homer0_jimple.ResourceCreator<"provider", "register", (options?: EnsureBearerTokenProviderOptions) => (app: Jimpex) => void, _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { EnsureBearerConstructorOptions, EnsureBearerToken, EnsureBearerTokenErrorOptions, EnsureBearerTokenOptions, EnsureBearerTokenProviderOptions, ensureBearerTokenProvider };

package/dist/services/utils/ensureBearerToken.d.ts

@@ -0,0 +1,158 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-b2a04c78.js';
+import { ExpressMiddleware } from '../../types/express.js';
+import { Statuses } from '../../utils/fns/statuses.js';
+import { DeepPartial } from '../../types/utils.js';
+import { HTTPErrorClass } from '../common/httpError.js';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'express';
+import 'node-fetch';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import 'statuses';
+import '../common/appError.js';
+
+/**
+ * The options for the error the middleare can generate.
+ *
+ * @group Services/EnsureBearerToken
+ */
+type EnsureBearerTokenErrorOptions = {
+    /**
+     * The error message for the response.
+     *
+     * @default 'Unauthorized'
+     */
+    message: string;
+    /**
+     * The HTTP status that will be added to the error context.
+     *
+     * @default 401
+     */
+    status: number;
+    /**
+     * Context information for the error handler and that can be added to the actual
+     * response.
+     */
+    response: unknown;
+};
+/**
+ * The options to customize the service/middleware.
+ *
+ * @group Services/EnsureBearerToken
+ */
+type EnsureBearerTokenOptions = {
+    error: EnsureBearerTokenErrorOptions;
+    expression: RegExp;
+    local: string;
+};
+/**
+ * The options to construct a {@link EnsureBearerToken}.
+ *
+ * @group Services/EnsureBearerToken
+ */
+type EnsureBearerConstructorOptions = DeepPartial<EnsureBearerTokenOptions> & {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        HTTPError: HTTPErrorClass;
+        statuses: Statuses;
+    };
+};
+/**
+ * Custom options for the provider that will register an instance of
+ * {@link EnsureBearerToken}
+ * as a service.
+ *
+ * @group Services/EnsureBearerToken
+ */
+type EnsureBearerTokenProviderOptions = DeepPartial<EnsureBearerTokenOptions> & {
+    /**
+     * The name that will be used to register the service on the container. This is to allow
+     * multiple "instances" of the service to be created.
+     *
+     * @default 'ensureBearerToken'
+     */
+    serviceName?: string;
+};
+/**
+ * This service gives you a middleware that verifies if a request has an `Authorization`
+ * header with a bearer token; if it does, the token will be saved on the `res.locals`,
+ * otherwise, it will generate an error.
+ *
+ * This is a "service middleware" to allow certain flexibility: you can have controllers
+ * where some routes are protected and others are not. For those cases, you get the
+ * service from the container, and include it only in the routes that need it.
+ *
+ * @group Services
+ * @group Services/EnsureBearerToken
+ */
+declare class EnsureBearerToken {
+    /**
+     * To generate the errors when the validation fails.
+     */
+    protected readonly _HTTPError: HTTPErrorClass;
+    /**
+     * The customization options for the service.
+     */
+    protected readonly _options: EnsureBearerTokenOptions;
+    /**
+     * @param options  The options to construct the class.
+     */
+    constructor({ inject: { HTTPError, statuses }, ...options }: EnsureBearerConstructorOptions);
+    /**
+     * Generates the middleware that verifies if a request has an `Authorization` header
+     * with a bearer token.
+     */
+    getMiddleware(): ExpressMiddleware;
+    /**
+     * The customization options.
+     */
+    get options(): Readonly<EnsureBearerTokenOptions>;
+}
+/**
+ * Generates a "service middleware" that can be used on route controllers in order to
+ * validate the presence of a bearer token on the requests authorization header.
+ *
+ * The registered service is an instance of {@link EnsureBearerToken}, and it uses the key
+ * `ensureBearerToken`.
+ *
+ * Since it's a "provider creator", when registering it, you can pass custom options.
+ *
+ * @example
+ *
+ * <caption>Basic usage</caption>
+ *
+ *   // Register it on the container
+ *   container.register(ensureBearerTokenProvider);
+ *
+ *   // Let's assume we are in a controller now...
+ *   // Getting access to the middleware.
+ *   const ensureBearerToken = container.get<ExpressMiddleware>('ensureBearerToken');
+ *
+ * @example
+ *
+ * <caption>Customizing the service</caption>
+ *
+ *   // Register it on the container
+ *   container.register(
+ *     ensureBearerTokenProvider({
+ *       serviceName: 'ensureBearerTokenCustom',
+ *       error: {
+ *         message: 'Missing token!',
+ *       },
+ *     }),
+ *   );
+ *
+ * @group Providers
+ * @group Services/EnsureBearerToken
+ */
+declare const ensureBearerTokenProvider: _homer0_jimple.ResourceCreator<"provider", "register", (options?: EnsureBearerTokenProviderOptions) => (app: Jimpex) => void, _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { EnsureBearerConstructorOptions, EnsureBearerToken, EnsureBearerTokenErrorOptions, EnsureBearerTokenOptions, EnsureBearerTokenProviderOptions, ensureBearerTokenProvider };

package/dist/services/utils/ensureBearerToken.js

@@ -0,0 +1,121 @@
+"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 ensureBearerToken_exports = {};
+__export(ensureBearerToken_exports, {
+  EnsureBearerToken: () => EnsureBearerToken,
+  ensureBearerTokenProvider: () => ensureBearerTokenProvider
+});
+module.exports = __toCommonJS(ensureBearerToken_exports);
+var import_deep_assign = require("@homer0/deep-assign");
+var import_utils = require("../../utils");
+class EnsureBearerToken {
+  /**
+   * @param options  The options to construct the class.
+   */
+  constructor({
+    inject: { HTTPError, statuses },
+    ...options
+  }) {
+    /**
+     * To generate the errors when the validation fails.
+     */
+    __publicField(this, "_HTTPError");
+    /**
+     * The customization options for the service.
+     */
+    __publicField(this, "_options");
+    this._HTTPError = HTTPError;
+    this._options = (0, import_deep_assign.deepAssignWithOverwrite)(
+      {
+        error: {
+          message: "Unauthorized",
+          status: statuses("unauthorized"),
+          response: {}
+        },
+        expression: /bearer (.*?)(?:$|\s)/i,
+        local: "token"
+      },
+      options
+    );
+  }
+  /**
+   * Generates the middleware that verifies if a request has an `Authorization` header
+   * with a bearer token.
+   */
+  getMiddleware() {
+    return (req, res, next) => {
+      let unauthorized = true;
+      const {
+        headers: { authorization }
+      } = req;
+      if (authorization) {
+        const matches = this._options.expression.exec(authorization);
+        if (matches) {
+          const [, token] = matches;
+          res.locals[this._options.local] = token;
+          unauthorized = false;
+        }
+      }
+      if (unauthorized) {
+        const {
+          error: { message, status, response }
+        } = this._options;
+        next(
+          new this._HTTPError(message, status, {
+            response
+          })
+        );
+      } else {
+        next();
+      }
+    };
+  }
+  /**
+   * The customization options.
+   */
+  get options() {
+    return (0, import_deep_assign.deepAssignWithOverwrite)({}, this._options);
+  }
+}
+const ensureBearerTokenProvider = (0, import_utils.providerCreator)(
+  (options = {}) => (app) => {
+    const { serviceName = "ensureBearerToken", ...rest } = options;
+    app.set(
+      serviceName,
+      () => new EnsureBearerToken({
+        inject: {
+          HTTPError: app.get("HTTPError"),
+          statuses: app.get("statuses")
+        },
+        ...rest
+      }).getMiddleware()
+    );
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnsureBearerToken,
+  ensureBearerTokenProvider
+});
+//# sourceMappingURL=ensureBearerToken.js.map

package/dist/services/utils/ensureBearerToken.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/utils/ensureBearerToken.ts"],"sourcesContent":["import { deepAssignWithOverwrite } from '@homer0/deep-assign';\nimport { providerCreator, type Statuses } from '../../utils';\nimport type { HTTPErrorClass } from '../common';\nimport type { DeepPartial, ExpressMiddleware } from '../../types';\n/**\n * The options for the error the middleare can generate.\n *\n * @group Services/EnsureBearerToken\n */\nexport type EnsureBearerTokenErrorOptions = {\n  /**\n   * The error message for the response.\n   *\n   * @default 'Unauthorized'\n   */\n  message: string;\n  /**\n   * The HTTP status that will be added to the error context.\n   *\n   * @default 401\n   */\n  status: number;\n  /**\n   * Context information for the error handler and that can be added to the actual\n   * response.\n   */\n  response: unknown;\n};\n/**\n * The options to customize the service/middleware.\n *\n * @group Services/EnsureBearerToken\n */\nexport type EnsureBearerTokenOptions = {\n  error: EnsureBearerTokenErrorOptions;\n  expression: RegExp;\n  local: string;\n};\n/**\n * The options to construct a {@link EnsureBearerToken}.\n *\n * @group Services/EnsureBearerToken\n */\nexport type EnsureBearerConstructorOptions = DeepPartial<EnsureBearerTokenOptions> & {\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    HTTPError: HTTPErrorClass;\n    statuses: Statuses;\n  };\n};\n/**\n * Custom options for the provider that will register an instance of\n * {@link EnsureBearerToken}\n * as a service.\n *\n * @group Services/EnsureBearerToken\n */\nexport type EnsureBearerTokenProviderOptions = DeepPartial<EnsureBearerTokenOptions> & {\n  /**\n   * The name that will be used to register the service on the container. This is to allow\n   * multiple \"instances\" of the service to be created.\n   *\n   * @default 'ensureBearerToken'\n   */\n  serviceName?: string;\n};\n/**\n * This service gives you a middleware that verifies if a request has an `Authorization`\n * header with a bearer token; if it does, the token will be saved on the `res.locals`,\n * otherwise, it will generate an error.\n *\n * This is a \"service middleware\" to allow certain flexibility: you can have controllers\n * where some routes are protected and others are not. For those cases, you get the\n * service from the container, and include it only in the routes that need it.\n *\n * @group Services\n * @group Services/EnsureBearerToken\n */\nexport class EnsureBearerToken {\n  /**\n   * To generate the errors when the validation fails.\n   */\n  protected readonly _HTTPError: HTTPErrorClass;\n  /**\n   * The customization options for the service.\n   */\n  protected readonly _options: EnsureBearerTokenOptions;\n  /**\n   * @param options  The options to construct the class.\n   */\n  constructor({\n    inject: { HTTPError, statuses },\n    ...options\n  }: EnsureBearerConstructorOptions) {\n    this._HTTPError = HTTPError;\n    this._options = deepAssignWithOverwrite(\n      {\n        error: {\n          message: 'Unauthorized',\n          status: statuses('unauthorized'),\n          response: {},\n        },\n        expression: /bearer (.*?)(?:$|\\s)/i,\n        local: 'token',\n      },\n      options,\n    );\n  }\n  /**\n   * Generates the middleware that verifies if a request has an `Authorization` header\n   * with a bearer token.\n   */\n  getMiddleware(): ExpressMiddleware {\n    return (req, res, next) => {\n      let unauthorized = true;\n      const {\n        headers: { authorization },\n      } = req;\n      if (authorization) {\n        const matches = this._options.expression.exec(authorization);\n        if (matches) {\n          const [, token] = matches;\n          res.locals[this._options.local] = token;\n          unauthorized = false;\n        }\n      }\n\n      if (unauthorized) {\n        const {\n          error: { message, status, response },\n        } = this._options;\n        next(\n          new this._HTTPError(message, status, {\n            response,\n          }),\n        );\n      } else {\n        next();\n      }\n    };\n  }\n  /**\n   * The customization options.\n   */\n  get options(): Readonly<EnsureBearerTokenOptions> {\n    return deepAssignWithOverwrite({}, this._options);\n  }\n}\n/**\n * Generates a \"service middleware\" that can be used on route controllers in order to\n * validate the presence of a bearer token on the requests authorization header.\n *\n * The registered service is an instance of {@link EnsureBearerToken}, and it uses the key\n * `ensureBearerToken`.\n *\n * Since it's a \"provider creator\", when registering it, you can pass custom options.\n *\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   // Register it on the container\n *   container.register(ensureBearerTokenProvider);\n *\n *   // Let's assume we are in a controller now...\n *   // Getting access to the middleware.\n *   const ensureBearerToken = container.get<ExpressMiddleware>('ensureBearerToken');\n *\n * @example\n *\n * <caption>Customizing the service</caption>\n *\n *   // Register it on the container\n *   container.register(\n *     ensureBearerTokenProvider({\n *       serviceName: 'ensureBearerTokenCustom',\n *       error: {\n *         message: 'Missing token!',\n *       },\n *     }),\n *   );\n *\n * @group Providers\n * @group Services/EnsureBearerToken\n */\nexport const ensureBearerTokenProvider = providerCreator(\n  (options: EnsureBearerTokenProviderOptions = {}) =>\n    (app) => {\n      const { serviceName = 'ensureBearerToken', ...rest } = options;\n      app.set(serviceName, () =>\n        new EnsureBearerToken({\n          inject: {\n            HTTPError: app.get('HTTPError'),\n            statuses: app.get('statuses'),\n          },\n          ...rest,\n        }).getMiddleware(),\n      );\n    },\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAAwC;AACxC,mBAA+C;AA+ExC,MAAM,kBAAkB;AAAA;AAAA;AAAA;AAAA,EAY7B,YAAY;AAAA,IACV,QAAQ,EAAE,WAAW,SAAS;AAAA,IAC9B,GAAG;AAAA,EACL,GAAmC;AAXnC;AAAA;AAAA;AAAA,wBAAmB;AAInB;AAAA;AAAA;AAAA,wBAAmB;AAQjB,SAAK,aAAa;AAClB,SAAK,eAAW;AAAA,MACd;AAAA,QACE,OAAO;AAAA,UACL,SAAS;AAAA,UACT,QAAQ,SAAS,cAAc;AAAA,UAC/B,UAAU,CAAC;AAAA,QACb;AAAA,QACA,YAAY;AAAA,QACZ,OAAO;AAAA,MACT;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,gBAAmC;AACjC,WAAO,CAAC,KAAK,KAAK,SAAS;AACzB,UAAI,eAAe;AACnB,YAAM;AAAA,QACJ,SAAS,EAAE,cAAc;AAAA,MAC3B,IAAI;AACJ,UAAI,eAAe;AACjB,cAAM,UAAU,KAAK,SAAS,WAAW,KAAK,aAAa;AAC3D,YAAI,SAAS;AACX,gBAAM,CAAC,EAAE,KAAK,IAAI;AAClB,cAAI,OAAO,KAAK,SAAS,KAAK,IAAI;AAClC,yBAAe;AAAA,QACjB;AAAA,MACF;AAEA,UAAI,cAAc;AAChB,cAAM;AAAA,UACJ,OAAO,EAAE,SAAS,QAAQ,SAAS;AAAA,QACrC,IAAI,KAAK;AACT;AAAA,UACE,IAAI,KAAK,WAAW,SAAS,QAAQ;AAAA,YACnC;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF,OAAO;AACL,aAAK;AAAA,MACP;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,UAA8C;AAChD,eAAO,4CAAwB,CAAC,GAAG,KAAK,QAAQ;AAAA,EAClD;AACF;AAsCO,MAAM,gCAA4B;AAAA,EACvC,CAAC,UAA4C,CAAC,MAC5C,CAAC,QAAQ;AACP,UAAM,EAAE,cAAc,qBAAqB,GAAG,KAAK,IAAI;AACvD,QAAI;AAAA,MAAI;AAAA,MAAa,MACnB,IAAI,kBAAkB;AAAA,QACpB,QAAQ;AAAA,UACN,WAAW,IAAI,IAAI,WAAW;AAAA,UAC9B,UAAU,IAAI,IAAI,UAAU;AAAA,QAC9B;AAAA,QACA,GAAG;AAAA,MACL,CAAC,EAAE,cAAc;AAAA,IACnB;AAAA,EACF;AACJ;","names":[]}

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

@@ -0,0 +1,44 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-efeb437e.js';
+import { EnsureBearerTokenProviderOptions } from './ensureBearerToken.mjs';
+export { EnsureBearerConstructorOptions, EnsureBearerToken, EnsureBearerTokenErrorOptions, EnsureBearerTokenOptions, ensureBearerTokenProvider } from './ensureBearerToken.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';
+import '../common/httpError.mjs';
+import '../common/appError.mjs';
+
+/**
+ * Registers all the utility services on the container.
+ *
+ * - {@link EnsureBearerToken | ensureBearerToken}
+ *
+ * @example
+ *
+ *   // Register the collection on the container
+ *   container.register(utilsServicesProvider);
+ *   // Getting access to one the services instance
+ *   const ensureBearerToken = container.get<EnsureBearerToken>('ensureBearerToken');
+ *
+ * @group Providers
+ */
+declare const utilsServicesProvider: {
+    ensureBearerTokenProvider: _homer0_jimple.ResourceCreator<"provider", "register", (options?: EnsureBearerTokenProviderOptions) => (app: Jimpex) => void, _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 { EnsureBearerTokenProviderOptions, utilsServicesProvider };

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

@@ -0,0 +1,44 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-b2a04c78.js';
+import { EnsureBearerTokenProviderOptions } from './ensureBearerToken.js';
+export { EnsureBearerConstructorOptions, EnsureBearerToken, EnsureBearerTokenErrorOptions, EnsureBearerTokenOptions, ensureBearerTokenProvider } from './ensureBearerToken.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 '../../utils/fns/statuses.js';
+import 'statuses';
+import '../common/httpError.js';
+import '../common/appError.js';
+
+/**
+ * Registers all the utility services on the container.
+ *
+ * - {@link EnsureBearerToken | ensureBearerToken}
+ *
+ * @example
+ *
+ *   // Register the collection on the container
+ *   container.register(utilsServicesProvider);
+ *   // Getting access to one the services instance
+ *   const ensureBearerToken = container.get<EnsureBearerToken>('ensureBearerToken');
+ *
+ * @group Providers
+ */
+declare const utilsServicesProvider: {
+    ensureBearerTokenProvider: _homer0_jimple.ResourceCreator<"provider", "register", (options?: EnsureBearerTokenProviderOptions) => (app: Jimpex) => void, _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 { EnsureBearerTokenProviderOptions, utilsServicesProvider };

package/dist/services/utils/index.js

@@ -0,0 +1,36 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  utilsServicesProvider: () => utilsServicesProvider
+});
+module.exports = __toCommonJS(utils_exports);
+var import_utils = require("../../utils");
+var import_ensureBearerToken = require("./ensureBearerToken");
+__reExport(utils_exports, require("./ensureBearerToken"), module.exports);
+const utilsServicesProvider = (0, import_utils.providers)({
+  ensureBearerTokenProvider: import_ensureBearerToken.ensureBearerTokenProvider
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  utilsServicesProvider,
+  ...require("./ensureBearerToken")
+});
+//# sourceMappingURL=index.js.map

package/dist/services/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/utils/index.ts"],"sourcesContent":["import { providers } from '../../utils';\nimport { ensureBearerTokenProvider } from './ensureBearerToken';\n/**\n * Registers all the utility services on the container.\n *\n * - {@link EnsureBearerToken | ensureBearerToken}\n *\n * @example\n *\n *   // Register the collection on the container\n *   container.register(utilsServicesProvider);\n *   // Getting access to one the services instance\n *   const ensureBearerToken = container.get<EnsureBearerToken>('ensureBearerToken');\n *\n * @group Providers\n */\nexport const utilsServicesProvider = providers({\n  ensureBearerTokenProvider,\n});\n\nexport * from './ensureBearerToken';\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA0B;AAC1B,+BAA0C;AAmB1C,0BAAc,gCApBd;AAgBO,MAAM,4BAAwB,wBAAU;AAAA,EAC7C;AACF,CAAC;","names":[]}

package/dist/types/events.d.mts

@@ -0,0 +1,14 @@
+import './express.mjs';
+export { E as EventPayload, l as Events, k as JimpexEventListener, b as JimpexEventName, i as JimpexEventNameLike, c as JimpexEventPayload, a as JimpexEvents, f as JimpexReducerEventName, h as JimpexReducerEventPayload, e as JimpexReducerEventPayloads, g as JimpexReducerEventTarget, d as JimpexReducerEventTargets } from '../index-efeb437e.js';
+import 'express';
+import './http.mjs';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import './utils.mjs';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import '@homer0/jimple';

package/dist/types/events.d.ts

@@ -0,0 +1,14 @@
+import './express.js';
+export { E as EventPayload, l as Events, k as JimpexEventListener, b as JimpexEventName, i as JimpexEventNameLike, c as JimpexEventPayload, a as JimpexEvents, f as JimpexReducerEventName, h as JimpexReducerEventPayload, e as JimpexReducerEventPayloads, g as JimpexReducerEventTarget, d as JimpexReducerEventTargets } from '../index-b2a04c78.js';
+import 'express';
+import './http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import 'node-fetch';
+import './utils.js';
+import '@homer0/path-utils';
+import '@homer0/simple-logger';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+import '@homer0/jimple';

package/dist/types/events.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 events_exports = {};
+module.exports = __toCommonJS(events_exports);
+//# sourceMappingURL=events.js.map

package/dist/types/events.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/events.ts"],"sourcesContent":["import type { Router, ExpressMiddlewareLike } from './express';\nimport type { Controller, Middleware } from '../utils';\nimport type { Jimpex } from '../app/jimpex';\n/**\n * The base payload the events emitted by the application send.\n *\n * @template T  Extra properties beside the reference to the application.\n * @group Services/Events\n */\nexport type EventPayload<T = Record<string, unknown>> = {\n  /**\n   * A reference to the application.\n   */\n  app: Jimpex;\n} & T;\n/**\n * A dictionary with the events emitted by the application and their payloads.\n *\n * @group Services/Events\n */\nexport interface JimpexEvents {\n  /**\n   * Called right before creating the server and calling `listen` on it.\n   */\n  beforeStart: EventPayload;\n  /**\n   * Called once the server confirmed that is listening.\n   */\n  start: EventPayload;\n  /**\n   * Called after the controllers and middlewares have been mounted.\n   */\n  afterStart: EventPayload;\n  /**\n   * Called after the `onStart` callback has been called.\n   */\n  afterStartCallback: EventPayload;\n  /**\n   * Called before closing the server instance.\n   */\n  beforeStop: EventPayload;\n  /**\n   * Called after the server instance has been closed.\n   */\n  afterStop: EventPayload;\n  /**\n   * Called every time a new route is mounted in the application.\n   */\n  routeAdded: EventPayload<{ route: string }>;\n}\n/**\n * The events emitted by the application.\n *\n * @group Services/Events\n */\nexport type JimpexEventName = keyof JimpexEvents;\n/**\n * The type of the payload sent by a specific event.\n *\n * @template EventName  The literal type of the event, to obtain the type of the\n *                      payload.\n * @group Services/Events\n */\nexport type JimpexEventPayload<EventName extends JimpexEventName> =\n  JimpexEvents[EventName];\n/**\n * A dictionary of the reducer events and their targets.\n *\n * @group Services/Events\n */\nexport interface JimpexReducerEventTargets {\n  /**\n   * It gets called before mounting a router/middleware for a specific route.\n   */\n  controllerWillBeMounted: Router | ExpressMiddlewareLike;\n  /**\n   * It gets called before using a middleware without route.\n   */\n  middlewareWillBeUsed: ExpressMiddlewareLike;\n}\n/**\n * A dictionary of the payloads the reducer events the application uses.\n *\n * @group Services/Events\n */\nexport interface JimpexReducerEventPayloads {\n  /**\n   * It gets called before mounting a router/middleware for a specific route.\n   */\n  controllerWillBeMounted: EventPayload<{\n    /**\n     * The route in which the controller will be mounted.\n     */\n    route: string;\n    /**\n     * A reference for the controller/middleware before being \"connected\".\n     */\n    controller: Controller | Middleware;\n  }>;\n  /**\n   * It gets called before using a middleware without route.\n   */\n  middlewareWillBeUsed: EventPayload;\n}\n/**\n * The reducer events used by the application.\n *\n * @group Services/Events\n */\nexport type JimpexReducerEventName = keyof JimpexReducerEventTargets;\n/**\n * The type of the target of a specific reducer event.\n *\n * @template EventName  The literal type of the event, to obtain the type of the\n *                      target.\n * @group Services/Events\n */\nexport type JimpexReducerEventTarget<EventName extends JimpexReducerEventName> =\n  JimpexReducerEventTargets[EventName];\n/**\n * The type of the payload of a specific reducer event.\n *\n * @template EventName  The literal type of the event, to obtain the type of the\n *                      payload.\n * @group Services/Events\n */\nexport type JimpexReducerEventPayload<EventName extends JimpexReducerEventName> =\n  JimpexReducerEventPayloads[EventName];\n/**\n * The name of the events o reducer events emitted/used by the application.\n * This generic type exists because the listener for both types are added using the same\n * method.\n *\n * @group Services/Events\n */\nexport type JimpexEventNameLike = JimpexEventName | JimpexReducerEventName;\n/**\n * The definition of a listener for an event or a reducer event.\n *\n * @template EventName  The literal type of the event, to validate whether the\n *                      parameters should be for a reducer event or an event.\n * @group Services/Events\n */\nexport type JimpexEventListener<EventName extends JimpexEventNameLike> =\n  EventName extends JimpexEventName\n    ? (payload: JimpexEventPayload<EventName>) => void\n    : EventName extends JimpexReducerEventName\n    ? (\n        target: JimpexReducerEventTarget<EventName>,\n        payload: JimpexReducerEventPayload<EventName>,\n      ) => JimpexReducerEventTarget<EventName>\n    : never;\n/**\n * The `events` service Jimpex uses.\n * This is an alternative declaration of the `EventsHub` class that uses the interfaces\n * and types from this project.\n *\n * @group Services\n * @group Services/Events\n */\nexport type Events = {\n  /**\n   * Adds a new event listener.\n   *\n   * @param event     The name of the event.\n   * @param listener  The listener function.\n   * @returns An unsubscribe function to remove the listener.\n   * @template EventName  The literal type of the event, to generate the type of the\n   *                      listener.\n   * @example\n   *\n   *   const unsubscribe = events.on('afterStart', ({ app }) => {\n   *     app.getLogger().info('Hello world!');\n   *     unsubscribe();\n   *   });\n   *\n   */\n  on: <EventName extends JimpexEventNameLike>(\n    eventName: EventName,\n    listener: JimpexEventListener<EventName>,\n  ) => () => boolean;\n  /**\n   * Adds an event listener that will only be executed once.\n   *\n   * @param event     The name of the event.\n   * @param listener  The listener function.\n   * @returns An unsubscribe function to remove the listener.\n   * @template EventName  The literal type of the event, to generate the type of the\n   *                      listener.\n   * @example\n   *\n   *   events.once('afterStart', ({ app }) => {\n   *     app.getLogger().info('Hello world!');\n   *     unsubscribe();\n   *   });\n   *\n   */\n  once: <EventName extends JimpexEventNameLike>(\n    eventName: EventName,\n    listener: JimpexEventListener<EventName>,\n  ) => () => boolean;\n  /**\n   * Emits an event and call all its listeners.\n   *\n   * @param event    The name of the events.\n   * @param payload  Context information for the event.\n   * @template EventName  The literal type of the event, to generate the type of the\n   *                      payload.\n   * @example\n   *\n   *   // Extend the interface to type the payload.\n   *   interface JimpexEvents {\n   *     myEvent: { message: string };\n   *   }\n   *   // Add the listener.\n   *   events.on('myEvent', ({ message }) => {\n   *     console.log('Event received:', message);\n   *   });\n   *   // Trigger the event.\n   *   events.emit('myEvent', { message: 'Hello' });\n   *   // prints \"Event received: Hello\"\n   *\n   */\n  emit: <EventName extends JimpexEventName>(\n    event: JimpexEventName,\n    payload: JimpexEventPayload<EventName>,\n  ) => void;\n  /**\n   * Asynchronously reduces a target using an event. It's like emit, but the event\n   * listeners return a modified (or not) version of the `target`.\n   *\n   * @param event    The name of the event.\n   * @param target   The variable to reduce with the reducers/listeners.\n   * @param payload  Context information for the event.\n   * @returns A version of the `target` processed by the listeners.\n   * @template EventName  The literal type of the event, to generate the types of the\n   *                      target and the payload.\n   * @example\n   *\n   *   // Extend the interface to type the target.\n   *   interface JimpexReducerEventTargets {\n   *     myReducer: unknown[];\n   *   }\n   *   // Extend the interface to type the payload.\n   *   interface JimpexReducerEventPayloads {\n   *     myReducer: {\n   *       message: string;\n   *     };\n   *   }\n   *   // Add the reducer.\n   *   events.on('myReducer', async (target, { message }) => {\n   *     const data = await fetch('https://api.example.com/' + message);\n   *     target.push(data);\n   *     return target;\n   *   });\n   *   // Trigger the event.\n   *   const result = await events.reduce('myReducer', [], { message: 'Hello' });\n   *   // result would be a list of data fetched from the API.\n   *\n   */\n  reduce: <EventName extends JimpexReducerEventName>(\n    event: JimpexReducerEventName,\n    target: JimpexReducerEventTarget<EventName>,\n    payload: JimpexReducerEventPayload<EventName>,\n  ) => Promise<JimpexReducerEventTarget<EventName>>;\n  /**\n   * Synchronously reduces a target using an event. It's like emit, but the events\n   * listener return a modified (or not) version of the `target`.\n   *\n   * @param event    The name of the event.\n   * @param target   The variable to reduce with the reducers/listeners.\n   * @param payload  Context information for the event.\n   * @returns A version of the `target` processed by the listeners.\n   * @template EventName  The literal type of the event, to generate the types of the\n   *                      target and the payload.\n   * @example\n   *\n   *   // Extend the interface to type the target.\n   *   interface JimpexReducerEventTargets {\n   *     myReducer: string[];\n   *   }\n   *   // Extend the interface to type the payload.\n   *   interface JimpexReducerEventPayloads {\n   *     myReducer: {\n   *       message: string;\n   *     };\n   *   }\n   *   // Add the reducer.\n   *   events.on('myReducer', (target, { message }) => {\n   *     target.push(message);\n   *     return target;\n   *   });\n   *   // Trigger the event.\n   *   events.reduce('event', [], 'Hello');\n   *   // returns ['Hello']\n   *\n   */\n  reduceSync: <EventName extends JimpexReducerEventName>(\n    event: JimpexReducerEventName,\n    target: JimpexReducerEventTarget<EventName>,\n    payload: JimpexReducerEventPayload<EventName>,\n  ) => JimpexReducerEventTarget<EventName>;\n};\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/types/express.d.mts

@@ -0,0 +1,10 @@
+import { RequestHandler, ErrorRequestHandler } from 'express';
+export { Express, NextFunction, Request, Response, Router } from 'express';
+
+type ExpressMiddlewareLike = RequestHandler | ErrorRequestHandler;
+type ExpressMiddleware = RequestHandler;
+type AsyncExpressMiddleware = (...args: Parameters<ExpressMiddleware>) => Promise<void>;
+type ExpressErrorHandler = ErrorRequestHandler;
+type RouterMethod = 'all' | 'get' | 'head' | 'post' | 'patch' | 'put' | 'delete' | 'connect' | 'options' | 'trace';
+
+export { AsyncExpressMiddleware, ExpressErrorHandler, ExpressMiddleware, ExpressMiddlewareLike, RouterMethod };