contentbase 0.0.2 → 0.0.5

package/test/model-instance.test.ts

@@ -1,197 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { Collection } from "../src/collection";
-import { createModelInstance } from "../src/model-instance";
-import { createTestCollection } from "./helpers";
-import { Epic, Story } from "./fixtures/sdlc/models";
-
-describe("createModelInstance", () => {
-  let collection: Collection;
-
-  beforeEach(async () => {
-    collection = await createTestCollection();
-  });
-
-  describe("core properties", () => {
-    it("has correct id", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      expect(instance.id).toBe("epics/authentication");
-    });
-
-    it("has correct title", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      expect(instance.title).toBe("Authentication");
-    });
-
-    it("has correct slug", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      expect(instance.slug).toBe("authentication");
-    });
-
-    it("references the original document", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      expect(instance.document).toBe(doc);
-    });
-
-    it("references the collection", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      expect(instance.collection).toBe(collection);
-    });
-  });
-
-  describe("meta", () => {
-    it("returns Zod-parsed frontmatter", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      expect(instance.meta.priority).toBe("high");
-      expect(instance.meta.status).toBe("created");
-    });
-
-    it("applies defaults where fields are missing", () => {
-      const doc = collection.document("epics/searching-and-browsing");
-      const instance = createModelInstance(doc, Epic, collection);
-      expect(instance.meta.status).toBe("created");
-    });
-  });
-
-  describe("sections", () => {
-    it("lazily extracts section data", () => {
-      const doc = collection.document(
-        "stories/authentication/a-user-should-be-able-to-register"
-      );
-      const instance = createModelInstance(doc, Story, collection);
-      const criteria = instance.sections.acceptanceCriteria;
-      expect(Array.isArray(criteria)).toBe(true);
-      expect(criteria.length).toBe(4);
-    });
-
-    it("extracts mockups as record", () => {
-      const doc = collection.document(
-        "stories/authentication/a-user-should-be-able-to-register"
-      );
-      const instance = createModelInstance(doc, Story, collection);
-      const mockups = instance.sections.mockups;
-      expect(typeof mockups).toBe("object");
-      expect(Object.keys(mockups).length).toBeGreaterThan(0);
-    });
-  });
-
-  describe("computed", () => {
-    it("evaluates computed properties", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      expect(instance.computed.isComplete).toBe(false);
-    });
-  });
-
-  describe("relationships", () => {
-    it("hasMany fetchAll returns related instances", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      const stories = instance.relationships.stories.fetchAll();
-      expect(stories.length).toBe(2);
-      expect(stories[0].title).toBeDefined();
-    });
-
-    it("hasMany first returns first child", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      const first = instance.relationships.stories.first();
-      expect(first).toBeDefined();
-      expect(first!.title).toContain("register");
-    });
-
-    it("hasMany last returns last child", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      const last = instance.relationships.stories.last();
-      expect(last).toBeDefined();
-      expect(last!.title).toContain("login");
-    });
-
-    it("belongsTo fetch returns parent", () => {
-      const doc = collection.document(
-        "stories/authentication/a-user-should-be-able-to-register"
-      );
-      const instance = createModelInstance(doc, Story, collection);
-      const epic = instance.relationships.epic.fetch();
-      expect(epic.title).toBe("Authentication");
-    });
-  });
-
-  describe("validation", () => {
-    it("returns valid for good data", async () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      const result = await instance.validate();
-      expect(result.valid).toBe(true);
-      expect(result.errors.length).toBe(0);
-    });
-
-    it("returns errors for bad meta", async () => {
-      const doc = collection.createDocument({
-        id: "test/bad",
-        content: "# Bad Doc\n",
-        meta: { status: "INVALID_STATUS" },
-      });
-      const instance = createModelInstance(doc, Epic, collection);
-      const result = await instance.validate();
-      expect(result.valid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-
-    it("populates errors map", async () => {
-      const doc = collection.createDocument({
-        id: "test/bad",
-        content: "# Bad Doc\n",
-        meta: { status: "INVALID_STATUS" },
-      });
-      const instance = createModelInstance(doc, Epic, collection);
-      await instance.validate();
-      expect(instance.hasErrors).toBe(true);
-      expect(instance.errors.size).toBeGreaterThan(0);
-    });
-  });
-
-  describe("toJSON", () => {
-    it("returns id, title, meta by default", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      const json = instance.toJSON();
-      expect(json.id).toBe("epics/authentication");
-      expect(json.title).toBe("Authentication");
-      expect(json.meta).toBeDefined();
-    });
-
-    it("includes requested sections", () => {
-      const doc = collection.document(
-        "stories/authentication/a-user-should-be-able-to-register"
-      );
-      const instance = createModelInstance(doc, Story, collection);
-      const json = instance.toJSON({
-        sections: ["acceptanceCriteria"],
-      });
-      expect(json.acceptanceCriteria).toBeDefined();
-      expect(Array.isArray(json.acceptanceCriteria)).toBe(true);
-    });
-
-    it("includes requested computed values", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      const json = instance.toJSON({ computed: ["isComplete"] });
-      expect(json.isComplete).toBe(false);
-    });
-
-    it("includes requested relationships", () => {
-      const doc = collection.document("epics/authentication");
-      const instance = createModelInstance(doc, Epic, collection);
-      const json = instance.toJSON({ related: ["stories"] });
-      expect(json.stories).toBeDefined();
-      expect(Array.isArray(json.stories)).toBe(true);
-    });
-  });
-});

