@fireproof/core-test 0.23.1 → 0.23.2

package/fireproof/query-docs.test.ts

@@ -1,117 +0,0 @@
-import { Database, DocWithId, fireproof } from "@fireproof/core";
-import { describe, beforeEach, afterEach, it, expect } from "vitest";
-
-interface TestDoc {
-  text: string;
-  category: string;
-  active: boolean;
-}
-
-describe("query return value consistency", function () {
-  let db: Database;
-
-  beforeEach(async () => {
-    db = fireproof("test-query-docs");
-
-    // Add test documents
-    await db.put({ _id: "doc1", text: "hello world", category: "greeting", active: true });
-    await db.put({ _id: "doc2", text: "goodbye world", category: "farewell", active: true });
-    await db.put({ _id: "doc3", text: "hello again", category: "greeting", active: false });
-  });
-
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-  });
-
-  it("database query should return docs property like useLiveQuery", async function () {
-    // This test should initially fail because the query method doesn't return docs yet
-    const result = await db.query<TestDoc>("category");
-
-    // Check that rows property exists (this should pass)
-    expect(result).toHaveProperty("rows");
-    expect(result.rows.length).toBe(3);
-
-    // Check that docs property exists (this should fail until we implement the feature)
-    expect(result).toHaveProperty("docs");
-    expect(Array.isArray(result.docs)).toBe(true);
-    expect(result.docs.length).toBe(3);
-
-    // Verify docs contain the correct document data
-    const docIds = result.docs.map((doc) => doc._id).sort();
-    expect(docIds).toEqual(["doc1", "doc2", "doc3"]);
-  });
-
-  it("should return docs with the same order as rows", async function () {
-    const result = await db.query<TestDoc>("category");
-
-    // Ensure docs array exists
-    expect(result).toHaveProperty("docs");
-
-    // Verify the order matches between rows and docs
-    for (let i = 0; i < result.rows.length; i++) {
-      const row = result.rows[i];
-      const doc = result.docs[i];
-      expect(doc._id).toBe(row.id);
-    }
-  });
-
-  it("should work with complex map functions and query options", async function () {
-    // Test with a map function and query options
-    const result = await db.query<TestDoc, boolean>((doc) => doc.active, {
-      key: true,
-      includeDocs: true,
-    });
-
-    // Check rows (this should pass)
-    expect(result.rows.length).toBeGreaterThan(0);
-
-    // Check docs property (this should fail until we implement the feature)
-    expect(result).toHaveProperty("docs");
-    expect(result.docs.length).toBe(result.rows.length);
-
-    // Verify all returned docs are active
-    result.docs.forEach((doc) => {
-      // Since we know these are TestDoc documents
-      expect((doc as DocWithId<TestDoc>).active).toBe(true);
-    });
-  });
-
-  it("should only return docs with false value when queried with {key: false}", async function () {
-    // Test with a map function and query options for false value
-    const result = await db.query<TestDoc, boolean>((doc) => doc.active, {
-      key: false,
-      includeDocs: true,
-    });
-
-    // Should only return documents where active is false
-    expect(result.rows.length).toBe(1); // We only have one document with active: false
-
-    // Check docs property exists and matches rows length
-    expect(result).toHaveProperty("docs");
-    expect(result.docs.length).toBe(result.rows.length);
-
-    // Verify all returned docs have active set to false
-    result.docs.forEach((doc) => {
-      expect((doc as DocWithId<TestDoc>).active).toBe(false);
-    });
-
-    // Make sure no documents with active: true are included
-    const activeTrue = result.docs.filter((doc) => (doc as DocWithId<TestDoc>).active === true);
-    expect(activeTrue.length).toBe(0); // No active: true docs should be included
-
-    // Now run a query with key: true for comparison
-    const trueResult = await db.query<TestDoc, boolean>((doc) => doc.active, {
-      key: true,
-      includeDocs: true,
-    });
-
-    // This correctly returns only active: true documents
-    expect(trueResult.rows.length).toBe(2);
-
-    // All returned docs have active set to true
-    trueResult.docs.forEach((doc) => {
-      expect((doc as DocWithId<TestDoc>).active).toBe(true);
-    });
-  });
-});

package/fireproof/query-limit-issue.test.ts

