jimpex 7.0.2 → 9.0.0

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

@@ -0,0 +1,170 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-efeb437e.js';
+import { HTTPErrorClass } from '../common/httpError.mjs';
+import { HTTP } from './http.mjs';
+import { APIClientOptions, APIClient as APIClient$1, ErrorResponse } from '@homer0/api-utils';
+export { ErrorResponse } from '@homer0/api-utils';
+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/appError.mjs';
+
+/**
+ * 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.d.ts

@@ -0,0 +1,170 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-b2a04c78.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 '../../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/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,122 @@
+"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 {
+  /**
+   * @param options  The options to construct the class.
+   */
+  constructor({ inject: { http, HTTPError }, ...rest }) {
+    const { endpoints, gateway, url } = rest;
+    const useEndpoints = endpoints || gateway;
+    const apiConfig = {
+      url,
+      endpoints: useEndpoints
+    };
+    super({
+      ...apiConfig,
+      fetchClient: http.fetch
+    });
+    /**
+     * The service that makes the requests to the API.
+     */
+    __publicField(this, "_http");
+    /**
+     * The class to generate possible errors in the requests.
+     */
+    __publicField(this, "_HTTPError");
+    /**
+     * The configuration of the API it uses.
+     */
+    __publicField(this, "_apiConfig");
+    this._http = http;
+    this._HTTPError = HTTPError;
+    this._apiConfig = (0, import_deep_assign.deepAssignWithOverwrite)({}, apiConfig);
+  }
+  /**
+   * The configuration for the API.
+   */
+  get apiConfig() {
+    return (0, import_deep_assign.deepAssignWithOverwrite)({}, this._apiConfig);
+  }
+  /**
+   * Tries to obtain a message from an error caused on a failed request.
+   *
+   * @param response  The response from the failed request.
+   */
+  _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";
+  }
+  /**
+   * 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.
+   */
+  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;AAAA;AAAA;AAAA,EAgB3C,YAAY,EAAE,QAAQ,EAAE,MAAM,UAAU,GAAG,GAAG,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;AAAA;AAAA;AAAA,wBAAmB;AAInB;AAAA;AAAA;AAAA,wBAAmB;AAInB;AAAA;AAAA;AAAA,wBAAmB;AAgBjB,SAAK,QAAQ;AACb,SAAK,aAAa;AAClB,SAAK,iBAAa,4CAAwB,CAAC,GAAG,SAAS;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,YAAuC;AACzC,eAAO,4CAAwB,CAAC,GAAG,KAAK,UAAU;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA;AAAA;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;AAAA;AAAA;AAAA;AAAA;AAAA;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.mts

@@ -0,0 +1,176 @@
+import * as _homer0_jimple from '@homer0/jimple';
+import { J as Jimpex } from '../../index-efeb437e.js';
+import { Request } from 'express';
+import { BodyInit, Response, RequestInit } from 'node-fetch';
+import { SimpleLogger } from '@homer0/simple-logger';
+import '../../types/express.mjs';
+import '../../types/http.mjs';
+import 'https';
+import 'http';
+import 'spdy';
+import '../../types/utils.mjs';
+import '@homer0/path-utils';
+import '@homer0/simple-config';
+import '@homer0/events-hub';
+
+/**
+ * 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 };