@enbox/dwn-sdk-js 0.4.8 → 0.4.9

package/dist/esm/tests/store/index-level.spec.js

@@ -53,7 +53,7 @@ describe('IndexLevel', () => {
                 dateCreated, // 1 key
             });
             let keys = await ArrayUtility.fromAsyncGenerator(testIndex.db.keys());
-            expect(keys.length).toBe(5);
+            expect(keys).toHaveLength(5);
             await testIndex.clear();
             await testIndex.put(tenant, id, {
                 'a': 'b', // 1 key
@@ -62,7 +62,7 @@ describe('IndexLevel', () => {
                 dateCreated, // 1 key
             });
             keys = await ArrayUtility.fromAsyncGenerator(testIndex.db.keys());
-            expect(keys.length).toBe(6);
+            expect(keys).toHaveLength(6);
         });
         it('should not put anything if aborted beforehand', async () => {
             const controller = new AbortController();
@@ -75,7 +75,7 @@ describe('IndexLevel', () => {
             const indexPromise = testIndex.put(tenant, id, index, { signal: controller.signal });
             await expect(indexPromise).rejects.toThrow('reason');
             const entries = await testIndex.query(tenant, [{ foo: 'bar' }], { sortProperty: 'id' });
-            expect(entries.length).toBe(0);
+            expect(entries).toHaveLength(0);
         });
     });
     describe('query', () => {
@@ -118,7 +118,7 @@ describe('IndexLevel', () => {
                     'a': 'b',
                     'c': 'e'
                 }], { sortProperty: 'id' });
-            expect(entries.length).toBe(1);
+            expect(entries).toHaveLength(1);
             expect(entries[0].messageCid).toBe(id3);
         });
         it('should return all records if an empty filter array is passed', async () => {
@@ -147,27 +147,27 @@ describe('IndexLevel', () => {
                 const filters = [{ schema: 'schema', published: true }];
                 // query with limit, default (ascending)
                 const results = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
-                expect(results.length).toBe(2);
+                expect(results).toHaveLength(2);
                 expect(results.map(({ messageCid }) => messageCid)).toEqual(['a', 'b']);
                 // query with cursor, default (ascending)
                 const resultsAfterCursor = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(results, 'val') });
-                expect(resultsAfterCursor.length).toBe(2);
+                expect(resultsAfterCursor).toHaveLength(2);
                 expect(resultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual(['c', 'd']);
                 // query with limit, explicit ascending
                 const ascResults = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
-                expect(ascResults.length).toBe(2);
+                expect(ascResults).toHaveLength(2);
                 expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b']);
                 // query with cursor, explicit ascending
                 const ascResultsAfterCursor = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(ascResults, 'val') });
-                expect(ascResultsAfterCursor.length).toBe(2);
+                expect(ascResultsAfterCursor).toHaveLength(2);
                 expect(ascResultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual(['c', 'd']);
                 // query with limit, descending
                 const descResults = await testIndex.queryWithIteratorPaging(tenant, filters, { sortDirection: SortDirection.Descending, sortProperty: 'val', limit: 2 });
-                expect(descResults.length).toBe(2);
+                expect(descResults).toHaveLength(2);
                 expect(descResults.map(({ messageCid }) => messageCid)).toEqual(['d', 'c']);
                 // query with cursor, descending
                 const descResultsAfterCursor = await testIndex.queryWithIteratorPaging(tenant, filters, { sortDirection: SortDirection.Descending, sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(descResults, 'val') });
-                expect(descResultsAfterCursor.length).toBe(2);
+                expect(descResultsAfterCursor).toHaveLength(2);
                 expect(descResultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual(['b', 'a']);
             });
             it('returns empty array if sort property is invalid', async () => {
@@ -183,10 +183,10 @@ describe('IndexLevel', () => {
                 const filters = [{ schema: 'schema', published: true }];
                 // control test: return all results
                 const validResults = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val' });
-                expect(validResults.length).toBe(4);
+                expect(validResults).toHaveLength(4);
                 // sort by invalid property returns no results
                 const invalidResults = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'invalid' });
-                expect(invalidResults.length).toBe(0);
+                expect(invalidResults).toHaveLength(0);
             });
             it('cursor is valid but out of range of matched results', async () => {
                 const testVals = ['b', 'd', 'c']; // a is missing
@@ -206,7 +206,7 @@ describe('IndexLevel', () => {
                 // cursor `e-id` doesn't actually exist, but the value `e` is sorted after to the result set.
                 const cursorE = { messageCid: 'e-id', value: 'e' };
                 const noResults = await testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', cursor: cursorE });
-                expect(noResults.length).toEqual(0);
+                expect(noResults).toHaveLength(0);
             });
         });
         describe('array values', () => {
@@ -229,11 +229,11 @@ describe('IndexLevel', () => {
                 }
                 const filterForItemTag = [{ tag: 'item' }];
                 const allResults = await testIndex.queryWithIteratorPaging(tenant, filterForItemTag, { sortProperty: 'id' });
-                expect(allResults.length).toBe(4);
+                expect(allResults).toHaveLength(4);
                 expect(allResults.map(item => item.messageCid)).toEqual(expect.arrayContaining(items.map(item => item.id)));
                 const filterForItem3 = [{ tag: 'item3' }];
                 const item3Results = await testIndex.queryWithIteratorPaging(tenant, filterForItem3, { sortProperty: 'id' });
-                expect(item3Results.length).toBe(1);
+                expect(item3Results).toHaveLength(1);
                 expect(item3Results.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[2].id]));
             });
             it('query items with number array values', async () => {
@@ -255,15 +255,15 @@ describe('IndexLevel', () => {
                 }
                 const filterForItemTag = [{ tag: 1 }];
                 const allResults = await testIndex.queryWithIteratorPaging(tenant, filterForItemTag, { sortProperty: 'id' });
-                expect(allResults.length).toBe(4);
+                expect(allResults).toHaveLength(4);
                 expect(allResults.map(item => item.messageCid)).toEqual(expect.arrayContaining(items.map(item => item.id)));
                 const filterForItem3 = [{ tag: 3 }];
                 const item3Results = await testIndex.queryWithIteratorPaging(tenant, filterForItem3, { sortProperty: 'id' });
-                expect(item3Results.length).toBe(1);
+                expect(item3Results).toHaveLength(1);
                 expect(item3Results.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[2].id]));
                 const filterForRange = [{ tag: { gt: 1, lt: 4 } }];
                 const rangeItems = await testIndex.queryWithIteratorPaging(tenant, filterForRange, { sortProperty: 'id' });
-                expect(rangeItems.length).toBe(2);
+                expect(rangeItems).toHaveLength(2);
                 expect(rangeItems.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[1].id, items[2].id]));
             });
         });
