Fixed cache save to db

Added db safe guards
Reverted ASet
2025-07-07 15:27:07 -04:00 · 2025-07-07 14:53:14 -04:00 · 2025-07-07 14:34:29 -04:00 · 2025-07-07 14:29:49 -04:00 · 2025-07-07 12:41:44 -04:00 · 2025-07-07 10:52:36 -04:00
9 changed files with 258 additions and 128 deletions
--- a/.gitmodules
+++ b/.gitmodules
@ -1,5 +1,5 @@
 [submodule "docs"]
 	path = docs
-	url = git@git.zakscode.com:ztimson/utils.wiki.git
+	url = ../utils.wiki.git
 	branch = master
 	ignore = all
--- a/index.html
+++ b/index.html
@ -1,9 +1,11 @@
 <html>
 	<body>
 		<script type="module">
-			import {PES} from './dist/index.mjs';
+			import {PathEventEmitter} from './dist/index.mjs';
-			console.log(PES`storage${'Test/Test'}:d`);
+			const emitter = new PathEventEmitter('data');
 			emitter.on('*', console.log);
 			emitter.emit('data/asd', {});
 		</script>
 	</body>
 </html>
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
 	"name": "@ztimson/utils",
-	"version": "0.25.22",
+	"version": "0.26.4",
 	"description": "Utility library",
 	"author": "Zak Timson",
 	"license": "MIT",
--- a/src/cache.ts
+++ b/src/cache.ts
@ -1,13 +1,11 @@
-import {Table} from './database.ts';
+import {Database, Table} from './database.ts';
 import {deepCopy, includes, JSONSanitize} from './objects.ts';
 export type CacheOptions = {
 	/** Delete keys automatically after x amount of seconds */
 	ttl?: number;
 	/** Storage to persist cache */
-	storage?: Storage | Table<any, any>;
+	persistentStorage?: {storage: Storage | Database, key: string} | string;
 	/** Key cache will be stored under */
 	storageKey?: string;
 	/** Keep or delete cached items once expired, defaults to delete */
 	expiryPolicy?: 'delete' | 'keep';
 }
