@mandujs/core 0.11.0 → 0.12.0

package/src/content/content.test.ts

@@ -0,0 +1,433 @@
+/**
+ * Content Layer Tests
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { generateDigest, generateFileDigest, combineDigests, digestsMatch } from "./digest";
+import { createDataStore, type ContentDataStore } from "./data-store";
+import { createMetaStore, type ContentMetaStore } from "./meta-store";
+import { createLoaderContext, createSimpleMarkdownRenderer } from "./loader-context";
+import { z } from "zod";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// ============================================================================
+// Digest Tests
+// ============================================================================
+
+describe("digest", () => {
+  test("generateDigest creates consistent hash for same data", () => {
+    const data = { title: "Hello", count: 42 };
+    const hash1 = generateDigest(data);
+    const hash2 = generateDigest(data);
+
+    expect(hash1).toBe(hash2);
+    expect(hash1.length).toBe(16);
+  });
+
+  test("generateDigest creates different hash for different data", () => {
+    const hash1 = generateDigest({ a: 1 });
+    const hash2 = generateDigest({ a: 2 });
+
+    expect(hash1).not.toBe(hash2);
+  });
+
+  test("generateDigest handles nested objects", () => {
+    const data = {
+      user: { name: "John", age: 30 },
+      tags: ["a", "b"],
+    };
+
+    const hash = generateDigest(data);
+    expect(hash.length).toBe(16);
+  });
+
+  test("generateDigest is order-independent for object keys", () => {
+    const hash1 = generateDigest({ a: 1, b: 2 });
+    const hash2 = generateDigest({ b: 2, a: 1 });
+
+    expect(hash1).toBe(hash2);
+  });
+
+  test("generateFileDigest works with string content", () => {
+    const content = "# Hello World\n\nThis is content.";
+    const hash = generateFileDigest(content);
+
+    expect(hash.length).toBe(16);
+  });
+
+  test("combineDigests combines multiple digests", () => {
+    const d1 = generateDigest({ a: 1 });
+    const d2 = generateDigest({ b: 2 });
+    const combined = combineDigests([d1, d2]);
+
+    expect(combined.length).toBe(16);
+    expect(combined).not.toBe(d1);
+    expect(combined).not.toBe(d2);
+  });
+
+  test("digestsMatch compares digests correctly", () => {
+    const d1 = generateDigest({ x: 1 });
+    const d2 = generateDigest({ x: 1 });
+    const d3 = generateDigest({ x: 2 });
+
+    expect(digestsMatch(d1, d2)).toBe(true);
+    expect(digestsMatch(d1, d3)).toBe(false);
+    expect(digestsMatch(undefined, d1)).toBe(false);
+  });
+});
+
+// ============================================================================
+// DataStore Tests
+// ============================================================================
+
+describe("DataStore", () => {
+  let store: ContentDataStore;
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "mandu-test-"));
+    store = createDataStore({
+      filePath: path.join(tempDir, "store.json"),
+      autoSave: false,
+    });
+  });
+
+  afterEach(() => {
+    store.dispose();
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test("getStore returns a DataStore interface", () => {
+    const posts = store.getStore("posts");
+
+    expect(posts.get).toBeDefined();
+    expect(posts.set).toBeDefined();
+    expect(posts.delete).toBeDefined();
+    expect(posts.entries).toBeDefined();
+  });
+
+  test("set and get work correctly", () => {
+    const posts = store.getStore("posts");
+
+    posts.set({
+      id: "hello-world",
+      data: { title: "Hello World" },
+      digest: "abc123",
+    });
+
+    const entry = posts.get("hello-world");
+    expect(entry).toBeDefined();
+    expect(entry?.data.title).toBe("Hello World");
+  });
+
+  test("set returns true for new/changed entries", () => {
+    const posts = store.getStore("posts");
+
+    const result1 = posts.set({
+      id: "post1",
+      data: { title: "Post 1" },
+      digest: "digest1",
+    });
+    expect(result1).toBe(true);
+
+    // Same digest, no change
+    const result2 = posts.set({
+      id: "post1",
+      data: { title: "Post 1" },
+      digest: "digest1",
+    });
+    expect(result2).toBe(false);
+
+    // Different digest, changed
+    const result3 = posts.set({
+      id: "post1",
+      data: { title: "Post 1 Updated" },
+      digest: "digest2",
+    });
+    expect(result3).toBe(true);
+  });
+
+  test("delete removes entry", () => {
+    const posts = store.getStore("posts");
+
+    posts.set({ id: "to-delete", data: {}, digest: "x" });
+    expect(posts.has("to-delete")).toBe(true);
+
+    posts.delete("to-delete");
+    expect(posts.has("to-delete")).toBe(false);
+  });
+
+  test("entries returns all entries", () => {
+    const posts = store.getStore("posts");
+
+    posts.set({ id: "p1", data: { n: 1 }, digest: "a" });
+    posts.set({ id: "p2", data: { n: 2 }, digest: "b" });
+
+    const entries = posts.entries();
+    expect(entries.length).toBe(2);
+    expect(entries.map(([id]) => id).sort()).toEqual(["p1", "p2"]);
+  });
+
+  test("size returns entry count", () => {
+    const posts = store.getStore("posts");
+
+    expect(posts.size()).toBe(0);
+
+    posts.set({ id: "p1", data: {}, digest: "a" });
+    posts.set({ id: "p2", data: {}, digest: "b" });
+
+    expect(posts.size()).toBe(2);
+  });
+
+  test("clear removes all entries", () => {
+    const posts = store.getStore("posts");
+
+    posts.set({ id: "p1", data: {}, digest: "a" });
+    posts.set({ id: "p2", data: {}, digest: "b" });
+
+    posts.clear();
+    expect(posts.size()).toBe(0);
+  });
+
+  test("save and load persist data", async () => {
+    const posts = store.getStore("posts");
+
+    posts.set({
+      id: "persistent",
+      data: { title: "Persistent Post" },
+      digest: "persistent-digest",
+    });
+
+    await store.save();
+
+    // Create new store and load
+    const store2 = createDataStore({
+      filePath: path.join(tempDir, "store.json"),
+      autoSave: false,
+    });
+
+    await store2.load();
+
+    const posts2 = store2.getStore("posts");
+    const entry = posts2.get("persistent");
+
+    expect(entry).toBeDefined();
+    expect(entry?.data.title).toBe("Persistent Post");
+
+    store2.dispose();
+  });
+});
+
+// ============================================================================
+// MetaStore Tests
+// ============================================================================
+
+describe("MetaStore", () => {
+  let metaStore: ContentMetaStore;
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "mandu-meta-test-"));
+    metaStore = createMetaStore({
+      filePath: path.join(tempDir, "meta.json"),
+      autoSave: false,
+    });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test("getStore returns MetaStore interface", () => {
+    const meta = metaStore.getStore("posts");
+
+    expect(meta.get).toBeDefined();
+    expect(meta.set).toBeDefined();
+    expect(meta.has).toBeDefined();
+  });
+
+  test("set and get work correctly", () => {
+    const meta = metaStore.getStore("api-data");
+
+    meta.set("lastSync", "2024-01-15T10:00:00Z");
+    meta.set("cursor", "abc123");
+
+    expect(meta.get("lastSync")).toBe("2024-01-15T10:00:00Z");
+    expect(meta.get("cursor")).toBe("abc123");
+    expect(meta.get("nonexistent")).toBeUndefined();
+  });
+
+  test("has checks existence", () => {
+    const meta = metaStore.getStore("collection");
+
+    expect(meta.has("key")).toBe(false);
+
+    meta.set("key", "value");
+    expect(meta.has("key")).toBe(true);
+  });
+
+  test("delete removes key", () => {
+    const meta = metaStore.getStore("collection");
+
+    meta.set("toDelete", "value");
+    expect(meta.has("toDelete")).toBe(true);
+
+    meta.delete("toDelete");
+    expect(meta.has("toDelete")).toBe(false);
+  });
+
+  test("entries returns all key-value pairs", () => {
+    const meta = metaStore.getStore("collection");
+
+    meta.set("k1", "v1");
+    meta.set("k2", "v2");
+
+    const entries = meta.entries();
+    expect(entries.length).toBe(2);
+  });
+});
+
+// ============================================================================
+// LoaderContext Tests
+// ============================================================================
+
+describe("LoaderContext", () => {
+  let dataStore: ContentDataStore;
+  let metaStore: ContentMetaStore;
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "mandu-ctx-test-"));
+    dataStore = createDataStore({ autoSave: false });
+    metaStore = createMetaStore({ autoSave: false });
+  });
+
+  afterEach(() => {
+    dataStore.dispose();
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test("creates context with all properties", () => {
+    const context = createLoaderContext({
+      collection: "posts",
+      store: dataStore.getStore("posts"),
+      meta: metaStore.getStore("posts"),
+      config: { root: tempDir },
+    });
+
+    expect(context.collection).toBe("posts");
+    expect(context.store).toBeDefined();
+    expect(context.meta).toBeDefined();
+    expect(context.logger).toBeDefined();
+    expect(context.parseData).toBeDefined();
+    expect(context.generateDigest).toBeDefined();
+  });
+
+  test("parseData validates with schema", async () => {
+    const schema = z.object({
+      title: z.string(),
+      count: z.number(),
+    });
+
+    const context = createLoaderContext({
+      collection: "posts",
+      store: dataStore.getStore("posts"),
+      meta: metaStore.getStore("posts"),
+      config: { root: tempDir },
+      schema,
+    });
+
+    // Valid data
+    const valid = await context.parseData({
+      id: "test",
+      data: { title: "Hello", count: 5 },
+    });
+
+    expect(valid.title).toBe("Hello");
+    expect(valid.count).toBe(5);
+
+    // Invalid data should throw
+    await expect(
+      context.parseData({
+        id: "invalid",
+        data: { title: 123, count: "not a number" },
+      })
+    ).rejects.toThrow();
+  });
+
+  test("parseData passes through without schema", async () => {
+    const context = createLoaderContext({
+      collection: "posts",
+      store: dataStore.getStore("posts"),
+      meta: metaStore.getStore("posts"),
+      config: { root: tempDir },
+    });
+
+    const data = await context.parseData({
+      id: "test",
+      data: { anything: "goes" },
+    });
+
+    expect(data.anything).toBe("goes");
+  });
+
+  test("generateDigest creates hash", () => {
+    const context = createLoaderContext({
+      collection: "posts",
+      store: dataStore.getStore("posts"),
+      meta: metaStore.getStore("posts"),
+      config: { root: tempDir },
+    });
+
+    const hash = context.generateDigest({ test: "data" });
+    expect(hash.length).toBe(16);
+  });
+});
+
+// ============================================================================
+// Markdown Renderer Tests
+// ============================================================================
+
+describe("SimpleMarkdownRenderer", () => {
+  const render = createSimpleMarkdownRenderer();
+
+  test("renders headings", async () => {
+    const result = await render("# Heading 1\n## Heading 2");
+
+    expect(result.html).toContain("<h1>Heading 1</h1>");
+    expect(result.html).toContain("<h2>Heading 2</h2>");
+  });
+
+  test("extracts headings", async () => {
+    const result = await render("# Title\n## Section 1\n### Subsection");
+
+    expect(result.headings).toBeDefined();
+    expect(result.headings?.length).toBe(3);
+    expect(result.headings?.[0]).toEqual({
+      depth: 1,
+      text: "Title",
+      slug: "title",
+    });
+  });
+
+  test("renders bold and italic", async () => {
+    const result = await render("**bold** and *italic*");
+
+    expect(result.html).toContain("<strong>bold</strong>");
+    expect(result.html).toContain("<em>italic</em>");
+  });
+
+  test("renders links", async () => {
+    const result = await render("[Link Text](https://example.com)");
+
+    expect(result.html).toContain('<a href="https://example.com">Link Text</a>');
+  });
+
+  test("renders code", async () => {
+    const result = await render("`inline code`");
+
+    expect(result.html).toContain("<code>inline code</code>");
+  });
+});

package/src/content/data-store.ts

@@ -0,0 +1,245 @@
+/**
+ * DataStore - 콘텐츠 데이터 저장소
+ *
+ * 컬렉션별 데이터 엔트리를 메모리에 저장하고
+ * 영속화를 위해 JSON 파일로 직렬화
+ */
+
+import type { DataEntry, DataStore } from "./types";
+import { digestsMatch } from "./digest";
+import * as fs from "fs";
+import * as path from "path";
+
+/**
+ * 스토어 옵션
+ */
+export interface DataStoreOptions {
+  /** 영속화 파일 경로 */
+  filePath?: string;
+  /** 자동 저장 활성화 */
+  autoSave?: boolean;
+  /** 저장 디바운스 (ms) */
+  saveDebounce?: number;
+}
+
+/**
+ * 직렬화된 스토어 형식
+ */
+interface SerializedStore {
+  version: number;
+  collections: Record<string, Record<string, DataEntry>>;
+  timestamp: string;
+}
+
+const STORE_VERSION = 1;
+
+/**
+ * 컬렉션별 DataStore 관리자
+ */
+export class ContentDataStore {
+  private collections: Map<string, Map<string, DataEntry>> = new Map();
+  private options: DataStoreOptions;
+  private saveTimer: NodeJS.Timeout | null = null;
+  private dirty: boolean = false;
+
+  constructor(options: DataStoreOptions = {}) {
+    this.options = {
+      autoSave: true,
+      saveDebounce: 500,
+      ...options,
+    };
+  }
+
+  /**
+   * 컬렉션용 DataStore 인터페이스 생성
+   */
+  getStore(collection: string): DataStore {
+    if (!this.collections.has(collection)) {
+      this.collections.set(collection, new Map());
+    }
+
+    const store = this.collections.get(collection)!;
+
+    return {
+      get: <T>(id: string) => store.get(id) as DataEntry<T> | undefined,
+
+      set: <T>(entry: DataEntry<T>) => {
+        const existing = store.get(entry.id);
+        const changed = !existing || !digestsMatch(existing.digest, entry.digest);
+
+        if (changed) {
+          store.set(entry.id, entry as DataEntry);
+          this.markDirty();
+        }
+
+        return changed;
+      },
+
+      delete: (id: string) => {
+        if (store.has(id)) {
+          store.delete(id);
+          this.markDirty();
+        }
+      },
+
+      clear: () => {
+        if (store.size > 0) {
+          store.clear();
+          this.markDirty();
+        }
+      },
+
+      entries: <T>() =>
+        Array.from(store.entries()) as Array<[string, DataEntry<T>]>,
+
+      has: (id: string) => store.has(id),
+
+      size: () => store.size,
+
+      keys: () => Array.from(store.keys()),
+
+      values: <T>() => Array.from(store.values()) as Array<DataEntry<T>>,
+    };
+  }
+
+  /**
+   * 컬렉션 삭제
+   */
+  deleteCollection(collection: string): void {
+    if (this.collections.has(collection)) {
+      this.collections.delete(collection);
+      this.markDirty();
+    }
+  }
+
+  /**
+   * 모든 컬렉션 이름 조회
+   */
+  getCollectionNames(): string[] {
+    return Array.from(this.collections.keys());
+  }
+
+  /**
+   * 변경 표시 및 자동 저장 스케줄링
+   */
+  private markDirty(): void {
+    this.dirty = true;
+
+    if (this.options.autoSave && this.options.filePath) {
+      if (this.saveTimer) {
+        clearTimeout(this.saveTimer);
+      }
+
+      this.saveTimer = setTimeout(() => {
+        this.save();
+      }, this.options.saveDebounce);
+    }
+  }
+
+  /**
+   * 파일에서 로드
+   */
+  async load(): Promise<void> {
+    if (!this.options.filePath) return;
+
+    try {
+      if (!fs.existsSync(this.options.filePath)) {
+        return;
+      }
+
+      const content = fs.readFileSync(this.options.filePath, "utf-8");
+      const data: SerializedStore = JSON.parse(content);
+
+      if (data.version !== STORE_VERSION) {
+        console.warn(
+          `[ContentStore] Store version mismatch (${data.version} vs ${STORE_VERSION}), starting fresh`
+        );
+        return;
+      }
+
+      for (const [collection, entries] of Object.entries(data.collections)) {
+        const store = new Map<string, DataEntry>();
+        for (const [id, entry] of Object.entries(entries)) {
+          store.set(id, entry);
+        }
+        this.collections.set(collection, store);
+      }
+
+      this.dirty = false;
+    } catch (error) {
+      console.warn(
+        `[ContentStore] Failed to load store:`,
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
+
+  /**
+   * 파일에 저장
+   */
+  async save(): Promise<void> {
+    if (!this.options.filePath || !this.dirty) return;
+
+    try {
+      const dir = path.dirname(this.options.filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      const data: SerializedStore = {
+        version: STORE_VERSION,
+        collections: {},
+        timestamp: new Date().toISOString(),
+      };
+
+      for (const [collection, store] of this.collections) {
+        data.collections[collection] = Object.fromEntries(store);
+      }
+
+      fs.writeFileSync(this.options.filePath, JSON.stringify(data, null, 2));
+      this.dirty = false;
+    } catch (error) {
+      console.error(
+        `[ContentStore] Failed to save store:`,
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
+
+  /**
+   * 저장 타이머 정리
+   */
+  dispose(): void {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+    }
+
+    // 남은 변경사항 저장
+    if (this.dirty && this.options.filePath) {
+      this.save();
+    }
+  }
+
+  /**
+   * 전체 스토어 통계
+   */
+  getStats(): { collections: number; totalEntries: number } {
+    let totalEntries = 0;
+    for (const store of this.collections.values()) {
+      totalEntries += store.size;
+    }
+
+    return {
+      collections: this.collections.size,
+      totalEntries,
+    };
+  }
+}
+
+/**
+ * DataStore 팩토리
+ */
+export function createDataStore(options?: DataStoreOptions): ContentDataStore {
+  return new ContentDataStore(options);
+}