jimpex 7.0.1 → 8.0.0

package/dist/services/http/apiClient.d.ts

@@ -0,0 +1,169 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../jimpex-7eaee271.js';
+import { HTTPErrorClass } from '../common/httpError.js';
+import { HTTP } from './http.js';
+import { APIClientOptions, APIClient as APIClient$1, ErrorResponse } from '@homer0/api-utils';
+export { ErrorResponse } from '@homer0/api-utils';
+import '@homer0/events-hub';
+import '../../types/express.js';
+import 'express';
+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 '../../utils/fns/statuses.js';
+import 'statuses';
+import '../common/appError.js';
+
+/**
+ * The required settings needed to create the an API client.
+ *
+ * @group Services/APIClient
+ */
+type APIClientConfig = Pick<APIClientOptions, 'url' | 'endpoints'>;
+/**
+ * A dictionary of endpoints for the API client.
+ * This is declared as standalone because it needs to reference them multiple times.
+ *
+ * @group Services/APIClient
+ */
+type EndpointsType = APIClientOptions['endpoints'];
+/**
+ * The format the settings needs to have in the application configuration in order to
+ * create a valid API client.
+ * The settings may include the endpoints dictionary in the `endpoints` property, or the
+ * gateway `property`, with `endpoints` always having priority if both exists.
+ * The reason for the `gateway` property to be valid, is in case the application also
+ * implements a {@link GatewayController}, using the same property for both things will
+ * help reduce the amount of duplicated definitions.
+ *
+ * @group Services/APIClient
+ */
+type APIClientSettings = Omit<APIClientConfig, 'endpoints'> & ({
+    endpoints: EndpointsType;
+    gateway?: EndpointsType;
+} | {
+    endpoints?: EndpointsType;
+    gateway: EndpointsType;
+});
+/**
+ * The options to construct a {@link APIClient}.
+ *
+ * @group Services/APIClient
+ */
+type APIClientConstructorOptions = APIClientSettings & {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        http: HTTP;
+        HTTPError: HTTPErrorClass;
+    };
+};
+/**
+ * An API client for the application to use. What makes this service special is that it
+ * formats received errors using the {@link _HTTPError} class, and as fetch client, it
+ * uses the {@link HTTP} service, allowing the application to to internally handle all the
+ * requests and responses.
+ *
+ * The only reason to use the class directly is if you want to subclass it, as you would
+ * normally just register the {@link apiClientProvider}.
+ *
+ * @group Services
+ * @group Services/APIClient
+ */
+declare class APIClient extends APIClient$1 {
+    /**
+     * The service that makes the requests to the API.
+     */
+    protected readonly _http: HTTP;
+    /**
+     * The class to generate possible errors in the requests.
+     */
+    protected readonly _HTTPError: HTTPErrorClass;
+    /**
+     * The configuration of the API it uses.
+     */
+    protected readonly _apiConfig: APIClientConfig;
+    /**
+     * @param options  The options to construct the class.
+     */
+    constructor({ inject: { http, HTTPError }, ...rest }: APIClientConstructorOptions);
+    /**
+     * The configuration for the API.
+     */
+    get apiConfig(): Readonly<APIClientConfig>;
+    /**
+     * Tries to obtain a message from an error caused on a failed request.
+     *
+     * @param response  The response from the failed request.
+     */
+    protected _getErrorMessageFromResponse(response: unknown): string;
+    /**
+     * Generates an {@link _HTTPError} from the response of a failed request.
+     *
+     * @param response  The response from the failed request.
+     * @param status    The status code of the response.
+     */
+    protected formatError<ResponseType extends ErrorResponse>(response: ResponseType, status: number): Error;
+}
+/**
+ * The options for the provider creator that registers an {@link APIClient} in the
+ * container.
+ * These options allow the application to register multiple instances for different APIs.
+ *
+ * @group Services/APIClient
+ */
+type APIClientProviderOptions = {
+    /**
+     * The name of the service that will be registered into the app.
+     *
+     * @default 'apiClient'
+     */
+    serviceName?: string;
+    /**
+     * The name of the configuration setting that has the API information.
+     *
+     * @default 'api'
+     */
+    configSetting?: string;
+    /**
+     * The class the service will instantiate. It has to extend {@link APIClient}.
+     *
+     * @default APIClient
+     */
+    clientClass?: typeof APIClient;
+};
+/**
+ * The provider creator to register an instance of {@link APIClient} on the container.
+ *
+ * @example
+ *
+ * <caption>Basic usage</caption>
+ *
+ *   // Register it on the container
+ *   container.register(apiClientProvider);
+ *   // Getting access to the service instance
+ *   const apiClient = container.get<APIClient>('apiClient');
+ *
+ * @example
+ *
+ * <caption>With custom options</caption>
+ *
+ *   container.register(
+ *     apiClientProvider({
+ *       serviceName: 'myApiClient',
+ *       configSetting: 'myApi',
+ *     }),
+ *   );
+ *
+ * @group Providers
+ * @group Services/APIClient
+ */
+declare const apiClientProvider: _homer0_jimple.ResourceCreator<"provider", "register", (options?: APIClientProviderOptions) => (app: Jimpex) => void, _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { APIClient, APIClientConfig, APIClientConstructorOptions, APIClientProviderOptions, APIClientSettings, EndpointsType, apiClientProvider };

