Class SQLiteCache

cli/src/cache/sqliteCache.ts:5–71

import type { EntityResult, ProtonDriveCache } from '@protontech/drive-sdk';

const SQLITE_BUSY_TIMEOUT_MS = 5000;

export class SQLiteCache implements ProtonDriveCache<string> {
    private db: Database;

    constructor(cacheFile: string) {
        this.db = new Database(cacheFile, { create: true });
        this.db.run(`PRAGMA journal_mode = WAL`);
        this.db.run(`PRAGMA synchronous = NORMAL`);
        this.db.run(`PRAGMA busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS}`);
        this.db.run('CREATE TABLE IF NOT EXISTS entities (key TEXT PRIMARY KEY, value TEXT)');
        this.db.run('CREATE TABLE IF NOT EXISTS entities_labels (label TEXT, key TEXT, UNIQUE (label, key))');
    }

    async clear() {
        this.db.run('DELETE FROM entities');
        this.db.run('DELETE FROM entities_labels');
    }

    async setEntity(key: string, data: string, tags?: string[]) {
        const query = this.db.query('INSERT OR REPLACE INTO entities (key, value) VALUES ($key, $data)');
        query.run({ $key: key, $data: data });

        // Remove previous tags.
        const deleteQuery = this.db.query('DELETE FROM entities_labels WHERE key = $key');
        deleteQuery.run({ $key: key });

        for (const tag of tags || []) {
            const insertQuery = this.db.query(
                'INSERT OR REPLACE INTO entities_labels (label, key) VALUES ($tag, $key)',
            );
            insertQuery.run({ $tag: tag, $key: key });
        }
    }

    async getEntity(key: string) {
        const query = this.db.query('SELECT value FROM entities WHERE key = $key');
        const result = query.get({ $key: key });
        if (!result) {
            throw Error(`Entity ${key} not found`);
        }
        // @ts-expect-error - SQLite returns unknown type.
        return result['value'];
    }

    async *iterateEntities(keys: string[]): AsyncGenerator<EntityResult<string>> {
        for (const key of keys) {
            try {
                const value = await this.getEntity(key);
                yield { key, ok: true, value };
            } catch (error) {
                yield { key, ok: false, error: `${error}` };
            }
        }
    }

    async *iterateEntitiesByTag(tag: string): AsyncGenerator<EntityResult<string>> {
        const query = this.db.query('SELECT key FROM entities_labels WHERE label = $tag');