package/test/query.test.ts

@@ -1,167 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { QueryBuilder } from "../src/query/query-builder";
-import { operators } from "../src/query/operators";
-import { Collection } from "../src/collection";
-import { createTestCollection } from "./helpers";
-import { Epic } from "./fixtures/sdlc/models";
-
-describe("QueryBuilder", () => {
-  it("builds eq conditions with two args", () => {
-    const qb = new QueryBuilder();
-    qb.where("meta.status", "active");
-    expect(qb.conditions).toEqual([
-      { path: "meta.status", operator: "eq", value: "active" },
-    ]);
-  });
-
-  it("builds conditions with explicit operator", () => {
-    const qb = new QueryBuilder();
-    qb.where("meta.count", "gt", 5);
-    expect(qb.conditions[0].operator).toBe("gt");
-    expect(qb.conditions[0].value).toBe(5);
-  });
-
-  it("builds conditions from object shorthand", () => {
-    const qb = new QueryBuilder();
-    qb.where({ "meta.status": "active", "meta.type": "post" });
-    expect(qb.conditions.length).toBe(2);
-  });
-
-  it("whereIn adds in condition", () => {
-    const qb = new QueryBuilder();
-    qb.whereIn("meta.tags", ["a", "b"]);
-    expect(qb.conditions[0].operator).toBe("in");
-  });
-
-  it("whereNotIn adds notIn condition", () => {
-    const qb = new QueryBuilder();
-    qb.whereNotIn("meta.status", ["archived"]);
-    expect(qb.conditions[0].operator).toBe("notIn");
-  });
-
-  it("supports all chainable methods", () => {
-    const qb = new QueryBuilder();
-    const result = qb
-      .where("a", "1")
-      .whereGt("b", 2)
-      .whereLt("c", 3)
-      .whereGte("d", 4)
-      .whereLte("e", 5)
-      .whereContains("f", "hello")
-      .whereStartsWith("g", "pre")
-      .whereEndsWith("h", "suf")
-      .whereRegex("i", /test/)
-      .whereExists("j")
-      .whereNotExists("k");
-
-    expect(result).toBe(qb); // chaining returns this
-    expect(qb.conditions.length).toBe(11);
-  });
-
-  it("where with three args returns this (bug fix)", () => {
-    const qb = new QueryBuilder();
-    const result = qb.where("path", "neq", "value");
-    expect(result).toBe(qb);
-  });
-});
-
-describe("operators", () => {
-  it("eq handles primitive equality", () => {
-    expect(operators.eq("a", "a")).toBe(true);
-    expect(operators.eq("a", "b")).toBe(false);
-    expect(operators.eq(1, 1)).toBe(true);
-  });
-
-  it("eq handles deep equality", () => {
-    expect(operators.eq({ a: 1 }, { a: 1 })).toBe(true);
-    expect(operators.eq({ a: 1 }, { a: 2 })).toBe(false);
-  });
-
-  it("neq is negation of eq", () => {
-    expect(operators.neq("a", "b")).toBe(true);
-    expect(operators.neq("a", "a")).toBe(false);
-  });
-
-  it("in checks membership", () => {
-    expect(operators.in("a", ["a", "b"])).toBe(true);
-    expect(operators.in("c", ["a", "b"])).toBe(false);
-  });
-
-  it("notIn checks non-membership", () => {
-    expect(operators.notIn("c", ["a", "b"])).toBe(true);
-    expect(operators.notIn("a", ["a", "b"])).toBe(false);
-  });
-
-  it("gt/lt/gte/lte compare values", () => {
-    expect(operators.gt(5, 3)).toBe(true);
-    expect(operators.lt(3, 5)).toBe(true);
-    expect(operators.gte(5, 5)).toBe(true);
-    expect(operators.lte(5, 5)).toBe(true);
-  });
-
-  it("contains checks string inclusion", () => {
-    expect(operators.contains("hello world", "world")).toBe(true);
-    expect(operators.contains("hello", "world")).toBe(false);
-  });
-
-  it("startsWith/endsWith check string prefixes/suffixes", () => {
-    expect(operators.startsWith("hello", "hel")).toBe(true);
-    expect(operators.endsWith("hello", "llo")).toBe(true);
-  });
-
-  it("regex tests patterns", () => {
-    expect(operators.regex("hello123", /\d+/)).toBe(true);
-    expect(operators.regex("hello123", "\\d+")).toBe(true);
-    expect(operators.regex("hello", /\d+/)).toBe(false);
-  });
-
-  it("exists checks for defined values", () => {
-    expect(operators.exists("value", true)).toBe(true);
-    expect(operators.exists(null, true)).toBe(false);
-    expect(operators.exists(undefined, true)).toBe(false);
-    expect(operators.exists(null, false)).toBe(true);
-  });
-});
-
-describe("CollectionQuery", () => {
-  let collection: Collection;
-
-  beforeEach(async () => {
-    collection = await createTestCollection();
-  });
-
-  it("fetchAll returns matching model instances", async () => {
-    const epics = await collection.query(Epic).fetchAll();
-    expect(epics.length).toBe(2);
-  });
-
-  it("where filters results", async () => {
-    const epics = await collection
-      .query(Epic)
-      .where("meta.priority", "high")
-      .fetchAll();
-    expect(epics.length).toBe(1);
-    expect(epics[0].meta.priority).toBe("high");
-  });
-
-  it("first returns first result", async () => {
-    const first = await collection.query(Epic).first();
-    expect(first).toBeDefined();
-    expect(first!.title).toBeDefined();
-  });
-
-  it("last returns last result", async () => {
-    const last = await collection.query(Epic).last();
-    expect(last).toBeDefined();
-  });
-
-  it("count returns correct count", async () => {
-    const count = await collection.query(Epic).count();
-    expect(count).toBe(2);
-  });
-
-  it("empty conditions returns all of model type", async () => {
-    const all = await collection.query(Epic).fetchAll();
-    expect(all.length).toBe(2);
-  });
-});

