fuse-core-express 1.0.2 → 1.0.3

package/README.md

@@ -1,588 +1,334 @@
-# FuseCore - Express.js Development Toolkit
+# FuseCore Express Encrypted Package
 
-> 🔐 **This package contains encrypted and obfuscated code**
-> 
-> **Version:** 1.0.2  
-> **Protection:** JavaScript Obfuscation + AES-256-CBC + RSA-2048  
-> **MIT Compliant:** Private key included in package for open source compliance  
+FuseCore Express version - Provides the exact same API as the standard version, but with AES-256-GCM + RSA encryption for code protection.
 
-## ⚠️ Security Notice
+## 🚀 Quick Start
 
-This package contains encrypted code that is protected by multiple layers of security. The private key is included in the package to comply with MIT open source license requirements. The code is protected by:
+### Installation
 
-- **JavaScript Obfuscation** - Code structure completely obfuscated
-- **AES-256-CBC Encryption** - All source code encrypted
-- **RSA-2048 Key Protection** - AES keys encrypted with RSA
-- **Digital Signature** - Code integrity verification
-
-## Quick Start
-
-```javascript
-import FuseCore from 'fuse-core-express';
-
-// Initialize decryption with included private key (MIT compliant)
-FuseCore.initDecryption('./private-1.0.2.pem');
-
-// Then use normally
-await FuseCore.init();
+```bash
+npm install fuse-core-express
 ```
 
----
-
+### Basic Usage
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+The FuseCore uses a **two-stage initialization** pattern:
 
-**FuseCore** - A comprehensive Express.js toolkit that provides essential web development utilities including caching, logging, monitoring, AJAX handling, and more. Built with MIT open source license.
+```javascript
+import FuseCore from 'fuse-core-express';
+import path from 'path';
+import { fileURLToPath } from 'url';
 
-### init options
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-```
+// Stage 1: Initialize decryption
+const privateKeyPath = path.join(__dirname, 'keys/recipient-keys-1.0.3.json');
+await FuseCore.initDecryption(privateKeyPath);
 
-{
-    common: {
-        expressApp: null,
-        listenHostname: '',
-        listenPort: 3000,
-    },
-    cache: {
-        impl: 'memory', // 'memory' or 'redis'
-        redis: {
-            url: 'redis://localhost:6379',
-            connectTimeout: 10000,
-            commandTimeout: 5000,
-            enableTls: false,
-            clientOptions: {}
-        }
-    },
+// Stage 2: Initialize FuseCore (same as standard version)
+await FuseCore.init({
     log: {
-        path: '',
-        level: '',
-        extraZipStreams: [],
-        takeOverConsole: false,
-        extraOutputStreams: {
-            info: process.stdout,
-            error: process.stderr,
-        },
+        level: 'info',
+        format: 'json'
     },
-    ajax: {
-        timeout: 10000,
-        slowThreshold: 3000,
-        defaultHeaders: {
-            "X-Requested-With": "FuseCore Web component V1.0"
-        },
-        agentOptions:{}
-    },
-    manifest: {
-        path: '',
-        name: '',
+    cache: {
+        type: 'memory',
+        maxSize: '100MB'
     },
-
     monitor: {
-        prefix: '',
-        suffix: '',
-        mem: true,
-        cpu: true,
-        req404: true,
-        req5xx: true,
-    },
-    isPrimaryProcess: cluster.isPrimary || cluster.isMaster
-}
+        enabled: true,
+        interval: 5000
+    }
+});
+
+// Use FuseCore API normally
+// ... Your business logic ...
 
+// Shutdown FuseCore
+await FuseCore.shutdown();
 ```
 
-* common.expressApp           (object) optional,Express.app object.
-* common.listenHostname           (string) optional, hostname or ip http server listens on, used for config server callback.
-* common.listenPort           (number) optional,port number http server listens on, used for config server callback.
-* cache.impl            (string) optional, cache implementation, 'memory' or 'redis', default is memory.
-* cache.redis.url       (string) optional, Redis connection URL, default is 'redis://localhost:6379'.
+## 📋 Detailed API Documentation
 
