meno-core 1.0.0

package/lib/server/providers/fileSystemCMSProvider.ts

@@ -0,0 +1,227 @@
+/**
+ * File System CMS Provider
+ * Implements CMSProvider for loading CMS data from the file system
+ */
+
+import { existsSync, readdirSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import type { CMSProvider, CMSSchemaInfo } from '../../shared/interfaces/contentProvider';
+import type { CMSSchema, CMSItem } from '../../shared/types';
+import { validateCMSItem } from '../../shared/validation/validators';
+
+/**
+ * Load JSON file content from disk
+ */
+async function loadJSONFile(filePath: string): Promise<unknown | null> {
+  try {
+    const file = Bun.file(filePath);
+    if (await file.exists()) {
+      return await file.json();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * FileSystemCMSProvider
+ * Loads CMS schemas from page files and CMS items from cms/<collection>/<slug>.json
+ */
+export class FileSystemCMSProvider implements CMSProvider {
+  private schemaCache: Map<string, CMSSchemaInfo> | null = null;
+
+  constructor(
+    private pagesDir: string,    // e.g., './pages' - schemas extracted from here
+    private cmsDir: string       // e.g., './cms' - items stored here
+  ) {}
+
+  /**
+   * Load all CMS schemas from page files with source: 'cms'
+   */
+  async getAllSchemas(): Promise<Map<string, CMSSchemaInfo>> {
+    // Return cached if available
+    if (this.schemaCache) {
+      return this.schemaCache;
+    }
+
+    const schemas = new Map<string, CMSSchemaInfo>();
+
+    if (!existsSync(this.pagesDir)) {
+      return schemas;
+    }
+
+    const files = readdirSync(this.pagesDir);
+    for (const file of files) {
+      if (!file.endsWith('.json')) continue;
+
+      const filePath = join(this.pagesDir, file);
+      const content = await loadJSONFile(filePath);
+
+      if (
+        content &&
+        typeof content === 'object' &&
+        'meta' in content &&
+        typeof (content as Record<string, unknown>).meta === 'object'
+      ) {
+        const meta = (content as Record<string, unknown>).meta as Record<string, unknown>;
+
+        if (meta.source === 'cms' && meta.cms) {
+          const schema = meta.cms as CMSSchema;
+          schemas.set(schema.id, {
+            schema,
+            pagePath: filePath,
+          });
+        }
+      }
+    }
+
+    this.schemaCache = schemas;
+    return schemas;
+  }
+
+  /**
+   * Load all items for a collection
+   */
+  async getItems(collection: string): Promise<CMSItem[]> {
+    const collectionDir = join(this.cmsDir, collection);
+
+    if (!existsSync(collectionDir)) {
+      return [];
+    }
+
+    const items: CMSItem[] = [];
+    const files = readdirSync(collectionDir);
+
+    for (const file of files) {
+      if (!file.endsWith('.json')) continue;
+
+      const filePath = join(collectionDir, file);
+      const content = await loadJSONFile(filePath);
+
+      if (content && typeof content === 'object') {
+        const slug = file.replace('.json', '');
+        const item = { ...content as CMSItem, _slug: slug };
+
+        const validation = validateCMSItem(item);
+        if (validation.valid) {
+          items.push(validation.data);
+        } else {
+          console.warn(`Invalid CMS item at ${filePath}:`, validation.errors);
+        }
+      }
+    }
+
+    return items;
+  }
+
+  /**
+   * Get single item by slug
+   */
+  async getItemBySlug(collection: string, slug: string): Promise<CMSItem | null> {
+    const filePath = join(this.cmsDir, collection, `${slug}.json`);
+    const content = await loadJSONFile(filePath);
+
+    if (!content || typeof content !== 'object') {
+      return null;
+    }
+
+    const item = { ...content as CMSItem, _slug: slug };
+    const validation = validateCMSItem(item);
+
+    if (validation.valid) {
+      return validation.data;
+    }
+
+    console.warn(`Invalid CMS item at ${filePath}:`, validation.errors);
+    return null;
+  }
+
+  /**
+   * Get single item by ID
+   */
+  async getItemById(collection: string, id: string): Promise<CMSItem | null> {
+    const items = await this.getItems(collection);
+    return items.find(item => item._id === id) || null;
+  }
+
+  /**
+   * Save item to file system
+   */
+  async saveItem(collection: string, item: CMSItem): Promise<void> {
+    const { writeFile } = await import('fs/promises');
+
+    // Get schema to determine slug field
+    const schemas = await this.getAllSchemas();
+    const schemaInfo = schemas.get(collection);
+
+    if (!schemaInfo) {
+      throw new Error(`Unknown collection: ${collection}`);
+    }
+
+    const slugField = schemaInfo.schema.slugField;
+    const slug = String(item[slugField]);
+
+    if (!slug) {
+      throw new Error(`Missing slug field: ${slugField}`);
+    }
+
+    // Ensure collection directory exists
+    const collectionDir = join(this.cmsDir, collection);
+    if (!existsSync(collectionDir)) {
+      mkdirSync(collectionDir, { recursive: true });
+    }
+
+    // Remove internal fields before saving
+    const { _slug, ...itemData } = item;
+
+    const filePath = join(collectionDir, `${slug}.json`);
+    await writeFile(filePath, JSON.stringify(itemData, null, 2), 'utf-8');
+  }
+
+  /**
+   * Delete item by slug
+   */
+  async deleteItem(collection: string, slug: string): Promise<void> {
+    const { unlink } = await import('fs/promises');
+    const filePath = join(this.cmsDir, collection, `${slug}.json`);
+
+    if (existsSync(filePath)) {
+      await unlink(filePath);
+    }
+  }
+
+  /**
+   * Clear schema cache (useful when pages are modified)
+   */
+  clearSchemaCache(): void {
+    this.schemaCache = null;
+  }
+
+  /**
+   * Save a new collection schema by creating a page file
+   */
+  async saveSchema(collectionId: string, pageData: unknown): Promise<void> {
+    const { writeFile, mkdir } = await import('fs/promises');
+
+    // Create page file path (use collection ID as filename)
+    const pageFilePath = join(this.pagesDir, `${collectionId}.json`);
+
+    // Check if file already exists
+    if (existsSync(pageFilePath)) {
+      throw new Error(`Page file already exists: ${collectionId}.json`);
+    }
+
+    // Write the page file
+    await writeFile(pageFilePath, JSON.stringify(pageData, null, 2), 'utf-8');
+
+    // Create the CMS collection directory
+    const collectionDir = join(this.cmsDir, collectionId);
+    if (!existsSync(collectionDir)) {
+      await mkdir(collectionDir, { recursive: true });
+    }
+
+    // Clear the schema cache so the new collection is detected
+    this.clearSchemaCache();
+  }
+}

package/lib/server/providers/fileSystemPageProvider.ts

@@ -0,0 +1,83 @@
+/**
+ * File System Page Provider
+ * Implements PageProvider for loading pages from the file system
+ */
+
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import type { PageProvider } from '../../shared/interfaces/contentProvider';
+import { isJSONFile, stripExtension, mapPageNameToPath, mapPathToPageName } from '../../shared/utils/fileUtils';
+
+/**
+ * Load JSON file content from disk
+ */
+async function loadJSONFile(filePath: string): Promise<string | null> {
+  try {
+    const file = Bun.file(filePath);
+    if (await file.exists()) {
+      return await file.text();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * FileSystemPageProvider
+ * Loads and saves page JSON files from/to the file system
+ */
+export class FileSystemPageProvider implements PageProvider {
+  constructor(private pagesDir: string) {}
+
+  async loadAll(): Promise<Map<string, string>> {
+    const pages = new Map<string, string>();
+
+    if (!existsSync(this.pagesDir)) {
+      return pages;
+    }
+
+    const files = readdirSync(this.pagesDir);
+    for (const file of files) {
+      if (isJSONFile(file)) {
+        const pageName = stripExtension(file);
+        const content = await loadJSONFile(join(this.pagesDir, file));
+        if (content) {
+          const pagePath = mapPageNameToPath(pageName);
+          pages.set(pagePath, content);
+        }
+      }
+    }
+
+    return pages;
+  }
+
+  async get(path: string): Promise<string | null> {
+    const pageName = mapPathToPageName(path);
+    const filePath = join(this.pagesDir, `${pageName}.json`);
+    return loadJSONFile(filePath);
+  }
+
+  async save(path: string, content: string): Promise<void> {
+    const { writeFile } = await import('fs/promises');
+    const pageName = mapPathToPageName(path);
+    const filePath = join(this.pagesDir, `${pageName}.json`);
+    await writeFile(filePath, content, 'utf-8');
+  }
+
+  async delete(path: string): Promise<void> {
+    const { unlink } = await import('fs/promises');
+    const pageName = mapPathToPageName(path);
+    const filePath = join(this.pagesDir, `${pageName}.json`);
+
+    if (existsSync(filePath)) {
+      await unlink(filePath);
+    }
+  }
+
+  async exists(path: string): Promise<boolean> {
+    const pageName = mapPathToPageName(path);
+    const filePath = join(this.pagesDir, `${pageName}.json`);
+    return existsSync(filePath);
+  }
+}

package/lib/server/routes/api/cms.test.ts

@@ -0,0 +1,177 @@
+/**
+ * CMS API Routes Tests
+ * Tests for CMS CRUD endpoints
+ */
+
+import { describe, it, expect, beforeEach } from 'bun:test';
+import type { CMSProvider, CMSSchemaInfo } from '../../../shared/interfaces/contentProvider';
+import type { CMSItem, CMSSchema } from '../../../shared/types';
+import { CMSService } from '../../services/cmsService';
+import {
+  handleCollectionsRoute,
+  handleCollectionSchemaRoute,
+  handleItemsRoute,
+  handleItemRoute,
+} from './cms';
+
+// Note: Write handler tests (handleCreateItemRoute, handleUpdateItemRoute, handleDeleteItemRoute)
+// moved to @meno/studio
+
+// Mock schema info
+const mockBlogSchema: CMSSchema = {
+  id: 'blog-posts',
+  name: 'Blog Posts',
+  slugField: 'slug',
+  urlPattern: '/blog/{{slug}}',
+  fields: {
+    title: { type: 'string', required: true, label: 'Title' },
+    slug: { type: 'string', required: true, label: 'Slug' },
+    content: { type: 'text', label: 'Content' },
+    featured: { type: 'boolean', label: 'Featured' },
+  },
+};
+
+const mockProductSchema: CMSSchema = {
+  id: 'products',
+  name: 'Products',
+  slugField: 'slug',
+  urlPattern: '/shop/{{slug}}',
+  fields: {
+    name: { type: 'string', required: true },
+    slug: { type: 'string', required: true },
+    price: { type: 'number' },
+  },
+};
+
+const mockSchemaInfo: CMSSchemaInfo = {
+  schema: mockBlogSchema,
+  pagePath: '/pages/blog-post.json',
+};
+
+const mockProductSchemaInfo: CMSSchemaInfo = {
+  schema: mockProductSchema,
+  pagePath: '/pages/product.json',
+};
+
+const mockBlogItems: CMSItem[] = [
+  { _id: '1', _slug: 'hello-world', slug: 'hello-world', title: 'Hello World', content: 'First post', featured: true },
+  { _id: '2', _slug: 'getting-started', slug: 'getting-started', title: 'Getting Started', content: 'Guide', featured: false },
+];
+
+describe('CMS API Routes - Read Operations', () => {
+  let cmsService: 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];
+        return [];
+      },
+      getItemBySlug: async (collection: string, slug: string) => {
+        if (collection === 'blog-posts') {
+          return mockBlogItems.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;
+        }
+        return null;
+      },
+      saveItem: async () => {},
+      deleteItem: async () => {},
+    };
+
+    cmsService = new CMSService(mockProvider);
+    await cmsService.initialize();
+  });
+
+  describe('GET /api/cms/collections', () => {
+    it('should return all collections with schemas', async () => {
+      const response = handleCollectionsRoute(cmsService);
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.collections).toHaveLength(2);
+      expect(data.collections[0].id).toBe('blog-posts');
+      expect(data.collections[0].name).toBe('Blog Posts');
+      expect(data.collections[1].id).toBe('products');
+    });
+
+    it('should include field definitions in schema', async () => {
+      const response = handleCollectionsRoute(cmsService);
+      const data = await response.json();
+
+      const blogCollection = data.collections.find((c: any) => c.id === 'blog-posts');
+      expect(blogCollection.fields).toBeDefined();
+      expect(blogCollection.fields.title.type).toBe('string');
+      expect(blogCollection.fields.title.required).toBe(true);
+    });
+  });
+
+  describe('GET /api/cms/collections/:collection', () => {
+    it('should return schema for specific collection', async () => {
+      const response = handleCollectionSchemaRoute('blog-posts', cmsService);
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.schema.id).toBe('blog-posts');
+      expect(data.schema.name).toBe('Blog Posts');
+      expect(data.schema.slugField).toBe('slug');
+    });
+
+    it('should return 404 for unknown collection', async () => {
+      const response = handleCollectionSchemaRoute('unknown', cmsService);
+      const data = await response.json();
+
+      expect(response.status).toBe(404);
+      expect(data.error).toBe('Collection not found');
+    });
+  });
+
+  describe('GET /api/cms/:collection', () => {
+    it('should return all items in collection', async () => {
+      const response = await handleItemsRoute('blog-posts', cmsService);
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.items).toHaveLength(2);
+      expect(data.items[0].title).toBe('Hello World');
+    });
+
+    it('should return empty array for empty collection', async () => {
+      const response = await handleItemsRoute('products', cmsService);
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.items).toEqual([]);
+    });
+  });
+
+  describe('GET /api/cms/:collection/:slug', () => {
+    it('should return specific item by slug', async () => {
+      const response = await handleItemRoute('blog-posts', 'hello-world', cmsService);
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.item.title).toBe('Hello World');
+      expect(data.item._slug).toBe('hello-world');
+    });
+
+    it('should return 404 for non-existent item', async () => {
+      const response = await handleItemRoute('blog-posts', 'non-existent', cmsService);
+      const data = await response.json();
+
+      expect(response.status).toBe(404);
+      expect(data.error).toBe('Item not found');
+    });
+  });
+
+  // Note: POST/PUT/DELETE tests moved to @meno/studio/lib/server/routes/api/cms.test.ts
+});

