contentbase 0.0.4 → 0.0.5

package/test/collection.test.ts

@@ -1,215 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "fs/promises";
-import path from "path";
-import { Collection } from "../src/collection";
-import { createTestCollection, FIXTURES_PATH } from "./helpers";
-import { Epic, Story } from "./fixtures/sdlc/models";
-
-describe("Collection", () => {
-  let collection: Collection;
-
-  beforeEach(async () => {
-    collection = await createTestCollection();
-  });
-
-  it("loads all mdx files from rootPath", () => {
-    expect(collection.loaded).toBe(true);
-    expect(collection.available.length).toBeGreaterThanOrEqual(3);
-  });
-
-  it("returns correct path IDs", () => {
-    expect(collection.available).toContain("epics/authentication");
-    expect(collection.available).toContain("epics/searching-and-browsing");
-    expect(collection.available).toContain(
-      "stories/authentication/a-user-should-be-able-to-register"
-    );
-  });
-
-  it("lazily creates documents", () => {
-    const doc = collection.document("epics/authentication");
-    expect(doc).toBeDefined();
-    expect(doc.id).toBe("epics/authentication");
-  });
-
-  it("caches documents", () => {
-    const doc1 = collection.document("epics/authentication");
-    const doc2 = collection.document("epics/authentication");
-    expect(doc1).toBe(doc2);
-  });
-
-  it("throws if not loaded", () => {
-    const fresh = new Collection({ rootPath: FIXTURES_PATH });
-    expect(() => fresh.document("epics/authentication")).toThrow(
-      "Collection has not been loaded"
-    );
-  });
-
-  it("throws for unknown pathId", () => {
-    expect(() => collection.document("nonexistent")).toThrow(
-      'Could not find document "nonexistent"'
-    );
-  });
-
-  it("registers model definitions", () => {
-    expect(collection.getModelDefinition("Epic")).toBeDefined();
-    expect(collection.getModelDefinition("Story")).toBeDefined();
-    expect(collection.getModelDefinition("Base")).toBeDefined();
-    expect(collection.modelDefinitions.length).toBe(3);
-  });
-
-  it("finds model definition by pathId prefix", () => {
-    const def = collection.findModelDefinition("epics/authentication");
-    expect(def?.name).toBe("Epic");
-  });
-
-  it("gets typed model instances", () => {
-    const epic = collection.getModel("epics/authentication", Epic);
-    expect(epic.id).toBe("epics/authentication");
-    expect(epic.title).toBe("Authentication");
-    expect(epic.meta.status).toBe("created");
-  });
-
-  it("creates typed queries", async () => {
-    const epics = await collection.query(Epic).fetchAll();
-    expect(epics.length).toBe(2);
-    expect(epics[0].meta.status).toBeDefined();
-  });
-
-  it("serializes to JSON", () => {
-    const json = collection.toJSON();
-    expect(json.models).toBeDefined();
-    expect(json.itemIds).toBeDefined();
-  });
-
-  it("supports actions", async () => {
-    let called = false;
-    collection.action("test-action", () => {
-      called = true;
-    });
-    expect(collection.availableActions).toContain("test-action");
-    await collection.runAction("test-action");
-    expect(called).toBe(true);
-  });
-
-  it("supports plugins", () => {
-    let pluginCalled = false;
-    collection.use((coll) => {
-      pluginCalled = true;
-      expect(coll).toBe(collection);
-    });
-    expect(pluginCalled).toBe(true);
-  });
-
-  describe("refresh after delete", () => {
-    let tmpDir: string;
-    let tmpCollection: Collection;
-
-    beforeEach(async () => {
-      tmpDir = await fs.mkdtemp(path.join(import.meta.dirname, ".tmp-refresh-"));
-      // Create two documents
-      const epicDir = path.join(tmpDir, "epics");
-      await fs.mkdir(epicDir, { recursive: true });
-      await fs.writeFile(
-        path.join(epicDir, "one.mdx"),
-        "---\nstatus: created\npriority: 1\n---\n# One\n"
-      );
-      await fs.writeFile(
-        path.join(epicDir, "two.mdx"),
-        "---\nstatus: created\npriority: 2\n---\n# Two\n"
-      );
-
-      tmpCollection = new Collection({ rootPath: tmpDir });
-      tmpCollection.register(Epic);
-      await tmpCollection.load();
-    });
-
-    afterEach(async () => {
-      await fs.rm(tmpDir, { recursive: true });
-    });
-
-    it("evicts cached documents whose files were deleted", async () => {
-      // Access a document so it's in the #documents cache
-      const doc = tmpCollection.document("epics/one");
-      expect(doc.title).toBe("One");
-
-      // Delete the file externally
-      await fs.unlink(path.join(tmpDir, "epics", "one.mdx"));
-
-      // Refresh should succeed without ENOENT
-      await tmpCollection.load({ refresh: true });
-
-      // The deleted document should no longer be available
-      expect(tmpCollection.available).not.toContain("epics/one");
-      expect(tmpCollection.available).toContain("epics/two");
-    });
-  });
-
-  describe("generateModelSummary", () => {
-    let tmpDir: string;
-    let tmpCollection: Collection;
-
-    beforeEach(async () => {
-      tmpDir = await fs.mkdtemp(path.join(import.meta.dirname, ".tmp-summary-"));
-      tmpCollection = new Collection({ rootPath: tmpDir });
-      tmpCollection.register(Epic);
-      tmpCollection.register(Story);
-      await tmpCollection.load();
-    });
-
-    afterEach(async () => {
-      await fs.rm(tmpDir, { recursive: true });
-    });
-
-    it("generates inspect-style text with model info", () => {
-      const text = tmpCollection.generateModelSummary();
-
-      // Collection header
-      expect(text).toContain("Collection:");
-      expect(text).toContain("Root:");
-      expect(text).toContain("Items:");
-
-      // Model entries
-      expect(text).toContain("Model: Epic");
-      expect(text).toContain("Model: Story");
-
-      // Prefixes
-      expect(text).toContain("Prefix: epics");
-      expect(text).toContain("Prefix: stories");
-
-      // Meta attributes
-      expect(text).toContain("priority");
-      expect(text).toContain("status");
-
-      // Sections
-      expect(text).toContain("Sections:");
-
-      // Relationships
-      expect(text).toContain("Relationships:");
-    });
-
-    it("saveModelSummary writes README.md to rootPath", async () => {
-      await tmpCollection.saveModelSummary();
-      const content = await fs.readFile(path.join(tmpDir, "README.md"), "utf8");
-      expect(content).toContain("# Models");
-      expect(content).toContain("## Overview");
-      expect(content).toContain("## Summary");
-    });
-
-    it("saveModelSummary preserves existing Overview content", async () => {
-      // Write an initial README.md with user content in Overview
-      const initial = "# Models\n\n## Overview\n\nThis is my custom overview.\n\n## Summary\n\n```\nold summary\n```\n";
-      await fs.writeFile(path.join(tmpDir, "README.md"), initial, "utf8");
-
-      await tmpCollection.saveModelSummary();
-      const content = await fs.readFile(path.join(tmpDir, "README.md"), "utf8");
-      expect(content).toContain("This is my custom overview.");
-      expect(content).toContain("Model: Epic");
-    });
-
-    it("includes collection actions", () => {
-      tmpCollection.action("deploy", () => {});
-      const text = tmpCollection.generateModelSummary();
-      expect(text).toContain("Actions: deploy");
-    });
-  });
-});