@@ -281,27 +281,27 @@ describe('IndexLevel', () => {
                 const filters = [{ schema: 'schema', published: true }];
                 // query with limit, default (ascending)
                 const results = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
-                expect(results.length).toBe(2);
+                expect(results).toHaveLength(2);
                 expect(results.map(({ messageCid }) => messageCid)).toEqual(['a', 'b']);
                 // query with cursor, default (ascending)
                 const resultsAfterCursor = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(results, 'val') });
-                expect(resultsAfterCursor.length).toBe(2);
+                expect(resultsAfterCursor).toHaveLength(2);
                 expect(resultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual(['c', 'd']);
                 // query with limit, explicit ascending
                 const ascResults = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
-                expect(ascResults.length).toBe(2);
+                expect(ascResults).toHaveLength(2);
                 expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b']);
                 // query with cursor, explicit ascending
                 const ascResultsAfterCursor = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(ascResults, 'val') });
-                expect(ascResultsAfterCursor.length).toBe(2);
+                expect(ascResultsAfterCursor).toHaveLength(2);
                 expect(ascResultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual(['c', 'd']);
                 // query with limit, descending
                 const descResults = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortDirection: SortDirection.Descending, sortProperty: 'val', limit: 2 });
-                expect(descResults.length).toBe(2);
+                expect(descResults).toHaveLength(2);
                 expect(descResults.map(({ messageCid }) => messageCid)).toEqual(['d', 'c']);
                 // query with cursor, descending
                 const descResultsAfterCursor = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortDirection: SortDirection.Descending, sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(descResults, 'val') });
