contentbase 0.0.4 → 0.0.6

package/test/query-dsl.test.ts

@@ -1,431 +0,0 @@
-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

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