meno-core 1.0.0

package/lib/server/pageCache.test.ts

@@ -0,0 +1,167 @@
+import { test, expect, describe, beforeEach } from "bun:test";
+import { PageCache } from "./pageCache";
+import type { LineMap } from "./utils/jsonLineMapper";
+
+// Helper to create empty line map for tests
+const emptyLineMap = (): LineMap => new Map();
+
+describe("PageCache", () => {
+  let cache: PageCache;
+
+  beforeEach(() => {
+    cache = new PageCache();
+  });
+
+  describe("set and get", () => {
+    test("should store and retrieve page content", () => {
+      cache.set("/", "home content", emptyLineMap());
+      const result = cache.getContent("/");
+
+      expect(result).toBe("home content");
+    });
+
+    test("should return undefined for non-existent page", () => {
+      const result = cache.getContent("/nonexistent");
+      expect(result).toBeUndefined();
+    });
+
+    test("should overwrite existing page content", () => {
+      cache.set("/about", "old content", emptyLineMap());
+      cache.set("/about", "new content", emptyLineMap());
+
+      const result = cache.getContent("/about");
+      expect(result).toBe("new content");
+    });
+  });
+
+  describe("has", () => {
+    test("should return true for cached page", () => {
+      cache.set("/about", "content", emptyLineMap());
+      expect(cache.has("/about")).toBe(true);
+    });
+
+    test("should return false for non-cached page", () => {
+      expect(cache.has("/nonexistent")).toBe(false);
+    });
+  });
+
+  describe("delete", () => {
+    test("should delete cached page", () => {
+      cache.set("/temp", "content", emptyLineMap());
+      expect(cache.has("/temp")).toBe(true);
+
+      cache.delete("/temp");
+      expect(cache.has("/temp")).toBe(false);
+    });
+
+    test("should not throw when deleting non-existent page", () => {
+      expect(() => cache.delete("/nonexistent")).not.toThrow();
+    });
+  });
+
+  describe("keys", () => {
+    test("should return all cached page paths", () => {
+      cache.set("/", "home", emptyLineMap());
+      cache.set("/about", "about", emptyLineMap());
+      cache.set("/contact", "contact", emptyLineMap());
+
+      const keys = cache.keys();
+
+      expect(keys.length).toBe(3);
+      expect(keys).toContain("/");
+      expect(keys).toContain("/about");
+      expect(keys).toContain("/contact");
+    });
+
+    test("should return empty array when cache is empty", () => {
+      const keys = cache.keys();
+      expect(keys).toEqual([]);
+    });
+  });
+
+  describe("clear", () => {
+    test("should clear all cached pages", () => {
+      cache.set("/", "home", emptyLineMap());
+      cache.set("/about", "about", emptyLineMap());
+
+      expect(cache.size()).toBe(2);
+
+      cache.clear();
+
+      expect(cache.size()).toBe(0);
+      expect(cache.has("/")).toBe(false);
+      expect(cache.has("/about")).toBe(false);
+    });
+  });
+
+  describe("size", () => {
+    test("should return number of cached pages", () => {
+      expect(cache.size()).toBe(0);
+
+      cache.set("/", "home", emptyLineMap());
+      expect(cache.size()).toBe(1);
+
+      cache.set("/about", "about", emptyLineMap());
+      expect(cache.size()).toBe(2);
+
+      cache.delete("/");
+      expect(cache.size()).toBe(1);
+    });
+  });
+
+  describe("toObject", () => {
+    test("should convert cache to object", () => {
+      cache.set("/", "home content", emptyLineMap());
+      cache.set("/about", "about content", emptyLineMap());
+
+      const obj = cache.toObject();
+
+      expect(obj["/"]).toBe("home content");
+      expect(obj["/about"]).toBe("about content");
+      expect(Object.keys(obj).length).toBe(2);
+    });
+
+    test("should return empty object when cache is empty", () => {
+      const obj = cache.toObject();
+      expect(obj).toEqual({});
+    });
+  });
+
+  describe("page path mapping", () => {
+    test("should handle index page as root path", () => {
+      cache.set("/", "home content", emptyLineMap());
+      expect(cache.getContent("/")).toBe("home content");
+    });
+
+    test("should handle nested paths", () => {
+      cache.set("/blog/post-1", "blog post content", emptyLineMap());
+      expect(cache.getContent("/blog/post-1")).toBe("blog post content");
+    });
+  });
+
+  describe("line map", () => {
+    test("should store and retrieve line map", () => {
+      const lineMap: LineMap = new Map();
+      lineMap.set("0", { startLine: 31, endLine: 39 });
+      lineMap.set("1", { startLine: 40, endLine: 100 });
+
+      cache.set("/", "home content", lineMap);
+      const result = cache.getLineMap("/");
+
+      expect(result).toBeDefined();
+      expect(result?.get("0")).toEqual({ startLine: 31, endLine: 39 });
+      expect(result?.get("1")).toEqual({ startLine: 40, endLine: 100 });
+    });
+
+    test("should get line range for specific element path", () => {
+      const lineMap: LineMap = new Map();
+      lineMap.set("0,1", { startLine: 50, endLine: 75 });
+
+      cache.set("/about", "about content", lineMap);
+      const range = cache.getLineRange("/about", "0,1");
+
+      expect(range).toEqual({ startLine: 50, endLine: 75 });
+    });
+  });
+});
+

