Compare commits

...

10 Commits

Author SHA1 Message Date
a8b6fdd5a6 fixed type error in test
Some checks failed
Build / Build NPM Project (push) Successful in 40s
Build / Publish Documentation (push) Failing after 5s
Build / Tag Version (push) Successful in 9s
2025-07-06 22:19:45 -04:00
3e899e6ae4 Clear cache DB correctly
Some checks failed
Build / Build NPM Project (push) Successful in 1m24s
Build / Tag Version (push) Successful in 19s
Build / Publish Documentation (push) Failing after 17s
2025-07-06 20:41:01 -04:00
08fa5b6783 Clear cache DB correctly
Some checks failed
Build / Build NPM Project (push) Successful in 42s
Build / Publish Documentation (push) Failing after 5s
Build / Tag Version (push) Successful in 8s
2025-07-04 01:23:57 -04:00
529f1e2b30 fixed docs submodule
Some checks failed
Build / Build NPM Project (push) Successful in 1m10s
Build / Tag Version (push) Successful in 15s
Build / Publish Documentation (push) Failing after 5s
2025-07-04 00:39:22 -04:00
87ef246760 Indexdb race conditions
Some checks failed
Build / Build NPM Project (push) Failing after 6s
Build / Publish Documentation (push) Has been skipped
Build / Tag Version (push) Has been skipped
2025-07-04 00:34:31 -04:00
10ac6101f4 Fixed cache handling of undefined
All checks were successful
Build / Build NPM Project (push) Successful in 47s
Build / Tag Version (push) Successful in 13s
Build / Publish Documentation (push) Successful in 53s
2025-06-30 11:44:32 -04:00
b5d534dc8c Added hook to wait for cache loading
All checks were successful
Build / Build NPM Project (push) Successful in 39s
Build / Tag Version (push) Successful in 8s
Build / Publish Documentation (push) Successful in 34s
2025-06-29 23:11:21 -04:00
d140b2edd1 Revert: Restoring cache from DB gets complete status
All checks were successful
Build / Build NPM Project (push) Successful in 41s
Build / Tag Version (push) Successful in 8s
Build / Publish Documentation (push) Successful in 32s
2025-06-29 22:41:39 -04:00
56f6681492 Restoring cache from DB gets complete status
All checks were successful
Build / Build NPM Project (push) Successful in 47s
Build / Tag Version (push) Successful in 15s
Build / Publish Documentation (push) Successful in 52s
2025-06-29 22:29:16 -04:00
64945a647c Fixed path-events
All checks were successful
Build / Build NPM Project (push) Successful in 43s
Build / Tag Version (push) Successful in 8s
Build / Publish Documentation (push) Successful in 48s
2025-06-28 22:25:11 -04:00
6 changed files with 218 additions and 105 deletions

2
.gitmodules vendored
View File

@ -1,5 +1,5 @@
[submodule "docs"] [submodule "docs"]
path = docs path = docs
url = git@git.zakscode.com:ztimson/utils.wiki.git url = ../utils.wiki.git
branch = master branch = master
ignore = all ignore = all

View File

