@elytracms/studio 0.0.73 → 0.0.75

package/dist/components/cms/cms-store.js

@@ -4,12 +4,12 @@ import { createCollectionRegistry, createDocumentStore, documentKey, documentSch
 import { translate } from '@elytracms/studio/lib/i18n';
 import { configureStudioLocales, useStudioLocale } from '@elytracms/studio/lib/locale';
 import { studioManifestLookup } from '@elytracms/studio/lib/registry';
-import { resolveDeploymentCollections } from '@elytracms/studio/lib/workspace';
+import { resolveDeploymentCollections, resolveDeploymentRoutes } from '@elytracms/studio/lib/workspace';
 import { validateComposition, validateRichTextEmbeds } from './cms-composition-validators.js';
 import { matchesRef, removeDoc, replaceDoc, upsertDoc } from './document-ref-utils.js';
 import { createRequiredContext } from '@elytracms/studio/lib/required-context';
 import { createCmsPersister, getStudioOperations } from '@elytracms/studio/lib/operations';
-import { ALL_VIEW_ID, DEFAULT_VIEW_OVERRIDE_ID, canonicalViewState, configViewIssues, defaultConfigViewId, defaultViewState, deprecatedDefaultFlagViewIds, hasDefaultViewOverride, resolveCollectionViews, viewStatesEqual, } from '@elytracms/studio/lib/cms-views';
+import { ALL_VIEW_ID, DEFAULT_VIEW_OVERRIDE_ID, canonicalViewState, configViewIssues, defaultConfigViewId, defaultViewState, deprecatedDefaultFlagViewIds, hasDefaultViewOverride, pseudoColumns, resolveCollectionViews, viewStatesEqual, } from '@elytracms/studio/lib/cms-views';
 import { useOptionalAssets } from '../assets/assets-store.js';
 import { consumeStagedDocuments } from './document-staging.js';
 import { applyCellValue, commitCellEdit } from './cell-edit.js';
@@ -101,12 +101,12 @@ function warnDeprecatedDefaultFlag(collection) {
     }
 }
 /** The unnamed built-in view: no filters, no sort, every field visible. */
