ACacheProvider Abstract Class

import { ACacheProvider, CacheProviderFactory, type ICacheEntry } from '@katlux/providers'

export class CMyCustomCache extends ACacheProvider {
    private static instance: CMyCustomCache | null = null
    private storage = new Map<string, ICacheEntry<any>>()

    public static getInstance(): CMyCustomCache {
        if (!this.instance) this.instance = new CMyCustomCache()
        return this.instance
    }

    async getKeyList(nuxtApp?: any): Promise<string[]> {
        return Array.from(this.storage.keys())
    }

    async get<T>(key: string, nuxtApp?: any): Promise<T | null> {
        const entry = this.storage.get(key)
        if (!entry) return null
        if (Date.now() > entry.timestamp + entry.lifetime) {
            this.storage.delete(key)
            return null
        }
        return entry.data as T
    }

    async set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void> {
        this.storage.set(key, { data, timestamp: Date.now(), lifetime })
    }

    async remove(key: string, nuxtApp?: any): Promise<void> {
        this.storage.delete(key)
    }

    async removeByPrefix(prefix: string, nuxtApp?: any): Promise<void> {
        for (const key of this.storage.keys()) {
            if (key.startsWith(prefix)) this.storage.delete(key)
        }
    }

    async getRemainingTime(key: string, nuxtApp?: any): Promise<number | null> {
        const entry = this.storage.get(key)
        if (!entry) return null
        const remaining = (entry.timestamp + entry.lifetime) - Date.now()
        return remaining > 0 ? remaining : null
    }

    async cleanupExpired(): Promise<void> {
        const now = Date.now()
        for (const [key, entry] of this.storage.entries()) {
            if (now > entry.timestamp + entry.lifetime) this.storage.delete(key)
        }
    }
}

// Register with the factory:
CacheProviderFactory.registerDriver('MyCustom', CMyCustomCache)