contentbase 0.0.2 → 0.0.4

package/test/relationships.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import { Collection } from "../src/collection";
 import { createModelInstance } from "../src/model-instance";
+import { defineModel, hasMany, belongsTo, z } from "../src/index";
 import { createTestCollection } from "./helpers";
 import { Epic, Story } from "./fixtures/sdlc/models";
 
@@ -53,6 +54,135 @@ describe("HasManyRelationship", () => {
   });
 });
 
+describe("HasMany with foreignKey", () => {
+  let collection: Collection;
+
+  beforeEach(async () => {
+    collection = await createTestCollection();
+  });
+
+  it("finds children by matching meta field to parent slug", () => {
+    // Define a version of Epic that uses foreignKey instead of heading
+    const EpicFK = defineModel("Epic", {
+      prefix: "epics",
+      meta: z.object({
+        priority: z.enum(["low", "medium", "high"]).optional(),
+        status: z.enum(["created", "in-progress", "complete"]).default("created"),
+      }),
+      relationships: {
+        stories: hasMany(() => Story, { foreignKey: "epic" }),
+      },
+    });
+
+    const doc = collection.document("epics/authentication");
+    const epic = createModelInstance(doc, EpicFK, collection);
+    const stories = epic.relationships.stories.fetchAll();
+
+    expect(stories.length).toBe(2);
+    expect(stories.map((s: any) => s.meta.epic)).toEqual(["authentication", "authentication"]);
+  });
+
+  it("infers foreignKey from parent prefix when omitted", () => {
+    // hasMany with empty options — should infer foreignKey as "epic" from "epics/" prefix
+    const EpicInferred = defineModel("Epic", {
+      prefix: "epics",
+      meta: z.object({
+        priority: z.enum(["low", "medium", "high"]).optional(),
+        status: z.enum(["created", "in-progress", "complete"]).default("created"),
+      }),
+      relationships: {
+        stories: hasMany(() => Story, {}),
+      },
+    });
+
+    const doc = collection.document("epics/authentication");
+    const epic = createModelInstance(doc, EpicInferred, collection);
+    const stories = epic.relationships.stories.fetchAll();
+
+    expect(stories.length).toBe(2);
+  });
+
+  it("returns empty array when no children match", () => {
+    const EpicFK = defineModel("Epic", {
+      prefix: "epics",
+      meta: z.object({
+        priority: z.enum(["low", "medium", "high"]).optional(),
+        status: z.enum(["created", "in-progress", "complete"]).default("created"),
+      }),
+      relationships: {
+        stories: hasMany(() => Story, { foreignKey: "epic" }),
+      },
+    });
+
+    const doc = collection.document("epics/searching-and-browsing");
+    const epic = createModelInstance(doc, EpicFK, collection);
+    const stories = epic.relationships.stories.fetchAll();
+
+    // No story files have epic: "searching-and-browsing" in their meta
+    expect(stories.length).toBe(0);
+  });
+
+  it("children have correct titles and IDs", () => {
+    const EpicFK = defineModel("Epic", {
+      prefix: "epics",
+      meta: z.object({
+        priority: z.enum(["low", "medium", "high"]).optional(),
+        status: z.enum(["created", "in-progress", "complete"]).default("created"),
+      }),
+      relationships: {
+        stories: hasMany(() => Story, { foreignKey: "epic" }),
+      },
+    });
+
+    const doc = collection.document("epics/authentication");
+    const epic = createModelInstance(doc, EpicFK, collection);
+    const stories = epic.relationships.stories.fetchAll();
+
+    const ids = stories.map((s: any) => s.id).sort();
+    expect(ids).toEqual([
+      "stories/authentication/a-user-should-be-able-to-login",
+      "stories/authentication/a-user-should-be-able-to-register",
+    ]);
+  });
+});
+
+describe("CollectionQuery include()", () => {
+  let collection: Collection;
+
+  beforeEach(async () => {
+    collection = await createTestCollection();
+  });
+
+  it("includes relationships in toJSON output", async () => {
+    const results = await collection.query(Epic).include("stories").fetchAll();
+    const auth = results.find((e: any) => e.id === "epics/authentication");
+    const json = auth!.toJSON();
+
+    expect(json.stories).toBeDefined();
+    expect(Array.isArray(json.stories)).toBe(true);
+    expect((json.stories as any[]).length).toBe(2);
+  });
+
+  it("toJSON without include does not contain relationships", async () => {
+    const results = await collection.query(Epic).fetchAll();
+    const auth = results.find((e: any) => e.id === "epics/authentication");
+    const json = auth!.toJSON();
+
+    expect(json.stories).toBeUndefined();
+  });
+
+  it("include can be combined with where", async () => {
+    const results = await collection.query(Epic)
+      .where("meta.priority", "high")
+      .include("stories")
+      .fetchAll();
+
+    expect(results.length).toBeGreaterThan(0);
+    const json = results[0].toJSON();
+    expect(json.stories).toBeDefined();
+  });
+});
+
 describe("BelongsToRelationship", () => {
   let collection: Collection;
 

package/test/section.test.ts

@@ -71,6 +71,67 @@ describe("section helper", () => {
     expect(extractCalled).toBe(1); // Cached
   });
 
+  it("stores alternatives in the definition", () => {
+    const sd = section("Acceptance Criteria", {
+      alternatives: ["AC", "ACs"],
+      extract: (q) => q.selectAll("listItem"),
+    });
+    expect(sd.alternatives).toEqual(["AC", "ACs"]);
+  });
+
+  it("uses alternative heading when primary is missing", async () => {
+    const collection = await createTestCollection();
+    const doc = collection.createDocument({
+      id: "test/alt-heading",
+      content: "# Title\n\n## AC\n\n- item one\n- item two\n",
+    });
+
+    const TestModel = {
+      name: "Test",
+      prefix: "test",
+      meta: z.looseObject({}),
+      schema: z.looseObject({}),
+      sections: {
+        criteria: section("Acceptance Criteria", {
+          alternatives: ["AC", "ACs"],
+          extract: (q) => q.selectAll("listItem").map((n) => toString(n)),
+        }),
+      },
+      relationships: {},
+      computed: {},
+    } as any;
+
+    const instance = createModelInstance(doc, TestModel, collection);
+    expect(instance.sections.criteria).toEqual(["item one", "item two"]);
+  });
+
+  it("primary heading takes precedence over alternatives", async () => {
+    const collection = await createTestCollection();
+    const doc = collection.createDocument({
+      id: "test/both-headings",
+      content:
+        "# Title\n\n## Acceptance Criteria\n\n- primary item\n\n## AC\n\n- alt item\n",
+    });
+
+    const TestModel = {
+      name: "Test",
+      prefix: "test",
+      meta: z.looseObject({}),
+      schema: z.looseObject({}),
+      sections: {
+        criteria: section("Acceptance Criteria", {
+          alternatives: ["AC"],
+          extract: (q) => q.selectAll("listItem").map((n) => toString(n)),
+        }),
+      },
+      relationships: {},
+      computed: {},
+    } as any;
+
+    const instance = createModelInstance(doc, TestModel, collection);
+    expect(instance.sections.criteria).toEqual(["primary item"]);
+  });
+
   it("missing section returns empty data", async () => {
     const collection = await createTestCollection();
     const doc = collection.createDocument({

package/test/table-of-contents.test.ts

@@ -12,8 +12,8 @@ describe("Collection.tableOfContents", () => {
   it("generates markdown with model group headings", () => {
     const toc = collection.tableOfContents();
 
-    expect(toc).toContain("# Epic");
-    expect(toc).toContain("# Story");
+    expect(toc).toContain("## Epics");
+    expect(toc).toContain("## Stories");
   });
 
   it("includes document titles as link text", () => {
@@ -41,8 +41,8 @@ describe("Collection.tableOfContents", () => {
 
     expect(toc).toContain("# Project Docs");
     // Model group headings shift to h2
-    expect(toc).toContain("## Epic");
-    expect(toc).toContain("## Story");
+    expect(toc).toContain("## Epics");
+    expect(toc).toContain("## Stories");
   });
 
   it("sorts items alphabetically within groups", () => {
@@ -70,7 +70,7 @@ describe("Collection.tableOfContents", () => {
   });
 
   it("works without models registered (flat list)", async () => {
-    const bare = new Collection({ rootPath: FIXTURES_PATH });
+    const bare = new Collection({ rootPath: FIXTURES_PATH, autoDiscover: false });
     await bare.load();
 
     const toc = bare.tableOfContents();
@@ -89,3 +89,47 @@ describe("Collection.tableOfContents", () => {
     );
   });
 });
+
+describe("Collection.renderFileTree", () => {
+  it("renders a tree with directory structure", () => {
+    const tree = collection.renderFileTree();
+
+    expect(tree).toContain("epics/");
+    expect(tree).toContain("stories/");
+    expect(tree).toContain("authentication.mdx");
+  });
+
+  it("nests files under their directories", () => {
+    const tree = collection.renderFileTree();
+    const lines = tree.split("\n");
+
+    // Find the stories directory line and the nested file
+    const storiesLine = lines.findIndex((l) => l.includes("stories/"));
+    const nestedFile = lines.findIndex((l) =>
+      l.includes("a-user-should-be-able-to-register.mdx")
+    );
+
+    expect(storiesLine).toBeGreaterThanOrEqual(0);
+    expect(nestedFile).toBeGreaterThan(storiesLine);
+  });
+
+  it("uses tree connector characters", () => {
+    const tree = collection.renderFileTree();
+
+    expect(tree).toMatch(/[├└]/);
+    expect(tree).toMatch(/──/);
+  });
+
+  it("ends with a newline", () => {
+    const tree = collection.renderFileTree();
+    expect(tree.endsWith("\n")).toBe(true);
+  });
+
+  it("throws if collection not loaded", () => {
+    const unloaded = new Collection({ rootPath: FIXTURES_PATH });
+
+    expect(() => unloaded.renderFileTree()).toThrow(
+      "Collection has not been loaded"
+    );
+  });
+});