package/lib/server/routes/api/cms.ts

@@ -0,0 +1,82 @@
+/**
+ * CMS API Routes
+ * Handles CMS content CRUD endpoints
+ */
+
+import type { CMSService } from '../../services/cmsService';
+import type { CMSSchema } from '../../../shared/types';
+import { jsonResponse, errorResponse } from './shared';
+
+/**
+ * GET /api/cms/collections - List all collections with their schemas
+ */
+export function handleCollectionsRoute(cmsService: CMSService): Response {
+  const schemas = cmsService.getAllSchemas();
+  const collections: CMSSchema[] = [];
+
+  for (const [, schemaInfo] of schemas) {
+    collections.push(schemaInfo.schema);
+  }
+
+  return jsonResponse({ collections });
+}
+
+/**
+ * GET /api/cms/collections/:collection - Get schema for specific collection
+ */
+export function handleCollectionSchemaRoute(
+  collection: string,
+  cmsService: CMSService
+): Response {
+  const schema = cmsService.getSchema(collection);
+
+  if (!schema) {
+    return errorResponse('Collection not found', 404);
+  }
+
+  return jsonResponse({ schema });
+}
+
+// Note: handleCreateCollectionRoute moved to @meno/studio
+
+/**
+ * GET /api/cms/:collection - List all items in a collection
+ */
+export async function handleItemsRoute(
+  collection: string,
+  cmsService: CMSService
+): Promise<Response> {
+  const items = await cmsService.queryItems({ collection });
+  return jsonResponse({ items });
+}
+
+/**
+ * GET /api/cms/:collection/:slug - Get specific item by slug
+ */
+export async function handleItemRoute(
+  collection: string,
+  slug: string,
+  cmsService: CMSService
+): Promise<Response> {
+  const match = await cmsService.matchRoute(
+    cmsService.getSchema(collection)?.urlPattern.replace('{{slug}}', slug) || ''
+  );
+
+  // If no match via route, try direct provider access
+  if (!match) {
+    // For direct item access, we need to check if item exists
+    const items = await cmsService.queryItems({ collection });
+    const item = items.find(i => i._slug === slug || i[cmsService.getSchema(collection)?.slugField || 'slug'] === slug);
+
+    if (!item) {
+      return errorResponse('Item not found', 404);
+    }
+
+    return jsonResponse({ item });
+  }
+
+  return jsonResponse({ item: match.item });
+}
+
+// Note: Write handlers (handleCreateItemRoute, handleUpdateItemRoute, handleDeleteItemRoute)
+// moved to @meno/studio