@ -33,21 +31,30 @@ export class Cache<K extends string | number | symbol, T> {
 	 * @param options
 	 */
 	constructor(public readonly key?: keyof T, public readonly options: CacheOptions = {}) {
-		let resolve: any;
+		let done!: Function;
-		this.loading = new Promise(r => resolve = r);
+		this.loading = new Promise(r => done = r);
-		if(options.storageKey && !options.storage && typeof(Storage) !== 'undefined') options.storage = localStorage;
+
-		if(options.storage) {
+		// Persistent storage
-			if(options.storage instanceof Table) {
+		if(this.options.persistentStorage != null) {
 			if(typeof this.options.persistentStorage == 'string')
 				this.options.persistentStorage = {storage: localStorage, key: this.options.persistentStorage};
 			if(this.options.persistentStorage?.storage?.constructor.name == 'Database') {
 				(async () => {
-					this.addAll(await options.storage?.getAll(), false);
+					const persists: any = this.options.persistentStorage;
-					resolve();
+					const table: Table<any, any> = await persists.storage.createTable({name: persists.key, key: this.key});
-				})()
+					const rows = await table.getAll();
-			} else if(options.storageKey) {
+					Object.assign(this.store, rows.reduce((acc, row) => ({...acc, [this.getKey(row)]: row}), {}));
-				const stored = options.storage?.getItem(options.storageKey);
+					done();
 				})();
 			} else if(this.options.persistentStorage?.storage?.constructor.name == 'Storage') {
 				const stored = (<Storage>this.options.persistentStorage.storage).getItem(this.options.persistentStorage.key);
 				if(stored != null) try { Object.assign(this.store, JSON.parse(stored)); } catch { }
-				resolve();
+				done();
 			}
-		} else resolve();
+		}
 		// Handle index lookups
 		return new Proxy(this, {
 			get: (target: this, prop: string | symbol) => {
 				if(prop in target) return (target as any)[prop];
@ -67,12 +74,20 @@ export class Cache<K extends string | number | symbol, T> {
 		return <K>value[this.key];
 	}
-	private save(key: K) {
+	private save(key?: K) {
-		if(this.options.storage) {
+		const persists: {storage: any, key: string} = <any>this.options.persistentStorage;
-			if(this.options.storage instanceof Table) {
+		if(!!persists?.storage) {
-				this.options.storage.put(key, this.store[key]);
+			if(persists.storage?.constructor.name == 'Database') {
-			} else if(this.options.storageKey) {
+				(<Database>persists.storage).createTable({name: persists.key, key: <string>this.key}).then(table => {
-				this.options.storage.setItem(this.options.storageKey, JSONSanitize(this.store));
+					if(key) {
 						table.set(this.get(key), key);
 					} else {
 						table.clear();
 						this.all().forEach(row => table.add(row));
 					}
 				});
 			} else if(persists.storage?.constructor.name == 'Storage') {
 				persists.storage.setItem(persists.storage.key, JSONSanitize(this.all(true)));
 			}
 		}
 	}
@ -117,6 +132,7 @@ export class Cache<K extends string | number | symbol, T> {
 	clear(): this {
 		this.complete = false;
 		this.store = <any>{};
 		this.save();
 		return this;
 	}
--- a/src/database.ts
+++ b/src/database.ts
@ -1,5 +1,6 @@
 import {findByProp} from './array.ts';
 import {ASet} from './aset.ts';
 import {sleepWhile} from './time.ts';
 export type TableOptions = {
 	name: string;
@ -7,11 +8,24 @@ export type TableOptions = {
 	autoIncrement?: boolean;
 };
 class AsyncLock {
 	private p = Promise.resolve();
 	run<T>(fn: () => Promise<T>): Promise<T> {
 		const res = this.p.then(fn, fn);
 		this.p = res.then(() => {}, () => {});
 		return res;
 }
 	}
 export class Database {
 	private schemaLock = new AsyncLock();
 	private upgrading = false;
 	connection!: Promise<IDBDatabase>;
 	ready = false;
 	tables!: TableOptions[];
 	get ready() { return !this.upgrading; }
 	constructor(public readonly database: string, tables?: (string | TableOptions)[], public version?: number) {
 		this.connection = new Promise((resolve, reject) => {
 			const req = indexedDB.open(this.database, this.version);
@ -26,7 +40,7 @@ export class Database {
 				const db = req.result;
 				const existing = Array.from(db.objectStoreNames);
 				if(!tables) this.tables = existing.map(t => {
-					const tx = db.transaction(t, 'readonly', )
+					const tx = db.transaction(t, 'readonly');
 					const store = tx.objectStore(t);
 					return {name: t, key: <string>store.keyPath};
 				});
@ -39,10 +53,11 @@ export class Database {
 					this.version = db.version;
 					resolve(db);
 				}
-				this.ready = true;
+				this.upgrading = false;
 			};
 			req.onupgradeneeded = () => {
 				this.upgrading = true;
 				const db = req.result;
 				const existingTables = new ASet(Array.from(db.objectStoreNames));
 				if(tables) {
@ -52,7 +67,7 @@ export class Database {
 						const t = this.tables.find(findByProp('name', name));
 						db.createObjectStore(name, {
 							keyPath: t?.key,
-							autoIncrement: t?.autoIncrement || !t?.key
+							autoIncrement: t?.autoIncrement || !t?.key,
 						});
 					});
 				}
@ -60,22 +75,34 @@ export class Database {
 		});
 	}
 	waitForUpgrade = () => sleepWhile(() => this.upgrading);
 	async createTable<K extends IDBValidKey = any, T = any>(table: string | TableOptions): Promise<Table<K, T>> {
-		if(typeof table == 'string') table = {name: table};
+		return this.schemaLock.run(async () => {
-		const conn = await this.connection;
+			if (typeof table == 'string') table = { name: table };
-		if(!this.includes(table.name)) {
+			const conn = await this.connection;
-			conn.close();
+			if (!this.includes(table.name)) {
-			Object.assign(this, new Database(this.database, [...this.tables, table], (this.version ?? 0) + 1));
+				const newDb = new Database(this.database, [...this.tables, table], (this.version ?? 0) + 1);
-		}
+				conn.close();
-		return this.table<K, T>(table.name);
+				Object.assign(this, newDb);
 				await this.connection;
 			}
 			return this.table<K, T>(table.name);
 		});
 	}
 	async deleteTable(table: string | TableOptions): Promise<void> {
-		if(typeof table == 'string') table = {name: table};
+		return this.schemaLock.run(async () => {
-		if(!this.includes(table.name)) return;
+			if (typeof table == 'string') table = { name: table };
-		const conn = await this.connection;
+			if (!this.includes(table.name)) return;
-		conn.close();
+			const conn = await this.connection;
-		Object.assign(this, new Database(this.database, this.tables.filter(t => t.name != table.name), (this.version ?? 0) + 1));
+			const newDb = new Database(this.database, this.tables.filter(t => t.name != (<TableOptions>table).name), (this.version ?? 0) + 1);
 			conn.close();
 			Object.assign(this, newDb);
 			await this.connection;
 		});
 	}
 	includes(name: any): boolean {
@ -96,12 +123,13 @@ export class Table<K extends IDBValidKey = any, T = any> {
 	}
 	async tx<R>(table: string, fn: (store: IDBObjectStore) => IDBRequest, readonly = false): Promise<R> {
 		await this.database.waitForUpgrade();
 		const db = await this.database.connection;
 		const tx = db.transaction(table, readonly ? 'readonly' : 'readwrite');
 		const store = tx.objectStore(table);
 		return new Promise<R>((resolve, reject) => {
 			const request = fn(store);
-			request.onsuccess = () => resolve(request.result as R); // ✅ explicit cast
+			request.onsuccess = () => resolve(request.result as R);
 			request.onerror = () => reject(request.error);
 		});
 	}
@ -138,8 +166,11 @@ export class Table<K extends IDBValidKey = any, T = any> {
 		return this.tx(this.name, store => store.getAllKeys(), true);
 	}
-	put(key: K, value: T): Promise<void> {
+	put(value: T, key?: string): Promise<void> {
-		return this.tx(this.name, store => store.put(value, key));
+		return this.tx(this.name, store => {
 			if (store.keyPath) return store.put(value);
 			return store.put(value, key);
 		});
 	}
 	read(): Promise<T[]>;
@ -149,8 +180,9 @@ export class Table<K extends IDBValidKey = any, T = any> {
 	}
 	set(value: T, key?: K): Promise<void> {
-		if(!key && !(<any>value)[this.key]) return this.add(value);
+		if(key) (<any>value)[this.key] = key;
-		return this.put(key || (<any>value)[this.key], value);
+		if(!(<any>value)[this.key]) return this.add(value);
 		return this.put(value);
 	}
 	update = this.set;
--- a/src/objects.ts
+++ b/src/objects.ts
@ -177,19 +177,51 @@ export function includes(target: any, values: any, allowMissing = false): boolea
 }
 /**
- * Deep check if two objects are equal
+ * Deep check if two items are equal.
 * Handles primitives, objects, arrays, functions, Date, RegExp, and circular references.
 *
 * @param {any} a - first item to compare
 * @param {any} b - second item to compare
 * @param {WeakMap<object, object>} [seen] - Internal parameter to track circular references
 * @returns {boolean} True if they match
 */
-export function isEqual(a: any, b: any): boolean {
+export function isEqual(a: any, b: any, seen = new WeakMap<object, object>()): boolean {
-	const ta = typeof a, tb = typeof b;
+	// Simple cases
-	if((ta != 'object' || a == null) || (tb != 'object' || b == null))
+	if(a === b) return true;
-		return ta == 'function' && tb == 'function' ? a.toString() == b.toString() : a === b;
+	if(a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
-	const keys = Object.keys(a);
+	if(a instanceof RegExp && b instanceof RegExp) return a.source === b.source && a.flags === b.flags;
-	if(keys.length != Object.keys(b).length) return false;
+
-	return Object.keys(a).every(key => isEqual(a[key], b[key]));
+	// Null checks
 	if(typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
 		if(Number.isNaN(a) && Number.isNaN(b)) return true;
 		if(typeof a === 'function' && typeof b === 'function') return a.toString() === b.toString()
 		return false;
 	}
 	// Circular references
 	if(seen.has(a)) return seen.get(a) === b;
 	seen.set(a, b);
 	const isArrayA = Array.isArray(a);
 	const isArrayB = Array.isArray(b);
 	// Array checks
 	if(isArrayA && isArrayB) {
 		if(a.length !== b.length) return false;
 		for(let i = 0; i < a.length; i++) {
 			if(!isEqual(a[i], b[i], seen)) return false;
 		}
 		return true;
 	}
 	if(isArrayA !== isArrayB) return false;
 	// Key & value deep comparison
 	const keysA = Object.keys(a);
 	const keysB = Object.keys(b);
 	if(keysA.length !== keysB.length) return false;
 	for(const key of keysA) {
 		if(!Object.prototype.hasOwnProperty.call(b, key) || !isEqual(a[key], b[key], seen)) return false;
 	}
 	return true;
 }
 /**
--- a/src/path-events.ts
+++ b/src/path-events.ts
@ -71,9 +71,12 @@ export class PathEvent {
 	/** List of methods */
 	methods!: ASet<Method>;
 	/** Internal cache for PathEvent instances to avoid redundant parsing */
 	private static pathEventCache: Map<string, PathEvent> = new Map();
 	/** All/Wildcard specified */
 	get all(): boolean { return this.methods.has('*') }
-	set all(v: boolean) { v ? new ASet<Method>(['*']) : this.methods.delete('*'); }
+	set all(v: boolean) { v ? this.methods = new ASet<Method>(['*']) : this.methods.delete('*'); }
 	/** None specified */
 	get none(): boolean { return this.methods.has('n') }
 	set none(v: boolean) { v ? this.methods = new ASet<Method>(['n']) : this.methods.delete('n'); }
@ -91,10 +94,20 @@ export class PathEvent {
 	set delete(v: boolean) { v ? this.methods.delete('n').delete('*').add('d') : this.methods.delete('d'); }
 	constructor(e: string | PathEvent) {
-		if(typeof e == 'object') return Object.assign(this, e);
+		if(typeof e == 'object') {
 			Object.assign(this, e);
 			return;
 		}
 		// Check cache first
 		if (PathEvent.pathEventCache.has(e)) {
 			Object.assign(this, PathEvent.pathEventCache.get(e)!);
 			return;
 		}
 		let [p, scope, method] = e.replaceAll(/\/{2,}/g, '/').split(':');
 		if(!method) method = scope || '*';
-		if(p == '*' || !p && method == '*') {
+		if(p == '*' || (!p && method == '*')) {
 			p = '';
 			method = '*';
 		}
@ -104,6 +117,14 @@ export class PathEvent {
 		this.fullPath = `${this.module}${this.module && this.path ? '/' : ''}${this.path}`;
 		this.name = temp.pop() || '';
 		this.methods = new ASet(<any>method.split(''));
 		// Store in cache
 		PathEvent.pathEventCache.set(e, this);
 	}
 	/** Clear the cache of all PathEvents */
 	static clearCache(): void {
 		PathEvent.pathEventCache.clear();
 	}
 	/**
@ -115,7 +136,7 @@ export class PathEvent {
 	 */
 	static combine(...paths: (string | PathEvent)[]): PathEvent {
 		let hitNone = false;
-		const combined = paths.map(p => new PathEvent(p))
+		const combined = paths.map(p => p instanceof PathEvent ? p : new PathEvent(p))
 			.toSorted((p1, p2) => {
 				const l1 = p1.fullPath.length, l2 = p2.fullPath.length;
 				return l1 < l2 ? 1 : (l1 > l2 ? -1 : 0);
@ -124,10 +145,9 @@ export class PathEvent {
 				if(p.none) hitNone = true;
 				if(!acc) return p;
 				if(hitNone) return acc;
-				acc.methods = [...acc.methods, ...p.methods];
+				acc.methods = new ASet([...acc.methods, ...p.methods]);
 				return acc;
 			}, <any>null);
 		combined.methods = new ASet<Method>(combined.methods);
 		return combined;
 	}
@ -139,11 +159,12 @@ export class PathEvent {
 	 * @return {boolean} Whether there is any overlap
 	 */
 	static filter(target: string | PathEvent | (string | PathEvent)[], ...filter: (string | PathEvent)[]): PathEvent[] {
-		const parsedTarget = makeArray(target).map(pe => new PathEvent(pe));
+		const parsedTarget = makeArray(target).map(pe => pe instanceof PathEvent ? pe : new PathEvent(pe));
-		const parsedFilter = makeArray(filter).map(pe => new PathEvent(pe));
+		const parsedFilter = makeArray(filter).map(pe => pe instanceof PathEvent ? pe : new PathEvent(pe));
 		return parsedTarget.filter(t => !!parsedFilter.find(r => {
 			const wildcard = r.fullPath == '*' || t.fullPath == '*';
-			const p1 = r.fullPath.slice(0, r.fullPath.indexOf('*')), p2 = t.fullPath.slice(0, t.fullPath.indexOf('*'))
+			const p1 = r.fullPath.includes('*') ? r.fullPath.slice(0, r.fullPath.indexOf('*')) : r.fullPath;
 			const p2 = t.fullPath.includes('*') ? t.fullPath.slice(0, t.fullPath.indexOf('*')) : t.fullPath;
 			const scope = p1.startsWith(p2) || p2.startsWith(p1);
 			const methods = r.all || t.all || r.methods.intersection(t.methods).length;
 			return (wildcard || scope) && methods;
@ -158,12 +179,13 @@ export class PathEvent {
 	 * @return {boolean} Whether there is any overlap
 	 */
 	static has(target: string | PathEvent | (string | PathEvent)[], ...has: (string | PathEvent)[]): boolean {
-		const parsedTarget = makeArray(target).map(pe => new PathEvent(pe));
+		const parsedTarget = makeArray(target).map(pe => pe instanceof PathEvent ? pe : new PathEvent(pe));
-		const parsedRequired = makeArray(has).map(pe => new PathEvent(pe));
+		const parsedRequired = makeArray(has).map(pe => pe instanceof PathEvent ? pe : new PathEvent(pe));
 		return !!parsedRequired.find(r => !!parsedTarget.find(t => {
 			const wildcard = r.fullPath == '*' || t.fullPath == '*';
-			const p1 = r.fullPath.slice(0, r.fullPath.indexOf('*')), p2 = t.fullPath.slice(0, t.fullPath.indexOf('*'))
+			const p1 = r.fullPath.includes('*') ? r.fullPath.slice(0, r.fullPath.indexOf('*')) : r.fullPath;
-			const scope = p1.startsWith(p2);
+			const p2 = t.fullPath.includes('*') ? t.fullPath.slice(0, t.fullPath.indexOf('*')) : t.fullPath;
 			const scope = p1.startsWith(p2); // Note: Original had || p2.startsWith(p1) here, but has implies target has required.
 			const methods = r.all || t.all || r.methods.intersection(t.methods).length;
 			return (wildcard || scope) && methods;
 		}));
@ -293,7 +315,7 @@ export class PathEventEmitter implements IPathEventEmitter{
 	constructor(public readonly prefix: string = '') { }
 	emit(event: Event, ...args: any[]) {
-		const parsed = PE`${this.prefix}/${event}`;
+		const parsed = event instanceof PathEvent ? event : new PathEvent(`${this.prefix}/${event}`);
 		this.listeners.filter(l => PathEvent.has(l[0], parsed))
 			.forEach(async l => l[1](parsed, ...args));
 	};
@ -304,7 +326,7 @@ export class PathEventEmitter implements IPathEventEmitter{
 	on(event: Event | Event[], listener: PathListener): PathUnsubscribe {
 		makeArray(event).forEach(e => this.listeners.push([
-			new PathEvent(`${this.prefix}/${e}`),
+			e instanceof PathEvent ? e : new PathEvent(`${this.prefix}/${e}`),
 			listener
 		]));
 		return () => this.off(listener);
--- a/tests/cache.spec.ts
+++ b/tests/cache.spec.ts
@ -1,7 +1,7 @@
-import {Cache} from '../src';
+import { Cache } from '../src';
 describe('Cache', () => {
-	type TestItem = { id: string; value: string; };
+	type TestItem = { id: string; value: string };
 	let cache: Cache<string, TestItem>;
 	let storageMock: Storage;
@ -10,6 +10,7 @@ describe('Cache', () => {
 	beforeEach(() => {
 		storageMock = {
 			constructor: {name: 'Storage' as any},
 			getItem: jest.fn(),
 			setItem: jest.fn(),
 			removeItem: jest.fn(),
@ -17,93 +18,114 @@ describe('Cache', () => {
 			key: jest.fn(),
 			length: 0,
 		};
 		// Spies
 		storageGetItemSpy = jest.spyOn(storageMock, 'getItem');
 		storageSetItemSpy = jest.spyOn(storageMock, 'setItem');
-		cache = new Cache<string, TestItem>('id', {storage: storageMock, storageKey: 'cache'});
+
 		cache = new Cache<string, TestItem>('id', {
 			persistentStorage: { storage: storageMock, key: 'cache' },
 		});
 		jest.clearAllMocks();
 		jest.useFakeTimers();
 	});
-	test('should add and get an item', () => {
+	it('adds and gets an item', () => {
-		const item = {id: '1', value: 'a'};
+		const item = { id: '1', value: 'a' };
 		cache.add(item);
 		expect(cache.get('1')).toEqual(item);
 	});
-	test('should not get an expired item when expired option not set', () => {
+	it('skips expired items by default but fetches if requested', () => {
-		const item = {id: '1', value: 'a'};
+		const item = { id: '2', value: 'b' };
-		cache.set('1', item);
+		cache.set('2', item);
 		cache.options.expiryPolicy = 'keep';
-		cache.expire('1');
+		cache.expire('2');
-		expect(cache.get('1')).toBeNull();
+		expect(cache.get('2')).toBeNull();
-		expect(cache.get('1', true)).toEqual({...item, _expired: true});
+		expect(cache.get('2', true)).toEqual({ ...item, _expired: true });
 	});
-	test('should set and get via property access (proxy)', () => {
+	it('supports property access and setting via Proxy', () => {
-		(cache as any)['2'] = {id: '2', value: 'b'};
+		(cache as any)['3'] = { id: '3', value: 'c' };
-		expect((cache as any)['2']).toEqual({id: '2', value: 'b'});
+		expect((cache as any)['3']).toEqual({ id: '3', value: 'c' });
 		expect(cache.get('3')).toEqual({ id: '3', value: 'c' });
 	});
-	test('should remove an item', () => {
+	it('removes an item and persists', () => {
-		cache.set('1', {id: '1', value: 'a'});
+		cache.add({ id: '4', value: 'd' });
-		cache.delete('1');
+		cache.delete('4');
-		expect(cache.get('1')).toBeNull();
+		expect(cache.get('4')).toBeNull();
 		expect(storageSetItemSpy).toHaveBeenCalled();
 	});
-	test('should clear the cache', () => {
+	it('clears the cache', () => {
-		cache.add({id: '1', value: 'a'});
+		cache.add({ id: '1', value: 'test' });
 		cache.clear();
 		expect(cache.get('1')).toBeNull();
 		expect(cache.complete).toBe(false);
 	});
-	test('should add multiple items and mark complete', () => {
+	it('bulk adds, marks complete', () => {
-		const rows = [
+		const items = [
-			{id: 'a', value: '1'},
+			{ id: 'a', value: '1' },
-			{id: 'b', value: '2'},
+			{ id: 'b', value: '2' },
 		];
-		cache.addAll(rows);
+		cache.addAll(items);
 		expect(cache.all().length).toBe(2);
 		expect(cache.complete).toBe(true);
 	});
-	test('should return all, keys, entries, and map', () => {
+	it('returns correct keys, entries, and map', () => {
-		cache.add({id: '1', value: 'a'});
+		cache.add({ id: 'x', value: 'foo' });
-		cache.add({id: '2', value: 'b'});
+		cache.add({ id: 'y', value: 'bar' });
-		expect(cache.all().length).toBe(2);
+		expect(cache.keys().sort()).toEqual(['x', 'y']);
-		expect(cache.keys().sort()).toEqual(['1', '2']);
+		expect(cache.entries().map(e => e[0]).sort()).toEqual(['x', 'y']);
-		expect(cache.entries().length).toBe(2);
+		const m = cache.map();
-		expect(Object.keys(cache.map())).toContain('1');
+		expect(Object.keys(m)).toEqual(expect.arrayContaining(['x', 'y']));
-		expect(Object.keys(cache.map())).toContain('2');
+		expect(m['x'].value).toBe('foo');
 	});
-	// test('should expire/delete items after TTL', () => {
+	it('persists and restores from storage', () => {
-	// 	jest.useFakeTimers();
+		(storageMock.getItem as jest.Mock).mockReturnValueOnce(
-	// 	cache = new Cache<string, TestItem>('id', {ttl: 0.1});
+			JSON.stringify({ z: { id: 'z', value: 'from-storage' } }),
-	// 	cache.add({id: '3', value: 'x'});
+		);
-	// 	jest.advanceTimersByTime(250);
+		const c = new Cache<string, TestItem>('id', {
-	// 	expect(cache.get('3')).toBeNull();
+			persistentStorage: { storage: storageMock, key: 'cache' },
 		});
 		expect(c.get('z')).toEqual({ id: 'z', value: 'from-storage' });
 	});
 	it('expiryPolicy "delete" removes expired items completely', () => {
 		cache.options.expiryPolicy = 'delete';
 		cache.add({ id: 'del1', value: 'gone' });
 		cache.expire('del1');
 		expect(cache.get('del1', true)).toBeNull();
 		expect(cache.get('del1')).toBeNull();
 	});
 	it('expiryPolicy "keep" marks as expired but does not delete', () => {
 		cache.options.expiryPolicy = 'keep';
 		cache.add({ id: 'keep1', value: 'kept' });
 		cache.expire('keep1');
 		expect(cache.get('keep1')).toBeNull();
 		const val = cache.get('keep1', true);
 		expect(val && val._expired).toBe(true);
 	});
 	// Uncomment and adapt this test if TTL/expiry timers are supported by your implementation
 	// it('expires and deletes items after TTL', () => {
 	//   jest.useFakeTimers();
 	//   cache = new Cache<string, TestItem>('id', { ttl: 0.01 });
 	//   cache.add({ id: 'ttl1', value: 'temp' });
 	//   jest.advanceTimersByTime(100);
 	//   expect(cache.get('ttl1')).toBeNull();
 	// });
-	test('should persist and restore from storage', () => {
+	// Edge: add error handling test
-		(storageMock.getItem as jest.Mock).mockReturnValueOnce(JSON.stringify({a: {id: 'a', value: 'from-storage'}}));
+	it('throws if instantiating with invalid key property', () => {
-		const c = new Cache<string, TestItem>('id', {storage: storageMock, storageKey: 'cache'});
+		expect(() => {
-		expect(c.get('a')).toEqual({id: 'a', value: 'from-storage'});
+			const invalid = new Cache<'string', TestItem>('id');
-	});
+			// try invalid.add({id: 'z', value: 'fail'}) if needed
-
+		}).not.toThrow();
 	test('should handle expiryPolicy "delete"', () => {
 		cache.options.expiryPolicy = 'delete';
 		cache.add({id: 'k1', value: 'KeepMe'});
 		cache.expire('k1');
 		expect(cache.get('k1', true)).toBeNull();
 	});
 	test('should handle expiryPolicy "keep"', () => {
 		cache.options.expiryPolicy = 'keep';
 		cache.add({id: 'k1', value: 'KeepMe'});
 		cache.expire('k1');
 		expect(cache.get('k1')).toBeNull();
 		expect(cache.get('k1', true)?._expired).toBe(true);
 	});
 });
--- a/tests/path-events.spec.ts
+++ b/tests/path-events.spec.ts
@ -1,6 +1,10 @@
 import {PathError, PathEvent, PathEventEmitter, PE, PES} from '../src';
 describe('Path Events', () => {
 	beforeEach(() => {
 		PathEvent.clearCache();
 	});
 	describe('PE', () => {
 		it('creates PathEvent from template string', () => {
 			const e = PE`users/system:cr`;
Author	SHA1	Message	Date
ztimson	71552aa243	Fixed cache save to db Some checks failed Build / Build NPM Project (push) Successful in 43s Details Build / Publish Documentation (push) Failing after 5s Details Build / Tag Version (push) Successful in 8s Details	2025-07-07 15:27:07 -04:00
ztimson	ce3878e18b	Added db safe guards Some checks failed Build / Build NPM Project (push) Successful in 44s Details Build / Publish Documentation (push) Failing after 5s Details Build / Tag Version (push) Successful in 9s Details	2025-07-07 14:53:14 -04:00
ztimson	388a09718b	Reverted ASet Some checks failed Build / Build NPM Project (push) Successful in 43s Details Build / Publish Documentation (push) Failing after 5s Details Build / Tag Version (push) Successful in 8s Details	2025-07-07 14:34:29 -04:00
ztimson	59bce9d28d	Optimizations Some checks failed Build / Build NPM Project (push) Failing after 29s Details Build / Publish Documentation (push) Has been skipped Details Build / Tag Version (push) Has been skipped Details	2025-07-07 14:29:49 -04:00
ztimson	387e6b2512	Fixed cache save to db Some checks failed Build / Build NPM Project (push) Successful in 43s Details Build / Publish Documentation (push) Failing after 5s Details Build / Tag Version (push) Successful in 8s Details	2025-07-07 12:41:44 -04:00
ztimson	d748d740ea	bump 0.26.0 Some checks failed Build / Build NPM Project (push) Successful in 42s Details Build / Publish Documentation (push) Failing after 5s Details Build / Tag Version (push) Successful in 8s Details	2025-07-07 10:52:36 -04:00
ztimson	c8f44584a2	Fixed cache saving with different backends Some checks failed Build / Build NPM Project (push) Successful in 43s Details Build / Publish Documentation (push) Failing after 5s Details Build / Tag Version (push) Successful in 8s Details	2025-07-07 10:46:54 -04:00
ztimson	8b84d170a6	Fixed test Some checks failed Build / Build NPM Project (push) Successful in 1m11s Details Build / Tag Version (push) Successful in 17s Details Build / Publish Documentation (push) Failing after 19s Details	2025-07-07 10:42:40 -04:00
ztimson	37df7e6090	Fixed an unreliable caching backend check Some checks failed Build / Build NPM Project (push) Failing after 45s Details Build / Publish Documentation (push) Has been skipped Details Build / Tag Version (push) Has been skipped Details	2025-07-07 10:36:47 -04:00
ztimson	a8b6fdd5a6	fixed type error in test Some checks failed Build / Build NPM Project (push) Successful in 40s Details Build / Publish Documentation (push) Failing after 5s Details Build / Tag Version (push) Successful in 9s Details	2025-07-06 22:19:45 -04:00
ztimson	3e899e6ae4	Clear cache DB correctly Some checks failed Build / Build NPM Project (push) Successful in 1m24s Details Build / Tag Version (push) Successful in 19s Details Build / Publish Documentation (push) Failing after 17s Details	2025-07-06 20:41:01 -04:00
ztimson	08fa5b6783	Clear cache DB correctly Some checks failed Build / Build NPM Project (push) Successful in 42s Details Build / Publish Documentation (push) Failing after 5s Details Build / Tag Version (push) Successful in 8s Details	2025-07-04 01:23:57 -04:00
ztimson	529f1e2b30	fixed docs submodule Some checks failed Build / Build NPM Project (push) Successful in 1m10s Details Build / Tag Version (push) Successful in 15s Details Build / Publish Documentation (push) Failing after 5s Details	2025-07-04 00:39:22 -04:00
ztimson	87ef246760	Indexdb race conditions Some checks failed Build / Build NPM Project (push) Failing after 6s Details Build / Publish Documentation (push) Has been skipped Details Build / Tag Version (push) Has been skipped Details	2025-07-04 00:34:31 -04:00
ztimson	10ac6101f4	Fixed cache handling of undefined All checks were successful Build / Build NPM Project (push) Successful in 47s Details Build / Tag Version (push) Successful in 13s Details Build / Publish Documentation (push) Successful in 53s Details	2025-06-30 11:44:32 -04:00