package/test/relationships.test.ts

@@ -1,84 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { Collection } from "../src/collection";
-import { createModelInstance } from "../src/model-instance";
-import { createTestCollection } from "./helpers";
-import { Epic, Story } from "./fixtures/sdlc/models";
-
-describe("HasManyRelationship", () => {
-  let collection: Collection;
-
-  beforeEach(async () => {
-    collection = await createTestCollection();
-  });
-
-  it("extracts child headings from parent section", () => {
-    const epic = collection.getModel("epics/authentication", Epic);
-    const stories = epic.relationships.stories.fetchAll();
-    expect(stories.length).toBe(2);
-  });
-
-  it("child instances have correct titles", () => {
-    const epic = collection.getModel("epics/authentication", Epic);
-    const stories = epic.relationships.stories.fetchAll();
-    expect(stories[0].title).toContain("register");
-    expect(stories[1].title).toContain("login");
-  });
-
-  it("first returns first child", () => {
-    const epic = collection.getModel("epics/authentication", Epic);
-    const first = epic.relationships.stories.first();
-    expect(first).toBeDefined();
-  });
-
-  it("last returns last child", () => {
-    const epic = collection.getModel("epics/authentication", Epic);
-    const last = epic.relationships.stories.last();
-    expect(last).toBeDefined();
-  });
-
-  it("works with epic that has multiple stories", () => {
-    const epic = collection.getModel(
-      "epics/searching-and-browsing",
-      Epic
-    );
-    const stories = epic.relationships.stories.fetchAll();
-    expect(stories.length).toBe(3);
-  });
-
-  it("computes IDs as targetPrefix/parentSlug/childSlug", () => {
-    const epic = collection.getModel("epics/authentication", Epic);
-    const stories = epic.relationships.stories.fetchAll();
-    expect(stories[0].id).toContain("stories/");
-    expect(stories[0].id).toContain("authentication");
-  });
-});
-
-describe("BelongsToRelationship", () => {
-  let collection: Collection;
-
-  beforeEach(async () => {
-    collection = await createTestCollection();
-  });
-
-  it("resolves parent by foreign key", () => {
-    const story = collection.getModel(
-      "stories/authentication/a-user-should-be-able-to-register",
-      Story
-    );
-    const epic = story.relationships.epic.fetch();
-    expect(epic.title).toBe("Authentication");
-    expect(epic.id).toBe("epics/authentication");
-  });
-
-  it("throws if parent not found", () => {
-    const doc = collection.createDocument({
-      id: "test/orphan",
-      content: "# Orphan Story\n",
-      meta: { epic: "nonexistent" },
-    });
-    const instance = createModelInstance(doc, Story, collection);
-    expect(() => instance.relationships.epic.fetch()).toThrow(
-      'Could not find Epic'
-    );
-  });
-});

