@katlux/providers 0.1.0-beta.0

package/services/CacheProvider/CIndexedDBCache.ts

@@ -0,0 +1,312 @@
+import { ACacheProvider } from './ACacheProvider'
+import type { ICacheEntry } from '../types'
+
+export class CIndexedDBCache extends ACacheProvider {
+	private static instance: CIndexedDBCache | null = null
+
+	public static getInstance(): CIndexedDBCache {
+		if (!this.instance) {
+			this.instance = new CIndexedDBCache()
+		}
+		return this.instance
+	}
+
+	private dbName = 'KatluxDB'
+	private storeName = 'cache'
+	private version = 2
+	private dbPromise: Promise<IDBDatabase> | null = null
+
+	public setStore(storeName: string = "cache") {
+		this.storeName = storeName || 'cache'
+		if (import.meta.client) {
+			this.dbPromise = this.openDB()
+			this._hydrateFromPayload()
+		}
+	}
+
+	private constructor() {
+		super()
+		this.setStore()
+	}
+
+	private _hydrateFromPayload() {
+		try {
+			const nuxtApp = typeof useNuxtApp === 'function' ? useNuxtApp() : null
+			const payloadData = nuxtApp?.payload?.data || (globalThis as any).__NUXT__?.payload?.data
+			if (!payloadData) return
+
+			const prefix = 'cache:'
+			let count = 0
+			for (const key in payloadData) {
+				if (key.startsWith(prefix)) {
+					const value = payloadData[key]
+					if (value && typeof value === 'object' && 'data' in value && 'timestamp' in value && 'lifetime' in value) {
+						this.dbPromise?.then(async (db) => {
+							try {
+								const tx = db.transaction(this.storeName, 'readwrite')
+								const store = tx.objectStore(this.storeName)
+								store.put(value, key)
+								tx.commit?.()
+							} catch (e) {
+								// Silent fail
+							}
+						})
+						count++
+					}
+				}
+			}
+			if (count > 0) console.log(`[CIndexedDBCache] Hydrated ${count} entries from payload`)
+		} catch (e) {
+			// Silent fail
+		}
+	}
+
+	private openDB(): Promise<IDBDatabase> {
+		return new Promise((resolve, reject) => {
+			const request = indexedDB.open(this.dbName, this.version)
+			request.onerror = () => reject(request.error)
+			request.onsuccess = () => resolve(request.result)
+			request.onupgradeneeded = (event) => {
+				const db = (event.target as IDBOpenDBRequest).result
+				if (!db.objectStoreNames.contains(this.storeName)) {
+					db.createObjectStore(this.storeName)
+				}
+			}
+		})
+	}
+
+	private async getStore(mode: IDBTransactionMode): Promise<IDBObjectStore> {
+		if (!this.dbPromise) return Promise.reject("IndexedDB not initialized")
+		const db = await this.dbPromise
+		return db.transaction(this.storeName, mode).objectStore(this.storeName)
+	}
+
+	async getKeyList(nuxtApp?: any): Promise<Array<string>> {
+		if (!import.meta.client || !this.dbPromise) return []
+		const db = await this.dbPromise
+		const store = db.transaction(this.storeName, 'readonly').objectStore(this.storeName)
+		const keys = await new Promise<string[]>((resolve, reject) => {
+			const req = store.getAllKeys()
+			req.onsuccess = () => resolve(req.result as string[])
+			req.onerror = () => reject(req.error)
+		})
+		const prefix = 'cache:'
+		return keys
+			.filter(key => key.startsWith(prefix))
+			.map(key => key.substring(prefix.length))
+	}
+
+	async get<T>(key: string, nuxtApp?: any): Promise<T | null> {
+		const prefixedKey = 'cache:' + key
+
+		if (import.meta.client) {
+			try {
+				const store = await this.getStore('readonly')
+				const data = await new Promise<ICacheEntry<T> | undefined>((resolve, reject) => {
+					const req = store.get(prefixedKey)
+					req.onsuccess = () => resolve(req.result)
+					req.onerror = () => reject(req.error)
+				})
+
+				if (data) {
+					if (Date.now() - data.timestamp <= data.lifetime) {
+						console.log(`[CIndexedDBCache] GET SUCCESS: ${key}`)
+						return data.data
+					} else {
+						console.log(`[CIndexedDBCache] EXPIRED: ${key}`)
+						const writeStore = await this.getStore('readwrite')
+						writeStore.delete(prefixedKey)
+					}
+				} else {
+					console.log(`[CIndexedDBCache] NOT IN DB: ${key}`)
+				}
+			} catch (e) {
+				// Silent fail
+			}
+		}
+
+		// Check SSR Payload
+		try {
+			let payloadData: any = null
+			if (import.meta.client) {
+				payloadData = (globalThis as any).__NUXT__?.payload?.data
+			} else if (nuxtApp) {
+				payloadData = (nuxtApp as any).payload?.data || (nuxtApp as any).ssrContext?.payload?.data
+			}
+
+			if (payloadData && payloadData[prefixedKey]) {
+				const entry = payloadData[prefixedKey] as ICacheEntry<T>
+				if (Date.now() - entry.timestamp <= entry.lifetime) {
+					if (import.meta.client) {
+						this.set(key, entry.data, entry.lifetime, nuxtApp)
+					}
+					return entry.data
+				}
+			}
+		} catch (e) {
+			// Silent fail
+		}
+
+		return null
+	}
+
+	async set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void> {
+		const prefixedKey = 'cache:' + key
+		const entry: ICacheEntry<T> = {
+			data,
+			timestamp: Date.now(),
+			lifetime
+		}
+
+		if (import.meta.server && nuxtApp) {
+			try {
+				const payload = (nuxtApp as any).payload?.data || (nuxtApp as any).ssrContext?.payload?.data
+				if (payload) {
+					payload[prefixedKey] = entry
+				}
+			} catch (e) {
+				// Silent fail
+			}
+		}
+
+		if (import.meta.client) {
+			try {
+				const store = await this.getStore('readwrite')
+				await new Promise<void>((resolve, reject) => {
+					const req = store.put(entry, prefixedKey)
+					req.onsuccess = () => resolve()
+					req.onerror = () => reject(req.error)
+				})
+			} catch (e) {
+				// Silent fail
+			}
+		}
+	}
+
+	async remove(key: string, nuxtApp?: any): Promise<void> {
+		const prefixedKey = 'cache:' + key
+		if (import.meta.client) {
+			try {
+				const store = await this.getStore('readwrite')
+				await new Promise<void>((resolve, reject) => {
+					const req = store.delete(prefixedKey)
+					req.onsuccess = () => resolve()
+					req.onerror = () => reject(req.error)
+				})
+			} catch (e) {
+				// Silent fail
+			}
+		}
+		if (import.meta.server && nuxtApp) {
+			try {
+				const payload = (nuxtApp as any).payload?.data || (nuxtApp as any).ssrContext?.payload?.data
+				if (payload && payload[prefixedKey]) {
+					delete payload[prefixedKey]
+				}
+			} catch (e) {
+				// Silent fail
+			}
+		}
+	}
+
+	async removeByPrefix(prefix: string, nuxtApp?: any): Promise<void> {
+		const fullPrefix = 'cache:' + prefix
+		if (import.meta.client) {
+			try {
+				const store = await this.getStore('readwrite')
+				const allKeys = await new Promise<string[]>((resolve, reject) => {
+					const req = store.getAllKeys()
+					req.onsuccess = () => resolve(req.result as string[])
+					req.onerror = () => reject(req.error)
+				})
+
+				const keysToDelete = allKeys.filter(k => k.startsWith(fullPrefix))
+
+				for (const key of keysToDelete) {
+					await new Promise<void>((resolve, reject) => {
+						const req = store.delete(key)
+						req.onsuccess = () => resolve()
+						req.onerror = () => reject(req.error)
+					})
+				}
+			} catch (e) {
+				// Silent fail
+			}
+		}
+		if (import.meta.server && nuxtApp) {
+			try {
+				const payload = (nuxtApp as any).payload?.data || (nuxtApp as any).ssrContext?.payload?.data
+				if (payload) {
+					for (const key in payload) {
+						if (key.startsWith(fullPrefix)) {
+							delete payload[key]
+						}
+					}
+				}
+			} catch (e) {
+				// Silent fail
+			}
+		}
+	}
+
+	async getRemainingTime(key: string, nuxtApp?: any): Promise<number | null> {
+		if (import.meta.client) {
+			try {
+				const prefixedKey = 'cache:' + key
+				const store = await this.getStore('readonly')
+				const entry = await new Promise<ICacheEntry<any> | undefined>((resolve, reject) => {
+					const req = store.get(prefixedKey)
+					req.onsuccess = () => resolve(req.result)
+					req.onerror = () => reject(req.error)
+				})
+
+				if (!entry) return null
+				return Math.max(0, (entry.timestamp + entry.lifetime) - Date.now())
+			} catch (e) {
+				return null
+			}
+		}
+		return null
+	}
+
+	async cleanupExpired(): Promise<void> {
+		if (import.meta.client && this.dbPromise) {
+			try {
+				const prefix = 'cache:'
+				const now = Date.now()
+				const keysToDelete: string[] = []
+
+				const store = await this.getStore('readwrite')
+				const allKeys = await new Promise<string[]>((resolve, reject) => {
+					const req = store.getAllKeys()
+					req.onsuccess = () => resolve(req.result as string[])
+					req.onerror = () => reject(req.error)
+				})
+
+				for (const key of allKeys) {
+					if (key.startsWith(prefix)) {
+						const entry = await new Promise<ICacheEntry<any> | undefined>((resolve, reject) => {
+							const req = store.get(key)
+							req.onsuccess = () => resolve(req.result)
+							req.onerror = () => reject(req.error)
+						})
+
+						if (entry && now - entry.timestamp > entry.lifetime) {
+							keysToDelete.push(key)
+						}
+					}
+				}
+
+				for (const key of keysToDelete) {
+					await new Promise<void>((resolve, reject) => {
+						const req = store.delete(key)
+						req.onsuccess = () => resolve()
+						req.onerror = () => reject(req.error)
+					})
+				}
+			} catch (e) {
+				// Silent fail
+			}
+		}
+	}
+}

