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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@katlux/providers",
-	"version": "0.1.0-beta.0",
+	"version": "0.1.0-beta.11",
 	"description": "Core data calculation and caching providers for the Katlux ecosystem",
 	"author": "Katlux",
 	"license": "MIT",
@@ -11,7 +11,8 @@
 	"types": "./dist/index.d.ts",
 	"scripts": {
 		"build": "unbuild",
-		"dev": "unbuild --stub"
+		"dev": "unbuild --stub",
+		"prepublishOnly": "npm run build"
 	},
 	"exports": {
 		".": {
@@ -20,5 +21,8 @@
 			"require": "./dist/index.cjs"
 		}
 	},
-	"dependencies": {}
+	"dependencies": {},
+	"files": [
+		"dist"
+	]
 }

package/build.config.ts

@@ -1,4 +0,0 @@
-export default {
-	failOnWarn: false,
-	externals: ['#app', '@katlux/toolkit']
-}

package/services/CacheProvider/ACacheProvider.ts

@@ -1,13 +0,0 @@
-export abstract class ACacheProvider {
-	constructor() {
-		// Cleanup expired entries on initialization
-		this.cleanupExpired()
-	}
-	abstract getKeyList(nuxtApp?: any): Array<string> | Promise<Array<string>>
-	abstract get<T>(key: string, nuxtApp?: any): Promise<T | null>
-	abstract set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>
-	abstract remove(key: string, nuxtApp?: any): Promise<void>
-	abstract removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>
-	abstract getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>
-	abstract cleanupExpired(): Promise<void>
-}

package/services/CacheProvider/CApplicationCache.ts

@@ -1,123 +0,0 @@
-import { ACacheProvider } from './ACacheProvider'
-import type { ICacheEntry } from '../types'
-
-export class CApplicationCache extends ACacheProvider {
-	private static instance: CApplicationCache | 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<string, ICacheEntry<any>>()
-		}
-		return this._storage
-	}
-
-	public static getInstance(): CApplicationCache {
-		if (!this.instance) {
-			this.instance = new CApplicationCache()
-		}
-		return this.instance
-	}
-
-	public static getSnapshot(): Map<string, ICacheEntry<any>> {
-		return this.storage
-	}
-
-	private constructor() {
-		super()
-	}
-
-	async getKeyList(nuxtApp?: any): Promise<Array<string>> {
-		const prefix = 'cache:'
-		const storage = CApplicationCache.storage
-		return Array.from(storage.keys())
-			.filter(key => key.startsWith(prefix))
-			.map(key => key.substring(prefix.length))
-	}
-
-	async get<T>(key: string, nuxtApp?: any): Promise<T | null> {
-		if (import.meta.server) {
-			const prefixedKey = 'cache:' + key
-			const storage = CApplicationCache.storage
-			const entry = storage.get(prefixedKey)
-			if (!entry) return null
-
-			if (Date.now() - entry.timestamp > entry.lifetime) {
-				storage.delete(prefixedKey)
-				return null
-			}
-
-			return entry.data as T
-		}
-		return null
-	}
-
-	async set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void> {
-		if (import.meta.server) {
-			const prefixedKey = 'cache:' + key
-			const storage = CApplicationCache.storage
-			storage.set(prefixedKey, {
-				data,
-				timestamp: Date.now(),
-				lifetime
-			})
-		}
-	}
-
-	async remove(key: string, nuxtApp?: any): Promise<void> {
-		if (import.meta.server) {
-			const prefixedKey = 'cache:' + key
-			CApplicationCache.storage.delete(prefixedKey)
-		}
-	}
-
-	async removeByPrefix(prefix: string, nuxtApp?: any): Promise<void> {
-		if (import.meta.server) {
-			const fullPrefix = 'cache:' + prefix
-			const storage = CApplicationCache.storage
-			const keysToDelete: string[] = []
-
-			for (const key of storage.keys()) {
-				if (key.startsWith(fullPrefix)) {
-					keysToDelete.push(key)
-				}
-			}
-
-			for (const key of keysToDelete) {
-				storage.delete(key)
-			}
-		}
-	}
-
-	async getRemainingTime(key: string, nuxtApp?: any): Promise<number | null> {
-		if (import.meta.server) {
-			const prefixedKey = 'cache:' + key
-			const storage = CApplicationCache.storage
-			const entry = storage.get(prefixedKey)
-			if (!entry) return null
-			return Math.max(0, (entry.timestamp + entry.lifetime) - Date.now())
-		}
-		return null
-	}
-
-	async cleanupExpired(): Promise<void> {
-		if (import.meta.server) {
-			const prefix = 'cache:'
-			const now = Date.now()
-			const storage = CApplicationCache.storage
-			const keysToDelete: string[] = []
-
-			for (const [key, entry] of storage.entries()) {
-				if (key.startsWith(prefix)) {
-					if (now - entry.timestamp > entry.lifetime) {
-						keysToDelete.push(key)
-					}
-				}
-			}
-
-			for (const key of keysToDelete) {
-				storage.delete(key)
-			}
-		}
-	}
-}

