@fireproof/core 0.20.5 → 0.21.0-dev-preview-3

package/tests/fireproof/indexer.test.ts

@@ -23,7 +23,7 @@ interface TestType {
 
 describe("basic Index", () => {
   let db: Database;
-  let indexer: Index<string, TestType>;
+  let indexer: Index<TestType, string>;
   let didMap: boolean;
   const sthis = ensureSuperThis();
   afterEach(async () => {
@@ -38,7 +38,7 @@ describe("basic Index", () => {
     await db.put({ title: "amazing" });
     await db.put({ title: "creative" });
     await db.put({ title: "bazillas" });
-    indexer = new Index<string, TestType>(sthis, db.ledger.crdt, "hello", (doc) => {
+    indexer = new Index<TestType, string>(sthis, db.ledger.crdt, "hello", (doc) => {
       didMap = true;
       return doc.title;
     });
@@ -111,7 +111,7 @@ describe("basic Index", () => {
 
 describe("Index query with compound key", function () {
   let db: Database;
-  let indexer: Index<[string, number], TestType>;
+  let indexer: Index<TestType, [string, number]>;
   const sthis = ensureSuperThis();
   afterEach(async () => {
     await db.close();
@@ -126,7 +126,7 @@ describe("Index query with compound key", function () {
     await db.put({ title: "creative", score: 2 });
     await db.put({ title: "creative", score: 20 });
     await db.put({ title: "bazillas", score: 3 });
-    indexer = new Index<[string, number], TestType>(sthis, db.ledger.crdt, "hello", (doc) => {
+    indexer = new Index<TestType, [string, number]>(sthis, db.ledger.crdt, "hello", (doc) => {
       return [doc.title, doc.score];
     });
     await indexer.ready();
@@ -141,7 +141,7 @@ describe("Index query with compound key", function () {
 
 describe("basic Index with map fun", function () {
   let db: Database;
-  let indexer: Index<string, TestType>;
+  let indexer: Index<TestType, string>;
   const sthis = ensureSuperThis();
   afterEach(async () => {
     await db.close();
@@ -155,7 +155,7 @@ describe("basic Index with map fun", function () {
     await db.put({ title: "amazing" });
     await db.put({ title: "creative" });
     await db.put({ title: "bazillas" });
-    indexer = new Index<string, TestType>(sthis, db.ledger.crdt, "hello", (doc, map) => {
+    indexer = new Index<TestType, string>(sthis, db.ledger.crdt, "hello", (doc, map) => {
       map(doc.title);
     });
     await indexer.ready();
@@ -171,7 +171,7 @@ describe("basic Index with map fun", function () {
 
 describe("basic Index with map fun with value", function () {
   let db: Database;
-  let indexer: Index<string, TestType, number>;
+  let indexer: Index<TestType, string, number>;
   const sthis = ensureSuperThis();
   afterEach(async () => {
     await db.close();
@@ -183,7 +183,7 @@ describe("basic Index with map fun with value", function () {
     await db.put({ title: "amazing" });
     await db.put({ title: "creative" });
     await db.put({ title: "bazillas" });
-    indexer = new Index<string, TestType, number>(sthis, db.ledger.crdt, "hello", (doc, map) => {
+    indexer = new Index<TestType, string, number>(sthis, db.ledger.crdt, "hello", (doc, map) => {
       map(doc.title, doc.title.length);
     });
   });
@@ -209,7 +209,7 @@ describe("basic Index with map fun with value", function () {
 
 describe("Index query with map and compound key", function () {
   let db: Database;
-  let indexer: Index<[string, number], TestType>;
+  let indexer: Index<TestType, [string, number]>;
   const sthis = ensureSuperThis();
   afterEach(async () => {
     await db.close();
@@ -224,7 +224,7 @@ describe("Index query with map and compound key", function () {
     await db.put({ title: "creative", score: 2 });
     await db.put({ title: "creative", score: 20 });
     await db.put({ title: "bazillas", score: 3 });
-    indexer = new Index<[string, number], TestType>(sthis, db.ledger.crdt, "hello", (doc, emit) => {
+    indexer = new Index<TestType, [string, number]>(sthis, db.ledger.crdt, "hello", (doc, emit) => {
       emit([doc.title, doc.score]);
     });
     await indexer.ready();
@@ -239,7 +239,7 @@ describe("Index query with map and compound key", function () {
 
 describe("basic Index with string fun", function () {
   let db: Database;
-  let indexer: Index<string, TestType>;
+  let indexer: Index<TestType, string>;
   const sthis = ensureSuperThis();
   afterEach(async () => {
     await db.close();
@@ -253,7 +253,7 @@ describe("basic Index with string fun", function () {
     await db.put({ title: "amazing" });
     await db.put({ title: "creative" });
     await db.put({ title: "bazillas" });
-    indexer = new Index<string, TestType>(sthis, db.ledger.crdt, "title");
+    indexer = new Index<TestType, string>(sthis, db.ledger.crdt, "title");
     await indexer.ready();
   });
   it("should get results", async () => {
@@ -271,7 +271,7 @@ describe("basic Index with string fun", function () {
 
 describe("basic Index with string fun and numeric keys", function () {
   let db: Database;
-  let indexer: Index<string, TestType>;
+  let indexer: Index<TestType, string>;
   const sthis = ensureSuperThis();
   afterEach(async () => {
     await db.close();
@@ -286,7 +286,7 @@ describe("basic Index with string fun and numeric keys", function () {
     await db.put({ points: 1 });
     await db.put({ points: 2 });
     await db.put({ points: 3 });
-    indexer = new Index<string, TestType>(sthis, db.ledger.crdt, "points");
+    indexer = new Index<TestType, string>(sthis, db.ledger.crdt, "points");
     await indexer.ready();
   });
   it("should get results", async () => {
@@ -308,10 +308,10 @@ describe("basic Index upon cold start", function () {
     score?: number;
   }
   let crdt: CRDT;
-  let indexer: Index<string, TestType>;
+  let indexer: Index<TestType>;
   let didMap: number;
   let mapFn: (doc: TestType) => string;
-  let result: IndexRows<string, TestType>;
+  let result: IndexRows<TestType>;
   const sthis = ensureSuperThis();
   let dbOpts: LedgerOpts;
   // result, mapFn;
@@ -346,7 +346,7 @@ describe("basic Index upon cold start", function () {
       didMap++;
       return doc.title;
     };
-    indexer = await index<string, TestType>(crdt, "hello", mapFn);
+    indexer = await index<TestType>(crdt, "hello", mapFn);
     logger.Debug().Msg("post index beforeEach");
     await indexer.ready();
     logger.Debug().Msg("post indexer.ready beforeEach");
@@ -371,7 +371,7 @@ describe("basic Index upon cold start", function () {
     const { result, head } = await crdt2.changes();
     expect(result).toBeTruthy();
     await crdt2.ready();
-    const indexer2 = await index<string, TestType>(crdt2, "hello", mapFn);
+    const indexer2 = await index<TestType>(crdt2, "hello", mapFn);
     await indexer2.ready();
     const result2 = await indexer2.query();
     expect(indexer2.indexHead).toEqual(head);
@@ -407,7 +407,7 @@ describe("basic Index upon cold start", function () {
   });
   it("should ignore meta when map function definiton changes", async () => {
     const crdt2 = new CRDTImpl(sthis, dbOpts);
-    const result = await index<string, TestType>(crdt2, "hello", (doc) => doc.title.split("").reverse().join("")).query();
+    const result = await index<TestType>(crdt2, "hello", (doc) => doc.title.split("").reverse().join("")).query();
     expect(result.rows.length).toEqual(3);
     expect(result.rows[0].key).toEqual("evitaerc"); // creative
   });
@@ -415,7 +415,7 @@ describe("basic Index upon cold start", function () {
 
 describe("basic Index with no data", function () {
   let db: Database;
-  let indexer: Index<string, TestType>;
+  let indexer: Index<TestType>;
   let didMap: boolean;
   const sthis = ensureSuperThis();
   afterEach(async () => {
@@ -427,7 +427,7 @@ describe("basic Index with no data", function () {
   beforeEach(async () => {
     await sthis.start();
     db = fireproof("test-indexer");
-    indexer = new Index<string, TestType>(sthis, db.ledger.crdt, "hello", (doc) => {
+    indexer = new Index<TestType>(sthis, db.ledger.crdt, "hello", (doc) => {
       didMap = true;
       return doc.title;
     });

package/tests/fireproof/query-docs.test.ts

@@ -1,5 +1,4 @@
-import { describe, it, beforeEach, afterEach, expect } from "vitest";
-import { Database, DocWithId, ensureSuperThis, fireproof } from "@fireproof/core";
+import { Database, DocWithId, fireproof } from "@fireproof/core";
 
 interface TestDoc {
   text: string;
@@ -9,10 +8,8 @@ interface TestDoc {
 
 describe("query return value consistency", function () {
   let db: Database;
-  const sthis = ensureSuperThis();
 
   beforeEach(async () => {
-    await sthis.start();
     db = fireproof("test-query-docs");
 
     // Add test documents
@@ -28,7 +25,7 @@ describe("query return value consistency", function () {
 
   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<string, TestDoc>("category");
+    const result = await db.query<TestDoc>("category");
 
     // Check that rows property exists (this should pass)
     expect(result).toHaveProperty("rows");
@@ -45,7 +42,7 @@ describe("query return value consistency", function () {
   });
 
   it("should return docs with the same order as rows", async function () {
-    const result = await db.query<string, TestDoc>("category");
+    const result = await db.query<TestDoc>("category");
 
     // Ensure docs array exists
     expect(result).toHaveProperty("docs");
@@ -60,7 +57,7 @@ describe("query return value consistency", function () {
 
   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<boolean, TestDoc>((doc) => doc.active, {
+    const result = await db.query<TestDoc, boolean>((doc) => doc.active, {
       key: true,
       includeDocs: true,
     });
@@ -78,4 +75,42 @@ describe("query return value consistency", function () {
       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/tests/fireproof/query-limit-issue.test.ts

@@ -0,0 +1,147 @@
+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/tests/fireproof/query-property-inconsistency.test.ts

@@ -0,0 +1,89 @@
+import { Database, fireproof } from "@fireproof/core";
+
+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/tests/fireproof/query-result-properties.test.ts

@@ -0,0 +1,42 @@
+import { Database, fireproof } from "@fireproof/core";
+
+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);
+  });
+});