@@ -1,147 +0,0 @@
-import { describe, it, beforeEach, afterEach, expect } from "vitest";
-import { Database, fireproof } from "@fireproof/core";
-
-interface TodoDoc {
-  task: string;
-  completed: boolean;
-  priority?: number;
-}
-
-describe("query limit handling", () => {
-  let db: Database;
-
-  beforeEach(async () => {
-    db = await fireproof("test-query-limit");
-
-    // Create multiple documents with different completed values and priorities
-    await db.put({ _id: "task1", task: "Task 1", completed: true, priority: 1 });
-    await db.put({ _id: "task2", task: "Task 2", completed: true, priority: 2 });
-    await db.put({ _id: "task3", task: "Task 3", completed: false, priority: 3 });
-    await db.put({ _id: "task4", task: "Task 4", completed: false, priority: 4 });
-    await db.put({ _id: "task5", task: "Task 5", completed: true, priority: 5 });
-  });
-
-  afterEach(async () => {
-    await db.destroy();
-  });
-
-  // PASSING CASES - These should work correctly with the current implementation
-
-  it("should correctly limit results for regular queries", async () => {
-    // Regular query with limit (no key/keys specified)
-    const queryResult = await db.query("completed", {
-      includeDocs: false,
-      limit: 2,
-    });
-
-    // This should pass - limit should work for regular queries
-    expect(queryResult.rows.length).toBe(2);
-  });
-
-  it("should correctly limit results for 'key' parameter queries", async () => {
-    // Query with a single key and limit
-    const queryResult = await db.query("completed", {
-      key: true,
-      includeDocs: false,
-      limit: 2,
-    });
-
-    // This should pass - limit should work for queries with 'key' option
-    expect(queryResult.rows.length).toBe(2);
-
-    // All results should have completed=true
-    queryResult.rows.forEach((row) => {
-      expect(row.key).toBe(true);
-    });
-  });
-
-  it("should correctly limit range query results", async () => {
-    // Query with range and limit
-    const queryResult = await db.query("priority", {
-      range: [2, 4],
-      includeDocs: false,
-      limit: 2,
-    });
-
-    // This should pass - limit should work for range queries
-    expect(queryResult.rows.length).toBe(2);
-
-    // All results should have priority between 2 and 4
-    queryResult.rows.forEach((row) => {
-      expect(row.key).toBeGreaterThanOrEqual(2);
-      expect(row.key).toBeLessThanOrEqual(4);
-    });
-  });
-
-  // FAILING CASES - These demonstrate the current bug
-
-  it("should respect the limit option with 'keys' parameter (currently failing)", async () => {
-    // Query with multiple keys and limit=1
-    // This should return only 1 result total, but currently returns 1 per key
-    const queryResult = await db.query("completed", {
-      keys: [true, false],
-      includeDocs: false,
-      limit: 1,
-    });
-
-    // This assertion will fail with the current implementation
-    // Current behavior: Returns limit=1 for EACH key, so 2 results total
-    // Expected behavior: Returns limit=1 across ALL keys combined
-    expect(queryResult.rows.length).toBe(1);
-  });
-
-  it("should apply limit correctly to combined results from multiple keys", async () => {
-    // Query with multiple keys and limit=3
-    // Should return exactly 3 results total
-    const queryResult = await db.query<TodoDoc, boolean>("completed", {
-      keys: [true, false],
-      includeDocs: false,
-      limit: 3,
-    });
-
-    // This assertion verifies that limit is applied to the combined result
-    expect(queryResult.rows.length).toBe(3);
-  });
-
-  it("demonstrates the limit+1 issue with the 'keys' parameter", async () => {
-    // Create a controlled test case with exact document counts
-    await db.destroy();
-    db = await fireproof("test-exact-limit");
-
-    // Create exactly 2 documents with completed=true and 2 with completed=false
-    await db.put({ _id: "doc1", task: "Doc 1", completed: true });
-    await db.put({ _id: "doc2", task: "Doc 2", completed: true });
-    await db.put({ _id: "doc3", task: "Doc 3", completed: false });
-    await db.put({ _id: "doc4", task: "Doc 4", completed: false });
-
-    // Query with limit=1 - should return exactly 1 result total
-    const result1 = await db.query("completed", {
-      keys: [true, false],
-      limit: 1,
-      includeDocs: false,
-    });
-
-    // Will fail - returns 2 instead of 1
-    expect(result1.rows.length).toBe(1);
-
-    // Query with limit=2 - should return exactly 2 results total
-    const result2 = await db.query("completed", {
-      keys: [true, false],
-      limit: 2,
-      includeDocs: false,
-    });
-
-    // Will fail - returns 4 instead of 2
-    expect(result2.rows.length).toBe(2);
-
-    // Query with limit=3 - should return exactly 3 results total
-    const result3 = await db.query("completed", {
-      keys: [true, false],
-      limit: 3,
-      includeDocs: false,
-    });
-
-    // Will fail - returns 4 instead of 3
-    expect(result3.rows.length).toBe(3);
-  });
-});