package/lib/server/routes/api/colors.ts

@@ -0,0 +1,59 @@
+/**
+ * Colors API Routes
+ * Handles color variables endpoints with theme support
+ */
+
+import { colorService } from '../../services/ColorService';
+import { jsonResponse } from './shared';
+
+/**
+ * Handle colors API endpoint - GET /api/colors?theme=<themeName>
+ */
+export async function handleColorsRoute(url?: URL): Promise<Response> {
+  try {
+    const themeName = url?.searchParams.get('theme') || undefined;
+    const colors = await colorService.getThemeColors(themeName);
+    return jsonResponse(colors);
+  } catch (error) {
+    console.error('Error loading colors:', error);
+    return jsonResponse(
+      { error: 'Failed to load colors' },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * Handle themes API endpoint - GET /api/themes
+ */
+export async function handleThemesRoute(): Promise<Response> {
+  try {
+    const themes = await colorService.getAvailableThemes();
+    const defaultTheme = await colorService.getDefaultTheme();
+    return jsonResponse({ themes, default: defaultTheme });
+  } catch (error) {
+    console.error('Error loading themes:', error);
+    return jsonResponse(
+      { error: 'Failed to load themes' },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * Handle full colors config API endpoint - GET /api/colors-config
+ */
+export async function handleColorsConfigRoute(): Promise<Response> {
+  try {
+    const config = await colorService.getFullConfig();
+    return jsonResponse(config);
+  } catch (error) {
+    console.error('Error loading colors config:', error);
+    return jsonResponse(
+      { error: 'Failed to load colors config' },
+      { status: 500 }
+    );
+  }
+}
+
+// Note: handleSaveColorsRoute moved to @meno/studio

package/lib/server/routes/api/components.ts

@@ -0,0 +1,70 @@
+/**
+ * Components API Routes
+ * Handles component CRUD endpoints
+ */
+
+import type { ComponentService } from '../../services/componentService';
+import { createCorsHeaders } from '../../middleware/cors';
+import { jsonResponse } from './shared';
+
+/**
+ * Handle components API endpoint - GET /api/components
+ */
+export function handleComponentsRoute(componentService: ComponentService): Response {
+  const components = componentService.getAllComponents();
+  return jsonResponse(components);
+}
+
+/**
+ * Handle component data API endpoint - GET /api/component-data/:name
+ * Validates that component has structure before returning
+ */
+export function handleComponentDataRoute(
+  url: URL,
+  componentService: ComponentService
+): Response {
+  const componentName = url.pathname.replace('/api/component-data/', '');
+  const componentDef = componentService.getComponent(componentName);
+
+  if (!componentDef) {
+    return jsonResponse({ error: 'Component not found' }, { status: 404 });
+  }
+
+  // Debug: Log what we're about to return
+
+  // Validate that component has structure
+  if (!componentService.validateComponentStructure(componentDef)) {
+    return jsonResponse(
+      { 
+        error: 'Component structure is missing',
+        message: `Component "${componentName}" does not have a valid structure definition. Please add a structure field to the component definition.`
+      }, 
+      { status: 400 }
+    );
+  }
+
+  return jsonResponse(componentDef);
+}
+
+/**
+ * Handle component JavaScript API endpoint - GET /api/component-js/:name
+ */
+export async function handleComponentJavaScriptRoute(
+  url: URL,
+  componentService: ComponentService
+): Promise<Response> {
+  const componentName = url.pathname.replace('/api/component-js/', '');
+  const jsContent = await componentService.getComponentJavaScript(componentName);
+  const corsHeaders = createCorsHeaders();
+
+  return new Response(jsContent || '', {
+    headers: {
+      'Content-Type': 'text/javascript',
+      ...corsHeaders,
+    },
+  });
+}
+
+// Note: Write handlers (handleSaveComponentRoute, handleSaveComponentJavaScriptRoute,
+// handleSaveComponentCSSRoute, handleComponentCategoryRoute) moved to @meno/studio
+