@cardinali-studio/adminkit 2.2.2 → 2.2.5

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/App.js

@@ -58,6 +58,7 @@ export function App() {
     const local = isLocalPreview();
     const pages = usePages();
     const home = useHome(section === "home");
+    const HomeEditorView = site().homeEditor ?? HomeEditor;
     /* Anche la Panoramica: le sue card devono sapere quali funzioni aggiuntive sono attive, e
        lo stato è quello — non una seconda copia. È una lettura sola, e la Panoramica è la
        schermata da cui si entra, quindi arriva prima che serva. */
@@ -257,7 +258,7 @@ export function App() {
                                         /* Con un errore di caricamento c'era solo la riga rossa: nessun modo di riprovare
                                            se non ricaricando il pannello a mano. Le altre sezioni il bottone ce l'hanno. */
                                         home.error ? (_jsxs("div", { className: "pane-empty", children: [_jsx("p", { className: "ak-error", children: home.error }), _jsx("button", { className: "ak-btn", onClick: () => void home.load(), children: "Riprova" })] }))
-                                            : home.data ? _jsx(HomeEditor, { data: home.data, group: homeGroup, onChange: home.change, pickMedia: pickMedia })
+                                            : home.data ? _jsx(HomeEditorView, { data: home.data, group: homeGroup, onChange: home.change, pickMedia: pickMedia })
                                                 : _jsx("p", { className: "ak-hint", children: "Carico\u2026" })), section === "settings" && (settings.error ? (_jsxs("div", { className: "pane-empty", children: [_jsx("p", { className: "ak-error", children: settings.error }), _jsx("button", { className: "ak-btn", onClick: () => void settings.load(), children: "Riprova" })] })) : settings.data ? (settingsView === "seo"
                                             ? _jsx(WebsiteSeoSettingsEditor, { value: settings.data, onChange: settings.change })
                                             : _jsx(SiteSettingsEditor, { value: settings.data, onChange: settings.change, pickMediaFiles: pickMediaFiles, focus: route[1] })) : _jsx("p", { className: "pane-empty ak-hint", children: "Carico\u2026" })), view === "media" && _jsx(MediaGrid, { lib: media }), view === "trash" && _jsx(Trash, {}), section === "requests" && (requests.error ? _jsx("p", { className: "ak-error", children: requests.error })

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/app/lib/settings.js

@@ -45,7 +45,11 @@ export function useSiteSettings(active) {
                 const payload = document.draftPayload ?? document.publishedPayload;
                 if (!payload || (document.draftPayload !== null ? document.draftTombstone : document.publishedTombstone))
                     throw new Error("content_unavailable");
-                setData({ ...empty, ...JSON.parse(payload), password: "" });
+                const stored = JSON.parse(payload);
+                const settings = mapped.fromPayload ? mapped.fromPayload(stored) : stored;
+                if (!settings || typeof settings !== "object" || Array.isArray(settings))
+                    throw new Error("content_unavailable");
+                setData({ ...empty, ...settings, password: "" });
                 setRevision({ base: document.draftRevisionId ?? document.publishedRevisionId, expected: document.draftRevisionId });
             }
             else {
@@ -72,7 +76,8 @@ export function useSiteSettings(active) {
             const mapped = site().siteSettingsDocument;
             if (contentPersistenceMode() === "d1" && mapped && revision) {
                 const revisionId = crypto.randomUUID();
-                await api.saveContent({ revisionId, documentId: mapped.documentId, baseRevisionId: revision.base, expectedDraftRevisionId: revision.expected, kind: mapped.kind, locale: mapped.locale, schemaVersion: mapped.schemaVersion, payload: data, tombstone: false });
+                const payload = mapped.toPayload ? mapped.toPayload(data) : data;
+                await api.saveContent({ revisionId, documentId: mapped.documentId, baseRevisionId: revision.base, expectedDraftRevisionId: revision.expected, kind: mapped.kind, locale: mapped.locale, schemaVersion: mapped.schemaVersion, payload: payload, tombstone: false });
                 setRevision({ base: revisionId, expected: revisionId });
                 setDirty(false);
                 setNotice("Bozza D1 salvata");

package/dist/app/site.d.ts

@@ -1,4 +1,5 @@
 import type * as z from "zod";
+import type { ComponentType } from "react";
 export type Shape = Record<string, z.ZodType>;
 /** Contratto di UNA tipologia di pagina. Il tipo sceglie la forma prima che un file venga
  * letto, validato o riscritto: non esiste più uno schema che contenga i campi di tutte le
@@ -38,6 +39,17 @@ export interface SiteAdminConfig {
     languages?: LanguagesConfig;
     /** Forma del singleton home: i suoi `group` diventano le voci della seconda colonna. */
     home: Shape;
+    /** Optional site-owned Home surface. The kit keeps its legacy visual editor
+     * as a fallback, while a site with a different document shape can render its
+     * own schema-driven editor without teaching the shared package its fields. */
+    homeEditor?: ComponentType<{
+        data: Record<string, unknown>;
+        group: string;
+        onChange: (next: Record<string, unknown>) => void;
+        pickMedia: (opts: {
+            multiple: boolean;
+        }) => Promise<string[] | null>;
+    }>;
     /** Peso di ordinamento di una pagina data la sua posizione nell'elenco. */
     positionWeight: (item: Record<string, unknown>, index: number, all: Record<string, unknown>[]) => number;
     /**
@@ -56,11 +68,16 @@ export interface SiteAdminConfig {
         locale: string;
         schemaVersion: number;
     };
+    /** Identity plus the deliberately site-owned conversion between the generic
+     * settings form and an immutable D1 document payload. A site may persist the
+     * object directly or keep it inside a repository-specific file envelope. */
     siteSettingsDocument?: {
         documentId: string;
         kind: string;
         locale: string;
         schemaVersion: number;
+        fromPayload?: (payload: unknown) => Record<string, unknown>;
+        toPayload?: (settings: Record<string, unknown>) => unknown;
     };
 }
 /** Chiamata da `mountAdmin` prima del primo render. */

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.5",
   "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",