package/lib/server/pageCache.ts

@@ -0,0 +1,97 @@
+/**
+ * Page Cache
+ * Manages caching of page JSON content with line number tracking
+ */
+
+import type { LineMap, LineRange } from './utils/jsonLineMapper';
+
+export interface CachedPage {
+  content: string;
+  lineMap: LineMap;
+}
+
+export class PageCache {
+  private cache = new Map<string, CachedPage>();
+
+  /**
+   * Store page content and line map in cache
+   */
+  set(path: string, content: string, lineMap: LineMap): void {
+    this.cache.set(path, { content, lineMap });
+  }
+
+  /**
+   * Get cached page data
+   */
+  get(path: string): CachedPage | undefined {
+    return this.cache.get(path);
+  }
+
+  /**
+   * Get page content from cache
+   */
+  getContent(path: string): string | undefined {
+    return this.cache.get(path)?.content;
+  }
+
+  /**
+   * Get line map from cache
+   */
+  getLineMap(path: string): LineMap | undefined {
+    return this.cache.get(path)?.lineMap;
+  }
+
+  /**
+   * Get line range for a specific element path
+   */
+  getLineRange(pagePath: string, elementPath: string): LineRange | undefined {
+    return this.cache.get(pagePath)?.lineMap.get(elementPath);
+  }
+
+  /**
+   * Delete page from cache
+   */
+  delete(path: string): void {
+    this.cache.delete(path);
+  }
+
+  /**
+   * Check if page exists in cache
+   */
+  has(path: string): boolean {
+    return this.cache.has(path);
+  }
+
+  /**
+   * Get all page paths
+   */
+  keys(): string[] {
+    return Array.from(this.cache.keys());
+  }
+
+  /**
+   * Clear all cached pages
+   */
+  clear(): void {
+    this.cache.clear();
+  }
+
+  /**
+   * Get cache size
+   */
+  size(): number {
+    return this.cache.size;
+  }
+
+  /**
+   * Get all pages content as object (without line maps)
+   */
+  toObject(): Record<string, string> {
+    const obj: Record<string, string> = {};
+    this.cache.forEach((value, key) => {
+      obj[key] = value.content;
+    });
+    return obj;
+  }
+}
+

package/lib/server/projectContext.ts

@@ -0,0 +1,51 @@
+import { join, dirname } from 'path';
+
+let projectRoot: string = process.cwd();
+
+// Package root is where the editor files are installed (2 levels up from this file)
+const packageRoot = join(dirname(import.meta.dir), '..');
+
+export function setProjectRoot(root: string): void {
+  projectRoot = root;
+}
+
+export function getProjectRoot(): string {
+  return projectRoot;
+}
+
+export function getPackageRoot(): string {
+  return packageRoot;
+}
+
+// Path getters for project files (user's project)
+export const projectPaths = {
+  pages: () => join(projectRoot, 'pages'),
+  components: () => join(projectRoot, 'components'),
+  fonts: () => join(projectRoot, 'fonts'),
+  images: () => join(projectRoot, 'images'),
+  videos: () => join(projectRoot, 'videos'),
+  assets: () => join(projectRoot, 'assets'),
+  icons: () => join(projectRoot, 'icons'),
+  cms: () => join(projectRoot, 'cms'),
+  functions: () => join(projectRoot, 'functions'),
+  config: () => join(projectRoot, 'project.config.json'),
+  colors: () => join(projectRoot, 'colors.json'),
+  dist: () => join(projectRoot, 'dist'),
+  env: () => join(projectRoot, '.env'),
+  get project() { return projectRoot; }, // Direct access to project root
+};
+
+// Path getters for package files (core assets)
+// Note: Editor-specific paths (editorHtml) are now in @meno/studio
+export const packagePaths = {
+  indexHtml: () => join(packageRoot, 'templates', 'index-router.html'),
+  clientRouter: () => join(packageRoot, 'entries', 'client-router.tsx'),
+};
+
+export function resolveProjectPath(...segments: string[]): string {
+  return join(projectRoot, ...segments);
+}
+
+export function resolvePackagePath(...segments: string[]): string {
+  return join(packageRoot, ...segments);
+}