package/services/CacheProvider/CCookieCache.ts

@@ -1,212 +0,0 @@
-import { ACacheProvider } from './ACacheProvider'
-import type { ICacheEntry } from '../types'
-
-export class CCookieCache extends ACacheProvider {
-	private static instance: CCookieCache | null = null
-
-	public static getInstance(): CCookieCache {
-		if (!this.instance) {
-			this.instance = new CCookieCache()
-		}
-		return this.instance
-	}
-
-	public type = 'Cookie'
-
-	private constructor() {
-		super()
-	}
-
-	async getKeyList(nuxtApp?: any): Promise<Array<string>> {
-		const prefix = 'cache:'
-		let cookieStr = ''
-
-		if (import.meta.client) {
-			cookieStr = document.cookie
-		} else if (nuxtApp) {
-			// Extract from H3Event or SSR Context
-			const headers = (nuxtApp as any).node?.req?.headers || (nuxtApp as any).ssrContext?.event?.node?.req?.headers
-			cookieStr = headers?.['cookie'] || ''
-		}
-
-		if (!cookieStr) return []
-
-		const keys: string[] = []
-		const cookies = cookieStr.split(';')
-		for (let i = 0; i < cookies.length; i++) {
-			const cookie = cookies[i].trim()
-			const eqPos = cookie.indexOf('=')
-			if (eqPos > 0) {
-				const name = decodeURIComponent(cookie.substring(0, eqPos))
-				if (name.startsWith(prefix)) {
-					keys.push(name.substring(prefix.length))
-				}
-			}
-		}
-		return keys
-	}
-
-	async get<T>(key: string, nuxtApp?: any): Promise<T | null> {
-		const prefixedKey = 'cache:' + key
-		let cookieValue: string | null = null
-
-		if (import.meta.client) {
-			const name = prefixedKey + '='
-			const ca = document.cookie.split(';')
-			for (let i = 0; i < ca.length; i++) {
-				let c = ca[i].trim()
-				if (c.indexOf(name) === 0) {
-					cookieValue = c.substring(name.length, c.length)
-					break
-				}
-			}
-		} else if (nuxtApp) {
-			const headers = (nuxtApp as any).node?.req?.headers || (nuxtApp as any).ssrContext?.event?.node?.req?.headers
-			const cookieStr = headers?.['cookie'] || ''
-			const name = prefixedKey + '='
-			const ca = cookieStr.split(';')
-			for (let i = 0; i < ca.length; i++) {
-				let c = ca[i].trim()
-				if (c.indexOf(name) === 0) {
-					cookieValue = c.substring(name.length, c.length)
-					break
-				}
-			}
-		}
-
-		if (!cookieValue) return null
-
-		try {
-			const val = JSON.parse(decodeURIComponent(cookieValue)) as ICacheEntry<T>
-			if (val && val.timestamp && val.lifetime) {
-				if (Date.now() - val.timestamp <= val.lifetime) {
-					return val.data
-				} else {
-					// Expired
-					await this.set(key, null as any, 0, nuxtApp)
-				}
-			}
-			return null
-		} catch (e) {
-			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
-		}
-
-		const cookieValue = encodeURIComponent(JSON.stringify(entry))
-		const maxAge = Math.floor(lifetime / 1000)
-		const expires = new Date(Date.now() + lifetime).toUTCString()
-		const cookieStr = `${prefixedKey}=${cookieValue}; Max-Age=${maxAge}; Path=/; SameSite=Lax${import.meta.server ? '; HttpOnly' : ''}`
-
-		if (import.meta.client) {
-			document.cookie = cookieStr
-		} else if (nuxtApp) {
-			const res = (nuxtApp as any).node?.res || (nuxtApp as any).ssrContext?.event?.node?.res
-			if (res) {
-				const existing = res.getHeader('Set-Cookie')
-				if (!existing) {
-					res.setHeader('Set-Cookie', cookieStr)
-				} else if (Array.isArray(existing)) {
-					res.setHeader('Set-Cookie', [...existing, cookieStr])
-				} else {
-					res.setHeader('Set-Cookie', [existing as string, cookieStr])
-				}
-			}
-		}
-	}
-
-	async remove(key: string, nuxtApp?: any): Promise<void> {
-		const prefixedKey = 'cache:' + key
-		const cookieStr = `${prefixedKey}=; Max-Age=0; Path=/; SameSite=Lax${import.meta.server ? '; HttpOnly' : ''}`
-
-		if (import.meta.client) {
-			document.cookie = cookieStr
-		} else if (nuxtApp) {
-			const res = (nuxtApp as any).node?.res || (nuxtApp as any).ssrContext?.event?.node?.res
-			if (res) {
-				const existing = res.getHeader('Set-Cookie')
-				if (!existing) {
-					res.setHeader('Set-Cookie', cookieStr)
-				} else if (Array.isArray(existing)) {
-					res.setHeader('Set-Cookie', [...existing, cookieStr])
-				} else {
-					res.setHeader('Set-Cookie', [existing as string, cookieStr])
-				}
-			}
-		}
-	}
-
-	async getRemainingTime(key: string, nuxtApp?: any): Promise<number | null> {
-		const prefixedKey = 'cache:' + key
-		let cookieValue: string | null = null
-
-		if (import.meta.client) {
-			const name = prefixedKey + '='
-			const ca = document.cookie.split(';')
-			for (let i = 0; i < ca.length; i++) {
-				let c = ca[i].trim()
-				if (c.indexOf(name) === 0) {
-					cookieValue = c.substring(name.length, c.length)
-					break
-				}
-			}
-		} else if (nuxtApp) {
-			const headers = (nuxtApp as any).node?.req?.headers || (nuxtApp as any).ssrContext?.event?.node?.req?.headers
-			const cookieStr = headers?.['cookie'] || ''
-			const name = prefixedKey + '='
-			const ca = cookieStr.split(';')
-			for (let i = 0; i < ca.length; i++) {
-				let c = ca[i].trim()
-				if (c.indexOf(name) === 0) {
-					cookieValue = c.substring(name.length, c.length)
-					break
-				}
-			}
-		}
-
-		if (!cookieValue) return null
-
-		try {
-			const val = JSON.parse(decodeURIComponent(cookieValue)) as ICacheEntry<any>
-			if (val && val.timestamp && val.lifetime) {
-				return Math.max(0, (val.timestamp + val.lifetime) - Date.now())
-			}
-			return null
-		} catch (e) {
-			return null
-		}
-	}
-
-	async cleanupExpired(): Promise<void> {
-		if (import.meta.client) {
-			const prefix = 'cache:'
-			const now = Date.now()
-			const cookies = document.cookie.split(';')
-			for (let i = 0; i < cookies.length; i++) {
-				const cookie = cookies[i].trim()
-				const eqPos = cookie.indexOf('=')
-				if (eqPos > 0) {
-					const name = decodeURIComponent(cookie.substring(0, eqPos))
-					if (name.startsWith(prefix)) {
-						const value = decodeURIComponent(cookie.substring(eqPos + 1))
-						try {
-							const entry: ICacheEntry<any> = JSON.parse(value)
-							if (now - entry.timestamp > entry.lifetime) {
-								document.cookie = `${encodeURIComponent(name)}=; max-age=0; path=/`
-							}
-						} catch (e) {
-							document.cookie = `${encodeURIComponent(name)}=; max-age=0; path=/`
-						}
-					}
-				}
-			}
-		}
-	}
-}

package/services/CacheProvider/CIndexedDBCache.ts

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