-* cache.redis.enableTls       (boolean) optional, enable TLS/SSL for Redis connection, default is false.
-* cache.redis.clientOptions   (object) optional, additional Redis client options.
-* log.path              (string) optional, directory to save log files.
-* log.level             (string) optional, minimal level written to log file,default is info.
-* log.extraZipStreams    (array) optional, streams for access log.
-* log.takeOverConsole    (bool) optional, default false, indicate log module take over system console, thus all console message will be pipe to log file.
-* log.extraOutputStreams (Object) optional, default null, extra log output stream, should be {info:[...Writable],error:[...Writable]}.
-* ajax.timeout          (number) optional, default timeout in millisecond, default is 10000.
-* ajax.slowThreshold          (number) optional, default slow log time limit in millisecond, all backend response time greater than limit will be logged to slow log file, default value is 50.
-* ajax.defaultHeaders          (object) optional, default headers send to backend, default value is {'x-requested-with':'FuseCore Web Server 1.0'}.
-* ajax.agentOptions          (object) optional, extra agent options will pass to http/https agent, also will applied to globalAgent.
-* manifest.path          (string) optional, directory contain manifest file.
-* manifest.name         (string) optional, manifest name to load.
+### `FuseCore.initDecryption(privateKeyPath)`
 
-* monitor.prefix         (string) optional, prefix of all monitor keys.
-* monitor.suffix         (string) optional, suffix of all monitor keys.
-* monitor.mem         (bool) optional, auto monitor memory usage, default is false.
-* monitor.cpu         (bool) optional, auto monitor cpu usage, default is false.
-* monitor.req404         (bool) optional, monitor 404 requests, default is false.
-* monitor.req5xx         (bool) optional, monitor 5xx requests, default is false.
-* isPrimaryProcess         (bool) optional, indicate current process is primary in cluster mode, monitor module will act differently when run as a worker process. 
+Initialize the decryption process, this is the necessary first step for using FuseCore.
 
+#### Parameters
 
+- **`privateKeyPath`** (string): Path to the recipient private key file
+  - Must be a JSON file containing the `privateKey` field
+  - Typically named `recipient-keys-{version}.json`
+  - Example path: `./keys/recipient-keys-1.0.3.json`
 
-## Monitor
+#### Return Value
 
-### Usage:
+- Returns FuseCore instance (for method chaining)
 
-#### Init:
-@deprecated
+#### Examples
 
-var FuseCore = require('fuse-core-express');
-//this line must @ top ,before any routes or app filters.
-app.use(FuseCore.requestFilter());
+```javascript
+// Use bundled key files (recommended for development/testing)
+const privateKeyPath = path.join(__dirname, 'keys/recipient-keys-1.0.3.json');
+await FuseCore.initDecryption(privateKeyPath);
 
-.....
+// Use custom path key files
+await FuseCore.initDecryption('/path/to/your/private-key.json');
+```
 
+#### Key File Format
 
-var Monitor = FuseCore.monitor;
-Monitor.init(configObj);
+The private key file should be in JSON format, containing the following fields:
 
-#### Monitor Config:
+```json
 {
-    app: Express.app object (obj,required)
-    prefix: monitor default prefix (string,optional)
-    suffix: monitor default suffix (string,optional)
-    mem: monitor memory usage (boolean,optional)
-    cpu: monitor cpu usage (boolean,optional)
-    mon404: monitor 404 response (boolean,optional)
-    mon5xx: monitor 5xx response (boolean,optional)
-    monitorPath: the path for express which remove graph drawer used to get monitor indicators and values
+  "privateKey": "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----\n",
+  "publicKey": "-----BEGIN PUBLIC KEY-----\nMIIB...\n-----END PUBLIC KEY-----\n",
+  "owner": "recipient",
+  "timestamp": "2025-08-01T15:58:34.531Z"
 }
+```
 
+### `FuseCore.init(options)`
 
-#### Request filter
-1. Used to adept nestia ip rule,when using request.ip property.
-1. add req.realUrl property presents the url send to nginx.
+Initialize FuseCore instance, exactly the same API as the standard version.
 
+#### Prerequisites
 
-#### Request Utils
-Provides function to resolve request headers,such as accept-language or user-agent.
+- ⚠️ **Must call `initDecryption()` first**
 
-##### getUAInfo
+#### Parameters
 
-param: 
+- **`options`** (object): FuseCore configuration options
+  - `log`: Logging configuration
+  - `cache`: Cache configuration  
+  - `monitor`: Monitoring configuration
+  - etc... (same as standard version)
 
-* req: express request object
+#### Examples
 
