meno-core 1.0.53 → 1.1.0

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

@@ -4,10 +4,10 @@
 
 import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
 import { FileSystemCMSProvider } from './fileSystemCMSProvider';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
-import { join } from 'path';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
 
-const TEST_DIR = '/tmp/cms-provider-test-' + Date.now();
+const TEST_DIR = `/tmp/cms-provider-test-${Date.now()}`;
 const TEMPLATES_DIR = join(TEST_DIR, 'templates');
 const CMS_DIR = join(TEST_DIR, 'cms');
 
@@ -22,54 +22,70 @@ describe('FileSystemCMSProvider', () => {
     // Create test page with embedded schema in templates/ subdirectory
     writeFileSync(
       join(TEMPLATES_DIR, 'blog-post.json'),
-      JSON.stringify({
-        meta: {
-          source: 'cms',
-          cms: {
-            id: 'blog-posts',
-            name: 'Blog Posts',
-            slugField: 'slug',
-            urlPattern: '/blog/{{slug}}',
-            fields: {
-              title: { type: 'string', required: true },
-              slug: { type: 'string', required: true },
-              content: { type: 'text' },
+      JSON.stringify(
+        {
+          meta: {
+            source: 'cms',
+            cms: {
+              id: 'blog-posts',
+              name: 'Blog Posts',
+              slugField: 'slug',
+              urlPattern: '/blog/{{slug}}',
+              fields: {
+                title: { type: 'string', required: true },
+                slug: { type: 'string', required: true },
+                content: { type: 'text' },
+              },
             },
+            title: '{{cms.title}}',
           },
-          title: '{{cms.title}}'
+          root: { type: 'node', tag: 'div', children: [] },
         },
-        root: { type: 'node', tag: 'div', children: [] }
-      }, null, 2)
+        null,
+        2,
+      ),
     );
 
     // Create non-CMS page in templates (should be ignored since it lacks source: 'cms')
     writeFileSync(
       join(TEMPLATES_DIR, 'about.json'),
-      JSON.stringify({
-        meta: { title: 'About' },
-        root: { type: 'node', tag: 'div', children: [] }
-      }, null, 2)
+      JSON.stringify(
+        {
+          meta: { title: 'About' },
+          root: { type: 'node', tag: 'div', children: [] },
+        },
+        null,
+        2,
+      ),
     );
 
     // Create CMS items
     writeFileSync(
       join(CMS_DIR, 'blog-posts', 'hello-world.json'),
-      JSON.stringify({
-        _id: '1',
-        title: 'Hello World',
-        slug: 'hello-world',
-        content: 'First post content'
-      }, null, 2)
+      JSON.stringify(
+        {
+          _id: '1',
+          title: 'Hello World',
+          slug: 'hello-world',
+          content: 'First post content',
+        },
+        null,
+        2,
+      ),
     );
 
     writeFileSync(
       join(CMS_DIR, 'blog-posts', 'getting-started.json'),
-      JSON.stringify({
-        _id: '2',
-        title: 'Getting Started',
-        slug: 'getting-started',
-        content: 'Guide content'
-      }, null, 2)
+      JSON.stringify(
+        {
+          _id: '2',
+          title: 'Getting Started',
+          slug: 'getting-started',
+          content: 'Guide content',
+        },
+        null,
+        2,
+      ),
     );
 
     provider = new FileSystemCMSProvider(TEMPLATES_DIR, CMS_DIR);
@@ -119,13 +135,13 @@ describe('FileSystemCMSProvider', () => {
       const items = await provider.getItems('blog-posts');
 
       expect(items).toHaveLength(2);
-      expect(items.some(i => i.slug === 'hello-world')).toBe(true);
-      expect(items.some(i => i.slug === 'getting-started')).toBe(true);
+      expect(items.some((i) => i.slug === 'hello-world')).toBe(true);
+      expect(items.some((i) => i.slug === 'getting-started')).toBe(true);
     });
 
     it('should add _slug from filename', async () => {
       const items = await provider.getItems('blog-posts');
-      const helloWorld = items.find(i => i.slug === 'hello-world');
+      const helloWorld = items.find((i) => i.slug === 'hello-world');
 
       expect(helloWorld?._slug).toBe('hello-world');
     });
@@ -208,23 +224,27 @@ describe('FileSystemCMSProvider', () => {
       // Add products schema in templates/
       writeFileSync(
         join(TEMPLATES_DIR, 'product.json'),
-        JSON.stringify({
-          meta: {
-            source: 'cms',
-            cms: {
-              id: 'products',
-              name: 'Products',
-              slugField: 'slug',
-              urlPattern: '/shop/{{slug}}',
-              fields: {
-                name: { type: 'string' },
-                slug: { type: 'string' },
-                price: { type: 'number' },
+        JSON.stringify(
+          {
+            meta: {
+              source: 'cms',
+              cms: {
+                id: 'products',
+                name: 'Products',
+                slugField: 'slug',
+                urlPattern: '/shop/{{slug}}',
+                fields: {
+                  name: { type: 'string' },
+                  slug: { type: 'string' },
+                  price: { type: 'number' },
+                },
               },
             },
+            root: { type: 'node', tag: 'div', children: [] },
           },
-          root: { type: 'node', tag: 'div', children: [] }
-        }, null, 2)
+          null,
+          2,
+        ),
       );
 
       provider.clearSchemaCache();
@@ -264,19 +284,23 @@ describe('FileSystemCMSProvider', () => {
       // Add new page with CMS in templates/
       writeFileSync(
         join(TEMPLATES_DIR, 'product.json'),
-        JSON.stringify({
-          meta: {
-            source: 'cms',
-            cms: {
-              id: 'products',
-              name: 'Products',
-              slugField: 'slug',
-              urlPattern: '/shop/{{slug}}',
-              fields: {},
+        JSON.stringify(
+          {
+            meta: {
+              source: 'cms',
+              cms: {
+                id: 'products',
+                name: 'Products',
+                slugField: 'slug',
+                urlPattern: '/shop/{{slug}}',
+                fields: {},
+              },
             },
+            root: { type: 'node', tag: 'div', children: [] },
           },
-          root: { type: 'node', tag: 'div', children: [] }
-        }, null, 2)
+          null,
+          2,
+        ),
       );
 
       // Still cached
@@ -303,37 +327,43 @@ describe('FileSystemCMSProvider', () => {
     });
 
     it('should reject filenames with path traversal in getItemByFilename', async () => {
-      await expect(provider.getItemByFilename('blog-posts', '../../../etc/passwd'))
-        .rejects.toThrow(/Invalid filename/);
-      await expect(provider.getItemByFilename('blog-posts', '..'))
-        .rejects.toThrow(/Invalid filename/);
+      await expect(provider.getItemByFilename('blog-posts', '../../../etc/passwd')).rejects.toThrow(/Invalid filename/);
+      await expect(provider.getItemByFilename('blog-posts', '..')).rejects.toThrow(/Invalid filename/);
     });
 
     it('should reject filenames with path separators in getItemByFilename', async () => {
-      await expect(provider.getItemByFilename('blog-posts', 'path/to/file'))
-        .rejects.toThrow(/Invalid filename/);
+      await expect(provider.getItemByFilename('blog-posts', 'path/to/file')).rejects.toThrow(/Invalid filename/);
     });
 
     it('should reject invalid collection names in deleteItem', async () => {
-      await expect(provider.deleteItem('../etc', 'passwd'))
-        .rejects.toThrow(/Invalid collection name/);
+      await expect(provider.deleteItem('../etc', 'passwd')).rejects.toThrow(/Invalid collection name/);
     });
 
     it('should reject invalid filenames in deleteItem', async () => {
-      await expect(provider.deleteItem('blog-posts', '../../../etc/passwd'))
-        .rejects.toThrow(/Invalid filename/);
+      await expect(provider.deleteItem('blog-posts', '../../../etc/passwd')).rejects.toThrow(/Invalid filename/);
     });
 
     it('should reject invalid collection IDs in saveSchema', async () => {
-      await expect(provider.saveSchema('../hack', {}))
-        .rejects.toThrow(/Invalid collection ID/);
-      await expect(provider.saveSchema('test/path', {}))
-        .rejects.toThrow(/Invalid collection ID/);
+      await expect(provider.saveSchema('../hack', {})).rejects.toThrow(/Invalid collection ID/);
+      await expect(provider.saveSchema('test/path', {})).rejects.toThrow(/Invalid collection ID/);
     });
 
     it('should reject invalid collection IDs in updateSchema', async () => {
-      await expect(provider.updateSchema('../hack', {}))
-        .rejects.toThrow(/Invalid collection ID/);
+      await expect(provider.updateSchema('../hack', {})).rejects.toThrow(/Invalid collection ID/);
+    });
+
+    it('saveSchema creates a cms/<id>/ dir for a file-backed collection', async () => {
+      await provider.saveSchema('file-coll', { meta: { source: 'cms', cms: { id: 'file-coll' } } });
+      expect(existsSync(join(CMS_DIR, 'file-coll'))).toBe(true);
+    });
+
+    it('saveSchema does NOT create a cms/<id>/ dir for a Sanity-backed collection', async () => {
+      await provider.saveSchema('sanity-coll', {
+        meta: { source: 'cms', cms: { id: 'sanity-coll', source: 'sanity', documentType: 'post' } },
+      });
+      // Template written, but no on-disk items dir (items live in Sanity, read-only).
+      expect(existsSync(join(TEMPLATES_DIR, 'sanity-coll.json'))).toBe(true);
+      expect(existsSync(join(CMS_DIR, 'sanity-coll'))).toBe(false);
     });
 
     it('should accept valid collection names', async () => {
@@ -344,12 +374,9 @@ describe('FileSystemCMSProvider', () => {
 
     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/);
+      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/);
     });
   });
 
@@ -392,9 +419,9 @@ describe('FileSystemCMSProvider', () => {
       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();
+      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');
+      expect(items.find((i) => i._filename === 'hello-world')?.title).toBe('Hello World');
 
       const single = await provider.getItemByFilename('blog-posts', 'brand-new');
       expect(single).toBeNull();
@@ -402,22 +429,31 @@ describe('FileSystemCMSProvider', () => {
 
     it('getAllDrafts returns drafts with _isDraft transient flag', async () => {
       await provider.saveDraft('blog-posts', {
-        _id: '1', _filename: 'hello-world', title: 'WIP', slug: 'hello-world',
+        _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',
+        _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']);
+      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',
+        _id: '1',
+        _filename: 'hello-world',
+        title: 'WIP',
+        slug: 'hello-world',
       });
       expect(await provider.hasDraft('blog-posts', 'hello-world')).toBe(true);
     });
@@ -426,7 +462,10 @@ describe('FileSystemCMSProvider', () => {
       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',
+        _id: '1',
+        _filename: 'hello-world',
+        title: 'WIP',
+        slug: 'hello-world',
       });
       expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.draft.json'))).toBe(true);
 
@@ -459,25 +498,30 @@ describe('FileSystemCMSProvider', () => {
 
     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',
+        _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(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/);
+      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',
+        _id: '1',
+        _filename: 'hello-world',
+        title: 'WIP',
+        slug: 'hello-world',
       });
 
       await provider.deleteItem('blog-posts', 'hello-world');
@@ -497,12 +541,11 @@ describe('FileSystemCMSProvider', () => {
       };
       await provider.saveItem('blog-posts', item as any);
 
-      const { readFile } = await import('fs/promises');
+      const { readFile } = await import('node: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();
     });
   });
-
 });