-                expect(descResultsAfterCursor.length).toBe(2);
+                expect(descResultsAfterCursor).toHaveLength(2);
                 expect(descResultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual(['b', 'a']);
             });
             it('returns empty array if sort property is invalid', async () => {
@@ -317,10 +317,10 @@ describe('IndexLevel', () => {
                 const filters = [{ schema: 'schema', published: true }];
                 // control test: return all results
                 const validResults = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', limit: 3 });
-                expect(validResults.length).toBe(3);
+                expect(validResults).toHaveLength(3);
                 // sort by invalid property returns no results
                 const invalidResults = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'invalid' });
-                expect(invalidResults.length).toBe(0);
+                expect(invalidResults).toHaveLength(0);
             });
             it('cursor is valid but out of range of matched results', async () => {
                 const testVals = ['b', 'd', 'c', 'a'];
@@ -338,7 +338,7 @@ describe('IndexLevel', () => {
                 expect(allResults.map(({ messageCid }) => messageCid)).toEqual(['b', 'c', 'd']);
                 const cursorE = { messageCid: 'e', value: 'e' }; // after results
                 const noResults = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', cursor: cursorE });
-                expect(noResults.length).toEqual(0);
+                expect(noResults).toHaveLength(0);
             });
             it('supports range queries', async () => {
                 const id = uuid();
@@ -366,7 +366,7 @@ describe('IndexLevel', () => {
                         }
                     }];
                 const entries = await testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).toBe(2);
+                expect(entries).toHaveLength(2);
                 expect(entries.map(({ messageCid }) => messageCid)).toEqual(expect.arrayContaining([id2, id3]));
                 // only upper bounds
                 const lteFilter = [{
@@ -375,7 +375,7 @@ describe('IndexLevel', () => {
                         }
                     }];
                 const lteReply = await testIndex.queryWithInMemoryPaging(tenant, lteFilter, { sortProperty: 'id' });
-                expect(lteReply.length).toBe(3);
+                expect(lteReply).toHaveLength(3);
                 expect(lteReply.map(({ messageCid }) => messageCid)).toEqual(expect.arrayContaining([id, id2, id3]));
             });
             describe('array values', () => {
@@ -398,11 +398,11 @@ describe('IndexLevel', () => {
                     }
                     const filterForItemTag = [{ tag: 'item' }];
                     const allResults = await testIndex.queryWithInMemoryPaging(tenant, filterForItemTag, { sortProperty: 'id' });
-                    expect(allResults.length).toBe(4);
+                    expect(allResults).toHaveLength(4);
                     expect(allResults.map(item => item.messageCid)).toEqual(expect.arrayContaining(items.map(item => item.id)));
                     const filterForItem3 = [{ tag: 'item3' }];
                     const item3Results = await testIndex.queryWithInMemoryPaging(tenant, filterForItem3, { sortProperty: 'id' });
-                    expect(item3Results.length).toBe(1);
+                    expect(item3Results).toHaveLength(1);
                     expect(item3Results.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[2].id]));
                 });
                 it('query items with number array values', async () => {
@@ -424,15 +424,15 @@ describe('IndexLevel', () => {
                     }
                     const filterForItemTag = [{ tag: 1 }];
                     const allResults = await testIndex.queryWithInMemoryPaging(tenant, filterForItemTag, { sortProperty: 'id' });
-                    expect(allResults.length).toBe(4);
+                    expect(allResults).toHaveLength(4);
                     expect(allResults.map(item => item.messageCid)).toEqual(expect.arrayContaining(items.map(item => item.id)));
                     const filterForItem3 = [{ tag: 3 }];
                     const item3Results = await testIndex.queryWithInMemoryPaging(tenant, filterForItem3, { sortProperty: 'id' });
-                    expect(item3Results.length).toBe(1);
+                    expect(item3Results).toHaveLength(1);
                     expect(item3Results.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[2].id]));
                     const filterForRange = [{ tag: { gt: 1, lt: 4 } }];
                     const rangeItems = await testIndex.queryWithInMemoryPaging(tenant, filterForRange, { sortProperty: 'id' });
-                    expect(rangeItems.length).toBe(2);
+                    expect(rangeItems).toHaveLength(2);
                     expect(rangeItems.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[1].id, items[2].id]));
                 });
             });
