opticore-cache 1.0.0 → 1.0.3

package/dist/index.cjs

@@ -30,7 +30,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  default: () => index_default
+  CacheFactoryRepository: () => CacheFactoryRepository,
+  CacheMiddleware: () => CacheMiddleware,
+  CacheService: () => CacheService,
+  EnvironmentLoader: () => EnvironmentLoader,
+  HttpCacheFactory: () => HttpCacheFactory,
+  RouteValidator: () => RouteValidator,
+  SCacheMiddleware: () => SCacheMiddleware
 });
 module.exports = __toCommonJS(index_exports);
 var import_dotenv = __toESM(require("dotenv"), 1);
@@ -431,6 +437,7 @@ var MemoryCache = class {
 var import_fs = __toESM(require("fs"), 1);
 var import_path = __toESM(require("path"), 1);
 var import_util = require("util");
+var import_opticore_logger = require("opticore-logger");
 var fsExists = (0, import_util.promisify)(import_fs.default.exists);
 var fsMkdir = (0, import_util.promisify)(import_fs.default.mkdir);
 var fsReadFile = (0, import_util.promisify)(import_fs.default.readFile);
@@ -476,7 +483,7 @@ var DiskCache = class {
    * @private
    */
   getCacheDirectory() {
-    return process.env.CACHE_DISK_DIR || import_path.default.join(process.cwd(), "storage", "cache", this.config.namespace);
+    return process.env.CACHE_DISK_DIR || import_path.default.join(process.cwd(), "src", "core", "cache", this.config.namespace);
   }
   /**
    * Initialise le répertoire de cache
@@ -853,8 +860,8 @@ NE PAS SUPPRIMER MANUELLEMENT ces fichiers pendant l'ex\xE9cution du serveur.
     if (this.cleanupInterval) {
       clearInterval(this.cleanupInterval);
     }
-    this.cleanupInterval = setInterval(() => {
-      this.cleanupExpiredEntries();
+    this.cleanupInterval = setInterval(async () => {
+      await this.cleanupExpiredEntries();
     }, this.config.cleanupInterval);
     if (this.config.debug) {
       console.log(`[DiskCache] Cycle de nettoyage: ${this.config.cleanupInterval}ms`);
@@ -879,6 +886,9 @@ NE PAS SUPPRIMER MANUELLEMENT ces fichiers pendant l'ex\xE9cution du serveur.
       console.log(`[DiskCache] Nettoyage: ${expiredKeys.length} entr\xE9es expir\xE9es`);
     }
   }
+  logger() {
+    return new import_opticore_logger.LoggerCore();
+  }
   /**
    * Récupère le chemin du dossier de cache
    * @returns string
@@ -1240,7 +1250,7 @@ var CacheManagementUseCase = class {
 
 // src/application/services/cacheService.service.ts
 var import_opticore_loader_translation = require("opticore-loader-translation");
-var import_opticore_logger = require("opticore-logger");
+var import_opticore_logger2 = require("opticore-logger");
 var CacheService = class _CacheService {
   cacheUseCase;
   cacheRepository;
@@ -1414,7 +1424,7 @@ var CacheService = class _CacheService {
     });
   }
   logger() {
-    return new import_opticore_logger.LoggerCore(this.configLogger);
+    return new import_opticore_logger2.LoggerCore(this.configLogger);
   }
 };
 
@@ -1480,11 +1490,11 @@ var RouteValidator = class {
    * @param enableWildcards - Activer le support des wildcards
    * @returns RegExp
    */
-  compileToRegex(path2, enableWildcards) {
-    if (!enableWildcards || !path2.includes("*")) {
-      return new RegExp(`^${this.escapeRegex(path2)}$`, "i");
+  compileToRegex(path3, enableWildcards) {
+    if (!enableWildcards || !path3.includes("*")) {
+      return new RegExp(`^${this.escapeRegex(path3)}$`, "i");
     }
-    let regexString = this.escapeRegex(path2).replace(/\\\*/g, ".*");
+    let regexString = this.escapeRegex(path3).replace(/\\\*/g, ".*");
     if (regexString.endsWith("/.*")) {
       regexString = regexString.replace(/\/\.\*$/, "(\\/.*)?");
     }
@@ -1528,11 +1538,11 @@ var RouteValidator = class {
    * @param path - Chemin à normaliser
    * @returns string - Chemin normalisé
    */
-  normalizePath(path2) {
-    if (path2.length > 1 && path2.endsWith("/")) {
-      return path2.slice(0, -1);
+  normalizePath(path3) {
+    if (path3.length > 1 && path3.endsWith("/")) {
+      return path3.slice(0, -1);
     }
-    return path2;
+    return path3;
   }
   /**
    * Récupère la liste des patterns compilés (pour debug)
@@ -1676,11 +1686,11 @@ var CacheMiddleware = class {
    * @returns string
    * @private
    */
-  normalizePath(path2) {
-    if (path2.length > 1 && path2.endsWith("/")) {
-      return path2.slice(0, -1);
+  normalizePath(path3) {
+    if (path3.length > 1 && path3.endsWith("/")) {
+      return path3.slice(0, -1);
     }
-    return path2;
+    return path3;
   }
   /**
    * Adds HTTP headers related to the cache
@@ -1835,17 +1845,34 @@ var SCacheMiddleware = class {
 };
 
 // src/application/services/adaptedHttpCache.service.ts
+var import_opticore_logger3 = require("opticore-logger");
+var import_opticore_webapp_core = require("opticore-webapp-core");
+var import_opticore_webapp = require("opticore-webapp");
+var import_opticore_http_response = require("opticore-http-response");
 var AdaptedHttpCacheService = class {
+  /**
+   * Creates an instance of AdaptedHttpCacheService.
+   *
+   * @param cacheService - The underlying cache service instance (must implement getOrSet, delete, etc.)
+   * @param namespace - Namespace prefix for cache keys (default: "http-cache")
+   */
   constructor(cacheService, namespace = "http-cache") {
     this.cacheService = cacheService;
     this.namespace = namespace;
   }
-  stats = { totalRequests: 0, cacheHits: 0, cacheMisses: 0 };
+  stats = {
+    totalRequests: 0,
+    cacheHits: 0,
+    cacheMisses: 0
+  };
   /**
+   * Performs a GET request and caches the response.
    *
-   * @param url
-   * @param options
-   * @param cacheOptions
+   * @param url - The URL to fetch
+   * @param options - Optional fetch options (headers, etc.)
+   * @param cacheOptions - Cache configuration (TTL, bypass, custom key)
+   *
+   * @returns A promise resolving to the response data, merged with metadata
    */
   async getWithCache(url, options, cacheOptions) {
     this.stats.totalRequests++;
@@ -1873,12 +1900,15 @@ var AdaptedHttpCacheService = class {
     }
   }
   /**
+   * Performs a POST request and optionally caches the response.
+   *
+   * @param url - The URL to post to
+   * @param data - The payload to send
+   * @param options - Additional fetch options
+   * @param cacheResponse - Whether to cache the response (default: false)
+   * @param cacheOptions - Cache configuration (TTL, bypass, namespace)
    *
-   * @param url
-   * @param data
-   * @param options
-   * @param cacheResponse
-   * @param cacheOptions
+   * @returns A promise resolving to the response data, merged with metadata
    */
   async postWithCache(url, data, options, cacheResponse = false, cacheOptions) {
     this.stats.totalRequests++;
@@ -1908,18 +1938,26 @@ var AdaptedHttpCacheService = class {
       );
       return this.mergeResponse(cachedResponse);
     } catch (error) {
-      console.error(`Cache error for POST ${url}:`, error.message);
+      this.SLogger().error({
+        errorType: error.type,
+        httpCodeValue: import_opticore_http_response.HttpStatusCode.INTERNAL_SERVER_ERROR,
+        message: `Cache error for POST ${url}:\`, ${error.message}`,
+        stackTrace: error.stack,
+        title: "ERROR_POST_CACHING"
+      });
       this.stats.cacheMisses++;
       const response = await this.executeRequest("POST", url, requestOptions);
       return this.mergeResponse(response);
     }
   }
   /**
+   * Executes an HTTP request and returns a normalized response.
    *
-   * @param method
-   * @param url
-   * @param options
-   * @private
+   * @param method - HTTP method (GET, POST, etc.)
+   * @param url - Request URL
+   * @param options - Fetch options
+   *
+   * @returns A promise resolving to an IHttpClientResponse containing data and metadata
    */
   async executeRequest(method, url, options) {
     const response = await fetch(url, { method, ...options });
@@ -1936,21 +1974,25 @@ var AdaptedHttpCacheService = class {
     };
   }
   /**
+   * Merges response data with metadata, adding a _metadata property.
    *
-   * @param response
-   * @private
+   * @param response - The HTTP client response containing data and metadata
+   *
+   * @returns The data enriched with a _metadata field
    */
   mergeResponse(response) {
     const result = { ...response.data, _metadata: response.metadata };
     return result;
   }
   /**
+   * Generates a cache key based on request parameters.
    *
-   * @param method
-   * @param url
-   * @param options
-   * @param customKey
-   * @private
+   * @param method - HTTP method
+   * @param url - Request URL
+   * @param options - Request options (headers, body)
+   * @param customKey - Optional override for the key
+   *
+   * @returns A base64 encoded cache key string
    */
   generateKey(method, url, options, customKey) {
     if (customKey) return customKey;
@@ -1963,35 +2005,48 @@ var AdaptedHttpCacheService = class {
     return Buffer.from(keyParts.join("|")).toString("base64");
   }
   /**
+   * Invalidates cache entries matching a URL or pattern.
    *
-   * @param urlOrPattern
+   * @param urlOrPattern - The URL or pattern to invalidate
+   *
+   * @returns A promise resolving to the number of invalidated entries
    */
   async invalidateCache(urlOrPattern) {
     try {
-      console.log(`Invalidating cache for pattern: ${urlOrPattern}`);
       const encodedPattern = Buffer.from(urlOrPattern).toString("base64").slice(0, 20);
       const searchPattern = `*${encodedPattern}*`;
-      const invalidatedCount = await this.cacheService.invalidate(searchPattern);
-      console.log(`Invalidated ${invalidatedCount} entries for pattern: ${urlOrPattern}`);
-      return invalidatedCount;
+      return await this.cacheService.invalidate(searchPattern);
     } catch (error) {
-      console.error(`Error invalidating cache for ${urlOrPattern}:`, error.message);
+      this.SLogger().error({
+        errorType: error.type,
+        httpCodeValue: import_opticore_http_response.HttpStatusCode.INTERNAL_SERVER_ERROR,
+        message: `Error invalidating cache for ${urlOrPattern}: error.message`,
+        stackTrace: error.stackTrace,
+        title: "INVALIDATE CACHE"
+      });
       try {
         if (urlOrPattern.startsWith(this.namespace + ":")) {
           await this.cacheService.delete(urlOrPattern);
           return 1;
         }
       } catch (fallbackError) {
+        this.SLogger().error({
+          errorType: fallbackError.name,
+          httpCodeValue: import_opticore_http_response.HttpStatusCode.INTERNAL_SERVER_ERROR,
+          message: fallbackError.message,
+          stackTrace: fallbackError.stackTrace,
+          title: "INVALIDATE_PATTERN"
+        });
       }
       return 0;
     }
   }
   /**
-   *
+   * Clears all HTTP cache entries and resets statistics.
+   * @returns A promise that resolves when the cache is cleared
    */
   async clearHttpCache() {
     try {
-      console.log("Clearing HTTP cache...");
       if (typeof this.cacheService.clear === "function") {
         await this.cacheService.clear();
       } else if (typeof this.cacheService.keys === "function") {
@@ -2000,15 +2055,31 @@ var AdaptedHttpCacheService = class {
         for (const key of httpKeys) {
           await this.cacheService.delete(key);
         }
-        console.log(`Cleared ${httpKeys.length} HTTP cache entries`);
+        this.SLogger().success({
+          title: "CLEAR_HTTP_CACHE_ENTRIES",
+          message: `Cleared ${httpKeys.length} HTTP cache entries`
+        });
       }
       this.stats = { totalRequests: 0, cacheHits: 0, cacheMisses: 0 };
-      console.log("HTTP cache cleared successfully");
+      this.SLogger().success({
+        title: "CLEAR_CACHE",
+        message: "HTTP cache cleared successfully"
+      });
     } catch (error) {
-      console.error("Error clearing HTTP cache:", error.message);
+      this.SLogger().error({
+        errorType: error.name,
+        httpCodeValue: import_opticore_http_response.HttpStatusCode.INTERNAL_SERVER_ERROR,
+        message: error.message,
+        stackTrace: error.stackTrace,
+        title: "ERROR_CLEARING_HTTP_CACHE"
+      });
       throw new Error(`Failed to clear HTTP cache: ${error.message}`);
     }
   }
+  /**
+   * Retrieves current cache statistics.
+   * @returns A promise resolving to an HttpCacheStats object
+   */
   async getStats() {
     try {
       const cacheStats = await this.cacheService.getStatistics();
@@ -2027,10 +2098,20 @@ var AdaptedHttpCacheService = class {
         enabled: this.isEnabled()
       };
     } catch (error) {
-      console.error("Error getting cache stats:", error.message);
+      this.SLogger().error({
+        errorType: error.name,
+        httpCodeValue: import_opticore_http_response.HttpStatusCode.INTERNAL_SERVER_ERROR,
+        message: error.message,
+        stackTrace: error.stackTrace,
+        title: "ERROR_GETTING_CACHE_STATS"
+      });
       return this.getDefaultStats();
     }
   }
+  /**
+   * Returns default statistics when an error occurs.
+   * @returns A default HttpCacheStats object
+   */
   getDefaultStats() {
     return {
       totalRequests: this.stats.totalRequests,
@@ -2043,6 +2124,10 @@ var AdaptedHttpCacheService = class {
       enabled: false
     };
   }
+  /**
+   * Checks whether the cache service is enabled.
+   * @returns True if the cache is enabled, false otherwise
+   */
   isEnabled() {
     try {
       if (this.cacheService.isEnabled && typeof this.cacheService.isEnabled === "function") {
@@ -2053,6 +2138,13 @@ var AdaptedHttpCacheService = class {
       return false;
     }
   }
+  /**
+   * Creates a logger instance for internal error reporting.
+   * @returns A configured LoggerCore instance
+   */
+  SLogger() {
+    return new import_opticore_logger3.LoggerCore((0, import_opticore_webapp_core.loggerConfig)(import_opticore_webapp.envPath));
+  }
 };
 
 // src/application/services/fetch.client.service.ts
@@ -2505,8 +2597,33 @@ var CurlHttpClient = class {
 };
 
 // src/application/services/httpCacheFactory.service.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var import_opticore_logger4 = require("opticore-logger");
 var HttpCacheFactory = class {
+  /**
+   * Map of created instances, keyed by `${appName}:${clientType}`.
+   * @private
+   */
   static instances = /* @__PURE__ */ new Map();
+  /**
+   * Creates or retrieves an HTTP cache service instance.
+   * If an instance for the given appName and clientType already exists, it is returned.
+   * Otherwise, a new instance is created with the provided configuration.
+   *
+   * @param appName - Name of the application/context (default: "default"). Used for instance caching and default namespace.
+   * @param config - Configuration options for the cache and HTTP client.
+   * @param config.namespace - Namespace prefix for cache keys (default: `http-cache-${appName}`).
+   * @param config.localLang - Localization language (optional).
+   * @param config.storageType - Storage backend type: "memory", "disk", or "hybrid" (default: "disk").
+   * @param config.diskDir - Directory path for disk storage (default: "src/core/cache").
+   * @param config.maxSize - Maximum number of items to store (default: 10000).
+   * @param config.defaultTTL - Default time-to-live in milliseconds (default: 300000).
+   * @param config.clientType - HTTP client to use: "fetch", "node-http", "axios", or "curl" (default: "fetch").
+   * @param config.clientOptions - Additional options for the HTTP client (e.g., timeout, headers, baseURL).
+   *
+   * @returns An HTTP cache service instance implementing IHttpCacheService.
+   */
   static create(appName = "default", config) {
     const instanceKey = `${appName}:${config?.clientType || "fetch"}`;
     if (!this.instances.has(instanceKey)) {
@@ -2531,8 +2648,18 @@ var HttpCacheFactory = class {
         maxSize: config?.maxSize || 1e4,
         defaultTTL: config?.defaultTTL || 3e5,
         storageType: config?.storageType || "disk",
-        diskDir: config?.diskDir || `./storage/cache/${appName}`
+        diskDir: config?.diskDir || "src/core/cache"
       };
+      if (cacheConfig.storageType === "disk" || cacheConfig.storageType === "hybrid") {
+        const resolvedDiskDir = import_path2.default.resolve(process.cwd(), cacheConfig.diskDir);
+        if (!import_fs2.default.existsSync(resolvedDiskDir)) {
+          this.SLogger().warn({
+            title: "UNRESOLVED_CACHE_DIR",
+            message: `[HttpCacheFactory] Cache directory does not exist: ${resolvedDiskDir}
+Please create it manually or ensure the path is correct.`
+          });
+        }
+      }
       const instance = new HttpCacheClient(httpClient, void 0, {
         cacheConfig,
         timeout: config?.clientOptions?.timeout,
@@ -2543,23 +2670,51 @@ var HttpCacheFactory = class {
     }
     return this.instances.get(instanceKey);
   }
+  /**
+   * Creates an HTTP cache service instance by adapting an existing generic cache service.
+   * This is useful when you already have a cache service from another source and want to
+   * use it with the HTTP caching interface.
+   *
+   * @param cacheService - The underlying cache service instance (must support getOrSet, delete, etc.).
+   * @param namespace - Namespace for cache keys (default: "http-cache").
+   *
+   * @returns An adapted HTTP cache service implementing IHttpCacheService.
+   */
   static createFromExistingCache(cacheService, namespace = "http-cache") {
     return new AdaptedHttpCacheService(cacheService, namespace);
   }
+  /**
+   * Destroys a cached HTTP cache service instance, removing it from the internal map.
+   * After destruction, a new call to `create` will generate a fresh instance.
+   *
+   * @param appName - Name of the application/context (default: "default").
+   * @param clientType - HTTP client type used for the instance (default: "fetch").
+   *
+   * @return void
+   */
   static destroy(appName = "default", clientType) {
     const key = `${appName}:${clientType || "fetch"}`;
     this.instances.delete(key);
   }
+  /**
+   * Internal logger for warnings and errors.
+   * @returns A LoggerCore instance configured for the factory.
+   * @private
+   */
+  static SLogger() {
+    return new import_opticore_logger4.LoggerCore();
+  }
 };
 
 // src/index.ts
 import_dotenv.default.config();
-var index_default = {
-  SCacheMiddleware,
-  CacheService,
-  CacheMiddleware,
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   CacheFactoryRepository,
-  RouteValidator,
+  CacheMiddleware,
+  CacheService,
   EnvironmentLoader,
-  HttpCacheFactory
-};
+  HttpCacheFactory,
+  RouteValidator,
+  SCacheMiddleware
+});

package/dist/index.d.cts

@@ -544,8 +544,36 @@ interface IHttpCacheService {
 
 type HttpClientType = "fetch" | "node-http" | "axios" | "curl";
 
+/**
+ * Factory class for creating and managing HTTP cache service instances.
+ * It provides a centralized way to obtain configured HTTP cache implementations,
+ * supporting different HTTP clients and storage backends.
+ * Instances are cached and reused based on application name and client type.
+ */
 declare class HttpCacheFactory {
+    /**
+     * Map of created instances, keyed by `${appName}:${clientType}`.
+     * @private
+     */
     private static instances;
+    /**
+     * Creates or retrieves an HTTP cache service instance.
+     * If an instance for the given appName and clientType already exists, it is returned.
+     * Otherwise, a new instance is created with the provided configuration.
+     *
+     * @param appName - Name of the application/context (default: "default"). Used for instance caching and default namespace.
+     * @param config - Configuration options for the cache and HTTP client.
+     * @param config.namespace - Namespace prefix for cache keys (default: `http-cache-${appName}`).
+     * @param config.localLang - Localization language (optional).
+     * @param config.storageType - Storage backend type: "memory", "disk", or "hybrid" (default: "disk").
+     * @param config.diskDir - Directory path for disk storage (default: "src/core/cache").
+     * @param config.maxSize - Maximum number of items to store (default: 10000).
+     * @param config.defaultTTL - Default time-to-live in milliseconds (default: 300000).
+     * @param config.clientType - HTTP client to use: "fetch", "node-http", "axios", or "curl" (default: "fetch").
+     * @param config.clientOptions - Additional options for the HTTP client (e.g., timeout, headers, baseURL).
+     *
+     * @returns An HTTP cache service instance implementing IHttpCacheService.
+     */
     static create(appName?: string, config?: {
         namespace?: string;
         localLang?: string;
@@ -556,8 +584,33 @@ declare class HttpCacheFactory {
         clientType?: HttpClientType;
         clientOptions?: any;
     }): IHttpCacheService;
+    /**
+     * Creates an HTTP cache service instance by adapting an existing generic cache service.
+     * This is useful when you already have a cache service from another source and want to
+     * use it with the HTTP caching interface.
+     *
+     * @param cacheService - The underlying cache service instance (must support getOrSet, delete, etc.).
+     * @param namespace - Namespace for cache keys (default: "http-cache").
+     *
+     * @returns An adapted HTTP cache service implementing IHttpCacheService.
+     */
     static createFromExistingCache(cacheService: any, namespace?: string): IHttpCacheService;
+    /**
+     * Destroys a cached HTTP cache service instance, removing it from the internal map.
+     * After destruction, a new call to `create` will generate a fresh instance.
+     *
+     * @param appName - Name of the application/context (default: "default").
+     * @param clientType - HTTP client type used for the instance (default: "fetch").
+     *
+     * @return void
+     */
     static destroy(appName?: string, clientType?: HttpClientType): void;
+    /**
+     * Internal logger for warnings and errors.
+     * @returns A LoggerCore instance configured for the factory.
+     * @private
+     */
+    private static SLogger;
 }
 
 /**
@@ -581,17 +634,4 @@ interface CacheEntry<T = any> {
     lastAccessedAt: number;
 }
 
-/**
- * Default export object with all features
- */
-declare const _default: {
-    SCacheMiddleware: typeof SCacheMiddleware;
-    CacheService: typeof CacheService;
-    CacheMiddleware: typeof CacheMiddleware;
-    CacheFactoryRepository: typeof CacheFactoryRepository;
-    RouteValidator: typeof RouteValidator;
-    EnvironmentLoader: typeof EnvironmentLoader;
-    HttpCacheFactory: typeof HttpCacheFactory;
-};
-
-export { type CacheEntry, type ICacheRepository, type IHttpCacheService, _default as default };
+export { type CacheEntry, CacheFactoryRepository, CacheMiddleware, CacheService, EnvironmentLoader, HttpCacheFactory, type ICacheRepository, type IHttpCacheService, RouteValidator, SCacheMiddleware };

package/dist/index.d.ts

@@ -544,8 +544,36 @@ interface IHttpCacheService {
 
 type HttpClientType = "fetch" | "node-http" | "axios" | "curl";
 
+/**
+ * Factory class for creating and managing HTTP cache service instances.
+ * It provides a centralized way to obtain configured HTTP cache implementations,
+ * supporting different HTTP clients and storage backends.
+ * Instances are cached and reused based on application name and client type.
+ */
 declare class HttpCacheFactory {
+    /**
+     * Map of created instances, keyed by `${appName}:${clientType}`.
+     * @private
+     */
     private static instances;
+    /**
+     * Creates or retrieves an HTTP cache service instance.
+     * If an instance for the given appName and clientType already exists, it is returned.
+     * Otherwise, a new instance is created with the provided configuration.
+     *
+     * @param appName - Name of the application/context (default: "default"). Used for instance caching and default namespace.
+     * @param config - Configuration options for the cache and HTTP client.
+     * @param config.namespace - Namespace prefix for cache keys (default: `http-cache-${appName}`).
+     * @param config.localLang - Localization language (optional).
+     * @param config.storageType - Storage backend type: "memory", "disk", or "hybrid" (default: "disk").
+     * @param config.diskDir - Directory path for disk storage (default: "src/core/cache").
+     * @param config.maxSize - Maximum number of items to store (default: 10000).
+     * @param config.defaultTTL - Default time-to-live in milliseconds (default: 300000).
+     * @param config.clientType - HTTP client to use: "fetch", "node-http", "axios", or "curl" (default: "fetch").
+     * @param config.clientOptions - Additional options for the HTTP client (e.g., timeout, headers, baseURL).
+     *
+     * @returns An HTTP cache service instance implementing IHttpCacheService.
+     */
     static create(appName?: string, config?: {
         namespace?: string;
         localLang?: string;
@@ -556,8 +584,33 @@ declare class HttpCacheFactory {
         clientType?: HttpClientType;
         clientOptions?: any;
     }): IHttpCacheService;
+    /**
+     * Creates an HTTP cache service instance by adapting an existing generic cache service.
+     * This is useful when you already have a cache service from another source and want to
+     * use it with the HTTP caching interface.
+     *
+     * @param cacheService - The underlying cache service instance (must support getOrSet, delete, etc.).
+     * @param namespace - Namespace for cache keys (default: "http-cache").
+     *
+     * @returns An adapted HTTP cache service implementing IHttpCacheService.
+     */
     static createFromExistingCache(cacheService: any, namespace?: string): IHttpCacheService;
+    /**
+     * Destroys a cached HTTP cache service instance, removing it from the internal map.
+     * After destruction, a new call to `create` will generate a fresh instance.
+     *
+     * @param appName - Name of the application/context (default: "default").
+     * @param clientType - HTTP client type used for the instance (default: "fetch").
+     *
+     * @return void
+     */
     static destroy(appName?: string, clientType?: HttpClientType): void;
+    /**
+     * Internal logger for warnings and errors.
+     * @returns A LoggerCore instance configured for the factory.
+     * @private
+     */
+    private static SLogger;
 }
 
 /**
@@ -581,17 +634,4 @@ interface CacheEntry<T = any> {
     lastAccessedAt: number;
 }
 
-/**
- * Default export object with all features
- */
-declare const _default: {
-    SCacheMiddleware: typeof SCacheMiddleware;
-    CacheService: typeof CacheService;
-    CacheMiddleware: typeof CacheMiddleware;
-    CacheFactoryRepository: typeof CacheFactoryRepository;
-    RouteValidator: typeof RouteValidator;
-    EnvironmentLoader: typeof EnvironmentLoader;
-    HttpCacheFactory: typeof HttpCacheFactory;
-};
-
-export { type CacheEntry, type ICacheRepository, type IHttpCacheService, _default as default };
+export { type CacheEntry, CacheFactoryRepository, CacheMiddleware, CacheService, EnvironmentLoader, HttpCacheFactory, type ICacheRepository, type IHttpCacheService, RouteValidator, SCacheMiddleware };