Aggiunge il controllo dei tipi e copre con un test lo script di backup

- npm run typecheck (tsc --noEmit) entra nella checklist di fine lavoro:
  bun esegue i test senza controllare i tipi, ed è così che si erano
  accumulati errori di tipo con la suite verde.
- La logica pura del download dello storage passa in storage-core.ts,
  testata con dati finti (nessuna lettura del .env reale).
- Il download dello storage esce con errore se anche un solo file non
  si scarica, così backup.sh non dichiara completo un backup parziale.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

backups/README.md

@@ -56,6 +56,10 @@ Ogni esecuzione crea una cartella nuova con timestamp: non sovrascrive backup
 precedenti. Non c'è pulizia automatica dei vecchi backup — cancellali a mano
 quando non servono più.
 
+Se un passaggio fallisce (un dump o anche un solo file dello storage non scaricato),
+lo script si ferma con un errore e **non** stampa «Backup completato»: un backup
+incompleto non va considerato valido, rilancialo.
+
 Il backup contiene:
 
 | File/cartella       | Contenuto                                                                                                  |
@@ -97,3 +101,11 @@ personali reali. Per questo:
 - se sposti un backup fuori da questo host, usa sempre `--encrypt` o cifra tu
   l'archivio a mano;
 - cancella i backup in chiaro quando non ti servono più.
+
+## File di questa cartella
+
+| File                   | Ruolo                                                                                            |
+| ---------------------- | ------------------------------------------------------------------------------------------------ |
+| `backup.sh`            | Punto di ingresso: esegue dump e download in ordine                                              |
+| `download-storage.mjs` | Scarica i file dei bucket (usa la service role key del `.env`)                                   |
+| `storage-core.ts`      | Logica pura (lettura del `.env`, elenco dei file), coperta da `test/unit/backup-storage.test.ts` |

backups/download-storage.mjs

@@ -3,41 +3,33 @@
 import { createClient } from "@supabase/supabase-js";
 import { mkdir, writeFile, readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import { elencaFile, leggiEnv } from "./storage-core.ts";
 
-for (const line of (await readFile(new URL("../.env", import.meta.url), "utf8")).split("\n")) {
-  const match = /^([\w.]+)=(.*)$/.exec(line.trim());
-  if (match) process.env[match[1]] ??= match[2].replace(/^["']|["']$/g, "");
-}
+const env = leggiEnv(await readFile(new URL("../.env", import.meta.url), "utf8"));
+for (const [chiave, valore] of Object.entries(env)) process.env[chiave] ??= valore;
 
 const BUCKETS = ["avatar-giocatori", "profili-giocatore"];
 const OUT_DIR = process.argv[2] ?? new URL("./storage/", import.meta.url).pathname;
 
 const supabase = createClient(process.env.VITE_SUPABASE_URL, process.env.SUPABASE_SERVICE_ROLE_KEY);
 
-async function listAll(bucket, prefix = "") {
-  const { data, error } = await supabase.storage.from(bucket).list(prefix, { limit: 1000 });
+const elencaCartella = (bucket) => async (prefisso) => {
+  const { data, error } = await supabase.storage.from(bucket).list(prefisso, { limit: 1000 });
   if (error) throw error;
-  let files = [];
-  for (const entry of data) {
-    const path = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.id === null) {
-      // è una "cartella" (nessun id): ricorri
-      files = files.concat(await listAll(bucket, path));
-    } else {
-      files.push(path);
-    }
-  }
-  return files;
-}
+  return data;
+};
+
+const falliti = [];
 
 for (const bucket of BUCKETS) {
   console.log(`Bucket: ${bucket}`);
-  const files = await listAll(bucket);
+  const files = await elencaFile(elencaCartella(bucket));
   console.log(`  ${files.length} file trovati`);
   for (const path of files) {
     const { data, error } = await supabase.storage.from(bucket).download(path);
     if (error) {
       console.error(`  ERRORE ${path}:`, error.message);
+      falliti.push(`${bucket}/${path}`);
       continue;
     }
     const destPath = join(OUT_DIR, bucket, path);
@@ -46,4 +38,8 @@ for (const bucket of BUCKETS) {
     console.log(`  scaricato: ${bucket}/${path}`);
   }
 }
+if (falliti.length) {
+  console.error(`${falliti.length} file non scaricati: il backup storage è incompleto.`);
+  process.exit(1);
+}
 console.log("Fatto.");

backups/storage-core.ts

@@ -0,0 +1,30 @@
+/** Logica pura del backup storage, separata dalla rete per poterla testare. */
+
+/** Righe `CHIAVE=valore` di un file `.env`; toglie le virgolette solo se aprono e chiudono. */
+export function leggiEnv(testo: string): Record<string, string> {
+  const env: Record<string, string> = {};
+  for (const riga of testo.split("\n")) {
+    const match = /^([\w.]+)=(.*)$/.exec(riga.trim());
+    if (!match) continue;
+    const [, chiave, grezzo] = match as unknown as [string, string, string];
+    const tra = /^(["'])(.*)\1$/.exec(grezzo);
+    env[chiave] = tra ? tra[2]! : grezzo;
+  }
+  return env;
+}
+
+export type Voce = { name: string; id: string | null };
+
+/** Tutti i percorsi dei file sotto `prefisso`; Supabase segnala le cartelle con `id: null`. */
+export async function elencaFile(
+  lista: (prefisso: string) => Promise<Voce[]>,
+  prefisso = "",
+): Promise<string[]> {
+  const file: string[] = [];
+  for (const voce of await lista(prefisso)) {
+    const percorso = prefisso ? `${prefisso}/${voce.name}` : voce.name;
+    if (voce.id === null) file.push(...(await elencaFile(lista, percorso)));
+    else file.push(percorso);
+  }
+  return file;
+}