meno-core 1.0.0

package/lib/server/services/configService.ts

@@ -0,0 +1,156 @@
+/**
+ * Config Service
+ * Centralized configuration loading and access
+ *
+ * Consolidates multiple config loaders into a single service that loads
+ * the project.config.json file once and exposes typed sections.
+ */
+
+import type { BreakpointConfig } from '../../shared/breakpoints';
+import { DEFAULT_BREAKPOINTS } from '../../shared/breakpoints';
+import type { ResponsiveScales } from '../../shared/responsiveScaling';
+import { DEFAULT_RESPONSIVE_SCALES } from '../../shared/responsiveScaling';
+import type { I18nConfig } from '../../shared/types/components';
+import { DEFAULT_I18N_CONFIG, migrateI18nConfig } from '../../shared/i18n';
+import { projectPaths } from '../projectContext';
+
+/**
+ * Icons configuration
+ */
+export interface IconsConfig {
+  favicon?: string;
+  appleTouchIcon?: string;
+}
+
+/**
+ * Raw project config structure from project.config.json
+ */
+interface RawProjectConfig {
+  breakpoints?: Record<string, number>;
+  responsiveScales?: Partial<ResponsiveScales>;
+  i18n?: unknown;
+  icons?: IconsConfig;
+}
+
+/**
+ * ConfigService
+ * Loads project configuration once and provides typed access to sections
+ */
+export class ConfigService {
+  private config: RawProjectConfig | null = null;
+  private loaded = false;
+
+  /**
+   * Load configuration from project.config.json
+   * Safe to call multiple times - only loads once
+   */
+  async load(): Promise<void> {
+    if (this.loaded) {
+      return;
+    }
+
+    try {
+      const file = Bun.file(projectPaths.config());
+      if (await file.exists()) {
+        const content = await file.text();
+        this.config = JSON.parse(content);
+      }
+    } catch {
+      // Fall through to defaults
+      this.config = null;
+    }
+
+    this.loaded = true;
+  }
+
+  /**
+   * Check if configuration has been loaded
+   */
+  isLoaded(): boolean {
+    return this.loaded;
+  }
+
+  /**
+   * Reset the service (for testing)
+   */
+  reset(): void {
+    this.config = null;
+    this.loaded = false;
+  }
+
+  /**
+   * Get breakpoint configuration
+   * Returns validated breakpoints or defaults
+   */
+  getBreakpoints(): BreakpointConfig {
+    if (!this.config?.breakpoints || typeof this.config.breakpoints !== 'object') {
+      return { ...DEFAULT_BREAKPOINTS };
+    }
+
+    // Validate breakpoint values
+    const breakpoints: BreakpointConfig = {};
+    for (const [key, value] of Object.entries(this.config.breakpoints)) {
+      if (typeof value === 'number' && value > 0) {
+        breakpoints[key] = value;
+      }
+    }
+
+    // Return validated breakpoints or defaults if none valid
+    return Object.keys(breakpoints).length > 0 ? breakpoints : { ...DEFAULT_BREAKPOINTS };
+  }
+
+  /**
+   * Get i18n configuration
+   * Automatically migrates old string[] format to LocaleConfig[] format
+   */
+  getI18n(): I18nConfig {
+    if (!this.config?.i18n) {
+      return { ...DEFAULT_I18N_CONFIG };
+    }
+
+    return migrateI18nConfig(this.config.i18n);
+  }
+
+  /**
+   * Get responsive scales configuration
+   * Merges with defaults for any missing values
+   */
+  getResponsiveScales(): ResponsiveScales {
+    if (!this.config?.responsiveScales || typeof this.config.responsiveScales !== 'object') {
+      return { ...DEFAULT_RESPONSIVE_SCALES };
+    }
+
+    return {
+      ...DEFAULT_RESPONSIVE_SCALES,
+      ...this.config.responsiveScales,
+    };
+  }
+
+  /**
+   * Get icons configuration
+   * Returns empty object if not configured
+   */
+  getIcons(): IconsConfig {
+    if (!this.config?.icons || typeof this.config.icons !== 'object') {
+      return {};
+    }
+
+    return this.config.icons;
+  }
+
+  /**
+   * Get raw config value by key (for extension)
+   */
+  getRaw<T>(key: string): T | undefined {
+    if (!this.config) {
+      return undefined;
+    }
+    return (this.config as Record<string, unknown>)[key] as T | undefined;
+  }
+}
+
+/**
+ * Singleton instance for global access
+ * Use this for convenience, or create your own instance for testing
+ */
+export const configService = new ConfigService();

