Final: Library Working

Author: hoangsonww

README.md

@@ -40,6 +40,7 @@ Currently available as a Node.js package on NPM. **NPM Page:** [https://www.npmj
   - [Node.js Example](#nodejs-example)
 - [API Reference](#api-reference)
 - [Testing](#testing)
+- [Demo Script](#demo-script)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -152,8 +153,6 @@ const profile = await getCache("user-profile");
 console.log("Manual cache:", profile);
 ```
 
----
-
 ## Storage Adapters
 
 ### localStorage
@@ -206,8 +205,6 @@ enableGhostCache({
 });
 ```
 
----
-
 ## Advanced Examples
 
 ### React Application Example
@@ -272,8 +269,6 @@ api
   });
 ```
 
----
-
 ## API Reference
 
 - **enableGhostCache(options?: GhostCacheOptions): void**  
@@ -294,8 +289,6 @@ api
 - **registerAxios(instance: AxiosInstance): void**  
   Registers an Axios instance so that its requests are intercepted and cached.
 
----
-
 ## Testing
 
 GhostCache comes with a comprehensive Jest test suite. To run tests:
@@ -316,22 +309,32 @@ Tests use the Pokémon API (`https://pokeapi.co/api/v2/pokemon/ditto`) to verify
 
 > Note: There may be path/import issues. If you encounter any, please check the test files and adjust the import paths accordingly.
 
+## Demo Script
+
+To run a demo script that showcases GhostCache in action, use the following command:
+
+```bash
+npm run demo
+```
+
+This will execute a script that demonstrates caching with both `fetch()` and Axios. Monitor the console for logs indicating cache hits and misses.
+
 ## Contributing
 
 Contributions are welcome! Please follow these steps:
 
 1. **Fork the Repository**
 2. **Create a Feature Branch**
+
    ```bash
    git checkout -b feature/my-new-feature
    ```
+
 3. **Commit Your Changes**
 4. **Submit a Pull Request**
 
 For major changes, please open an issue first to discuss what you would like to change.
 
----
-
 ## License
 
 GhostCache is released under the MIT License.

package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "ghost-cache",
   "displayName": "GhostCache API Cache",
-  "version": "1.1.2",
+  "version": "1.2.3",
   "description": "A lightweight auto-caching wrapper for fetch() and Axios with multi-storage support (localStorage, sessionStorage, IndexedDB, Redis)",
   "main": "dist/index.js",
   "types": "index.d.ts",
@@ -53,7 +53,7 @@
   },
   "dependencies": {
     "axios": "^1.3.0",
-    "ghost-cache": "^1.1.1",
+    "ghost-cache": "^1.2.3",
     "prettier": "^3.5.3",
     "redis": "^4.0.0"
   }

package.json

@@ -61,7 +61,7 @@ let originalFetch: typeof globalObj.fetch | null = null;
 let axiosInstances: AxiosInstance[] = [];
 
 /**
- * Picks correct storage adapter
+ * Picks correct storage adapter based on config.
  */
 function determineStorageAdapter(
   opt: GhostCacheOptions["storage"],
@@ -78,7 +78,7 @@ function determineStorageAdapter(
 }
 
 /**
- * Enable GhostCache
+ * Enable GhostCache: intercept fetch and (optionally) Axios requests.
  */
 export function enableGhostCache(options: GhostCacheOptions = {}): void {
   // Merge user options into defaults
@@ -89,29 +89,32 @@ export function enableGhostCache(options: GhostCacheOptions = {}): void {
     ? determineStorageAdapter(defaultConfig.storage)
     : null;
 
-  // Intercept fetch if not done
+  // Intercept global fetch if we haven't already
   if (!originalFetch) {
     originalFetch = globalObj.fetch.bind(globalObj);
     globalObj.fetch = async (url: RequestInfo, config?: RequestInit) => {
       return handleRequest({ url, config });
     };
   }
 
-  // Setup Axios interceptors
+  // Set up Axios interceptors
   axiosInstances.forEach((instance) => {
     instance.interceptors.request.use(
       async (config: InternalAxiosRequestConfig) => {
-        const safeUrl = config.url ?? "";
+        const safeUrl: string = config.url ?? "";
         const cacheKey = JSON.stringify({
           url: safeUrl,
           params: config.params,
           method: config.method,
         });
 
-        // Check in-memory
+        // Check in-memory cache
         if (inMemoryCache.has(cacheKey)) {
           const entry = inMemoryCache.get(cacheKey)!;
           if (Date.now() - entry.timestamp < defaultConfig.ttl) {
+            console.log(
+              `[GhostCache] Using in-memory cache for request: ${safeUrl}`,
+            );
             return Promise.reject({
               __ghostCache__: true,
               data: JSON.parse(entry.data),
@@ -122,12 +125,15 @@ export function enableGhostCache(options: GhostCacheOptions = {}): void {
           }
         }
 
-        // Check persistent
+        // Check persistent storage
         if (storageAdapter) {
           const stored = await storageAdapter.getItem(cacheKey);
           if (stored) {
             const parsed = JSON.parse(stored) as CacheEntry;
             if (Date.now() - parsed.timestamp < defaultConfig.ttl) {
+              console.log(
+                `[GhostCache] Using persistent cache for request: ${safeUrl}`,
+              );
               return Promise.reject({
                 __ghostCache__: true,
                 data: JSON.parse(parsed.data),
@@ -146,7 +152,7 @@ export function enableGhostCache(options: GhostCacheOptions = {}): void {
 
     instance.interceptors.response.use(
       (res: AxiosResponse) => {
-        const safeUrl = res.config.url ?? "";
+        const safeUrl: string = res.config.url ?? "";
         const cacheKey = JSON.stringify({
           url: safeUrl,
           params: res.config.params,
@@ -173,18 +179,23 @@ export function enableGhostCache(options: GhostCacheOptions = {}): void {
 }
 
 /**
- * Internal fetch handler
+ * Handle fetch() requests with caching.
  */
 async function handleRequest(request: {
   url: RequestInfo;
   config?: RequestInit;
 }): Promise<Response> {
   const cacheKey = JSON.stringify(request);
 
-  // in-memory check
+  // In-memory cache check
   if (inMemoryCache.has(cacheKey)) {
     const entry = inMemoryCache.get(cacheKey)!;
     if (Date.now() - entry.timestamp < defaultConfig.ttl) {
+      console.log(
+        `[GhostCache] (fetch) Using in-memory cache for: ${JSON.stringify(
+          request,
+        )}`,
+      );
       return new globalObj.Response(entry.data, {
         status: 200,
         headers: { "Content-Type": "application/json" },
@@ -194,12 +205,17 @@ async function handleRequest(request: {
     }
   }
 
-  // storage check
+  // Persistent cache check
   if (storageAdapter) {
     const stored = await storageAdapter.getItem(cacheKey);
     if (stored) {
       const entry = JSON.parse(stored) as CacheEntry;
       if (Date.now() - entry.timestamp < defaultConfig.ttl) {
+        console.log(
+          `[GhostCache] (fetch) Using persistent cache for: ${JSON.stringify(
+            request,
+          )}`,
+        );
         return new globalObj.Response(entry.data, {
           status: 200,
           headers: { "Content-Type": "application/json" },
@@ -210,21 +226,28 @@ async function handleRequest(request: {
     }
   }
 
+  console.log(
+    `[GhostCache] (fetch) Fetching from network: ${JSON.stringify(request)}`,
+  );
+  // Network fetch
   if (!originalFetch) {
     throw new Error("GhostCache: original fetch is missing.");
   }
-  // network fetch
   const response = await originalFetch(request.url, request.config);
   const cloned = response.clone();
   const textData = await cloned.text();
   cacheResponse(cacheKey, textData);
   return response;
 }
 
+/**
+ * Save to in-memory cache and persistent storage.
+ */
 function cacheResponse(cacheKey: string, data: string) {
-  const entry = { timestamp: Date.now(), data };
+  const entry: CacheEntry = { timestamp: Date.now(), data };
   inMemoryCache.set(cacheKey, entry);
 
+  // Enforce maximum cache entries
   if (inMemoryCache.size > defaultConfig.maxEntries) {
     const firstKey = inMemoryCache.keys().next().value;
     if (firstKey) inMemoryCache.delete(firstKey);
@@ -233,52 +256,64 @@ function cacheResponse(cacheKey: string, data: string) {
   if (storageAdapter) {
     storageAdapter.setItem(cacheKey, JSON.stringify(entry));
   }
+
+  console.log(`[GhostCache] Cached response for key: ${cacheKey}`);
 }
 
 /**
- * Manually set a cache
+ * Manually set a cache entry.
  */
 export async function setCache(key: string, value: any): Promise<void> {
   const cacheKey = JSON.stringify(key);
-  const entry = { timestamp: Date.now(), data: JSON.stringify(value) };
+  const entry: CacheEntry = {
+    timestamp: Date.now(),
+    data: JSON.stringify(value),
+  };
   inMemoryCache.set(cacheKey, entry);
-
   if (storageAdapter) {
     await storageAdapter.setItem(cacheKey, JSON.stringify(entry));
   }
+  console.log(`[GhostCache] Manually cached key: ${cacheKey}`);
 }
 
 /**
- * Get a cached item
+ * Retrieve a cache entry.
  */
 export async function getCache<T = any>(key: string): Promise<T | null> {
   const cacheKey = JSON.stringify(key);
   if (inMemoryCache.has(cacheKey)) {
     const entry = inMemoryCache.get(cacheKey)!;
+    console.log(
+      `[GhostCache] Retrieved from in-memory cache for key: ${cacheKey}`,
+    );
     return JSON.parse(entry.data) as T;
   }
   if (storageAdapter) {
     const stored = await storageAdapter.getItem(cacheKey);
     if (stored) {
       const entry = JSON.parse(stored) as CacheEntry;
+      console.log(
+        `[GhostCache] Retrieved from persistent cache for key: ${cacheKey}`,
+      );
       return JSON.parse(entry.data) as T;
     }
   }
   return null;
 }
 
 /**
- * Clear all caches
+ * Clear all cache entries.
  */
 export function clearGhostCache(): void {
   inMemoryCache.clear();
   if (storageAdapter) {
     storageAdapter.clear();
   }
+  console.log("[GhostCache] Cache cleared");
 }
 
 /**
- * Disable GhostCache
+ * Disable GhostCache and restore the original fetch.
  */
 export function disableGhostCache(): void {
   if (originalFetch) {
@@ -287,11 +322,13 @@ export function disableGhostCache(): void {
   }
   axiosInstances = [];
   clearGhostCache();
+  console.log("[GhostCache] Disabled and restored original fetch");
 }
 
 /**
- * Register an Axios instance
+ * Register an Axios instance to intercept its requests.
  */
 export function registerAxios(instance: AxiosInstance): void {
   axiosInstances.push(instance);
+  console.log("[GhostCache] Registered an Axios instance");
 }