@cardinali-studio/adminkit 2.2.2 → 2.2.3

package/dist/api.d.ts

@@ -132,6 +132,26 @@ export declare const api: {
         ok: true;
         discarded: true;
     }>;
+    /** D1 publication is site-owned: the site chooses which documents it can
+     * materialize, while the panel only displays the pending immutable inputs. */
+    contentPublishState: () => Promise<{
+        ok: true;
+        configured: true;
+        ahead: number;
+        documents: {
+            documentId: string;
+            kind: string;
+            updatedAt: number;
+        }[];
+        activeReleaseId?: string | null;
+    }>;
+    contentPublish: () => Promise<{
+        ok: true;
+        published: boolean;
+        releaseId?: string;
+        attemptId?: string;
+        message?: string;
+    }>;
     publishState: () => Promise<{
         ok: true;
         configured: boolean;

package/dist/api.js

@@ -60,6 +60,10 @@ export const api = {
     contentDocument: (documentId) => call(`/admin/api/content/document?id=${encodeURIComponent(documentId)}`),
     saveContent: async (command) => post("/admin/api/content/save", await contentSaveRequest(command)),
     discardContent: (documentId, expectedDraftRevisionId, baselineRevisionId) => post("/admin/api/content/discard", { documentId, expectedDraftRevisionId, baselineRevisionId }),
+    /** D1 publication is site-owned: the site chooses which documents it can
+     * materialize, while the panel only displays the pending immutable inputs. */
+    contentPublishState: () => call("/admin/api/content/publish"),
+    contentPublish: () => post("/admin/api/content/publish", {}),
     // ---- pubblicazione
     /* Salvare scrive sulla bozza e non fa partire nessuna build; è questo che manda online. Due
      * gesti separati, quindi due chiamate: una chiede quanto c'è di non pubblicato, l'altra lo

package/dist/app/lib/publish.js

@@ -17,10 +17,19 @@ export function usePublish() {
     const [error, setError] = useState(null);
     const reload = useCallback(async () => {
         if (contentPersistenceMode() === "d1") {
-            setAhead(0);
-            setCommits([]);
-            setConfigured(false);
-            setError("La pubblicazione D1 non è ancora disponibile in questa versione del pannello.");
+            try {
+                const d = await api.contentPublishState();
+                setAhead(d.ahead ?? 0);
+                setCommits((d.documents ?? []).map((document) => ({
+                    message: `Modifica salvata (${document.kind})`, date: document.updatedAt ? new Date(document.updatedAt).toISOString() : null,
+                })));
+                setConfigured(true);
+                setError(null);
+            }
+            catch (e) {
+                setConfigured(false);
+                setError(e instanceof ApiError ? e.message : String(e));
+            }
             return;
         }
         try {
@@ -42,7 +51,22 @@ export function usePublish() {
     useEffect(() => { void reload(); }, [reload]);
     const publish = useCallback(async () => {
         if (contentPersistenceMode() === "d1") {
-            setNotice("La pubblicazione D1 non è ancora disponibile in questa versione del pannello.");
+            setPublishing(true);
+            setNotice(null);
+            try {
+                const r = await api.contentPublish();
+                setNotice(r.published === false
+                    ? r.message ?? "Non c'erano modifiche salvate da pubblicare."
+                    : "Pubblicazione avviata. Il sito si aggiorna fra qualche minuto.");
+                await reload();
+            }
+            catch (e) {
+                const err = e;
+                setNotice(`Pubblicazione non riuscita: ${err.message}`);
+            }
+            finally {
+                setPublishing(false);
+            }
             return;
         }
         setPublishing(true);

package/dist/deployment.d.ts

@@ -7,6 +7,7 @@ export type DeploymentAttempt = Readonly<{
     intentKind: DeploymentIntent;
     releaseId: string;
     codeSha: string | null;
+    expectedFingerprint: string | null;
     phase: DeploymentPhase;
     claimTokenChecksum: string | null;
     claimExpiresAt: number | null;
@@ -36,6 +37,7 @@ export declare class DeploymentAttemptKernel {
         intentKind: DeploymentIntent;
         releaseId: string;
         codeSha: string | null;
+        expectedFingerprint: string | null;
         phase: DeploymentPhase;
         claimTokenChecksum: string | null;
         claimExpiresAt: number | null;

package/dist/deployment.js

@@ -75,7 +75,7 @@ function asAttempt(row) {
     if (!row?.releaseId)
         return null;
     return {
-        attemptId: row.attemptId, intentKind: row.intentKind, releaseId: row.releaseId, codeSha: row.codeSha,
+        attemptId: row.attemptId, intentKind: row.intentKind, releaseId: row.releaseId, codeSha: row.codeSha, expectedFingerprint: row.expectedFingerprint,
         phase: row.phase, claimTokenChecksum: row.claimTokenChecksum, claimExpiresAt: row.claimExpiresAt,
     };
 }
@@ -88,7 +88,8 @@ export class D1DeploymentAttemptRepository {
     }
     async get(attemptId) {
         const row = await this.db.prepare(`SELECT attempt_id AS attemptId, intent_kind AS intentKind, release_id AS releaseId,
-      code_sha AS codeSha, phase, ci_claim_token_checksum AS claimTokenChecksum, ci_claim_expires_at AS claimExpiresAt
+      code_sha AS codeSha, expected_fingerprint AS expectedFingerprint, phase,
+      ci_claim_token_checksum AS claimTokenChecksum, ci_claim_expires_at AS claimExpiresAt
       FROM production_deployment_attempts WHERE attempt_id = ?`).bind(attemptId).first();
         return asAttempt(row);
     }

package/dist/functions/api/content-ci.js

@@ -109,7 +109,10 @@ export async function handleInternalContentCi({ request, env }) {
       const { attempt } = await claimedAttempt(request, attempts, identity, now);
       const snapshot = await content.getReleaseExport(attempt.releaseId);
       if (!snapshot) throw new Error("attempt_not_available");
-      return response({ ok: true, attempt: { attemptId: attempt.attemptId, releaseId: attempt.releaseId, phase: attempt.phase }, release: await releaseExportFromStored(snapshot) });
+      return response({ ok: true, attempt: {
+        attemptId: attempt.attemptId, releaseId: attempt.releaseId, codeSha: attempt.codeSha,
+        expectedFingerprint: attempt.expectedFingerprint, phase: attempt.phase,
+      }, release: await releaseExportFromStored(snapshot) });
     }
 
     const input = await body(request);

package/dist/persistence.d.ts

@@ -116,6 +116,16 @@ export type ReleaseInput = {
         revisionId: string;
     }[];
 };
+export type ReleaseDeploymentInput = ReleaseInput & {
+    attempt: {
+        attemptId: string;
+        intentKind: string;
+        requestedReleaseId: string | null;
+        requestedCodeSha: string;
+        codeSha: string;
+        expectedFingerprint: string;
+    };
+};
 export type ContentImportRun = {
     importId: string;
     requestChecksum: string;
@@ -149,6 +159,20 @@ export declare class D1ContentRepository {
     save(input: SaveInput): Promise<"created" | "repeated">;
     discard(documentId: string, expectedDraftRevisionId: string | null, baselineRevisionId: string | null, now: number): Promise<void>;
     publish(input: ReleaseInput): Promise<"created" | "repeated">;
+    /** Candidate release and deployment-lane reservation are inseparable: a
+     * failed reservation must not leave an unclaimable publishing release. */
+    publishWithDeploymentAttempt(input: ReleaseDeploymentInput): Promise<"created">;
+    /** The browser-side dispatcher is allowed to undo only an untouched waiting
+     * attempt. Once CI has claimed it, failure handling belongs exclusively to
+     * the short-lived CI capability. */
+    abortUnclaimedDeploymentAttempt(input: {
+        attemptId: string;
+        releaseId: string;
+        now: number;
+        code: string;
+        stage: string;
+        message: string;
+    }): Promise<void>;
     finalize(releaseId: string, now: number): Promise<void>;
 }
 /** Pure strict-CAS kernel. The D1 adapter uses these guards around its SQL operations. */

package/dist/persistence.js

@@ -232,6 +232,67 @@ export class D1ContentRepository {
             throw new Error("invalid_document");
         return "created";
     }
+    /** Candidate release and deployment-lane reservation are inseparable: a
+     * failed reservation must not leave an unclaimable publishing release. */
+    async publishWithDeploymentAttempt(input) {
+        const [existingRelease, existingAttempt] = await Promise.all([
+            this.db.prepare("SELECT release_id FROM content_releases WHERE release_id = ?").bind(input.releaseId).first(),
+            this.db.prepare("SELECT attempt_id FROM production_deployment_attempts WHERE attempt_id = ?").bind(input.attempt.attemptId).first(),
+        ]);
+        if (existingRelease || existingAttempt)
+            throw new Error("duplicate_request");
+        const state = await this.db.prepare("SELECT current_release_id FROM content_site_state WHERE singleton = 1").first();
+        if (!state)
+            throw new Error("content_unavailable");
+        const inherited = state.current_release_id
+            ? (await this.db.prepare("SELECT document_id, revision_id FROM content_release_entries WHERE release_id = ?").bind(state.current_release_id).all()).results ?? []
+            : [];
+        const manifest = new Map(inherited.map((entry) => [entry.document_id, entry.revision_id]));
+        const selected = [...input.entries];
+        if (!selected.length)
+            throw new Error("invalid_document");
+        for (const entry of selected)
+            manifest.set(entry.documentId, entry.revisionId);
+        const selectionGuard = selected.map(() => "EXISTS (SELECT 1 FROM content_documents WHERE document_id = ? AND draft_revision_id = ?)").join(" AND ");
+        const candidate = this.db.prepare(`INSERT INTO content_releases (release_id, base_release_id, request_checksum, status, active_slot, manifest_checksum, schema_package_version, materializer_version, created_by_subject, created_at)
+      SELECT ?, current_release_id, ?, 'publishing', 1, ?, ?, ?, ?, ? FROM content_site_state
+      WHERE singleton = 1 AND current_release_id IS ? AND NOT EXISTS (SELECT 1 FROM content_releases WHERE active_slot = 1)
+        AND NOT EXISTS (SELECT 1 FROM production_deployment_attempts WHERE active_slot = 1) AND ${selectionGuard}`)
+            .bind(input.releaseId, input.requestChecksum, input.manifestChecksum, input.schemaPackageVersion, input.materializerVersion, input.authorSubject, input.now, state.current_release_id, ...selected.flatMap((entry) => [entry.documentId, entry.revisionId]));
+        const statements = [candidate];
+        for (const [documentId, revisionId] of manifest)
+            statements.push(this.db.prepare("INSERT INTO content_release_entries (release_id, document_id, revision_id) SELECT ?, ?, ? WHERE EXISTS (SELECT 1 FROM content_revisions WHERE document_id = ? AND revision_id = ?)")
+                .bind(input.releaseId, documentId, revisionId, documentId, revisionId));
+        statements.push(this.db.prepare(`INSERT INTO production_deployment_attempts
+      (attempt_id, intent_kind, requested_release_id, requested_code_sha, code_sha, release_id, expected_fingerprint, phase, active_slot, created_at, updated_at)
+      SELECT ?, ?, ?, ?, ?, ?, ?, 'waiting', 1, ?, ?
+      WHERE NOT EXISTS (SELECT 1 FROM production_deployment_attempts WHERE active_slot = 1)
+        AND EXISTS (SELECT 1 FROM content_releases WHERE release_id = ? AND status = 'publishing')`)
+            .bind(input.attempt.attemptId, input.attempt.intentKind, input.attempt.requestedReleaseId, input.attempt.requestedCodeSha, input.attempt.codeSha, input.releaseId, input.attempt.expectedFingerprint, input.now, input.now, input.releaseId));
+        const results = await this.db.batch(statements);
+        if (results[0]?.meta?.changes !== 1 || results.slice(1, -1).some((result) => result.meta?.changes !== 1)
+            || results.at(-1)?.meta?.changes !== 1)
+            throw new Error("deployment_lane_busy");
+        return "created";
+    }
+    /** The browser-side dispatcher is allowed to undo only an untouched waiting
+     * attempt. Once CI has claimed it, failure handling belongs exclusively to
+     * the short-lived CI capability. */
+    async abortUnclaimedDeploymentAttempt(input) {
+        const guard = `EXISTS (SELECT 1 FROM production_deployment_attempts WHERE attempt_id = ? AND release_id = ?
+      AND phase = 'waiting' AND ci_claim_token_checksum IS NULL AND ci_claim_expires_at IS NULL)`;
+        const results = await this.db.batch([
+            this.db.prepare(`UPDATE content_releases SET status = 'failed', active_slot = NULL, finished_at = ?
+        WHERE release_id = ? AND status = 'publishing' AND ${guard}`)
+                .bind(input.now, input.releaseId, input.attemptId, input.releaseId),
+            this.db.prepare(`UPDATE production_deployment_attempts
+        SET phase = 'failed', active_slot = NULL, error_code = ?, error_stage = ?, safe_message = ?, updated_at = ?, finished_at = ?
+        WHERE attempt_id = ? AND release_id = ? AND phase = 'waiting' AND ci_claim_token_checksum IS NULL AND ci_claim_expires_at IS NULL`)
+                .bind(input.code, input.stage, input.message, input.now, input.now, input.attemptId, input.releaseId),
+        ]);
+        if (results[0]?.meta?.changes !== 1 || results[1]?.meta?.changes !== 1)
+            throw new Error("attempt_unavailable");
+    }
     async finalize(releaseId, now) {
         const release = await this.db.prepare("SELECT release_id, request_checksum, status, base_release_id FROM content_releases WHERE release_id = ?").bind(releaseId).first();
         if (!release || release.status !== "publishing")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cardinali-studio/adminkit",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "type": "module",
   "description": "Motore riusabile di un pannello di amministrazione per siti Hugo su Cloudflare Pages: codec del front matter guidato dallo schema, form React, libreria media su R2. NIENTE di specifico di un sito qui dentro.",
   "license": "UNLICENSED",