@ -1,6 +1,6 @@
{ {
"name": "@ztimson/utils", "name": "@ztimson/utils",
"version": "0.25.18", "version": "0.25.26",
"description": "Utility library", "description": "Utility library",
"author": "Zak Timson", "author": "Zak Timson",
"license": "MIT", "license": "MIT",

View File

@ -1,13 +1,11 @@
import {Table} from './database.ts'; import {Database, Table} from './database.ts';
import {deepCopy, includes, JSONSanitize} from './objects.ts'; import {deepCopy, includes, JSONSanitize} from './objects.ts';
export type CacheOptions = { export type CacheOptions = {
/** Delete keys automatically after x amount of seconds */ /** Delete keys automatically after x amount of seconds */
ttl?: number; ttl?: number;
/** Storage to persist cache */ /** 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 */ /** Keep or delete cached items once expired, defaults to delete */
expiryPolicy?: 'delete' | 'keep'; expiryPolicy?: 'delete' | 'keep';
} }
@ -24,6 +22,8 @@ export class Cache<K extends string | number | symbol, T> {
[key: string | number | symbol]: CachedValue<T> | any; [key: string | number | symbol]: CachedValue<T> | any;
/** Whether cache is complete */ /** Whether cache is complete */
complete = false; complete = false;
/** Await initial loading */
loading!: Promise<void>;
/** /**
* Create new cache * Create new cache
@ -31,20 +31,30 @@ export class Cache<K extends string | number | symbol, T> {
* @param options * @param options
*/ */
constructor(public readonly key?: keyof T, public readonly options: CacheOptions = {}) { constructor(public readonly key?: keyof T, public readonly options: CacheOptions = {}) {
if(options.storageKey && !options.storage && typeof(Storage) !== 'undefined') options.storage = localStorage; let done!: Function;
if(options.storage) { this.loading = new Promise(r => done = r);
if(options.storage instanceof Table) {
(async () => (await options.storage?.getAll()).forEach((v: any) => { // Persistent storage
if(v) { if(this.options.persistentStorage != null) {
try { this.add(v) } if(typeof this.options.persistentStorage == 'string')
catch { } this.options.persistentStorage = {storage: localStorage, key: this.options.persistentStorage};
}
}))() if(this.options.persistentStorage?.storage instanceof Database) {
} else if(options.storageKey) { (async () => {
const stored = options.storage?.getItem(options.storageKey); const persists: any = this.options.persistentStorage;
const table: Table<any, any> = await persists.storage.createTable({name: persists.key, key: this.key});
const rows = await table.getAll();
Object.assign(this.store, rows.reduce((acc, row) => ({...acc, [this.getKey(row)]: row}), {}));
done();
})();
} else {
const stored = this.options.persistentStorage.storage.getItem(this.options.persistentStorage.key);
if(stored != null) try { Object.assign(this.store, JSON.parse(stored)); } catch { } if(stored != null) try { Object.assign(this.store, JSON.parse(stored)); } catch { }
done();
} }
} }
// Handle index lookups
return new Proxy(this, { return new Proxy(this, {
get: (target: this, prop: string | symbol) => { get: (target: this, prop: string | symbol) => {
if(prop in target) return (target as any)[prop]; if(prop in target) return (target as any)[prop];
@ -64,12 +74,20 @@ export class Cache<K extends string | number | symbol, T> {
return <K>value[this.key]; return <K>value[this.key];
} }
private save(key: K) { private save(key?: K) {
if(this.options.storage) { const persists: any = this.options.persistentStorage;
if(this.options.storage instanceof Table) { if(!!persists?.storage) {
this.options.storage.put(key, this.store[key]); if(persists.storage instanceof Database) {
} else if(this.options.storageKey) { (<Database>persists.storage).createTable({name: persists.storage.key, key: <string>this.key}).then(table => {
this.options.storage.setItem(this.options.storageKey, JSONSanitize(this.store)); if(key) {
table.set(key, this.get(key));
} else {
table.clear();
this.all().forEach(row => table.add(row));
}
});
} else {
persists.storage.setItem(persists.storage.key, JSONSanitize(this.all(true)));
} }
} }
} }
@ -114,6 +132,7 @@ export class Cache<K extends string | number | symbol, T> {
clear(): this { clear(): this {
this.complete = false; this.complete = false;
this.store = <any>{}; this.store = <any>{};
this.save();
return this; return this;
} }

View File

@ -1,5 +1,6 @@
import {findByProp} from './array.ts'; import {findByProp} from './array.ts';
import {ASet} from './aset.ts'; import {ASet} from './aset.ts';
import {sleepWhile} from './time.ts';
export type TableOptions = { export type TableOptions = {
name: string; name: string;
@ -7,11 +8,24 @@ export type TableOptions = {
autoIncrement?: boolean; 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 { export class Database {
private schemaLock = new AsyncLock();
private upgrading = false;
connection!: Promise<IDBDatabase>; connection!: Promise<IDBDatabase>;
ready = false;
tables!: TableOptions[]; tables!: TableOptions[];
get ready() { return !this.upgrading; }
constructor(public readonly database: string, tables?: (string | TableOptions)[], public version?: number) { constructor(public readonly database: string, tables?: (string | TableOptions)[], public version?: number) {
this.connection = new Promise((resolve, reject) => { this.connection = new Promise((resolve, reject) => {
const req = indexedDB.open(this.database, this.version); const req = indexedDB.open(this.database, this.version);
@ -26,7 +40,7 @@ export class Database {
const db = req.result; const db = req.result;
const existing = Array.from(db.objectStoreNames); const existing = Array.from(db.objectStoreNames);
if(!tables) this.tables = existing.map(t => { if(!tables) this.tables = existing.map(t => {
const tx = db.transaction(t, 'readonly', ) const tx = db.transaction(t, 'readonly');
const store = tx.objectStore(t); const store = tx.objectStore(t);
return {name: t, key: <string>store.keyPath}; return {name: t, key: <string>store.keyPath};
}); });
@ -39,10 +53,11 @@ export class Database {
this.version = db.version; this.version = db.version;
resolve(db); resolve(db);
} }
this.ready = true; this.upgrading = false;
}; };
req.onupgradeneeded = () => { req.onupgradeneeded = () => {
this.upgrading = true;
const db = req.result; const db = req.result;
const existingTables = new ASet(Array.from(db.objectStoreNames)); const existingTables = new ASet(Array.from(db.objectStoreNames));
if(tables) { if(tables) {
@ -52,7 +67,7 @@ export class Database {
const t = this.tables.find(findByProp('name', name)); const t = this.tables.find(findByProp('name', name));
db.createObjectStore(name, { db.createObjectStore(name, {
keyPath: t?.key, 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>> { 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> { 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 { 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> { async tx<R>(table: string, fn: (store: IDBObjectStore) => IDBRequest, readonly = false): Promise<R> {
await this.database.waitForUpgrade();
const db = await this.database.connection; const db = await this.database.connection;
const tx = db.transaction(table, readonly ? 'readonly' : 'readwrite'); const tx = db.transaction(table, readonly ? 'readonly' : 'readwrite');
const store = tx.objectStore(table); const store = tx.objectStore(table);
return new Promise<R>((resolve, reject) => { return new Promise<R>((resolve, reject) => {
const request = fn(store); 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); request.onerror = () => reject(request.error);
}); });
} }

View File

@ -141,9 +141,13 @@ export class PathEvent {
static filter(target: string | PathEvent | (string | PathEvent)[], ...filter: (string | PathEvent)[]): PathEvent[] { 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 => new PathEvent(pe));
const parsedFilter = makeArray(filter).map(pe => new PathEvent(pe)); const parsedFilter = makeArray(filter).map(pe => new PathEvent(pe));
return parsedTarget.filter(t => !!parsedFilter.find(f => return parsedTarget.filter(t => !!parsedFilter.find(r => {
(t.fullPath == '*' || f.fullPath == '*' || t.fullPath.startsWith(f.fullPath) || f.fullPath.startsWith(t.fullPath)) && const wildcard = r.fullPath == '*' || t.fullPath == '*';
(f.all || t.all || t.methods.intersection(f.methods).length))); const p1 = r.fullPath.slice(0, r.fullPath.indexOf('*')), p2 = t.fullPath.slice(0, t.fullPath.indexOf('*'))
const scope = p1.startsWith(p2) || p2.startsWith(p1);
const methods = r.all || t.all || r.methods.intersection(t.methods).length;
return (wildcard || scope) && methods;
}));
} }
/** /**
@ -156,10 +160,13 @@ export class PathEvent {
static has(target: string | PathEvent | (string | PathEvent)[], ...has: (string | PathEvent)[]): boolean { 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 => new PathEvent(pe));
const parsedRequired = makeArray(has).map(pe => new PathEvent(pe)); const parsedRequired = makeArray(has).map(pe => new PathEvent(pe));
return !!parsedRequired.find(r => !!parsedTarget.find(t => return !!parsedRequired.find(r => !!parsedTarget.find(t => {
(r.fullPath == '*' || t.fullPath == '*' || r.fullPath.startsWith(t.fullPath)) && const wildcard = r.fullPath == '*' || t.fullPath == '*';
(r.all || t.all || r.methods.intersection(t.methods).length) const p1 = r.fullPath.slice(0, r.fullPath.indexOf('*')), p2 = t.fullPath.slice(0, t.fullPath.indexOf('*'))
)); const scope = p1.startsWith(p2);
const methods = r.all || t.all || r.methods.intersection(t.methods).length;
return (wildcard || scope) && methods;
}));
} }
/** /**
@ -207,6 +214,44 @@ export class PathEvent {
return p; return p;
} }
/**
* Squash 2 sets of paths & return true if any overlap is found
*
* @param has Target must have at least one of these path
* @return {boolean} Whether there is any overlap
*/
has(...has: (string | PathEvent)[]): boolean {
return PathEvent.has(this, ...has);
}
/**
* Squash 2 sets of paths & return true if the target has all paths
*
* @param has Target must have all these paths
* @return {boolean} Whether there is any overlap
*/
hasAll(...has: (string | PathEvent)[]): boolean {
return PathEvent.hasAll(this, ...has);
}
/**
* Same as `has` but raises an error if there is no overlap
*
* @param has Target must have at least one of these path
*/
hasFatal(...has: (string | PathEvent)[]): void {
return PathEvent.hasFatal(this, ...has);
}
/**
* Same as `hasAll` but raises an error if the target is missing any paths
*
* @param has Target must have all these paths
*/
hasAllFatal(...has: (string | PathEvent)[]): void {
return PathEvent.hasAllFatal(this, ...has);
}
/** /**
* Filter a set of paths based on this event * Filter a set of paths based on this event
* *

View File

@ -1,7 +1,7 @@
import {Cache} from '../src'; import { Cache } from '../src';
describe('Cache', () => { describe('Cache', () => {
type TestItem = { id: string; value: string; }; type TestItem = { id: string; value: string };
let cache: Cache<string, TestItem>; let cache: Cache<string, TestItem>;
let storageMock: Storage; let storageMock: Storage;
@ -17,93 +17,114 @@ describe('Cache', () => {
key: jest.fn(), key: jest.fn(),
length: 0, length: 0,
}; };
// Spies
storageGetItemSpy = jest.spyOn(storageMock, 'getItem'); storageGetItemSpy = jest.spyOn(storageMock, 'getItem');
storageSetItemSpy = jest.spyOn(storageMock, 'setItem'); 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.clearAllMocks();
jest.useFakeTimers(); 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); cache.add(item);
expect(cache.get('1')).toEqual(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.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(); 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(); cache.clear();
expect(cache.get('1')).toBeNull(); expect(cache.get('1')).toBeNull();
expect(cache.complete).toBe(false); 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.all().length).toBe(2);
expect(cache.complete).toBe(true); 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);
}); });
}); });