-function defaultView(collection) {
+function defaultView(collection, pseudo = []) {
     return {
         id: ALL_VIEW_ID,
         name: translate('cms.list.view.all'),
         state: collection
-            ? defaultViewState(collection)
+            ? defaultViewState(collection, pseudo)
             : { filters: [], sort: null, columns: [], hidden: [] },
     };
 }
@@ -117,7 +117,7 @@ function defaultView(collection) {
  * layer (`documents.*` / `schema.*` commands) through {@link createCmsPersister}.
  * Failed/denied commands surface as {@link CmsStore.persistError}.
  */
-export function CmsProvider({ children, projectId, initialCollections, initialDocuments, initialPublishedKeys, initialLocaleConfig, }) {
+export function CmsProvider({ children, projectId, initialCollections, initialDocuments, initialPublishedKeys, initialTimestamps, initialPublishTimestamps, initialLocaleConfig, }) {
     const [documents, setDocuments] = useState(() => {
         const seeded = (initialDocuments ?? sampleDocuments).map((d) => structuredClone(d));
         // EC-320 (0.0.44 follow-up): merge any documents STAGED by the
@@ -139,6 +139,68 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
             return new Set(initialPublishedKeys);
         return new Set(initialDocuments ? [] : samplePublishedKeys);
     });
+    // EC-445: per-document last-write timestamps behind the `$updatedAt` column.
+    // Seeded from hydration (connected: the persisted `cmsDocuments.updatedAt`), then
+    // re-stamped on the common edit paths. A seeded document with no hydrated timestamp
+    // (the playground fixtures / a kit) gets a session-start stamp so the column is
+    // never a wall of blanks; a fresh draft is stamped when it is created.
+    const [updatedAtByKey, setUpdatedAtByKey] = useState(() => {
+        const now = new Date().toISOString();
+        const map = new Map();
+        if (initialTimestamps) {
+            for (const [key, value] of Object.entries(initialTimestamps))
+                map.set(key, value);
+        }
+        for (const doc of initialDocuments ?? sampleDocuments) {
+            const key = documentKey(doc);
+            if (!map.has(key))
+                map.set(key, now);
+        }
+        return map;
+    });
+    const stampUpdatedAt = useCallback((ref, iso = new Date().toISOString()) => {
+        setUpdatedAtByKey((prev) => {
+            const next = new Map(prev);
+            next.set(documentKey(ref), iso);
+            return next;
+        });
+    }, []);
+    const documentUpdatedAt = useCallback((ref) => updatedAtByKey.get(documentKey(ref)), [updatedAtByKey]);
+    // EC-447: per-document FIRST-publish instants behind the `$publishedAt` column.
+    // Seeded from hydration (the persisted `cmsDocuments.publishedAt`); UNLIKE
+    // `$updatedAt` there is NO session-start fallback — an absent entry is a real "no
+    // publish date" (EmDash). The store re-stamps/clears it authoritatively on
+    // publish/unpublish (the set-once + clear semantics live in the persistence spine).
+    const [publishedAtByKey, setPublishedAtByKey] = useState(() => {
+        const map = new Map();
+        if (initialPublishTimestamps) {
+            for (const [key, value] of Object.entries(initialPublishTimestamps))
+                map.set(key, value);
+        }
+        return map;
+    });
+    // Adopt the AUTHORITATIVE publish instant from the reconciled record: an ISO value
+    // stamps it (set-once is enforced server-side, so this only ever adopts the pinned
+    // first-publish value); `undefined` CLEARS it (unpublish). Mirrors `stampUpdatedAt`
+    // but supports clearing — the column shows a date iff the doc is currently published.
+    const stampPublishedAt = useCallback((ref, iso) => {
+        setPublishedAtByKey((prev) => {
+            const key = documentKey(ref);
+            if (iso === undefined) {
+                if (!prev.has(key))
+                    return prev;
+                const next = new Map(prev);
+                next.delete(key);
+                return next;
+            }
+            if (prev.get(key) === iso)
+                return prev;
+            const next = new Map(prev);
+            next.set(key, iso);
+            return next;
+        });
+    }, []);
+    const documentPublishedAt = useCallback((ref) => publishedAtByKey.get(documentKey(ref)), [publishedAtByKey]);
     const [activeViews, setActiveViews] = useState({});
     // The live table state per collection where it diverges from the active
     // view; absent key = exactly the active view's state (not dirty).
@@ -229,8 +291,9 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
         // Replace-or-append (upsert): a brand-new document must still land even
         // though nothing in the session matches its ref yet.
         setDocuments((prev) => upsertDoc(prev, doc));
+        stampUpdatedAt(doc); // EC-445: a save bumps the $updatedAt column
         persisterRef.current?.upsertDocument(doc);
-    }, []);
+    }, [stampUpdatedAt]);
     const commitFieldEdit = useCallback((input) => {
         // Pure map-replace: an edit always targets a document already open in
         // the session, so a miss (already gone) is a no-op, never an append.
@@ -240,7 +303,12 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
             registry,
             documents: documentsRef.current,
             localeConfig,
-            applySession: replaceWith,
+            // EC-445: the optimistic apply bumps the $updatedAt column (a rollback
+            // leaves it — it self-corrects on the next hydration).
+            applySession: (doc) => {
+                replaceWith(doc);
+                stampUpdatedAt(doc);
+            },
             rollbackSession: replaceWith,
             ...(persister && projectId !== undefined
                 ? {
@@ -254,7 +322,7 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
                 }
                 : {}),
         }, input);
-    }, [registry, localeConfig, projectId]);
+    }, [registry, localeConfig, projectId, stampUpdatedAt]);
     // Shared insert sequence (EC-326): existingIds/mint/seedDefaults (via
     // `buildNewDocument`) + optimistic append + persist, consumed by both
     // `createDocument` (always inserts) and `ensureSingletonDocument`'s empty
@@ -266,9 +334,10 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
     const insertNewDocument = useCallback((collectionId, options) => {
         const doc = buildNewDocument(collectionId, registry, seq, documentsRef.current);
         setDocuments((prev) => options?.guardExisting && hasDocumentFor(prev, collectionId) ? prev : [...prev, doc]);
+        stampUpdatedAt(doc); // EC-445: a fresh draft's $updatedAt starts at creation time
         persisterRef.current?.upsertDocument(doc);
         return doc;
-    }, [registry]);
+    }, [registry, stampUpdatedAt]);
     const createDocument = useCallback((collectionId) => {
         const doc = insertNewDocument(collectionId);
         return { collection: collectionId, id: doc.id };
@@ -339,9 +408,18 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
             return;
         const { operations } = await getStudioOperations();
         const record = await operations.documents.get({ projectId, ref });
-        if (record.ok)
+        if (record.ok) {
             setPublished(ref, record.value.publishedVersion !== undefined);
-    }, [projectId, setPublished]);
+            // EC-445: publish/unpublish patches `updatedAt` — adopt the authoritative
+            // value so the $updatedAt column reflects the actual write, not a guess.
+            if (record.value.updatedAt)
+                stampUpdatedAt(ref, record.value.updatedAt);
+            // EC-447: adopt the authoritative `publishedAt` — set-once on the first
+            // publish, absent after unpublish. Passing `undefined` CLEARS the column, so
+            // an unpublish reverts $publishedAt to EmDash and a republish records fresh.
+            stampPublishedAt(ref, record.value.publishedAt);
+        }
+    }, [projectId, setPublished, stampUpdatedAt, stampPublishedAt]);
     const publishDocument = useCallback(async (ref) => {
         setPublished(ref, true); // optimistic
         // EC-273: no clearing here — the draft is already free of conditionally-hidden
@@ -465,6 +543,17 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
     }, [registry, documents, localeConfig, assetExists]);
     const isFieldReadOnly = useCallback((field) => field.form?.readOnly === true, []);
     // --- Views (EC-246b: config-as-code) --------------------------------------
