homarr/apps/nextjs/src/components/backup/use-backup-analysis.ts

"use client";

import { useCallback, useRef, useState } from "react";

import { useScopedI18n } from "@homarr/translation/client";

import type { BackupAnalysis, MigrationFile, MigrationStatus } from "./types";
import { PREVIEW_TABLE_KEYS } from "./types";

const DRIZZLE_MIGRATIONS_TABLE = "__drizzle_migrations";

const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

const getAppliedMigrationCount = (db: any): number => {
  try {
    const result = db.exec(`SELECT COUNT(*) FROM "${DRIZZLE_MIGRATIONS_TABLE}"`);
    return (result[0]?.values[0]?.[0] as number) ?? 0;
  } catch {
    return 0;
  }
};

const fetchMigrations = async (): Promise<MigrationFile[]> => {
  const res = await fetch("/api/backup/migrations");
  if (!res.ok) throw new Error("Failed to fetch migration files from server");
  const data = await res.json();
  return data.migrations ?? [];
};

const countEntities = (db: any): Record<string, number> => {
  const counts: Record<string, number> = {};
  for (const key of PREVIEW_TABLE_KEYS) {
    try {
      const result = db.exec(`SELECT COUNT(*) FROM "${key}"`);
      counts[key] = (result[0]?.values[0]?.[0] as number) ?? 0;
    } catch {
      counts[key] = 0;
    }
  }
  return counts;
};

const getBoardNames = (db: any): string[] => {
  try {
    const result = db.exec('SELECT "name" FROM "board" ORDER BY "name"');
    return result[0]?.values.map((row: unknown[]) => row[0] as string) ?? [];
  } catch {
    return [];
  }
};

export interface MigrationProgress {
  current: number;
  total: number;
  tag: string;
  phase: "pending" | "applying" | "done" | "error";
}

export const useBackupAnalysis = () => {
  const t = useScopedI18n("management.page.tool.backup.restore");
  const [analysis, setAnalysis] = useState<BackupAnalysis | null>(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [migrationProgress, setMigrationProgress] = useState<MigrationProgress | null>(null);
  const dbRef = useRef<any>(null);

  const analyzeFile = useCallback(async (file: File) => {
    setLoading(true);
    setError(null);
    setAnalysis(null);
    setMigrationProgress(null);

    try {
      const [JSZip, initSqlJs, allMigrations, wasmBinary] = await Promise.all([
        import("jszip").then((m) => m.default),
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        import("sql.js").then((m: any) => m.default),
        fetchMigrations(),
        fetch("/api/backup/sql-wasm").then((r) => {
          if (!r.ok) throw new Error("Failed to load SQL WASM binary");
          return r.arrayBuffer();
        }),
      ]);

      const arrayBuffer = await file.arrayBuffer();
      const zip = await JSZip.loadAsync(arrayBuffer);

      const metadataFile = zip.file("metadata.json");
      if (!metadataFile) throw new Error(t("invalidMissingMetadata"));
      const dbFile = zip.file("db.sqlite");
      if (!dbFile) throw new Error(t("invalidMissingDb"));

      const metadata = JSON.parse(await metadataFile.async("string"));
      const dbBuffer = await dbFile.async("uint8array");

      const SQL = await initSqlJs({ wasmBinary });

      const db = new SQL.Database(dbBuffer);
      dbRef.current = db;

      try {
        const appliedCount = getAppliedMigrationCount(db);
        const pendingMigrations = allMigrations.filter((m) => m.idx >= appliedCount);

        const migrations: MigrationStatus = {
          applied: appliedCount,
          pending: pendingMigrations,
          total: allMigrations.length,
        };

        if (pendingMigrations.length > 0) {
          for (const [i, migration] of pendingMigrations.entries()) {
            setMigrationProgress({
              current: i + 1,
              total: pendingMigrations.length,
              tag: migration.tag,
              phase: "applying",
            });

            await delay(100);

            try {
              const statements = migration.sql
                .split("--> statement-breakpoint")
                .map((s) => s.trim())
                .filter(Boolean);

              for (const stmt of statements) {
                db.run(stmt);
              }

              db.run(
                `INSERT INTO "${DRIZZLE_MIGRATIONS_TABLE}" ("hash", "created_at") VALUES (?, ?)`,
                [migration.tag, Date.now()],
              );
            } catch (migrationErr) {
              setMigrationProgress({
                current: i + 1,
                total: pendingMigrations.length,
                tag: migration.tag,
                phase: "error",
              });
              throw new Error(
                `Migration ${migration.tag} failed: ${migrationErr instanceof Error ? migrationErr.message : "Unknown error"}`,
              );
            }

            setMigrationProgress({
              current: i + 1,
              total: pendingMigrations.length,
              tag: migration.tag,
              phase: "done",
            });

            await delay(50);
          }
        }

        const counts = countEntities(db);
        const boardNames = getBoardNames(db);

        setMigrationProgress(null);
        setAnalysis({ metadata, counts, boardNames, migrations });
      } finally {
        db.close();
        dbRef.current = null;
      }
    } catch (err) {
      setError(err instanceof Error ? err.message : t("analyzeError"));
    } finally {
      setLoading(false);
    }
  }, [t]);

  const reset = useCallback(() => {
    if (dbRef.current) {
      try { dbRef.current.close(); } catch { /* already closed */ }
      dbRef.current = null;
    }
    setAnalysis(null);
    setError(null);
    setMigrationProgress(null);
  }, []);

  return { analysis, loading, error, migrationProgress, analyzeFile, reset };
};