package/fireproof/query-property-inconsistency.test.ts

@@ -1,90 +0,0 @@
-import { Database, fireproof } from "@fireproof/core";
-import { describe, beforeEach, afterEach, it, expect } from "vitest";
-
-interface TestDoc {
-  text: string;
-  category: string;
-  count: number;
-}
-
-describe("query property inconsistency issue", function () {
-  let db: Database;
-
-  beforeEach(async () => {
-    db = fireproof("test-query-property-inconsistency");
-
-    // Add test documents
-    await db.put({ _id: "doc1", text: "hello world", category: "greeting", count: 1 });
-    await db.put({ _id: "doc2", text: "goodbye world", category: "farewell", count: 2 });
-    await db.put({ _id: "doc3", text: "hello again", category: "greeting", count: 3 });
-  });
-
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-  });
-
-  it("demonstrates property inconsistency in query results", async function () {
-    // Case 1: Query without key option - should have 'value' property
-    const queryNoKey = await db.query<TestDoc>((doc) => doc.category);
-
-    // Verify it has 'value' property
-    expect(queryNoKey.rows[0]).toHaveProperty("value");
-
-    // Case 2: Query with key option - currently has 'row' property instead of 'value'
-    const queryWithKey = await db.query<TestDoc>((doc) => doc.category, {
-      key: "greeting",
-    });
-
-    // THIS WILL FAIL - Demonstrating the inconsistency
-    // After standardizing on 'value', this assertion should pass
-    expect(queryWithKey.rows[0]).toHaveProperty("value");
-
-    // This assertion will pass after standardizing on 'value' and removing 'row'
-    expect(queryWithKey.rows[0]).not.toHaveProperty("row");
-  });
-
-  it("should use consistent property names regardless of query type", async function () {
-    // Multiple query variations to test different code paths
-
-    // 1. Regular query (no options)
-    const regularQuery = await db.query<TestDoc>((doc) => doc.category);
-
-    // 2. Query with key option
-    const keyQuery = await db.query<TestDoc>((doc) => doc.category, {
-      key: "greeting",
-    });
-
-    // 3. Query with range option
-    const rangeQuery = await db.query<TestDoc>((doc) => doc.count, {
-      range: [1, 3],
-    });
-
-    // 4. Query with prefix option
-    const prefixQuery = await db.query<TestDoc>((doc) => [doc.category, doc.count], {
-      prefix: ["greeting"],
-    });
-
-    // Check each query type has the 'value' property
-    expect(regularQuery.rows[0]).toHaveProperty("value");
-    expect(keyQuery.rows[0]).toHaveProperty("value");
-    expect(rangeQuery.rows[0]).toHaveProperty("value");
-    expect(prefixQuery.rows[0]).toHaveProperty("value");
-
-    // Ensure no query has the 'row' property
-    expect(regularQuery.rows[0]).not.toHaveProperty("row");
-    expect(keyQuery.rows[0]).not.toHaveProperty("row");
-    expect(rangeQuery.rows[0]).not.toHaveProperty("row");
-    expect(prefixQuery.rows[0]).not.toHaveProperty("row");
-
-    // Ensure all queries have the same set of properties
-    const regularProps = Object.keys(regularQuery.rows[0]).sort();
-    const keyProps = Object.keys(keyQuery.rows[0]).sort();
-    const rangeProps = Object.keys(rangeQuery.rows[0]).sort();
-    const prefixProps = Object.keys(prefixQuery.rows[0]).sort();
-
-    expect(keyProps).toEqual(regularProps);
-    expect(rangeProps).toEqual(regularProps);
-    expect(prefixProps).toEqual(regularProps);
-  });
-});

package/fireproof/query-result-properties.test.ts

@@ -1,43 +0,0 @@
-import { Database, fireproof } from "@fireproof/core";
-import { describe, beforeEach, afterEach, it, expect } from "vitest";
-
-interface TestDoc {
-  text: string;
-  category: string;
-  count: number;
-}
-
-describe("query result property consistency", function () {
-  let db: Database;
-
-  beforeEach(async () => {
-    db = fireproof("test-query-result-properties");
-
-    // Add test documents
-    await db.put({ _id: "doc1", text: "hello world", category: "greeting", count: 1 });
-    await db.put({ _id: "doc2", text: "goodbye world", category: "farewell", count: 2 });
-    await db.put({ _id: "doc3", text: "hello again", category: "greeting", count: 3 });
-  });
-
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-  });
-
-  it("should have consistent result properties regardless of query options", async function () {
-    // Query without using the key option
-    const resultWithoutKey = await db.query<TestDoc>((doc) => doc.category);
-
-    // Query with the key option
-    const resultWithKey = await db.query<TestDoc>((doc) => doc.category, {
-      key: "greeting",
-    });
-
-    // Add assertions to check property existence
-    const withoutKeyProps = Object.keys(resultWithoutKey.rows[0]);
-    const withKeyProps = Object.keys(resultWithKey.rows[0]);
-
-    // Test if the properties are the same in both cases
-    expect(withoutKeyProps).toEqual(withKeyProps);
-  });
-});

