meno-core 1.0.52 → 1.0.53

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

@@ -1,5 +1,9 @@
-import { test, expect, describe, beforeEach, mock } from 'bun:test';
-import { ComponentService, type ComponentServiceFs, type ComponentLoader } from './componentService';
+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 { setProjectRoot, getProjectRoot, projectPaths } from '../projectContext';
 import { createMockComponentDefinition } from '../../test-utils';
 import {
   createTypedMockComponentServiceFs,
@@ -249,6 +253,199 @@ describe('ComponentService', () => {
     });
   });
 
+  describe('rewriteComponentRefs', () => {
+    test('rewrites component references in a tree', () => {
+      const tree = {
+        type: 'node',
+        tag: 'div',
+        children: [
+          { type: 'component', component: 'Old' },
+          { type: 'node', tag: 'section', children: [
+            { type: 'component', component: 'Old', props: { text: 'hi' } },
+            { type: 'component', component: 'Keep' },
+          ] },
+        ],
+      };
+
+      const changed = rewriteComponentRefs(tree, 'Old', 'New');
+
+      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');
+    });
+
+    test('returns false when no references match', () => {
+      const tree = {
+        type: 'node',
+        tag: 'div',
+        children: [{ type: 'component', component: 'Keep' }],
+      };
+
+      expect(rewriteComponentRefs(tree, 'Old', 'New')).toBe(false);
+      expect((tree.children[0] as any).component).toBe('Keep');
+    });
+
+    test('does not match component names that appear as substrings in other fields', () => {
+      // Critical: a name like "Button" must not be substituted inside HTML
+      // tags, CSS classes, or string copy that happen to contain the word.
+      const tree = {
+        type: 'node',
+        tag: 'button',
+        attributes: { class: 'Button primary' },
+        children: [
+          { type: 'embed', html: '<button>Button</button>' },
+          'Click the Button below',
+        ],
+      };
+
+      const changed = rewriteComponentRefs(tree, 'Button', 'Cta');
+
+      expect(changed).toBe(false);
+      expect(tree.tag).toBe('button');
+      expect(tree.attributes.class).toBe('Button primary');
+      expect((tree.children[0] as any).html).toBe('<button>Button</button>');
+      expect(tree.children[1]).toBe('Click the Button below');
+    });
+
+    test('handles missing children safely', () => {
+      expect(rewriteComponentRefs({ type: 'component', component: 'Old' }, 'Old', 'New')).toBe(true);
+      expect(rewriteComponentRefs(null, 'Old', 'New')).toBe(false);
+      expect(rewriteComponentRefs(undefined, 'Old', 'New')).toBe(false);
+    });
+
+    test('walks an object children field (e.g. single nested node)', () => {
+      const tree = {
+        type: 'node',
+        tag: 'div',
+        children: { type: 'component', component: 'Old' },
+      };
+      expect(rewriteComponentRefs(tree, 'Old', 'New')).toBe(true);
+      expect((tree.children as any).component).toBe('New');
+    });
+  });
+
+  describe('renameComponent', () => {
+    test('rejects when oldName is empty', async () => {
+      await expect(componentService.renameComponent('', 'New')).rejects.toThrow(/oldName/);
+    });
+
+    test('rejects when newName is empty', async () => {
+      await expect(componentService.renameComponent('Button', '')).rejects.toThrow(/newName/);
+    });
+
+    test('rejects when names are identical', async () => {
+      await componentService.loadAllComponents();
+      await expect(componentService.renameComponent('Button', 'Button')).rejects.toThrow(/differ/);
+    });
+
+    test('rejects invalid identifiers', async () => {
+      await componentService.loadAllComponents();
+      await expect(componentService.renameComponent('Button', '1Bad')).rejects.toThrow(/identifier/);
+      await expect(componentService.renameComponent('Button', 'bad-name')).rejects.toThrow(/identifier/);
+    });
+
+    test('rejects when the source component does not exist', async () => {
+      await componentService.loadAllComponents();
+      await expect(componentService.renameComponent('Ghost', 'NewGhost')).rejects.toThrow(/not found/);
+    });
+
+    test('rejects when the target name is already taken', async () => {
+      await componentService.loadAllComponents();
+      // Both TestComponent and Button are seeded in beforeEach.
+      await expect(componentService.renameComponent('Button', 'TestComponent')).rejects.toThrow(/already exists/);
+    });
+  });
+
+  describe('JSON mode (no writer) — default path regression guard', () => {
+    // Locks in that a writer-less service still writes <root>/components/<name>.json
+    // with the exact 2-space JSON serialization (byte-identical to legacy behavior).
+    const prevRoot = getProjectRoot();
+    const root = mkdtempSync(join(tmpdir(), 'meno-json-comp-'));
+    afterAll(() => {
+      rmSync(root, { recursive: true, force: true });
+      setProjectRoot(prevRoot);
+    });
+
+    test('saveComponent writes components/<name>.json under projectRoot', async () => {
+      setProjectRoot(root);
+      // Real JSON projects always have a components/ dir; the JSON save path only
+      // auto-creates category subdirs, never the root (unchanged legacy behavior).
+      mkdirSync(join(root, 'components'), { recursive: true });
+      const svc = new ComponentService(); // no fs, no loader, no writer → real fs
+      const def = createMockComponentDefinition('JsonCard');
+      await svc.saveComponent('JsonCard', def);
+
+      const file = join(projectPaths.components(), 'JsonCard.json');
+      expect(file).toBe(join(root, 'components', 'JsonCard.json'));
+      expect(existsSync(file)).toBe(true);
+
+      // Byte-identical serialization: javascript stripped, 2-space indent.
+      const onDisk = readFileSync(file, 'utf8');
+      const expected = JSON.parse(JSON.stringify(def));
+      delete (expected as any).component?.javascript;
+      expect(onDisk).toBe(JSON.stringify(expected, null, 2));
+    });
+  });
+
+  describe('writer mode — write ops route through the injected writer', () => {
+    // A spy writer that records calls and never touches projectPaths.components().
+    function makeSpyWriter() {
+      const calls: Array<{ op: string; dir: string; name: string; extra?: unknown }> = [];
+      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 }); },
+        componentExists: async () => false,
+        moveComponent: async (s, t, n, dn) => { calls.push({ op: 'moveComponent', dir: `${s}->${t}`, name: n, extra: dn }); },
+      };
+      return { writer, calls, dir };
+    }
+
+    test('saveComponent calls writer.writeComponent (not fs/json), under the writer dir', async () => {
+      const { writer, calls, dir } = makeSpyWriter();
+      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(svc.hasComponent('Widget')).toBe(true);
+    });
+
+    test('saveComponentJavaScript / saveComponentCSS route through the writer and update the cache', async () => {
+      const { writer, calls } = makeSpyWriter();
+      const svc = new ComponentService({ writer });
+      await svc.saveComponent('Widget', createMockComponentDefinition('Widget'));
+      await svc.saveComponentCSS('Widget', '.w{}');
+      await svc.saveComponentJavaScript('Widget', 'x();');
+      const ops = calls.map(c => c.op);
+      expect(ops).toEqual(['writeComponent', 'writeCSS', 'writeJavaScript']);
+      const cached = svc.getComponent('Widget');
+      expect(cached?.component?.css).toBe('.w{}');
+      expect(cached?.component?.javascript).toBe('x();');
+    });
+
+    test('renameComponent uses writer.moveComponent with the new name', async () => {
+      const { writer, calls } = makeSpyWriter();
+      const svc = new ComponentService({
+        writer,
+        loader: createTypedMockComponentLoader(new Map([['Widget', createMockComponentDefinition('Widget')]])),
+      });
+      await svc.loadAllComponents();
+      await svc.renameComponent('Widget', 'Gadget');
+      const move = calls.find(c => c.op === 'moveComponent');
+      expect(move).toBeDefined();
+      expect(move!.name).toBe('Widget');
+      expect(move!.extra).toBe('Gadget'); // dstName
+      expect(svc.hasComponent('Gadget')).toBe(true);
+      expect(svc.hasComponent('Widget')).toBe(false);
+    });
+  });
+
   describe('constructor options', () => {
     test('should work with no options', () => {
       const service = new ComponentService();