meno-core 1.0.53 → 1.1.0

package/lib/server/fileWatcher.ts

@@ -3,12 +3,91 @@
  * Watches for changes in JSON files and triggers callbacks
  */
 
-import { watch, existsSync } from 'fs';
-import { basename, dirname, join } from 'path';
-import type { FSWatcher } from 'fs';
+import { watch, existsSync, statSync, readdirSync } from 'node:fs';
+import { basename, dirname, join, relative } from 'node:path';
+import type { FSWatcher } from 'node:fs';
 import { mapPageNameToPath } from './jsonLoader';
 import { projectPaths, getProjectRoot } from './projectContext';
 
+/**
+ * Recursive directory watcher that also covers subdirectories created AFTER the
+ * watch began. Node's `fs.watch({recursive:true})` does this natively, but Bun's
+ * does NOT — it reports the new subdir's creation event yet never the files
+ * created inside it (verified on Bun 1.3). Since the studio server can run under
+ * Bun, relying on the native behavior silently breaks live-reload / cache
+ * invalidation for any collection or page added at runtime (e.g. a new
+ * `src/pages/<col>/[slug].astro` or `src/content/<col>/*.json`).
+ *
+ * We attach the native recursive watcher (covering the depth present at start),
+ * then, whenever a directory appears, attach a nested watcher to it AND replay
+ * its current contents as synthetic `rename` events — closing the
+ * mkdir-then-write race where a file lands before the nested watcher is live.
+ * The listener receives paths relative to `root` (matching `fs.watch`'s relative
+ * `filename`). Idempotent callbacks tolerate the occasional duplicate event this
+ * can produce under Node (where the native watcher already recurses).
+ */
+export function watchRecursive(root: string, listener: (event: string, relPath: string) => void): FSWatcher {
+  const nested: FSWatcher[] = [];
+  const watchedDirs = new Set<string>();
+  let rootWatcher: FSWatcher | null = null;
+
+  const coverNewDir = (abs: string): void => {
+    let isDir = false;
+    try {
+      isDir = statSync(abs).isDirectory();
+    } catch {
+      return; // vanished (or unreadable) between event and stat — nothing to do
+    }
+    if (!isDir || watchedDirs.has(abs)) return;
+    attachDir(abs);
+    // Replay what's already inside (created before the nested watcher went live).
+    try {
+      for (const e of readdirSync(abs, { withFileTypes: true })) {
+        const child = join(abs, e.name);
+        if (e.isDirectory()) coverNewDir(child);
+        else listener('rename', relative(root, child));
+      }
+    } catch {
+      /* dir vanished / unreadable — nothing to replay */
+    }
+  };
+
+  function attachDir(absDir: string): void {
+    if (watchedDirs.has(absDir)) return;
+    watchedDirs.add(absDir);
+    let w: FSWatcher;
+    try {
+      w = watch(absDir, { recursive: true }, (event, filename) => {
+        if (!filename) return;
+        const abs = join(absDir, filename);
+        listener(event, relative(root, abs));
+        coverNewDir(abs); // a newly-created subdir — Bun won't recurse into it on its own
+      });
+    } catch {
+      return; // dir vanished mid-attach
+    }
+    if (absDir === root) rootWatcher = w;
+    else nested.push(w);
+  }
+
+  attachDir(root);
+
+  // Composite handle: closing it tears down the root + every nested watcher.
+  const handle = (rootWatcher ?? { close() {} }) as FSWatcher;
+  const baseClose = handle.close.bind(handle);
+  handle.close = () => {
+    baseClose();
+    for (const w of nested) {
+      try {
+        w.close();
+      } catch {
+        /* already closed */
+      }
+    }
+  };
+  return handle;
+}
+
 /**
  * Attach a recursive watcher to `dirPath`. If the directory doesn't exist
  * yet, watch the parent directory and defer the attach until the target is
@@ -21,7 +100,7 @@ import { projectPaths, getProjectRoot } from './projectContext';
 function attachWhenDirExists(
   dirPath: string,
   attach: () => FSWatcher | null,
-  setWatcher: (w: FSWatcher | null) => void
+  setWatcher: (w: FSWatcher | null) => void,
 ): void {
   if (existsSync(dirPath)) {
     setWatcher(attach());
@@ -50,6 +129,13 @@ function attachWhenDirExists(
 export interface FileWatchCallbacks {
   onComponentChange?: () => Promise<void>;
   onPageChange?: (pagePath: string) => Promise<void>;
+  /**
+   * Fires when an astro CMS template page (`src/pages/<col>/[slug].astro`) is
+   * added, edited, or removed. Distinct from onPageChange because this changes
+   * the set of collections (not just one page's content), so the handler must
+   * refresh the CMS schema cache + the `/templates/<id>` page-cache entries.
+   */
+  onCMSTemplateChange?: () => Promise<void>;
   onColorsChange?: () => Promise<void>;
   onVariablesChange?: () => Promise<void>;
   onEnumsChange?: () => Promise<void>;