package/fireproof/stable-cid.test.ts

@@ -1,72 +0,0 @@
-import { sha256 } from "multiformats/hashes/sha2";
-import { base58btc } from "multiformats/bases/base58";
-import { URI, toCryptoRuntime } from "@adviser/cement";
-import * as cborg from "cborg";
-import { asyncBlockDecode, asyncBlockEncode, ensureSuperThis, keyedCryptoFactory } from "@fireproof/core-runtime";
-import { describe, beforeEach, it, expect } from "vitest";
-import { getKeyBag } from "@fireproof/core-keybag";
-import { CryptoAction, IvKeyIdData } from "@fireproof/core-types-blockstore";
-
-const sthis = ensureSuperThis();
-describe.each([
-  async () => {
-    const kb = await getKeyBag(sthis, {});
-    const keyStr = base58btc.encode(toCryptoRuntime().randomBytes(kb.rt.keyLength));
-    return await keyedCryptoFactory(URI.from(`test://bla?storekey=${keyStr}`), kb, sthis);
-  },
-  async () => {
-    const kb = await getKeyBag(sthis, {});
-    return await keyedCryptoFactory(URI.from(`test://bla?storekey=insecure`), kb, sthis);
-  },
-])("regression of stable cid encoding", (factory) => {
-  let kycr: CryptoAction;
-  beforeEach(async () => {
-    // let url: URI;
-    // if (runtimeFn().isBrowser) {
-    //   url = URI.from("indexeddb://fp-keybag");
-    // } else {
-    //   url = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
-    // }
-    kycr = await factory();
-  });
-
-  it("should encode and decode a stable cid", async () => {
-    const x1 = await asyncBlockEncode({
-      value: cborg.encode({ hello: "world" }),
-      // hashBytes: {
-      //   as: (x: Uint8Array<ArrayBufferLike>): Promise<ByteView<Uint8Array>> => Promise.resolve(x),
-      // },
-      hasher: sha256,
-      codec: kycr.codec(toCryptoRuntime().randomBytes(12)),
-    });
-    const x2 = await asyncBlockEncode({
-      value: cborg.encode({ hello: "world" }),
-      // hashBytes: {
-      //   as: (x: Uint8Array<ArrayBufferLike>): Promise<ByteView<Uint8Array>> => Promise.resolve(x),
-      // },
-      hasher: sha256,
-      codec: kycr.codec(toCryptoRuntime().randomBytes(12)),
-    });
-    expect(x1.cid).toEqual(x2.cid);
-  });
-  it("decode stable cid", async () => {
-    const x1 = await asyncBlockEncode({
-      value: cborg.encode({ hello: "world" }),
-      // hashBytes: {
-      //   as: (x: Uint8Array<ArrayBufferLike>): Promise<ByteView<Uint8Array>> => Promise.resolve(x),
-      // },
-      hasher: sha256,
-      codec: kycr.codec(),
-    });
-    const x = await asyncBlockDecode<IvKeyIdData, 24, 18>({
-      bytes: x1.bytes,
-      // hashBytes: {
-      //   get: (x:   IvKeyIdData): Promise<ByteView<Uint8Array>> => Promise.resolve(x.data as ByteView<Uint8Array<ArrayBufferLike>>),
-      // },
-      codec: kycr.codec(),
-      hasher: sha256,
-    });
-    expect(x.cid.toString()).toEqual(x1.cid.toString());
-    expect(cborg.decode(x.value.data)).toEqual({ hello: "world" });
-  }, 1000000);
-});

package/fireproof/utils.test.ts

