karten/src/adapters/marks-db.ts

import type { MarksPort, RememberedMarks } from "../karte/types";

const DB_NAME = "karte";
const STORE = "marks";
const KEY = "heruntergeladen";

function openDatabase(): Promise<IDBDatabase> {
  return new Promise((resolve, reject) => {
    const request = indexedDB.open(DB_NAME, 1);
    request.onupgradeneeded = () => {
      const db = request.result;
      if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE);
    };
    request.onsuccess = () => resolve(request.result);
    request.onerror = () => reject(request.error ?? new Error("IndexedDB"));
  });
}

function stringsFrom(value: unknown): string[] {
  if (!Array.isArray(value)) return [];
  return value.filter((item): item is string => typeof item === "string");
}

function rememberedFrom(value: unknown): RememberedMarks {
  if (Array.isArray(value)) {
    return { heruntergeladen: stringsFrom(value), ziele: [], downloadKnopf: false };
  }
  if (value && typeof value === "object") {
    const record = value as {
      heruntergeladen?: unknown;
      ziele?: unknown;
      downloadKnopf?: unknown;
    };
    return {
      heruntergeladen: stringsFrom(record.heruntergeladen),
      ziele: stringsFrom(record.ziele),
      downloadKnopf: record.downloadKnopf === true,
    };
  }
  return { heruntergeladen: [], ziele: [], downloadKnopf: false };
}

function settle(tx: IDBTransaction, value: () => unknown): Promise<unknown> {
  return new Promise((resolve, reject) => {
    tx.oncomplete = () => resolve(value());
    tx.onerror = () => reject(tx.error ?? new Error("IndexedDB"));
    tx.onabort = () => reject(tx.error ?? new Error("IndexedDB"));
  });
}

export function createMarksDb(): MarksPort {
  return {
    async read() {
      const db = await openDatabase();
      try {
        const tx = db.transaction(STORE, "readonly");
        const request = tx.objectStore(STORE).get(KEY);
        const value = await settle(tx, () => request.result);
        return rememberedFrom(value);
      } finally {
        db.close();
      }
    },

    async write(state) {
      const db = await openDatabase();
      try {
        const tx = db.transaction(STORE, "readwrite");
        tx.objectStore(STORE).put(
          {
            heruntergeladen: state.heruntergeladen,
            ziele: state.ziele,
            downloadKnopf: state.downloadKnopf,
          },
          KEY,
        );
        await settle(tx, () => undefined);
      } finally {
        db.close();
      }
    },
  };
}