package/test/section.test.ts

@@ -1,99 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { section } from "../src/section";
-import { Collection } from "../src/collection";
-import { createModelInstance } from "../src/model-instance";
-import { createTestCollection } from "./helpers";
-import { Story } from "./fixtures/sdlc/models";
-import { z } from "zod";
-import { toString } from "mdast-util-to-string";
-
-describe("section helper", () => {
-  it("creates a SectionDefinition with heading and extract", () => {
-    const sd = section("My Section", {
-      extract: (q) => q.selectAll("listItem"),
-    });
-    expect(sd.heading).toBe("My Section");
-    expect(sd.extract).toBeDefined();
-  });
-
-  it("stores optional schema", () => {
-    const schema = z.array(z.string());
-    const sd = section("Items", {
-      extract: (q) =>
-        q.selectAll("listItem").map((n) => toString(n)),
-      schema,
-    });
-    expect(sd.schema).toBe(schema);
-  });
-
-  it("extract receives AstQuery scoped to section content only", async () => {
-    const collection = await createTestCollection();
-    const doc = collection.document(
-      "stories/authentication/a-user-should-be-able-to-register"
-    );
-    const instance = createModelInstance(doc, Story, collection);
-
-    // acceptanceCriteria should only contain items from that section
-    const criteria = instance.sections.acceptanceCriteria;
-    expect(criteria.length).toBe(4);
-    expect(criteria[0]).toContain("signup form");
-  });
-
-  it("section data is lazily computed", async () => {
-    const collection = await createTestCollection();
-    const doc = collection.document(
-      "stories/authentication/a-user-should-be-able-to-register"
-    );
-
-    let extractCalled = 0;
-    const TestModel = {
-      name: "Test",
-      prefix: "test",
-      meta: z.looseObject({}),
-      schema: z.looseObject({}),
-      sections: {
-        items: section("Acceptance Criteria", {
-          extract: (q) => {
-            extractCalled++;
-            return q.selectAll("listItem").map((n) => toString(n));
-          },
-        }),
-      },
-      relationships: {},
-      computed: {},
-    } as any;
-
-    const instance = createModelInstance(doc, TestModel, collection);
-    expect(extractCalled).toBe(0); // Not yet accessed
-    const _items = instance.sections.items;
-    expect(extractCalled).toBe(1); // Now extracted
-    const _items2 = instance.sections.items;
-    expect(extractCalled).toBe(1); // Cached
-  });
-
-  it("missing section returns empty data", async () => {
-    const collection = await createTestCollection();
-    const doc = collection.createDocument({
-      id: "test/no-section",
-      content: "# Just a title\n\nSome content.\n",
-    });
-
-    const TestModel = {
-      name: "Test",
-      prefix: "test",
-      meta: z.looseObject({}),
-      schema: z.looseObject({}),
-      sections: {
-        missing: section("Nonexistent Section", {
-          extract: (q) => q.selectAll("listItem").map((n) => toString(n)),
-        }),
-      },
-      relationships: {},
-      computed: {},
-    } as any;
-
-    const instance = createModelInstance(doc, TestModel, collection);
-    // Should not crash, just return empty
-    expect(instance.sections.missing).toEqual([]);
-  });
-});

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