-return:
-```
- {
-     isBot: false,
-     isWinPhone: false,
-     isIPhone: false,
-     isIPad: false,
-     isAndroid: false,
-     isAndroidTablet: false,
-     isTablet: false,
-     isOtherMobile: false,
-     isMobile: false,
-     isWechatMiniProg: false,
-     platform: "windows" | "ios" | "android" | "linux" | "macos" | "whatsapp" | "compatible" | "unknown",
-     platformVersion: "10.3.1",
-     browser: "msie" | "opera" | "firefox" | "chrome" | "facebook" | "weixin" | "safari" | "unknown",
-     browserVersion: "10.3.1"
- }
+```javascript
+await FuseCore.init({
+    log: {
+        level: 'debug',
+        format: 'pretty',
+        output: './logs'
+    },
+    cache: {
+        type: 'redis',
+        host: 'localhost',
+        port: 6379
+    },
+    monitor: {
+        enabled: true,
+        interval: 3000,
+        metrics: ['cpu', 'memory', 'requests']
+    }
+});
 ```
 
-##### getLangInfo
-
-param: 
-
-* req: express request object
-* is4PC: true means client is requesting a web page for PC not mobile device.
+### `FuseCore.shutdown()`
 
-return:
+Shutdown FuseCore instance and clean up resources.
 
+```javascript
+await FuseCore.shutdown();
 ```
- {
-     languages: {
-         "zh-CN": "0,8",
-         "en": "0,6"
-     },
-     primaryLanguage: ["zh-CN"],
-     isEnglish: false,
-     lang: "zh-cn" | "en"
- }
-```
-
 
-#### Log
+## 🔐 Key Management
 
-1. provide an logger by using getLogger 
-1. automatically zip logs
-1. automatically removes oldlogs
-1. Requires init
-1. FuseCore.logger's method can be called at any time, but it won't output any data until init finished.
+### Method 1: Use Bundled Keys (Development/Testing)
 
-init options:
+The package includes ready-to-use key files:
 
-```
-{
-       dir:path.join(__dirname,'/../logs'),
-       streams:FileStreamRotator.getStream({...}) | [FileStreamRotator.getStream({...})]
-}
+```javascript
+const privateKeyPath = path.join(__dirname, 'keys/recipient-keys-1.0.3.json');
+await FuseCore.initDecryption(privateKeyPath);
 ```
 
-Usage Example:
+### Method 2: Environment Variables (Production Recommended)
 
+```bash
+export FUSECORE_RECIPIENT_PRIVATE_KEY="$(cat /secure/path/recipient-private-key.pem)"
+export FUSECORE_SIGNER_PUBLIC_KEY="$(cat /secure/path/signer-public-key.pem)"
 ```
-FuseCore.logger.info('some text',someObject);
 
+```javascript
+// When environment variables exist, no parameters need to be passed
+await FuseCore.initDecryption();
 ```
 
-#### Manifest
-```
-let FuseCore=require('fuse-core-express');
-let manifest=FuseCore.manifest;
+### Method 3: Custom Key Files
 
-let value=manifest.get('prop1.prop2.prop3');
-......
+```javascript
+await FuseCore.initDecryption('/custom/path/to/private-key.json');
 ```
 
-#### Ajax
-
-Ajax API
+## 📁 Package File Structure
 
-###### Request Options
-
-demo: 
 ```
-
-{
-    server:'lottery',
-    version:'v5.0'
-    path:'/toto/broadcast'
-    data:{
-        key1:1234,
-        key2:5678
-    },
-    method:'POST',
-    timeout:800,
-    reqContentType:'form',
-    resContentType:'json',
-    headers:{
-        SomeUserDefinedHeader:'this will pass to server'
-    },
-    isWeb:true,
-    anonymous:true,
-    cname:'toto_broadcast',
-    passClientIP:false,
-    req:req,
-    res:res
-}
-
+node_modules/fuse-core-express/
+├── index.js                    # Main entry file
+├── secure-package.vxz          # Encrypted code package
+├── decryptor.js               # Standalone decryptor
+├── keys/                      # Key files directory
+│   ├── build-version.json
+│   ├── recipient-keys-1.0.3.json  # Recipient keys (contains private key)
+│   ├── signer-keys-1.0.3.json     # Signer public key
+│   └── README.md
+├── example-usage.js           # Usage examples
+└── package.json
 ```
 