package/test/define-model.test.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { defineModel, z, section, hasMany, belongsTo } from "../src/index";
-
-describe("defineModel", () => {
-  it("creates a ModelDefinition with the given name", () => {
-    const MyModel = defineModel("MyModel");
-    expect(MyModel.name).toBe("MyModel");
-  });
-
-  it("auto-pluralizes the prefix from the name", () => {
-    const Epic = defineModel("Epic");
-    expect(Epic.prefix).toBe("epics");
-  });
-
-  it("uses custom prefix when provided", () => {
-    const MyModel = defineModel("MyModel", { prefix: "custom" });
-    expect(MyModel.prefix).toBe("custom");
-  });
-
-  it("stores the meta Zod schema", () => {
-    const schema = z.object({ status: z.string() });
-    const MyModel = defineModel("MyModel", { meta: schema });
-    expect(MyModel.meta).toBe(schema);
-    expect(MyModel.schema).toBe(schema);
-  });
-
-  it("creates passthrough schema when meta is omitted", () => {
-    const MyModel = defineModel("MyModel");
-    const result = MyModel.meta.safeParse({ anything: "goes" });
-    expect(result.success).toBe(true);
-  });
-
-  it("stores sections", () => {
-    const MyModel = defineModel("MyModel", {
-      sections: {
-        items: section("Items", {
-          extract: (q) => q.selectAll("listItem"),
-        }),
-      },
-    });
-    expect(MyModel.sections.items.heading).toBe("Items");
-  });
-
-  it("stores relationships", () => {
-    const Target = defineModel("Target");
-    const MyModel = defineModel("MyModel", {
-      relationships: {
-        targets: hasMany(() => Target, { heading: "Targets" }),
-      },
-    });
-    expect(MyModel.relationships.targets.type).toBe("hasMany");
-    expect(MyModel.relationships.targets.heading).toBe("Targets");
-  });
-
-  it("stores computed properties", () => {
-    const MyModel = defineModel("MyModel", {
-      computed: {
-        foo: () => 42,
-      },
-    });
-    expect(MyModel.computed.foo).toBeDefined();
-    expect(MyModel.computed.foo({})).toBe(42);
-  });
-
-  it("stores match function", () => {
-    const fn = (doc: any) => doc.id.startsWith("special");
-    const MyModel = defineModel("MyModel", { match: fn });
-    expect(MyModel.match).toBe(fn);
-  });
-
-  it("stores defaults", () => {
-    const MyModel = defineModel("MyModel", {
-      meta: z.object({ status: z.string().default("draft") }),
-      defaults: { status: "draft" },
-    });
-    expect(MyModel.defaults).toEqual({ status: "draft" });
-  });
-});