package/services/CacheProvider/CLocalStorageCache.ts

@@ -0,0 +1,232 @@
+import { ACacheProvider } from './ACacheProvider'
+import type { ICacheEntry } from '../types'
+
+export class CLocalStorageCache extends ACacheProvider {
+	private static instance: CLocalStorageCache | null = null
+
+	public static getInstance(): CLocalStorageCache {
+		if (!this.instance) {
+			this.instance = new CLocalStorageCache()
+		}
+		return this.instance
+	}
+
+	public type = 'LocalStorage'
+
+	private constructor() {
+		super()
+		if (import.meta.client) {
+			this._hydrateFromPayload()
+		}
+	}
+
+	private _hydrateFromPayload() {
+		try {
+			const nuxtApp = typeof useNuxtApp === 'function' ? useNuxtApp() : null
+			const payloadData = nuxtApp?.payload?.data || (window as any).__NUXT__?.payload?.data
+			if (!payloadData) return
+
+			const prefix = 'cache:'
+			let count = 0
+			for (const key in payloadData) {
+				if (key.startsWith(prefix)) {
+					const value = payloadData[key]
+					if (value && typeof value === 'object' && 'data' in value && 'timestamp' in value && 'lifetime' in value) {
+						try {
+							localStorage.setItem(key, JSON.stringify(value))
+							count++
+						} catch (e) {
+							// Ignore quota errors
+						}
+					}
+				}
+			}
+			if (count > 0) console.log(`[CLocalStorageCache] Hydrated ${count} entries from payload`)
+		} catch (e) {
+			// Silent fail
+		}
+	}
+
+	async getKeyList(nuxtApp?: any): Promise<Array<string>> {
+		if (!import.meta.client) return []
+		const prefix = 'cache:'
+		return Object.keys(localStorage)
+			.filter(key => key.startsWith(prefix))
+			.map(key => key.substring(prefix.length))
+	}
+
+	async get<T>(key: string, nuxtApp?: any): Promise<T | null> {
+		const prefixedKey = 'cache:' + key
+
+		if (import.meta.client) {
+			try {
+				// 1. Check LocalStorage
+				const stored = localStorage.getItem(prefixedKey)
+				if (stored) {
+					const entry: ICacheEntry<T> = JSON.parse(stored)
+					if (Date.now() - entry.timestamp <= entry.lifetime) {
+						console.log(`[CLocalStorageCache] GET SUCCESS: ${key}`)
+						return entry.data
+					} else {
+						console.log(`[CLocalStorageCache] EXPIRED: ${key}`)
+						localStorage.removeItem(prefixedKey)
+					}
+				} else {
+					console.log(`[CLocalStorageCache] NOT IN STORAGE: ${key}`)
+				}
+			} catch (e) {
+				// Serialisation error
+			}
+		}
+
+		// 2. Check SSR Payload (Hydration/Request Scoped Reuse)
+		// On server, payload is in nuxtApp. On client, it's also in nuxtApp if passed, or window.__NUXT__
+		try {
+			let payloadData: any = null
+			if (import.meta.client) {
+				payloadData = (window as any).__NUXT__?.payload?.data
+			} else if (nuxtApp) {
+				payloadData = (nuxtApp as any).payload?.data || (nuxtApp as any).ssrContext?.payload?.data
+			}
+
+			if (payloadData && payloadData[prefixedKey]) {
+				const entry = payloadData[prefixedKey] as ICacheEntry<T>
+				if (Date.now() - entry.timestamp <= entry.lifetime) {
+					if (import.meta.client) {
+						localStorage.setItem(prefixedKey, JSON.stringify(entry))
+					}
+					return entry.data
+				}
+			}
+		} catch (e) {
+			// Silent fail
+		}
+
+		return null
+	}
+
+	async set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void> {
+		const prefixedKey = 'cache:' + key
+		const entry: ICacheEntry<T> = {
+			data,
+			timestamp: Date.now(),
+			lifetime
+		}
+
+		if (import.meta.server && nuxtApp) {
+			// Write to Payload for hydration
+			try {
+				const payload = (nuxtApp as any).payload?.data || (nuxtApp as any).ssrContext?.payload?.data
+				if (payload) {
+					payload[prefixedKey] = entry
+				}
+			} catch (e) {
+				// Serialisation error
+			}
+		}
+
+		if (import.meta.client) {
+			try {
+				localStorage.setItem(prefixedKey, JSON.stringify(entry))
+			} catch (e) {
+				// Quota exceeded
+			}
+		}
+	}
+
+	async remove(key: string, nuxtApp?: any): Promise<void> {
+		const prefixedKey = 'cache:' + key
+		if (import.meta.client) {
+			localStorage.removeItem(prefixedKey)
+		}
+		if (import.meta.server && nuxtApp) {
+			try {
+				const payload = (nuxtApp as any).payload?.data || (nuxtApp as any).ssrContext?.payload?.data
+				if (payload && payload[prefixedKey]) {
+					delete payload[prefixedKey]
+				}
+			} catch (e) {
+				// Silent fail
+			}
+		}
+	}
+
+	async removeByPrefix(prefix: string, nuxtApp?: any): Promise<void> {
+		const fullPrefix = 'cache:' + prefix
+		if (import.meta.client) {
+			const keysToDelete: string[] = []
+			for (let i = 0; i < localStorage.length; i++) {
+				const key = localStorage.key(i)
+				if (key && key.startsWith(fullPrefix)) {
+					keysToDelete.push(key)
+				}
+			}
+			for (const key of keysToDelete) {
+				localStorage.removeItem(key)
+			}
+		}
+		if (import.meta.server && nuxtApp) {
+			try {
+				const payload = (nuxtApp as any).payload?.data || (nuxtApp as any).ssrContext?.payload?.data
+				if (payload) {
+					for (const key in payload) {
+						if (key.startsWith(fullPrefix)) {
+							delete payload[key]
+						}
+					}
+				}
+			} catch (e) {
+				// Silent fail
+			}
+		}
+	}
+
+	async getRemainingTime(key: string, nuxtApp?: any): Promise<number | null> {
+		if (import.meta.client) {
+			const prefixedKey = 'cache:' + key
+			const entryStr = localStorage.getItem(prefixedKey)
+			if (!entryStr) return null
+
+			try {
+				const entry: ICacheEntry<any> = JSON.parse(entryStr)
+				return Math.max(0, (entry.timestamp + entry.lifetime) - Date.now())
+			} catch (e) {
+				return null
+			}
+		}
+		return null
+	}
+
+	async cleanupExpired(): Promise<void> {
+		if (import.meta.client) {
+			try {
+				const prefix = 'cache:'
+				const now = Date.now()
+				const keysToDelete: string[] = []
+
+				for (let i = 0; i < localStorage.length; i++) {
+					const key = localStorage.key(i)
+					if (key && key.startsWith(prefix)) {
+						const stored = localStorage.getItem(key)
+						if (stored) {
+							try {
+								const entry: ICacheEntry<any> = JSON.parse(stored)
+								if (now - entry.timestamp > entry.lifetime) {
+									keysToDelete.push(key)
+								}
+							} catch (e) {
+								keysToDelete.push(key)
+							}
+						}
+					}
+				}
+
+				for (const key of keysToDelete) {
+					localStorage.removeItem(key)
+				}
+			} catch (e) {
+				// Silent fail
+			}
+		}
+	}
+}