meno-core 1.0.53 → 1.1.0

package/lib/server/services/cmsService.ts

@@ -10,11 +10,10 @@ import type {
   CMSItemVersions,
   CMSRouteMatch,
   CMSListQuery,
-  CMSFilterCondition,
-  CMSSortConfig,
   ReferenceLocation,
 } from '../../shared/types';
 import { isItemDraftForLocale } from '../../shared/types';
+import { applyCmsFilters, applyCmsSorting } from '../../shared/cmsQuery';
 import { isI18nValue } from '../../shared/i18n';
 import { tiptapToHtml } from '../../shared/richtext/tiptapToHtml';
 import { isTiptapDocument } from '../../shared/richtext/types';
@@ -144,7 +143,7 @@ export class CMSService {
     if (richTextFields.length === 0) return items;
 
     // Process each item
-    return items.map(item => {
+    return items.map((item) => {
       const processed = { ...item };
 
       for (const fieldName of richTextFields) {
@@ -199,6 +198,9 @@ export class CMSService {
 
     for (const [id, schemaInfo] of schemas) {
       newSchemaCache.set(id, schemaInfo);
+      // A data-only collection (no urlPattern) has no per-item route, so it contributes
+      // no route pattern — matchRoute never resolves it, which is correct (it's list-only).
+      if (!schemaInfo.schema.urlPattern) continue;
       newRoutePatterns.push({
         regex: this.patternToRegex(schemaInfo.schema.urlPattern),
         collection: id,
@@ -240,6 +242,7 @@ export class CMSService {
       const match = path.match(route.regex);
       if (match) {
         const urlSlug = match[route.slugGroup];
+        if (urlSlug === undefined) continue;
 
         // Try to find item by matching its slug field value
         const item = await this.findItemBySlug(route.collection, urlSlug, locale);
@@ -264,11 +267,7 @@ export class CMSService {
    * @param slugField - Field name containing the slug
    * @returns CMSItem if found, null otherwise
    */
-  private findBySimpleSlug(
-    items: CMSItem[],
-    urlSlug: string,
-    slugField: string
-  ): CMSItem | null {
+  private findBySimpleSlug(items: CMSItem[], urlSlug: string, slugField: string): CMSItem | null {
     for (const item of items) {
       const slugValue = item[slugField];
 
@@ -291,12 +290,7 @@ export class CMSService {
    * @param locale - Optional locale for preferential matching
    * @returns CMSItem if found, null otherwise
    */
-  private findByI18nSlug(
-    items: CMSItem[],
-    urlSlug: string,
-    slugField: string,
-    locale?: string
-  ): CMSItem | null {
+  private findByI18nSlug(items: CMSItem[], urlSlug: string, slugField: string, locale?: string): CMSItem | null {
     for (const item of items) {
       const slugValue = item[slugField];
 
@@ -324,11 +318,7 @@ export class CMSService {
    * @param locale - Optional locale for i18n slug matching
    * @returns CMSItem if found, null otherwise
    */
-  private async findItemBySlug(
-    collection: string,
-    urlSlug: string,
-    locale?: string
-  ): Promise<CMSItem | null> {
+  private async findItemBySlug(collection: string, urlSlug: string, locale?: string): Promise<CMSItem | null> {
     if (!this.provider) {
       return null;
     }
@@ -339,6 +329,9 @@ export class CMSService {
     const slugField = schemaInfo.schema.slugField;
     const items = await this.getCachedItems(collection);
 
+    // A data-only collection has no slug field — only the filename fallback can match.
+    if (!slugField) return await this.provider.getItemByFilename(collection, urlSlug);
+
     // Try simple string slug match first
     const simpleMatch = this.findBySimpleSlug(items, urlSlug, slugField);
     if (simpleMatch) return simpleMatch;
@@ -363,7 +356,7 @@ export class CMSService {
     collection: string,
     locales?: string[],
     defaultLocale?: string,
-    options?: { excludeDrafts?: boolean }
+    options?: { excludeDrafts?: boolean },
   ): Promise<string[]> {
     if (!this.provider) {
       return [];
@@ -371,20 +364,21 @@ export class CMSService {
 
     const schemaInfo = this.schemaCache.get(collection);
     if (!schemaInfo) return [];
+    // A data-only collection (no urlPattern/slugField) contributes no sitemap URLs.
+    const { urlPattern, slugField } = schemaInfo.schema;
+    if (!urlPattern || !slugField) return [];
 
     const items = await this.getCachedItems(collection);
     const urls: string[] = [];
 
     for (const item of items) {
-      const slugValue = item[schemaInfo.schema.slugField];
+      const slugValue = item[slugField];
 
       // Case 1: Simple string slug - one URL
       if (typeof slugValue === 'string') {
         // Skip if item is draft for the default locale (non-i18n case)
         if (options?.excludeDrafts && defaultLocale && isItemDraftForLocale(item, defaultLocale)) continue;
-        urls.push(
-          schemaInfo.schema.urlPattern.replace('{{slug}}', slugValue)
-        );
+        urls.push(urlPattern.replace('{{slug}}', slugValue));
       }
       // Case 2: i18n slug - one URL per locale
       else if (isI18nValue(slugValue) && locales) {
@@ -392,7 +386,7 @@ export class CMSService {
           if (options?.excludeDrafts && isItemDraftForLocale(item, locale)) continue;
           const localizedSlug = slugValue[locale] as string;
           if (localizedSlug) {
-            const path = schemaInfo.schema.urlPattern.replace('{{slug}}', localizedSlug);
+            const path = urlPattern.replace('{{slug}}', localizedSlug);
             // For default locale, no prefix; for others, add locale prefix
             if (locale === defaultLocale) {
               urls.push(path);
@@ -406,9 +400,7 @@ export class CMSService {
       else if (isI18nValue(slugValue)) {
         for (const key of Object.keys(slugValue)) {
           if (key !== '_i18n' && typeof slugValue[key] === 'string') {
-            urls.push(
-              schemaInfo.schema.urlPattern.replace('{{slug}}', slugValue[key] as string)
-            );
+            urls.push(urlPattern.replace('{{slug}}', slugValue[key] as string));
             break; // Only use first available
           }
         }
@@ -474,17 +466,17 @@ export class CMSService {
       this.provider.getAllDrafts(collection),
     ]);
 
-    const draftFilenames = new Set(drafts.map(d => d._filename).filter(Boolean) as string[]);
+    const draftFilenames = new Set(drafts.map((d) => d._filename).filter(Boolean) as string[]);
 
-    const annotatedPublished: CMSItem[] = published.map(item => {
+    const annotatedPublished: CMSItem[] = published.map((item) => {
       if (item._filename && draftFilenames.has(item._filename)) {
         return { ...item, _hasDraft: true };
       }
       return item;
     });
 
-    const publishedFilenames = new Set(published.map(i => i._filename).filter(Boolean) as string[]);
-    const draftOnly = drafts.filter(d => d._filename && !publishedFilenames.has(d._filename));
+    const publishedFilenames = new Set(published.map((i) => i._filename).filter(Boolean) as string[]);
+    const draftOnly = drafts.filter((d) => d._filename && !publishedFilenames.has(d._filename));
 
     return [...annotatedPublished, ...draftOnly];
   }
@@ -574,17 +566,17 @@ export class CMSService {
 
     // Exclude draft items for the specified locale
     if (query.excludeDraftLocale) {
-      items = items.filter(item => !isItemDraftForLocale(item, query.excludeDraftLocale!));
+      items = items.filter((item) => !isItemDraftForLocale(item, query.excludeDraftLocale!));
     }
 
     // Apply filters
     if (query.filter) {
-      items = this.applyFilters(items, query.filter);
+      items = applyCmsFilters(items, query.filter);
     }
 
     // Apply sorting
     if (query.sort) {
-      items = this.applySorting(items, query.sort);
+      items = applyCmsSorting(items, query.sort);
     }
 
     // Apply offset
@@ -600,63 +592,6 @@ export class CMSService {
     return items;
   }
 
-  /**
-   * Apply filters to items
-   */
-  private applyFilters(
-    items: CMSItem[],
-    filter: CMSFilterCondition | CMSFilterCondition[] | Record<string, unknown>
-  ): CMSItem[] {
-    // Handle simple object filter: { featured: true }
-    if (!Array.isArray(filter) && !this.isFilterCondition(filter)) {
-      return items.filter(item =>
-        Object.entries(filter).every(([key, value]) => item[key] === value)
-      );
-    }
-
-    // Handle array of conditions or single condition
-    const conditions = Array.isArray(filter) ? filter : [filter as CMSFilterCondition];
-    return items.filter(item =>
-      conditions.every(cond => this.matchCondition(item, cond))
-    );
-  }
-
-  /**
-   * Check if object is a CMSFilterCondition
-   */
-  private isFilterCondition(obj: unknown): obj is CMSFilterCondition {
-    return typeof obj === 'object' && obj !== null && 'field' in obj;
-  }
-
-  /**
-   * Match a single filter condition against an item
-   */
-  private matchCondition(item: CMSItem, condition: CMSFilterCondition): boolean {
-    const value = item[condition.field];
-    const op = condition.operator || 'eq';
-
-    switch (op) {
-      case 'eq':
-        return value === condition.value;
-      case 'neq':
-        return value !== condition.value;
-      case 'gt':
-        return (value as number) > (condition.value as number);
-      case 'gte':
-        return (value as number) >= (condition.value as number);
-      case 'lt':
-        return (value as number) < (condition.value as number);
-      case 'lte':
-        return (value as number) <= (condition.value as number);
-      case 'contains':
-        return String(value).includes(String(condition.value));
-      case 'in':
-        return Array.isArray(condition.value) && condition.value.includes(value);
-      default:
-        return false;
-    }
-  }
-
   /**
    * Get items by their IDs from a collection.
    * Used for resolving reference fields in CMS List templates.
@@ -674,56 +609,16 @@ export class CMSService {
     const allItems = await this.getCachedItems(collection);
 
     // Build lookup maps for both _id and _filename
-    const itemMap = new Map(allItems.map(item => [item._id, item]));
-    const filenameMap = new Map(
-      allItems
-        .filter(item => item._filename)
-        .map(item => [item._filename!, item])
-    );
+    const itemMap = new Map(allItems.map((item) => [item._id, item]));
+    const filenameMap = new Map(allItems.filter((item) => item._filename).map((item) => [item._filename!, item]));
 
     // Filter to matching items, preserving input order
     return ids
       .filter(Boolean)
-      .map(id => itemMap.get(id) || filenameMap.get(id))
+      .map((id) => itemMap.get(id) || filenameMap.get(id))
       .filter((item): item is CMSItem => item !== undefined);
   }
 
-  /**
-   * Apply sorting to items
-   */
-  private applySorting(items: CMSItem[], sort: CMSSortConfig | CMSSortConfig[]): CMSItem[] {
-    const sorts = Array.isArray(sort) ? sort : [sort];
-
-    return [...items].sort((a, b) => {
-      for (const s of sorts) {
-        const aVal = a[s.field];
-        const bVal = b[s.field];
-        const isDesc = s.order === 'desc';
-
-        // Handle boolean comparison
-        if (typeof aVal === 'boolean' && typeof bVal === 'boolean') {
-          if (aVal === bVal) continue;
-          // For desc: true first (true > false), for asc: false first
-          if (isDesc) {
-            return aVal ? -1 : 1;
-          } else {
-            return aVal ? 1 : -1;
-          }
-        }
-
-        // Standard comparison (compare as primitives)
-        let result = 0;
-        if ((aVal as string | number) < (bVal as string | number)) result = -1;
-        else if ((aVal as string | number) > (bVal as string | number)) result = 1;
-
-        if (result !== 0) {
-          return isDesc ? -result : result;
-        }
-      }
-      return 0;
-    });
-  }
-
   /**
    * Find all references to a specific item across all collections.
    * Used to warn users before deleting an item that is referenced elsewhere.
@@ -732,10 +627,7 @@ export class CMSService {
    * @param targetId - ID or filename of the target item
    * @returns Array of ReferenceLocation objects describing where the item is referenced
    */
-  async findReferencesTo(
-    targetCollection: string,
-    targetId: string
-  ): Promise<ReferenceLocation[]> {
+  async findReferencesTo(targetCollection: string, targetId: string): Promise<ReferenceLocation[]> {
     if (!this.provider) {
       return [];
     }
@@ -747,8 +639,9 @@ export class CMSService {
       const { schema } = schemaInfo;
 
       // Find reference fields pointing to targetCollection
-      const refFields = Object.entries(schema.fields)
-        .filter(([_, def]) => def.type === 'reference' && def.collection === targetCollection);
+      const refFields = Object.entries(schema.fields).filter(
+        ([_, def]) => def.type === 'reference' && def.collection === targetCollection,
+      );
 
       if (refFields.length === 0) continue;
 
@@ -782,10 +675,7 @@ export class CMSService {
    * For multi-reference fields: filters out the target ID
    * @returns Number of items updated
    */
-  async removeReferencesTo(
-    targetCollection: string,
-    targetId: string
-  ): Promise<number> {
+  async removeReferencesTo(targetCollection: string, targetId: string): Promise<number> {
     if (!this.provider) {
       return 0;
     }
@@ -806,7 +696,7 @@ export class CMSService {
       let newValue: string | string[] | null;
       if (fieldDef?.multiple && Array.isArray(currentValue)) {
         // Multi-reference: filter out target
-        newValue = currentValue.filter(id => id !== targetId);
+        newValue = currentValue.filter((id) => id !== targetId);
         if (newValue.length === 0) newValue = null;
       } else {
         // Single reference: clear it

package/lib/server/services/componentService.test.ts

@@ -1,8 +1,8 @@
-import { test, expect, describe, beforeEach, afterAll, mock } from 'bun:test';
-import { mkdtempSync, rmSync, existsSync, readFileSync, mkdirSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { ComponentService, rewriteComponentRefs, type ComponentServiceFs, type ComponentLoader, type ComponentWriter } from './componentService';
+import { test, expect, describe, beforeEach, afterAll } from 'bun:test';
+import { mkdtempSync, rmSync, existsSync, readFileSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { ComponentService, rewriteComponentRefs, type ComponentWriter } from './componentService';
 import { setProjectRoot, getProjectRoot, projectPaths } from '../projectContext';
 import { createMockComponentDefinition } from '../../test-utils';
 import {
@@ -108,8 +108,8 @@ describe('ComponentService', () => {
       const allComponents = componentService.getAllComponents();
 
       expect(allComponents).toBeDefined();
-      expect(allComponents['TestComponent']).toBeDefined();
-      expect(allComponents['Button']).toBeDefined();
+      expect(allComponents.TestComponent).toBeDefined();
+      expect(allComponents.Button).toBeDefined();
     });
 
     test('should return empty object when no components loaded', () => {
@@ -135,33 +135,41 @@ describe('ComponentService', () => {
     });
 
     test('should return false for missing structure', () => {
-      expect(componentService.validateComponentStructure({
-        component: {}
-      } as any)).toBe(false);
+      expect(
+        componentService.validateComponentStructure({
+          component: {},
+        } as any),
+      ).toBe(false);
     });
 
     test('should return false for invalid structure type', () => {
-      expect(componentService.validateComponentStructure({
-        component: { structure: 'invalid' }
-      } as any)).toBe(false);
+      expect(
+        componentService.validateComponentStructure({
+          component: { structure: 'invalid' },
+        } as any),
+      ).toBe(false);
     });
 
     test('should return false for structure without type', () => {
-      expect(componentService.validateComponentStructure({
-        component: { structure: { tag: 'div' } }
-      } as any)).toBe(false);
+      expect(
+        componentService.validateComponentStructure({
+          component: { structure: { tag: 'div' } },
+        } as any),
+      ).toBe(false);
     });
 
     test('should return true for structure with valid type', () => {
-      expect(componentService.validateComponentStructure({
-        component: {
-          structure: {
-            type: NODE_TYPE.NODE,
-            tag: 'div',
-            children: []
-          }
-        }
-      } as any)).toBe(true);
+      expect(
+        componentService.validateComponentStructure({
+          component: {
+            structure: {
+              type: NODE_TYPE.NODE,
+              tag: 'div',
+              children: [],
+            },
+          },
+        } as any),
+      ).toBe(true);
     });
   });
 
@@ -209,6 +217,67 @@ describe('ComponentService', () => {
 
       expect(filePath).toContain('Button.json');
     });
+
+    test('keeps javascript in the in-memory cache (JSON payload stays js-less)', async () => {
+      // The `.json` file must not carry javascript (the sibling `.js` owns it), but the
+      // LIVE cache must — otherwise the SSR preview renders the component without its
+      // script between this save and the next file-watcher reload.
+      const componentData = createMockComponentDefinition('TestComponent');
+      if (componentData.component) {
+        componentData.component.javascript = 'console.log("kept");';
+      }
+
+      await componentService.saveComponent('TestComponent', componentData);
+
+      const savedData = JSON.parse((mockFs.writeFile as any).mock.calls[0][1]);
+      expect(savedData.component.javascript).toBeUndefined();
+      expect(componentService.getComponent('TestComponent')?.component?.javascript).toBe('console.log("kept");');
+    });
+
+    test('a js-less save preserves the previously cached javascript', async () => {
+      // A props/structure-only save (the common PropsPanel edit) must not erase the
+      // component's script from the cache.
+      const withJs = createMockComponentDefinition('TestComponent');
+      if (withJs.component) withJs.component.javascript = 'console.log("orig");';
+      await componentService.saveComponent('TestComponent', withJs);
+
+      const withoutJs = createMockComponentDefinition('TestComponent');
+      await componentService.saveComponent('TestComponent', withoutJs);
+
+      expect(componentService.getComponent('TestComponent')?.component?.javascript).toBe('console.log("orig");');
+    });
+  });
+
+  describe('saveComponent with a single-file writer (astro format)', () => {
+    test('the writer receives the FULL def — javascript preserved, not stripped', async () => {
+      // Single-file writers (AstroComponentWriter) re-emit the WHOLE file from the def
+      // they're given: a js-less def would silently delete the component's <script>
+      // from the source of truth. Regression test for the rename-cascade data loss.
+      const written: ComponentDefinition[] = [];
+      const writer: ComponentWriter = {
+        componentsDir: () => '/tmp/fake-components',
+        writeComponent: async (_dir, _name, def) => {
+          written.push(def);
+        },
+        writeJavaScript: async () => {},
+        writeCSS: async () => {},
+        removeComponent: async () => {},
+        componentExists: async () => false,
+        moveComponent: async () => {},
+      };
+      const service = new ComponentService({ loader: mockLoader, writer });
+
+      const withJs = createMockComponentDefinition('Header');
+      if (withJs.component) withJs.component.javascript = 'menuToggle();';
+      await service.saveComponent('Header', withJs);
+      expect(written[0]?.component?.javascript).toBe('menuToggle();');
+
+      // A js-less follow-up save (props-only edit, or the href-rename cascade
+      // re-saving a cached def) keeps the cached script in the emitted file.
+      const withoutJs = createMockComponentDefinition('Header');
+      await service.saveComponent('Header', withoutJs);
+      expect(written[1]?.component?.javascript).toBe('menuToggle();');
+    });
   });
 
   describe('saveComponentJavaScript', () => {
@@ -260,10 +329,14 @@ describe('ComponentService', () => {
         tag: 'div',
         children: [
           { type: 'component', component: 'Old' },
-          { type: 'node', tag: 'section', children: [
-            { type: 'component', component: 'Old', props: { text: 'hi' } },
-            { type: 'component', component: 'Keep' },
-          ] },
+          {
+            type: 'node',
+            tag: 'section',
+            children: [
+              { type: 'component', component: 'Old', props: { text: 'hi' } },
+              { type: 'component', component: 'Keep' },
+            ],
+          },
         ],
       };
 
@@ -271,8 +344,8 @@ describe('ComponentService', () => {
 
       expect(changed).toBe(true);
       expect((tree.children[0] as any).component).toBe('New');
-      expect(((tree.children[1] as any).children[0]).component).toBe('New');
-      expect(((tree.children[1] as any).children[1]).component).toBe('Keep');
+      expect((tree.children[1] as any).children[0].component).toBe('New');
+      expect((tree.children[1] as any).children[1].component).toBe('Keep');
     });
 
     test('returns false when no references match', () => {
@@ -293,10 +366,7 @@ describe('ComponentService', () => {
         type: 'node',
         tag: 'button',
         attributes: { class: 'Button primary' },
-        children: [
-          { type: 'embed', html: '<button>Button</button>' },
-          'Click the Button below',
-        ],
+        children: [{ type: 'embed', html: '<button>Button</button>' }, 'Click the Button below'],
       };
 
       const changed = rewriteComponentRefs(tree, 'Button', 'Cta');
@@ -395,12 +465,22 @@ describe('ComponentService', () => {
       const dir = '/virtual/src/components';
       const writer: ComponentWriter = {
         componentsDir: () => dir,
-        writeComponent: async (d, n) => { calls.push({ op: 'writeComponent', dir: d, name: n }); },
-        writeJavaScript: async (d, n, js) => { calls.push({ op: 'writeJavaScript', dir: d, name: n, extra: js }); },
-        writeCSS: async (d, n, css) => { calls.push({ op: 'writeCSS', dir: d, name: n, extra: css }); },
-        removeComponent: async (d, n) => { calls.push({ op: 'removeComponent', dir: d, name: n }); },
+        writeComponent: async (d, n) => {
+          calls.push({ op: 'writeComponent', dir: d, name: n });
+        },
+        writeJavaScript: async (d, n, js) => {
+          calls.push({ op: 'writeJavaScript', dir: d, name: n, extra: js });
+        },
+        writeCSS: async (d, n, css) => {
+          calls.push({ op: 'writeCSS', dir: d, name: n, extra: css });
+        },
+        removeComponent: async (d, n) => {
+          calls.push({ op: 'removeComponent', dir: d, name: n });
+        },
         componentExists: async () => false,
-        moveComponent: async (s, t, n, dn) => { calls.push({ op: 'moveComponent', dir: `${s}->${t}`, name: n, extra: dn }); },
+        moveComponent: async (s, t, n, dn) => {
+          calls.push({ op: 'moveComponent', dir: `${s}->${t}`, name: n, extra: dn });
+        },
       };
       return { writer, calls, dir };
     }
@@ -410,9 +490,9 @@ describe('ComponentService', () => {
       const svc = new ComponentService({ writer });
       await svc.saveComponent('Widget', createMockComponentDefinition('Widget'));
       expect(calls).toHaveLength(1);
-      expect(calls[0].op).toBe('writeComponent');
-      expect(calls[0].dir).toBe(dir);
-      expect(calls[0].name).toBe('Widget');
+      expect(calls[0]!.op).toBe('writeComponent');
+      expect(calls[0]!.dir).toBe(dir);
+      expect(calls[0]!.name).toBe('Widget');
       expect(svc.hasComponent('Widget')).toBe(true);
     });
 
@@ -422,7 +502,7 @@ describe('ComponentService', () => {
       await svc.saveComponent('Widget', createMockComponentDefinition('Widget'));
       await svc.saveComponentCSS('Widget', '.w{}');
       await svc.saveComponentJavaScript('Widget', 'x();');
-      const ops = calls.map(c => c.op);
+      const ops = calls.map((c) => c.op);
       expect(ops).toEqual(['writeComponent', 'writeCSS', 'writeJavaScript']);
       const cached = svc.getComponent('Widget');
       expect(cached?.component?.css).toBe('.w{}');
@@ -437,7 +517,7 @@ describe('ComponentService', () => {
       });
       await svc.loadAllComponents();
       await svc.renameComponent('Widget', 'Gadget');
-      const move = calls.find(c => c.op === 'moveComponent');
+      const move = calls.find((c) => c.op === 'moveComponent');
       expect(move).toBeDefined();
       expect(move!.name).toBe('Widget');
       expect(move!.extra).toBe('Gadget'); // dstName