123 lines
4.2 KiB
TypeScript
123 lines
4.2 KiB
TypeScript
import { BaseStorage, FindOptions, type Filter } from './base-storage.js';
|
|
import { StorageMemory } from './storage-memory.js';
|
|
|
|
/**
|
|
* Storage Adapter that takes another Storage Adapter (e.g. IndexedDB) and "syncs" its contents to system memory for faster read access.
|
|
*
|
|
* All read operations will use system memory - all write operations will use the provided adapter.
|
|
*/
|
|
export class StorageMemorySynced<T extends Record<string, any> = Record<string, any>> extends BaseStorage<T> {
|
|
private isPrimed: boolean;
|
|
private primePromise: Promise<void> | null;
|
|
|
|
constructor(
|
|
private inMemoryCache: StorageMemory<T>,
|
|
private store: BaseStorage<T>,
|
|
isPrimed = false,
|
|
) {
|
|
super();
|
|
this.isPrimed = isPrimed;
|
|
this.primePromise = null;
|
|
|
|
// Hook into all write operations so that we can sync the In-Memory cache.
|
|
this.store.on('insert', async (payload) => {
|
|
await this.inMemoryCache.insertOne(payload.value);
|
|
this.emit('insert', payload);
|
|
});
|
|
|
|
this.store.on('update', async (payload) => {
|
|
// Remove the old version and insert the new one. We use delete + insert
|
|
// rather than updateOne because the oldValue is the complete document,
|
|
// guaranteeing an exact match without assuming any particular key field.
|
|
await this.inMemoryCache.deleteOne(payload.oldValue);
|
|
await this.inMemoryCache.insertOne(payload.value);
|
|
this.emit('update', payload);
|
|
});
|
|
|
|
this.store.on('delete', async (payload) => {
|
|
await this.inMemoryCache.deleteOne(payload.value);
|
|
|
|
// Re-emit the delete event with the original payload.
|
|
this.emit('delete', payload);
|
|
});
|
|
|
|
this.store.on('clear', async () => {
|
|
// Clear all documents from memory cache
|
|
await this.inMemoryCache.deleteMany({});
|
|
|
|
// Re-emit the clear event with the original payload.
|
|
this.emit('clear', undefined);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Ensure the in-memory cache has been initialized from the backing store.
|
|
* This is especially important for derived children, whose caches start empty.
|
|
*/
|
|
private async ensurePrimed(): Promise<void> {
|
|
if (this.isPrimed) return;
|
|
if (!this.primePromise) {
|
|
this.primePromise = (async () => {
|
|
await this.inMemoryCache.deleteMany({});
|
|
const allDocuments = await this.store.find();
|
|
await this.inMemoryCache.insertMany(allDocuments);
|
|
this.isPrimed = true;
|
|
})();
|
|
}
|
|
await this.primePromise;
|
|
}
|
|
|
|
static async create<T extends Record<string, any>>(store: BaseStorage<T>) {
|
|
// Instantiate in-memory cache and the backing store.
|
|
const inMemoryCache = new StorageMemory<T>();
|
|
|
|
// Create instance of this store.
|
|
const memorySyncedStore = new StorageMemorySynced<T>(inMemoryCache, store);
|
|
|
|
// Sync the data from the backing store into the In-Memory cache.
|
|
const allDocuments = await store.find();
|
|
for (const document of allDocuments) {
|
|
await inMemoryCache.insertOne(document);
|
|
}
|
|
|
|
// Return our instance of this store.
|
|
memorySyncedStore.isPrimed = true;
|
|
return memorySyncedStore;
|
|
}
|
|
|
|
async insertMany(documents: Array<T>): Promise<void> {
|
|
await this.store.insertMany(documents);
|
|
}
|
|
|
|
async find(filter?: Filter<T>, options?: FindOptions): Promise<T[]> {
|
|
await this.ensurePrimed();
|
|
return await this.inMemoryCache.find(filter, options);
|
|
}
|
|
|
|
async updateMany(
|
|
filter: Filter<T>,
|
|
update: Partial<T>,
|
|
options: Partial<FindOptions> = {},
|
|
): Promise<number> {
|
|
await this.ensurePrimed();
|
|
return await this.store.updateMany(filter, update, options);
|
|
}
|
|
|
|
async deleteMany(filter: Filter<T>, options: Partial<FindOptions> = {}): Promise<number> {
|
|
await this.ensurePrimed();
|
|
return await this.store.deleteMany(filter, options);
|
|
}
|
|
|
|
deriveChild<C extends Record<string, any>>(path: string): BaseStorage<C> {
|
|
const childStore = this.store.deriveChild<C>(path);
|
|
const childMemory = this.inMemoryCache.deriveChild<C>(path);
|
|
|
|
if (!(childMemory instanceof StorageMemory)) {
|
|
throw new Error('Expected derived in-memory cache to be a StorageMemory instance');
|
|
}
|
|
|
|
// Create a new synced storage for the child
|
|
return new StorageMemorySynced<C>(childMemory, childStore);
|
|
}
|
|
}
|