contentbase 0.0.4 → 0.0.6

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/pattern.test.ts

@@ -1,191 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { matchPattern, matchPatterns } from "../src/utils/match-pattern";
-import { defineModel, z } from "../src/index";
-import { createModelInstance } from "../src/model-instance";
-import { validateDocument } from "../src/validator";
-import { Collection } from "../src/collection";
-import { createTestCollection } from "./helpers";
-
-describe("matchPattern", () => {
-  it("extracts named params from matching path", () => {
-    const result = matchPattern("plans/:project/:slug", "plans/acme/launch");
-    expect(result).toEqual({ project: "acme", slug: "launch" });
-  });
-
-  it("returns null on literal segment mismatch", () => {
-    const result = matchPattern("plans/:project/:slug", "stories/acme/launch");
-    expect(result).toBeNull();
-  });
-
-  it("returns null on segment count mismatch (too few)", () => {
-    const result = matchPattern("plans/:project/:slug", "plans/acme");
-    expect(result).toBeNull();
-  });
-
-  it("returns null on segment count mismatch (too many)", () => {
-    const result = matchPattern("plans/:project/:slug", "plans/acme/launch/extra");
-    expect(result).toBeNull();
-  });
-
-  it("matches literal-only pattern", () => {
-    const result = matchPattern("plans/acme/launch", "plans/acme/launch");
-    expect(result).toEqual({});
-  });
-
-  it("returns null for literal-only mismatch", () => {
-    const result = matchPattern("plans/acme/launch", "plans/acme/other");
-    expect(result).toBeNull();
-  });
-
-  it("handles single-segment patterns", () => {
-    const result = matchPattern(":slug", "my-doc");
-    expect(result).toEqual({ slug: "my-doc" });
-  });
-
-  it("handles leading/trailing slashes gracefully", () => {
-    const result = matchPattern("/plans/:slug/", "/plans/launch/");
-    expect(result).toEqual({ slug: "launch" });
-  });
-});
-
-describe("matchPatterns", () => {
-  it("accepts a single pattern string", () => {
-    const result = matchPatterns("plans/:project/:slug", "plans/acme/launch");
-    expect(result).toEqual({ project: "acme", slug: "launch" });
-  });
-
-  it("returns first matching pattern from array", () => {
-    const result = matchPatterns(
-      ["docs/:category/:slug", "plans/:project/:slug"],
-      "plans/acme/launch"
-    );
-    expect(result).toEqual({ project: "acme", slug: "launch" });
-  });
-
-  it("skips non-matching patterns", () => {
-    const result = matchPatterns(
-      ["docs/:category/:slug", "plans/:project/:slug"],
-      "plans/acme/launch"
-    );
-    // First pattern doesn't match (docs != plans), second does
-    expect(result).toEqual({ project: "acme", slug: "launch" });
-  });
-
-  it("returns null when no patterns match", () => {
-    const result = matchPatterns(
-      ["docs/:slug", "plans/:slug"],
-      "stories/my-story"
-    );
-    expect(result).toBeNull();
-  });
-
-  it("returns first match when multiple patterns could match", () => {
-    const result = matchPatterns(
-      ["things/:a/:b", "things/:x/:y"],
-      "things/foo/bar"
-    );
-    expect(result).toEqual({ a: "foo", b: "bar" });
-  });
-});
-
-describe("pattern integration", () => {
-  let collection: Collection;
-
-  beforeEach(async () => {
-    collection = await createTestCollection();
-  });
-
-  const Plan = defineModel("Plan", {
-    prefix: "plans",
-    pattern: "plans/:project/:slug",
-    meta: z.object({
-      project: z.string(),
-      status: z.enum(["draft", "active"]).default("draft"),
-    }),
-  });
-
-  it("infers meta from path pattern via createModelInstance", () => {
-    const doc = collection.createDocument({
-      id: "plans/acme/launch",
-      content: "# Launch Plan\n",
-      meta: {},
-    });
-    const instance = createModelInstance(doc, Plan, collection);
-    expect(instance.meta.project).toBe("acme");
-    expect(instance.meta.status).toBe("draft");
-  });
-
-  it("frontmatter overrides pattern-inferred values", () => {
-    const doc = collection.createDocument({
-      id: "plans/acme/launch",
-      content: "# Launch Plan\n",
-      meta: { project: "override-corp" },
-    });
-    const instance = createModelInstance(doc, Plan, collection);
-    expect(instance.meta.project).toBe("override-corp");
-  });
-
-  it("defaults < pattern < frontmatter priority chain", () => {
-    const ModelWithDefaults = defineModel("ModelWithDefaults", {
-      prefix: "items",
-      pattern: "items/:category/:slug",
-      meta: z.object({
-        category: z.string().default("uncategorized"),
-        slug: z.string().optional(),
-        tag: z.string().default("none"),
-      }),
-      defaults: { category: "default-cat", tag: "default-tag" },
-    });
-
-    const doc = collection.createDocument({
-      id: "items/electronics/phone",
-      content: "# Phone\n",
-      meta: { tag: "frontmatter-tag" },
-    });
-    const instance = createModelInstance(doc, ModelWithDefaults, collection);
-
-    // category: defaults="default-cat", pattern="electronics", frontmatter=absent → "electronics"
-    expect(instance.meta.category).toBe("electronics");
-    // tag: defaults="default-tag", pattern=absent, frontmatter="frontmatter-tag" → "frontmatter-tag"
-    expect(instance.meta.tag).toBe("frontmatter-tag");
-  });
-
-  it("no pattern means no change in behavior", () => {
-    const NoPattern = defineModel("NoPattern", {
-      prefix: "things",
-      meta: z.object({
-        status: z.string().default("new"),
-      }),
-    });
-
-    const doc = collection.createDocument({
-      id: "things/foo",
-      content: "# Foo\n",
-      meta: {},
-    });
-    const instance = createModelInstance(doc, NoPattern, collection);
-    expect(instance.meta.status).toBe("new");
-  });
-
-  it("validateDocument uses pattern-inferred values", () => {
-    const doc = collection.createDocument({
-      id: "plans/acme/launch",
-      content: "# Launch Plan\n",
-      meta: {},
-    });
-    const result = validateDocument(doc, Plan);
-    // project is inferred from pattern, status gets default → should be valid
-    expect(result.valid).toBe(true);
-  });
-
-  it("validateDocument fails when pattern doesn't match and required field missing", () => {
-    const doc = collection.createDocument({
-      id: "other/something",
-      content: "# Something\n",
-      meta: {},
-    });
-    const result = validateDocument(doc, Plan);
-    // pattern won't match, project is required with no default → should fail
-    expect(result.valid).toBe(false);
-  });
-});