@nuasite/cms 0.22.3 → 0.22.4

package/dist/editor.js

@@ -381,7 +381,7 @@ function CS(t, e) {
 function ES(t, e) {
   return typeof e == "function" ? e(t) : e;
 }
-const J_ = "0.22.3", j_ = J_, ct = {
+const J_ = "0.22.4", j_ = J_, ct = {
   /** Highlight overlay for hovered elements */
   HIGHLIGHT: 2147483644,
   /** Hover outline for elements/components */

package/package.json

@@ -14,7 +14,7 @@
     "directory": "packages/astro-cms"
   },
   "license": "Apache-2.0",
-  "version": "0.22.3",
+  "version": "0.22.4",
   "module": "src/index.ts",
   "types": "src/index.ts",
   "type": "module",

package/src/content-invalidator.ts

@@ -0,0 +1,134 @@
+/**
+ * Vite SSR module cache invalidation + content-sync coordination.
+ *
+ * Astro's content layer chain (chokidar → glob loader → syncData → data store
+ * → fs.watch → invalidateModule) is racy and unreliable under several conditions:
+ *
+ *   - Native fs.watch on Linux dies after the first atomic rename of the watched
+ *     file (Astro writes data-store.json via writeFile-tmp + rename).
+ *   - Vite's bundled chokidar 3.6.0 misses the same atomic-write events.
+ *   - `invalidateModule(astro:data-layer-content)` alone does not propagate up
+ *     the import graph, so route modules that already cached `getCollection`
+ *     references keep returning stale data.
+ *
+ * This module exposes two things:
+ *
+ *   - `invalidateContentCache(server)` — walks the SSR module graph from
+ *     `astro:data-layer-content` upward and invalidates every transitive
+ *     importer, then broadcasts `full-reload` to the client.
+ *   - `notifyContentStoreUpdated` / `awaitNextContentStoreUpdate` — a shared
+ *     rendezvous between the fs.watch plugin (which observes data-store.json
+ *     writes) and the CMS API middleware (which needs to hold the HTTP
+ *     response until the store is fresh). Keeps invalidation on a single path.
+ */
+
+interface SsrModuleNode {
+	id: string | null
+	importers: Set<SsrModuleNode>
+}
+
+interface SsrModuleGraph {
+	getModuleById(id: string): SsrModuleNode | undefined
+	invalidateModule(
+		mod: SsrModuleNode,
+		seen?: Set<SsrModuleNode>,
+		timestamp?: number,
+		isHmr?: boolean,
+	): void
+}
+
+interface SsrEnvironment {
+	moduleGraph: SsrModuleGraph
+	hot: { send: (event: string, data?: unknown) => void }
+}
+
+interface ClientEnvironment {
+	hot: { send: (payload: { type: string; path: string }) => void }
+}
+
+export interface ViteServerLike {
+	environments: { ssr: SsrEnvironment; client: ClientEnvironment }
+}
+
+// Astro exposes the content data store as a virtual module whose resolved id
+// is `\0astro:data-layer-content` (see astro/dist/content/consts.js). Earlier
+// versions of this file used `\0astro:data-store`, which does not exist and
+// silently reduced `invalidateContentCache` to a no-op full-reload broadcast.
+const DATA_STORE_VIRTUAL_ID = '\0astro:data-layer-content'
+
+/**
+ * Invalidate the SSR `astro:data-layer-content` virtual module and every
+ * module that (transitively) imports it. After this returns, the next request
+ * that imports any of these modules will re-execute and read fresh content.
+ *
+ * Also broadcasts `full-reload` so any connected browser refreshes.
+ */
+export function invalidateContentCache(server: ViteServerLike): void {
+	const ssr = server.environments.ssr
+	const dataStoreMod = ssr.moduleGraph.getModuleById(DATA_STORE_VIRTUAL_ID)
+	if (dataStoreMod) {
+		const seen = new Set<SsrModuleNode>()
+		const ts = Date.now()
+		const walk = (mod: SsrModuleNode) => {
+			if (seen.has(mod)) return
+			seen.add(mod)
+			ssr.moduleGraph.invalidateModule(mod, seen, ts, true)
+			for (const importer of mod.importers) {
+				walk(importer)
+			}
+		}
+		walk(dataStoreMod)
+	}
+	ssr.hot.send('astro:content-changed', {})
+	server.environments.client.hot.send({ type: 'full-reload', path: '*' })
+}
+
+// ---------------------------------------------------------------------------
+// Content-sync rendezvous
+// ---------------------------------------------------------------------------
+//
+// The CMS API middleware writes a content file and then needs to hold the HTTP
+// response until Astro has actually re-synced the data store — otherwise the
+// browser reloads into a stale render. The fs.watch plugin is the component
+// that observes the data-store.json write, so it is also the component that
+// resolves these waiters.
+
+type StoreUpdateResolver = () => void
+const pendingStoreUpdateWaiters = new Set<StoreUpdateResolver>()
+
+/**
+ * Called by the data-store fs.watch plugin after it has invalidated the SSR
+ * module cache in response to a data-store.json write. Wakes every middleware
+ * caller currently parked in `awaitNextContentStoreUpdate`.
+ */
+export function notifyContentStoreUpdated(): void {
+	if (pendingStoreUpdateWaiters.size === 0) return
+	const resolvers = Array.from(pendingStoreUpdateWaiters)
+	pendingStoreUpdateWaiters.clear()
+	for (const resolve of resolvers) resolve()
+}
+
+/**
+ * Park until the next data-store.json write has been fully processed (store
+ * reloaded on disk, SSR module graph invalidated). Resolves with `true` on
+ * success or `false` if the timeout elapses first — callers should treat
+ * timeout as "best-effort, proceed anyway".
+ *
+ * The timeout fallback exists because some edits legitimately do not change
+ * the data store (e.g. whitespace-only edits are skipped by Astro's atomic
+ * write comparator), in which case no fs.watch event will ever fire.
+ */
+export function awaitNextContentStoreUpdate(timeoutMs: number): Promise<boolean> {
+	return new Promise((resolve) => {
+		const resolver = () => {
+			clearTimeout(timer)
+			pendingStoreUpdateWaiters.delete(resolver)
+			resolve(true)
+		}
+		const timer = setTimeout(() => {
+			pendingStoreUpdateWaiters.delete(resolver)
+			resolve(false)
+		}, timeoutMs)
+		pendingStoreUpdateWaiters.add(resolver)
+	})
+}

package/src/dev-middleware.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import path from 'node:path'
 import { getProjectRoot } from './config'
+import { awaitNextContentStoreUpdate } from './content-invalidator'
 import { handleCmsApiRoute } from './handlers/api-routes'
 import { buildMapPattern, detectArrayPattern, extractArrayElementProps, parseInlineArrayName } from './handlers/array-ops'
 import {
@@ -43,6 +44,7 @@ interface ViteDevServerLike {
 	watcher?: {
 		on: (event: string, listener: (...args: any[]) => void) => any
 		removeListener: (event: string, listener: (...args: any[]) => void) => any
+		emit: (event: string, ...args: any[]) => boolean
 	}
 }
 
@@ -100,6 +102,45 @@ export function createDevMiddleware(
 
 	// CMS API endpoints (local dev server backend)
 	if (options.enableCmsApi) {
+		const projectRoot = getProjectRoot()
+
+		/**
+		 * Hold the HTTP response for a `markdown/update` (or equivalent) call
+		 * until Astro's content layer has actually re-synced the edited file.
+		 *
+		 * The race we're fixing: handleUpdateMarkdown writes the file and
+		 * returns immediately, the editor then triggers a full-reload, and
+		 * the next page render reads a still-cached `astro:data-layer-content`
+		 * virtual module — so the user sees their edit disappear until Astro's
+		 * async chain (glob loader → syncData → 500 ms save debounce → atomic
+		 * write → fs.watch → invalidateModule) finally catches up.
+		 *
+		 * The fix, end to end:
+		 *
+		 *   1. `server.watcher.emit('change', fullPath)` kicks Astro's glob
+		 *      loader directly. It is registered on this exact watcher (see
+		 *      astro/dist/core/dev/dev.js — `viteServer.watcher` is handed to
+		 *      `globalContentLayer.init`), so synthetic change events fire its
+		 *      `onChange` handler and trigger `syncData`. This also works
+		 *      around Vite's bundled chokidar missing some edits.
+		 *   2. `awaitNextContentStoreUpdate` parks until the shared data-store
+		 *      watcher (in `vite-plugin.ts`) observes the resulting atomic
+		 *      write and finishes invalidating the SSR module graph.
+		 *   3. Only then do we return — so the subsequent full-reload lands
+		 *      on a page that will re-execute with fresh content.
+		 *
+		 * The timeout fallback covers edits that legitimately do not rewrite
+		 * the data store (Astro's MutableDataStore skips identical writes).
+		 * In that case no fs.watch event will ever fire, and 3 s is plenty of
+		 * budget before we give up and let the response through anyway.
+		 */
+		const notifyContentChanged = async (filePath: string): Promise<void> => {
+			const fullPath = path.resolve(projectRoot, filePath)
+			const waiter = awaitNextContentStoreUpdate(3000)
+			server.watcher?.emit('change', fullPath)
+			await waiter
+		}
+
 		server.middlewares.use((req, res, next) => {
 			const url = req.url || ''
 			if (!url.startsWith('/_nua/cms/')) {
@@ -111,7 +152,7 @@ export function createDevMiddleware(
 
 			const route = url.replace('/_nua/cms/', '').split('?')[0]!
 
-			handleCmsApiRoute(route, req, res, manifestWriter, config.contentDir, options.mediaAdapter)
+			handleCmsApiRoute(route, req, res, manifestWriter, config.contentDir, options.mediaAdapter, notifyContentChanged)
 				.catch((error) => {
 					console.error('[astro-cms] API error:', error)
 					sendError(res, 'Internal server error', 500)

package/src/handlers/api-routes.ts

@@ -21,6 +21,15 @@ export interface RouteContext {
 	manifestWriter: ManifestWriter
 	contentDir: string
 	mediaAdapter?: MediaStorageAdapter
+	/**
+	 * Triggered after a content file (markdown / data collection) is written so
+	 * the dev middleware can synchronously refresh Astro's content layer and
+	 * invalidate Vite's SSR module cache before responding to the client.
+	 *
+	 * Awaiting this is important: returning success before the cache is fresh
+	 * causes the editor to reload the page into a stale render.
+	 */
+	notifyContentChanged?: (filePath: string) => Promise<void>
 }
 
 type RouteHandler = (ctx: RouteContext) => Promise<void>
@@ -104,9 +113,13 @@ const routeMap = new Map<string, RouteHandler>([
 		}
 		sendJson(res, result)
 	}),
-	custom('POST', 'markdown/update', async ({ req, res, manifestWriter }) => {
+	custom('POST', 'markdown/update', async ({ req, res, manifestWriter, notifyContentChanged }) => {
 		const body = await parseJsonBody<Parameters<typeof handleUpdateMarkdown>[0]>(req)
-		sendJson(res, await handleUpdateMarkdown(body, manifestWriter.getComponentDefinitions()))
+		const result = await handleUpdateMarkdown(body, manifestWriter.getComponentDefinitions())
+		if (result.success && notifyContentChanged) {
+			await notifyContentChanged(body.filePath)
+		}
+		sendJson(res, result)
 	}),
 	post('markdown/rename', (body: Parameters<typeof handleRenameMarkdown>[0]) => handleRenameMarkdown(body)),
 	postWithStatus('markdown/create', (body: Parameters<typeof handleCreateMarkdown>[0]) => handleCreateMarkdown(body)),
@@ -225,8 +238,9 @@ export async function handleCmsApiRoute(
 	manifestWriter: ManifestWriter,
 	contentDir: string,
 	mediaAdapter?: MediaStorageAdapter,
+	notifyContentChanged?: (filePath: string) => Promise<void>,
 ): Promise<void> {
-	const ctx: RouteContext = { req, res, route, manifestWriter, contentDir, mediaAdapter }
+	const ctx: RouteContext = { req, res, route, manifestWriter, contentDir, mediaAdapter, notifyContentChanged }
 
 	// Exact match lookup
 	const handler = routeMap.get(`${req.method}:${route}`)

package/src/vite-plugin.ts

@@ -1,6 +1,7 @@
 import { watch } from 'node:fs'
 import { join } from 'node:path'
 import type { Plugin } from 'vite'
+import { invalidateContentCache, notifyContentStoreUpdated, type ViteServerLike } from './content-invalidator'
 import { expectedDeletions } from './dev-middleware'
 import type { ManifestWriter } from './manifest-writer'
 import { markFileDirty } from './source-finder'
@@ -85,6 +86,11 @@ export function createVitePlugin(context: VitePluginContext): Plugin[] {
 	// Without this, content collection edits update the data store on disk but the
 	// browser never receives a full-reload because Vite's watcher never fires "change"
 	// for that file. We use native fs.watch as a reliable fallback.
+	//
+	// Caveat: native fs.watch on Linux tracks the inode, not the path. Astro writes
+	// data-store.json via atomic rename (writeFile-tmp + rename), which replaces the
+	// inode and silently kills the existing watcher. We re-attach on every event to
+	// keep tracking the live file across atomic writes.
 	const dataStoreWatchPlugin: Plugin = {
 		name: 'cms-data-store-watch',
 		configureServer(server) {
@@ -93,25 +99,32 @@ export function createVitePlugin(context: VitePluginContext): Plugin[] {
 			const dataStorePath = join(root, '.astro', 'data-store.json')
 			let fsWatcher: ReturnType<typeof watch> | undefined
 			let debounce: ReturnType<typeof setTimeout> | undefined
+			let closed = false
 
 			const invalidate = () => {
-				// Replicate Astro's invalidateDataStore which never fires because
-				// Vite's bundled chokidar 3.6.0 misses atomic-write changes.
-				const ssr = server.environments.ssr
-				const mod = ssr.moduleGraph.getModuleById('\0astro:data-store')
-				if (mod) {
-					ssr.moduleGraph.invalidateModule(mod, undefined, Date.now(), true)
-				}
-				ssr.hot.send('astro:content-changed', {})
-				server.environments.client.hot.send({ type: 'full-reload', path: '*' })
+				invalidateContentCache(server as unknown as ViteServerLike)
+				// Wake any CMS API middleware call that is currently blocked
+				// waiting for the data store to reflect a just-written file.
+				// This keeps the invalidation on a single path (here) and lets
+				// the middleware respond only after the SSR module graph is fresh.
+				notifyContentStoreUpdated()
+			}
+
+			const onEvent = () => {
+				clearTimeout(debounce)
+				debounce = setTimeout(invalidate, 80)
+				// Re-attach: native fs.watch dies after the inode is replaced by an
+				// atomic rename. Close current and restart so subsequent writes are
+				// observed.
+				fsWatcher?.close()
+				fsWatcher = undefined
+				if (!closed) startWatching()
 			}
 
 			const startWatching = () => {
+				if (closed) return
 				try {
-					fsWatcher = watch(dataStorePath, () => {
-						clearTimeout(debounce)
-						debounce = setTimeout(invalidate, 80)
-					})
+					fsWatcher = watch(dataStorePath, onEvent)
 				} catch {
 					// File doesn't exist yet — retry when it appears
 					setTimeout(startWatching, 2000)
@@ -123,6 +136,7 @@ export function createVitePlugin(context: VitePluginContext): Plugin[] {
 
 			const origClose = server.close.bind(server)
 			server.close = async () => {
+				closed = true
 				fsWatcher?.close()
 				clearTimeout(debounce)
 				return origClose()