@@ -76,7 +162,7 @@ export class FileWatcher {
   private astroContentWatcher: FSWatcher | null = null;
 
   constructor(private callbacks: FileWatchCallbacks) {}
-  
+
   /**
    * Start watching components directory
    * Watches both .json and .js files to detect component definition and JavaScript changes
@@ -85,24 +171,19 @@ export class FileWatcher {
     if (!existsSync(dirPath)) {
       return;
     }
-    
-    this.componentsWatcher = watch(
-      dirPath,
-      { recursive: true },
-      async (event, filename) => {
-        // Watch .json (component definitions), .js (component JavaScript), and .css (component CSS) files
-        if (filename && (filename.endsWith('.json') || filename.endsWith('.js') || filename.endsWith('.css'))) {
-          const fileType = filename.endsWith('.js') ? 'JavaScript' : filename.endsWith('.css') ? 'CSS' : 'component';
-          
-          if (this.callbacks.onComponentChange) {
-            await this.callbacks.onComponentChange();
-          }
+
+    this.componentsWatcher = watchRecursive(dirPath, async (_event, filename) => {
+      // Watch .json (component definitions), .js (component JavaScript), and .css (component CSS) files
+      if (filename && (filename.endsWith('.json') || filename.endsWith('.js') || filename.endsWith('.css'))) {
+        const _fileType = filename.endsWith('.js') ? 'JavaScript' : filename.endsWith('.css') ? 'CSS' : 'component';
+
+        if (this.callbacks.onComponentChange) {
+          await this.callbacks.onComponentChange();
         }
       }
-    );
-    
+    });
   }
-  
+
   /**
    * Start watching pages directory
    */
@@ -111,21 +192,16 @@ export class FileWatcher {
       return;
     }
 
-    this.pagesWatcher = watch(
-      dirPath,
-      { recursive: true },
-      async (event, filename) => {
-        if (filename && filename.endsWith('.json')) {
-          const pageName = filename.replace('.json', '');
-          const pagePath = mapPageNameToPath(pageName);
-
-          if (this.callbacks.onPageChange) {
-            await this.callbacks.onPageChange(pagePath);
-          }
+    this.pagesWatcher = watchRecursive(dirPath, async (_event, filename) => {
+      if (filename?.endsWith('.json')) {
+        const pageName = filename.replace('.json', '');
+        const pagePath = mapPageNameToPath(pageName);
+
+        if (this.callbacks.onPageChange) {
+          await this.callbacks.onPageChange(pagePath);
         }
       }
-    );
-
+    });
   }
 
   /**
@@ -137,11 +213,9 @@ export class FileWatcher {
   watchTemplates(dirPath: string = projectPaths.templates()): void {
     attachWhenDirExists(
       dirPath,
-      () => watch(
-        dirPath,
-        { recursive: true },
-        async (event, filename) => {
-          if (filename && filename.endsWith('.json')) {
+      () =>
+        watchRecursive(dirPath, async (_event, filename) => {
+          if (filename?.endsWith('.json')) {
             // Prefix with templates/ so the path is /templates/...
             const pageName = `templates/${filename.replace('.json', '')}`;
             const pagePath = mapPageNameToPath(pageName);
@@ -150,12 +224,13 @@ export class FileWatcher {
               await this.callbacks.onPageChange(pagePath);
             }
           }
-        }
-      ),
-      (w) => { this.templatesWatcher = w; }
+        }),
+      (w) => {
+        this.templatesWatcher = w;
+      },
     );
   }
-  
+
   /**
    * Start watching colors.json file
    */
@@ -166,15 +241,11 @@ export class FileWatcher {
 
     // Watch the file's directory for changes
     const dirPath = getProjectRoot();
-    this.colorsWatcher = watch(
-      dirPath,
-      { recursive: false },
-      async (event, filename) => {
-        if (filename === 'colors.json' && this.callbacks.onColorsChange) {
-          await this.callbacks.onColorsChange();
-        }
+    this.colorsWatcher = watch(dirPath, { recursive: false }, async (_event, filename) => {
+      if (filename === 'colors.json' && this.callbacks.onColorsChange) {
+        await this.callbacks.onColorsChange();
       }
-    );
+    });
   }
 
   /**
@@ -182,15 +253,11 @@ export class FileWatcher {
    */
   watchVariables(): void {
     const dirPath = getProjectRoot();
-    this.variablesWatcher = watch(
-      dirPath,
-      { recursive: false },
-      async (event, filename) => {
-        if (filename === 'variables.json' && this.callbacks.onVariablesChange) {
-          await this.callbacks.onVariablesChange();
-        }
+    this.variablesWatcher = watch(dirPath, { recursive: false }, async (_event, filename) => {
+      if (filename === 'variables.json' && this.callbacks.onVariablesChange) {
+        await this.callbacks.onVariablesChange();
       }
-    );
+    });
   }
 
   /**
@@ -198,15 +265,11 @@ export class FileWatcher {
    */
   watchEnums(): void {
     const dirPath = getProjectRoot();
-    this.enumsWatcher = watch(
-      dirPath,
-      { recursive: false },
-      async (event, filename) => {
-        if (filename === 'enums.json' && this.callbacks.onEnumsChange) {
-          await this.callbacks.onEnumsChange();
-        }
+    this.enumsWatcher = watch(dirPath, { recursive: false }, async (_event, filename) => {
+      if (filename === 'enums.json' && this.callbacks.onEnumsChange) {
+        await this.callbacks.onEnumsChange();
       }
-    );
+    });
   }
 
   /**
@@ -217,20 +280,19 @@ export class FileWatcher {
   watchCMS(dirPath: string = projectPaths.cms()): void {
     attachWhenDirExists(
       dirPath,
-      () => watch(
-        dirPath,
-        { recursive: true },
-        async (event, filename) => {
-          if (filename && filename.endsWith('.json')) {
+      () =>
+        watchRecursive(dirPath, async (_event, filename) => {
+          if (filename?.endsWith('.json')) {
             // Extract collection from path: "blog/my-post.json" -> "blog"
-            const collection = filename.split('/')[0];
+            const collection = filename.split('/')[0] ?? filename;
             if (this.callbacks.onCMSChange) {
               await this.callbacks.onCMSChange(collection);
             }
           }
-        }
-      ),
-      (w) => { this.cmsWatcher = w; }
+        }),
+      (w) => {
+        this.cmsWatcher = w;
+      },
     );
   }
 
@@ -242,15 +304,11 @@ export class FileWatcher {
       return;
     }
 
-    this.imagesWatcher = watch(
-      dirPath,
-      { recursive: false },
-      async (event, filename) => {
-        if (event === 'rename' && filename && this.callbacks.onImageAdded) {
-          await this.callbacks.onImageAdded(filename);
-        }
+    this.imagesWatcher = watch(dirPath, { recursive: false }, async (event, filename) => {
+      if (event === 'rename' && filename && this.callbacks.onImageAdded) {
+        await this.callbacks.onImageAdded(filename);
       }
-    );
+    });
   }
 
   /**
@@ -261,15 +319,11 @@ export class FileWatcher {
    */
   watchProjectConfig(): void {
     const dirPath = getProjectRoot();
-    this.projectConfigWatcher = watch(
-      dirPath,
-      { recursive: false },
-      async (_event, filename) => {
-        if (filename === 'project.config.json' && this.callbacks.onProjectConfigChange) {
-          await this.callbacks.onProjectConfigChange();
-        }
+    this.projectConfigWatcher = watch(dirPath, { recursive: false }, async (_event, filename) => {
+      if (filename === 'project.config.json' && this.callbacks.onProjectConfigChange) {
+        await this.callbacks.onProjectConfigChange();
       }
-    );
+    });
   }
 
   /**
@@ -280,17 +334,13 @@ export class FileWatcher {
       return;
     }
 
-    this.librariesWatcher = watch(
-      dirPath,
-      { recursive: true },
-      async (event, filename) => {
-        if (filename && (filename.endsWith('.css') || filename.endsWith('.js'))) {
-          if (this.callbacks.onLibraryChange) {
-            await this.callbacks.onLibraryChange();
-          }
+    this.librariesWatcher = watchRecursive(dirPath, async (_event, filename) => {
+      if (filename && (filename.endsWith('.css') || filename.endsWith('.js'))) {
+        if (this.callbacks.onLibraryChange) {
+          await this.callbacks.onLibraryChange();
         }
       }
-    );
+    });
   }
 
   /**
@@ -299,35 +349,66 @@ export class FileWatcher {
    * (reload goes through the active provider), so file→editor live reload works
    * for `.astro` the same way it does for JSON. These are no-ops in JSON projects
    * (the src/ dirs don't exist).
+   *
+   * All three use deferred attach (like watchTemplates/watchCMS): `src/content`
+   * (and occasionally `src/components`) may not exist at startup — e.g. a project
+   * with no CMS collections yet. Without deferral the watcher would silently
+   * early-out and the first collection's item edits wouldn't live-reload until a
+   * dev-server restart.
    */
   watchAstroPages(dirPath: string = join(getProjectRoot(), 'src', 'pages')): void {
-    if (!existsSync(dirPath)) return;
-    this.astroPagesWatcher = watch(dirPath, { recursive: true }, async (_event, filename) => {
-      // Skip dynamic CMS routes ([slug].astro) — those are CMS templates, not pages.
-      if (filename && filename.endsWith('.astro') && !filename.includes('[')) {
-        const pagePath = mapPageNameToPath(filename.replace(/\.astro$/, ''));
-        if (this.callbacks.onPageChange) await this.callbacks.onPageChange(pagePath);
-      }
-    });
+    attachWhenDirExists(
+      dirPath,
+      () =>
+        watchRecursive(dirPath, async (_event, filename) => {
+          if (!filename?.endsWith('.astro')) return;
+          // Dynamic CMS routes ([slug].astro) are CMS template pages, not regular pages.
+          // A change there means a collection was added/edited/removed — route it to the
+          // CMS-template refresh (schema cache + /templates/<id> page cache). Mapping its
+          // on-disk name ([slug]) as a page path would be wrong, and skipping it (as before)
+          // left new collections + their template pages invisible until a dev-server restart.
+          if (filename.includes('[')) {
+            if (this.callbacks.onCMSTemplateChange) await this.callbacks.onCMSTemplateChange();
+            return;
+          }
+          const pagePath = mapPageNameToPath(filename.replace(/\.astro$/, ''));
+          if (this.callbacks.onPageChange) await this.callbacks.onPageChange(pagePath);
+        }),
+      (w) => {
+        this.astroPagesWatcher = w;
+      },
+    );
   }
 
   watchAstroComponents(dirPath: string = join(getProjectRoot(), 'src', 'components')): void {
-    if (!existsSync(dirPath)) return;
-    this.astroComponentsWatcher = watch(dirPath, { recursive: true }, async (_event, filename) => {
-      if (filename && filename.endsWith('.astro') && this.callbacks.onComponentChange) {
-        await this.callbacks.onComponentChange();
-      }
-    });
+    attachWhenDirExists(
+      dirPath,
+      () =>
+        watchRecursive(dirPath, async (_event, filename) => {
+          if (filename?.endsWith('.astro') && this.callbacks.onComponentChange) {
+            await this.callbacks.onComponentChange();
+          }
+        }),
+      (w) => {
+        this.astroComponentsWatcher = w;
+      },
+    );
   }
 
   watchAstroContent(dirPath: string = join(getProjectRoot(), 'src', 'content')): void {
-    if (!existsSync(dirPath)) return;
-    this.astroContentWatcher = watch(dirPath, { recursive: true }, async (_event, filename) => {
-      if (filename && filename.endsWith('.json') && this.callbacks.onCMSChange) {
-        const collection = filename.split('/')[0];
-        await this.callbacks.onCMSChange(collection);
-      }
-    });
+    attachWhenDirExists(
+      dirPath,
+      () =>
+        watchRecursive(dirPath, async (_event, filename) => {
+          if (filename?.endsWith('.json') && this.callbacks.onCMSChange) {
+            const collection = filename.split('/')[0] ?? filename;
+            await this.callbacks.onCMSChange(collection);
+          }
+        }),
+      (w) => {
+        this.astroContentWatcher = w;
+      },
+    );
   }
 
   /**
@@ -349,7 +430,7 @@ export class FileWatcher {
     this.watchAstroComponents();
     this.watchAstroContent();
   }
-  
+
   /**
    * Stop watching all directories
    */
@@ -424,7 +505,11 @@ export class FileWatcher {
    * Check if watchers are active
    */
   isWatching(): boolean {
-    return this.componentsWatcher !== null || this.pagesWatcher !== null || this.cmsWatcher !== null || this.imagesWatcher !== null;
+    return (
+      this.componentsWatcher !== null ||
+      this.pagesWatcher !== null ||
+      this.cmsWatcher !== null ||
+      this.imagesWatcher !== null
+    );
   }
 }
-

package/lib/server/index.ts

@@ -29,7 +29,9 @@ export { VariableService, variableService } from './services/VariableService';
 export { EnumService, enumService } from './services/EnumService';
 
 // Providers
-export { FileSystemPageProvider } from './providers/fileSystemPageProvider';
+// FileSystemPageProvider was retired with the bespoke JSON renderer (the editor is
+// meno-astro-only; AstroPageProvider is the live page provider). FileSystemCMSProvider
+// remains: the JSON→astro export (build-astro.ts) still reads JSON CMS items through it.
 export { FileSystemCMSProvider } from './providers/fileSystemCMSProvider';
 
 // CMS interfaces
@@ -39,10 +41,16 @@ export type { CMSProvider, CMSSchemaInfo } from '../shared/interfaces/contentPro
 export { handleCoreApiRoutes, type CoreRouteContext } from './routes/api/core-routes';
 
 // CMS read routes (GET handlers)
-export { handleCollectionsRoute, handleCollectionSchemaRoute, handleItemsRoute, handleItemRoute } from './routes/api/cms';
+export {
+  handleCollectionsRoute,
+  handleCollectionSchemaRoute,
+  handleItemsRoute,
+  handleItemRoute,
+} from './routes/api/cms';
 
 // Route utilities
 export { jsonResponse, errorResponse } from './routes/api/shared';
+export { createCorsHeaders, handleCorsPreflight } from './middleware/cors';
 
 // Note: Write route handlers moved to @meno/studio:
 // - handleSavePageRoute
@@ -64,28 +72,17 @@ export * from './projectContext';
 
 // File watcher
 export { FileWatcherService } from './services/fileWatcherService';
+// Recursive watch shim that also covers subdirs created AFTER the watch began (Bun's native
+// `fs.watch({recursive:true})` does not — see fileWatcher.ts). Reused by the studio Astro
+// dev-server's workdir mirror so a new collection/page dir live-syncs under Bun.
+export { watchRecursive } from './fileWatcher';
 
 // Migration
 export { migrateTemplatesDirectory } from './migrateTemplates';
 
-// Static build
-export { buildStaticPages } from '../../build-static';
-
 // Astro export
 export { buildAstroProject } from '../../build-astro';
 
-// Next.js export
-export { buildNextProject } from '../../build-next';
-
-// Webflow export
-export { buildWebflowPayload, wrapInWebflowTemplate } from './webflow';
-export type {
-  WebflowExportPayload,
-  WebflowPage,
-  WebflowElement,
-  WebflowStyleClass,
-} from './webflow';
-
 // Utilities
 export * from './utils';
 

package/lib/server/jsonLoader.test.ts

@@ -1,6 +1,11 @@
-import { describe, test, expect } from 'bun:test';
+import { describe, test, expect, afterEach } from 'bun:test';
+import { writeFileSync, mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 import {
   parseJSON,
+  loadAndParseJSON,
+  loadJSONFile,
   mapPageNameToPath,
   mapPathToPageName,
   getBreakpointConfig,
@@ -8,6 +13,7 @@ import {
   getI18nConfig,
   setI18nConfig,
 } from './jsonLoader';
+import { setErrorHandler } from '../shared/errorLogger';
 import { DEFAULT_BREAKPOINTS } from '../shared/breakpoints';
 import { DEFAULT_I18N_CONFIG } from '../shared/i18n';
 
@@ -56,6 +62,37 @@ describe('jsonLoader', () => {
     });
   });
 
+  describe('file-load error observability', () => {
+    afterEach(() => setErrorHandler(null));
+
+    test('loadAndParseJSON surfaces corrupt JSON via the error handler but still returns null', async () => {
+      const dir = mkdtempSync(join(tmpdir(), 'jsonloader-'));
+      const filePath = join(dir, 'broken.json');
+      writeFileSync(filePath, '{ not valid json ', 'utf8');
+
+      const entries: string[] = [];
+      setErrorHandler((entry) => entries.push(entry.location));
+
+      try {
+        const result = await loadAndParseJSON(filePath);
+        expect(result).toBeNull();
+        expect(entries).toContain('jsonLoader.loadAndParseJSON');
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+
+    test('loadJSONFile returns null without logging for a missing file', async () => {
+      const entries: string[] = [];
+      setErrorHandler((entry) => entries.push(entry.location));
+
+      const result = await loadJSONFile(join(tmpdir(), 'definitely-does-not-exist-xyz.json'));
+      expect(result).toBeNull();
+      // Missing file is gated by fileExists() — no error should be logged.
+      expect(entries).toHaveLength(0);
+    });
+  });
+
   describe('breakpoint config cache', () => {
     test('returns default config initially', () => {
       const config = getBreakpointConfig();
@@ -65,7 +102,7 @@ describe('jsonLoader', () => {
     test('returns cached config after set', () => {
       const customConfig = {
         mobile: { breakpoint: 500, previewPoint: 375 },
-        tablet: { breakpoint: 900, previewPoint: 768 }
+        tablet: { breakpoint: 900, previewPoint: 768 },
       };
       setBreakpointConfig(customConfig);
       const config = getBreakpointConfig();