@@ -1,91 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { Collection } from "../src/collection";
-import { createTestCollection, FIXTURES_PATH } from "./helpers";
-
-let collection: Collection;
-
-beforeEach(async () => {
-  collection = await createTestCollection();
-});
-
-describe("Collection.tableOfContents", () => {
-  it("generates markdown with model group headings", () => {
-    const toc = collection.tableOfContents();
-
-    expect(toc).toContain("# Epic");
-    expect(toc).toContain("# Story");
-  });
-
-  it("includes document titles as link text", () => {
-    const toc = collection.tableOfContents();
-
-    expect(toc).toContain("[Authentication]");
-    expect(toc).toContain("[Searching And Browsing]");
-  });
-
-  it("generates relative links with file extensions", () => {
-    const toc = collection.tableOfContents();
-
-    expect(toc).toContain("(./epics/authentication.mdx)");
-    expect(toc).toContain("(./epics/searching-and-browsing.mdx)");
-  });
-
-  it("uses custom basePath for links", () => {
-    const toc = collection.tableOfContents({ basePath: "./content" });
-
-    expect(toc).toContain("(./content/epics/authentication.mdx)");
-  });
-
-  it("adds a title heading when provided", () => {
-    const toc = collection.tableOfContents({ title: "Project Docs" });
-
-    expect(toc).toContain("# Project Docs");
-    // Model group headings shift to h2
-    expect(toc).toContain("## Epic");
-    expect(toc).toContain("## Story");
-  });
-
-  it("sorts items alphabetically within groups", () => {
-    const toc = collection.tableOfContents();
-    const authIndex = toc.indexOf("[Authentication]");
-    const searchIndex = toc.indexOf("[Searching And Browsing]");
-
-    expect(authIndex).toBeLessThan(searchIndex);
-  });
-
-  it("formats entries as markdown list items", () => {
-    const toc = collection.tableOfContents();
-    const lines = toc.split("\n");
-    const listLines = lines.filter((l) => l.startsWith("- ["));
-
-    expect(listLines.length).toBeGreaterThanOrEqual(3);
-    for (const line of listLines) {
-      expect(line).toMatch(/^- \[.+\]\(.+\.mdx?\)$/);
-    }
-  });
-
-  it("ends with a newline", () => {
-    const toc = collection.tableOfContents();
-    expect(toc.endsWith("\n")).toBe(true);
-  });
-
-  it("works without models registered (flat list)", async () => {
-    const bare = new Collection({ rootPath: FIXTURES_PATH });
-    await bare.load();
-
-    const toc = bare.tableOfContents();
-
-    // No group headings — just list items
-    expect(toc).not.toContain("# Epic");
-    expect(toc).toContain("- [");
-    expect(toc).toContain("(./epics/authentication.mdx)");
-  });
-
-  it("throws if collection not loaded", () => {
-    const unloaded = new Collection({ rootPath: FIXTURES_PATH });
-
-    expect(() => unloaded.tableOfContents()).toThrow(
-      "Collection has not been loaded"
-    );
-  });
-});