meno-core 1.0.0

package/lib/server/jsonLoader.ts

@@ -0,0 +1,350 @@
+/**
+ * JSON Loader
+ * Utilities for loading and parsing JSON files
+ */
+
+import { existsSync, readdirSync } from 'fs';
+import type { z } from 'zod';
+import type { ComponentDefinition } from '../shared/types';
+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 { validateComponentDefinition } from '../shared/validation/validators';
+import { projectPaths } from './projectContext';
+
+/**
+ * Load JSON file from a file path
+ */
+export 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 (error) {
+    return null;
+  }
+}
+
+/**
+ * Parse JSON content
+ */
+export function parseJSON<T = unknown>(content: string): T {
+  return JSON.parse(content);
+}
+
+/**
+ * Parse and validate JSON content against a zod schema
+ * Returns null on validation failure (for backward compatibility)
+ */
+export function parseAndValidateJSON<T>(
+  content: string,
+  schema: z.ZodType<T>
+): T | null {
+  try {
+    const parsed = JSON.parse(content);
+    const result = schema.safeParse(parsed);
+    if (result.success) {
+      return result.data;
+    }
+    // Return parsed value anyway for backward compatibility
+    return parsed as T;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Load and parse JSON file
+ */
+export async function loadAndParseJSON<T = any>(filePath: string): Promise<T | null> {
+  const content = await loadJSONFile(filePath);
+  if (!content) return null;
+  
+  try {
+    return parseJSON<T>(content);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Load all JSON files from a directory
+ */
+export async function loadJSONDirectory(
+  dirPath: string
+): Promise<Map<string, string>> {
+  const files = new Map<string, string>();
+  
+  if (!existsSync(dirPath)) {
+    return files;
+  }
+  
+  const fileList = readdirSync(dirPath);
+  
+  for (const file of fileList) {
+    if (file.endsWith('.json')) {
+      const name = file.replace('.json', '');
+      const content = await loadJSONFile(`${dirPath}/${file}`);
+      
+      if (content) {
+        files.set(name, content);
+      }
+    }
+  }
+  
+  return files;
+}
+
+/**
+ * Load file content as text (for .js, .css, etc.)
+ */
+async function loadFileAsText(filePath: string): Promise<string | null> {
+  try {
+    const file = Bun.file(filePath);
+    if (await file.exists()) {
+      return await file.text();
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Load all component definitions from components directory
+ * Automatically loads corresponding .js files if they exist
+ */
+export async function loadComponentDirectory(
+  dirPath: string = './components'
+): Promise<Map<string, ComponentDefinition>> {
+  const components = new Map<string, ComponentDefinition>();
+
+  if (!existsSync(dirPath)) {
+    return components;
+  }
+
+  const files = readdirSync(dirPath);
+
+  for (const file of files) {
+    if (file.endsWith('.json')) {
+      const componentName = file.replace('.json', '');
+      const content = await loadJSONFile(`${dirPath}/${file}`);
+
+      if (content) {
+        try {
+          const parsed = parseJSON<ComponentDefinition>(content);
+
+          // Validate component definition (logs warnings but doesn't fail - graceful degradation)
+          const validationResult = validateComponentDefinition(parsed);
+          if (!validationResult.valid) {
+            console.warn(`[jsonLoader] Component validation failed for ${componentName}:`,
+              validationResult.errors.map(e => `${e.path}: ${e.message}`).join('; '));
+          }
+          const componentDef = validationResult.valid ? validationResult.data : parsed;
+
+          // Check if there's a corresponding .js file
+          const jsFilePath = `${dirPath}/${componentName}.js`;
+          const jsContent = await loadFileAsText(jsFilePath);
+
+          // Check if there's a corresponding .css file
+          const cssFilePath = `${dirPath}/${componentName}.css`;
+          const cssContent = await loadFileAsText(cssFilePath);
+
+          if (!componentDef.component) {
+            componentDef.component = {};
+          }
+
+          // If .js file exists, use its content for javascript field
+          // This takes precedence over any javascript field in the JSON
+          if (jsContent) {
+            componentDef.component.javascript = jsContent;
+          }
+
+          // If .css file exists, use its content for css field
+          // This takes precedence over any css field in the JSON
+          if (cssContent) {
+            componentDef.component.css = cssContent;
+          }
+
+          components.set(componentName, componentDef);
+        } catch (error) {
+        }
+      }
+    }
+  }
+
+  return components;
+}
+
+/**
+ * Map page filename to route path
+ */
+export function mapPageNameToPath(pageName: string): string {
+  return pageName === 'index' ? '/' : `/${pageName}`;
+}
+
+/**
+ * Map route path to page filename
+ */
+export function mapPathToPageName(path: string): string {
+  return path === '/' ? 'index' : path.substring(1);
+}
+
+// Breakpoint types are now imported from shared/breakpoints
+
+/**
+ * Load and validate breakpoint configuration from project.config.json
+ */
+export async function loadBreakpointConfig(): Promise<BreakpointConfig> {
+  try {
+    const configContent = await loadJSONFile(projectPaths.config());
+    if (configContent) {
+      const config = parseJSON<{ breakpoints?: Record<string, number> }>(configContent);
+      
+      if (config.breakpoints && typeof config.breakpoints === 'object') {
+        // Preserve all breakpoints from config, filtering out invalid values
+        const breakpoints: BreakpointConfig = {};
+        for (const [key, value] of Object.entries(config.breakpoints)) {
+          if (typeof value === 'number' && value > 0) {
+            breakpoints[key] = value;
+          }
+        }
+        
+        // If we have valid breakpoints, return them; otherwise fall back to defaults
+        if (Object.keys(breakpoints).length > 0) {
+          return breakpoints;
+        }
+      }
+    }
+  } catch (error) {
+  }
+  
+  return { ...DEFAULT_BREAKPOINTS };
+}
+
+/**
+ * Get breakpoint config synchronously (for cases where async is not available)
+ * Uses cached value if available, otherwise defaults
+ */
+let cachedBreakpoints: BreakpointConfig | null = null;
+
+export function getBreakpointConfig(): BreakpointConfig {
+  if (cachedBreakpoints) {
+    return cachedBreakpoints;
+  }
+  return DEFAULT_BREAKPOINTS;
+}
+
+export function setBreakpointConfig(config: BreakpointConfig): void {
+  cachedBreakpoints = config;
+}
+
+/**
+ * Load and validate responsive scales configuration from project.config.json
+ */
+export async function loadResponsiveScalesConfig(): Promise<ResponsiveScales> {
+  try {
+    const configContent = await loadJSONFile(projectPaths.config());
+    if (configContent) {
+      const config = parseJSON<{ responsiveScales?: Partial<ResponsiveScales> }>(configContent);
+
+      if (config.responsiveScales && typeof config.responsiveScales === 'object') {
+        // Merge with defaults to fill in missing values
+        const scales: ResponsiveScales = {
+          ...DEFAULT_RESPONSIVE_SCALES,
+          ...config.responsiveScales,
+        };
+
+        return scales;
+      }
+    }
+  } catch (error) {
+  }
+
+  return { ...DEFAULT_RESPONSIVE_SCALES };
+}
+
+/**
+ * Get responsive scales config synchronously (for cases where async is not available)
+ * Uses cached value if available, otherwise defaults
+ */
+let cachedResponsiveScales: ResponsiveScales | null = null;
+
+export function getResponsiveScalesConfig(): ResponsiveScales {
+  if (cachedResponsiveScales) {
+    return cachedResponsiveScales;
+  }
+  return { ...DEFAULT_RESPONSIVE_SCALES };
+}
+
+export function setResponsiveScalesConfig(config: ResponsiveScales): void {
+  cachedResponsiveScales = config;
+}
+
+/**
+ * Load and validate i18n configuration from project.config.json
+ * Automatically migrates old string[] format to new LocaleConfig[] format
+ */
+export async function loadI18nConfig(): Promise<I18nConfig> {
+  try {
+    const configContent = await loadJSONFile(projectPaths.config());
+    if (configContent) {
+      const config = parseJSON<{ i18n?: unknown }>(configContent);
+      return migrateI18nConfig(config.i18n);
+    }
+  } catch (error) {
+    // Fall through to default
+  }
+
+  return { ...DEFAULT_I18N_CONFIG };
+}
+
+/**
+ * Get i18n config synchronously (for cases where async is not available)
+ * Uses cached value if available, otherwise defaults
+ */
+let cachedI18nConfig: I18nConfig | null = null;
+
+export function getI18nConfig(): I18nConfig {
+  if (cachedI18nConfig) {
+    return cachedI18nConfig;
+  }
+  return { ...DEFAULT_I18N_CONFIG };
+}
+
+export function setI18nConfig(config: I18nConfig): void {
+  cachedI18nConfig = config;
+}
+
+/**
+ * Icons configuration from project.config.json
+ */
+export interface IconsConfig {
+  favicon?: string;
+  appleTouchIcon?: string;
+}
+
+/**
+ * Load icons configuration from project.config.json
+ */
+export async function loadIconsConfig(): Promise<IconsConfig> {
+  try {
+    const configContent = await loadJSONFile(projectPaths.config());
+    if (configContent) {
+      const config = parseJSON<{ icons?: IconsConfig }>(configContent);
+      if (config.icons && typeof config.icons === 'object') {
+        return config.icons;
+      }
+    }
+  } catch (error) {
+    // Fall through to default
+  }
+
+  return {};
+}
+

package/lib/server/middleware/cors.test.ts

@@ -0,0 +1,177 @@
+import { describe, test, expect } from 'bun:test';
+import { createCorsHeaders, handleCorsPreflight, type CorsOptions } from './cors';
+
+describe('cors middleware', () => {
+  describe('createCorsHeaders', () => {
+    test('returns default headers with no options', () => {
+      const headers = createCorsHeaders();
+      expect(headers['Access-Control-Allow-Origin']).toBe('*');
+      expect(headers['Access-Control-Allow-Methods']).toBe('GET, POST, PUT, DELETE, OPTIONS');
+      expect(headers['Access-Control-Allow-Headers']).toBe('Content-Type, Authorization');
+    });
+
+    test('handles string origin', () => {
+      const headers = createCorsHeaders({ origin: 'https://example.com' });
+      expect(headers['Access-Control-Allow-Origin']).toBe('https://example.com');
+    });
+
+    test('handles array origin', () => {
+      const headers = createCorsHeaders({
+        origin: ['https://example.com', 'https://test.com']
+      });
+      expect(headers['Access-Control-Allow-Origin']).toBe('https://example.com, https://test.com');
+    });
+
+    test('handles function origin', () => {
+      const headers = createCorsHeaders({
+        origin: (origin: string) => origin === 'https://example.com'
+      });
+      // Function origin falls back to '*' since we don't have request origin
+      expect(headers['Access-Control-Allow-Origin']).toBe('*');
+    });
+
+    test('handles custom methods', () => {
+      const headers = createCorsHeaders({
+        methods: ['GET', 'POST']
+      });
+      expect(headers['Access-Control-Allow-Methods']).toBe('GET, POST');
+    });
+
+    test('handles empty methods array', () => {
+      const headers = createCorsHeaders({
+        methods: []
+      });
+      expect(headers['Access-Control-Allow-Methods']).toBeUndefined();
+    });
+
+    test('handles custom allowed headers', () => {
+      const headers = createCorsHeaders({
+        allowedHeaders: ['X-Custom-Header', 'Content-Type']
+      });
+      expect(headers['Access-Control-Allow-Headers']).toBe('X-Custom-Header, Content-Type');
+    });
+
+    test('handles empty allowed headers array', () => {
+      const headers = createCorsHeaders({
+        allowedHeaders: []
+      });
+      expect(headers['Access-Control-Allow-Headers']).toBeUndefined();
+    });
+
+    test('sets credentials header when enabled', () => {
+      const headers = createCorsHeaders({
+        credentials: true
+      });
+      expect(headers['Access-Control-Allow-Credentials']).toBe('true');
+    });
+
+    test('does not set credentials header when disabled', () => {
+      const headers = createCorsHeaders({
+        credentials: false
+      });
+      expect(headers['Access-Control-Allow-Credentials']).toBeUndefined();
+    });
+
+    test('merges multiple options', () => {
+      const headers = createCorsHeaders({
+        origin: 'https://example.com',
+        methods: ['GET', 'POST'],
+        allowedHeaders: ['X-Token'],
+        credentials: true
+      });
+      expect(headers['Access-Control-Allow-Origin']).toBe('https://example.com');
+      expect(headers['Access-Control-Allow-Methods']).toBe('GET, POST');
+      expect(headers['Access-Control-Allow-Headers']).toBe('X-Token');
+      expect(headers['Access-Control-Allow-Credentials']).toBe('true');
+    });
+
+    test('overrides defaults with provided options', () => {
+      const headers = createCorsHeaders({
+        methods: ['GET']
+      });
+      expect(headers['Access-Control-Allow-Methods']).toBe('GET');
+      expect(headers['Access-Control-Allow-Origin']).toBe('*'); // Still defaults
+    });
+  });
+
+  describe('handleCorsPreflight', () => {
+    test('returns null for non-OPTIONS request', () => {
+      const req = new Request('http://localhost:3000/api/test', {
+        method: 'GET'
+      });
+      const response = handleCorsPreflight(req);
+      expect(response).toBeNull();
+    });
+
+    test('returns response for OPTIONS request', () => {
+      const req = new Request('http://localhost:3000/api/test', {
+        method: 'OPTIONS'
+      });
+      const response = handleCorsPreflight(req);
+      expect(response).not.toBeNull();
+      expect(response?.status).toBe(204);
+    });
+
+    test('OPTIONS response includes default CORS headers', () => {
+      const req = new Request('http://localhost:3000/api/test', {
+        method: 'OPTIONS'
+      });
+      const response = handleCorsPreflight(req);
+      expect(response?.headers.get('Access-Control-Allow-Origin')).toBe('*');
+      expect(response?.headers.get('Access-Control-Allow-Methods')).toContain('GET');
+    });
+
+    test('OPTIONS response includes custom CORS headers', () => {
+      const req = new Request('http://localhost:3000/api/test', {
+        method: 'OPTIONS'
+      });
+      const response = handleCorsPreflight(req, {
+        origin: 'https://example.com',
+        methods: ['GET', 'POST']
+      });
+      expect(response?.headers.get('Access-Control-Allow-Origin')).toBe('https://example.com');
+      expect(response?.headers.get('Access-Control-Allow-Methods')).toBe('GET, POST');
+    });
+
+    test('OPTIONS response has no body', async () => {
+      const req = new Request('http://localhost:3000/api/test', {
+        method: 'OPTIONS'
+      });
+      const response = handleCorsPreflight(req);
+      const body = await response?.text();
+      expect(body).toBe('');
+    });
+
+    test('handles POST request', () => {
+      const req = new Request('http://localhost:3000/api/test', {
+        method: 'POST'
+      });
+      const response = handleCorsPreflight(req);
+      expect(response).toBeNull();
+    });
+
+    test('handles PUT request', () => {
+      const req = new Request('http://localhost:3000/api/test', {
+        method: 'PUT'
+      });
+      const response = handleCorsPreflight(req);
+      expect(response).toBeNull();
+    });
+
+    test('handles DELETE request', () => {
+      const req = new Request('http://localhost:3000/api/test', {
+        method: 'DELETE'
+      });
+      const response = handleCorsPreflight(req);
+      expect(response).toBeNull();
+    });
+
+    test('OPTIONS with credentials option', () => {
+      const req = new Request('http://localhost:3000/api/test', {
+        method: 'OPTIONS'
+      });
+      const response = handleCorsPreflight(req, { credentials: true });
+      expect(response?.headers.get('Access-Control-Allow-Credentials')).toBe('true');
+    });
+  });
+});

package/lib/server/middleware/cors.ts

@@ -0,0 +1,69 @@
+/**
+ * CORS Middleware
+ * Handles Cross-Origin Resource Sharing headers
+ */
+
+export interface CorsOptions {
+  origin?: string | string[] | ((origin: string) => boolean);
+  methods?: string[];
+  allowedHeaders?: string[];
+  credentials?: boolean;
+}
+
+const DEFAULT_OPTIONS: CorsOptions = {
+  origin: '*',
+  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+  allowedHeaders: ['Content-Type', 'Authorization'],
+  credentials: false,
+};
+
+/**
+ * Create CORS headers for a response
+ */
+export function createCorsHeaders(options: CorsOptions = {}): HeadersInit {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const headers: HeadersInit = {};
+
+  // Handle origin
+  if (opts.origin) {
+    if (typeof opts.origin === 'function') {
+      // Dynamic origin - would need request origin to evaluate
+      headers['Access-Control-Allow-Origin'] = '*';
+    } else if (Array.isArray(opts.origin)) {
+      headers['Access-Control-Allow-Origin'] = opts.origin.join(', ');
+    } else {
+      headers['Access-Control-Allow-Origin'] = opts.origin;
+    }
+  }
+
+  // Handle methods
+  if (opts.methods && opts.methods.length > 0) {
+    headers['Access-Control-Allow-Methods'] = opts.methods.join(', ');
+  }
+
+  // Handle headers
+  if (opts.allowedHeaders && opts.allowedHeaders.length > 0) {
+    headers['Access-Control-Allow-Headers'] = opts.allowedHeaders.join(', ');
+  }
+
+  // Handle credentials
+  if (opts.credentials) {
+    headers['Access-Control-Allow-Credentials'] = 'true';
+  }
+
+  return headers;
+}
+
+/**
+ * Handle CORS preflight requests
+ */
+export function handleCorsPreflight(req: Request, options: CorsOptions = {}): Response | null {
+  if (req.method === 'OPTIONS') {
+    return new Response(null, {
+      status: 204,
+      headers: createCorsHeaders(options),
+    });
+  }
+  return null;
+}
+