package/dist/services/http/apiClient.js

@@ -0,0 +1,96 @@
+"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 apiClient_exports = {};
+__export(apiClient_exports, {
+  APIClient: () => APIClient,
+  apiClientProvider: () => apiClientProvider
+});
+module.exports = __toCommonJS(apiClient_exports);
+var import_api_utils = require("@homer0/api-utils");
+var import_deep_assign = require("@homer0/deep-assign");
+var import_utils = require("../../utils");
+class APIClient extends import_api_utils.APIClient {
+  constructor({ inject: { http, HTTPError }, ...rest }) {
+    const { endpoints, gateway, url } = rest;
+    const useEndpoints = endpoints || gateway;
+    const apiConfig = {
+      url,
+      endpoints: useEndpoints
+    };
+    super({
+      ...apiConfig,
+      fetchClient: http.fetch
+    });
+    __publicField(this, "_http");
+    __publicField(this, "_HTTPError");
+    __publicField(this, "_apiConfig");
+    this._http = http;
+    this._HTTPError = HTTPError;
+    this._apiConfig = (0, import_deep_assign.deepAssignWithOverwrite)({}, apiConfig);
+  }
+  get apiConfig() {
+    return (0, import_deep_assign.deepAssignWithOverwrite)({}, this._apiConfig);
+  }
+  _getErrorMessageFromResponse(response) {
+    const res = response;
+    if (res.error)
+      return res.error;
+    if (res.data) {
+      if (res.data.message)
+        return res.data.message;
+      if (res.data.error)
+        return res.data.error;
+    }
+    return "Unexpected error";
+  }
+  formatError(response, status) {
+    return new this._HTTPError(this._getErrorMessageFromResponse(response), status);
+  }
+}
+const apiClientProvider = (0, import_utils.providerCreator)(
+  (options = {}) => (app) => {
+    const defaultName = "apiClient";
+    const { serviceName = defaultName, clientClass: ClientClass = APIClient } = options;
+    let { configSetting } = options;
+    if (!configSetting) {
+      configSetting = serviceName === defaultName ? "api" : serviceName;
+    }
+    app.set(
+      serviceName,
+      () => new ClientClass({
+        inject: {
+          http: app.get("http"),
+          HTTPError: app.get("HTTPError")
+        },
+        ...app.getConfig(configSetting)
+      })
+    );
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIClient,
+  apiClientProvider
+});
+//# sourceMappingURL=apiClient.js.map

