contentbase 0.0.2 → 0.0.4

package/test/pattern.test.ts

@@ -0,0 +1,191 @@
+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);
+  });
+});

package/test/query-dsl.test.ts

@@ -0,0 +1,431 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  queryDSLSchema,
+  parseWhereClause,
+  parseSortClause,
+  executeQueryDSL,
+} from "../src/query/query-dsl";
+import { Collection } from "../src/collection";
+import { createTestCollection } from "./helpers";
+import { Epic } from "./fixtures/sdlc/models";
+
+// ---------------------------------------------------------------------------
+// Schema validation
+// ---------------------------------------------------------------------------
+
+describe("queryDSLSchema", () => {
+  it("validates a minimal query", () => {
+    const result = queryDSLSchema.safeParse({ model: "Epic" });
+    expect(result.success).toBe(true);
+  });
+
+  it("validates a full query", () => {
+    const result = queryDSLSchema.safeParse({
+      model: "Epic",
+      where: { "meta.status": "created", "meta.priority": { $gt: 3 } },
+      sort: { "meta.priority": "desc" },
+      select: ["id", "title"],
+      limit: 10,
+      offset: 5,
+      method: "fetchAll",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects missing model", () => {
+    const result = queryDSLSchema.safeParse({ where: {} });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects negative limit", () => {
+    const result = queryDSLSchema.safeParse({ model: "Epic", limit: -1 });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects negative offset", () => {
+    const result = queryDSLSchema.safeParse({ model: "Epic", offset: -1 });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects non-integer limit", () => {
+    const result = queryDSLSchema.safeParse({ model: "Epic", limit: 1.5 });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects invalid method", () => {
+    const result = queryDSLSchema.safeParse({
+      model: "Epic",
+      method: "deleteAll",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("defaults method to fetchAll", () => {
+    const result = queryDSLSchema.parse({ model: "Epic" });
+    expect(result.method).toBe("fetchAll");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseWhereClause
+// ---------------------------------------------------------------------------
+
+describe("parseWhereClause", () => {
+  it("converts literal string to eq condition", () => {
+    const conditions = parseWhereClause({ "meta.status": "active" });
+    expect(conditions).toEqual([
+      { path: "meta.status", operator: "eq", value: "active" },
+    ]);
+  });
+
+  it("converts literal number to eq condition", () => {
+    const conditions = parseWhereClause({ "meta.count": 5 });
+    expect(conditions).toEqual([
+      { path: "meta.count", operator: "eq", value: 5 },
+    ]);
+  });
+
+  it("converts literal boolean to eq condition", () => {
+    const conditions = parseWhereClause({ "meta.active": true });
+    expect(conditions).toEqual([
+      { path: "meta.active", operator: "eq", value: true },
+    ]);
+  });
+
+  it("converts null to eq condition", () => {
+    const conditions = parseWhereClause({ "meta.field": null });
+    expect(conditions).toEqual([
+      { path: "meta.field", operator: "eq", value: null },
+    ]);
+  });
+
+  it("converts array to in condition", () => {
+    const conditions = parseWhereClause({
+      "meta.status": ["active", "draft"],
+    });
+    expect(conditions).toEqual([
+      { path: "meta.status", operator: "in", value: ["active", "draft"] },
+    ]);
+  });
+
+  it("converts operator object to condition", () => {
+    const conditions = parseWhereClause({
+      "meta.priority": { $gt: 5 },
+    });
+    expect(conditions).toEqual([
+      { path: "meta.priority", operator: "gt", value: 5 },
+    ]);
+  });
+
+  it("handles multiple operators on the same path", () => {
+    const conditions = parseWhereClause({
+      "meta.priority": { $gte: 3, $lte: 8 },
+    });
+    expect(conditions).toEqual([
+      { path: "meta.priority", operator: "gte", value: 3 },
+      { path: "meta.priority", operator: "lte", value: 8 },
+    ]);
+  });
+
+  it("handles mixed literal and operator values", () => {
+    const conditions = parseWhereClause({
+      "meta.status": "active",
+      "meta.priority": { $gt: 5 },
+      title: { $contains: "Auth" },
+    });
+    expect(conditions.length).toBe(3);
+    expect(conditions[0].operator).toBe("eq");
+    expect(conditions[1].operator).toBe("gt");
+    expect(conditions[2].operator).toBe("contains");
+  });
+
+  it("supports all operators", () => {
+    const ops = [
+      "$eq",
+      "$neq",
+      "$in",
+      "$notIn",
+      "$gt",
+      "$lt",
+      "$gte",
+      "$lte",
+      "$contains",
+      "$startsWith",
+      "$endsWith",
+      "$regex",
+      "$exists",
+    ];
+    for (const op of ops) {
+      const conditions = parseWhereClause({
+        field: { [op]: "value" },
+      });
+      expect(conditions.length).toBe(1);
+    }
+  });
+
+  it("throws on unknown operator", () => {
+    expect(() =>
+      parseWhereClause({ field: { $unknown: "value" } }),
+    ).toThrow("Unknown operator: $unknown");
+  });
+
+  it("throws on regex pattern exceeding max length", () => {
+    const longPattern = "a".repeat(201);
+    expect(() =>
+      parseWhereClause({ field: { $regex: longPattern } }),
+    ).toThrow("Regex pattern exceeds maximum length");
+  });
+
+  it("rejects __proto__ path segment", () => {
+    expect(() =>
+      parseWhereClause({ "__proto__.polluted": "value" }),
+    ).toThrow('Forbidden path segment "__proto__"');
+  });
+
+  it("rejects constructor path segment", () => {
+    expect(() =>
+      parseWhereClause({ "meta.constructor.name": "value" }),
+    ).toThrow('Forbidden path segment "constructor"');
+  });
+
+  it("rejects prototype path segment", () => {
+    expect(() =>
+      parseWhereClause({ "prototype.method": "value" }),
+    ).toThrow('Forbidden path segment "prototype"');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseSortClause
+// ---------------------------------------------------------------------------
+
+describe("parseSortClause", () => {
+  it("parses object form", () => {
+    const sorts = parseSortClause({ "meta.priority": "desc", title: "asc" });
+    expect(sorts).toEqual([
+      { path: "meta.priority", direction: "desc" },
+      { path: "title", direction: "asc" },
+    ]);
+  });
+
+  it("passes through array form", () => {
+    const input = [{ path: "title", direction: "asc" as const }];
+    const sorts = parseSortClause(input);
+    expect(sorts).toEqual(input);
+  });
+
+  it("returns empty array for undefined", () => {
+    expect(parseSortClause(undefined)).toEqual([]);
+  });
+
+  it("returns empty array for null", () => {
+    expect(parseSortClause(null)).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// executeQueryDSL — integration tests
+// ---------------------------------------------------------------------------
+
+describe("executeQueryDSL", () => {
+  let collection: Collection;
+
+  beforeEach(async () => {
+    collection = await createTestCollection();
+  });
+
+  it("returns all instances of a model", async () => {
+    const results = await executeQueryDSL(collection, {
+      model: "Epic",
+      method: "fetchAll",
+    });
+    expect(Array.isArray(results)).toBe(true);
+    expect((results as any[]).length).toBe(2);
+  });
+
+  it("filters with implicit $eq", async () => {
+    const results = await executeQueryDSL(collection, {
+      model: "Epic",
+      where: { "meta.priority": "high" },
+      method: "fetchAll",
+    });
+    expect((results as any[]).length).toBe(1);
+    expect((results as any[])[0].meta.priority).toBe("high");
+  });
+
+  it("filters with $exists", async () => {
+    const results = await executeQueryDSL(collection, {
+      model: "Epic",
+      where: { "meta.priority": { $exists: true } },
+      method: "fetchAll",
+    });
+    expect((results as any[]).length).toBe(1);
+  });
+
+  it("filters with $contains on title", async () => {
+    const results = await executeQueryDSL(collection, {
+      model: "Epic",
+      where: { title: { $contains: "Authentication" } },
+      method: "fetchAll",
+    });
+    expect((results as any[]).length).toBe(1);
+  });
+
+  it("sorts results", async () => {
+    const results = await executeQueryDSL(collection, {
+      model: "Epic",
+      sort: { title: "desc" },
+      method: "fetchAll",
+    }) as any[];
+    expect(results[0].title.localeCompare(results[1].title)).toBeGreaterThan(0);
+  });
+
+  it("applies limit", async () => {
+    const results = await executeQueryDSL(collection, {
+      model: "Epic",
+      limit: 1,
+      method: "fetchAll",
+    });
+    expect((results as any[]).length).toBe(1);
+  });
+
+  it("applies offset", async () => {
+    const all = await executeQueryDSL(collection, {
+      model: "Epic",
+      sort: { title: "asc" },
+      method: "fetchAll",
+    }) as any[];
+
+    const offsetResults = await executeQueryDSL(collection, {
+      model: "Epic",
+      sort: { title: "asc" },
+      offset: 1,
+      method: "fetchAll",
+    }) as any[];
+
+    expect(offsetResults.length).toBe(1);
+    expect(offsetResults[0].title).toBe(all[1].title);
+  });
+
+  it("applies limit + offset for pagination", async () => {
+    const all = await executeQueryDSL(collection, {
+      model: "Epic",
+      sort: { title: "asc" },
+      method: "fetchAll",
+    }) as any[];
+
+    const page = await executeQueryDSL(collection, {
+      model: "Epic",
+      sort: { title: "asc" },
+      limit: 1,
+      offset: 1,
+      method: "fetchAll",
+    }) as any[];
+
+    expect(page.length).toBe(1);
+    expect(page[0].title).toBe(all[1].title);
+  });
+
+  it("method count returns count object", async () => {
+    const result = await executeQueryDSL(collection, {
+      model: "Epic",
+      method: "count",
+    });
+    expect(result).toEqual({ count: 2 });
+  });
+
+  it("method first returns single result", async () => {
+    const result = await executeQueryDSL(collection, {
+      model: "Epic",
+      method: "first",
+    });
+    expect(result).toBeDefined();
+    expect((result as any).title).toBeDefined();
+  });
+
+  it("method last returns single result", async () => {
+    const result = await executeQueryDSL(collection, {
+      model: "Epic",
+      method: "last",
+    });
+    expect(result).toBeDefined();
+    expect((result as any).title).toBeDefined();
+  });
+
+  it("select filters output fields", async () => {
+    const results = await executeQueryDSL(collection, {
+      model: "Epic",
+      select: ["id", "title"],
+      method: "fetchAll",
+    }) as any[];
+
+    for (const r of results) {
+      expect(Object.keys(r)).toEqual(["id", "title"]);
+    }
+  });
+
+  it("throws on unknown model", async () => {
+    await expect(
+      executeQueryDSL(collection, {
+        model: "NonExistent",
+        method: "fetchAll",
+      }),
+    ).rejects.toThrow("Unknown model: NonExistent");
+  });
+
+  it("resolves model by prefix", async () => {
+    const results = await executeQueryDSL(collection, {
+      model: "epics",
+      method: "fetchAll",
+    });
+    expect((results as any[]).length).toBe(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// CollectionQuery limit/offset
+// ---------------------------------------------------------------------------
+
+describe("CollectionQuery limit/offset", () => {
+  let collection: Collection;
+
+  beforeEach(async () => {
+    collection = await createTestCollection();
+  });
+
+  it("limit restricts results", async () => {
+    const results = await collection
+      .query(Epic)
+      .limit(1)
+      .fetchAll();
+    expect(results.length).toBe(1);
+  });
+
+  it("offset skips results", async () => {
+    const all = await collection.query(Epic).sort("title").fetchAll();
+    const offset = await collection
+      .query(Epic)
+      .sort("title")
+      .offset(1)
+      .fetchAll();
+    expect(offset.length).toBe(1);
+    expect(offset[0].title).toBe(all[1].title);
+  });
+
+  it("limit(0) returns empty array", async () => {
+    const results = await collection.query(Epic).limit(0).fetchAll();
+    expect(results.length).toBe(0);
+  });
+
+  it("limit + offset chain together", async () => {
+    const all = await collection.query(Epic).sort("title").fetchAll();
+    const page = await collection
+      .query(Epic)
+      .sort("title")
+      .offset(1)
+      .limit(1)
+      .fetchAll();
+    expect(page.length).toBe(1);
+    expect(page[0].title).toBe(all[1].title);
+  });
+});

package/test/query.test.ts

@@ -164,4 +164,33 @@ describe("CollectionQuery", () => {
     const all = await collection.query(Epic).fetchAll();
     expect(all.length).toBe(2);
   });
+
+  it("sort orders results ascending by default", async () => {
+    const epics = await collection.query(Epic).sort("title").fetchAll();
+    expect(epics.length).toBe(2);
+    expect(epics[0].title.localeCompare(epics[1].title)).toBeLessThan(0);
+  });
+
+  it("sort orders results descending", async () => {
+    const epics = await collection.query(Epic).sort("title", "desc").fetchAll();
+    expect(epics.length).toBe(2);
+    expect(epics[0].title.localeCompare(epics[1].title)).toBeGreaterThan(0);
+  });
+
+  it("sort handles null values (pushed to end in asc)", async () => {
+    // authentication has priority "high", searching-and-browsing has no priority
+    const epics = await collection.query(Epic).sort("meta.priority").fetchAll();
+    expect(epics[0].meta.priority).toBe("high");
+    expect(epics[1].meta.priority).toBeUndefined();
+  });
+
+  it("sort chains with where", async () => {
+    const epics = await collection
+      .query(Epic)
+      .where("meta.status", "created")
+      .sort("title", "desc")
+      .fetchAll();
+    expect(epics.length).toBe(2);
+    expect(epics[0].title.localeCompare(epics[1].title)).toBeGreaterThan(0);
+  });
 });