meno-core 1.0.53 → 1.1.0

package/lib/server/fileWatcher.test.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect, afterEach, beforeEach } from 'bun:test';
-import { mkdirSync, rmSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 import { FileWatcher } from './fileWatcher';
 import { setProjectRoot, getProjectRoot } from './projectContext';
 
@@ -17,7 +17,20 @@ import { setProjectRoot, getProjectRoot } from './projectContext';
  * generously and only asserts that the callback fires at least once.
  */
 async function settle(ms = 300): Promise<void> {
-  await new Promise(r => setTimeout(r, ms));
+  await new Promise((r) => setTimeout(r, ms));
+}
+
+/**
+ * Poll until `predicate()` is truthy or `timeoutMs` elapses. fs.watch / chokidar
+ * latency varies wildly under CI load, so a fixed sleep before asserting flakes
+ * (the change event simply hadn't fired yet). Polling waits only as long as
+ * needed and returns early once the callback has run.
+ */
+async function waitFor(predicate: () => boolean, timeoutMs = 3000, stepMs = 25): Promise<void> {
+  const start = Date.now();
+  while (!predicate() && Date.now() - start < timeoutMs) {
+    await new Promise((r) => setTimeout(r, stepMs));
+  }
 }
 
 describe('FileWatcher deferred attach', () => {
@@ -29,13 +42,19 @@ describe('FileWatcher deferred attach', () => {
   });
 
   afterEach(() => {
-    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    try {
+      rmSync(projectRoot, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
   });
 
   test('watchTemplates fires onPageChange after templates/ is created post-startup', async () => {
     const seen: string[] = [];
     const watcher = new FileWatcher({
-      onPageChange: async (p) => { seen.push(p); },
+      onPageChange: async (p) => {
+        seen.push(p);
+      },
     });
 
     // templates/ does NOT exist yet — pre-fix this returned silently.
@@ -57,7 +76,9 @@ describe('FileWatcher deferred attach', () => {
   test('watchCMS fires onCMSChange after cms/ is created post-startup', async () => {
     const seen: string[] = [];
     const watcher = new FileWatcher({
-      onCMSChange: async (collection) => { seen.push(collection); },
+      onCMSChange: async (collection) => {
+        seen.push(collection);
+      },
     });
 
     const cmsDir = join(projectRoot, 'cms');
@@ -80,6 +101,125 @@ describe('FileWatcher deferred attach', () => {
   });
 });
 
+describe('FileWatcher astro CMS template pages', () => {
+  let projectRoot: string;
+  let pagesDir: string;
+
+  beforeEach(() => {
+    projectRoot = join(tmpdir(), `meno-fw-astro-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    pagesDir = join(projectRoot, 'src', 'pages');
+    mkdirSync(pagesDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(projectRoot, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  });
+
+  // A new CMS collection lands on disk as src/pages/<col>/[slug].astro. Pre-fix the
+  // watcher skipped any filename containing '[', so adding a collection never refreshed
+  // the schema/page caches — it stayed invisible until a dev-server restart.
+  test('routes a new [slug].astro to onCMSTemplateChange (not onPageChange)', async () => {
+    const pageChanges: string[] = [];
+    let cmsTemplateChanges = 0;
+    const watcher = new FileWatcher({
+      onPageChange: async (p) => {
+        pageChanges.push(p);
+      },
+      onCMSTemplateChange: async () => {
+        cmsTemplateChanges++;
+      },
+    });
+
+    watcher.watchAstroPages(pagesDir);
+    await settle(50);
+
+    mkdirSync(join(pagesDir, 'blog'), { recursive: true });
+    await settle(100);
+    writeFileSync(join(pagesDir, 'blog', '[slug].astro'), '---\nconst meta = {};\n---\n');
+    await waitFor(() => cmsTemplateChanges >= 1);
+
+    watcher.stopAll();
+    expect(cmsTemplateChanges).toBeGreaterThanOrEqual(1);
+    expect(pageChanges).toEqual([]);
+  });
+
+  // Regression for Bun's recursive fs.watch: a regular page added inside a NEW
+  // subdirectory (created after the watcher started) must still fire onPageChange.
+  // Bun's native recursive watcher misses files in post-start subdirs; the
+  // watchRecursive shim covers them.
+  test('fires onPageChange for a page added in a subdirectory created post-startup', async () => {
+    const pageChanges: string[] = [];
+    const watcher = new FileWatcher({
+      onPageChange: async (p) => {
+        pageChanges.push(p);
+      },
+    });
+
+    watcher.watchAstroPages(pagesDir);
+    await settle(50);
+
+    mkdirSync(join(pagesDir, 'services'), { recursive: true }); // new subdir at runtime
+    await settle(100);
+    writeFileSync(join(pagesDir, 'services', 'wellness.astro'), '---\nconst meta = {};\n---\n');
+    await waitFor(() => pageChanges.length >= 1);
+
+    watcher.stopAll();
+    expect(pageChanges.some((p) => p.includes('services/wellness') || p.includes('wellness'))).toBe(true);
+  });
+
+  // A project with no CMS collections yet has no src/content/ at startup. The
+  // watcher must defer-attach (like watchTemplates/watchCMS) so the first
+  // collection's item edits live-reload without a dev-server restart.
+  test('watchAstroContent fires onCMSChange after src/content is created post-startup', async () => {
+    const seen: string[] = [];
+    const watcher = new FileWatcher({
+      onCMSChange: async (collection) => {
+        seen.push(collection);
+      },
+    });
+
+    // src/ exists (astro project) but src/content does NOT yet.
+    const contentDir = join(pagesDir, '..', 'content');
+    watcher.watchAstroContent(contentDir);
+
+    await settle(50);
+    mkdirSync(join(contentDir, 'blog'), { recursive: true });
+    await settle(100);
+    writeFileSync(join(contentDir, 'blog', 'post.json'), '{}');
+    await settle(300);
+
+    watcher.stopAll();
+    expect(seen.length).toBeGreaterThanOrEqual(1);
+  });
+
+  test('routes a regular .astro page to onPageChange (not onCMSTemplateChange)', async () => {
+    const pageChanges: string[] = [];
+    let cmsTemplateChanges = 0;
+    const watcher = new FileWatcher({
+      onPageChange: async (p) => {
+        pageChanges.push(p);
+      },
+      onCMSTemplateChange: async () => {
+        cmsTemplateChanges++;
+      },
+    });
+
+    watcher.watchAstroPages(pagesDir);
+    await settle(50);
+
+    writeFileSync(join(pagesDir, 'about.astro'), '---\nconst meta = {};\n---\n');
+    await settle(300);
+
+    watcher.stopAll();
+    expect(pageChanges.length).toBeGreaterThanOrEqual(1);
+    expect(cmsTemplateChanges).toBe(0);
+  });
+});
+
 describe('FileWatcher project.config.json', () => {
   let projectRoot: string;
   let prevRoot: string;
@@ -94,22 +234,31 @@ describe('FileWatcher project.config.json', () => {
 
   afterEach(() => {
     setProjectRoot(prevRoot);
-    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+    try {
+      rmSync(projectRoot, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
   });
 
   test('fires onProjectConfigChange when project.config.json is written', async () => {
     let fired = 0;
     const watcher = new FileWatcher({
-      onProjectConfigChange: async () => { fired++; },
+      onProjectConfigChange: async () => {
+        fired++;
+      },
     });
 
     watcher.watchProjectConfig();
     await settle(50);
 
     // Simulate AI / external tool editing project.config.json to add a locale.
-    writeFileSync(join(projectRoot, 'project.config.json'), JSON.stringify({
-      i18n: { defaultLocale: 'en', locales: [{ code: 'en' }, { code: 'fr' }] }
-    }));
+    writeFileSync(
+      join(projectRoot, 'project.config.json'),
+      JSON.stringify({
+        i18n: { defaultLocale: 'en', locales: [{ code: 'en' }, { code: 'fr' }] },
+      }),
+    );
     await settle(300);
 
     watcher.stopAll();
@@ -119,7 +268,9 @@ describe('FileWatcher project.config.json', () => {
   test('ignores writes to unrelated files at the project root', async () => {
     let fired = 0;
     const watcher = new FileWatcher({
-      onProjectConfigChange: async () => { fired++; },
+      onProjectConfigChange: async () => {
+        fired++;
+      },
     });
 
     watcher.watchProjectConfig();