package/lib/server/services/fileWatcherService.ts

@@ -0,0 +1,67 @@
+/**
+ * File Watcher Service
+ * Manages file watching for pages and components
+ */
+
+import { join } from 'path';
+import { FileWatcher, type FileWatchCallbacks } from '../fileWatcher';
+import { WebSocketManager } from '../websocketManager';
+import { ComponentService } from './componentService';
+import { PageService } from './pageService';
+import { PageCache } from '../pageCache';
+import { colorService } from './ColorService';
+import { loadJSONFile, mapPageNameToPath } from '../jsonLoader';
+import { projectPaths } from '../projectContext';
+
+export class FileWatcherService {
+  private fileWatcher: FileWatcher | null = null;
+
+  constructor(
+    private componentService: ComponentService,
+    private pageService: PageService,
+    private pageCache: PageCache,
+    private wsManager: WebSocketManager
+  ) {}
+
+  /**
+   * Initialize file watchers
+   */
+  initialize(): void {
+    this.fileWatcher = new FileWatcher({
+      onComponentChange: async () => {
+        await this.componentService.loadAllComponents();
+        this.wsManager.broadcastUpdate('all');
+      },
+      onPageChange: async (pagePath: string) => {
+        const pageName = pagePath === '/' ? 'index' : pagePath.substring(1);
+        const content = await loadJSONFile(join(projectPaths.pages(), `${pageName}.json`));
+        if (content) {
+          this.pageCache.set(pagePath, content);
+          this.wsManager.broadcastUpdate(pagePath);
+        } else {
+          this.pageCache.delete(pagePath);
+          this.wsManager.broadcastUpdate(pagePath);
+        }
+      },
+      onColorsChange: async () => {
+        // Clear the color service cache so it reloads on next request
+        colorService.clearCache();
+        // Broadcast to all clients to refresh their color data
+        this.wsManager.broadcastColorsUpdate();
+      },
+    });
+
+    this.fileWatcher.watchAll();
+  }
+
+  /**
+   * Stop file watchers
+   */
+  stop(): void {
+    if (this.fileWatcher) {
+      this.fileWatcher.stopAll();
+      this.fileWatcher = null;
+    }
+  }
+}
+

package/lib/server/services/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Server Services
+ * Centralized services for server operations
+ */
+
+export { PageService } from './pageService';
+export { ComponentService } from './componentService';
+export { FileWatcherService } from './fileWatcherService';
+export { CMSService } from './cmsService';
+

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

