@katlux/providers 0.1.0-beta.0

package/services/CacheProvider/CMemoryCache.ts

@@ -0,0 +1,185 @@
+import { ACacheProvider } from './ACacheProvider'
+import type { ICacheEntry } from '../types'
+
+export class CMemoryCache extends ACacheProvider {
+	private static instance: CMemoryCache | null = null
+	private static _storage: Map<string, ICacheEntry<any>> | null = null
+
+	private static get storage(): Map<string, ICacheEntry<any>> {
+		if (!this._storage) this._storage = new Map()
+		return this._storage
+	}
+
+	public static getInstance(): CMemoryCache {
+		if (!this.instance) {
+			this.instance = new CMemoryCache()
+		}
+		return this.instance
+	}
+
+	private constructor() {
+		super()
+		if (import.meta.client && CMemoryCache.storage.size === 0) {
+			this._hydrateFromPayload()
+		}
+	}
+
+	private _hydrateFromPayload() {
+		try {
+			const nuxtApp = typeof useNuxtApp === 'function' ? useNuxtApp() : null
+			const payloadData = nuxtApp?.payload?.data || (globalThis as any).__NUXT__?.payload?.data
+			if (!payloadData) return
+
+			for (const key in payloadData) {
+				const value = payloadData[key]
+				if (value && typeof value === 'object' && 'data' in value && 'timestamp' in value && 'lifetime' in value) {
+					if (typeof (value as any).lifetime === 'number') {
+						CMemoryCache.storage.set(key, value as ICacheEntry<any>)
+					}
+				}
+			}
+		} catch (e) {
+			// Silent fail
+		}
+	}
+
+	async getKeyList(nuxtApp?: any): Promise<Array<string>> {
+		const prefix = 'cache:'
+		return Array.from(CMemoryCache.storage.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) {
+			const entry = CMemoryCache.storage.get(prefixedKey)
+			if (entry) {
+				if (Date.now() - entry.timestamp <= entry.lifetime) {
+					return entry.data as T
+				} else {
+					CMemoryCache.storage.delete(prefixedKey)
+				}
+			}
+		}
+
+		// 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) {
+						CMemoryCache.storage.set(prefixedKey, 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) {
+			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) {
+			CMemoryCache.storage.set(prefixedKey, entry)
+		}
+	}
+
+	async remove(key: string, nuxtApp?: any): Promise<void> {
+		const prefixedKey = 'cache:' + key
+		CMemoryCache.storage.delete(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
+
+		const keysToDelete: string[] = []
+		for (const key of CMemoryCache.storage.keys()) {
+			if (key.startsWith(fullPrefix)) {
+				keysToDelete.push(key)
+			}
+		}
+		for (const key of keysToDelete) {
+			CMemoryCache.storage.delete(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> {
+		const prefixedKey = 'cache:' + key
+		const entry = CMemoryCache.storage.get(prefixedKey)
+		if (!entry) return null
+		return Math.max(0, (entry.timestamp + entry.lifetime) - Date.now())
+	}
+
+	async cleanupExpired(): Promise<void> {
+		const prefix = 'cache:'
+		const now = Date.now()
+		const keysToDelete: string[] = []
+
+		for (const [key, entry] of CMemoryCache.storage.entries()) {
+			if (key.startsWith(prefix)) {
+				if (now - entry.timestamp > entry.lifetime) {
+					keysToDelete.push(key)
+				}
+			}
+		}
+
+		for (const key of keysToDelete) {
+			CMemoryCache.storage.delete(key)
+		}
+	}
+}

package/services/CacheProvider/CSessionCache.ts

@@ -0,0 +1,378 @@
+import { ACacheProvider } from './ACacheProvider'
+import type { ICacheEntry } from '../types'
+import { CCookieCache } from './CCookieCache'
+
+export class CSessionCache extends ACacheProvider {
+	private static instance: CSessionCache | null = null
+
+	public static getInstance(): CSessionCache {
+		if (!this.instance) {
+			this.instance = new CSessionCache()
+		}
+		return this.instance
+	}
+
+	// Use global symbol to share storage across module instances (API vs App)
+	private static get storage(): Map<string, Map<string, ICacheEntry<any>>> {
+		const globalKey = Symbol.for('Katlux_CSessionCache_Storage')
+		const _global = globalThis as any
+		if (!_global[globalKey]) {
+			_global[globalKey] = new Map<string, Map<string, ICacheEntry<any>>>()
+		}
+		return _global[globalKey]
+	}
+
+	public static getSnapshot(): Map<string, Map<string, ICacheEntry<any>>> {
+		return this.storage
+	}
+
+	private sessionIdCache: ACacheProvider | null = null
+	private sessionId: string | null = null
+	private readonly SESSION_ID_KEY = '_session_id'
+
+	private constructor() {
+		super()
+		// Use cookie cache for storing sessionId on client via Singleton
+		this.sessionIdCache = CCookieCache.getInstance()
+	}
+
+	/**
+	 * Generate a UUID v4 sessionId
+	 */
+	private generateSessionId(): string {
+		return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+			const r = Math.random() * 16 | 0
+			const v = c === 'x' ? r : (r & 0x3 | 0x8)
+			return v.toString(16)
+		})
+	}
+
+	/**
+	 * Get or create sessionId
+	 */
+	private async getSessionId(nuxtApp?: any): Promise<string> {
+		if (this.sessionId) {
+			return this.sessionId
+		}
+
+		if (!this.sessionIdCache) {
+			return this.generateSessionId()
+		}
+
+		// Try to get existing sessionId from cookie
+		const existingId = await this.sessionIdCache.get<string>(this.SESSION_ID_KEY, nuxtApp)
+
+		if (existingId) {
+			this.sessionId = existingId
+			return existingId
+		}
+
+		// Generate new sessionId
+		const newId = this.generateSessionId()
+		this.sessionId = newId
+
+		// Store in cookie (1 year lifetime)
+		if (this.sessionIdCache) {
+			await this.sessionIdCache.set(this.SESSION_ID_KEY, newId, 365 * 24 * 60 * 60 * 1000, nuxtApp)
+		}
+
+		return newId
+	}
+
+	async getKeyList(nuxtApp?: any): Promise<Array<string>> {
+		const prefix = 'cache:'
+
+		// Client: Use browser sessionStorage
+		if (import.meta.client) {
+			return Object.keys(sessionStorage)
+				.filter(key => key.startsWith(prefix))
+				.map(key => key.substring(prefix.length))
+		}
+
+		// Server: Use session storage (Map)
+		const sessionId = await this.getSessionId(nuxtApp)
+		const sessionData = CSessionCache.storage.get(sessionId)
+		if (!sessionData) {
+			return []
+		}
+
+		return Array.from(sessionData.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
+
+		// Client: Use browser sessionStorage
+		if (import.meta.client) {
+			try {
+				const stored = sessionStorage.getItem(prefixedKey)
+				if (stored) {
+					const entry: ICacheEntry<T> = JSON.parse(stored)
+					if (Date.now() - entry.timestamp <= entry.lifetime) {
+						return entry.data as T
+					} else {
+						sessionStorage.removeItem(prefixedKey)
+					}
+				}
+			} catch (e) {
+				// Serialisation error
+			}
+
+			// Check SSR Payload as fallback/hydration
+			try {
+				const payloadData = (window as any).__NUXT__?.payload?.data
+				if (payloadData && payloadData[prefixedKey]) {
+					const entry = payloadData[prefixedKey] as ICacheEntry<T>
+					if (Date.now() - entry.timestamp <= entry.lifetime) {
+						// Hydrate into sessionStorage
+						window.sessionStorage.setItem(prefixedKey, JSON.stringify(entry))
+						return entry.data
+					}
+				}
+			} catch (e) {
+				// Silent fail
+			}
+
+			return null
+		}
+
+		// Server: Retrieve from session storage (Map)
+		if (import.meta.server) {
+			const sessionId = await this.getSessionId(nuxtApp)
+			const sessionData = CSessionCache.storage.get(sessionId)
+			if (!sessionData) {
+				return null
+			}
+
+			const entry = sessionData.get(prefixedKey)
+			if (!entry) {
+				return null
+			}
+
+			// Check expiration
+			if (Date.now() - entry.timestamp <= entry.lifetime) {
+				return entry.data as T
+			} else {
+				// Remove expired entry
+				sessionData.delete(prefixedKey)
+				return null
+			}
+		}
+
+		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
+		}
+
+		// Client: Store in browser sessionStorage
+		if (import.meta.client) {
+			try {
+				sessionStorage.setItem(prefixedKey, JSON.stringify(entry))
+			} catch (e) {
+				// Quota exceeded
+			}
+		}
+
+		// Server: Store in session storage (Map) AND Payload for hydration
+		if (import.meta.server) {
+			try {
+				const sessionId = await this.getSessionId(nuxtApp)
+
+				// 1. Session Storage
+				let sessionData = CSessionCache.storage.get(sessionId)
+				if (!sessionData) {
+					sessionData = new Map<string, ICacheEntry<any>>()
+					CSessionCache.storage.set(sessionId, sessionData)
+				}
+				sessionData.set(prefixedKey, entry)
+
+				// 2. Nuxt Payload (for hydration into client's sessionStorage)
+				if (nuxtApp) {
+					const payload = (nuxtApp as any).payload?.data || (nuxtApp as any).ssrContext?.payload?.data
+					if (payload) {
+						payload[prefixedKey] = entry
+					}
+				}
+			} catch (e) {
+				// Silent fail
+			}
+		}
+	}
+
+	async remove(key: string, nuxtApp?: any): Promise<void> {
+		const prefixedKey = 'cache:' + key
+
+		if (import.meta.client) {
+			sessionStorage.removeItem(prefixedKey)
+		}
+
+		if (import.meta.server) {
+			try {
+				// 1. Session storage
+				const sessionId = await this.getSessionId(nuxtApp)
+				const sessionData = CSessionCache.storage.get(sessionId)
+				if (sessionData) {
+					sessionData.delete(prefixedKey)
+				}
+
+				// 2. Payload cleanup
+				if (nuxtApp) {
+					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
+
+		// Client: Iterate sessionStorage
+		if (import.meta.client) {
+			const keysToDelete: string[] = []
+			for (let i = 0; i < sessionStorage.length; i++) {
+				const key = sessionStorage.key(i)
+				if (key && key.startsWith(fullPrefix)) {
+					keysToDelete.push(key)
+				}
+			}
+			for (const key of keysToDelete) {
+				sessionStorage.removeItem(key)
+			}
+		}
+
+		// Server: Iterate session map
+		if (import.meta.server) {
+			try {
+				const sessionId = await this.getSessionId(nuxtApp)
+				const sessionData = CSessionCache.storage.get(sessionId)
+
+				if (sessionData) {
+					const keysToDelete: string[] = []
+					for (const key of sessionData.keys()) {
+						if (key.startsWith(fullPrefix)) {
+							keysToDelete.push(key)
+						}
+					}
+					for (const key of keysToDelete) {
+						sessionData.delete(key)
+					}
+				}
+
+				// Payload cleanup
+				if (nuxtApp) {
+					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> {
+		const prefixedKey = 'cache:' + key
+
+		if (import.meta.client) {
+			const entryStr = sessionStorage.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
+			}
+		}
+
+		if (import.meta.server) {
+			const sessionId = await this.getSessionId(nuxtApp)
+			const sessionData = CSessionCache.storage.get(sessionId)
+			if (!sessionData) return null
+
+			const entry = sessionData.get(prefixedKey)
+			if (!entry) return null
+
+			return Math.max(0, (entry.timestamp + entry.lifetime) - Date.now())
+		}
+		return null
+	}
+
+	async cleanupExpired(): Promise<void> {
+		const prefix = 'cache:'
+		const now = Date.now()
+
+		if (import.meta.client) {
+			const keysToDelete: string[] = []
+			for (let i = 0; i < sessionStorage.length; i++) {
+				const key = sessionStorage.key(i)
+				if (key && key.startsWith(prefix)) {
+					const stored = sessionStorage.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) {
+				sessionStorage.removeItem(key)
+			}
+		}
+
+		if (import.meta.server) {
+			const sessionsToDelete: string[] = []
+
+			// Iterate through all sessions
+			for (const [sessionId, sessionData] of CSessionCache.storage.entries()) {
+				const keysToDelete: string[] = []
+
+				// Check each entry in the session
+				for (const [key, entry] of sessionData.entries()) {
+					// Only cleanup entries for this cache key
+					if (key.startsWith(prefix)) {
+						if (now - entry.timestamp > entry.lifetime) {
+							keysToDelete.push(key)
+						}
+					}
+				}
+
+				// Remove expired entries
+				for (const key of keysToDelete) {
+					sessionData.delete(key)
+				}
+
+				// If session is empty, mark for deletion
+				if (sessionData.size === 0) {
+					sessionsToDelete.push(sessionId)
+				}
+			}
+
+			// Remove empty sessions
+			for (const sessionId of sessionsToDelete) {
+				CSessionCache.storage.delete(sessionId)
+			}
+		}
+	}
+}

package/services/CacheProvider/CacheProviderFactory.ts

@@ -0,0 +1,22 @@
+import { ECacheStrategy } from '../types'
+import { ACacheProvider } from './ACacheProvider'
+import { CApplicationCache } from './CApplicationCache'
+import { CMemoryCache } from './CMemoryCache'
+import { CLocalStorageCache } from './CLocalStorageCache'
+import { CIndexedDBCache } from './CIndexedDBCache'
+import { CCookieCache } from './CCookieCache'
+import { CSessionCache } from './CSessionCache'
+
+export class CacheProviderFactory {
+	static getProvider(strategy: ECacheStrategy): ACacheProvider | null {
+		switch (strategy) {
+			case ECacheStrategy.Application: return CApplicationCache.getInstance()
+			case ECacheStrategy.Session: return CSessionCache.getInstance()
+			case ECacheStrategy.Memory: return CMemoryCache.getInstance()
+			case ECacheStrategy.LocalStorage: return CLocalStorageCache.getInstance()
+			case ECacheStrategy.IndexedDB: return CIndexedDBCache.getInstance()
+			case ECacheStrategy.Cookie: return CCookieCache.getInstance()
+			default: return null
+		}
+	}
+}

package/services/DataProvider/AAPIDataProvider.ts

@@ -0,0 +1,24 @@
+import { ref, type Ref } from 'vue'
+import { ECacheStrategy } from '../types';
+import type { IDataProviderOptions } from '../types';
+import { RequestProvider } from '../RequestProvider/RequestProvider';
+
+export abstract class AAPIDataProvider {
+
+	apiUrl: Ref<string> = ref("")
+	cacheStrategy: Ref<ECacheStrategy | null> = ref(null)
+	cacheLifetime: Ref<number> = ref(60 * 1000)
+	requestProvider: RequestProvider = new RequestProvider()
+	refreshOnMutation: Ref<boolean | undefined> = ref(undefined)
+
+	constructor(options?: IDataProviderOptions) {
+		if (options?.cacheStrategy) this.cacheStrategy.value = options.cacheStrategy
+		if (options?.cacheLifetime) this.cacheLifetime.value = options.cacheLifetime
+		if (options?.refreshOnMutation !== undefined) this.refreshOnMutation.value = options.refreshOnMutation
+	}
+	abstract setAPIUrl(url: string): void
+	abstract create(item: any): Promise<void>
+	abstract update(item: any): Promise<void>
+	abstract delete(items: any[]): Promise<void>
+}
+