package/test/document.test.ts

@@ -1,225 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { Collection } from "../src/collection";
-import { createTestCollection } from "./helpers";
-import { toString } from "mdast-util-to-string";
-
-describe("Document", () => {
-  let collection: Collection;
-
-  beforeEach(async () => {
-    collection = await createTestCollection();
-  });
-
-  it("lazily parses AST", () => {
-    const doc = collection.document("epics/authentication");
-    // Content should exist but AST is not parsed yet
-    expect(doc.content).toBeDefined();
-    // Accessing ast triggers parsing
-    expect(doc.ast.type).toBe("root");
-    expect(doc.ast.children.length).toBeGreaterThan(0);
-  });
-
-  it("extracts title from first heading", () => {
-    const doc = collection.document("epics/authentication");
-    expect(doc.title).toBe("Authentication");
-  });
-
-  it("falls back to id if no heading", () => {
-    const doc = collection.createDocument({
-      id: "test/no-heading",
-      content: "Just some text without a heading.",
-    });
-    expect(doc.title).toBe("test/no-heading");
-  });
-
-  it("generates slug from title", () => {
-    const doc = collection.document("epics/authentication");
-    expect(doc.slug).toBe("authentication");
-  });
-
-  it("exposes parsed frontmatter as meta", () => {
-    const doc = collection.document("epics/authentication");
-    expect(doc.meta.priority).toBe("high");
-    expect(doc.meta.status).toBe("created");
-  });
-
-  it("serializes rawContent with frontmatter", () => {
-    const doc = collection.document("epics/authentication");
-    expect(doc.rawContent).toContain("---");
-    expect(doc.rawContent).toContain("priority: high");
-    expect(doc.rawContent).toContain("# Authentication");
-  });
-
-  it("omits frontmatter block if meta is empty", () => {
-    const doc = collection.createDocument({
-      id: "test/no-meta",
-      content: "# Hello\n",
-    });
-    expect(doc.rawContent).not.toContain("---");
-  });
-
-  it("provides astQuery", () => {
-    const doc = collection.document("epics/authentication");
-    expect(doc.astQuery.select("heading")).toBeDefined();
-  });
-
-  it("provides nodes shortcuts", () => {
-    const doc = collection.document("epics/authentication");
-    expect(doc.nodes.headings.length).toBeGreaterThan(0);
-    expect(doc.nodes.firstHeading).toBeDefined();
-  });
-
-  describe("extractSection", () => {
-    it("extracts section by heading text", () => {
-      const doc = collection.document("epics/authentication");
-      const section = doc.extractSection("Stories");
-      expect(section.length).toBeGreaterThan(1);
-      expect(toString(section[0])).toBe("Stories");
-    });
-
-    it("throws for non-existent heading", () => {
-      const doc = collection.document("epics/authentication");
-      expect(() => doc.extractSection("Nonexistent")).toThrow(
-        "Heading not found"
-      );
-    });
-  });
-
-  describe("querySection", () => {
-    it("returns scoped AstQuery without the heading", () => {
-      const doc = collection.document("epics/authentication");
-      const query = doc.querySection("Stories");
-      const headings = query.selectAll("heading");
-      // Should have the story sub-headings but not "Stories" itself
-      expect(headings.length).toBeGreaterThan(0);
-    });
-
-    it("returns empty query for non-existent heading", () => {
-      const doc = collection.document("epics/authentication");
-      const query = doc.querySection("Nonexistent");
-      expect(query.selectAll("heading").length).toBe(0);
-    });
-  });
-
-  describe("immutable section mutations", () => {
-    it("removeSection returns new Document", () => {
-      const doc = collection.document("epics/authentication");
-      const originalContent = doc.content;
-      const newDoc = doc.removeSection("Stories");
-      expect(newDoc).not.toBe(doc);
-      expect(doc.content).toBe(originalContent);
-      expect(newDoc.content).not.toContain("A User should be able to register");
-    });
-
-    it("replaceSectionContent returns new Document", () => {
-      const doc = collection.document("epics/authentication");
-      const newDoc = doc.replaceSectionContent(
-        "Stories",
-        "New stories content here."
-      );
-      expect(newDoc).not.toBe(doc);
-      expect(newDoc.content).toContain("New stories content here");
-    });
-
-    it("insertBefore returns new Document", () => {
-      const doc = collection.document("epics/authentication");
-      const heading = doc.astQuery.findHeadingByText("Stories");
-      expect(heading).toBeDefined();
-      const newDoc = doc.insertBefore(heading!, "Inserted before.");
-      expect(newDoc).not.toBe(doc);
-      expect(newDoc.content).toContain("Inserted before");
-    });
-
-    it("insertAfter returns new Document", () => {
-      const doc = collection.document("epics/authentication");
-      const heading = doc.astQuery.findHeadingByText("Stories");
-      expect(heading).toBeDefined();
-      const newDoc = doc.insertAfter(heading!, "Inserted after.");
-      expect(newDoc).not.toBe(doc);
-      expect(newDoc.content).toContain("Inserted after");
-    });
-
-    it("appendToSection returns new Document", () => {
-      const doc = collection.document("epics/authentication");
-      const newDoc = doc.appendToSection(
-        "Stories",
-        "### New Story\n\nAppended story."
-      );
-      expect(newDoc).not.toBe(doc);
-      expect(newDoc.content).toContain("New Story");
-    });
-  });
-
-  describe("mutable mutations", () => {
-    it("removeSection with mutate modifies in place", () => {
-      const doc = collection.createDocument({
-        id: "test/mutable",
-        content:
-          "# Test\n\n## Section A\n\nContent A\n\n## Section B\n\nContent B\n",
-      });
-      const result = doc.removeSection("Section A", { mutate: true });
-      expect(result).toBe(doc);
-      expect(doc.content).not.toContain("Content A");
-      expect(doc.content).toContain("Content B");
-    });
-  });
-
-  it("replaceContent returns new Document", () => {
-    const doc = collection.document("epics/authentication");
-    const newDoc = doc.replaceContent("# Completely new content");
-    expect(newDoc).not.toBe(doc);
-    expect(newDoc.content).toBe("# Completely new content");
-  });
-
-  it("appendContent returns new Document", () => {
-    const doc = collection.createDocument({
-      id: "test/append",
-      content: "# Start\n",
-    });
-    const newDoc = doc.appendContent("\n## Added\n");
-    expect(newDoc).not.toBe(doc);
-    expect(newDoc.content).toContain("Added");
-  });
-
-  it("toJSON serializes document", () => {
-    const doc = collection.document("epics/authentication");
-    const json = doc.toJSON();
-    expect(json.id).toBe("epics/authentication");
-    expect(json.meta).toBeDefined();
-    expect(json.content).toBeDefined();
-    expect(json.ast).toBeDefined();
-  });
-
-  it("toText extracts plain text", () => {
-    const doc = collection.document("epics/authentication");
-    const text = doc.toText();
-    expect(text).toContain("Authentication");
-  });
-
-  describe("toOutline", () => {
-    it("returns indented heading outline", () => {
-      const doc = collection.document("epics/authentication");
-      const outline = doc.toOutline();
-      expect(outline).toBe(
-        [
-          "- Authentication",
-          "  - Stories",
-          "    - A User should be able to register.",
-          "      - Acceptance Criteria",
-          "      - Mockups",
-          "    - A User should be able to login.",
-          "      - Acceptance Criteria",
-          "      - Mockups",
-        ].join("\n")
-      );
-    });
-
-    it("returns empty string for document with no headings", () => {
-      const doc = collection.createDocument({
-        id: "test/no-headings",
-        content: "Just some text without any headings.",
-      });
-      expect(doc.toOutline()).toBe("");
-    });
-  });
-});