package/dist/services/http/apiClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/http/apiClient.ts"],"sourcesContent":["import {\n  APIClient as APIClientBase,\n  type ErrorResponse,\n  type APIClientOptions,\n  type FetchClient,\n} from '@homer0/api-utils';\nimport { deepAssignWithOverwrite } from '@homer0/deep-assign';\nimport { providerCreator } from '../../utils';\nimport type { HTTP } from './http';\nimport type { HTTPErrorClass } from '../common';\n\nexport type { ErrorResponse };\n/**\n * The required settings needed to create the an API client.\n *\n * @group Services/APIClient\n */\nexport type APIClientConfig = Pick<APIClientOptions, 'url' | 'endpoints'>;\n/**\n * A dictionary of endpoints for the API client.\n * This is declared as standalone because it needs to reference them multiple times.\n *\n * @group Services/APIClient\n */\nexport type EndpointsType = APIClientOptions['endpoints'];\n/**\n * The format the settings needs to have in the application configuration in order to\n * create a valid API client.\n * The settings may include the endpoints dictionary in the `endpoints` property, or the\n * gateway `property`, with `endpoints` always having priority if both exists.\n * The reason for the `gateway` property to be valid, is in case the application also\n * implements a {@link GatewayController}, using the same property for both things will\n * help reduce the amount of duplicated definitions.\n *\n * @group Services/APIClient\n */\nexport type APIClientSettings = Omit<APIClientConfig, 'endpoints'> &\n  (\n    | {\n        endpoints: EndpointsType;\n        gateway?: EndpointsType;\n      }\n    | {\n        endpoints?: EndpointsType;\n        gateway: EndpointsType;\n      }\n  );\n/**\n * The options to construct a {@link APIClient}.\n *\n * @group Services/APIClient\n */\nexport type APIClientConstructorOptions = APIClientSettings & {\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    http: HTTP;\n    HTTPError: HTTPErrorClass;\n  };\n};\n/**\n * An API client for the application to use. What makes this service special is that it\n * formats received errors using the {@link _HTTPError} class, and as fetch client, it\n * uses the {@link HTTP} service, allowing the application to to internally handle all the\n * requests and responses.\n *\n * The only reason to use the class directly is if you want to subclass it, as you would\n * normally just register the {@link apiClientProvider}.\n *\n * @group Services\n * @group Services/APIClient\n */\nexport class APIClient extends APIClientBase {\n  /**\n   * The service that makes the requests to the API.\n   */\n  protected readonly _http: HTTP;\n  /**\n   * The class to generate possible errors in the requests.\n   */\n  protected readonly _HTTPError: HTTPErrorClass;\n  /**\n   * The configuration of the API it uses.\n   */\n  protected readonly _apiConfig: APIClientConfig;\n  /**\n   * @param options  The options to construct the class.\n   */\n  constructor({ inject: { http, HTTPError }, ...rest }: APIClientConstructorOptions) {\n    const { endpoints, gateway, url } = rest;\n    const useEndpoints = (endpoints || gateway)!;\n    const apiConfig = {\n      url,\n      endpoints: useEndpoints,\n    };\n    super({\n      ...apiConfig,\n      fetchClient: http.fetch as unknown as FetchClient,\n    });\n\n    this._http = http;\n    this._HTTPError = HTTPError;\n    this._apiConfig = deepAssignWithOverwrite({}, apiConfig);\n  }\n  /**\n   * The configuration for the API.\n   */\n  get apiConfig(): Readonly<APIClientConfig> {\n    return deepAssignWithOverwrite({}, this._apiConfig);\n  }\n  /**\n   * Tries to obtain a message from an error caused on a failed request.\n   *\n   * @param response  The response from the failed request.\n   */\n  protected _getErrorMessageFromResponse(response: unknown) {\n    const res = response as {\n      error?: string;\n      data?: {\n        message?: string;\n        error?: string;\n      };\n    };\n    if (res.error) return res.error;\n    if (res.data) {\n      if (res.data.message) return res.data.message;\n      if (res.data.error) return res.data.error;\n    }\n\n    return 'Unexpected error';\n  }\n  /**\n   * Generates an {@link _HTTPError} from the response of a failed request.\n   *\n   * @param response  The response from the failed request.\n   * @param status    The status code of the response.\n   */\n  protected override formatError<ResponseType extends ErrorResponse>(\n    response: ResponseType,\n    status: number,\n  ): Error {\n    return new this._HTTPError(this._getErrorMessageFromResponse(response), status);\n  }\n}\n/**\n * The options for the provider creator that registers an {@link APIClient} in the\n * container.\n * These options allow the application to register multiple instances for different APIs.\n *\n * @group Services/APIClient\n */\nexport type APIClientProviderOptions = {\n  /**\n   * The name of the service that will be registered into the app.\n   *\n   * @default 'apiClient'\n   */\n  serviceName?: string;\n  /**\n   * The name of the configuration setting that has the API information.\n   *\n   * @default 'api'\n   */\n  configSetting?: string;\n  /**\n   * The class the service will instantiate. It has to extend {@link APIClient}.\n   *\n   * @default APIClient\n   */\n  clientClass?: typeof APIClient;\n};\n/**\n * The provider creator to register an instance of {@link APIClient} on the container.\n *\n * @example\n *\n * <caption>Basic usage</caption>\n *\n *   // Register it on the container\n *   container.register(apiClientProvider);\n *   // Getting access to the service instance\n *   const apiClient = container.get<APIClient>('apiClient');\n *\n * @example\n *\n * <caption>With custom options</caption>\n *\n *   container.register(\n *     apiClientProvider({\n *       serviceName: 'myApiClient',\n *       configSetting: 'myApi',\n *     }),\n *   );\n *\n * @group Providers\n * @group Services/APIClient\n */\nexport const apiClientProvider = providerCreator(\n  (options: APIClientProviderOptions = {}) =>\n    (app) => {\n      const defaultName = 'apiClient';\n      const { serviceName = defaultName, clientClass: ClientClass = APIClient } = options;\n      let { configSetting } = options;\n      if (!configSetting) {\n        configSetting = serviceName === defaultName ? 'api' : serviceName;\n      }\n\n      app.set(\n        serviceName,\n        () =>\n          new ClientClass({\n            inject: {\n              http: app.get('http'),\n              HTTPError: app.get('HTTPError'),\n            },\n            ...app.getConfig<APIClientSettings>(configSetting!),\n          }),\n      );\n    },\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAKO;AACP,yBAAwC;AACxC,mBAAgC;AAkEzB,MAAM,kBAAkB,iBAAAA,UAAc;AAAA,EAgB3C,YAAY,EAAE,QAAQ,EAAE,MAAM,UAAU,MAAM,KAAK,GAAgC;AACjF,UAAM,EAAE,WAAW,SAAS,IAAI,IAAI;AACpC,UAAM,eAAgB,aAAa;AACnC,UAAM,YAAY;AAAA,MAChB;AAAA,MACA,WAAW;AAAA,IACb;AACA,UAAM;AAAA,MACJ,GAAG;AAAA,MACH,aAAa,KAAK;AAAA,IACpB,CAAC;AAtBH,wBAAmB;AAInB,wBAAmB;AAInB,wBAAmB;AAgBjB,SAAK,QAAQ;AACb,SAAK,aAAa;AAClB,SAAK,iBAAa,4CAAwB,CAAC,GAAG,SAAS;AAAA,EACzD;AAAA,EAIA,IAAI,YAAuC;AACzC,eAAO,4CAAwB,CAAC,GAAG,KAAK,UAAU;AAAA,EACpD;AAAA,EAMU,6BAA6B,UAAmB;AACxD,UAAM,MAAM;AAOZ,QAAI,IAAI;AAAO,aAAO,IAAI;AAC1B,QAAI,IAAI,MAAM;AACZ,UAAI,IAAI,KAAK;AAAS,eAAO,IAAI,KAAK;AACtC,UAAI,IAAI,KAAK;AAAO,eAAO,IAAI,KAAK;AAAA,IACtC;AAEA,WAAO;AAAA,EACT;AAAA,EAOmB,YACjB,UACA,QACO;AACP,WAAO,IAAI,KAAK,WAAW,KAAK,6BAA6B,QAAQ,GAAG,MAAM;AAAA,EAChF;AACF;AAsDO,MAAM,wBAAoB;AAAA,EAC/B,CAAC,UAAoC,CAAC,MACpC,CAAC,QAAQ;AACP,UAAM,cAAc;AACpB,UAAM,EAAE,cAAc,aAAa,aAAa,cAAc,UAAU,IAAI;AAC5E,QAAI,EAAE,cAAc,IAAI;AACxB,QAAI,CAAC,eAAe;AAClB,sBAAgB,gBAAgB,cAAc,QAAQ;AAAA,IACxD;AAEA,QAAI;AAAA,MACF;AAAA,MACA,MACE,IAAI,YAAY;AAAA,QACd,QAAQ;AAAA,UACN,MAAM,IAAI,IAAI,MAAM;AAAA,UACpB,WAAW,IAAI,IAAI,WAAW;AAAA,QAChC;AAAA,QACA,GAAG,IAAI,UAA6B,aAAc;AAAA,MACpD,CAAC;AAAA,IACL;AAAA,EACF;AACJ;","names":["APIClientBase"]}

package/dist/services/http/http.d.ts

@@ -0,0 +1,175 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../jimpex-7eaee271.js';
+import { Request } from 'express';
+import { BodyInit, Response, RequestInit } from 'node-fetch';
+import { SimpleLogger } from '@homer0/simple-logger';
+import '@homer0/events-hub';
+import '../../types/express.js';
+import '../../types/http.js';
+import 'https';
+import 'http';
+import 'spdy';
+import '@homer0/simple-config';
+import '../../types/utils.js';
+
+/**
+ * The options to customize the service.
+ *
+ * @group Services/HTTP
+ */
+type HTTPOptions = {
+    /**
+     * Whether or not the service should log the requests and their responses.
+     */
+    logRequests?: boolean;
+};
+/**
+ * The options to construct a {@link HTTP}.
+ *
+ * @group Services/HTTP
+ */
+type HTTPContructorOptions = Partial<HTTPOptions> & {
+    /**
+     * A dictionary with the dependencies to inject.
+     */
+    inject: {
+        logger: SimpleLogger;
+    };
+};
+/**
+ * The allowed formats for the body of a request.
+ *
+ * @group Services/HTTP
+ */
+type HTTPFetchBody = string | Record<string | number, unknown> | BodyInit;
+/**
+ * The options for a request.
+ *
+ * @group Services/HTTP
+ */
+type HTTPFetchOptions = {
+    /**
+     * The HTTP method.
+     *
+     * @default 'GET'
+     */
+    method?: string;
+    /**
+     * The headers dictionary.
+     */
+    headers?: Record<string, string>;
+    /**
+     * The body of the request.
+     */
+    body?: HTTPFetchBody;
+    /**
+     * A dictionary of query string parameters.
+     */
+    qs?: Record<string, unknown>;
+    /**
+     * A request object generated by the application. This can be used to copy information
+     * like custom headers or the IP (for the X-Forwarded-For header).
+     */
+    req?: Request;
+};
+/**
+ * The options for the method that extracts custom headers from a request.
+ *
+ * @group Services/HTTP
+ */
+type GetCustomHeadersFromRequestOptions = {
+    /**
+     * Since the method considers all headers that start with `x-` as custom headers,
+     * setting this to `false` is the only way to exclude `x-forwarded-` headers from the
+     * list.
+     *
+     * @default false
+     */
+    includeXForwardedHeaders?: boolean;
+};
+/**
+ * A set of utilities to work with HTTP requests and responses.
+ *
+ * @group Services
+ * @group Services/HTTP
+ */
+declare class HTTP {
+    /**
+     * The service used to log information in the terminal.
+     */
+    protected readonly _logger: SimpleLogger;
+    /**
+     * The service customization options.
+     */
+    protected readonly _options: HTTPOptions;
+    /**
+     * @param options  The options to construct the class.
+     */
+    constructor({ inject: { logger }, ...options }: HTTPContructorOptions);
+    /**
+     * Makes a fetch request.
+     *
+     * @param url      The URL to fetch.
+     * @param options  The custom options for the request.
+     */
+    fetch(url: string, options?: HTTPFetchOptions): Promise<Response>;
+    /**
+     * Tries to get the IP address from a given request.
+     *
+     * @param req  The request from which it will try to obtain the IP address.
+     */
+    getIPFromRequest(req: Request): string | undefined;
+    /**
+     * Creates a dictionary with all the custom headers a request has. By custom header it
+     * means all the headers which name start with `x-`.
+     *
+     * @param req      The request from which it will try to get the headers.
+     * @param options  The options to customize the behavior with certain headers.
+     */
+    getCustomHeadersFromRequest(req: Request, options?: GetCustomHeadersFromRequestOptions): Record<string, string>;
+    /**
+     * It takes a dictionary of headers and normalize the names so each word will start with
+     * an upper case character. This is helpful in case you added custom headers and didn't
+     * care about the casing, or when copying headers from a server request, as they all
+     * come tranformed into lower case.
+     *
+     * @param headers  The dictionary of headers to normalize.
+     */
+    normalizeHeaders(headers: Record<string, string>): Record<string, string>;
+    /**
+     * The customization options.
+     */
+    get options(): Readonly<HTTPOptions>;
+    /**
+     * Logs a request information into the terminal.
+     *
+     * @param url      The request URL.
+     * @param options  The options for the request.
+     */
+    protected _logRequest(url: string, options: RequestInit): void;
+    /**
+     * Logs a response information into the terminal.
+     *
+     * @param response  The response to log.
+     */
+    protected _logResponse(response: Response): void;
+}
+/**
+ * The service provider that once registered on the container will set an instance of
+ * {@link HTTP} as the `http` service. The provider also checks the `debug.logRequests`
+ * setting on the application configuration in order to enable or not the logging of
+ * requests/responses.
+ *
+ * @example
+ *
+ *   // Register it on the container
+ *   container.register(httpProvider);
+ *   // Getting access to the service instance
+ *   const http = container.get<HTTP>('http');
+ *
+ * @group Providers
+ * @group Services/HTTP
+ */
+declare const httpProvider: _homer0_jimple.Resource<"provider", "register", _homer0_jimple.ProviderRegisterFn<Jimpex>>;
+
+export { GetCustomHeadersFromRequestOptions, HTTP, HTTPContructorOptions, HTTPFetchBody, HTTPFetchOptions, HTTPOptions, httpProvider };

package/dist/services/http/http.js

@@ -0,0 +1,158 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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 http_exports = {};
+__export(http_exports, {
+  HTTP: () => HTTP,
+  httpProvider: () => httpProvider
+});
+module.exports = __toCommonJS(http_exports);
+var import_node_fetch = __toESM(require("node-fetch"));
+var import_urijs = __toESM(require("urijs"));
+var import_deep_assign = require("@homer0/deep-assign");
+var import_utils = require("../../utils");
+class HTTP {
+  constructor({ inject: { logger }, ...options }) {
+    __publicField(this, "_logger");
+    __publicField(this, "_options");
+    this._logger = logger;
+    this._options = (0, import_deep_assign.deepAssignWithOverwrite)(
+      {
+        logRequests: false
+      },
+      options
+    );
+    this.fetch = this.fetch.bind(this);
+  }
+  async fetch(url, options = {}) {
+    let useURL = url;
+    if (options.qs) {
+      useURL = (0, import_urijs.default)(url).query(options.qs).toString();
+    }
+    const fetchOptions = {
+      method: (options.method || "get").toUpperCase(),
+      body: options.body
+    };
+    let defaultHeaders;
+    if (options.req) {
+      defaultHeaders = this.getCustomHeadersFromRequest(options.req);
+      const ip = this.getIPFromRequest(options.req);
+      if (ip) {
+        defaultHeaders["x-forwarded-for"] = ip;
+      }
+    }
+    const headers = {
+      ...defaultHeaders,
+      ...options.headers
+    };
+    if (Object.keys(headers).length) {
+      fetchOptions.headers = this.normalizeHeaders(headers);
+    }
+    const { logRequests } = this._options;
+    if (logRequests) {
+      this._logRequest(useURL, fetchOptions);
+    }
+    const response = await (0, import_node_fetch.default)(useURL, fetchOptions);
+    if (logRequests) {
+      this._logResponse(response);
+    }
+    return response;
+  }
+  getIPFromRequest(req) {
+    const headerValue = req.headers["x-forwarded-for"];
+    if (headerValue) {
+      return String(headerValue);
+    }
+    return req?.connection?.remoteAddress || req?.socket?.remoteAddress;
+  }
+  getCustomHeadersFromRequest(req, options = {}) {
+    const { includeXForwardedHeaders = false } = options;
+    return Object.keys(req.headers).reduce((acc, headerName) => {
+      if (headerName.startsWith("x-") && (includeXForwardedHeaders || !headerName.startsWith("x-forwarded-"))) {
+        acc[headerName] = req.headers[headerName];
+      }
+      return acc;
+    }, {});
+  }
+  normalizeHeaders(headers) {
+    return Object.keys(headers).reduce((acc, name) => {
+      const newName = name.split("-").map((part) => part.replace(/^(\w)/, (_, letter) => letter.toUpperCase())).join("-");
+      acc[newName] = headers[name];
+      return acc;
+    }, {});
+  }
+  get options() {
+    return (0, import_deep_assign.deepAssignWithOverwrite)({}, this._options);
+  }
+  _logRequest(url, options) {
+    const { method, headers } = options;
+    const prefix = "REQUEST> ";
+    const lines = ["--->>", `${prefix}${method} ${url}`];
+    if (headers) {
+      Object.keys(headers).forEach((header) => {
+        const value = headers[header];
+        lines.push(`${prefix}${header}: ${value}`);
+      });
+    }
+    if (options.body) {
+      lines.push(`${prefix}body: "${options.body}"`);
+    }
+    this._logger.info(lines);
+  }
+  _logResponse(response) {
+    const prefix = "RESPONSE> ";
+    const lines = [
+      "<<---",
+      `${prefix}${response.url}`,
+      `${prefix}status: ${response.status}`
+    ];
+    response.headers.forEach((value, header) => {
+      lines.push(`${prefix}${header}: ${value}`);
+    });
+    this._logger.info(lines);
+  }
+}
+const httpProvider = (0, import_utils.provider)((app) => {
+  app.set("http", () => {
+    const config = app.getConfig();
+    const logRequests = config.get("debug.logRequests") === true;
+    return new HTTP({
+      inject: {
+        logger: app.get("logger")
+      },
+      logRequests
+    });
+  });
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HTTP,
+  httpProvider
+});
+//# sourceMappingURL=http.js.map

package/dist/services/http/http.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/http/http.ts"],"sourcesContent":["import fetch, { type RequestInit, type BodyInit } from 'node-fetch';\nimport urijs from 'urijs';\nimport { deepAssignWithOverwrite } from '@homer0/deep-assign';\nimport { provider } from '../../utils';\nimport { Logger, Request, HTTPResponse } from '../../types';\n/**\n * The options to customize the service.\n *\n * @group Services/HTTP\n */\nexport type HTTPOptions = {\n  /**\n   * Whether or not the service should log the requests and their responses.\n   */\n  logRequests?: boolean;\n};\n/**\n * The options to construct a {@link HTTP}.\n *\n * @group Services/HTTP\n */\nexport type HTTPContructorOptions = Partial<HTTPOptions> & {\n  /**\n   * A dictionary with the dependencies to inject.\n   */\n  inject: {\n    logger: Logger;\n  };\n};\n/**\n * The allowed formats for the body of a request.\n *\n * @group Services/HTTP\n */\nexport type HTTPFetchBody = string | Record<string | number, unknown> | BodyInit;\n/**\n * The options for a request.\n *\n * @group Services/HTTP\n */\nexport type HTTPFetchOptions = {\n  /**\n   * The HTTP method.\n   *\n   * @default 'GET'\n   */\n  method?: string;\n  /**\n   * The headers dictionary.\n   */\n  headers?: Record<string, string>;\n  /**\n   * The body of the request.\n   */\n  body?: HTTPFetchBody;\n  /**\n   * A dictionary of query string parameters.\n   */\n  qs?: Record<string, unknown>;\n  /**\n   * A request object generated by the application. This can be used to copy information\n   * like custom headers or the IP (for the X-Forwarded-For header).\n   */\n  req?: Request;\n};\n/**\n * The options for the method that extracts custom headers from a request.\n *\n * @group Services/HTTP\n */\nexport type GetCustomHeadersFromRequestOptions = {\n  /**\n   * Since the method considers all headers that start with `x-` as custom headers,\n   * setting this to `false` is the only way to exclude `x-forwarded-` headers from the\n   * list.\n   *\n   * @default false\n   */\n  includeXForwardedHeaders?: boolean;\n};\n/**\n * A set of utilities to work with HTTP requests and responses.\n *\n * @group Services\n * @group Services/HTTP\n */\nexport class HTTP {\n  /**\n   * The service used to log information in the terminal.\n   */\n  protected readonly _logger: Logger;\n  /**\n   * The service customization options.\n   */\n  protected readonly _options: HTTPOptions;\n  /**\n   * @param options  The options to construct the class.\n   */\n  constructor({ inject: { logger }, ...options }: HTTPContructorOptions) {\n    this._logger = logger;\n    this._options = deepAssignWithOverwrite(\n      {\n        logRequests: false,\n      },\n      options,\n    );\n\n    this.fetch = this.fetch.bind(this);\n  }\n  /**\n   * Makes a fetch request.\n   *\n   * @param url      The URL to fetch.\n   * @param options  The custom options for the request.\n   */\n  async fetch(url: string, options: HTTPFetchOptions = {}): Promise<HTTPResponse> {\n    let useURL = url;\n    if (options.qs) {\n      useURL = urijs(url).query(options.qs).toString();\n    }\n\n    const fetchOptions: RequestInit = {\n      method: (options.method || 'get').toUpperCase(),\n      body: options.body as BodyInit,\n    };\n\n    let defaultHeaders: Record<string, string> | undefined;\n    if (options.req) {\n      defaultHeaders = this.getCustomHeadersFromRequest(options.req);\n      const ip = this.getIPFromRequest(options.req);\n      if (ip) {\n        defaultHeaders['x-forwarded-for'] = ip;\n      }\n    }\n    const headers = {\n      ...defaultHeaders,\n      ...options.headers,\n    };\n\n    if (Object.keys(headers).length) {\n      fetchOptions.headers = this.normalizeHeaders(headers);\n    }\n\n    const { logRequests } = this._options;\n    if (logRequests) {\n      this._logRequest(useURL, fetchOptions);\n    }\n\n    const response = await fetch(useURL, fetchOptions);\n    if (logRequests) {\n      this._logResponse(response);\n    }\n\n    return response;\n  }\n  /**\n   * Tries to get the IP address from a given request.\n   *\n   * @param req  The request from which it will try to obtain the IP address.\n   */\n  getIPFromRequest(req: Request): string | undefined {\n    const headerValue = req.headers['x-forwarded-for'];\n    if (headerValue) {\n      return String(headerValue);\n    }\n\n    return req?.connection?.remoteAddress || req?.socket?.remoteAddress;\n  }\n  /**\n   * Creates a dictionary with all the custom headers a request has. By custom header it\n   * means all the headers which name start with `x-`.\n   *\n   * @param req      The request from which it will try to get the headers.\n   * @param options  The options to customize the behavior with certain headers.\n   */\n  getCustomHeadersFromRequest(\n    req: Request,\n    options: GetCustomHeadersFromRequestOptions = {},\n  ): Record<string, string> {\n    const { includeXForwardedHeaders = false } = options;\n    return Object.keys(req.headers).reduce<Record<string, string>>((acc, headerName) => {\n      if (\n        headerName.startsWith('x-') &&\n        (includeXForwardedHeaders || !headerName.startsWith('x-forwarded-'))\n      ) {\n        acc[headerName] = req.headers[headerName] as string;\n      }\n      return acc;\n    }, {});\n  }\n  /**\n   * It takes a dictionary of headers and normalize the names so each word will start with\n   * an upper case character. This is helpful in case you added custom headers and didn't\n   * care about the casing, or when copying headers from a server request, as they all\n   * come tranformed into lower case.\n   *\n   * @param headers  The dictionary of headers to normalize.\n   */\n  normalizeHeaders(headers: Record<string, string>): Record<string, string> {\n    return Object.keys(headers).reduce<Record<string, string>>((acc, name) => {\n      const newName = name\n        .split('-')\n        .map((part) => part.replace(/^(\\w)/, (_, letter) => letter.toUpperCase()))\n        .join('-');\n\n      acc[newName] = headers[name]!;\n      return acc;\n    }, {});\n  }\n  /**\n   * The customization options.\n   */\n  get options(): Readonly<HTTPOptions> {\n    return deepAssignWithOverwrite({}, this._options);\n  }\n  /**\n   * Logs a request information into the terminal.\n   *\n   * @param url      The request URL.\n   * @param options  The options for the request.\n   */\n  protected _logRequest(url: string, options: RequestInit): void {\n    const { method, headers } = options;\n    const prefix = 'REQUEST> ';\n    const lines = ['--->>', `${prefix}${method} ${url}`];\n    if (headers) {\n      Object.keys(headers).forEach((header) => {\n        const value = headers[header as keyof typeof headers];\n        lines.push(`${prefix}${header}: ${value}`);\n      });\n    }\n\n    if (options.body) {\n      lines.push(`${prefix}body: \"${options.body}\"`);\n    }\n\n    this._logger.info(lines);\n  }\n  /**\n   * Logs a response information into the terminal.\n   *\n   * @param response  The response to log.\n   */\n  protected _logResponse(response: HTTPResponse) {\n    const prefix = 'RESPONSE> ';\n    const lines = [\n      '<<---',\n      `${prefix}${response.url}`,\n      `${prefix}status: ${response.status}`,\n    ];\n\n    response.headers.forEach((value, header) => {\n      lines.push(`${prefix}${header}: ${value}`);\n    });\n\n    this._logger.info(lines);\n  }\n}\n/**\n * The service provider that once registered on the container will set an instance of\n * {@link HTTP} as the `http` service. The provider also checks the `debug.logRequests`\n * setting on the application configuration in order to enable or not the logging of\n * requests/responses.\n *\n * @example\n *\n *   // Register it on the container\n *   container.register(httpProvider);\n *   // Getting access to the service instance\n *   const http = container.get<HTTP>('http');\n *\n * @group Providers\n * @group Services/HTTP\n */\nexport const httpProvider = provider((app) => {\n  app.set('http', () => {\n    const config = app.getConfig();\n    const logRequests = config.get<boolean | undefined>('debug.logRequests') === true;\n    return new HTTP({\n      inject: {\n        logger: app.get('logger'),\n      },\n      logRequests,\n    });\n  });\n});\n"],"mappings":"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","names":["urijs","fetch"]}