@decaf-ts/for-http 0.2.1 → 0.2.3

package/lib/esm/adapter.js

@@ -1,24 +1,90 @@
 import { Adapter, UnsupportedError, } from "@decaf-ts/core";
-import { RestService } from "./RestService";
+import { RestService } from "./RestService.js";
+/**
+ * @description Abstract HTTP adapter for REST API interactions
+ * @summary Provides a base implementation for HTTP adapters with methods for CRUD operations,
+ * URL construction, and error handling. This class extends the core Adapter class and
+ * implements the necessary methods for HTTP communication. Concrete implementations
+ * must provide specific HTTP client functionality.
+ * @template Y - The native HTTP client type
+ * @template Q - The query type used by the adapter
+ * @template F - The HTTP flags type, extending HttpFlags
+ * @template C - The context type, extending Context<F>
+ * @param {Y} native - The native HTTP client instance
+ * @param {HttpConfig} config - Configuration for the HTTP adapter
+ * @param {string} flavour - The adapter flavor identifier
+ * @param {string} [alias] - Optional alias for the adapter
+ * @example
+ * ```typescript
+ * // Example implementation with Axios
+ * class AxiosAdapter extends HttpAdapter<AxiosInstance, AxiosRequestConfig> {
+ *   constructor(config: HttpConfig) {
+ *     super(axios.create(), config, 'axios');
+ *   }
+ *
+ *   async request<V>(details: AxiosRequestConfig): Promise<V> {
+ *     const response = await this.native.request(details);
+ *     return response.data;
+ *   }
+ *
+ *   // Implement other abstract methods...
+ * }
+ * ```
+ * @class
+ */
 export class HttpAdapter extends Adapter {
     constructor(native, config, flavour, alias) {
         super(native, flavour, alias);
         this.config = config;
     }
+    /**
+     * @description Generates operation flags with HTTP headers
+     * @summary Extends the base flags method to include HTTP-specific headers for operations.
+     * This method adds an empty headers object to the flags returned by the parent class.
+     * @template F - The Repository Flags type
+     * @template M - The model type
+     * @param {OperationKeys.CREATE|OperationKeys.READ|OperationKeys.UPDATE|OperationKeys.DELETE} operation - The operation type
+     * @param {Constructor<M>} model - The model constructor
+     * @param {Partial<F>} overrides - Optional flag overrides
+     * @return {F} The flags object with headers
+     */
     flags(operation, model, overrides) {
         return Object.assign(super.flags(operation, model, overrides), {
             headers: {},
         });
     }
+    /**
+     * @description Returns the repository constructor for this adapter
+     * @summary Provides the RestService class as the repository implementation for this HTTP adapter.
+     * This method is used to create repository instances that work with this adapter type.
+     * @template M - The model type
+     * @return {Constructor<Repository<M, Q, HttpAdapter<Y, Q, F, C>>>} The repository constructor
+     */
     repository() {
         return RestService;
     }
+    /**
+     * @description Constructs a URL for API requests
+     * @summary Builds a complete URL for API requests using the configured protocol and host,
+     * the specified table name, and optional query parameters. The method handles URL encoding.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {Record<string, string | number>} [queryParams] - Optional query parameters
+     * @return {string} The encoded URL string
+     */
     url(tableName, queryParams) {
         const url = new URL(`${this.config.protocol}://${this.config.host}/${tableName}`);
         if (queryParams)
             Object.entries(queryParams).forEach(([key, value]) => url.searchParams.append(key, value.toString()));
         return encodeURI(url.toString());
     }
+    /**
+     * @description Parses and converts errors to BaseError type
+     * @summary Processes errors that occur during HTTP operations and converts them to
+     * the appropriate BaseError type. Currently returns the error as-is, but can be
+     * extended to handle specific error messages differently.
+     * @param {Error} err - The error to parse
+     * @return {BaseError} The parsed error as a BaseError
+     */
     parseError(err) {
         const { message } = err;
         switch (message) {
@@ -26,24 +92,71 @@ export class HttpAdapter extends Adapter {
                 return err;
         }
     }
+    /**
+     * @description Initializes the HTTP adapter
+     * @summary Placeholder method for adapter initialization. This method is currently
+     * a no-op but can be overridden by subclasses to perform initialization tasks.
+     * @param {...any[]} args - Initialization arguments
+     * @return {Promise<void>} A promise that resolves when initialization is complete
+     */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async initialize(...args) {
         // do nothing
     }
+    /**
+     * @description Executes a raw query
+     * @summary Method for executing raw queries directly with the HTTP client.
+     * This method is not supported by default in HTTP adapters and throws an UnsupportedError.
+     * Subclasses can override this method to provide implementation.
+     * @template R - The result type
+     * @param {Q} rawInput - The raw query input
+     * @param {boolean} process - Whether to process the result
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<R>} A promise that resolves with the query result
+     * @throws {UnsupportedError} Always throws as this method is not supported by default
+     */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     raw(rawInput, process, ...args) {
         throw new UnsupportedError("Api is not natively available for HttpAdapters. If required, please extends this class");
     }
+    /**
+     * @description Creates a sequence
+     * @summary Method for creating a sequence for generating unique identifiers.
+     * This method is not supported by default in HTTP adapters and throws an UnsupportedError.
+     * Subclasses can override this method to provide implementation.
+     * @param {SequenceOptions} options - Options for creating the sequence
+     * @return {Promise<Sequence>} A promise that resolves with the created sequence
+     * @throws {UnsupportedError} Always throws as this method is not supported by default
+     */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     Sequence(options) {
         throw new UnsupportedError("Api is not natively available for HttpAdapters. If required, please extends this class");
     }
+    /**
+     * @description Creates a statement for querying
+     * @summary Method for creating a statement for building and executing queries.
+     * This method is not supported by default in HTTP adapters and throws an UnsupportedError.
+     * Subclasses can override this method to provide implementation.
+     * @template M - The model type
+     * @template ! - The raw query type
+     * @return {Statement<Q, M, any>} A statement object for building queries
+     * @throws {UnsupportedError} Always throws as this method is not supported by default
+     */
     Statement() {
         throw new UnsupportedError("Api is not natively available for HttpAdapters. If required, please extends this class");
     }
+    /**
+     * @description Parses a condition into a query
+     * @summary Method for parsing a condition object into a query format understood by the HTTP client.
+     * This method is not supported by default in HTTP adapters and throws an UnsupportedError.
+     * Subclasses can override this method to provide implementation.
+     * @param {Condition<any>} condition - The condition to parse
+     * @return {Q} The parsed query
+     * @throws {UnsupportedError} Always throws as this method is not supported by default
+     */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     parseCondition(condition) {
         throw new UnsupportedError("Api is not natively available for HttpAdapters. If required, please extends this class");
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EAKP,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAIxB,OAAO,EAAE,WAAW,EAAE,yBAAsB;AAG5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,OAAgB,WAKpB,SAAQ,OAAmB;IAC3B,YACE,MAAS,EACC,MAAkB,EAC5B,OAAe,EACf,KAAc;QAEd,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;QAJpB,WAAM,GAAN,MAAM,CAAY;IAK9B,CAAC;IAED;;;;;;;;;;OAUG;IACM,KAAK,CACZ,SAIwB,EACxB,KAAqB,EACrB,SAAqB;QAErB,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAI,SAAS,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE;YAChE,OAAO,EAAE,EAAE;SACZ,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACM,UAAU;QAGjB,OAAO,WAEN,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACO,GAAG,CACX,SAAiB,EACjB,WAA6C;QAE7C,MAAM,GAAG,GAAG,IAAI,GAAG,CACjB,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,SAAS,EAAE,CAC7D,CAAC;QACF,IAAI,WAAW;YACb,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CACnD,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAC/C,CAAC;QAEJ,OAAO,SAAS,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;;OAOG;IACH,UAAU,CAAC,GAAU;QACnB,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,CAAC;QACxB,QAAQ,OAAO,EAAE,CAAC;YAChB;gBACE,OAAO,GAAgB,CAAC;QAC5B,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,6DAA6D;IAC7D,KAAK,CAAC,UAAU,CAAC,GAAG,IAAW;QAC7B,aAAa;IACf,CAAC;IA4ED;;;;;;;;;;;OAWG;IACH,6DAA6D;IAC7D,GAAG,CAAI,QAAW,EAAE,OAAgB,EAAE,GAAG,IAAW;QAClD,MAAM,IAAI,gBAAgB,CACxB,wFAAwF,CACzF,CAAC;IACJ,CAAC;IAED;;;;;;;;OAQG;IACH,6DAA6D;IAC7D,QAAQ,CAAC,OAAwB;QAC/B,MAAM,IAAI,gBAAgB,CACxB,wFAAwF,CACzF,CAAC;IACJ,CAAC;IAED;;;;;;;;;OASG;IACM,SAAS;QAChB,MAAM,IAAI,gBAAgB,CACxB,wFAAwF,CACzF,CAAC;IACJ,CAAC;IAED;;;;;;;;OAQG;IACH,6DAA6D;IAC7D,cAAc,CAAC,SAAyB;QACtC,MAAM,IAAI,gBAAgB,CACxB,wFAAwF,CACzF,CAAC;IACJ,CAAC;CACF","sourcesContent":["import {\n  Adapter,\n  Condition,\n  Repository,\n  Sequence,\n  SequenceOptions,\n  UnsupportedError,\n} from \"@decaf-ts/core\";\nimport { BaseError, Context, OperationKeys } from \"@decaf-ts/db-decorators\";\nimport { HttpConfig, HttpFlags } from \"./types\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { RestService } from \"./RestService\";\nimport { Statement } from \"@decaf-ts/core\";\n\n/**\n * @description Abstract HTTP adapter for REST API interactions\n * @summary Provides a base implementation for HTTP adapters with methods for CRUD operations,\n * URL construction, and error handling. This class extends the core Adapter class and\n * implements the necessary methods for HTTP communication. Concrete implementations\n * must provide specific HTTP client functionality.\n * @template Y - The native HTTP client type\n * @template Q - The query type used by the adapter\n * @template F - The HTTP flags type, extending HttpFlags\n * @template C - The context type, extending Context<F>\n * @param {Y} native - The native HTTP client instance\n * @param {HttpConfig} config - Configuration for the HTTP adapter\n * @param {string} flavour - The adapter flavor identifier\n * @param {string} [alias] - Optional alias for the adapter\n * @example\n * ```typescript\n * // Example implementation with Axios\n * class AxiosAdapter extends HttpAdapter<AxiosInstance, AxiosRequestConfig> {\n *   constructor(config: HttpConfig) {\n *     super(axios.create(), config, 'axios');\n *   }\n *\n *   async request<V>(details: AxiosRequestConfig): Promise<V> {\n *     const response = await this.native.request(details);\n *     return response.data;\n *   }\n *\n *   // Implement other abstract methods...\n * }\n * ```\n * @class\n */\nexport abstract class HttpAdapter<\n  Y,\n  Q,\n  F extends HttpFlags = HttpFlags,\n  C extends Context<F> = Context<F>,\n> extends Adapter<Y, Q, F, C> {\n  protected constructor(\n    native: Y,\n    protected config: HttpConfig,\n    flavour: string,\n    alias?: string\n  ) {\n    super(native, flavour, alias);\n  }\n\n  /**\n   * @description Generates operation flags with HTTP headers\n   * @summary Extends the base flags method to include HTTP-specific headers for operations.\n   * This method adds an empty headers object to the flags returned by the parent class.\n   * @template F - The Repository Flags type\n   * @template M - The model type\n   * @param {OperationKeys.CREATE|OperationKeys.READ|OperationKeys.UPDATE|OperationKeys.DELETE} operation - The operation type\n   * @param {Constructor<M>} model - The model constructor\n   * @param {Partial<F>} overrides - Optional flag overrides\n   * @return {F} The flags object with headers\n   */\n  override flags<M extends Model>(\n    operation:\n      | OperationKeys.CREATE\n      | OperationKeys.READ\n      | OperationKeys.UPDATE\n      | OperationKeys.DELETE,\n    model: Constructor<M>,\n    overrides: Partial<F>\n  ) {\n    return Object.assign(super.flags<M>(operation, model, overrides), {\n      headers: {},\n    });\n  }\n\n  /**\n   * @description Returns the repository constructor for this adapter\n   * @summary Provides the RestService class as the repository implementation for this HTTP adapter.\n   * This method is used to create repository instances that work with this adapter type.\n   * @template M - The model type\n   * @return {Constructor<Repository<M, Q, HttpAdapter<Y, Q, F, C>>>} The repository constructor\n   */\n  override repository<M extends Model>(): Constructor<\n    Repository<M, Q, HttpAdapter<Y, Q, F, C>>\n  > {\n    return RestService as unknown as Constructor<\n      Repository<M, Q, HttpAdapter<Y, Q, F, C>>\n    >;\n  }\n\n  /**\n   * @description Constructs a URL for API requests\n   * @summary Builds a complete URL for API requests using the configured protocol and host,\n   * the specified table name, and optional query parameters. The method handles URL encoding.\n   * @param {string} tableName - The name of the table or endpoint\n   * @param {Record<string, string | number>} [queryParams] - Optional query parameters\n   * @return {string} The encoded URL string\n   */\n  protected url(\n    tableName: string,\n    queryParams?: Record<string, string | number>\n  ) {\n    const url = new URL(\n      `${this.config.protocol}://${this.config.host}/${tableName}`\n    );\n    if (queryParams)\n      Object.entries(queryParams).forEach(([key, value]) =>\n        url.searchParams.append(key, value.toString())\n      );\n\n    return encodeURI(url.toString());\n  }\n\n  /**\n   * @description Parses and converts errors to BaseError type\n   * @summary Processes errors that occur during HTTP operations and converts them to\n   * the appropriate BaseError type. Currently returns the error as-is, but can be\n   * extended to handle specific error messages differently.\n   * @param {Error} err - The error to parse\n   * @return {BaseError} The parsed error as a BaseError\n   */\n  parseError(err: Error): BaseError {\n    const { message } = err;\n    switch (message) {\n      default:\n        return err as BaseError;\n    }\n  }\n\n  /**\n   * @description Initializes the HTTP adapter\n   * @summary Placeholder method for adapter initialization. This method is currently\n   * a no-op but can be overridden by subclasses to perform initialization tasks.\n   * @param {...any[]} args - Initialization arguments\n   * @return {Promise<void>} A promise that resolves when initialization is complete\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async initialize(...args: any[]): Promise<void> {\n    // do nothing\n  }\n\n  /**\n   * @description Sends an HTTP request\n   * @summary Abstract method that must be implemented by subclasses to send HTTP requests\n   * using the native HTTP client. This is the core method for making API calls.\n   * @template V - The response value type\n   * @param {Q} details - The request details specific to the HTTP client\n   * @return {Promise<V>} A promise that resolves with the response data\n   */\n  abstract request<V>(details: Q): Promise<V>;\n\n  /**\n   * @description Creates a new resource\n   * @summary Abstract method that must be implemented by subclasses to create a new resource\n   * via HTTP. This typically corresponds to a POST request.\n   * @param {string} tableName - The name of the table or endpoint\n   * @param {string|number} id - The identifier for the resource\n   * @param {Record<string, any>} model - The data model to create\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<Record<string, any>>} A promise that resolves with the created resource\n   */\n  abstract override create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  /**\n   * @description Retrieves a resource by ID\n   * @summary Abstract method that must be implemented by subclasses to retrieve a resource\n   * via HTTP. This typically corresponds to a GET request.\n   * @param {string} tableName - The name of the table or endpoint\n   * @param {string|number|bigint} id - The identifier for the resource\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<Record<string, any>>} A promise that resolves with the retrieved resource\n   */\n  abstract override read(\n    tableName: string,\n    id: string | number | bigint,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  /**\n   * @description Updates an existing resource\n   * @summary Abstract method that must be implemented by subclasses to update a resource\n   * via HTTP. This typically corresponds to a PUT or PATCH request.\n   * @param {string} tableName - The name of the table or endpoint\n   * @param {string|number} id - The identifier for the resource\n   * @param {Record<string, any>} model - The updated data model\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<Record<string, any>>} A promise that resolves with the updated resource\n   */\n  abstract override update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  /**\n   * @description Deletes a resource by ID\n   * @summary Abstract method that must be implemented by subclasses to delete a resource\n   * via HTTP. This typically corresponds to a DELETE request.\n   * @param {string} tableName - The name of the table or endpoint\n   * @param {string|number|bigint} id - The identifier for the resource to delete\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<Record<string, any>>} A promise that resolves with the deletion result\n   */\n  abstract override delete(\n    tableName: string,\n    id: string | number | bigint,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  /**\n   * @description Executes a raw query\n   * @summary Method for executing raw queries directly with the HTTP client.\n   * This method is not supported by default in HTTP adapters and throws an UnsupportedError.\n   * Subclasses can override this method to provide implementation.\n   * @template R - The result type\n   * @param {Q} rawInput - The raw query input\n   * @param {boolean} process - Whether to process the result\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<R>} A promise that resolves with the query result\n   * @throws {UnsupportedError} Always throws as this method is not supported by default\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  raw<R>(rawInput: Q, process: boolean, ...args: any[]): Promise<R> {\n    throw new UnsupportedError(\n      \"Api is not natively available for HttpAdapters. If required, please extends this class\"\n    );\n  }\n\n  /**\n   * @description Creates a sequence\n   * @summary Method for creating a sequence for generating unique identifiers.\n   * This method is not supported by default in HTTP adapters and throws an UnsupportedError.\n   * Subclasses can override this method to provide implementation.\n   * @param {SequenceOptions} options - Options for creating the sequence\n   * @return {Promise<Sequence>} A promise that resolves with the created sequence\n   * @throws {UnsupportedError} Always throws as this method is not supported by default\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  Sequence(options: SequenceOptions): Promise<Sequence> {\n    throw new UnsupportedError(\n      \"Api is not natively available for HttpAdapters. If required, please extends this class\"\n    );\n  }\n\n  /**\n   * @description Creates a statement for querying\n   * @summary Method for creating a statement for building and executing queries.\n   * This method is not supported by default in HTTP adapters and throws an UnsupportedError.\n   * Subclasses can override this method to provide implementation.\n   * @template M - The model type\n   * @template ! - The raw query type\n   * @return {Statement<Q, M, any>} A statement object for building queries\n   * @throws {UnsupportedError} Always throws as this method is not supported by default\n   */\n  override Statement<M extends Model>(): Statement<Q, M, any> {\n    throw new UnsupportedError(\n      \"Api is not natively available for HttpAdapters. If required, please extends this class\"\n    );\n  }\n\n  /**\n   * @description Parses a condition into a query\n   * @summary Method for parsing a condition object into a query format understood by the HTTP client.\n   * This method is not supported by default in HTTP adapters and throws an UnsupportedError.\n   * Subclasses can override this method to provide implementation.\n   * @param {Condition<any>} condition - The condition to parse\n   * @return {Q} The parsed query\n   * @throws {UnsupportedError} Always throws as this method is not supported by default\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  parseCondition(condition: Condition<any>): Q {\n    throw new UnsupportedError(\n      \"Api is not natively available for HttpAdapters. If required, please extends this class\"\n    );\n  }\n}\n"]}

package/lib/esm/axios/axios.d.ts

@@ -3,12 +3,106 @@ import { Axios, AxiosRequestConfig } from "axios";
 import { HttpConfig } from "../types";
 import { AxiosFlags } from "./types";
 import { Context } from "@decaf-ts/db-decorators";
+/**
+ * @description Axios implementation of the HTTP adapter
+ * @summary Concrete implementation of HttpAdapter using Axios as the HTTP client.
+ * This adapter provides CRUD operations for RESTful APIs using Axios for HTTP requests.
+ * @template Axios - The Axios client type
+ * @template AxiosRequestConfig - The Axios request configuration type
+ * @template AxiosFlags - The flags type extending HttpFlags
+ * @template Context<AxiosFlags> - The context type for this adapter
+ * @param {Axios} native - The Axios instance
+ * @param {HttpConfig} config - Configuration for the HTTP adapter
+ * @param {string} [alias] - Optional alias for the adapter
+ * @class
+ * @example
+ * ```typescript
+ * import axios from 'axios';
+ * import { AxiosHttpAdapter } from '@decaf-ts/for-http';
+ *
+ * const config = { protocol: 'https', host: 'api.example.com' };
+ * const adapter = new AxiosHttpAdapter(axios.create(), config);
+ *
+ * // Use the adapter with a repository
+ * const userRepo = adapter.getRepository(User);
+ * const user = await userRepo.findById('123');
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant AxiosHttpAdapter
+ *   participant Axios
+ *   participant API
+ *
+ *   Client->>AxiosHttpAdapter: create(table, id, data)
+ *   AxiosHttpAdapter->>AxiosHttpAdapter: url(table)
+ *   AxiosHttpAdapter->>Axios: post(url, data)
+ *   Axios->>API: HTTP POST Request
+ *   API-->>Axios: Response
+ *   Axios-->>AxiosHttpAdapter: Response Data
+ *   AxiosHttpAdapter-->>Client: Created Resource
+ *
+ *   Client->>AxiosHttpAdapter: read(table, id)
+ *   AxiosHttpAdapter->>AxiosHttpAdapter: url(table, {id})
+ *   AxiosHttpAdapter->>Axios: get(url)
+ *   Axios->>API: HTTP GET Request
+ *   API-->>Axios: Response
+ *   Axios-->>AxiosHttpAdapter: Response Data
+ *   AxiosHttpAdapter-->>Client: Resource Data
+ */
 export declare class AxiosHttpAdapter extends HttpAdapter<Axios, AxiosRequestConfig, AxiosFlags, Context<AxiosFlags>> {
     constructor(native: Axios, config: HttpConfig, alias?: string);
+    /**
+     * @description Sends an HTTP request using Axios
+     * @summary Implementation of the abstract request method from HttpAdapter.
+     * This method uses the Axios instance to send HTTP requests with the provided configuration.
+     * @template V - The response value type
+     * @param {AxiosRequestConfig} details - The Axios request configuration
+     * @return {Promise<V>} A promise that resolves with the response data
+     */
     request<V>(details: AxiosRequestConfig): Promise<V>;
+    /**
+     * @description Creates a new resource via HTTP POST
+     * @summary Implementation of the abstract create method from HttpAdapter.
+     * This method sends a POST request to the specified endpoint with the model data.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {string|number} id - The identifier for the resource (not used in URL for POST)
+     * @param {Record<string, any>} model - The data model to create
+     * @return {Promise<Record<string, any>>} A promise that resolves with the created resource
+     */
     create(tableName: string, id: string | number, model: Record<string, any>): Promise<Record<string, any>>;
+    /**
+     * @description Retrieves a resource by ID via HTTP GET
+     * @summary Implementation of the abstract read method from HttpAdapter.
+     * This method sends a GET request to the specified endpoint with the ID as a query parameter.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {string|number|bigint} id - The identifier for the resource to retrieve
+     * @return {Promise<Record<string, any>>} A promise that resolves with the retrieved resource
+     */
     read(tableName: string, id: string | number | bigint): Promise<Record<string, any>>;
+    /**
+     * @description Updates an existing resource via HTTP PUT
+     * @summary Implementation of the abstract update method from HttpAdapter.
+     * This method sends a PUT request to the specified endpoint with the updated model data.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {string|number} id - The identifier for the resource (not used in URL for PUT)
+     * @param {Record<string, any>} model - The updated data model
+     * @return {Promise<Record<string, any>>} A promise that resolves with the updated resource
+     */
     update(tableName: string, id: string | number, model: Record<string, any>): Promise<Record<string, any>>;
+    /**
+     * @description Deletes a resource by ID via HTTP DELETE
+     * @summary Implementation of the abstract delete method from HttpAdapter.
+     * This method sends a DELETE request to the specified endpoint with the ID as a query parameter.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {string|number|bigint} id - The identifier for the resource to delete
+     * @return {Promise<Record<string, any>>} A promise that resolves with the deletion result
+     */
     delete(tableName: string, id: string | number | bigint): Promise<Record<string, any>>;
+    /**
+     * @description Static decoration method for the AxiosHttpAdapter class
+     * @summary Placeholder method for class decoration functionality.
+     * This method is currently empty but can be used for decorator-based configuration.
+     */
     static decoration(): void;
 }

package/lib/esm/axios/axios.js

@@ -1,12 +1,76 @@
-import { HttpAdapter } from "../adapter";
-import { AxiosFlavour } from "./constants";
+import { HttpAdapter } from "./../adapter.js";
+import { AxiosFlavour } from "./constants.js";
+/**
+ * @description Axios implementation of the HTTP adapter
+ * @summary Concrete implementation of HttpAdapter using Axios as the HTTP client.
+ * This adapter provides CRUD operations for RESTful APIs using Axios for HTTP requests.
+ * @template Axios - The Axios client type
+ * @template AxiosRequestConfig - The Axios request configuration type
+ * @template AxiosFlags - The flags type extending HttpFlags
+ * @template Context<AxiosFlags> - The context type for this adapter
+ * @param {Axios} native - The Axios instance
+ * @param {HttpConfig} config - Configuration for the HTTP adapter
+ * @param {string} [alias] - Optional alias for the adapter
+ * @class
+ * @example
+ * ```typescript
+ * import axios from 'axios';
+ * import { AxiosHttpAdapter } from '@decaf-ts/for-http';
+ *
+ * const config = { protocol: 'https', host: 'api.example.com' };
+ * const adapter = new AxiosHttpAdapter(axios.create(), config);
+ *
+ * // Use the adapter with a repository
+ * const userRepo = adapter.getRepository(User);
+ * const user = await userRepo.findById('123');
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant AxiosHttpAdapter
+ *   participant Axios
+ *   participant API
+ *
+ *   Client->>AxiosHttpAdapter: create(table, id, data)
+ *   AxiosHttpAdapter->>AxiosHttpAdapter: url(table)
+ *   AxiosHttpAdapter->>Axios: post(url, data)
+ *   Axios->>API: HTTP POST Request
+ *   API-->>Axios: Response
+ *   Axios-->>AxiosHttpAdapter: Response Data
+ *   AxiosHttpAdapter-->>Client: Created Resource
+ *
+ *   Client->>AxiosHttpAdapter: read(table, id)
+ *   AxiosHttpAdapter->>AxiosHttpAdapter: url(table, {id})
+ *   AxiosHttpAdapter->>Axios: get(url)
+ *   Axios->>API: HTTP GET Request
+ *   API-->>Axios: Response
+ *   Axios-->>AxiosHttpAdapter: Response Data
+ *   AxiosHttpAdapter-->>Client: Resource Data
+ */
 export class AxiosHttpAdapter extends HttpAdapter {
     constructor(native, config, alias) {
         super(native, config, AxiosFlavour, alias);
     }
+    /**
+     * @description Sends an HTTP request using Axios
+     * @summary Implementation of the abstract request method from HttpAdapter.
+     * This method uses the Axios instance to send HTTP requests with the provided configuration.
+     * @template V - The response value type
+     * @param {AxiosRequestConfig} details - The Axios request configuration
+     * @return {Promise<V>} A promise that resolves with the response data
+     */
     async request(details) {
         return this.native.request(details);
     }
+    /**
+     * @description Creates a new resource via HTTP POST
+     * @summary Implementation of the abstract create method from HttpAdapter.
+     * This method sends a POST request to the specified endpoint with the model data.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {string|number} id - The identifier for the resource (not used in URL for POST)
+     * @param {Record<string, any>} model - The data model to create
+     * @return {Promise<Record<string, any>>} A promise that resolves with the created resource
+     */
     async create(tableName, id, model) {
         try {
             const url = this.url(tableName);
@@ -16,6 +80,14 @@ export class AxiosHttpAdapter extends HttpAdapter {
             throw this.parseError(e);
         }
     }
+    /**
+     * @description Retrieves a resource by ID via HTTP GET
+     * @summary Implementation of the abstract read method from HttpAdapter.
+     * This method sends a GET request to the specified endpoint with the ID as a query parameter.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {string|number|bigint} id - The identifier for the resource to retrieve
+     * @return {Promise<Record<string, any>>} A promise that resolves with the retrieved resource
+     */
     async read(tableName, id) {
         try {
             const url = this.url(tableName, { id: id });
@@ -25,6 +97,15 @@ export class AxiosHttpAdapter extends HttpAdapter {
             throw this.parseError(e);
         }
     }
+    /**
+     * @description Updates an existing resource via HTTP PUT
+     * @summary Implementation of the abstract update method from HttpAdapter.
+     * This method sends a PUT request to the specified endpoint with the updated model data.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {string|number} id - The identifier for the resource (not used in URL for PUT)
+     * @param {Record<string, any>} model - The updated data model
+     * @return {Promise<Record<string, any>>} A promise that resolves with the updated resource
+     */
     async update(tableName, id, model) {
         try {
             const url = this.url(tableName);
@@ -34,6 +115,14 @@ export class AxiosHttpAdapter extends HttpAdapter {
             throw this.parseError(e);
         }
     }
+    /**
+     * @description Deletes a resource by ID via HTTP DELETE
+     * @summary Implementation of the abstract delete method from HttpAdapter.
+     * This method sends a DELETE request to the specified endpoint with the ID as a query parameter.
+     * @param {string} tableName - The name of the table or endpoint
+     * @param {string|number|bigint} id - The identifier for the resource to delete
+     * @return {Promise<Record<string, any>>} A promise that resolves with the deletion result
+     */
     async delete(tableName, id) {
         try {
             const url = this.url(tableName, { id: id });
@@ -43,6 +132,11 @@ export class AxiosHttpAdapter extends HttpAdapter {
             throw this.parseError(e);
         }
     }
+    /**
+     * @description Static decoration method for the AxiosHttpAdapter class
+     * @summary Placeholder method for class decoration functionality.
+     * This method is currently empty but can be used for decorator-based configuration.
+     */
     static decoration() { }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"axios.js","sourceRoot":"","sources":["../../../src/axios/axios.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,wBAAmB;AAKzC,OAAO,EAAE,YAAY,EAAE,uBAAoB;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,OAAO,gBAAiB,SAAQ,WAKrC;IACC,YAAY,MAAa,EAAE,MAAkB,EAAE,KAAc;QAC3D,KAAK,CAAC,MAAa,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;OAOG;IACM,KAAK,CAAC,OAAO,CAAI,OAA2B;QACnD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACtC,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,MAAM,CACV,SAAiB,EACjB,EAAmB,EACnB,KAA0B;QAE1B,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAChC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACtC,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,MAAM,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IACD;;;;;;;OAOG;IACH,KAAK,CAAC,IAAI,CACR,SAAiB,EACjB,EAA4B;QAE5B,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,EAAE,EAAE,EAAqB,EAAE,CAAC,CAAC;YAC/D,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC9B,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,MAAM,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,MAAM,CACV,SAAiB,EACjB,EAAmB,EACnB,KAA0B;QAE1B,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAChC,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACrC,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,MAAM,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,MAAM,CACV,SAAiB,EACjB,EAA4B;QAE5B,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,EAAE,EAAE,EAAqB,EAAE,CAAC,CAAC;YAC/D,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACjC,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,MAAM,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,KAAI,CAAC;CACvB","sourcesContent":["import { HttpAdapter } from \"../adapter\";\nimport { Axios, AxiosRequestConfig } from \"axios\";\nimport { HttpConfig } from \"../types\";\nimport { AxiosFlags } from \"./types\";\nimport { Context } from \"@decaf-ts/db-decorators\";\nimport { AxiosFlavour } from \"./constants\";\n\n/**\n * @description Axios implementation of the HTTP adapter\n * @summary Concrete implementation of HttpAdapter using Axios as the HTTP client.\n * This adapter provides CRUD operations for RESTful APIs using Axios for HTTP requests.\n * @template Axios - The Axios client type\n * @template AxiosRequestConfig - The Axios request configuration type\n * @template AxiosFlags - The flags type extending HttpFlags\n * @template Context<AxiosFlags> - The context type for this adapter\n * @param {Axios} native - The Axios instance\n * @param {HttpConfig} config - Configuration for the HTTP adapter\n * @param {string} [alias] - Optional alias for the adapter\n * @class\n * @example\n * ```typescript\n * import axios from 'axios';\n * import { AxiosHttpAdapter } from '@decaf-ts/for-http';\n * \n * const config = { protocol: 'https', host: 'api.example.com' };\n * const adapter = new AxiosHttpAdapter(axios.create(), config);\n * \n * // Use the adapter with a repository\n * const userRepo = adapter.getRepository(User);\n * const user = await userRepo.findById('123');\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant AxiosHttpAdapter\n *   participant Axios\n *   participant API\n *   \n *   Client->>AxiosHttpAdapter: create(table, id, data)\n *   AxiosHttpAdapter->>AxiosHttpAdapter: url(table)\n *   AxiosHttpAdapter->>Axios: post(url, data)\n *   Axios->>API: HTTP POST Request\n *   API-->>Axios: Response\n *   Axios-->>AxiosHttpAdapter: Response Data\n *   AxiosHttpAdapter-->>Client: Created Resource\n *   \n *   Client->>AxiosHttpAdapter: read(table, id)\n *   AxiosHttpAdapter->>AxiosHttpAdapter: url(table, {id})\n *   AxiosHttpAdapter->>Axios: get(url)\n *   Axios->>API: HTTP GET Request\n *   API-->>Axios: Response\n *   Axios-->>AxiosHttpAdapter: Response Data\n *   AxiosHttpAdapter-->>Client: Resource Data\n */\nexport class AxiosHttpAdapter extends HttpAdapter<\n  Axios,\n  AxiosRequestConfig,\n  AxiosFlags,\n  Context<AxiosFlags>\n> {\n  constructor(native: Axios, config: HttpConfig, alias?: string) {\n    super(native as any, config, AxiosFlavour, alias);\n  }\n\n  /**\n   * @description Sends an HTTP request using Axios\n   * @summary Implementation of the abstract request method from HttpAdapter.\n   * This method uses the Axios instance to send HTTP requests with the provided configuration.\n   * @template V - The response value type\n   * @param {AxiosRequestConfig} details - The Axios request configuration\n   * @return {Promise<V>} A promise that resolves with the response data\n   */\n  override async request<V>(details: AxiosRequestConfig): Promise<V> {\n    return this.native.request(details);\n  }\n\n  /**\n   * @description Creates a new resource via HTTP POST\n   * @summary Implementation of the abstract create method from HttpAdapter.\n   * This method sends a POST request to the specified endpoint with the model data.\n   * @param {string} tableName - The name of the table or endpoint\n   * @param {string|number} id - The identifier for the resource (not used in URL for POST)\n   * @param {Record<string, any>} model - The data model to create\n   * @return {Promise<Record<string, any>>} A promise that resolves with the created resource\n   */\n  async create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ): Promise<Record<string, any>> {\n    try {\n      const url = this.url(tableName);\n      return this.native.post(url, model);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n  }\n  /**\n   * @description Retrieves a resource by ID via HTTP GET\n   * @summary Implementation of the abstract read method from HttpAdapter.\n   * This method sends a GET request to the specified endpoint with the ID as a query parameter.\n   * @param {string} tableName - The name of the table or endpoint\n   * @param {string|number|bigint} id - The identifier for the resource to retrieve\n   * @return {Promise<Record<string, any>>} A promise that resolves with the retrieved resource\n   */\n  async read(\n    tableName: string,\n    id: string | number | bigint\n  ): Promise<Record<string, any>> {\n    try {\n      const url = this.url(tableName, { id: id as string | number });\n      return this.native.get(url);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n  }\n\n  /**\n   * @description Updates an existing resource via HTTP PUT\n   * @summary Implementation of the abstract update method from HttpAdapter.\n   * This method sends a PUT request to the specified endpoint with the updated model data.\n   * @param {string} tableName - The name of the table or endpoint\n   * @param {string|number} id - The identifier for the resource (not used in URL for PUT)\n   * @param {Record<string, any>} model - The updated data model\n   * @return {Promise<Record<string, any>>} A promise that resolves with the updated resource\n   */\n  async update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ): Promise<Record<string, any>> {\n    try {\n      const url = this.url(tableName);\n      return this.native.put(url, model);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n  }\n\n  /**\n   * @description Deletes a resource by ID via HTTP DELETE\n   * @summary Implementation of the abstract delete method from HttpAdapter.\n   * This method sends a DELETE request to the specified endpoint with the ID as a query parameter.\n   * @param {string} tableName - The name of the table or endpoint\n   * @param {string|number|bigint} id - The identifier for the resource to delete\n   * @return {Promise<Record<string, any>>} A promise that resolves with the deletion result\n   */\n  async delete(\n    tableName: string,\n    id: string | number | bigint\n  ): Promise<Record<string, any>> {\n    try {\n      const url = this.url(tableName, { id: id as string | number });\n      return this.native.delete(url);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n  }\n\n  /**\n   * @description Static decoration method for the AxiosHttpAdapter class\n   * @summary Placeholder method for class decoration functionality.\n   * This method is currently empty but can be used for decorator-based configuration.\n   */\n  static decoration() {}\n}\n"]}

package/lib/esm/axios/constants.d.ts

@@ -1 +1,7 @@
+/**
+ * @description Axios adapter flavor identifier
+ * @summary Constant string identifier used to identify the Axios implementation of the HTTP adapter
+ * @const {string} AxiosFlavour
+ * @memberOf module:for-http.axios
+ */
 export declare const AxiosFlavour = "axios";

package/lib/esm/axios/constants.js

@@ -1,2 +1,8 @@
+/**
+ * @description Axios adapter flavor identifier
+ * @summary Constant string identifier used to identify the Axios implementation of the HTTP adapter
+ * @const {string} AxiosFlavour
+ * @memberOf module:for-http.axios
+ */
 export const AxiosFlavour = "axios";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F4aW9zL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsT0FBTyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IEF4aW9zRmxhdm91ciA9IFwiYXhpb3NcIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F4aW9zL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkZXNjcmlwdGlvbiBBeGlvcyBhZGFwdGVyIGZsYXZvciBpZGVudGlmaWVyXG4gKiBAc3VtbWFyeSBDb25zdGFudCBzdHJpbmcgaWRlbnRpZmllciB1c2VkIHRvIGlkZW50aWZ5IHRoZSBBeGlvcyBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgSFRUUCBhZGFwdGVyXG4gKiBAY29uc3Qge3N0cmluZ30gQXhpb3NGbGF2b3VyXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmZvci1odHRwLmF4aW9zXG4gKi9cbmV4cG9ydCBjb25zdCBBeGlvc0ZsYXZvdXIgPSBcImF4aW9zXCI7XG4iXX0=

package/lib/esm/axios/index.js

@@ -1,6 +1,15 @@
-import { AxiosHttpAdapter } from "./axios";
+import { AxiosHttpAdapter } from "./axios.js";
+/**
+ * @description HTTP client module for REST API interactions
+ * @summary This module provides classes and utilities for interacting with REST APIs.
+ * It exposes repository and service classes for making HTTP requests, along with
+ * type definitions and adapters for different HTTP clients. The module includes
+ * {@link RestRepository} and {@link RestService} for API interactions.
+ * @namespace axios
+ * @memberOf module:for-http
+ */
 AxiosHttpAdapter.decoration();
-export * from "./axios";
-export * from "./constants";
-export * from "./types";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXhpb3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sU0FBUyxDQUFDO0FBRTNDLGdCQUFnQixDQUFDLFVBQVUsRUFBRSxDQUFDO0FBRTlCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXhpb3NIdHRwQWRhcHRlciB9IGZyb20gXCIuL2F4aW9zXCI7XG5cbkF4aW9zSHR0cEFkYXB0ZXIuZGVjb3JhdGlvbigpO1xuXG5leHBvcnQgKiBmcm9tIFwiLi9heGlvc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuIl19
+export * from "./axios.js";
+export * from "./constants.js";
+export * from "./types.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXhpb3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLG1CQUFnQjtBQUUzQzs7Ozs7Ozs7R0FRRztBQUVILGdCQUFnQixDQUFDLFVBQVUsRUFBRSxDQUFDO0FBRTlCLDJCQUF3QjtBQUN4QiwrQkFBNEI7QUFDNUIsMkJBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXhpb3NIdHRwQWRhcHRlciB9IGZyb20gXCIuL2F4aW9zXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEhUVFAgY2xpZW50IG1vZHVsZSBmb3IgUkVTVCBBUEkgaW50ZXJhY3Rpb25zXG4gKiBAc3VtbWFyeSBUaGlzIG1vZHVsZSBwcm92aWRlcyBjbGFzc2VzIGFuZCB1dGlsaXRpZXMgZm9yIGludGVyYWN0aW5nIHdpdGggUkVTVCBBUElzLlxuICogSXQgZXhwb3NlcyByZXBvc2l0b3J5IGFuZCBzZXJ2aWNlIGNsYXNzZXMgZm9yIG1ha2luZyBIVFRQIHJlcXVlc3RzLCBhbG9uZyB3aXRoXG4gKiB0eXBlIGRlZmluaXRpb25zIGFuZCBhZGFwdGVycyBmb3IgZGlmZmVyZW50IEhUVFAgY2xpZW50cy4gVGhlIG1vZHVsZSBpbmNsdWRlc1xuICoge0BsaW5rIFJlc3RSZXBvc2l0b3J5fSBhbmQge0BsaW5rIFJlc3RTZXJ2aWNlfSBmb3IgQVBJIGludGVyYWN0aW9ucy5cbiAqIEBuYW1lc3BhY2UgYXhpb3NcbiAqIEBtZW1iZXJPZiBtb2R1bGU6Zm9yLWh0dHBcbiAqL1xuXG5BeGlvc0h0dHBBZGFwdGVyLmRlY29yYXRpb24oKTtcblxuZXhwb3J0ICogZnJvbSBcIi4vYXhpb3NcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbiJdfQ==

package/lib/esm/axios/types.d.ts

@@ -1,2 +1,8 @@
 import { HttpFlags } from "../types";
+/**
+ * @description Axios-specific HTTP flags type
+ * @summary Type alias for HttpFlags used specifically with the Axios adapter implementation
+ * @typedef {HttpFlags} AxiosFlags
+ * @memberOf module:for-http.axios
+ */
 export type AxiosFlags = HttpFlags;

package/lib/esm/axios/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXhpb3MvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEh0dHBGbGFncyB9IGZyb20gXCIuLi90eXBlc1wiO1xuXG5leHBvcnQgdHlwZSBBeGlvc0ZsYWdzID0gSHR0cEZsYWdzO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXhpb3MvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEh0dHBGbGFncyB9IGZyb20gXCIuLi90eXBlc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBBeGlvcy1zcGVjaWZpYyBIVFRQIGZsYWdzIHR5cGVcbiAqIEBzdW1tYXJ5IFR5cGUgYWxpYXMgZm9yIEh0dHBGbGFncyB1c2VkIHNwZWNpZmljYWxseSB3aXRoIHRoZSBBeGlvcyBhZGFwdGVyIGltcGxlbWVudGF0aW9uXG4gKiBAdHlwZWRlZiB7SHR0cEZsYWdzfSBBeGlvc0ZsYWdzXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmZvci1odHRwLmF4aW9zXG4gKi9cbmV4cG9ydCB0eXBlIEF4aW9zRmxhZ3MgPSBIdHRwRmxhZ3M7XG4iXX0=

package/lib/esm/index.d.ts

@@ -1,5 +1,18 @@
+/**
+ * @description HTTP client module for REST API interactions
+ * @summary This module provides classes and utilities for interacting with REST APIs.
+ * It exposes repository and service classes for making HTTP requests, along with
+ * type definitions and adapters for different HTTP clients. The module includes
+ * {@link RestRepository} and {@link RestService} for API interactions.
+ * @module for-http
+ */
 export * from "./adapter";
 export * from "./RestRepository";
 export * from "./RestService";
 export * from "./types";
-export declare const VERSION = "0.2.1";
+/**
+ * @description Current version of the for-http module
+ * @summary Version identifier for the module
+ * @const VERSION
+ */
+export declare const VERSION = "0.2.3";

package/lib/esm/index.js

@@ -1,6 +1,19 @@
-export * from "./adapter";
-export * from "./RestRepository";
-export * from "./RestService";
-export * from "./types";
-export const VERSION = "0.2.1";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFNBQVMsQ0FBQztBQUV4QixNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYWRhcHRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vUmVzdFJlcG9zaXRvcnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1Jlc3RTZXJ2aWNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcbiJdfQ==
+/**
+ * @description HTTP client module for REST API interactions
+ * @summary This module provides classes and utilities for interacting with REST APIs.
+ * It exposes repository and service classes for making HTTP requests, along with
+ * type definitions and adapters for different HTTP clients. The module includes
+ * {@link RestRepository} and {@link RestService} for API interactions.
+ * @module for-http
+ */
+export * from "./adapter.js";
+export * from "./RestRepository.js";
+export * from "./RestService.js";
+export * from "./types.js";
+/**
+ * @description Current version of the for-http module
+ * @summary Version identifier for the module
+ * @const VERSION
+ */
+export const VERSION = "0.2.3";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUNILDZCQUEwQjtBQUMxQixvQ0FBaUM7QUFDakMsaUNBQThCO0FBQzlCLDJCQUF3QjtBQUV4Qjs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRlc2NyaXB0aW9uIEhUVFAgY2xpZW50IG1vZHVsZSBmb3IgUkVTVCBBUEkgaW50ZXJhY3Rpb25zXG4gKiBAc3VtbWFyeSBUaGlzIG1vZHVsZSBwcm92aWRlcyBjbGFzc2VzIGFuZCB1dGlsaXRpZXMgZm9yIGludGVyYWN0aW5nIHdpdGggUkVTVCBBUElzLlxuICogSXQgZXhwb3NlcyByZXBvc2l0b3J5IGFuZCBzZXJ2aWNlIGNsYXNzZXMgZm9yIG1ha2luZyBIVFRQIHJlcXVlc3RzLCBhbG9uZyB3aXRoXG4gKiB0eXBlIGRlZmluaXRpb25zIGFuZCBhZGFwdGVycyBmb3IgZGlmZmVyZW50IEhUVFAgY2xpZW50cy4gVGhlIG1vZHVsZSBpbmNsdWRlc1xuICoge0BsaW5rIFJlc3RSZXBvc2l0b3J5fSBhbmQge0BsaW5rIFJlc3RTZXJ2aWNlfSBmb3IgQVBJIGludGVyYWN0aW9ucy5cbiAqIEBtb2R1bGUgZm9yLWh0dHBcbiAqL1xuZXhwb3J0ICogZnJvbSBcIi4vYWRhcHRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vUmVzdFJlcG9zaXRvcnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1Jlc3RTZXJ2aWNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDdXJyZW50IHZlcnNpb24gb2YgdGhlIGZvci1odHRwIG1vZHVsZVxuICogQHN1bW1hcnkgVmVyc2lvbiBpZGVudGlmaWVyIGZvciB0aGUgbW9kdWxlXG4gKiBAY29uc3QgVkVSU0lPTlxuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcbiJdfQ==

package/lib/esm/types.d.ts

@@ -1,8 +1,23 @@
 import { RepositoryFlags } from "@decaf-ts/db-decorators";
+/**
+ * @description HTTP configuration type
+ * @summary Configuration type for HTTP connections specifying protocol and host
+ * @typedef {Object} HttpConfig
+ * @property {('http'|'https')} protocol - The HTTP protocol to use
+ * @property {string} host - The host address
+ * @memberOf module:for-http
+ */
 export type HttpConfig = {
     protocol: "http" | "https";
     host: string;
 };
+/**
+ * @description HTTP flags interface
+ * @summary Interface extending RepositoryFlags with HTTP-specific options
+ * @interface HttpFlags
+ * @property {Record<string, string>} [headers] - Optional HTTP headers to include with requests
+ * @memberOf module:for-http
+ */
 export interface HttpFlags extends RepositoryFlags {
     headers?: Record<string, string>;
 }

package/lib/esm/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJlcG9zaXRvcnlGbGFncyB9IGZyb20gXCJAZGVjYWYtdHMvZGItZGVjb3JhdG9yc1wiO1xuXG5leHBvcnQgdHlwZSBIdHRwQ29uZmlnID0ge1xuICBwcm90b2NvbDogXCJodHRwXCIgfCBcImh0dHBzXCI7XG4gIGhvc3Q6IHN0cmluZztcbn07XG5cbmV4cG9ydCBpbnRlcmZhY2UgSHR0cEZsYWdzIGV4dGVuZHMgUmVwb3NpdG9yeUZsYWdzIHtcbiAgaGVhZGVycz86IFJlY29yZDxzdHJpbmcsIHN0cmluZz47XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJlcG9zaXRvcnlGbGFncyB9IGZyb20gXCJAZGVjYWYtdHMvZGItZGVjb3JhdG9yc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBIVFRQIGNvbmZpZ3VyYXRpb24gdHlwZVxuICogQHN1bW1hcnkgQ29uZmlndXJhdGlvbiB0eXBlIGZvciBIVFRQIGNvbm5lY3Rpb25zIHNwZWNpZnlpbmcgcHJvdG9jb2wgYW5kIGhvc3RcbiAqIEB0eXBlZGVmIHtPYmplY3R9IEh0dHBDb25maWdcbiAqIEBwcm9wZXJ0eSB7KCdodHRwJ3wnaHR0cHMnKX0gcHJvdG9jb2wgLSBUaGUgSFRUUCBwcm90b2NvbCB0byB1c2VcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBob3N0IC0gVGhlIGhvc3QgYWRkcmVzc1xuICogQG1lbWJlck9mIG1vZHVsZTpmb3ItaHR0cFxuICovXG5leHBvcnQgdHlwZSBIdHRwQ29uZmlnID0ge1xuICBwcm90b2NvbDogXCJodHRwXCIgfCBcImh0dHBzXCI7XG4gIGhvc3Q6IHN0cmluZztcbn07XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEhUVFAgZmxhZ3MgaW50ZXJmYWNlXG4gKiBAc3VtbWFyeSBJbnRlcmZhY2UgZXh0ZW5kaW5nIFJlcG9zaXRvcnlGbGFncyB3aXRoIEhUVFAtc3BlY2lmaWMgb3B0aW9uc1xuICogQGludGVyZmFjZSBIdHRwRmxhZ3NcbiAqIEBwcm9wZXJ0eSB7UmVjb3JkPHN0cmluZywgc3RyaW5nPn0gW2hlYWRlcnNdIC0gT3B0aW9uYWwgSFRUUCBoZWFkZXJzIHRvIGluY2x1ZGUgd2l0aCByZXF1ZXN0c1xuICogQG1lbWJlck9mIG1vZHVsZTpmb3ItaHR0cFxuICovXG5leHBvcnQgaW50ZXJmYWNlIEh0dHBGbGFncyBleHRlbmRzIFJlcG9zaXRvcnlGbGFncyB7XG4gIGhlYWRlcnM/OiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+O1xufVxuIl19