AdaptiveCache

Description

AdaptiveCache is a highly efficient library for adaptive caching, specifically designed for Single-Page Applications (SPA). It aims to enhance application performance through intelligent caching mechanisms, including dynamic Time-to-Live (TTL) calculation, adaptive cache size adjustments, and support for various replacement policies.

Features

1. Dynamic TTL Calculation: Adjusts TTL based on access frequency using a Poisson distribution model.
2. Adaptive Cache Resizing: Dynamically adjusts cache size based on workload and hit rate.
3. Customizable Replacement Policies: Supports FIFO, LRU, and LFU caching policies.
4. Metrics Tracking: Optionally tracks hit rates, latency, and error rates for performance analysis.
5. Seamless Integration: Easily integrates with modern JavaScript frameworks like React, Angular, and Vue.

Installation

Install the package via npm:

npm install adaptive-cache

yarn add adaptive-cache

Usage

Basic Usage

const AdaptiveCache = require('adaptive-cache');

// Initialize the cache with a limit of 100 items and global TTL of 1 minute
const cache = new AdaptiveCache({
    limit: 100,
    globalTTL: 60000,
    policy: 'LRU',
    enableMetrics: true,
});

// Fetch data with a 'cache-first' policy
const fetchData = async (key) => {
    return cache.fetchWithPolicy(
        key,
        async () => {
            // Simulate fetching data from a network
            return await fetchFromNetwork(key);
        },
        'cache-first',
        120 // Access frequency
    );
};

Advanced Usage

Dynamic TTL Calculation The TTL is dynamically calculated based on access frequency using a Poisson-based probability model. This ensures optimal caching for frequently accessed data.

cache.setWithAdaptiveTTL('key', 'value', 150);

Cache Resizing

The cache automatically adjusts its size based on hit rates and system load.

Custom Replacement Policies

Choose between FIFO, LRU, and LFU policies when initializing the cache.

const cache = new AdaptiveCache({
    policy: 'LFU',
});

API

Constructor

new AdaptiveCache(options)

• limit (number): Maximum number of items in the cache.
• globalTTL (number): Default TTL for cached items in milliseconds.
• policy (string): Replacement policy (FIFO, LRU, or LFU).
• enableMetrics (boolean): Enable or disable metrics tracking.

fetchWithPolicy(key, fetchFunction, fetchPolicy, accessFrequency, options) - Fetch data with a specified policy.

get(key) - Retrieve an item from the cache.

setWithAdaptiveTTL(key, value, accessFrequency) - Store an item in the cache with a calculated TTL.

getMetrics() - Retrieve current cache metrics (if enabled).

clear() - Clear all items from the cache.