@@ -1,137 +0,0 @@
-import { runtimeFn, URI } from "@adviser/cement";
-import { getFileName } from "@fireproof/core-gateways-base";
-import { ensureSuperThis, ensureSuperLog, getStore, inplaceFilter } from "@fireproof/core-runtime";
-import { UUID } from "uuidv7";
-import { describe, beforeAll, it, expect, assert } from "vitest";
-
-describe("utils", () => {
-  const sthis = ensureSuperThis();
-  const logger = ensureSuperLog(sthis, "getfilename");
-
-  beforeAll(async () => {
-    await sthis.start();
-  });
-
-  it("sorts search params", () => {
-    const url = URI.from("http://example.com?z=1&y=2&x=3");
-    expect(url.toString()).toEqual("http://example.com/?x=3&y=2&z=1");
-  });
-
-  const storeOpts = [
-    {
-      type: "car",
-      pathPart: "data",
-      suffix: ".car",
-    },
-    {
-      type: "file",
-      pathPart: "data",
-      suffix: "",
-    },
-    {
-      type: "wal",
-      pathPart: "wal",
-      suffix: ".json",
-    },
-    {
-      type: "meta",
-      pathPart: "meta",
-      suffix: ".json",
-    },
-  ];
-  it("getfilename plain", () => {
-    for (const store of storeOpts) {
-      const url = URI.from(`file://./x/path?store=${store.type}&name=name&key=key&version=version&suffix=${store.suffix}`);
-      expect(getFileName(url, logger)).toEqual(`${store.pathPart}/key${store.suffix}`);
-    }
-  });
-
-  it("getfilename index", () => {
-    for (const store of storeOpts) {
-      const url = URI.from(
-        `file://./x/path?index=idx&store=${store.type}&name=name&key=key&version=version&suffix=${store.suffix}`,
-      );
-      expect(getFileName(url, logger)).toEqual(`idx-${store.pathPart}/key${store.suffix}`);
-    }
-  });
-
-  it("getstore", () => {
-    for (const store of storeOpts) {
-      const url = URI.from(`file://./x/path?store=${store.type}&name=name&key=key&version=version`);
-      expect(getStore(url, logger, (...toJoin) => toJoin.join("+"))).toEqual({
-        fromUrl: store.type,
-        name: store.pathPart,
-        pathPart: store.pathPart,
-      });
-    }
-  });
-
-  it("getstore idx", () => {
-    for (const store of storeOpts) {
-      const url = URI.from(`file://./x/path?index=ix&store=${store.type}&name=name&key=key&version=version`);
-      expect(getStore(url, logger, (...toJoin) => toJoin.join("+"))).toEqual({
-        fromUrl: store.type,
-        pathPart: store.pathPart,
-        name: `ix+${store.pathPart}`,
-      });
-    }
-  });
-
-  it("order timeorderednextid", () => {
-    let last = sthis.timeOrderedNextId().str;
-    for (let i = 0; i < 10; i++) {
-      const id = sthis.timeOrderedNextId().str;
-      const x = UUID.parse(id);
-      expect(x.getVariant()).toBe("VAR_10");
-      assert(id !== last, "id should be greater than last");
-      assert(id.slice(0, 13) >= last.slice(0, 13), `id should be greater than last ${id.slice(0, 13)} ${last.slice(0, 13)}`);
-      last = id;
-    }
-  });
-  it("timeorderednextid is uuidv7", () => {
-    const id = sthis.timeOrderedNextId(0xcafebabebeef).str;
-    expect(id.slice(0, 15)).toBe("cafebabe-beef-7");
-  });
-
-  it("inplaceFilter empty", () => {
-    const s: string[] = [];
-    expect(inplaceFilter(s, () => false)).toEqual([]);
-    expect(inplaceFilter(s, () => true)).toEqual([]);
-  });
-
-  it("inplaceFilter sized filtered", () => {
-    const s = new Array(100).fill("a").map((a, i) => `${a}${i.toString()}`);
-    expect(inplaceFilter(s, () => false)).toEqual([]);
-  });
-  it("inplaceFilter sized unfiltered", () => {
-    const s = new Array(100).fill("a").map((a, i) => `${a}${i.toString()}`);
-    const ref = [...s];
-    expect(inplaceFilter(s, () => true)).toEqual(ref);
-  });
-
-  it("inplaceFilter sized mod 7", () => {
-    const s = new Array(100).fill("a").map((a, i) => `${a}${i.toString()}`);
-    const ref = [...s];
-    for (let i = 99; i >= 0; i--) {
-      if (!(i % 7)) {
-        ref.splice(i, 1);
-      }
-    }
-    expect(inplaceFilter(s, (_, j) => !!(j % 7))).toEqual(ref);
-    expect(s.length).toBe(85);
-  });
-});
-
-describe("runtime", () => {
-  it("runtime", () => {
-    const isDeno = !!(typeof process === "object" && process.versions?.deno);
-    const isNode = !isDeno && !!(typeof process === "object" && process.versions?.node);
-    expect(runtimeFn()).toEqual({
-      isBrowser: !(isNode || isDeno),
-      isCFWorker: false,
-      isDeno: isDeno,
-      isNodeIsh: isNode,
-      isReactNative: false,
-    });
-  });
-});