@cardinali-studio/adminkit 1.0.0

package/dist/functions/api/deliveries.js

@@ -0,0 +1,629 @@
+/* CRUD immediato delle consegne.
+ *
+ * Sta sotto /admin/: Access + verifica JWT sono già applicati dal middleware.
+ * Nessun salvataggio tocca Git. Le operazioni sui byte sono versionate e i delete
+ * cancellano subito, nella stessa richiesta: non c'è un cestino dei transfer, e
+ * rimandare non serviva a nessuno. La tombstone D1 sopravvive solo il tempo del
+ * lavoro su B2, come punto di ripresa se una chiamata fallisce.
+ */
+
+import { b2ObjectKey, b2PutSmall } from "../_shared/b2.js";
+import { randomToken, seal, sha256, unseal } from "../_shared/delivery-crypto.js";
+/* Il lavoro di cancellazione sta in _shared perché lo condivide con il cron:
+ * workers/delivery-housekeeping. Qui si usa nelle due direzioni — subito dopo
+ * una delete, e in coda a una GET per finire ciò che si fosse fermato. */
+import { purgeDeliveryNow, purgeDue, purgePackageNow } from "../_shared/delivery-purge.js";
+
+const DAY = 86_400_000;
+
+export async function onRequestGet({ request, env, waitUntil }) {
+  if (!env.DB) return json({ ok: false, error: "Il servizio dei transfer non è configurato" }, 500);
+  if (typeof waitUntil === "function") {
+    waitUntil(purgeDue(env).catch((error) => console.error("delivery purge:", error)));
+  }
+  const id = new URL(request.url).searchParams.get("id");
+  try {
+    if (id) {
+      const delivery = await deliveryDetail(env, id, new URL(request.url).origin);
+      return delivery ? json({ ok: true, delivery }) : json({ ok: false, error: "Transfer non trovato" }, 404);
+    }
+    const { results } = await env.DB.prepare(`
+      SELECT d.*,
+        (SELECT COUNT(*) FROM delivery_packages p WHERE p.delivery_id=d.id AND p.state='ready') package_count,
+        (SELECT COALESCE(SUM(p.stored_bytes),0) FROM delivery_packages p WHERE p.delivery_id=d.id AND p.state='ready') stored_bytes,
+        (SELECT COUNT(*) FROM delivery_links l WHERE l.delivery_id=d.id AND l.revoked_at IS NULL) link_count,
+        (SELECT COALESCE(SUM(l.download_count),0) FROM delivery_links l WHERE l.delivery_id=d.id) download_count
+      FROM deliveries d
+      WHERE d.status != 'deleted'
+      ORDER BY d.updated_at DESC
+    `).all();
+    const deliveries = (results || []).map(normalizeDelivery);
+    const inSevenDays = new Date(Date.now() + 7 * DAY).toISOString();
+    const expiring = deliveries.filter((d) =>
+      d.status === "active" && d.filesExpiresAt && d.filesExpiresAt <= inSevenDays &&
+      d.filesExpiresAt > new Date().toISOString()).length;
+    return json({ ok: true, deliveries, expiring, settings: await deliverySettings(env) });
+  } catch (e) {
+    console.error("deliveries get:", e);
+    return json({ ok: false, error: message(e) }, 500);
+  }
+}
+
+export async function onRequestPost({ request, env }) {
+  if (!env.DB) return json({ ok: false, error: "Il servizio dei transfer non è configurato" }, 500);
+  let body;
+  try { body = await request.json(); }
+  catch { return json({ ok: false, error: "Corpo JSON non valido" }, 400); }
+  const action = String(body?.action || "");
+  try {
+    switch (action) {
+      case "create": return json({ ok: true, delivery: await createDelivery(env, body, new URL(request.url).origin) });
+      case "quickCreate": return json({ ok: true, delivery: await createQuickDelivery(env, body, new URL(request.url).origin) });
+      case "update": return json({ ok: true, delivery: await updateDelivery(env, body, new URL(request.url).origin) });
+      case "activate": return json({ ok: true, delivery: await activateDelivery(env, body, new URL(request.url).origin) });
+      case "archive": return json({ ok: true, delivery: await archiveDelivery(env, body, new URL(request.url).origin) });
+      case "extend": return json({ ok: true, delivery: await extendDelivery(env, body, new URL(request.url).origin) });
+      case "duplicate": return json({ ok: true, delivery: await duplicateDelivery(env, body, new URL(request.url).origin) });
+      case "delete": return json({ ok: true, ...(await deleteDelivery(env, body)) });
+      case "createPackage": return json({ ok: true, package: await createPackage(env, body) });
+      case "finalizePackage": return json({ ok: true, package: await finalizePackage(env, body) });
+      case "deletePackage": return json({ ok: true, ...(await deletePackage(env, body)) });
+      case "commitHeroes": return json({ ok: true, delivery: await commitHeroes(env, body, new URL(request.url).origin) });
+      case "saveSettings": return json({ ok: true, settings: await saveSettings(env, body) });
+      case "createLink": return json({ ok: true, link: await createLink(env, body, new URL(request.url).origin) });
+      case "updateLink": return json({ ok: true, link: await updateLink(env, body, new URL(request.url).origin) });
+      case "revokeLink": return json({ ok: true, ...(await revokeLink(env, body)) });
+      default: return json({ ok: false, error: "Azione non valida" }, 400);
+    }
+  } catch (e) {
+    console.error(`deliveries ${action}:`, e);
+    const status = e instanceof InputError ? 400 : e instanceof ConflictError ? 409 : 500;
+    return json({ ok: false, error: message(e), code: status === 409 ? "conflict" : "invalid" }, status);
+  }
+}
+
+async function createQuickDelivery(env, body, origin) {
+  const title = required(body.title, "Il nome del transfer è obbligatorio");
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+  await env.DB.prepare(`
+    INSERT INTO deliveries
+      (id,client_name,title,files_expires_at,status,created_at,updated_at)
+    VALUES (?,'',?,?,'uploading',?,?)
+  `).bind(id, title, nullableDate(body.filesExpiresAt), now, now).run();
+  return deliveryDetail(env, id, origin);
+}
+
+async function createDelivery(env, body, origin) {
+  const client = required(body.clientName, "Il cliente è obbligatorio");
+  const title = required(body.title, "Il transfer ha bisogno di un nome");
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+  await env.DB.prepare(`
+    INSERT INTO deliveries
+      (id,client_name,title,description,license_notes,cta_enabled,cta_label,cta_url,
+       expires_at,files_expires_at,status,created_at,updated_at)
+    VALUES (?,?,?,?,?,?,?,?,?,?,'draft',?,?)
+  `).bind(
+    id, client, title, text(body.description), text(body.licenseNotes),
+    bool(body.ctaEnabled), text(body.ctaLabel) || "Lascia una recensione",
+    optionalHttpUrl(body.ctaUrl), nullableDate(body.expiresAt),
+    nullableDate(body.filesExpiresAt), now, now,
+  ).run();
+  return deliveryDetail(env, id, origin);
+}
+
+async function updateDelivery(env, body, origin) {
+  const id = required(body.id, "id del transfer mancante");
+  const current = await env.DB.prepare("SELECT version,status FROM deliveries WHERE id=? AND status!='deleted'")
+    .bind(id).first();
+  if (!current) throw new InputError("Transfer non trovato");
+  if (body.version && Number(body.version) !== Number(current.version)) {
+    throw new ConflictError("Questo transfer è stato modificato in un’altra scheda. Ricarica la pagina.");
+  }
+  const client = text(body.clientName);
+  const title = required(body.title, "Il transfer ha bisogno di un nome");
+  await env.DB.prepare(`
+    UPDATE deliveries SET
+      client_name=?, title=?, description=?, license_notes=?,
+      cta_enabled=?, cta_label=?, cta_url=?, expires_at=?, files_expires_at=?,
+      version=version+1, updated_at=?
+    WHERE id=? AND status!='deleted'
+  `).bind(
+    client, title, text(body.description), text(body.licenseNotes),
+    bool(body.ctaEnabled), text(body.ctaLabel) || "Lascia una recensione",
+    optionalHttpUrl(body.ctaUrl), nullableDate(body.expiresAt), nullableDate(body.filesExpiresAt),
+    new Date().toISOString(), id,
+  ).run();
+  if (body.syncPackageLabel) {
+    await env.DB.prepare(`
+      UPDATE delivery_packages SET label=?,updated_at=?
+      WHERE delivery_id=? AND position=(
+        SELECT MIN(position) FROM delivery_packages WHERE delivery_id=?
+      )
+    `).bind(title, new Date().toISOString(), id, id).run();
+  }
+  return deliveryDetail(env, id, origin);
+}
+
+async function activateDelivery(env, body, origin) {
+  const id = required(body.id, "id del transfer mancante");
+  const ready = await env.DB.prepare(
+    "SELECT COUNT(*) n FROM delivery_packages WHERE delivery_id=? AND state='ready' AND originals_key IS NOT NULL"
+  ).bind(id).first();
+  if (!ready?.n) throw new InputError("Prima carica almeno un file");
+  const now = new Date().toISOString();
+  await env.DB.batch([
+    env.DB.prepare(`
+      UPDATE deliveries SET status='active', activated_at=COALESCE(activated_at,?),
+        updated_at=?, version=version+1 WHERE id=? AND status!='deleted'
+    `).bind(now, now, id),
+    env.DB.prepare(`
+      UPDATE delivery_packages SET originals_purge_after=NULL
+      WHERE delivery_id=? AND originals_key IS NOT NULL
+    `).bind(id),
+  ]);
+  const link = await env.DB.prepare(
+    "SELECT id FROM delivery_links WHERE delivery_id=? AND revoked_at IS NULL LIMIT 1"
+  ).bind(id).first();
+  if (!link) await createLink(env, { id, label: "Link principale" }, origin);
+  return deliveryDetail(env, id, origin);
+}
+
+async function archiveDelivery(env, body, origin) {
+  const id = required(body.id, "id del transfer mancante");
+  const current = await env.DB.prepare("SELECT status FROM deliveries WHERE id=?").bind(id).first();
+  if (current?.status !== "active") throw new InputError("Gli originali si possono togliere solo da un transfer già pronto");
+  const now = new Date();
+  const purge = new Date(now.getTime() + 7 * DAY).toISOString();
+  await env.DB.batch([
+    env.DB.prepare(`
+      UPDATE deliveries SET status='archived',updated_at=?,version=version+1
+      WHERE id=? AND status='active'
+    `).bind(now.toISOString(), id),
+    env.DB.prepare(`
+      UPDATE delivery_packages SET originals_purge_after=?
+      WHERE delivery_id=? AND state='ready' AND originals_key IS NOT NULL
+    `).bind(purge, id),
+  ]);
+  return deliveryDetail(env, id, origin);
+}
+
+async function extendDelivery(env, body, origin) {
+  const id = required(body.id, "id del transfer mancante");
+  const row = await env.DB.prepare(
+    "SELECT files_expires_at FROM deliveries WHERE id=? AND status!='deleted'"
+  ).bind(id).first();
+  if (!row) throw new InputError("Transfer non trovato");
+  const requestedDays = Number(body.days || 30);
+  if (!Number.isInteger(requestedDays)) throw new InputError("Durata non valida");
+  const days = Math.min(365, Math.max(1, requestedDays));
+  const base = row.files_expires_at && new Date(row.files_expires_at).getTime() > Date.now()
+    ? new Date(row.files_expires_at).getTime() : Date.now();
+  const expires = new Date(base + days * DAY).toISOString();
+  await env.DB.prepare(
+    "UPDATE deliveries SET files_expires_at=?,updated_at=?,version=version+1 WHERE id=?"
+  ).bind(expires, new Date().toISOString(), id).run();
+  return deliveryDetail(env, id, origin);
+}
+
+async function duplicateDelivery(env, body, origin) {
+  const source = await env.DB.prepare(
+    "SELECT * FROM deliveries WHERE id=? AND status!='deleted'"
+  ).bind(required(body.id, "id del transfer mancante")).first();
+  if (!source) throw new InputError("Transfer non trovato");
+  return createDelivery(env, {
+    clientName: source.client_name,
+    title: `${source.title} — copia`,
+    description: source.description,
+    licenseNotes: source.license_notes,
+    ctaEnabled: !!source.cta_enabled,
+    ctaLabel: source.cta_label,
+    ctaUrl: source.cta_url,
+    expiresAt: source.expires_at,
+    filesExpiresAt: source.files_expires_at,
+  }, origin);
+}
+
+/* Elimina davvero, subito: niente finestra di grazia. Non esiste un cestino dei
+ * transfer, quindi una tombstone di sette giorni non era recuperabile da
+ * nessuna parte — prometteva soltanto un ripensamento impossibile e lasciava i
+ * byte su B2 finché qualcuno non riapriva il pannello. La tombstone resta come
+ * rete: se una chiamata a B2 fallisce, `purge_after` è già scaduto e
+ * l'housekeeping riprende il lavoro dov'era. */
+async function deleteDelivery(env, body) {
+  const id = required(body.id, "id del transfer mancante");
+  const now = new Date().toISOString();
+  await env.DB.batch([
+    env.DB.prepare("UPDATE deliveries SET status='deleted',deleted_at=?,purge_after=?,updated_at=? WHERE id=?")
+      .bind(now, now, now, id),
+    env.DB.prepare("UPDATE delivery_links SET revoked_at=COALESCE(revoked_at,?) WHERE delivery_id=?")
+      .bind(now, id),
+    env.DB.prepare("UPDATE delivery_packages SET state='deleted',deleted_at=?,purge_after=? WHERE delivery_id=? AND state!='deleted'")
+      .bind(now, now, id),
+    env.DB.prepare("UPDATE delivery_hero_objects SET state='deleted',purge_after=?,updated_at=? WHERE delivery_id=? AND state!='deleted'")
+      .bind(now, now, id),
+  ]);
+  return { purged: await purgeDeliveryNow(env, id) };
+}
+
+async function createPackage(env, body) {
+  const deliveryId = required(body.id, "id del transfer mancante");
+  const delivery = await env.DB.prepare("SELECT id,status FROM deliveries WHERE id=? AND status!='deleted'")
+    .bind(deliveryId).first();
+  if (!delivery) throw new InputError("Transfer non trovato");
+  const id = crypto.randomUUID();
+  const prefix = `deliveries/${deliveryId}/${id}/v1`;
+  const now = new Date().toISOString();
+  const pos = await env.DB.prepare(
+    "SELECT COALESCE(MAX(position),-1)+1 n FROM delivery_packages WHERE delivery_id=?"
+  ).bind(deliveryId).first();
+  await env.DB.batch([
+    env.DB.prepare(`
+      INSERT INTO delivery_packages
+        (id,delivery_id,label,position,gallery_enabled,web_enabled,state,storage_prefix,
+         source_fingerprint,file_count,source_bytes,created_at,updated_at)
+      VALUES (?,?,?,?,?,?,'uploading',?,?,?,?,?,?)
+    `).bind(
+      id, deliveryId, text(body.label) || "Fotografie", Number(pos?.n || 0),
+      bool(body.galleryEnabled), bool(body.webEnabled), prefix,
+      required(body.sourceFingerprint, "impronta dei file mancante"),
+      Number(body.fileCount || 0), Number(body.sourceBytes || 0), now, now,
+    ),
+    env.DB.prepare("UPDATE deliveries SET status=CASE WHEN status='draft' THEN 'uploading' ELSE status END,updated_at=? WHERE id=?")
+      .bind(now, deliveryId),
+  ]);
+  return normalizePackage(await env.DB.prepare("SELECT * FROM delivery_packages WHERE id=?").bind(id).first());
+}
+
+async function finalizePackage(env, body) {
+  const deliveryId = required(body.id, "id del transfer mancante");
+  const packageId = required(body.packageId, "id dei file mancante");
+  const pkg = await env.DB.prepare(
+    "SELECT * FROM delivery_packages WHERE id=? AND delivery_id=? AND state='uploading'"
+  ).bind(packageId, deliveryId).first();
+  if (!pkg) throw new InputError("Non trovo il caricamento da completare");
+  const uploads = await env.DB.prepare(
+    "SELECT variant,object_key,state FROM delivery_uploads WHERE package_id=?"
+  ).bind(packageId).all();
+  const byVariant = Object.fromEntries((uploads.results || []).map((u) => [u.variant, u]));
+  if (byVariant.originals?.state !== "completed") throw new InputError("Il caricamento delle foto non è arrivato in fondo");
+  if ((pkg.web_enabled || pkg.gallery_enabled) && byVariant.web?.state !== "completed") {
+    throw new InputError("La versione leggera non è arrivata in fondo");
+  }
+  if (pkg.gallery_enabled && byVariant.thumbs?.state !== "completed") throw new InputError("Le anteprime non sono arrivate in fondo");
+
+  const manifest = body.manifest && typeof body.manifest === "object" ? body.manifest : null;
+  if (!manifest || !Array.isArray(manifest.entries)) throw new InputError("L’elenco delle foto è arrivato incompleto");
+  const manifestJson = JSON.stringify(manifest);
+  if (manifestJson.length > 1_800_000) throw new InputError("Troppe foto in un transfer solo: dividile in due invii");
+  const manifestKey = b2ObjectKey(pkg.storage_prefix, "manifest.json");
+  await b2PutSmall(env, manifestKey, manifestJson, "application/json");
+
+  const now = new Date().toISOString();
+  await env.DB.prepare(`
+    UPDATE delivery_packages SET state='ready', originals_key=?, web_key=?, thumbs_key=?,
+      manifest_key=?, manifest_json=?, file_count=?, source_bytes=?, stored_bytes=?, updated_at=?
+    WHERE id=?
+  `).bind(
+    byVariant.originals.object_key,
+    byVariant.web?.object_key || null,
+    byVariant.thumbs?.object_key || null,
+    manifestKey, manifestJson, Number(body.fileCount || manifest.entries.length),
+    Number(body.sourceBytes || 0), Number(body.storedBytes || 0), now, packageId,
+  ).run();
+  return normalizePackage(await env.DB.prepare("SELECT * FROM delivery_packages WHERE id=?").bind(packageId).first());
+}
+
+async function deletePackage(env, body) {
+  const packageId = required(body.packageId, "id dei file mancante");
+  const now = new Date().toISOString();
+  await env.DB.batch([
+    env.DB.prepare(`
+      UPDATE delivery_packages SET state='deleted',deleted_at=?,purge_after=?,updated_at=? WHERE id=?
+    `).bind(now, now, now, packageId),
+    env.DB.prepare(`
+      UPDATE delivery_hero_objects SET state='deleted',purge_after=?,updated_at=?
+      WHERE package_id=? AND state!='deleted'
+    `).bind(now, now, packageId),
+  ]);
+  return { purged: await purgePackageNow(env, packageId) };
+}
+
+async function commitHeroes(env, body, origin) {
+  const deliveryId = required(body.id, "id del transfer mancante");
+  const requested = Array.isArray(body.heroes) ? body.heroes.slice(0, 8) : [];
+  const delivery = await env.DB.prepare(
+    "SELECT hero_json FROM deliveries WHERE id=? AND status!='deleted'"
+  ).bind(deliveryId).first();
+  if (!delivery) throw new InputError("Transfer non trovato");
+  const sanitized = [];
+  const objectUpdates = [];
+  for (const item of requested) {
+    if (item?.type === "package") {
+      const pkg = await env.DB.prepare(`
+        SELECT manifest_json FROM delivery_packages
+        WHERE id=? AND delivery_id=? AND state='ready' AND web_key IS NOT NULL
+      `).bind(text(item.packageId), deliveryId).first();
+      const index = Number(item.index);
+      const entry = parseManifest(pkg?.manifest_json)?.entries?.[index];
+      if (!pkg || !Number.isInteger(index) || index < 0 || !entry?.web) {
+        throw new InputError("Una delle foto di copertina non è più disponibile");
+      }
+      sanitized.push({ type: "package", packageId: text(item.packageId), index });
+    } else if (item?.type === "object") {
+      const id = text(item.id);
+      const row = await env.DB.prepare(`
+        SELECT id FROM delivery_hero_objects
+        WHERE id=? AND delivery_id=? AND state IN ('pending','ready')
+      `).bind(id, deliveryId).first();
+      if (!row) throw new InputError("Una delle immagini di copertina caricate non è disponibile");
+      sanitized.push({ type: "object", id });
+      objectUpdates.push({
+        id, sourceName: text(item.sourceName), width: positiveInt(item.width),
+        height: positiveInt(item.height), bytes: positiveInt(item.bytes),
+      });
+    } else {
+      throw new InputError("Copertina non valida");
+    }
+  }
+  const oldObjects = parseHeroRefs(delivery.hero_json)
+    .filter((item) => item.type === "object").map((item) => item.id);
+  const selectedObjects = new Set(objectUpdates.map((item) => item.id));
+  const now = new Date();
+  const purge = new Date(now.getTime() + 7 * DAY).toISOString();
+  const statements = [
+    env.DB.prepare(`
+      UPDATE deliveries SET hero_json=?,version=version+1,updated_at=? WHERE id=?
+    `).bind(JSON.stringify(sanitized), now.toISOString(), deliveryId),
+    ...objectUpdates.map((item) => env.DB.prepare(`
+      UPDATE delivery_hero_objects SET state='ready',source_name=?,width=?,height=?,bytes=?,
+        updated_at=?,purge_after=NULL WHERE id=? AND delivery_id=?
+    `).bind(
+      item.sourceName, item.width, item.height, item.bytes,
+      now.toISOString(), item.id, deliveryId,
+    )),
+    ...oldObjects.filter((id) => !selectedObjects.has(id)).map((id) => env.DB.prepare(`
+      UPDATE delivery_hero_objects SET state='deleted',purge_after=?,updated_at=?
+      WHERE id=? AND delivery_id=?
+    `).bind(purge, now.toISOString(), id, deliveryId)),
+  ];
+  await env.DB.batch(statements);
+  return deliveryDetail(env, deliveryId, origin);
+}
+
+async function saveSettings(env, body) {
+  const values = Array.isArray(body.defaultHeroes) ? body.defaultHeroes.slice(0, 8) : [];
+  const heroes = values.map((value) => {
+    const url = text(value);
+    if (!/^\/media\/[^?#]+$/.test(url)) throw new InputError("La copertina predefinita si sceglie dalla libreria Media");
+    return url;
+  });
+  const now = new Date().toISOString();
+  await env.DB.prepare(`
+    INSERT INTO delivery_settings(key,value_json,updated_at) VALUES ('default_heroes',?,?)
+    ON CONFLICT(key) DO UPDATE SET value_json=excluded.value_json,updated_at=excluded.updated_at
+  `).bind(JSON.stringify(heroes), now).run();
+  return { defaultHeroes: heroes };
+}
+
+async function deliverySettings(env) {
+  const row = await env.DB.prepare(
+    "SELECT value_json FROM delivery_settings WHERE key='default_heroes'"
+  ).first();
+  return { defaultHeroes: parseStringArray(row?.value_json) };
+}
+
+async function createLink(env, body, origin) {
+  const deliveryId = required(body.id, "id del transfer mancante");
+  const exists = await env.DB.prepare("SELECT id FROM deliveries WHERE id=? AND status!='deleted'")
+    .bind(deliveryId).first();
+  if (!exists) throw new InputError("Transfer non trovato");
+  const token = randomToken(24);
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+  const pin = text(body.pin);
+  await env.DB.prepare(`
+    INSERT INTO delivery_links
+      (id,delivery_id,label,token_hash,token_ciphertext,pin_ciphertext,expires_at,created_at)
+    VALUES (?,?,?,?,?,?,?,?)
+  `).bind(
+    id, deliveryId, text(body.label) || "Link principale", await sha256(token),
+    await seal(env.DELIVERY_SECRET, token),
+    pin ? await seal(env.DELIVERY_SECRET, pin) : null,
+    nullableDate(body.expiresAt), now,
+  ).run();
+  return {
+    id, label: text(body.label) || "Link principale", token,
+    url: `${origin}/c/${token}`, pin: pin || null, expiresAt: nullableDate(body.expiresAt),
+    revokedAt: null, openedCount: 0, downloadCount: 0, createdAt: now,
+  };
+}
+
+async function updateLink(env, body, origin) {
+  const deliveryId = required(body.id, "id del transfer mancante");
+  const linkId = required(body.linkId, "id link mancante");
+  const link = await env.DB.prepare(`
+    SELECT * FROM delivery_links WHERE id=? AND delivery_id=? AND revoked_at IS NULL
+  `).bind(linkId, deliveryId).first();
+  if (!link) throw new InputError("Link non trovato");
+  const pin = text(body.pin);
+  const label = text(body.label) || link.label || "Link principale";
+  const expiresAt = nullableDate(body.expiresAt);
+  await env.DB.prepare(`
+    UPDATE delivery_links SET label=?,pin_ciphertext=?,expires_at=? WHERE id=? AND delivery_id=?
+  `).bind(
+    label, pin ? await seal(env.DELIVERY_SECRET, pin) : null,
+    expiresAt, linkId, deliveryId,
+  ).run();
+  const token = await unseal(env.DELIVERY_SECRET, link.token_ciphertext);
+  return {
+    id: linkId, label, token, url: `${origin}/c/${token}`, pin: pin || null,
+    expiresAt, revokedAt: null, createdAt: link.created_at,
+    openedCount: Number(link.opened_count || 0), lastOpenedAt: link.last_opened_at,
+    downloadCount: Number(link.download_count || 0), lastDownloadAt: link.last_download_at,
+  };
+}
+
+async function revokeLink(env, body) {
+  const linkId = required(body.linkId, "id link mancante");
+  const at = new Date().toISOString();
+  await env.DB.prepare("UPDATE delivery_links SET revoked_at=COALESCE(revoked_at,?) WHERE id=?")
+    .bind(at, linkId).run();
+  return { revokedAt: at };
+}
+
+async function deliveryDetail(env, id, origin) {
+  const row = await env.DB.prepare("SELECT * FROM deliveries WHERE id=? AND status!='deleted'").bind(id).first();
+  if (!row) return null;
+  const [packagesResult, linksResult] = await Promise.all([
+    env.DB.prepare("SELECT * FROM delivery_packages WHERE delivery_id=? AND state!='deleted' ORDER BY position").bind(id).all(),
+    env.DB.prepare("SELECT * FROM delivery_links WHERE delivery_id=? ORDER BY created_at").bind(id).all(),
+  ]);
+  const links = [];
+  for (const link of (linksResult.results || [])) {
+    let token = "";
+    let pin = null;
+    try {
+      token = await unseal(env.DELIVERY_SECRET, link.token_ciphertext);
+      pin = link.pin_ciphertext ? await unseal(env.DELIVERY_SECRET, link.pin_ciphertext) : null;
+    } catch (e) {
+      console.error("delivery link decrypt:", e);
+    }
+    links.push({
+      id: link.id, label: link.label, token, pin,
+      url: token ? `${origin}/c/${token}` : "",
+      expiresAt: link.expires_at, revokedAt: link.revoked_at, createdAt: link.created_at,
+      openedCount: Number(link.opened_count || 0), lastOpenedAt: link.last_opened_at,
+      downloadCount: Number(link.download_count || 0), lastDownloadAt: link.last_download_at,
+    });
+  }
+  return {
+    ...normalizeDelivery(row),
+    packages: (packagesResult.results || []).map(packageDetail),
+    heroes: await normalizeHeroes(env, row.hero_json),
+    links,
+  };
+}
+
+function normalizeDelivery(row) {
+  return {
+    id: row.id, clientName: row.client_name, title: row.title,
+    description: row.description || "", licenseNotes: row.license_notes || "",
+    ctaEnabled: !!row.cta_enabled, ctaLabel: row.cta_label || "",
+    ctaUrl: row.cta_url || "", expiresAt: row.expires_at,
+    filesExpiresAt: row.files_expires_at || null,
+    heroes: [],
+    status: row.status, version: Number(row.version || 1),
+    createdAt: row.created_at, updatedAt: row.updated_at, activatedAt: row.activated_at,
+    packageCount: Number(row.package_count || 0), linkCount: Number(row.link_count || 0),
+    storedBytes: Number(row.stored_bytes || 0), downloadCount: Number(row.download_count || 0),
+  };
+}
+
+function normalizePackage(row) {
+  return {
+    id: row.id, deliveryId: row.delivery_id, label: row.label, position: Number(row.position || 0),
+    galleryEnabled: !!row.gallery_enabled, webEnabled: !!row.web_enabled, state: row.state,
+    sourceFingerprint: row.source_fingerprint || "",
+    fileCount: Number(row.file_count || 0), sourceBytes: Number(row.source_bytes || 0),
+    storedBytes: Number(row.stored_bytes || 0), createdAt: row.created_at, updatedAt: row.updated_at,
+  };
+}
+
+function packageDetail(row) {
+  const pkg = normalizePackage(row);
+  const manifest = parseManifest(row.manifest_json);
+  return {
+    ...pkg,
+    images: (manifest?.entries || []).map((entry, index) => entry?.web ? {
+      index, name: entry.name || `Immagine ${index + 1}`,
+      previewUrl: `/admin/api/delivery/image?packageId=${encodeURIComponent(row.id)}` +
+        `&variant=${entry.thumb ? "thumb" : "web"}&index=${index}`,
+    } : null).filter(Boolean),
+  };
+}
+
+async function normalizeHeroes(env, value) {
+  const out = [];
+  for (const ref of parseHeroRefs(value)) {
+    if (ref.type === "package") {
+      const pkg = await env.DB.prepare(`
+        SELECT manifest_json FROM delivery_packages
+        WHERE id=? AND state='ready' AND web_key IS NOT NULL
+      `).bind(text(ref.packageId)).first();
+      const index = Number(ref.index);
+      if (pkg && Number.isInteger(index) && parseManifest(pkg.manifest_json)?.entries?.[index]?.web) {
+        out.push({
+          type: "package", packageId: text(ref.packageId), index,
+          previewUrl: `/admin/api/delivery/image?packageId=${encodeURIComponent(ref.packageId)}` +
+            `&variant=web&index=${index}`,
+        });
+      }
+    } else {
+      const row = await env.DB.prepare(`
+        SELECT source_name,width,height FROM delivery_hero_objects
+        WHERE id=? AND state='ready'
+      `).bind(ref.id).first();
+      if (row) out.push({
+        ...ref, sourceName: row.source_name, width: Number(row.width || 0),
+        height: Number(row.height || 0),
+        previewUrl: `/admin/api/delivery/hero?id=${encodeURIComponent(ref.id)}`,
+      });
+    }
+  }
+  return out;
+}
+
+function parseManifest(value) {
+  try { return JSON.parse(value || "{}"); } catch { return { entries: [] }; }
+}
+function parseHeroRefs(value) {
+  try {
+    const parsed = JSON.parse(value || "[]");
+    return Array.isArray(parsed) ? parsed : [];
+  } catch { return []; }
+}
+function parseStringArray(value) {
+  try {
+    const parsed = JSON.parse(value || "[]");
+    return Array.isArray(parsed) ? parsed.map(String) : [];
+  } catch { return []; }
+}
+function positiveInt(value) {
+  const n = Number(value || 0);
+  return Number.isFinite(n) && n > 0 ? Math.round(n) : 0;
+}
+
+function text(value) { return String(value ?? "").trim(); }
+function bool(value) { return value ? 1 : 0; }
+function required(value, error) {
+  const out = text(value);
+  if (!out) throw new InputError(error);
+  return out;
+}
+function nullableDate(value) {
+  if (!value) return null;
+  const d = new Date(value);
+  if (Number.isNaN(d.getTime())) throw new InputError("Data non valida");
+  return d.toISOString();
+}
+function optionalHttpUrl(value) {
+  const raw = text(value);
+  if (!raw) return "";
+  let url;
+  try { url = new URL(raw); }
+  catch { throw new InputError("Indirizzo del pulsante non valido"); }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new InputError("L’indirizzo del pulsante deve iniziare con https:// o http://");
+  }
+  return url.toString();
+}
+function message(e) { return e instanceof Error ? e.message : String(e); }
+class InputError extends Error {}
+class ConflictError extends Error {}
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status, headers: { "Content-Type": "application/json", "Cache-Control": "no-store" },
+  });
+}

package/dist/functions/api/delivery/hero.js

@@ -0,0 +1,21 @@
+/* Derivata hero dedicata: oggetto piccolo B2, mai l'originale fotografico. */
+import { b2Get } from "../../_shared/b2.js";
+
+export async function onRequestGet({ request, env }) {
+  if (!env.DB) return new Response("D1 non configurato", { status: 500 });
+  const id = new URL(request.url).searchParams.get("id") || "";
+  const hero = await env.DB.prepare(`
+    SELECT object_key,bytes FROM delivery_hero_objects WHERE id=? AND state='ready'
+  `).bind(id).first();
+  if (!hero) return new Response("Not found", { status: 404 });
+  const upstream = await b2Get(env, hero.object_key);
+  if (!upstream.ok) return new Response("Not found", { status: upstream.status });
+  const headers = new Headers({
+    "Content-Type": "image/webp",
+    "Cache-Control": "private, max-age=3600",
+    "X-Content-Type-Options": "nosniff",
+  });
+  const length = upstream.headers.get("content-length") || (hero.bytes ? String(hero.bytes) : "");
+  if (length) headers.set("Content-Length", length);
+  return new Response(upstream.body, { headers });
+}