karten/src/adapters/marks-db.ts

import type { MarksPort } 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): { heruntergeladen: string[]; ziele: string[] } {
  if (Array.isArray(value)) return { heruntergeladen: stringsFrom(value), ziele: [] };
  if (value && typeof value === "object") {
    const record = value as { heruntergeladen?: unknown; ziele?: unknown };
    return {
      heruntergeladen: stringsFrom(record.heruntergeladen),
      ziele: stringsFrom(record.ziele),
    };
  }
  return { heruntergeladen: [], ziele: [] };
}

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 },
          KEY,
        );
        await settle(tx, () => undefined);
      } finally {
        db.close();
      }
    },
  };
}