-* server:   (string) (required) Server code defined in manifest.
-* version:  (string) (optional) Version to replace '${version}' part in url.
-* path:     (string) (required) Api path apart from url defined in manifest.
-* data:     (object) (optional) Data will send to server.It should be a simple object.
-* method:   (string) (optional) Http method,default is 'GET'.
-* timeout:  (number) (optional) Timeout (microseconds) before server complete response,default is defined in config or init option DEFAULT_TIMEOUT.
-* reqContentType (deprecated alias dataType): (string) (optional) request data format,only support 'json' and 'form'(default).
-* resContentType (deprecated alias contentType): (string) (optional) Content format.If contentType set 'json' or server response with header 'content-type:application/json', response body will be decode automatically.
-* headers:  (object) (optional) Headers passed to server.Note:if req object is set,most of req.headers' property will passed to backend,no need to redefine headers in this option.
-* isWeb:    (bool) (optional) If true, and exists cookie named 'N1',then cookie N1's value will replace default Accept-Language value.Default is false.
-* anonymous: (bool) (optional) If false, and exists cookie named 'token',then a header named 'Authorization' will be set with value of cookie 'token'.
-* noCache: (bool) (optional) If true, headers named 'If-Modified-Since','If-None-Match' will be removed from header ,and 'Cache-Control' will be set 'no-cache'. Default is true.
-* passClientIP: (bool) (optional) If true, headers ('X-Forwarded-For','X-Real-IP') will be passed to server. Default is true.
-* req:      (obj) (optional) (*required by proxy) By default,most of headers in req will pass to backend request.In proxy method,request's body stream will piped to backend request.
-* res:      (obj) (unnecessary)(*required by proxy) Proxy will handle response,when reject happened.Only if ret.status === 0 ,proxy don't handle response,you should end response, such as res.status(500).end() .
-
-###### Response Data (also as reject error)
+## 🔄 Complete Usage Workflow
 
-```
+### 1. CommonJS Environment
 
-{
-    ok: false,
-    status: 0,
-    message: '',
-    error: null,
-    data: {},
-    raw: null,
-    headers: null,
-    totalCount: null,
-    duration: [0, 123000]
+```javascript
+const FuseCore = require('fuse-core-express');
+const path = require('path');
+
+async function initializeFuseCore() {
+    try {
+        // Decryption initialization
+        const privateKeyPath = path.join(__dirname, 'keys/recipient-keys-1.0.3.json');
+        await FuseCore.initDecryption(privateKeyPath);
+        
+        // FuseCore initialization
+        await FuseCore.init({
+            log: { level: 'info' },
+            cache: { type: 'memory' }
+        });
+        
+        // Use FuseCore...
+        console.log('FuseCore initialized successfully');
+        
+    } catch (error) {
+        console.error('Failed to initialize FuseCore:', error.message);
+        process.exit(1);
+    }
 }
 
+initializeFuseCore();
 ```
 
-* ok:       (bool) indicates request is successful.
-* status:   (number) http response code from backend server.
-* message:  (string) error message when exception or error happened.
-* error:    (Error) Error object,if exists.
-* data:     (*) parsed server response content.Object if content-type option set "json",string if content-type set something else. 
-* raw:      (string) original server response text,null when calling proxy method.
-* headers:  (object) response headers.
-* duration  (array) \[seconds,nanoseconds\], time used from request start to finish.
-* totalCount: (number) same value of response's headers\["X-Total-Count"\],null if header not exists.
-
-
-##### Ajax.request
-
-```
-FuseCore.ajax.request({
-        server: 'property',
-        version: 'v4.6',
-        timeout: 3000,
-        path: path,
-        method: 'POST',
-        isWeb:true,
-        req: req, 
-        performance: false,
-        proxy: 'http://someuser:password@127.0.0.1:7666',
-        headers: {
-            'origin': 'https://property-staging.nestia.com'
-        }
-    }).then((data) => {
-        res.render('somepage',data.data);
-    }, (err) => {
-        req.app.locals.logger.error('error request backend API:' + err.message, err);
-        if (err.status) {
-            res.status(err.status).end();
-        }else{
-            res.status(500).end();
-        }
-    });
-```
-
-##### Ajax.proxy
-
-```
-FuseCore.ajax.proxy({
-        server: 'property',
-        path: path,
-        method: 'POST',
-        isWeb:true,
-        req: req,
-        res: res,
-        headers: {
-            'origin': 'https://property-staging.nestia.com'
-        }
-    }).then((data) => {
-    }, (err) => {
-        FuseCore.logger.error('error upload property image:' + err.message, err);
-        if (!err.status) {
-            res.status(500).end();
-        }
-    });
-```
+### 2. ES Module Environment
 
-##### Ajax.requestAll
+```javascript
+import FuseCore from 'fuse-core-express';
+import path from 'path';
+import { fileURLToPath } from 'url';
 