@@ -447,7 +447,7 @@ describe('IndexLevel', () => {
                 await testIndex.put(tenant, id, doc);
                 const filters = [{ value: 'foo' }];
                 const entries = await testIndex.query(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).toBe(0);
+                expect(entries).toHaveLength(0);
             });
             it('supports OR queries', async () => {
                 const id1 = uuid();
@@ -472,7 +472,7 @@ describe('IndexLevel', () => {
                         a: ['a', 'b']
                     }];
                 const entries = await testIndex.query(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).toBe(2);
+                expect(entries).toHaveLength(2);
                 expect(entries.map(({ messageCid }) => messageCid)).toContain(id1);
                 expect(entries.map(({ messageCid }) => messageCid)).toContain(id2);
             });
@@ -491,7 +491,7 @@ describe('IndexLevel', () => {
                         }
                     }];
                 const entries = await testIndex.query(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).toBe(5);
+                expect(entries).toHaveLength(5);
             });
             it('supports prefixed range queries', async () => {
                 const id = uuid();
@@ -506,7 +506,7 @@ describe('IndexLevel', () => {
                         }
                     }];
                 const entries = await testIndex.query(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).toBe(1);
+                expect(entries).toHaveLength(1);
                 expect(entries.map(({ messageCid }) => messageCid)).toContain(id);
             });
             it('supports suffixed range queries', async () => {
@@ -528,7 +528,7 @@ describe('IndexLevel', () => {
                         }
                     }];
                 const entries = await testIndex.query(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).toBe(1);
+                expect(entries).toHaveLength(1);
                 expect(entries.map(({ messageCid }) => messageCid)).toContain(id1);
             });
             it('treats strings differently', async () => {
@@ -548,7 +548,7 @@ describe('IndexLevel', () => {
                         foo: true
                     }];
                 const entries = await testIndex.query(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).toBe(1);
+                expect(entries).toHaveLength(1);
                 expect(entries.map(({ messageCid }) => messageCid)).toContain(id1);
             });
             describe('numbers', () => {
@@ -564,7 +564,7 @@ describe('IndexLevel', () => {
                             digit: testNumbers.at(index)
                         }];
                     const entries = await testIndex.query(tenant, filters, { sortProperty: 'digit' });
-                    expect(entries.length).toBe(1);
+                    expect(entries).toHaveLength(1);
                     expect(entries.at(0)?.messageCid).toBe(testNumbers.at(index).toString());
                 });
                 it('should not return records that do not match provided number equality filter', async () => {
@@ -574,7 +574,7 @@ describe('IndexLevel', () => {
                     }
                     const filters = [{ digit: 1 }];
                     const entries = await testIndex.query(tenant, filters, { sortProperty: 'digit' });
-                    expect(entries.length).toBe(0);
+                    expect(entries).toHaveLength(0);
                 });
                 it('supports range queries with positive numbers inclusive', async () => {
                     for (const digit of testNumbers) {
@@ -684,17 +684,17 @@ describe('IndexLevel', () => {
                     const bothFilter = [{ schema: 'schema' }];
                     // control
                     const entries = await testIndex.query(tenant, bothFilter, { sortProperty: 'id' });
-                    expect(entries.length).toBe(2);
+                    expect(entries).toHaveLength(2);
                     expect(entries.map(({ messageCid }) => messageCid)).toEqual(expect.arrayContaining([itemTrueId, itemFalseId]));
                     const trueFilter = [{ published: true, schema: 'schema' }];
                     // equality true
                     const respTrue = await testIndex.query(tenant, trueFilter, { sortProperty: 'id' });
-                    expect(respTrue.length).toBe(1);
+                    expect(respTrue).toHaveLength(1);
                     expect(respTrue.map(({ messageCid }) => messageCid)).toEqual(expect.arrayContaining([itemTrueId]));
                     const falseFilter = [{ published: false, schema: 'schema' }];
                     // equality false
                     const respFalse = await testIndex.query(tenant, falseFilter, { sortProperty: 'id' });
-                    expect(respFalse.length).toBe(1);
+                    expect(respFalse).toHaveLength(1);
                     expect(respFalse.map(({ messageCid }) => messageCid)).toEqual(expect.arrayContaining([itemFalseId]));
                 });
             });
@@ -707,11 +707,11 @@ describe('IndexLevel', () => {
                     const filters = [{ schema: 'schema' }];
                     // limit results without cursor
                     let ascResults = await testIndex.query(tenant, filters, { sortProperty: 'val', limit: 2 });
-                    expect(ascResults.length).toBe(2);
+                    expect(ascResults).toHaveLength(2);
                     expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b']);
                     // limit results with a cursor
                     ascResults = await testIndex.query(tenant, filters, { sortProperty: 'val', limit: 2, cursor: IndexLevel.createCursorFromLastArrayItem(ascResults, 'val') });
-                    expect(ascResults.length).toBe(2);
+                    expect(ascResults).toHaveLength(2);
                     expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['c', 'd']);
                 });
                 it('can sort by any indexed property', async () => {
@@ -722,19 +722,19 @@ describe('IndexLevel', () => {
                     const filters = [{ schema: 'schema' }];
                     // sort by value ascending
                     const ascResults = await testIndex.query(tenant, filters, { sortProperty: 'val' });
-                    expect(ascResults.length).toBe(testVals.length);
+                    expect(ascResults).toHaveLength(testVals.length);
                     expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b', 'c', 'd']);
                     // sort by index ascending
                     const ascIndexResults = await testIndex.query(tenant, filters, { sortProperty: 'index' });
-                    expect(ascIndexResults.length).toBe(testVals.length);
+                    expect(ascIndexResults).toHaveLength(testVals.length);
                     expect(ascIndexResults.map(({ messageCid }) => messageCid)).toEqual(testVals);
                     // sort by value descending
                     const descResults = await testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending });
-                    expect(descResults.length).toBe(testVals.length);
+                    expect(descResults).toHaveLength(testVals.length);
                     expect(descResults.map(({ messageCid }) => messageCid)).toEqual(['d', 'c', 'b', 'a']);
                     // sort by index descending
                     const descIndexResults = await testIndex.query(tenant, filters, { sortProperty: 'index', sortDirection: SortDirection.Descending });
-                    expect(descIndexResults.length).toBe(testVals.length);
+                    expect(descIndexResults).toHaveLength(testVals.length);
                     expect(descIndexResults.map(({ messageCid }) => messageCid)).toEqual([...testVals].reverse());
                 });
                 it('sorts lexicographic', async () => {
@@ -745,11 +745,11 @@ describe('IndexLevel', () => {
                     const filters = [{ schema: 'schema' }];
                     // sort ascending
                     const ascResults = await testIndex.query(tenant, filters, { sortProperty: 'val' });
-                    expect(ascResults.length).toBe(4);
+                    expect(ascResults).toHaveLength(4);
                     expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b', 'c', 'd']);
                     // sort descending
                     const descResults = await testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending });
-                    expect(descResults.length).toBe(4);
+                    expect(descResults).toHaveLength(4);
                     expect(descResults.map(({ messageCid }) => messageCid)).toEqual(['d', 'c', 'b', 'a']);
                 });
                 it('sorts numeric with and without a cursor', async () => {
@@ -760,11 +760,11 @@ describe('IndexLevel', () => {
                     const filters = [{ schema: 'schema' }];
                     // sort ascending
                     const ascResults = await testIndex.query(tenant, filters, { sortProperty: 'val' });
-                    expect(ascResults.length).toBe(testVals.length);
+                    expect(ascResults).toHaveLength(testVals.length);
                     expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['-2', '-1', '0', '1', '2', '3', '4']);
                     // sort descending
                     const descResults = await testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending });
-                    expect(descResults.length).toEqual(testVals.length);
+                    expect(descResults).toHaveLength(testVals.length);
                     expect(descResults.map(({ messageCid }) => messageCid)).toEqual(['4', '3', '2', '1', '0', '-1', '-2']);
                 });
                 it('sorts range queries with or without a cursor', async () => {
@@ -1009,14 +1009,14 @@ describe('IndexLevel', () => {
             await testIndex.put(tenant, id1, doc1);
             await testIndex.put(tenant, id2, doc2);
             let result = await testIndex.query(tenant, [{ 'a': 'b', 'c': 'e' }], { sortProperty: 'id' });
-            expect(result.length).toBe(2);
+            expect(result).toHaveLength(2);
             expect(result.map(({ messageCid }) => messageCid)).toContain(id1);
             await testIndex.delete(tenant, id1);
             result = await testIndex.query(tenant, [{ 'a': 'b', 'c': 'e' }], { sortProperty: 'id' });
-            expect(result.length).toBe(1);
+            expect(result).toHaveLength(1);
             await testIndex.delete(tenant, id2);
             const allKeys = await ArrayUtility.fromAsyncGenerator(testIndex.db.keys());
-            expect(allKeys.length).toBe(0);
+            expect(allKeys).toHaveLength(0);
         });
         it('should not delete anything if aborted beforehand', async () => {
             const controller = new AbortController();
@@ -1034,7 +1034,7 @@ describe('IndexLevel', () => {
                 expect(e).toBe('reason');
             }
             const result = await testIndex.query(tenant, [{ foo: 'bar' }], { sortProperty: 'id' });
-            expect(result.length).toBe(1);
+            expect(result).toHaveLength(1);
             expect(result.map(({ messageCid }) => messageCid)).toContain(id);
         });
         it('does nothing when attempting to purge key that does not exist', async () => {
@@ -1049,7 +1049,7 @@ describe('IndexLevel', () => {
             // attempt purge an invalid id
             await testIndex.delete(tenant, 'invalidCid');
             const result = await testIndex.query(tenant, [{ foo: 'bar' }], { sortProperty: 'id' });
-            expect(result.length).toBe(1);
+            expect(result).toHaveLength(1);
             expect(result.map(({ messageCid }) => messageCid)).toContain(id);
         });
     });
@@ -1099,7 +1099,7 @@ describe('IndexLevel', () => {
     describe('createCursorFromLastArrayItem', () => {
         it('returns undefined if an empty array is provided', async () => {
             const cursor = IndexLevel.createCursorFromLastArrayItem([], 'someProperty');
-            expect(cursor).toBe(undefined);
+            expect(cursor).toBeUndefined();
         });
         it('returns a PaginationCursor for the last item given a valid sort property', async () => {
             const items = [{
@@ -1138,7 +1138,7 @@ describe('IndexLevel', () => {
         it('should encode positive digits and pad with leading zeros', () => {
             const expectedLength = String(Number.MAX_SAFE_INTEGER).length; //16
             const encoded = IndexLevel.encodeNumberValue(100);
-            expect(encoded.length).toBe(expectedLength);
+            expect(encoded).toHaveLength(expectedLength);
             expect(encoded).toBe('0000000000000100');
         });
         it('should encode negative digits as an offset with a prefix', () => {
@@ -1146,8 +1146,8 @@ describe('IndexLevel', () => {
             // expected length is maximum padding + the prefix.
             const expectedLength = (expectedPrefix + String(Number.MAX_SAFE_INTEGER)).length; //17
             const encoded = IndexLevel.encodeNumberValue(-100);
-            expect(encoded.length).toBe(String(Number.MIN_SAFE_INTEGER).length);
-            expect(encoded.length).toBe(expectedLength);
+            expect(encoded).toHaveLength(String(Number.MIN_SAFE_INTEGER).length);
+            expect(encoded).toHaveLength(expectedLength);
             expect(encoded).toBe('!9007199254740891');
         });
         it('should encode digits to sort using lexicographical comparison', () => {
@@ -1232,7 +1232,7 @@ describe('IndexLevel', () => {
                 });
                 // query using compound index (protocol + protocolPath sorted by messageTimestamp)
                 const results = await compoundIndex.query(compoundTenant, [{ protocol: 'https://protocol.xyz', protocolPath: 'chat/message' }], { sortProperty: 'messageTimestamp' });
-                expect(results.length).toBe(1);
+                expect(results).toHaveLength(1);
                 expect(results[0].messageCid).toBe(id);
             });
             it('should delete compound index entries during delete', async () => {
@@ -1246,12 +1246,12 @@ describe('IndexLevel', () => {
                 });
                 // verify it exists
                 let results = await compoundIndex.query(compoundTenant, [{ protocol: 'https://protocol.xyz', protocolPath: 'chat/message' }], { sortProperty: 'messageTimestamp' });
-                expect(results.length).toBe(1);
+                expect(results).toHaveLength(1);
                 // delete
                 await compoundIndex.delete(compoundTenant, id);
                 // verify compound index entries are removed
                 results = await compoundIndex.query(compoundTenant, [{ protocol: 'https://protocol.xyz', protocolPath: 'chat/message' }], { sortProperty: 'messageTimestamp' });
-                expect(results.length).toBe(0);
+                expect(results).toHaveLength(0);
             });
             it('should skip compound index entries when required properties are missing', async () => {
                 const id = uuid();
@@ -1263,7 +1263,7 @@ describe('IndexLevel', () => {
                 // the protocol+protocolPath compound index should not have entries
                 // query via the schema compound index should still work
                 const schemaResults = await compoundIndex.query(compoundTenant, [{ schema: 'https://schema.org/Message' }], { sortProperty: 'dateCreated' });
-                expect(schemaResults.length).toBe(1);
+                expect(schemaResults).toHaveLength(1);
                 expect(schemaResults[0].messageCid).toBe(id);
             });
         });
@@ -1283,7 +1283,7 @@ describe('IndexLevel', () => {
                     });
                 }
                 const results = await compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'thread/post' }], { sortProperty: 'messageTimestamp' });
-                expect(results.length).toBe(3);
+                expect(results).toHaveLength(3);
                 expect(results.map(r => r.messageCid)).toEqual(['msg-a', 'msg-b', 'msg-c']);
             });
             it('should return results sorted descending by the sort property', async () => {
@@ -1301,7 +1301,7 @@ describe('IndexLevel', () => {
                     });
                 }
                 const results = await compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'thread/post' }], { sortProperty: 'messageTimestamp', sortDirection: SortDirection.Descending });
-                expect(results.length).toBe(3);
+                expect(results).toHaveLength(3);
                 expect(results.map(r => r.messageCid)).toEqual(['msg-c', 'msg-b', 'msg-a']);
             });
             it('should support limit', async () => {
@@ -1313,7 +1313,7 @@ describe('IndexLevel', () => {
                     });
                 }
                 const results = await compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp', limit: 3 });
-                expect(results.length).toBe(3);
+                expect(results).toHaveLength(3);
                 expect(results.map(r => r.messageCid)).toEqual(['msg-0', 'msg-1', 'msg-2']);
             });
             it('should support cursor pagination ascending', async () => {
@@ -1326,12 +1326,12 @@ describe('IndexLevel', () => {
                 }
                 // first page
                 const page1 = await compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp', limit: 3 });
-                expect(page1.length).toBe(3);
+                expect(page1).toHaveLength(3);
                 expect(page1.map(r => r.messageCid)).toEqual(['msg-0', 'msg-1', 'msg-2']);
                 // second page using cursor
                 const cursor = IndexLevel.createCursorFromLastArrayItem(page1, 'messageTimestamp');
                 const page2 = await compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp', cursor });
-                expect(page2.length).toBe(3);
+                expect(page2).toHaveLength(3);
                 expect(page2.map(r => r.messageCid)).toEqual(['msg-3', 'msg-4', 'msg-5']);
             });
             it('should support cursor pagination descending', async () => {
@@ -1344,12 +1344,12 @@ describe('IndexLevel', () => {
                 }
                 // first page descending
                 const page1 = await compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp', sortDirection: SortDirection.Descending, limit: 3 });
-                expect(page1.length).toBe(3);
+                expect(page1).toHaveLength(3);
                 expect(page1.map(r => r.messageCid)).toEqual(['msg-5', 'msg-4', 'msg-3']);
                 // second page descending using cursor
                 const cursor = IndexLevel.createCursorFromLastArrayItem(page1, 'messageTimestamp');
                 const page2 = await compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp', sortDirection: SortDirection.Descending, cursor });
-                expect(page2.length).toBe(3);
+                expect(page2).toHaveLength(3);
                 expect(page2.map(r => r.messageCid)).toEqual(['msg-2', 'msg-1', 'msg-0']);
             });
             it('should verify residual filter properties in memory', async () => {
@@ -1365,7 +1365,7 @@ describe('IndexLevel', () => {
                 // compound index covers protocol+protocolPath+messageTimestamp but NOT published
                 // published should be verified as a residual filter
                 const results = await compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items', published: true }], { sortProperty: 'messageTimestamp' });
-                expect(results.length).toBe(2);
+                expect(results).toHaveLength(2);
                 expect(results.map(r => r.messageCid)).toEqual(['msg-0', 'msg-2']);
             });
             it('should only return results matching the specific filter values', async () => {
@@ -1387,7 +1387,7 @@ describe('IndexLevel', () => {
                 });
                 // query for only protocol.xyz + thread/post
                 const results = await compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'thread/post' }], { sortProperty: 'messageTimestamp' });
-                expect(results.length).toBe(1);
+                expect(results).toHaveLength(1);
                 expect(results[0].messageCid).toBe('msg-1');
             });
             it('should fall back to non-compound strategy for OR (multi-filter) queries', async () => {
@@ -1406,7 +1406,7 @@ describe('IndexLevel', () => {
                     { protocol: 'https://proto.xyz', protocolPath: 'thread/post' },
                     { protocol: 'https://proto.xyz', protocolPath: 'thread/reply' },
                 ], { sortProperty: 'messageTimestamp' });
-                expect(results.length).toBe(2);
+                expect(results).toHaveLength(2);
             });
             it('should prefer the compound index with the most properties', async () => {
                 // both compound indexes could potentially match a query with schema + dateCreated
@@ -1422,11 +1422,11 @@ describe('IndexLevel', () => {
                 });
                 // query using schema compound index
                 const schemaResults = await compoundIndex.query(compoundTenant, [{ schema: 'https://schema.org/Item' }], { sortProperty: 'dateCreated' });
-                expect(schemaResults.length).toBe(1);
+                expect(schemaResults).toHaveLength(1);
                 expect(schemaResults[0].messageCid).toBe('msg-1');
                 // query using protocol+protocolPath compound index
                 const protocolResults = await compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp' });
-                expect(protocolResults.length).toBe(1);
+                expect(protocolResults).toHaveLength(1);
                 expect(protocolResults[0].messageCid).toBe('msg-1');
             });
             it('should not use compound index when sort property does not match', async () => {
@@ -1441,7 +1441,7 @@ describe('IndexLevel', () => {
                 // this should NOT use the protocol-protocolPath-messageTimestamp compound index
                 // it should still return correct results via fallback strategy
                 const results = await compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'dateCreated' });
-                expect(results.length).toBe(1);
+                expect(results).toHaveLength(1);
             });
         });
         describe('count()', () => {
@@ -1534,12 +1534,12 @@ describe('IndexLevel', () => {
                 }
                 // first page
                 const page1 = await compoundIndex.query(compoundTenant, [{ schema: 'https://schema.org/Item' }], { sortProperty: 'dateCreated', limit: 3 });
-                expect(page1.length).toBe(3);
+                expect(page1).toHaveLength(3);
                 expect(page1.map(r => r.messageCid)).toEqual(['msg-0', 'msg-1', 'msg-2']);
                 // second page with cursor — this should still use the compound index
                 const cursor = IndexLevel.createCursorFromLastArrayItem(page1, 'dateCreated');
                 const page2 = await compoundIndex.query(compoundTenant, [{ schema: 'https://schema.org/Item' }], { sortProperty: 'dateCreated', cursor });
-                expect(page2.length).toBe(3);
+                expect(page2).toHaveLength(3);
                 expect(page2.map(r => r.messageCid)).toEqual(['msg-3', 'msg-4', 'msg-5']);
             });
         });