obsidian-livesync/src/modules/essential/ModuleKeyValueDB.ts

import { delay, yieldMicrotask } from "octagonal-wheels/promises";
import { OpenKeyValueDatabase } from "../../common/KeyValueDB.ts";
import type { LiveSyncLocalDB } from "../../lib/src/pouchdb/LiveSyncLocalDB.ts";
import { LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
import { AbstractModule } from "../AbstractModule.ts";
import type { ICoreModule } from "../ModuleTypes.ts";

export class ModuleKeyValueDB extends AbstractModule implements ICoreModule {

    tryCloseKvDB() {
        try {
            this.core.kvDB?.close();
            return true;
        } catch (e) {
            this._log("Failed to close KeyValueDB", LOG_LEVEL_VERBOSE);
            this._log(e);
            return false;
        }
    }
    async openKeyValueDB(): Promise<boolean> {
        await delay(10);
        try {
            this.tryCloseKvDB();
            await delay(10);
            await yieldMicrotask();
            this.core.kvDB = await OpenKeyValueDatabase(this.core.$$getVaultName() + "-livesync-kv");
            await yieldMicrotask();
            await delay(100);
        } catch (e) {
            this.core.kvDB = undefined!;
            this._log("Failed to open KeyValueDB", LOG_LEVEL_NOTICE);
            this._log(e, LOG_LEVEL_VERBOSE);
            return false;
        }
        return true;
    }
    $allOnDBUnload(db: LiveSyncLocalDB): void {
        if (this.core.kvDB) this.core.kvDB.close();
    }
    $allOnDBClose(db: LiveSyncLocalDB): void {
        if (this.core.kvDB) this.core.kvDB.close();
    }

    async $everyOnloadAfterLoadSettings(): Promise<boolean> {
        if (!await this.openKeyValueDB()) {
            return false;
        }
        this.core.simpleStore = this.core.$$getSimpleStore<any>("os");
        return Promise.resolve(true);
    }
    $$getSimpleStore<T>(kind: string) {
        const prefix = `${kind}-`;
        return {
            get: async (key: string): Promise<T> => {
                return await this.core.kvDB.get(`${prefix}${key}`);
            },
            set: async (key: string, value: any): Promise<void> => {
                await this.core.kvDB.set(`${prefix}${key}`, value);
            },
            delete: async (key: string): Promise<void> => {
                await this.core.kvDB.del(`${prefix}${key}`);
            },
            keys: async (from: string | undefined, to: string | undefined, count?: number | undefined): Promise<string[]> => {
                const ret = this.core.kvDB.keys(IDBKeyRange.bound(`${prefix}${from || ""}`, `${prefix}${to || ""}`), count);
                return (await ret).map(e => e.toString()).filter(e => e.startsWith(prefix)).map(e => e.substring(prefix.length));
            }
        }
    }
    $everyOnInitializeDatabase(db: LiveSyncLocalDB): Promise<boolean> {
        return this.openKeyValueDB();
    }

    async $everyOnResetDatabase(db: LiveSyncLocalDB): Promise<boolean> {
        try {
            const kvDBKey = "queued-files"
            await this.core.kvDB.del(kvDBKey);
            // localStorage.removeItem(lsKey);
            await this.core.kvDB.destroy();
            await yieldMicrotask();
            this.core.kvDB = await OpenKeyValueDatabase(this.core.$$getVaultName() + "-livesync-kv");
            await delay(100);
        } catch (e) {
            this.core.kvDB = undefined!;
            this._log("Failed to reset KeyValueDB", LOG_LEVEL_NOTICE);
            this._log(e, LOG_LEVEL_VERBOSE);
            return false;
        }
        return true;
    }
}