-* This method is a little like Promise.all
-* When one of requests fails,you will always get a resolve callback, which is different from Promise.all.
-* You can use data\[n\].ok to check whether request fails, and also you can get status, and raw data if exists.
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-```
-FuseCore.ajax.request([
-    {
-        server: 'property',
-        version: 'v4.6',
-        timeout: 3000,
-        path: '/nearby'
-    },
-    {
-        server: 'news',
-        version: 'v4.8',
-        path: '/news'
-    }
-]).then((datas) => {
-        let propertyData=datas[0];
-        let newsData=datas[1];
+async function initializeFuseCore() {
+    try {
+        // Decryption initialization
+        const privateKeyPath = path.join(__dirname, 'keys/recipient-keys-1.0.3.json');
+        await FuseCore.initDecryption(privateKeyPath);
         
-        //assume property backend never fails.
-        if(!newsData.ok){
-            //news api fails
-            res.render('onlyProperty',propertyData.data);        
-        }else{        
-            res.render('fullContent',{property:propertyData.data,news:newsData.data});
-        }
-    });
-```
-
-#### Cache
-
-FuseCore supports two cache implementations: memory cache (memory) and Redis cache (redis).
-
-##### Memory Cache (Default)
-
-```javascript
-let FuseCore = require('fuse-core-express');
-
-// Initialize with memory cache
-await FuseCore.init({
-    cache: {
-        impl: 'memory'
+        // FuseCore initialization
+        await FuseCore.init({
+            log: { level: 'info' },
+            cache: { type: 'memory' }
+        });
+        
+        // Use FuseCore...
+        console.log('FuseCore initialized successfully');
+        
+    } catch (error) {
+        console.error('Failed to initialize FuseCore:', error.message);
+        process.exit(1);
     }
-});
+}
 
-let cache = FuseCore.cache;
-// Set a cache
-// timeout is numeric represents seconds, default value is 300 seconds.
-// when timeout is negative number, the cache record will never expire.
-await cache.set('propName', 'propValue', 30);
+initializeFuseCore();
+```
 
-// Get value
-let val = await cache.get('propName');
-console.log(val); // 'propValue'
+## ⚠️ Security Considerations
 
-// Memory cache cleanup has 60 seconds deviation
-setTimeout(async function(){
-    let val = await cache.get('propName');
-    console.log(val); // should be null 
-}, 30 * 1000 + 60000);
+### Development Environment
 
-// Setting null value deletes the key
-await cache.set('anotherPropName', 'anotherPropValue', 30);
-await cache.set('anotherPropName', null, 30); // This deletes the key
+- ✅ Can use bundled key files for rapid development
+- ✅ Key files are already included in the npm package, ready to use
 
-let val = await cache.get('anotherPropName');
-console.log(val); // null
-```
+### Production Environment
 
-##### Redis Cache
+- 🔐 **Do not expose private keys on the client side**
+- 🔐 **Use environment variables or key management services**
+- 🔐 **Rotate keys regularly**
+- 🔐 **Monitor key usage**
+- 🔐 **Restrict access permissions to key files**
 
-Use Redis as cache storage, supporting distributed caching and persistence.
-
-**Configure Redis Cache:**
+### Recommended Production Configuration
 
 ```javascript
