contentbase 0.0.4 → 0.0.5

package/test/relationships.test.ts

@@ -1,214 +0,0 @@
-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";
-
-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("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;
-
-  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,160 +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("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({
-      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,135 +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("## Epics");
-    expect(toc).toContain("## Stories");
-  });
-
-  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("## Epics");
-    expect(toc).toContain("## Stories");
-  });
-
-  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, autoDiscover: false });
-    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"
-    );
-  });
-});
-
-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"
-    );
-  });
-});

package/test/validator.test.ts

@@ -1,62 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { validateDocument } from "../src/validator";
-import { Collection } from "../src/collection";
-import { createTestCollection } from "./helpers";
-import { Epic, Story } from "./fixtures/sdlc/models";
-
-describe("validateDocument", () => {
-  let collection: Collection;
-
-  beforeEach(async () => {
-    collection = await createTestCollection();
-  });
-
-  it("returns valid for good meta", () => {
-    const doc = collection.document("epics/authentication");
-    const result = validateDocument(doc, Epic);
-    expect(result.valid).toBe(true);
-    expect(result.errors.length).toBe(0);
-  });
-
-  it("returns errors for invalid meta", () => {
-    const doc = collection.createDocument({
-      id: "test/bad",
-      content: "# Bad\n",
-      meta: { status: "BOGUS" },
-    });
-    const result = validateDocument(doc, Epic);
-    expect(result.valid).toBe(false);
-    expect(result.errors.length).toBeGreaterThan(0);
-  });
-
-  it("applies defaults before validation", () => {
-    const doc = collection.createDocument({
-      id: "test/defaults",
-      content: "# Defaults\n",
-      meta: {},
-    });
-    const result = validateDocument(doc, Epic);
-    expect(result.valid).toBe(true);
-  });
-
-  it("validates sections when schema is present", () => {
-    const doc = collection.document(
-      "stories/authentication/a-user-should-be-able-to-register"
-    );
-    const result = validateDocument(doc, Story);
-    expect(result.valid).toBe(true);
-  });
-
-  it("section validation errors include section key in path", () => {
-    const doc = collection.createDocument({
-      id: "test/bad-section",
-      content: "# Bad\n\n## Acceptance Criteria\n\nNo list items here.\n",
-      meta: { status: "created" },
-    });
-    const result = validateDocument(doc, Story);
-    // acceptanceCriteria extracts listItems; paragraph text won't produce any
-    // The schema is z.array(z.string()) which allows empty arrays
-    // so this should actually pass - the extract returns []
-    expect(result.valid).toBe(true);
-  });
-});

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "esModuleInterop": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "types": ["bun-types"],
-    "skipLibCheck": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist", "test"]
-}

package/vitest.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  resolve: {
-    extensions: [".ts", ".js", ".mjs"],
-  },
-  test: {
-    globals: true,
-    include: ["test/**/*.test.ts"],
-  },
-});