@cedros/data-react 0.1.0

package/dist/admin/sections/CollectionsSection.js

@@ -0,0 +1,125 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from "react";
+import { requestJson } from "../api.js";
+import { AdminButton, Card, JsonEditor, SelectInput, StatusNotice, TextInput } from "../components.js";
+const RESERVED_COLLECTIONS = new Set(["pages", "navigation", "site_settings"]);
+export default function CollectionsSection({ pluginContext }) {
+    const canWriteCollections = pluginContext.hasPermission("data:collections:write");
+    const [collections, setCollections] = useState([]);
+    const [selectedCollectionName, setSelectedCollectionName] = useState("");
+    const [collectionName, setCollectionName] = useState("");
+    const [mode, setMode] = useState("jsonb");
+    const [tableName, setTableName] = useState("");
+    const [strictContractJson, setStrictContractJson] = useState("");
+    const [status, setStatus] = useState("");
+    const [tone, setTone] = useState("neutral");
+    const [loading, setLoading] = useState(false);
+    const reservedCollection = RESERVED_COLLECTIONS.has(collectionName.trim());
+    const load = useCallback(async () => {
+        setLoading(true);
+        setStatus("");
+        setTone("neutral");
+        try {
+            const data = await requestJson(pluginContext, "/admin/collections");
+            setCollections(data);
+            setSelectedCollectionName((current) => {
+                if (current && data.some((collection) => collection.collection_name === current)) {
+                    return current;
+                }
+                return data[0]?.collection_name || "";
+            });
+        }
+        catch (error) {
+            setStatus(error.message);
+            setTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [pluginContext]);
+    useEffect(() => {
+        void load();
+    }, [load]);
+    const submit = useCallback(async () => {
+        if (!canWriteCollections) {
+            setStatus("You do not have permission to edit collections.");
+            setTone("error");
+            return;
+        }
+        const name = collectionName.trim();
+        if (!name) {
+            setStatus("Collection name is required.");
+            setTone("error");
+            return;
+        }
+        if (RESERVED_COLLECTIONS.has(name)) {
+            setStatus(`Collection "${name}" is reserved and cannot be reconfigured.`);
+            setTone("error");
+            return;
+        }
+        if (mode === "typed" && !tableName.trim()) {
+            setStatus("Typed collections require a table name.");
+            setTone("error");
+            return;
+        }
+        let strictContract;
+        if (strictContractJson.trim()) {
+            try {
+                strictContract = JSON.parse(strictContractJson);
+            }
+            catch (error) {
+                setStatus(`Invalid strict contract JSON: ${error.message}`);
+                setTone("error");
+                return;
+            }
+        }
+        setLoading(true);
+        setStatus("");
+        setTone("neutral");
+        try {
+            await requestJson(pluginContext, "/admin/collections", {
+                method: "POST",
+                body: {
+                    collection_name: name,
+                    mode,
+                    table_name: mode === "typed" ? tableName.trim() || undefined : undefined,
+                    strict_contract: strictContract
+                }
+            });
+            setStatus(`Collection "${name}" registered.`);
+            setTone("success");
+            setSelectedCollectionName(name);
+            setCollectionName("");
+            setTableName("");
+            setStrictContractJson("");
+            await load();
+        }
+        catch (error) {
+            setStatus(error.message);
+            setTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [
+        canWriteCollections,
+        collectionName,
+        load,
+        mode,
+        pluginContext,
+        strictContractJson,
+        tableName
+    ]);
+    const selectCollection = useCallback((collection) => {
+        setSelectedCollectionName(collection.collection_name);
+        setCollectionName(collection.collection_name);
+        setMode(collection.mode);
+        setTableName(collection.table_name ?? "");
+        setStrictContractJson(collection.strict_contract ? JSON.stringify(collection.strict_contract, null, 2) : "");
+    }, []);
+    return (_jsxs("div", { className: "cedros-data", children: [_jsxs("header", { className: "cedros-data__header", children: [_jsxs("div", { children: [_jsx("h2", { className: "cedros-data__title", children: "Collections" }), _jsx("p", { className: "cedros-data__subtitle", children: "Manage the collection schemas for this deployment." }), reservedCollection && (_jsx("p", { className: "cedros-data__subtitle", children: "Reserved collections stay JSONB-backed and are not editable here." })), !canWriteCollections && (_jsx("p", { className: "cedros-data__subtitle", children: "Read-only mode. Missing `data:collections:write` permission." }))] }), _jsxs("div", { className: "cedros-data-actions", children: [_jsx(AdminButton, { variant: "secondary", onClick: () => void load(), disabled: loading, children: "Refresh" }), _jsx(AdminButton, { variant: "primary", onClick: () => void submit(), disabled: loading || !canWriteCollections || reservedCollection, title: !canWriteCollections
+                                    ? "Requires data:collections:write"
+                                    : reservedCollection
+                                        ? "Reserved collections are managed by bootstrap defaults"
+                                        : undefined, children: "Save Collection" })] })] }), _jsxs("div", { className: "cedros-data-grid cedros-data-grid--two", children: [_jsx(Card, { title: `Registered Collections (${collections.length})`, subtitle: "Current collection registrations and storage modes.", children: _jsxs("div", { className: "cedros-data-list", children: [collections.length === 0 && _jsx("div", { className: "cedros-data-empty", children: "No collections yet." }), collections.map((collection) => (_jsxs("button", { type: "button", className: `cedros-data-list-item ${collection.collection_name === selectedCollectionName ? "cedros-data-list-item--active" : ""}`, onClick: () => selectCollection(collection), children: [_jsxs("div", { style: { display: "flex", justifyContent: "space-between", gap: "0.5rem" }, children: [_jsx("strong", { children: collection.collection_name }), _jsx("span", { className: "cedros-data-pill", children: collection.mode })] }), _jsxs("div", { className: "cedros-data-key", children: ["table: ", collection.table_name || "entries(jsonb)", " \u2022 updated:", " ", new Date(collection.updated_at).toLocaleString()] })] }, collection.collection_name)))] }) }), _jsxs(Card, { title: "Register / Update Collection", subtitle: "Select an existing collection to edit or enter a new name.", children: [_jsx(TextInput, { label: "Collection Name", value: collectionName, onChange: (event) => setCollectionName(event.target.value), placeholder: "articles", disabled: !canWriteCollections }), _jsxs(SelectInput, { label: "Mode", value: mode, onChange: (event) => setMode(event.target.value), disabled: !canWriteCollections || reservedCollection, children: [_jsx("option", { value: "jsonb", children: "jsonb" }), _jsx("option", { value: "typed", children: "typed" })] }), mode === "typed" && (_jsx(TextInput, { label: "Typed Table Name", value: tableName, onChange: (event) => setTableName(event.target.value), placeholder: "articles", disabled: !canWriteCollections || reservedCollection })), _jsx(JsonEditor, { label: "Strict Contract (optional)", value: strictContractJson, onChange: (event) => setStrictContractJson(event.target.value), placeholder: '{"fields":[{"path":"title","required":true,"types":["string"]}]}', disabled: !canWriteCollections || reservedCollection })] })] }), status && _jsx(StatusNotice, { tone: tone, message: status })] }));
+}

package/dist/admin/sections/ContractVerifySection.d.ts

@@ -0,0 +1,11 @@
+import type { PluginContext } from "../types.js";
+import type { AdminSectionProps } from "../types.js";
+interface CollectionRecord {
+    collection_name: string;
+}
+export default function ContractVerifySection({ pluginContext }: AdminSectionProps): React.JSX.Element;
+export declare function loadContractVerifyCollections(pluginContext: PluginContext): Promise<{
+    collections: CollectionRecord[];
+    errorMessage: string | null;
+}>;
+export {};

package/dist/admin/sections/ContractVerifySection.js

@@ -0,0 +1,98 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from "react";
+import { requestJson } from "../api.js";
+import { AdminButton, Card, JsonEditor, StatusNotice, TextInput } from "../components.js";
+const SAMPLE_JSON_PLACEHOLDER = JSON.stringify([
+    {
+        title: "Welcome",
+        body: "Hello world"
+    }
+], null, 2);
+export default function ContractVerifySection({ pluginContext }) {
+    const [collections, setCollections] = useState([]);
+    const [collectionsLoadError, setCollectionsLoadError] = useState("");
+    const [collectionName, setCollectionName] = useState("");
+    const [samplesEditor, setSamplesEditor] = useState(SAMPLE_JSON_PLACEHOLDER);
+    const [report, setReport] = useState(null);
+    const [status, setStatus] = useState("");
+    const [tone, setTone] = useState("neutral");
+    const [loading, setLoading] = useState(false);
+    const loadCollections = useCallback(async () => {
+        const result = await loadContractVerifyCollections(pluginContext);
+        setCollections(result.collections);
+        setCollectionsLoadError(result.errorMessage ?? "");
+        setCollectionName((current) => {
+            if (current &&
+                (result.collections.some((collection) => collection.collection_name === current) ||
+                    result.collections.length === 0)) {
+                return current;
+            }
+            return result.collections[0]?.collection_name || "";
+        });
+    }, [pluginContext]);
+    useEffect(() => {
+        void loadCollections();
+    }, [loadCollections]);
+    const runVerify = useCallback(async () => {
+        const collection = collectionName.trim();
+        if (!collection) {
+            setStatus("Collection name is required.");
+            setTone("error");
+            return;
+        }
+        let samples;
+        try {
+            samples = JSON.parse(samplesEditor);
+        }
+        catch (error) {
+            setStatus(`Invalid samples JSON: ${error.message}`);
+            setTone("error");
+            return;
+        }
+        const normalizedSamples = Array.isArray(samples) ? samples : [samples];
+        if (normalizedSamples.length === 0) {
+            setStatus("Provide at least one sample object.");
+            setTone("error");
+            return;
+        }
+        setLoading(true);
+        setStatus("");
+        setTone("neutral");
+        try {
+            const nextReport = await requestJson(pluginContext, "/contract/verify", {
+                method: "POST",
+                body: {
+                    collection_name: collection,
+                    samples: normalizedSamples
+                }
+            });
+            setReport(nextReport);
+            setStatus(nextReport.passes
+                ? "Contract check passed (additive-only or identical)."
+                : "Breaking changes detected.");
+            setTone(nextReport.passes ? "success" : "error");
+        }
+        catch (error) {
+            setStatus(error.message);
+            setTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [collectionName, pluginContext, samplesEditor]);
+    return (_jsxs("div", { className: "cedros-data", children: [_jsxs("header", { className: "cedros-data__header", children: [_jsxs("div", { children: [_jsx("h2", { className: "cedros-data__title", children: "Contract Verify" }), _jsx("p", { className: "cedros-data__subtitle", children: "Compare incoming JSON shapes against stored collection contracts." })] }), _jsxs("div", { className: "cedros-data-actions", children: [_jsx(AdminButton, { variant: "secondary", onClick: () => void loadCollections(), disabled: loading, children: "Refresh Collections" }), _jsx(AdminButton, { variant: "primary", onClick: () => void runVerify(), disabled: loading, children: "Run Verify" })] })] }), _jsxs("div", { className: "cedros-data-grid cedros-data-grid--two", children: [_jsxs(Card, { title: "Input", subtitle: "Compare sample payloads against the current collection contract.", children: [collectionsLoadError && _jsx(StatusNotice, { tone: "error", message: collectionsLoadError }), collections.length > 0 ? (_jsxs("label", { className: "cedros-data-field", children: [_jsx("span", { className: "cedros-data-label", children: "Collection Name" }), _jsx("select", { className: "cedros-data-select", value: collectionName, onChange: (event) => setCollectionName(event.target.value), children: collections.map((collection) => (_jsx("option", { value: collection.collection_name, children: collection.collection_name }, collection.collection_name))) })] })) : (_jsx(TextInput, { label: "Collection Name", value: collectionName, onChange: (event) => setCollectionName(event.target.value), placeholder: "articles" })), _jsx(JsonEditor, { label: "Sample JSON (array or object)", value: samplesEditor, onChange: (event) => setSamplesEditor(event.target.value) })] }), _jsx(Card, { title: "Result", subtitle: "Additive and breaking changes from verification.", children: report ? (_jsxs("div", { style: { display: "grid", gap: "0.8rem" }, children: [_jsx("div", { className: "cedros-data-pill", children: report.passes ? "PASS: additive-only" : "FAIL: breaking changes" }), _jsxs("div", { children: [_jsx("strong", { children: "Additive" }), report.additive_changes.length === 0 && _jsx("div", { className: "cedros-data-empty", children: "None." }), report.additive_changes.map((item) => (_jsxs("div", { className: "cedros-data-key", children: ["\u2022 ", item] }, item)))] }), _jsxs("div", { children: [_jsx("strong", { children: "Breaking" }), report.breaking_changes.length === 0 && _jsx("div", { className: "cedros-data-empty", children: "None." }), report.breaking_changes.map((item) => (_jsxs("div", { className: "cedros-data-key", style: { color: "var(--cd-error)" }, children: ["\u2022 ", item] }, item)))] }), _jsx(JsonEditor, { label: "Stored Contract", value: JSON.stringify(report.stored_contract ?? {}, null, 2), readOnly: true }), _jsx(JsonEditor, { label: "Incoming Contract", value: JSON.stringify(report.incoming_contract ?? {}, null, 2), readOnly: true })] })) : (_jsx("div", { className: "cedros-data-empty", children: "Run verification to see a report." })) })] }), status && _jsx(StatusNotice, { tone: tone, message: status })] }));
+}
+export async function loadContractVerifyCollections(pluginContext) {
+    try {
+        return {
+            collections: await requestJson(pluginContext, "/admin/collections"),
+            errorMessage: null
+        };
+    }
+    catch (error) {
+        return {
+            collections: [],
+            errorMessage: `Unable to load collections automatically: ${error.message}. Enter a collection name manually.`
+        };
+    }
+}

package/dist/admin/sections/CustomDataSection.d.ts

@@ -0,0 +1,2 @@
+import type { AdminSectionProps } from "../types.js";
+export default function CustomDataSection({ pluginContext, pageSize }: AdminSectionProps): React.JSX.Element;

package/dist/admin/sections/CustomDataSection.js

@@ -0,0 +1,256 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { createLatestRequestController, requestJson } from "../api.js";
+import { AdminButton, Card, JsonEditor, SelectInput, StatusNotice, TextInput } from "../components.js";
+import { readPermissionForCollection, writePermissionForCollection } from "../permissions.js";
+export default function CustomDataSection({ pluginContext, pageSize }) {
+    const canReadCollections = pluginContext.hasPermission("data:collections:read") ||
+        pluginContext.hasPermission("data:custom:read");
+    const canCreateCollections = pluginContext.hasPermission("data:collections:write");
+    const canWriteCustomEntries = pluginContext.hasPermission("data:custom:write");
+    const queryLimit = Math.max(1, pageSize);
+    const [collections, setCollections] = useState([]);
+    const [selectedCollection, setSelectedCollection] = useState("");
+    const [newCollectionName, setNewCollectionName] = useState("");
+    const [containsEditor, setContainsEditor] = useState("");
+    const [offset, setOffset] = useState(0);
+    const [entries, setEntries] = useState([]);
+    const [entryKey, setEntryKey] = useState("");
+    const [payloadEditor, setPayloadEditor] = useState("{}");
+    const [loading, setLoading] = useState(false);
+    const [status, setStatus] = useState("");
+    const [statusTone, setStatusTone] = useState("neutral");
+    const entriesRequestControllerRef = useRef(createLatestRequestController());
+    const setError = useCallback((error) => {
+        setStatus(error.message);
+        setStatusTone("error");
+    }, []);
+    const loadCollections = useCallback(async () => {
+        if (!canReadCollections) {
+            throw new Error("You do not have permission to view collections.");
+        }
+        const data = await requestJson(pluginContext, "/admin/collections");
+        setCollections(data);
+        setSelectedCollection((current) => {
+            if (current && data.some((collection) => collection.collection_name === current)) {
+                return current;
+            }
+            return data[0]?.collection_name || "";
+        });
+    }, [canReadCollections, pluginContext]);
+    const loadEntries = useCallback(async () => {
+        if (!selectedCollection) {
+            entriesRequestControllerRef.current.cancel();
+            setEntries([]);
+            return;
+        }
+        const requiredReadPermission = readPermissionForCollection(selectedCollection);
+        if (!pluginContext.hasPermission(requiredReadPermission)) {
+            entriesRequestControllerRef.current.cancel();
+            setEntries([]);
+            setStatus(`You do not have permission to view entries in ${selectedCollection}.`);
+            setStatusTone("error");
+            return;
+        }
+        let contains = null;
+        if (containsEditor.trim()) {
+            try {
+                contains = JSON.parse(containsEditor);
+            }
+            catch (error) {
+                entriesRequestControllerRef.current.cancel();
+                setStatus(`Invalid contains filter JSON: ${error.message}`);
+                setStatusTone("error");
+                return;
+            }
+        }
+        const request = entriesRequestControllerRef.current.begin();
+        try {
+            const data = await requestJson(pluginContext, "/entries/query", {
+                method: "POST",
+                body: {
+                    collection_name: selectedCollection,
+                    entry_keys: [],
+                    contains,
+                    limit: queryLimit,
+                    offset
+                },
+                signal: request.signal
+            });
+            if (!request.isCurrent()) {
+                return;
+            }
+            setEntries(data);
+            if (data[0]) {
+                setEntryKey((current) => current || data[0].entry_key);
+            }
+        }
+        catch (error) {
+            if (isAbortError(error)) {
+                return;
+            }
+            throw error;
+        }
+    }, [containsEditor, offset, pluginContext, queryLimit, selectedCollection]);
+    const loadAll = useCallback(async () => {
+        setLoading(true);
+        setStatus("");
+        setStatusTone("neutral");
+        try {
+            await loadCollections();
+            await loadEntries();
+        }
+        catch (error) {
+            setError(error);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [loadCollections, loadEntries, setError]);
+    useEffect(() => {
+        void loadAll();
+    }, [loadAll]);
+    useEffect(() => () => {
+        entriesRequestControllerRef.current.cancel();
+    }, []);
+    useEffect(() => {
+        const selectedEntry = entries.find((entry) => entry.entry_key === entryKey);
+        if (!selectedEntry) {
+            return;
+        }
+        setPayloadEditor(JSON.stringify(selectedEntry.payload, null, 2));
+    }, [entries, entryKey]);
+    useEffect(() => {
+        if (!selectedCollection) {
+            return;
+        }
+        void loadEntries().catch(setError);
+    }, [loadEntries, selectedCollection]);
+    const createCollection = useCallback(async () => {
+        if (!canCreateCollections) {
+            setStatus("You do not have permission to create collections.");
+            setStatusTone("error");
+            return;
+        }
+        const trimmed = newCollectionName.trim();
+        if (!trimmed) {
+            setStatus("Collection name is required.");
+            setStatusTone("error");
+            return;
+        }
+        setLoading(true);
+        setStatus("");
+        setStatusTone("neutral");
+        try {
+            await requestJson(pluginContext, "/admin/collections", {
+                method: "POST",
+                body: {
+                    collection_name: trimmed,
+                    mode: "jsonb"
+                }
+            });
+            setNewCollectionName("");
+            setSelectedCollection(trimmed);
+            setStatus(`Collection "${trimmed}" ready.`);
+            setStatusTone("success");
+            await loadCollections();
+        }
+        catch (error) {
+            setError(error);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [canCreateCollections, loadCollections, newCollectionName, pluginContext, setError]);
+    const saveEntry = useCallback(async () => {
+        const key = entryKey.trim();
+        if (!selectedCollection) {
+            setStatus("Select a collection first.");
+            setStatusTone("error");
+            return;
+        }
+        const requiredWritePermission = writePermissionForCollection(selectedCollection);
+        if (!pluginContext.hasPermission(requiredWritePermission)) {
+            setStatus(`You do not have permission to edit ${selectedCollection}.`);
+            setStatusTone("error");
+            return;
+        }
+        if (!key) {
+            setStatus("Entry key is required.");
+            setStatusTone("error");
+            return;
+        }
+        let payload;
+        try {
+            const parsed = JSON.parse(payloadEditor);
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                throw new Error("payload must be a JSON object");
+            }
+            payload = parsed;
+        }
+        catch (error) {
+            setStatus(`Invalid JSON: ${error.message}`);
+            setStatusTone("error");
+            return;
+        }
+        setLoading(true);
+        setStatus("");
+        setStatusTone("neutral");
+        try {
+            await requestJson(pluginContext, "/entries/upsert", {
+                method: "POST",
+                body: {
+                    collection_name: selectedCollection,
+                    entry_key: key,
+                    payload
+                }
+            });
+            setStatus(`Saved ${selectedCollection}/${key}.`);
+            setStatusTone("success");
+            await loadEntries();
+        }
+        catch (error) {
+            setError(error);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [
+        entryKey,
+        loadEntries,
+        payloadEditor,
+        pluginContext,
+        selectedCollection,
+        setError
+    ]);
+    const selectedReadPermission = selectedCollection
+        ? readPermissionForCollection(selectedCollection)
+        : null;
+    const selectedWritePermission = selectedCollection
+        ? writePermissionForCollection(selectedCollection)
+        : null;
+    const canReadSelectedCollection = selectedReadPermission === null || pluginContext.hasPermission(selectedReadPermission);
+    const canWriteSelectedCollection = selectedWritePermission !== null && pluginContext.hasPermission(selectedWritePermission);
+    const collectionOptions = useMemo(() => collections.map((collection) => (_jsxs("option", { value: collection.collection_name, children: [collection.collection_name, " (", collection.mode, ")"] }, collection.collection_name))), [collections]);
+    return (_jsxs("div", { className: "cedros-data", children: [_jsxs("header", { className: "cedros-data__header", children: [_jsxs("div", { children: [_jsx("h2", { className: "cedros-data__title", children: "Custom Data" }), _jsx("p", { className: "cedros-data__subtitle", children: "Manage collection entries for this deployment." }), (!canCreateCollections || !canWriteCustomEntries) && (_jsx("p", { className: "cedros-data__subtitle", children: "Read-only mode. Creating collections requires `data:collections:write`; editing custom entries requires `data:custom:write`." }))] }), _jsxs("div", { className: "cedros-data-actions", children: [_jsx(AdminButton, { variant: "secondary", onClick: () => void loadEntries(), disabled: loading || !selectedCollection || !canReadSelectedCollection, title: !selectedCollection || canReadSelectedCollection || selectedReadPermission === null
+                                    ? undefined
+                                    : `Requires ${selectedReadPermission}`, children: "Refresh Entries" }), _jsx(AdminButton, { variant: "primary", onClick: () => void saveEntry(), disabled: loading || !selectedCollection || !canWriteSelectedCollection, title: !selectedCollection || canWriteSelectedCollection || selectedWritePermission === null
+                                    ? undefined
+                                    : `Requires ${selectedWritePermission}`, children: "Save Entry" })] })] }), _jsxs("div", { className: "cedros-data-grid cedros-data-grid--page", children: [_jsxs(Card, { title: "Collections", subtitle: "Create JSONB collections and browse existing entries.", children: [_jsx(SelectInput, { label: "Collection", value: selectedCollection, onChange: (event) => {
+                                    setSelectedCollection(event.target.value);
+                                    setEntryKey("");
+                                    setOffset(0);
+                                }, disabled: loading || collections.length === 0, children: collectionOptions }), _jsxs("div", { className: "cedros-data-actions", children: [_jsx(TextInput, { label: "New Collection", value: newCollectionName, onChange: (event) => setNewCollectionName(event.target.value), placeholder: "blog_posts", disabled: !canCreateCollections }), _jsx(AdminButton, { variant: "secondary", onClick: () => void createCollection(), disabled: loading || !canCreateCollections, title: !canCreateCollections ? "Requires data:collections:write" : undefined, children: "Create" })] }), _jsx(JsonEditor, { label: "Contains Filter (optional JSON)", value: containsEditor, onChange: (event) => setContainsEditor(event.target.value), placeholder: '{"status":"published"}' }), _jsxs("div", { className: "cedros-data-actions", children: [_jsx(AdminButton, { variant: "secondary", size: "sm", onClick: () => {
+                                            setOffset((current) => Math.max(0, current - queryLimit));
+                                            setEntryKey("");
+                                        }, disabled: loading || offset === 0, children: "Prev" }), _jsx(AdminButton, { variant: "secondary", size: "sm", onClick: () => {
+                                            setOffset((current) => current + queryLimit);
+                                            setEntryKey("");
+                                        }, disabled: loading || entries.length < queryLimit, children: "Next" }), _jsxs("span", { className: "cedros-data-key", children: ["offset: ", offset] })] }), _jsxs("div", { className: "cedros-data-list", children: [entries.length === 0 && _jsx("div", { className: "cedros-data-empty", children: "No entries in this collection." }), entries.map((entry) => (_jsx("button", { className: `cedros-data-list-item ${entry.entry_key === entryKey ? "cedros-data-list-item--active" : ""}`, onClick: () => {
+                                            setEntryKey(entry.entry_key);
+                                            setPayloadEditor(JSON.stringify(entry.payload, null, 2));
+                                        }, children: entry.entry_key }, entry.entry_key)))] })] }), _jsxs(Card, { title: selectedCollection ? `Entry Editor (${selectedCollection})` : "Entry Editor", subtitle: "Edit JSON payload for the selected entry key.", children: [_jsx(TextInput, { label: "Entry Key", value: entryKey, onChange: (event) => setEntryKey(event.target.value), placeholder: "homepage_hero", disabled: !selectedCollection || !canWriteSelectedCollection }), _jsx(JsonEditor, { label: "Entry Payload", value: payloadEditor, onChange: (event) => setPayloadEditor(event.target.value), disabled: !selectedCollection || !canWriteSelectedCollection })] })] }), status && _jsx(StatusNotice, { tone: statusTone, message: status })] }));
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}

package/dist/admin/sections/DataOpsSection.d.ts

@@ -0,0 +1,26 @@
+import type { AdminSectionProps } from "../types.js";
+interface SiteExport {
+    site?: unknown;
+    collections?: unknown[];
+    custom_schema?: unknown;
+    contracts?: unknown[];
+    entries?: unknown[];
+}
+export default function DataOpsSection({ pluginContext }: AdminSectionProps): React.JSX.Element;
+interface ParsedSiteExport {
+    value: SiteExport | null;
+    summary: HistoryArtifactSummary | null;
+    error: string | null;
+}
+interface HistoryArtifactSummary {
+    displayName: string;
+    collections: number;
+    contracts: number;
+    entries: number;
+    hasCustomSchema: boolean;
+}
+export declare function parseSiteExport(raw: string): ParsedSiteExport;
+export declare function isImportPayloadPending(raw: string, deferredRaw: string): boolean;
+export declare function resolveImportPayload(raw: string, deferredRaw: string, deferredParsed: ParsedSiteExport): ParsedSiteExport;
+export declare function formatHistoryArtifact(operation: "export" | "import", summary: HistoryArtifactSummary, overwriteContracts?: boolean): string;
+export {};