meno-core 1.0.0

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

@@ -0,0 +1,388 @@
+/**
+ * CMS Service Tests
+ * Tests for CMS service functionality including schema loading, route matching, and querying
+ */
+
+import { describe, it, expect, beforeEach } from 'bun:test';
+import { CMSService } from './cmsService';
+import type { CMSProvider, CMSSchemaInfo } from '../../shared/interfaces/contentProvider';
+import type { CMSItem } from '../../shared/types';
+
+// Mock schema info (schema extracted from page file)
+const mockSchemaInfo: CMSSchemaInfo = {
+  schema: {
+    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' },
+    },
+  },
+  pagePath: '/pages/blog-post.json',
+};
+
+const mockProductSchemaInfo: CMSSchemaInfo = {
+  schema: {
+    id: 'products',
+    name: 'Products',
+    slugField: 'slug',
+    urlPattern: '/shop/{{slug}}',
+    fields: {
+      name: { type: 'string', required: true },
+      slug: { type: 'string', required: true },
+      price: { type: 'number' },
+      featured: { type: 'boolean' },
+      category: { type: 'select', options: ['Electronics', 'Clothing', 'Books'] },
+    },
+  },
+  pagePath: '/pages/product.json',
+};
+
+const mockBlogItems: CMSItem[] = [
+  { _id: '1', slug: 'hello-world', title: 'Hello World', content: 'First post' },
+  { _id: '2', slug: 'getting-started', title: 'Getting Started', content: 'Guide' },
+  { _id: '3', slug: 'advanced-tips', title: 'Advanced Tips', content: 'Pro tips' },
+];
+
+const mockProductItems: CMSItem[] = [
+  { _id: '1', slug: 'laptop', name: 'Laptop Pro', price: 999, featured: true, category: 'Electronics' },
+  { _id: '2', slug: 'tshirt', name: 'Cool T-Shirt', price: 29, featured: false, category: 'Clothing' },
+  { _id: '3', slug: 'headphones', name: 'Wireless Headphones', price: 199, featured: true, category: 'Electronics' },
+];
+
+describe('CMSService', () => {
+  let service: CMSService;
+  let mockProvider: CMSProvider;
+
+  beforeEach(async () => {
+    mockProvider = {
+      getAllSchemas: async () => new Map([
+        ['blog-posts', mockSchemaInfo],
+        ['products', mockProductSchemaInfo],
+      ]),
+      getItems: async (collection: string) => {
+        if (collection === 'blog-posts') return mockBlogItems;
+        if (collection === 'products') return mockProductItems;
+        return [];
+      },
+      getItemBySlug: async (collection: string, slug: string) => {
+        if (collection === 'blog-posts') {
+          return mockBlogItems.find(i => i.slug === slug) || null;
+        }
+        if (collection === 'products') {
+          return mockProductItems.find(i => i.slug === slug) || null;
+        }
+        return null;
+      },
+      getItemById: async (collection: string, id: string) => {
+        if (collection === 'blog-posts') {
+          return mockBlogItems.find(i => i._id === id) || null;
+        }
+        if (collection === 'products') {
+          return mockProductItems.find(i => i._id === id) || null;
+        }
+        return null;
+      },
+      saveItem: async () => {},
+      deleteItem: async () => {},
+    };
+    service = new CMSService(mockProvider);
+    await service.initialize();
+  });
+
+  describe('initialize', () => {
+    it('should extract schemas from pages', async () => {
+      const schemas = service.getAllSchemas();
+      expect(schemas.size).toBe(2);
+      expect(schemas.get('blog-posts')?.schema.id).toBe('blog-posts');
+      expect(schemas.get('blog-posts')?.pagePath).toBe('/pages/blog-post.json');
+      expect(schemas.get('products')?.schema.id).toBe('products');
+    });
+
+    it('should build route patterns from schemas', async () => {
+      const match = await service.matchRoute('/blog/hello-world');
+      expect(match).not.toBeNull();
+      expect(match?.collection).toBe('blog-posts');
+    });
+
+    it('should not throw when provider is not set', async () => {
+      const emptyService = new CMSService();
+      await emptyService.initialize();
+      expect(emptyService.getAllSchemas().size).toBe(0);
+    });
+  });
+
+  describe('setProvider', () => {
+    it('should allow setting provider after construction', async () => {
+      const newService = new CMSService();
+      expect(newService.getAllSchemas().size).toBe(0);
+
+      newService.setProvider(mockProvider);
+      await newService.initialize();
+
+      expect(newService.getAllSchemas().size).toBe(2);
+    });
+  });
+
+  describe('matchRoute', () => {
+    it('should match CMS URL and return item with pagePath', async () => {
+      const match = await service.matchRoute('/blog/hello-world');
+      expect(match).toEqual({
+        collection: 'blog-posts',
+        slug: 'hello-world',
+        item: mockBlogItems[0],
+        pagePath: '/pages/blog-post.json',
+      });
+    });
+
+    it('should match product URLs', async () => {
+      const match = await service.matchRoute('/shop/laptop');
+      expect(match).toEqual({
+        collection: 'products',
+        slug: 'laptop',
+        item: mockProductItems[0],
+        pagePath: '/pages/product.json',
+      });
+    });
+
+    it('should return null for non-matching URL', async () => {
+      const match = await service.matchRoute('/about');
+      expect(match).toBeNull();
+    });
+
+    it('should return null for non-existent slug', async () => {
+      const match = await service.matchRoute('/blog/non-existent');
+      expect(match).toBeNull();
+    });
+
+    it('should not match partial URLs', async () => {
+      const match = await service.matchRoute('/blog');
+      expect(match).toBeNull();
+    });
+
+    it('should not match URLs with extra path segments', async () => {
+      const match = await service.matchRoute('/blog/hello-world/extra');
+      expect(match).toBeNull();
+    });
+  });
+
+  describe('getCollectionURLs', () => {
+    it('should return all URLs for blog-posts collection', async () => {
+      const urls = await service.getCollectionURLs('blog-posts');
+      expect(urls).toEqual([
+        '/blog/hello-world',
+        '/blog/getting-started',
+        '/blog/advanced-tips',
+      ]);
+    });
+
+    it('should return all URLs for products collection', async () => {
+      const urls = await service.getCollectionURLs('products');
+      expect(urls).toEqual([
+        '/shop/laptop',
+        '/shop/tshirt',
+        '/shop/headphones',
+      ]);
+    });
+
+    it('should return empty array for unknown collection', async () => {
+      const urls = await service.getCollectionURLs('unknown');
+      expect(urls).toEqual([]);
+    });
+  });
+
+  describe('getSchema', () => {
+    it('should return schema for existing collection', () => {
+      const schema = service.getSchema('blog-posts');
+      expect(schema?.id).toBe('blog-posts');
+      expect(schema?.name).toBe('Blog Posts');
+      expect(schema?.slugField).toBe('slug');
+    });
+
+    it('should return undefined for unknown collection', () => {
+      const schema = service.getSchema('unknown');
+      expect(schema).toBeUndefined();
+    });
+  });
+
+  describe('queryItems', () => {
+    it('should return all items without filter', async () => {
+      const items = await service.queryItems({ collection: 'blog-posts' });
+      expect(items).toHaveLength(3);
+    });
+
+    it('should apply simple object filter', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        filter: { featured: true },
+      });
+      expect(items).toHaveLength(2);
+      expect(items.every(i => i.featured === true)).toBe(true);
+    });
+
+    it('should apply filter with eq operator', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        filter: { field: 'category', operator: 'eq', value: 'Electronics' },
+      });
+      expect(items).toHaveLength(2);
+      expect(items.every(i => i.category === 'Electronics')).toBe(true);
+    });
+
+    it('should apply filter with neq operator', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        filter: { field: 'category', operator: 'neq', value: 'Electronics' },
+      });
+      expect(items).toHaveLength(1);
+      expect(items[0].category).toBe('Clothing');
+    });
+
+    it('should apply filter with gt operator', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        filter: { field: 'price', operator: 'gt', value: 100 },
+      });
+      expect(items).toHaveLength(2);
+      expect(items.every(i => (i.price as number) > 100)).toBe(true);
+    });
+
+    it('should apply filter with gte operator', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        filter: { field: 'price', operator: 'gte', value: 199 },
+      });
+      expect(items).toHaveLength(2);
+    });
+
+    it('should apply filter with lt operator', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        filter: { field: 'price', operator: 'lt', value: 100 },
+      });
+      expect(items).toHaveLength(1);
+      expect(items[0].name).toBe('Cool T-Shirt');
+    });
+
+    it('should apply filter with lte operator', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        filter: { field: 'price', operator: 'lte', value: 29 },
+      });
+      expect(items).toHaveLength(1);
+    });
+
+    it('should apply filter with contains operator', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        filter: { field: 'name', operator: 'contains', value: 'Wireless' },
+      });
+      expect(items).toHaveLength(1);
+      expect(items[0].slug).toBe('headphones');
+    });
+
+    it('should apply filter with in operator', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        filter: { field: 'category', operator: 'in', value: ['Electronics', 'Clothing'] },
+      });
+      expect(items).toHaveLength(3);
+    });
+
+    it('should apply multiple filter conditions (AND)', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        filter: [
+          { field: 'featured', value: true },
+          { field: 'category', value: 'Electronics' },
+        ],
+      });
+      expect(items).toHaveLength(2);
+    });
+
+    it('should apply ascending sort', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        sort: { field: 'price', order: 'asc' },
+      });
+      expect(items[0].price).toBe(29);
+      expect(items[1].price).toBe(199);
+      expect(items[2].price).toBe(999);
+    });
+
+    it('should apply descending sort', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        sort: { field: 'price', order: 'desc' },
+      });
+      expect(items[0].price).toBe(999);
+      expect(items[1].price).toBe(199);
+      expect(items[2].price).toBe(29);
+    });
+
+    it('should apply multi-field sort', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        sort: [
+          { field: 'featured', order: 'desc' },
+          { field: 'price', order: 'asc' },
+        ],
+      });
+      // Featured items first (true > false), then by price ascending
+      expect(items[0].slug).toBe('headphones'); // featured=true, price=199
+      expect(items[1].slug).toBe('laptop');     // featured=true, price=999
+      expect(items[2].slug).toBe('tshirt');     // featured=false, price=29
+    });
+
+    it('should apply limit', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        limit: 2,
+      });
+      expect(items).toHaveLength(2);
+    });
+
+    it('should apply offset', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        offset: 1,
+      });
+      expect(items).toHaveLength(2);
+      expect(items[0].slug).toBe('tshirt');
+    });
+
+    it('should apply limit and offset together', async () => {
+      const items = await service.queryItems({
+        collection: 'products',
+        sort: { field: 'price', order: 'asc' },
+        offset: 1,
+        limit: 1,
+      });
+      expect(items).toHaveLength(1);
+      expect(items[0].price).toBe(199);
+    });
+
+    it('should return empty array for empty collection', async () => {
+      const items = await service.queryItems({ collection: 'unknown' });
+      expect(items).toEqual([]);
+    });
+  });
+
+  describe('patternToRegex', () => {
+    it('should handle simple slug patterns', async () => {
+      // Test via matchRoute since patternToRegex is private
+      const match = await service.matchRoute('/blog/my-test-post');
+      // Will be null because item doesn't exist, but we're testing the pattern
+      expect(match).toBeNull();
+    });
+
+    it('should handle special regex characters in pattern', async () => {
+      // The pattern itself shouldn't have special chars, but slugs can
+      const match = await service.matchRoute('/blog/hello-world');
+      expect(match).not.toBeNull();
+    });
+  });
+});