@@ -0,0 +1,258 @@
+import { test, expect, describe, beforeEach, afterEach, mock } from 'bun:test';
+import { PageService } from './pageService';
+import { PageCache } from '../pageCache';
+import { createMockPageData } from '../../test-utils';
+import { createTypedMockPageProvider, type TypedMockPageProvider } from '../../test-utils/factories/ServerMockFactory';
+
+describe('PageService', () => {
+  let pageCache: PageCache;
+  let pageService: PageService;
+  let mockProvider: TypedMockPageProvider;
+
+  beforeEach(() => {
+    pageCache = new PageCache();
+    mockProvider = createTypedMockPageProvider();
+    pageService = new PageService(pageCache, mockProvider);
+  });
+
+  afterEach(() => {
+    pageCache.clear();
+  });
+
+  describe('loadAllPages', () => {
+    test('should load all pages from provider', async () => {
+      const indexData = createMockPageData({ meta: { title: 'Home' } });
+      const aboutData = createMockPageData({ meta: { title: 'About' } });
+
+      // Set up provider with pages
+      mockProvider._pages['/'] = JSON.stringify(indexData);
+      mockProvider._pages['/about'] = JSON.stringify(aboutData);
+
+      await pageService.loadAllPages();
+
+      const indexPage = pageService.getPage('/');
+      const aboutPage = pageService.getPage('/about');
+
+      expect(indexPage).toBeDefined();
+      expect(aboutPage).toBeDefined();
+      expect(mockProvider.loadAll).toHaveBeenCalledTimes(1);
+    });
+
+    test('should handle empty provider gracefully', async () => {
+      await pageService.loadAllPages();
+
+      expect(pageService.getAllPagePaths()).toEqual([]);
+      expect(mockProvider.loadAll).toHaveBeenCalled();
+    });
+
+    test('should work without provider set', async () => {
+      const serviceWithoutProvider = new PageService(pageCache);
+
+      // Should not throw
+      await serviceWithoutProvider.loadAllPages();
+
+      expect(serviceWithoutProvider.getAllPagePaths()).toEqual([]);
+    });
+  });
+
+  describe('getPage', () => {
+    test('should return page content from cache', () => {
+      const testData = createMockPageData();
+      pageCache.set('/', JSON.stringify(testData), new Map());
+
+      const result = pageService.getPage('/');
+
+      expect(result).toBe(JSON.stringify(testData));
+    });
+
+    test('should return undefined for non-existent page', () => {
+      const result = pageService.getPage('/non-existent');
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getPageData', () => {
+    test('should return parsed page data', () => {
+      const testData = createMockPageData();
+      pageCache.set('/', JSON.stringify(testData), new Map());
+
+      const result = pageService.getPageData('/');
+
+      expect(result).toBeDefined();
+      expect(result?.meta?.title).toBe(testData.meta?.title);
+      expect(result?.root).toBeDefined();
+    });
+
+    test('should return null for non-existent page', () => {
+      const result = pageService.getPageData('/non-existent');
+
+      expect(result).toBeNull();
+    });
+
+    test('should return null for invalid JSON', () => {
+      pageCache.set('/invalid', 'invalid json', new Map());
+
+      const result = pageService.getPageData('/invalid');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('savePage', () => {
+    test('should save page via provider', async () => {
+      const testData = createMockPageData({ meta: { title: 'Test Page' } });
+
+      await pageService.savePage('/', testData);
+
+      expect(mockProvider.save).toHaveBeenCalledWith('/', expect.any(String));
+      expect(pageService.getPage('/')).toBeDefined();
+    });
+
+    test('should update cache after saving', async () => {
+      const testData = createMockPageData({ meta: { title: 'Updated Page' } });
+
+      await pageService.savePage('/', testData);
+
+      const cached = pageService.getPageData('/');
+      expect(cached?.meta?.title).toBe('Updated Page');
+    });
+
+    test('should throw error when provider not set', async () => {
+      const serviceWithoutProvider = new PageService(pageCache);
+      const testData = createMockPageData();
+
+      await expect(serviceWithoutProvider.savePage('/', testData)).rejects.toThrow(
+        'PageProvider not set'
+      );
+    });
+
+    test('should strip _lineMap from saved data', async () => {
+      const testData = createMockPageData({ meta: { title: 'Test' } });
+      (testData as any)._lineMap = new Map();
+
+      await pageService.savePage('/', testData);
+
+      const savedContent = (mockProvider.save as any).mock.calls[0][1];
+      const savedData = JSON.parse(savedContent);
+      expect(savedData._lineMap).toBeUndefined();
+    });
+  });
+
+  describe('deletePage', () => {
+    test('should delete page from cache', async () => {
+      const testData = createMockPageData();
+      pageCache.set('/', JSON.stringify(testData), new Map());
+
+      await pageService.deletePage('/');
+
+      expect(pageService.getPage('/')).toBeUndefined();
+    });
+
+    test('should delete from storage when deleteFromStorage is true', async () => {
+      const testData = createMockPageData();
+      pageCache.set('/', JSON.stringify(testData), new Map());
+
+      await pageService.deletePage('/', true);
+
+      expect(mockProvider.delete).toHaveBeenCalledWith('/');
+    });
+
+    test('should not delete from storage when deleteFromStorage is false', async () => {
+      const testData = createMockPageData();
+      pageCache.set('/', JSON.stringify(testData), new Map());
+
+      await pageService.deletePage('/');
+
+      expect(mockProvider.delete).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('getAllPagePaths', () => {
+    test('should return all page paths from cache', () => {
+      pageCache.set('/', JSON.stringify(createMockPageData()), new Map());
+      pageCache.set('/about', JSON.stringify(createMockPageData()), new Map());
+
+      const paths = pageService.getAllPagePaths();
+
+      expect(paths).toContain('/');
+      expect(paths).toContain('/about');
+      expect(paths.length).toBe(2);
+    });
+
+    test('should return empty array when cache is empty', () => {
+      const paths = pageService.getAllPagePaths();
+
+      expect(paths).toEqual([]);
+    });
+  });
+
+  describe('getLineMap', () => {
+    test('should return line map from cache', () => {
+      const lineMap = new Map([['root', { startLine: 1, endLine: 10 }]]);
+      pageCache.set('/', JSON.stringify(createMockPageData()), lineMap);
+
+      const result = pageService.getLineMap('/');
+
+      expect(result).toBeDefined();
+      expect(result?.get('root')).toEqual({ startLine: 1, endLine: 10 });
+    });
+
+    test('should return undefined for non-existent page', () => {
+      const result = pageService.getLineMap('/non-existent');
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('setProvider', () => {
+    test('should allow setting provider after construction', async () => {
+      const serviceWithoutProvider = new PageService(pageCache);
+      const newProvider = createTypedMockPageProvider({
+        '/': JSON.stringify(createMockPageData()),
+      });
+
+      serviceWithoutProvider.setProvider(newProvider);
+      await serviceWithoutProvider.loadAllPages();
+
+      expect(serviceWithoutProvider.getPage('/')).toBeDefined();
+    });
+  });
+
+  describe('getSlugMappings', () => {
+    test('should return slug mappings from pages with slugs', () => {
+      const pageWithSlugs = createMockPageData({
+        meta: { title: 'About', slugs: { en: 'about', pl: 'o-nas' } },
+      });
+      pageCache.set('/about', JSON.stringify(pageWithSlugs), new Map());
+
+      const mappings = pageService.getSlugMappings();
+
+      expect(mappings).toHaveLength(1);
+      expect(mappings[0].pageId).toBe('about');
+      expect(mappings[0].slugs).toEqual({ en: 'about', pl: 'o-nas' });
+    });
+
+    test('should create default slug for pages without explicit slugs', () => {
+      const pageWithoutSlugs = createMockPageData({ meta: { title: 'About' } });
+      pageCache.set('/about', JSON.stringify(pageWithoutSlugs), new Map());
+
+      const mappings = pageService.getSlugMappings();
+
+      expect(mappings).toHaveLength(1);
+      expect(mappings[0].pageId).toBe('about');
+      expect(mappings[0].slugs).toEqual({ _default: 'about' });
+    });
+
+    test('should handle index page correctly', () => {
+      const indexPage = createMockPageData({ meta: { title: 'Home' } });
+      pageCache.set('/', JSON.stringify(indexPage), new Map());
+
+      const mappings = pageService.getSlugMappings();
+
+      expect(mappings).toHaveLength(1);
+      expect(mappings[0].pageId).toBe('index');
+      expect(mappings[0].slugs).toEqual({ _default: '' });
+    });
+  });
+});