@katlux/providers 0.1.0-beta.0 → 0.1.0-beta.11

package/services/CacheProvider/CSessionCache.ts

@@ -1,378 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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>
-}
-

package/services/DataProvider/ADataProvider.ts

@@ -1,126 +0,0 @@
-import { ref, type Ref } from 'vue'
-import type { TDataRow, IDataFilter, IDataSort, IDataResult, IKDatatableAction, IDataProviderOptions } from '../types'
-import { useDebounce } from '@katlux/toolkit/composables/useDebounce'
-
-// Note: In an isomorphic package, we must handle Nuxt auto-imports carefully. 
-// Standard Vue ref and watch are explicitly imported.
-import { watch } from 'vue'
-const APP_MODULE = '#app';
-// DataProvider abstract class
-export abstract class ADataProvider {
-	filter: Ref<IDataFilter | null> = ref(null)
-	sortList: Ref<IDataSort[]> = ref([])
-	currentPage: Ref<number> = ref(1)
-	pageSize: Ref<number> = ref(10)
-	pageData: Ref<TDataRow[]> = ref([])
-	rowCount: Ref<number> = ref(0)
-	loading: Ref<Boolean> = ref(false)
-	SSR: Ref<Boolean> = ref(false)
-	deduplicate: Ref<Boolean> = ref(true)
-	nuxtApp: any = null
-	urlPageParam: Ref<string> = ref('')
-	selectedRows: Ref<any[]> = ref([])
-	selectAll: Ref<boolean> = ref(false)
-
-	constructor(options?: IDataProviderOptions) {
-		if (options?.nuxtApp) {
-			this.nuxtApp = options.nuxtApp
-		} else if (import.meta.server) {
-			try {
-				import(/* @vite-ignore */ APP_MODULE).then(appModule => {
-					this.nuxtApp = appModule.useNuxtApp()
-				}).catch(() => { })
-			} catch (e) {
-				// Outside nuxt context
-			}
-		}
-
-		if (options?.filter) {
-			this.filter.value = options.filter
-		}
-		if (options?.sortList) {
-			this.sortList.value = options.sortList
-		}
-		if (options?.pageSize) {
-			this.pageSize.value = options.pageSize
-		}
-		if (options?.currentPage) {
-			this.currentPage.value = options.currentPage
-		}
-		if (options?.SSR) {
-			this.SSR.value = options.SSR
-		}
-		if (options?.deduplicate !== undefined) {
-			this.deduplicate.value = options.deduplicate
-		}
-
-		// URL-based pagination: read initial page from URL
-		if (options?.urlPageParam) {
-			this.urlPageParam.value = options.urlPageParam
-			try {
-				import(/* @vite-ignore */ APP_MODULE).then(appModule => {
-					const route = appModule.useRoute()
-					const pageFromUrl = route.query[options.urlPageParam!]
-					if (pageFromUrl) {
-						const parsedPage = parseInt(pageFromUrl as string, 10)
-						if (!isNaN(parsedPage) && parsedPage > 0) {
-							this.currentPage.value = parsedPage
-						}
-					}
-				}).catch(() => { })
-			} catch (e) {
-				// useRoute not available (outside Vue context)
-			}
-		}
-
-		// Watch for changes in currentPage and pageSize to automatically reload data
-		watch(this.currentPage, (newPage) => {
-			this.loadPageData()
-
-			// URL-based pagination: update URL when page changes (client-side only)
-			if (import.meta.client && this.urlPageParam.value) {
-				try {
-					import(/* @vite-ignore */ APP_MODULE).then(appModule => {
-						const router = appModule.useRouter()
-						const currentQuery = { ...router.currentRoute.value.query }
-						if (newPage === 1) {
-							delete currentQuery[this.urlPageParam.value]
-						} else {
-							currentQuery[this.urlPageParam.value] = String(newPage)
-						}
-						router.replace({ query: currentQuery })
-					}).catch(() => { })
-				} catch (e) {
-					// useRouter not available
-				}
-			}
-		})
-
-		watch(this.pageSize, () => {
-			this.currentPage.value = 1
-			this.loadPageData()
-		})
-
-		watch(this.filter, useDebounce(() => {
-			this.currentPage.value = 1
-			this.loadPageData()
-		}, 300))
-		watch(this.sortList, () => {
-			this.currentPage.value = 1
-			this.loadPageData()
-		})
-	}
-	setFilter(filter: IDataFilter | null) {
-		this.filter.value = filter
-	}
-	setSortList(sortList: IDataSort[]) {
-		this.sortList.value = sortList
-	}
-	setCurrentPage(currentPage: number) {
-		this.currentPage.value = currentPage
-	}
-	setPageSize(pageSize: number) {
-		this.pageSize.value = pageSize
-	}
-	abstract loadPageData(): void
-}