+    // EC-445: the reserved pseudo-columns a CMS collection's list surfaces. Every
+    // `cmsDocuments` collection has a publish lifecycle + materialized timestamps
+    // ($state + $updatedAt always apply); $url applies only where the deployment
+    // resolves a delivery route for it (mirrors the live-URL column's own guard).
+    const pseudoColumnsFor = useCallback((collectionId) => {
+        const collection = registry.get(collectionId);
+        if (!collection)
+            return [];
+        const routable = resolveDeploymentRoutes().some((route) => route.document?.collection === collectionId);
+        return pseudoColumns(collection, { publishing: true, timestamps: true, routable });
+    }, [registry]);
     const viewsOf = useCallback((collectionId) => {
         // The baseline view plus the collection's config-declared views (EC-246b/EC-444).
         // Views are PRESENTATION, read live from elytra.config.ts (AD-11) — not the
@@ -476,12 +565,13 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
         // EC-444: a config view with the reserved `id: 'default'` REPLACES the
         // synthesized "All entries" baseline verbatim (first tab); absent one, the
         // synthesized baseline leads. `resolveCollectionViews` owns that selection.
-        const baseline = defaultView(registry.get(collectionId));
+        const pseudo = pseudoColumnsFor(collectionId);
+        const baseline = defaultView(registry.get(collectionId), pseudo);
         const configCollection = resolveDeploymentCollections().find((c) => c.id === collectionId);
         if (!configCollection)
             return [baseline];
-        return resolveCollectionViews(configCollection, baseline);
-    }, [registry]);
+        return resolveCollectionViews(configCollection, baseline, pseudo);
+    }, [registry, pseudoColumnsFor]);
     // The INITIAL active view for a collection (EC-343/EC-444): a config view flagged
     // `initial: true` seeds the first-load lens; else the baseline — the `id: 'default'`
     // override when present, else the synthesized "All entries" (`ALL_VIEW_ID`). Only
@@ -502,8 +592,8 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
     const activeViewOf = useCallback((collectionId) => {
         const id = activeViews[collectionId] ?? initialViewId(collectionId);
         return (viewsOf(collectionId).find((view) => view.id === id) ??
-            defaultView(registry.get(collectionId)));
-    }, [activeViews, initialViewId, viewsOf, registry]);
+            defaultView(registry.get(collectionId), pseudoColumnsFor(collectionId)));
+    }, [activeViews, initialViewId, viewsOf, registry, pseudoColumnsFor]);
     const tableStateOf = useCallback((collectionId) => tableStates[collectionId] ?? activeViewOf(collectionId).state, [tableStates, activeViewOf]);
     const dropTableState = useCallback((collectionId) => {
         setTableStates((prev) => {
@@ -633,6 +723,8 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
         ensureSingletonDocument,
         deleteDocument,
         isPublished,
+        documentUpdatedAt,
+        documentPublishedAt,
         publishDocument,
         unpublishDocument,
         loadDocumentVersions,
@@ -658,8 +750,10 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
             if (collection === undefined)
                 return !viewStatesEqual(working, active);
             // Compare schema-resolved forms (EC-213): a column-order reconciliation
-            // or a stale `hidden` entry must not read as an unsaved edit.
-            return !viewStatesEqual(canonicalViewState(collection, working), canonicalViewState(collection, active));
+            // or a stale `hidden` entry must not read as an unsaved edit. EC-445: the
+            // pseudo-column universe must match so a reserved column never reads as a diff.
+            const pseudo = pseudoColumnsFor(collectionId);
+            return !viewStatesEqual(canonicalViewState(collection, working, pseudo), canonicalViewState(collection, active, pseudo));
         },
         resetTableState: dropTableState,
         runBulk,
@@ -683,6 +777,8 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
         ensureSingletonDocument,
         deleteDocument,
         isPublished,
+        documentUpdatedAt,
+        documentPublishedAt,
         publishDocument,
         unpublishDocument,
         loadDocumentVersions,
@@ -700,6 +796,7 @@ export function CmsProvider({ children, projectId, initialCollections, initialDo
         dropTableState,
         runBulk,
         registry,
+        pseudoColumnsFor,
         persistError,
     ]);
     return _jsx(CmsContext.Provider, { value: store$, children: children });