-let FuseCore = require('fuse-core-express');
-
-// Initialize with Redis cache
-await FuseCore.init({
-    cache: {
-        impl: 'redis',
-        redis: {
-            url: 'redis://localhost:6379',           // Redis connection URL
-            enableTls: false,                        // Enable TLS/SSL connection
-            clientOptions: {                         // Additional Redis client options
-                // Optional configuration, such as password, database, etc.
-                // password: 'your-password',
-                // database: 0
-            }
-        }
-    }
-});
-
-// Example with TLS enabled
-await FuseCore.init({
-    cache: {
-        impl: 'redis',
-        redis: {
-            url: 'redis://redis-server:6380',        // Redis server URL
-            enableTls: true,                         // Enable TLS/SSL connection
-            clientOptions: {
-                // Additional TLS options if needed
-                // password: 'your-password',
-                // database: 0
-            }
-        }
+// Production environment recommended to use environment variables
+if (process.env.NODE_ENV === 'production') {
+    // Ensure environment variables are set
+    if (!process.env.FUSECORE_RECIPIENT_PRIVATE_KEY) {
+        throw new Error('FUSECORE_RECIPIENT_PRIVATE_KEY environment variable is required in production');
     }
-});
+    await FuseCore.initDecryption(); // Automatically use environment variables
+} else {
+    // Development environment use bundled keys
+    const privateKeyPath = path.join(__dirname, 'keys/recipient-keys-1.0.3.json');
+    await FuseCore.initDecryption(privateKeyPath);
+}
 ```
 
-**Redis Connection URL Format:**
+## 🛠️ Troubleshooting
 
-```
-redis://[:password@]host[:port][/database]
-redis://localhost:6379                    // Local Redis, default port
-redis://:mypassword@localhost:6379/1      // With password, using database 1
-redis://redis-server:6379                 // Remote Redis server
-rediss://ssl-redis-server:6380            // SSL encrypted connection
-redis://tls-redis-server:6380             // TLS enabled connection (with enableTls: true)
-```
+### Common Errors
 
-**Basic Usage:**
+#### 1. "FuseCore not decrypted. Call initDecryption(privateKeyPath) first."
 
-```javascript
-let cache = FuseCore.cache;
+**Cause**: Used FuseCore methods without calling `initDecryption()` first
 
-// Set cache (asynchronous operation)
-await cache.set('user:123', { name: 'John', age: 30 }, 3600); // Expires in 1 hour
-await cache.set('session:abc', 'session-data', 0);           // Never expires
+**Solution**: Ensure to call `await FuseCore.initDecryption(privateKeyPath)` first
 
-// Get cache
-let user = await cache.get('user:123');
-console.log(user); // { name: 'John', age: 30 }
+#### 2. "Private key not found: /path/to/key.json"
 
-// Important: Type preservation (JSON strings are not automatically parsed into objects)
-await cache.set('json-string', '{"name":"John"}');  // Store JSON string
-let jsonStr = await cache.get('json-string');       // Retrieved is still a string
-console.log(typeof jsonStr);                        // "string"
+**Cause**: Private key file path is incorrect or file doesn't exist
 
-// Delete cache
-await cache.set('user:123', null); // Delete key
+**Solution**: 
+- Check if the file path is correct
+- Ensure the file exists and is readable
+- Use absolute path or correct relative path
 
-// Check if key exists (Redis-specific method)
-let exists = await cache.exists('user:123');
-console.log(exists); // false
+#### 3. "Signature verification failed"
 
-// Set expiration time (Redis-specific method)
-await cache.set('temp:data', 'some-value');
-await cache.expire('temp:data', 600); // Expires in 10 minutes
+**Cause**: Private key doesn't match the encrypted package, or package is corrupted
 
-// Get TTL (Redis-specific method)
-let ttl = await cache.ttl('temp:data');
-console.log(ttl); // Remaining seconds
+**Solution**:
+- Ensure using the correct version of key files
+- Re-download the package or regenerate keys
 
-// Get matching keys (Redis-specific method)
-let keys = await cache.keys('user:*');
-console.log(keys); // ['user:123', 'user:456', ...]
+#### 4. "Key files not found in either ./keys/ or ../keys/ directories"
 
-// Clear all cache (Redis-specific method)
-await cache.flushAll();
-```
+**Cause**: Cannot find the corresponding signer public key file
 
-**Error Handling:**
+**Solution**: Ensure the `signer-keys-{version}.json` file exists in the keys directory
 
-```javascript
-try {
-    await cache.set('mykey', 'myvalue');
-    let value = await cache.get('mykey');
-} catch (error) {
-    console.error('Cache operation failed:', error);
-}
-```
-
-**Close Connection:**
-
-```javascript
-// FuseCore will automatically close Redis connection when the application shuts down
-await FuseCore.shutdown();
-```
+## 📚 More Examples
 
----
+Check the `example-usage.js` file for complete usage examples.
 
-## 📄 License
-
-**FuseCore** follows the [MIT License](LICENSE) open source license.
-
-### MIT License
-
-Copyright (c) 2024 Ds.3783
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+## 🔗 Related Links
 
+- [FuseCore Standard Version Documentation](https://github.com/ds3783/FuseCore)
+- [Key Management Best Practices](./keys/README.md)
 
+## 📞 Support
 
+If you encounter issues during use, please:
 
+1. Check the troubleshooting section of this documentation
+2. Review the `example-usage.js` examples
+3. Submit an Issue to the project repository
 
+---
 
+**Version**: 1.0.3  
+**Last Updated**: 2025-08-02  
+**Encryption Algorithm**: AES-256-GCM + RSA-OAEP + RSA-PSS-SHA256