package/lib/server/providers/fileSystemCMSProvider.test.ts

@@ -0,0 +1,292 @@
+/**
+ * FileSystemCMSProvider Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { FileSystemCMSProvider } from './fileSystemCMSProvider';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const TEST_DIR = '/tmp/cms-provider-test-' + Date.now();
+const PAGES_DIR = join(TEST_DIR, 'pages');
+const CMS_DIR = join(TEST_DIR, 'cms');
+
+describe('FileSystemCMSProvider', () => {
+  let provider: FileSystemCMSProvider;
+
+  beforeEach(() => {
+    // Create test directories
+    mkdirSync(PAGES_DIR, { recursive: true });
+    mkdirSync(join(CMS_DIR, 'blog-posts'), { recursive: true });
+
+    // Create test page with embedded schema
+    writeFileSync(
+      join(PAGES_DIR, 'blog-post.json'),
+      JSON.stringify({
+        meta: {
+          source: 'cms',
+          cms: {
+            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' },
+            },
+          },
+          title: '{{cms.title}}'
+        },
+        root: { type: 'node', tag: 'div', children: [] }
+      }, null, 2)
+    );
+
+    // Create static page (should be ignored)
+    writeFileSync(
+      join(PAGES_DIR, 'about.json'),
+      JSON.stringify({
+        meta: { title: 'About' },
+        root: { type: 'node', tag: 'div', children: [] }
+      }, null, 2)
+    );
+
+    // Create CMS items
+    writeFileSync(
+      join(CMS_DIR, 'blog-posts', 'hello-world.json'),
+      JSON.stringify({
+        _id: '1',
+        title: 'Hello World',
+        slug: 'hello-world',
+        content: 'First post content'
+      }, null, 2)
+    );
+
+    writeFileSync(
+      join(CMS_DIR, 'blog-posts', 'getting-started.json'),
+      JSON.stringify({
+        _id: '2',
+        title: 'Getting Started',
+        slug: 'getting-started',
+        content: 'Guide content'
+      }, null, 2)
+    );
+
+    provider = new FileSystemCMSProvider(PAGES_DIR, CMS_DIR);
+  });
+
+  afterEach(() => {
+    // Clean up test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe('getAllSchemas', () => {
+    it('should extract schemas from CMS pages', async () => {
+      const schemas = await provider.getAllSchemas();
+
+      expect(schemas.size).toBe(1);
+      expect(schemas.has('blog-posts')).toBe(true);
+
+      const schemaInfo = schemas.get('blog-posts')!;
+      expect(schemaInfo.schema.id).toBe('blog-posts');
+      expect(schemaInfo.schema.name).toBe('Blog Posts');
+      expect(schemaInfo.schema.slugField).toBe('slug');
+      expect(schemaInfo.pagePath).toContain('blog-post.json');
+    });
+
+    it('should ignore static pages', async () => {
+      const schemas = await provider.getAllSchemas();
+      expect(schemas.has('about')).toBe(false);
+    });
+
+    it('should cache schemas', async () => {
+      const schemas1 = await provider.getAllSchemas();
+      const schemas2 = await provider.getAllSchemas();
+      expect(schemas1).toBe(schemas2); // Same object reference
+    });
+
+    it('should return empty map for non-existent pages directory', async () => {
+      const emptyProvider = new FileSystemCMSProvider('/non-existent', CMS_DIR);
+      const schemas = await emptyProvider.getAllSchemas();
+      expect(schemas.size).toBe(0);
+    });
+  });
+
+  describe('getItems', () => {
+    it('should load all items for a collection', async () => {
+      const items = await provider.getItems('blog-posts');
+
+      expect(items).toHaveLength(2);
+      expect(items.some(i => i.slug === 'hello-world')).toBe(true);
+      expect(items.some(i => i.slug === 'getting-started')).toBe(true);
+    });
+
+    it('should add _slug from filename', async () => {
+      const items = await provider.getItems('blog-posts');
+      const helloWorld = items.find(i => i.slug === 'hello-world');
+
+      expect(helloWorld?._slug).toBe('hello-world');
+    });
+
+    it('should return empty array for non-existent collection', async () => {
+      const items = await provider.getItems('unknown-collection');
+      expect(items).toEqual([]);
+    });
+  });
+
+  describe('getItemBySlug', () => {
+    it('should load item by slug', async () => {
+      const item = await provider.getItemBySlug('blog-posts', 'hello-world');
+
+      expect(item).not.toBeNull();
+      expect(item?.title).toBe('Hello World');
+      expect(item?.slug).toBe('hello-world');
+      expect(item?._slug).toBe('hello-world');
+    });
+
+    it('should return null for non-existent slug', async () => {
+      const item = await provider.getItemBySlug('blog-posts', 'non-existent');
+      expect(item).toBeNull();
+    });
+
+    it('should return null for non-existent collection', async () => {
+      const item = await provider.getItemBySlug('unknown', 'hello-world');
+      expect(item).toBeNull();
+    });
+  });
+
+  describe('getItemById', () => {
+    it('should load item by ID', async () => {
+      const item = await provider.getItemById('blog-posts', '1');
+
+      expect(item).not.toBeNull();
+      expect(item?.title).toBe('Hello World');
+    });
+
+    it('should return null for non-existent ID', async () => {
+      const item = await provider.getItemById('blog-posts', '999');
+      expect(item).toBeNull();
+    });
+  });
+
+  describe('saveItem', () => {
+    it('should save new item', async () => {
+      const newItem = {
+        _id: '3',
+        title: 'New Post',
+        slug: 'new-post',
+        content: 'New content',
+      };
+
+      await provider.saveItem('blog-posts', newItem);
+
+      const saved = await provider.getItemBySlug('blog-posts', 'new-post');
+      expect(saved).not.toBeNull();
+      expect(saved?.title).toBe('New Post');
+    });
+
+    it('should update existing item', async () => {
+      const item = await provider.getItemBySlug('blog-posts', 'hello-world');
+      const updated = { ...item!, title: 'Updated Title' };
+
+      await provider.saveItem('blog-posts', updated);
+
+      const saved = await provider.getItemBySlug('blog-posts', 'hello-world');
+      expect(saved?.title).toBe('Updated Title');
+    });
+
+    it('should create collection directory if not exists', async () => {
+      const newItem = {
+        _id: '1',
+        name: 'Product',
+        slug: 'test-product',
+        price: 99,
+      };
+
+      // Add products schema
+      writeFileSync(
+        join(PAGES_DIR, 'product.json'),
+        JSON.stringify({
+          meta: {
+            source: 'cms',
+            cms: {
+              id: 'products',
+              name: 'Products',
+              slugField: 'slug',
+              urlPattern: '/shop/{{slug}}',
+              fields: {
+                name: { type: 'string' },
+                slug: { type: 'string' },
+                price: { type: 'number' },
+              },
+            },
+          },
+          root: { type: 'node', tag: 'div', children: [] }
+        }, null, 2)
+      );
+
+      provider.clearSchemaCache();
+      await provider.saveItem('products', newItem);
+
+      const saved = await provider.getItemBySlug('products', 'test-product');
+      expect(saved?.name).toBe('Product');
+    });
+
+    it('should throw for unknown collection', async () => {
+      const item = { _id: '1', slug: 'test' };
+      await expect(provider.saveItem('unknown', item)).rejects.toThrow('Unknown collection');
+    });
+  });
+
+  describe('deleteItem', () => {
+    it('should delete item by slug', async () => {
+      const before = await provider.getItemBySlug('blog-posts', 'hello-world');
+      expect(before).not.toBeNull();
+
+      await provider.deleteItem('blog-posts', 'hello-world');
+
+      const after = await provider.getItemBySlug('blog-posts', 'hello-world');
+      expect(after).toBeNull();
+    });
+
+    it('should not throw for non-existent item', async () => {
+      await expect(provider.deleteItem('blog-posts', 'non-existent')).resolves.toBeUndefined();
+    });
+  });
+
+  describe('clearSchemaCache', () => {
+    it('should clear cached schemas', async () => {
+      const schemas1 = await provider.getAllSchemas();
+      expect(schemas1.size).toBe(1);
+
+      // Add new page with CMS
+      writeFileSync(
+        join(PAGES_DIR, 'product.json'),
+        JSON.stringify({
+          meta: {
+            source: 'cms',
+            cms: {
+              id: 'products',
+              name: 'Products',
+              slugField: 'slug',
+              urlPattern: '/shop/{{slug}}',
+              fields: {},
+            },
+          },
+          root: { type: 'node', tag: 'div', children: [] }
+        }, null, 2)
+      );
+
+      // Still cached
+      const schemas2 = await provider.getAllSchemas();
+      expect(schemas2.size).toBe(1);
+
+      // Clear and reload
+      provider.clearSchemaCache();
+      const schemas3 = await provider.getAllSchemas();
+      expect(schemas3.size).toBe(2);
+    });
+  });
+});