package/lib/server/services/cmsService.ts

@@ -0,0 +1,296 @@
+/**
+ * CMS Service
+ * Handles CMS schema extraction, route matching, and content querying
+ */
+
+import type { CMSProvider, CMSSchemaInfo } from '../../shared/interfaces/contentProvider';
+import type {
+  CMSSchema,
+  CMSItem,
+  CMSRouteMatch,
+  CMSListQuery,
+  CMSFilterCondition,
+  CMSSortConfig,
+} from '../../shared/types';
+
+interface RoutePattern {
+  regex: RegExp;
+  collection: string;
+  slugGroup: number;
+  pagePath: string;
+}
+
+/**
+ * CMS Service
+ * Manages CMS schemas, route matching, and content querying
+ */
+export class CMSService {
+  private schemaCache = new Map<string, CMSSchemaInfo>();
+  private routePatterns: RoutePattern[] = [];
+  private provider?: CMSProvider;
+
+  /**
+   * Creates a new CMSService instance
+   * @param provider - Optional CMSProvider for loading data (enables DI for testing)
+   */
+  constructor(provider?: CMSProvider) {
+    this.provider = provider;
+  }
+
+  /**
+   * Set the CMS provider
+   * Allows setting provider after construction for backward compatibility
+   * @param provider - CMSProvider implementation
+   */
+  setProvider(provider: CMSProvider): void {
+    this.provider = provider;
+  }
+
+  /**
+   * Initialize service - extract schemas from pages and build route patterns
+   */
+  async initialize(): Promise<void> {
+    if (!this.provider) {
+      return;
+    }
+
+    const schemas = await this.provider.getAllSchemas();
+
+    for (const [id, schemaInfo] of schemas) {
+      this.schemaCache.set(id, schemaInfo);
+      this.routePatterns.push({
+        regex: this.patternToRegex(schemaInfo.schema.urlPattern),
+        collection: id,
+        slugGroup: 1,
+        pagePath: schemaInfo.pagePath,
+      });
+    }
+  }
+
+  /**
+   * Convert URL pattern to regex
+   * e.g., "/blog/{{slug}}" -> /^\/blog\/([^\/]+)$/
+   */
+  private patternToRegex(pattern: string): RegExp {
+    // Escape special regex characters except our placeholder
+    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Replace the escaped placeholder with a capture group
+    const withCapture = escaped.replace(/\\\{\\\{slug\\\}\\\}/g, '([^/]+)');
+    return new RegExp(`^${withCapture}$`);
+  }
+
+  /**
+   * Match URL against CMS route patterns
+   * @param path - URL path to match
+   * @returns CMSRouteMatch if matched, null otherwise
+   */
+  async matchRoute(path: string): Promise<CMSRouteMatch | null> {
+    if (!this.provider) {
+      return null;
+    }
+
+    for (const route of this.routePatterns) {
+      const match = path.match(route.regex);
+      if (match) {
+        const slug = match[route.slugGroup];
+        const item = await this.provider.getItemBySlug(route.collection, slug);
+
+        if (item) {
+          return {
+            collection: route.collection,
+            slug,
+            item,
+            pagePath: route.pagePath,
+          };
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get all URLs for a collection (for static generation)
+   * @param collection - Collection ID
+   * @returns Array of URLs
+   */
+  async getCollectionURLs(collection: string): Promise<string[]> {
+    if (!this.provider) {
+      return [];
+    }
+
+    const schemaInfo = this.schemaCache.get(collection);
+    if (!schemaInfo) return [];
+
+    const items = await this.provider.getItems(collection);
+    return items.map(item =>
+      schemaInfo.schema.urlPattern.replace('{{slug}}', String(item[schemaInfo.schema.slugField]))
+    );
+  }
+
+  /**
+   * Get schema for collection
+   * @param collection - Collection ID
+   * @returns CMSSchema or undefined
+   */
+  getSchema(collection: string): CMSSchema | undefined {
+    return this.schemaCache.get(collection)?.schema;
+  }
+
+  /**
+   * Get all schemas
+   * @returns Map of collection ID to CMSSchemaInfo
+   */
+  getAllSchemas(): Map<string, CMSSchemaInfo> {
+    return this.schemaCache;
+  }
+
+  /**
+   * Refresh schemas from provider
+   * Call this after adding/removing collections to update the cache
+   */
+  async refreshSchemas(): Promise<void> {
+    if (!this.provider) {
+      return;
+    }
+
+    // Clear existing caches
+    this.schemaCache.clear();
+    this.routePatterns = [];
+
+    // Clear provider cache if available
+    if ('clearSchemaCache' in this.provider && typeof this.provider.clearSchemaCache === 'function') {
+      this.provider.clearSchemaCache();
+    }
+
+    // Re-initialize
+    await this.initialize();
+  }
+
+  /**
+   * Query items with filter/sort/limit
+   * @param query - CMSListQuery with collection, filter, sort, limit, offset
+   * @returns Filtered and sorted array of CMSItems
+   */
+  async queryItems(query: CMSListQuery): Promise<CMSItem[]> {
+    if (!this.provider) {
+      return [];
+    }
+
+    let items = await this.provider.getItems(query.collection);
+
+    // Apply filters
+    if (query.filter) {
+      items = this.applyFilters(items, query.filter);
+    }
+
+    // Apply sorting
+    if (query.sort) {
+      items = this.applySorting(items, query.sort);
+    }
+
+    // Apply offset
+    if (query.offset !== undefined && query.offset > 0) {
+      items = items.slice(query.offset);
+    }
+
+    // Apply limit
+    if (query.limit !== undefined && query.limit > 0) {
+      items = items.slice(0, query.limit);
+    }
+
+    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;
+    }
+  }
+
+  /**
+   * 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;
+    });
+  }
+}