opticore-cache 1.0.0 → 1.0.3

package/dist/index.js

@@ -404,6 +404,7 @@ var MemoryCache = class {
 import fs from "fs";
 import path from "path";
 import { promisify } from "util";
+import { LoggerCore } from "opticore-logger";
 var fsExists = promisify(fs.exists);
 var fsMkdir = promisify(fs.mkdir);
 var fsReadFile = promisify(fs.readFile);
@@ -449,7 +450,7 @@ var DiskCache = class {
    * @private
    */
   getCacheDirectory() {
-    return process.env.CACHE_DISK_DIR || path.join(process.cwd(), "storage", "cache", this.config.namespace);
+    return process.env.CACHE_DISK_DIR || path.join(process.cwd(), "src", "core", "cache", this.config.namespace);
   }
   /**
    * Initialise le répertoire de cache
@@ -826,8 +827,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`);
@@ -852,6 +853,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 LoggerCore();
+  }
   /**
    * Récupère le chemin du dossier de cache
    * @returns string
@@ -1213,7 +1217,7 @@ var CacheManagementUseCase = class {
 
 // src/application/services/cacheService.service.ts
 import { translate, translationLoaderConfig } from "opticore-loader-translation";
-import { LoggerCore } from "opticore-logger";
+import { LoggerCore as LoggerCore2 } from "opticore-logger";
 var CacheService = class _CacheService {
   cacheUseCase;
   cacheRepository;
@@ -1387,7 +1391,7 @@ var CacheService = class _CacheService {
     });
   }
   logger() {
-    return new LoggerCore(this.configLogger);
+    return new LoggerCore2(this.configLogger);
   }
 };
 
@@ -1453,11 +1457,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(/\/\.\*$/, "(\\/.*)?");
     }
@@ -1501,11 +1505,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)
@@ -1649,11 +1653,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
@@ -1808,17 +1812,34 @@ var SCacheMiddleware = class {
 };
 
 // src/application/services/adaptedHttpCache.service.ts
+import { LoggerCore as LoggerCore3 } from "opticore-logger";
+import { loggerConfig } from "opticore-webapp-core";
+import { envPath } from "opticore-webapp";
+import { HttpStatusCode } from "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++;
@@ -1846,12 +1867,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++;
@@ -1881,18 +1905,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: 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 });
@@ -1909,21 +1941,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;
@@ -1936,35 +1972,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: 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: 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") {
@@ -1973,15 +2022,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: 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();
@@ -2000,10 +2065,20 @@ var AdaptedHttpCacheService = class {
         enabled: this.isEnabled()
       };
     } catch (error) {
-      console.error("Error getting cache stats:", error.message);
+      this.SLogger().error({
+        errorType: error.name,
+        httpCodeValue: 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,
@@ -2016,6 +2091,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") {
@@ -2026,6 +2105,13 @@ var AdaptedHttpCacheService = class {
       return false;
     }
   }
+  /**
+   * Creates a logger instance for internal error reporting.
+   * @returns A configured LoggerCore instance
+   */
+  SLogger() {
+    return new LoggerCore3(loggerConfig(envPath));
+  }
 };
 
 // src/application/services/fetch.client.service.ts
@@ -2478,8 +2564,33 @@ var CurlHttpClient = class {
 };
 
 // src/application/services/httpCacheFactory.service.ts
+import fs2 from "fs";
+import path2 from "path";
+import { LoggerCore as LoggerCore4 } from "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)) {
@@ -2504,8 +2615,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 = path2.resolve(process.cwd(), cacheConfig.diskDir);
+        if (!fs2.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,
@@ -2516,26 +2637,50 @@ 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 LoggerCore4();
+  }
 };
 
 // src/index.ts
 dotenv.config();
-var index_default = {
-  SCacheMiddleware,
-  CacheService,
-  CacheMiddleware,
+export {
   CacheFactoryRepository,
-  RouteValidator,
+  CacheMiddleware,
+  CacheService,
   EnvironmentLoader,
-  HttpCacheFactory
-};
-export {
-  index_default as default
+  HttpCacheFactory,
+  RouteValidator,
+  SCacheMiddleware
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opticore-cache",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Highly configurable caching system compatible with OptiCore.js",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -31,14 +31,12 @@
     "ansi-colors": "^4.1.3",
     "chalk": "^5.4.1",
     "gradient-string": "^3.0.0",
-    "opticore-dependency-inject": "^1.0.7",
-    "opticore-env-access": "^1.0.13",
-    "opticore-http-response": "^1.0.9",
-    "opticore-loader-translation": "^1.0.3",
-    "opticore-logger": "^1.0.29",
-    "opticore-router": "^1.0.20",
-    "opticore-webapp": "^1.0.70",
-    "opticore-webapp-core": "^1.0.20",
+    "opticore-express": "^1.0.9",
+    "opticore-http-response": "^1.0.11",
+    "opticore-loader-translation": "^1.0.9",
+    "opticore-logger": "^1.0.32",
+    "opticore-webapp": "^1.0.86",
+    "opticore-webapp-core": "^1.0.21",
     "uuidv7": "^1.1.0"
   },
   "devDependencies": {