meno-core 1.0.48 → 1.0.50

package/lib/server/fileWatcher.ts

@@ -4,11 +4,49 @@
  */
 
 import { watch, existsSync } from 'fs';
-import { dirname } from 'path';
+import { basename, dirname } from 'path';
 import type { FSWatcher } from 'fs';
 import { mapPageNameToPath } from './jsonLoader';
 import { projectPaths, getProjectRoot } from './projectContext';
 
+/**
+ * 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
+ * created (e.g. a blank project that doesn't ship with `templates/` or `cms/`
+ * gets one added later by an external tool).
+ *
+ * Returns the currently active FSWatcher (which may be the deferred parent
+ * watcher until the target appears, then the proper recursive watcher).
+ */
+function attachWhenDirExists(
+  dirPath: string,
+  attach: () => FSWatcher | null,
+  setWatcher: (w: FSWatcher | null) => void
+): void {
+  if (existsSync(dirPath)) {
+    setWatcher(attach());
+    return;
+  }
+
+  const parentDir = dirname(dirPath);
+  const targetName = basename(dirPath);
+  if (!existsSync(parentDir)) {
+    // Parent doesn't exist either — give up; nothing reasonable to watch.
+    return;
+  }
+
+  let parentWatcher: FSWatcher | null = null;
+  parentWatcher = watch(parentDir, (_event, filename) => {
+    if (filename !== targetName) return;
+    if (!existsSync(dirPath)) return;
+    // Target exists now — tear down the parent watcher and attach the real one.
+    parentWatcher?.close();
+    parentWatcher = null;
+    setWatcher(attach());
+  });
+  setWatcher(parentWatcher);
+}
+
 export interface FileWatchCallbacks {
   onComponentChange?: () => Promise<void>;
   onPageChange?: (pagePath: string) => Promise<void>;
@@ -18,6 +56,7 @@ export interface FileWatchCallbacks {
   onCMSChange?: (collection: string) => Promise<void>;
   onImageAdded?: (filename: string) => Promise<void>;
   onLibraryChange?: () => Promise<void>;
+  onProjectConfigChange?: () => Promise<void>;
 }
 
 export class FileWatcher {
@@ -30,6 +69,7 @@ export class FileWatcher {
   private cmsWatcher: FSWatcher | null = null;
   private imagesWatcher: FSWatcher | null = null;
   private librariesWatcher: FSWatcher | null = null;
+  private projectConfigWatcher: FSWatcher | null = null;
 
   constructor(private callbacks: FileWatchCallbacks) {}
   
@@ -85,29 +125,31 @@ export class FileWatcher {
   }
 
   /**
-   * Start watching root templates directory for CMS template changes
+   * Start watching root templates directory for CMS template changes.
+   * Falls back to a deferred-attach watcher on the project root when
+   * `templates/` doesn't exist yet (blank projects, projects that have never
+   * had a CMS collection).
    */
   watchTemplates(dirPath: string = projectPaths.templates()): void {
-    if (!existsSync(dirPath)) {
-      return;
-    }
-
-    this.templatesWatcher = watch(
+    attachWhenDirExists(
       dirPath,
-      { recursive: true },
-      async (event, filename) => {
-        if (filename && filename.endsWith('.json')) {
-          // Prefix with templates/ so the path is /templates/...
-          const pageName = `templates/${filename.replace('.json', '')}`;
-          const pagePath = mapPageNameToPath(pageName);
+      () => watch(
+        dirPath,
+        { recursive: true },
+        async (event, filename) => {
+          if (filename && filename.endsWith('.json')) {
+            // Prefix with templates/ so the path is /templates/...
+            const pageName = `templates/${filename.replace('.json', '')}`;
+            const pagePath = mapPageNameToPath(pageName);
 
-          if (this.callbacks.onPageChange) {
-            await this.callbacks.onPageChange(pagePath);
+            if (this.callbacks.onPageChange) {
+              await this.callbacks.onPageChange(pagePath);
+            }
           }
         }
-      }
+      ),
+      (w) => { this.templatesWatcher = w; }
     );
-
   }
   
   /**
@@ -164,26 +206,27 @@ export class FileWatcher {
   }
 
   /**
-   * Start watching CMS directory
-   * Watches for changes in CMS content files (cms/{collection}/*.json)
+   * Start watching CMS directory.
+   * Watches for changes in CMS content files (cms/{collection}/*.json).
+   * Falls back to a deferred-attach watcher when `cms/` doesn't exist yet.
    */
   watchCMS(dirPath: string = projectPaths.cms()): void {
-    if (!existsSync(dirPath)) {
-      return;
-    }
-
-    this.cmsWatcher = watch(
+    attachWhenDirExists(
       dirPath,
-      { recursive: true },
-      async (event, filename) => {
-        if (filename && filename.endsWith('.json')) {
-          // Extract collection from path: "blog/my-post.json" -> "blog"
-          const collection = filename.split('/')[0];
-          if (this.callbacks.onCMSChange) {
-            await this.callbacks.onCMSChange(collection);
+      () => watch(
+        dirPath,
+        { recursive: true },
+        async (event, filename) => {
+          if (filename && filename.endsWith('.json')) {
+            // Extract collection from path: "blog/my-post.json" -> "blog"
+            const collection = filename.split('/')[0];
+            if (this.callbacks.onCMSChange) {
+              await this.callbacks.onCMSChange(collection);
+            }
           }
         }
-      }
+      ),
+      (w) => { this.cmsWatcher = w; }
     );
   }
 
@@ -206,6 +249,25 @@ export class FileWatcher {
     );
   }
 
+  /**
+   * Start watching project.config.json for changes.
+   * Picks up edits to i18n locales, breakpoints, libraries, icons, etc. so the
+   * studio reflects external writes (e.g. an AI tool adding a new locale) without
+   * a dev-server restart.
+   */
+  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();
+        }
+      }
+    );
+  }
+
   /**
    * Start watching libraries directory for CSS/JS changes
    */
@@ -240,6 +302,7 @@ export class FileWatcher {
     this.watchCMS();
     this.watchImages();
     this.watchLibraries();
+    this.watchProjectConfig();
   }
   
   /**
@@ -290,6 +353,11 @@ export class FileWatcher {
       this.librariesWatcher.close();
       this.librariesWatcher = null;
     }
+
+    if (this.projectConfigWatcher) {
+      this.projectConfigWatcher.close();
+      this.projectConfigWatcher = null;
+    }
   }
   
   /**

package/lib/server/jsonLoader.ts

@@ -423,6 +423,7 @@ export function setI18nConfig(config: I18nConfig): void {
  */
 export interface IconsConfig {
   favicon?: string;
+  faviconDark?: string;
   appleTouchIcon?: string;
 }
 

package/lib/server/providers/fileSystemCMSProvider.test.ts

@@ -341,5 +341,168 @@ describe('FileSystemCMSProvider', () => {
       const items = await provider.getItems('valid-collection');
       expect(items).toEqual([]);
     });
+
+    it('should reject filenames ending in reserved .draft suffix', async () => {
+      const item = { _id: '99', _filename: 'foo.draft', title: 'Sneaky', slug: 'foo' };
+      await expect(provider.saveItem('blog-posts', item))
+        .rejects.toThrow(/\.draft.*reserved/);
+      await expect(provider.deleteItem('blog-posts', 'foo.draft'))
+        .rejects.toThrow(/\.draft.*reserved/);
+      await expect(provider.getItemByFilename('blog-posts', 'foo.draft'))
+        .rejects.toThrow(/\.draft.*reserved/);
+    });
   });
+
+  describe('drafts', () => {
+    it('saveDraft writes a sibling .draft.json file and getDraft reads it back', async () => {
+      const draft = {
+        _id: '1',
+        _filename: 'hello-world',
+        title: 'Hello World — WIP edits',
+        slug: 'hello-world',
+        content: 'Updated content (not yet published)',
+      };
+
+      await provider.saveDraft('blog-posts', draft);
+
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.draft.json'))).toBe(true);
+
+      const read = await provider.getDraft('blog-posts', 'hello-world');
+      expect(read?.title).toBe('Hello World — WIP edits');
+      expect(read?._isDraft).toBe(true);
+    });
+
+    it('drafts do not appear in published-only queries (getItems, getItemByFilename)', async () => {
+      // Pre-existing item: hello-world (published). Add a draft for it.
+      await provider.saveDraft('blog-posts', {
+        _id: '1',
+        _filename: 'hello-world',
+        title: 'Draft title',
+        slug: 'hello-world',
+      });
+
+      // Add a draft-only item (no published file)
+      await provider.saveDraft('blog-posts', {
+        _id: 'new-1',
+        _filename: 'brand-new',
+        title: 'Brand new draft',
+        slug: 'brand-new',
+      });
+
+      const items = await provider.getItems('blog-posts');
+      // Still only the two original published items
+      expect(items).toHaveLength(2);
+      expect(items.find(i => i._filename === 'brand-new')).toBeUndefined();
+      // hello-world's published title is unchanged
+      expect(items.find(i => i._filename === 'hello-world')?.title).toBe('Hello World');
+
+      const single = await provider.getItemByFilename('blog-posts', 'brand-new');
+      expect(single).toBeNull();
+    });
+
+    it('getAllDrafts returns drafts with _isDraft transient flag', async () => {
+      await provider.saveDraft('blog-posts', {
+        _id: '1', _filename: 'hello-world', title: 'WIP', slug: 'hello-world',
+      });
+      await provider.saveDraft('blog-posts', {
+        _id: 'new', _filename: 'brand-new', title: 'New', slug: 'brand-new',
+      });
+
+      const drafts = await provider.getAllDrafts('blog-posts');
+      expect(drafts).toHaveLength(2);
+      expect(drafts.every(d => d._isDraft === true)).toBe(true);
+      expect(drafts.map(d => d._filename).sort()).toEqual(['brand-new', 'hello-world']);
+    });
+
+    it('hasDraft reflects whether a draft file exists', async () => {
+      expect(await provider.hasDraft('blog-posts', 'hello-world')).toBe(false);
+      await provider.saveDraft('blog-posts', {
+        _id: '1', _filename: 'hello-world', title: 'WIP', slug: 'hello-world',
+      });
+      expect(await provider.hasDraft('blog-posts', 'hello-world')).toBe(true);
+    });
+
+    it('discardDraft removes the draft file and is a no-op when none exists', async () => {
+      await expect(provider.discardDraft('blog-posts', 'hello-world')).resolves.toBeUndefined();
+
+      await provider.saveDraft('blog-posts', {
+        _id: '1', _filename: 'hello-world', title: 'WIP', slug: 'hello-world',
+      });
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.draft.json'))).toBe(true);
+
+      await provider.discardDraft('blog-posts', 'hello-world');
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.draft.json'))).toBe(false);
+      // Published file is untouched
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.json'))).toBe(true);
+    });
+
+    it('publishDraft promotes draft to published and removes the draft file', async () => {
+      await provider.saveDraft('blog-posts', {
+        _id: '1',
+        _filename: 'hello-world',
+        title: 'Updated Title',
+        slug: 'hello-world',
+        content: 'New content',
+      });
+
+      const result = await provider.publishDraft('blog-posts', 'hello-world');
+      expect(result.title).toBe('Updated Title');
+
+      // Published file now has the new content
+      const item = await provider.getItemByFilename('blog-posts', 'hello-world');
+      expect(item?.title).toBe('Updated Title');
+      expect(item?.content).toBe('New content');
+
+      // Draft file is gone
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.draft.json'))).toBe(false);
+    });
+
+    it('publishDraft of a draft-only item creates the published file', async () => {
+      await provider.saveDraft('blog-posts', {
+        _id: 'new', _filename: 'brand-new', title: 'New post', slug: 'brand-new',
+      });
+
+      const result = await provider.publishDraft('blog-posts', 'brand-new');
+      expect(result._filename).toBe('brand-new');
+
+      const items = await provider.getItems('blog-posts');
+      expect(items.find(i => i._filename === 'brand-new')?.title).toBe('New post');
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'brand-new.draft.json'))).toBe(false);
+    });
+
+    it('publishDraft throws when no draft exists', async () => {
+      await expect(provider.publishDraft('blog-posts', 'hello-world'))
+        .rejects.toThrow(/No draft to publish/);
+    });
+
+    it('deleteItem removes both published and draft files', async () => {
+      await provider.saveDraft('blog-posts', {
+        _id: '1', _filename: 'hello-world', title: 'WIP', slug: 'hello-world',
+      });
+
+      await provider.deleteItem('blog-posts', 'hello-world');
+
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.json'))).toBe(false);
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.draft.json'))).toBe(false);
+    });
+
+    it('saveItem strips transient _isDraft / _hasDraft fields before writing', async () => {
+      const item = {
+        _id: '1',
+        _filename: 'hello-world',
+        title: 'Hello',
+        slug: 'hello-world',
+        _isDraft: true,
+        _hasDraft: true,
+      };
+      await provider.saveItem('blog-posts', item as any);
+
+      const { readFile } = await import('fs/promises');
+      const raw = await readFile(join(CMS_DIR, 'blog-posts', 'hello-world.json'), 'utf-8');
+      const parsed = JSON.parse(raw);
+      expect(parsed._isDraft).toBeUndefined();
+      expect(parsed._hasDraft).toBeUndefined();
+    });
+  });
+
 });