@naturalcycles/db-lib 9.27.0 → 10.0.0

package/dist/adapter/inmemory/queryInMemory.js

@@ -20,7 +20,10 @@ function queryInMemory(q, rows = []) {
     // .filter
     // eslint-disable-next-line unicorn/no-array-reduce
     rows = q._filters.reduce((rows, filter) => {
-        return rows.filter(row => FILTER_FNS[filter.op](row[filter.name], filter.val));
+        return rows.filter(row => {
+            const value = (0, js_lib_1._get)(row, filter.name);
+            return FILTER_FNS[filter.op](value, filter.val);
+        });
     }, rows);
     // .select(fieldNames)
     if (q._selectedFieldNames) {

package/dist/testing/daoTest.js

@@ -4,6 +4,7 @@ exports.runCommonDaoTest = runCommonDaoTest;
 const node_stream_1 = require("node:stream");
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
+const vitest_1 = require("vitest");
 const __1 = require("..");
 const common_dao_1 = require("../commondao/common.dao");
 const dbTest_1 = require("./dbTest");
@@ -23,52 +24,52 @@ function runCommonDaoTest(db, quirks = {}) {
     const item1 = items[0];
     const expectedItems = items.map(i => ({
         ...i,
-        updated: expect.any(Number),
+        updated: vitest_1.expect.any(Number),
     }));
-    test('ping', async () => {
+    (0, vitest_1.test)('ping', async () => {
         await dao.ping();
     });
     // CREATE TABLE, DROP
     if (support.createTable) {
-        test('createTable, dropIfExists=true', async () => {
+        (0, vitest_1.test)('createTable, dropIfExists=true', async () => {
             await dao.createTable(test_model_1.testItemBMJsonSchema, { dropIfExists: true });
         });
     }
     if (support.queries) {
         // DELETE ALL initially
-        test('deleteByIds test items', async () => {
+        (0, vitest_1.test)('deleteByIds test items', async () => {
             const rows = await dao.query().select(['id']).runQuery();
             await db.deleteByQuery(__1.DBQuery.create(test_model_1.TEST_TABLE).filter('id', 'in', rows.map(r => r.id)));
         });
         // QUERY empty
-        test('runQuery(all), runQueryCount should return empty', async () => {
-            expect(await dao.query().runQuery()).toEqual([]);
-            expect(await dao.query().runQueryCount()).toBe(0);
+        (0, vitest_1.test)('runQuery(all), runQueryCount should return empty', async () => {
+            (0, vitest_1.expect)(await dao.query().runQuery()).toEqual([]);
+            (0, vitest_1.expect)(await dao.query().runQueryCount()).toBe(0);
         });
     }
     // GET empty
-    test('getByIds(item1.id) should return empty', async () => {
+    (0, vitest_1.test)('getByIds(item1.id) should return empty', async () => {
         const [item1Loaded] = await dao.getByIds([item1.id]);
-        expect(item1Loaded).toBeUndefined();
-        expect(await dao.getById(item1.id)).toBeNull();
+        (0, vitest_1.expect)(item1Loaded).toBeUndefined();
+        (0, vitest_1.expect)(await dao.getById(item1.id)).toBeNull();
     });
-    test('getByIds([]) should return []', async () => {
-        expect(await dao.getByIds([])).toEqual([]);
+    (0, vitest_1.test)('getByIds([]) should return []', async () => {
+        (0, vitest_1.expect)(await dao.getByIds([])).toEqual([]);
     });
-    test('getByIds(...) should return empty', async () => {
-        expect(await dao.getByIds(['abc', 'abcd'])).toEqual([]);
+    (0, vitest_1.test)('getByIds(...) should return empty', async () => {
+        (0, vitest_1.expect)(await dao.getByIds(['abc', 'abcd'])).toEqual([]);
     });
     // TimeMachine
     if (support.timeMachine) {
-        test('getByIds(...) 10 minutes ago should return []', async () => {
-            expect(await dao.getByIds([item1.id, 'abc'], {
+        (0, vitest_1.test)('getByIds(...) 10 minutes ago should return []', async () => {
+            (0, vitest_1.expect)(await dao.getByIds([item1.id, 'abc'], {
                 readAt: js_lib_1.localTime.now().minus(10, 'minute').unix,
             })).toEqual([]);
         });
     }
     // SAVE
     if (support.nullValues) {
-        test('should allow to save and load null values', async () => {
+        (0, vitest_1.test)('should allow to save and load null values', async () => {
             const item3 = {
                 ...(0, test_model_1.createTestItemBM)(3),
                 k2: null,
@@ -77,12 +78,12 @@ function runCommonDaoTest(db, quirks = {}) {
             await dao.save(item3);
             const item3Loaded = await dao.requireById(item3.id);
             (0, dbTest_1.expectMatch)([item3], [item3Loaded], quirks);
-            expect(item3Loaded.k2).toBeNull();
-            expect(Object.keys(item3)).toContain('k2');
-            expect(item3.k2).toBeNull();
+            (0, vitest_1.expect)(item3Loaded.k2).toBeNull();
+            (0, vitest_1.expect)(Object.keys(item3)).toContain('k2');
+            (0, vitest_1.expect)(item3.k2).toBeNull();
         });
     }
-    test('undefined values should not be saved/loaded', async () => {
+    (0, vitest_1.test)('undefined values should not be saved/loaded', async () => {
         const item3 = {
             ...(0, test_model_1.createTestItemBM)(3),
             k2: undefined,
@@ -94,21 +95,21 @@ function runCommonDaoTest(db, quirks = {}) {
         expected.updated = item3.updated; // as it's mutated
         const item3Loaded = await dao.requireById(item3.id);
         (0, dbTest_1.expectMatch)([expected], [item3Loaded], quirks);
-        expect(item3Loaded.k2).toBeUndefined();
-        expect(Object.keys(item3Loaded)).not.toContain('k2');
-        expect(Object.keys(item3)).toContain('k2');
-        expect(item3.k2).toBeUndefined();
+        (0, vitest_1.expect)(item3Loaded.k2).toBeUndefined();
+        (0, vitest_1.expect)(Object.keys(item3Loaded)).not.toContain('k2');
+        (0, vitest_1.expect)(Object.keys(item3)).toContain('k2');
+        (0, vitest_1.expect)(item3.k2).toBeUndefined();
     });
-    test('saveBatch test items', async () => {
+    (0, vitest_1.test)('saveBatch test items', async () => {
         const itemsSaved = await dao.saveBatch(items);
-        expect(itemsSaved[0]).toBe(items[0]); // expect "same object" returned
+        (0, vitest_1.expect)(itemsSaved[0]).toBe(items[0]); // expect "same object" returned
         // no unnecessary mutation
         const { updated: _, ...clone } = itemsClone[0];
-        expect(items[0]).toMatchObject(clone);
+        (0, vitest_1.expect)(items[0]).toMatchObject(clone);
         (0, dbTest_1.expectMatch)(expectedItems, itemsSaved, quirks);
     });
     if (support.increment) {
-        test('increment', async () => {
+        (0, vitest_1.test)('increment', async () => {
             await dao.incrementBatch('k3', { id1: 1, id2: 2 });
             let rows = await dao.query().runQuery();
             rows = (0, js_lib_1._sortBy)(rows, r => r.id);
@@ -134,66 +135,74 @@ function runCommonDaoTest(db, quirks = {}) {
         });
     }
     // GET not empty
-    test('getByIds all items', async () => {
+    (0, vitest_1.test)('getByIds all items', async () => {
         const rows = await dao.getByIds(items.map(i => i.id).concat('abcd'));
         (0, dbTest_1.expectMatch)(expectedItems, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
     });
     // QUERY
     if (support.queries) {
-        test('runQuery(all) should return all items', async () => {
+        (0, vitest_1.test)('runQuery(all) should return all items', async () => {
             let rows = await dao.query().runQuery();
             rows = (0, js_lib_1._sortBy)(rows, r => r.id);
             (0, dbTest_1.expectMatch)(expectedItems, rows, quirks);
         });
         if (support.dbQueryFilter) {
-            test('query even=true', async () => {
+            (0, vitest_1.test)('query even=true', async () => {
                 let rows = await dao.query().filter('even', '==', true).runQuery();
                 rows = (0, js_lib_1._sortBy)(rows, r => r.id);
                 (0, dbTest_1.expectMatch)(expectedItems.filter(i => i.even), rows, quirks);
             });
+            (0, vitest_1.test)('query nested property', async () => {
+                let rows = await dao
+                    .query()
+                    .filter('nested.foo', '==', 1)
+                    .runQuery();
+                rows = (0, js_lib_1._sortBy)(rows, r => r.id);
+                (0, dbTest_1.expectMatch)(expectedItems.filter(i => i.nested?.foo === 1), rows, quirks);
+            });
         }
         if (support.dbQueryOrder) {
-            test('query order by k1 desc', async () => {
+            (0, vitest_1.test)('query order by k1 desc', async () => {
                 const rows = await dao.query().order('k1', true).runQuery();
                 (0, dbTest_1.expectMatch)([...expectedItems].reverse(), rows, quirks);
             });
         }
         if (support.dbQuerySelectFields) {
-            test('projection query with only ids', async () => {
+            (0, vitest_1.test)('projection query with only ids', async () => {
                 let rows = await dao.query().select(['id']).runQuery();
                 rows = (0, js_lib_1._sortBy)(rows, r => r.id);
                 (0, dbTest_1.expectMatch)(expectedItems.map(item => (0, js_lib_1._pick)(item, ['id'])), rows, quirks);
             });
         }
-        test('runQueryCount should return 3', async () => {
-            expect(await dao.query().runQueryCount()).toBe(3);
+        (0, vitest_1.test)('runQueryCount should return 3', async () => {
+            (0, vitest_1.expect)(await dao.query().runQueryCount()).toBe(3);
         });
     }
     // STREAM
     if (support.streaming) {
-        test('streamQueryForEach all', async () => {
+        (0, vitest_1.test)('streamQueryForEach all', async () => {
             let rows = [];
             await dao.query().streamQueryForEach(bm => void rows.push(bm));
             rows = (0, js_lib_1._sortBy)(rows, r => r.id);
             (0, dbTest_1.expectMatch)(expectedItems, rows, quirks);
         });
-        test('streamQuery all', async () => {
+        (0, vitest_1.test)('streamQuery all', async () => {
             let rows = await dao.query().streamQuery().toArray();
             rows = (0, js_lib_1._sortBy)(rows, r => r.id);
             (0, dbTest_1.expectMatch)(expectedItems, rows, quirks);
         });
-        test('streamQueryIdsForEach all', async () => {
+        (0, vitest_1.test)('streamQueryIdsForEach all', async () => {
             let ids = [];
             await dao.query().streamQueryIdsForEach(id => void ids.push(id));
             ids = ids.sort();
             (0, dbTest_1.expectMatch)(expectedItems.map(i => i.id), ids, quirks);
         });
-        test('streamQueryIds all', async () => {
+        (0, vitest_1.test)('streamQueryIds all', async () => {
             let ids = await dao.query().streamQueryIds().toArray();
             ids = ids.sort();
             (0, dbTest_1.expectMatch)(expectedItems.map(i => i.id), ids, quirks);
         });
-        test('streamSaveTransform', async () => {
+        (0, vitest_1.test)('streamSaveTransform', async () => {
             const items2 = (0, test_model_1.createTestItemsBM)(2).map(i => ({ ...i, id: i.id + '_str' }));
             const ids = items2.map(i => i.id);
             await (0, nodejs_lib_1._pipeline)([node_stream_1.Readable.from(items2), ...dao.streamSaveTransform()]);
@@ -205,18 +214,18 @@ function runCommonDaoTest(db, quirks = {}) {
     }
     // DELETE BY
     if (support.queries) {
-        test('deleteByQuery even=false', async () => {
+        (0, vitest_1.test)('deleteByQuery even=false', async () => {
             const deleted = await dao.query().filter('even', '==', false).deleteByQuery();
-            expect(deleted).toBe(items.filter(item => !item.even).length);
-            expect(await dao.query().runQueryCount()).toBe(1);
+            (0, vitest_1.expect)(deleted).toBe(items.filter(item => !item.even).length);
+            (0, vitest_1.expect)(await dao.query().runQueryCount()).toBe(1);
         });
-        test('cleanup', async () => {
+        (0, vitest_1.test)('cleanup', async () => {
             // CLEAN UP
             await dao.query().deleteByQuery();
         });
     }
     if (support.transactions) {
-        test('transaction happy path', async () => {
+        (0, vitest_1.test)('transaction happy path', async () => {
             // cleanup
             await dao.query().deleteByQuery();
             // Test that id, created, updated are created
@@ -226,10 +235,10 @@ function runCommonDaoTest(db, quirks = {}) {
                 await tx.save(dao, row);
             });
             const loaded = await dao.query().runQuery();
-            expect(loaded.length).toBe(1);
-            expect(loaded[0].id).toBeDefined();
-            expect(loaded[0].created).toBeGreaterThanOrEqual(now);
-            expect(loaded[0].updated).toBe(loaded[0].created);
+            (0, vitest_1.expect)(loaded.length).toBe(1);
+            (0, vitest_1.expect)(loaded[0].id).toBeDefined();
+            (0, vitest_1.expect)(loaded[0].created).toBeGreaterThanOrEqual(now);
+            (0, vitest_1.expect)(loaded[0].updated).toBe(loaded[0].created);
             await dao.runInTransaction(async (tx) => {
                 await tx.deleteById(dao, loaded[0].id);
             });
@@ -246,8 +255,8 @@ function runCommonDaoTest(db, quirks = {}) {
             const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
             (0, dbTest_1.expectMatch)(expected, rows, quirks);
         });
-        test('transaction rollback', async () => {
-            await expect(dao.runInTransaction(async (tx) => {
+        (0, vitest_1.test)('transaction rollback', async () => {
+            await (0, vitest_1.expect)(dao.runInTransaction(async (tx) => {
                 await tx.deleteById(dao, items[2].id);
                 await tx.save(dao, { ...items[0], k1: 5 }); // it should fail here
             })).rejects.toThrow();
@@ -256,7 +265,7 @@ function runCommonDaoTest(db, quirks = {}) {
             (0, dbTest_1.expectMatch)(expected, rows, quirks);
         });
         if (support.queries) {
-            test('transaction cleanup', async () => {
+            (0, vitest_1.test)('transaction cleanup', async () => {
                 await dao.query().deleteByQuery();
             });
         }

package/dist/testing/dbTest.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommonDBTest = runCommonDBTest;
 exports.expectMatch = expectMatch;
 const js_lib_1 = require("@naturalcycles/js-lib");
+const vitest_1 = require("vitest");
 const common_db_1 = require("../common.db");
 const dbQuery_1 = require("../query/dbQuery");
 const test_model_1 = require("./test.model");
@@ -12,50 +13,50 @@ function runCommonDBTest(db, quirks = {}) {
     (0, js_lib_1._deepFreeze)(items);
     const item1 = items[0];
     const queryAll = () => dbQuery_1.DBQuery.create(test_model_1.TEST_TABLE);
-    test('ping', async () => {
+    (0, vitest_1.test)('ping', async () => {
         await db.ping();
     });
     // CREATE TABLE, DROP
     if (support.createTable) {
-        test('createTable, dropIfExists=true', async () => {
+        (0, vitest_1.test)('createTable, dropIfExists=true', async () => {
             await db.createTable(test_model_1.TEST_TABLE, test_model_1.testItemBMJsonSchema, { dropIfExists: true });
         });
     }
     if (support.queries) {
         // DELETE ALL initially
-        test('deleteByIds test items', async () => {
+        (0, vitest_1.test)('deleteByIds test items', async () => {
             const { rows } = await db.runQuery(queryAll().select(['id']));
             await db.deleteByQuery(queryAll().filterIn('id', rows.map(i => i.id)));
         });
         // QUERY empty
-        test('runQuery(all), runQueryCount should return empty', async () => {
-            expect((await db.runQuery(queryAll())).rows).toEqual([]);
-            expect(await db.runQueryCount(queryAll())).toBe(0);
+        (0, vitest_1.test)('runQuery(all), runQueryCount should return empty', async () => {
+            (0, vitest_1.expect)((await db.runQuery(queryAll())).rows).toEqual([]);
+            (0, vitest_1.expect)(await db.runQueryCount(queryAll())).toBe(0);
         });
     }
     // GET empty
-    test('getByIds(item1.id) should return empty', async () => {
+    (0, vitest_1.test)('getByIds(item1.id) should return empty', async () => {
         const [item1Loaded] = await db.getByIds(test_model_1.TEST_TABLE, [item1.id]);
         // console.log(a)
-        expect(item1Loaded).toBeUndefined();
+        (0, vitest_1.expect)(item1Loaded).toBeUndefined();
     });
-    test('getByIds([]) should return []', async () => {
-        expect(await db.getByIds(test_model_1.TEST_TABLE, [])).toEqual([]);
+    (0, vitest_1.test)('getByIds([]) should return []', async () => {
+        (0, vitest_1.expect)(await db.getByIds(test_model_1.TEST_TABLE, [])).toEqual([]);
     });
-    test('getByIds(...) should return empty', async () => {
-        expect(await db.getByIds(test_model_1.TEST_TABLE, ['abc', 'abcd'])).toEqual([]);
+    (0, vitest_1.test)('getByIds(...) should return empty', async () => {
+        (0, vitest_1.expect)(await db.getByIds(test_model_1.TEST_TABLE, ['abc', 'abcd'])).toEqual([]);
     });
     // TimeMachine
     if (support.timeMachine) {
-        test('getByIds(...) 10 minutes ago should return []', async () => {
-            expect(await db.getByIds(test_model_1.TEST_TABLE, [item1.id, 'abc'], {
+        (0, vitest_1.test)('getByIds(...) 10 minutes ago should return []', async () => {
+            (0, vitest_1.expect)(await db.getByIds(test_model_1.TEST_TABLE, [item1.id, 'abc'], {
                 readAt: js_lib_1.localTime.now().minus(10, 'minute').unix,
             })).toEqual([]);
         });
     }
     // SAVE
     if (support.nullValues) {
-        test('should allow to save and load null values', async () => {
+        (0, vitest_1.test)('should allow to save and load null values', async () => {
             const item3 = {
                 ...(0, test_model_1.createTestItemDBM)(3),
                 k2: null,
@@ -64,11 +65,11 @@ function runCommonDBTest(db, quirks = {}) {
             await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
             const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
             expectMatch([item3], [item3Loaded], quirks);
-            expect(item3Loaded.k2).toBeNull();
+            (0, vitest_1.expect)(item3Loaded.k2).toBeNull();
         });
     }
     if (db.dbType === common_db_1.CommonDBType.document) {
-        test('undefined values should not be saved/loaded', async () => {
+        (0, vitest_1.test)('undefined values should not be saved/loaded', async () => {
             const item3 = {
                 ...(0, test_model_1.createTestItemDBM)(3),
                 k2: undefined,
@@ -79,45 +80,45 @@ function runCommonDBTest(db, quirks = {}) {
             await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
             const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
             expectMatch([expected], [item3Loaded], quirks);
-            expect(item3Loaded.k2).toBeUndefined();
-            expect(Object.keys(item3Loaded)).not.toContain('k2');
+            (0, vitest_1.expect)(item3Loaded.k2).toBeUndefined();
+            (0, vitest_1.expect)(Object.keys(item3Loaded)).not.toContain('k2');
         });
     }
     if (support.updateSaveMethod) {
-        test('saveBatch UPDATE method should throw', async () => {
-            await expect(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'update' })).rejects.toThrow();
+        (0, vitest_1.test)('saveBatch UPDATE method should throw', async () => {
+            await (0, vitest_1.expect)(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'update' })).rejects.toThrow();
         });
     }
-    test('saveBatch test items', async () => {
+    (0, vitest_1.test)('saveBatch test items', async () => {
         await db.saveBatch(test_model_1.TEST_TABLE, items);
     });
-    test('saveBatch should throw on null id', async () => {
-        await expect(db.saveBatch(test_model_1.TEST_TABLE, [{ ...item1, id: null }])).rejects.toThrow();
+    (0, vitest_1.test)('saveBatch should throw on null id', async () => {
+        await (0, vitest_1.expect)(db.saveBatch(test_model_1.TEST_TABLE, [{ ...item1, id: null }])).rejects.toThrow();
     });
     if (support.insertSaveMethod) {
-        test('saveBatch INSERT method should throw', async () => {
-            await expect(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'insert' })).rejects.toThrow();
+        (0, vitest_1.test)('saveBatch INSERT method should throw', async () => {
+            await (0, vitest_1.expect)(db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'insert' })).rejects.toThrow();
         });
     }
     if (support.updateSaveMethod) {
-        test('saveBatch UPDATE method should pass', async () => {
+        (0, vitest_1.test)('saveBatch UPDATE method should pass', async () => {
             await db.saveBatch(test_model_1.TEST_TABLE, items, { saveMethod: 'update' });
         });
     }
     // GET not empty
-    test('getByIds all items', async () => {
+    (0, vitest_1.test)('getByIds all items', async () => {
         const rows = await db.getByIds(test_model_1.TEST_TABLE, items.map(i => i.id).concat('abcd'));
         expectMatch(items, (0, js_lib_1._sortBy)(rows, r => r.id), quirks);
     });
     // QUERY
     if (support.queries) {
-        test('runQuery(all) should return all items', async () => {
+        (0, vitest_1.test)('runQuery(all) should return all items', async () => {
             let { rows } = await db.runQuery(queryAll());
             rows = (0, js_lib_1._sortBy)(rows, r => r.id); // because query doesn't specify order here
             expectMatch(items, rows, quirks);
         });
         if (support.dbQueryFilter) {
-            test('query even=true', async () => {
+            (0, vitest_1.test)('query even=true', async () => {
                 const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).filter('even', '==', true);
                 let { rows } = await db.runQuery(q);
                 if (!support.dbQueryOrder)
@@ -126,67 +127,67 @@ function runCommonDBTest(db, quirks = {}) {
             });
         }
         if (support.dbQueryOrder) {
-            test('query order by k1 desc', async () => {
+            (0, vitest_1.test)('query order by k1 desc', async () => {
                 const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).order('k1', true);
                 const { rows } = await db.runQuery(q);
                 expectMatch([...items].reverse(), rows, quirks);
             });
         }
         if (support.dbQuerySelectFields) {
-            test('projection query with only ids', async () => {
+            (0, vitest_1.test)('projection query with only ids', async () => {
                 const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).select(['id']);
                 let { rows } = await db.runQuery(q);
                 rows = (0, js_lib_1._sortBy)(rows, r => r.id); // cause order is not specified
                 expectMatch(items.map(item => (0, js_lib_1._pick)(item, ['id'])), rows, quirks);
             });
-            test('projection query without ids', async () => {
+            (0, vitest_1.test)('projection query without ids', async () => {
                 const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).select(['k1']);
                 let { rows } = await db.runQuery(q);
                 rows = (0, js_lib_1._sortBy)(rows, r => r.k1); // cause order is not specified
                 expectMatch(items.map(item => (0, js_lib_1._pick)(item, ['k1'])), rows, quirks);
             });
-            test('projection query empty fields (edge case)', async () => {
+            (0, vitest_1.test)('projection query empty fields (edge case)', async () => {
                 const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).select([]);
                 const { rows } = await db.runQuery(q);
                 expectMatch(items.map(() => ({})), rows, quirks);
             });
         }
-        test('runQueryCount should return 3', async () => {
-            expect(await db.runQueryCount(new dbQuery_1.DBQuery(test_model_1.TEST_TABLE))).toBe(3);
+        (0, vitest_1.test)('runQueryCount should return 3', async () => {
+            (0, vitest_1.expect)(await db.runQueryCount(new dbQuery_1.DBQuery(test_model_1.TEST_TABLE))).toBe(3);
         });
     }
     // STREAM
     if (support.streaming) {
-        test('streamQuery all', async () => {
+        (0, vitest_1.test)('streamQuery all', async () => {
             let rows = await db.streamQuery(queryAll()).toArray();
             rows = (0, js_lib_1._sortBy)(rows, r => r.id); // cause order is not specified in DBQuery
             expectMatch(items, rows, quirks);
         });
     }
     // getTables
-    test('getTables, getTableSchema (if supported)', async () => {
+    (0, vitest_1.test)('getTables, getTableSchema (if supported)', async () => {
         const tables = await db.getTables();
         // console.log({ tables })
         if (support.tableSchemas) {
             await (0, js_lib_1.pMap)(tables, async (table) => {
                 const schema = await db.getTableSchema(table);
                 // console.log(schema)
-                expect(schema.$id).toBe(`${table}.schema.json`);
+                (0, vitest_1.expect)(schema.$id).toBe(`${table}.schema.json`);
             });
         }
     });
     // DELETE BY
     if (support.queries && support.dbQueryFilter) {
-        test('deleteByQuery even=false', async () => {
+        (0, vitest_1.test)('deleteByQuery even=false', async () => {
             const q = new dbQuery_1.DBQuery(test_model_1.TEST_TABLE).filter('even', '==', false);
             const deleted = await db.deleteByQuery(q);
-            expect(deleted).toBe(items.filter(item => !item.even).length);
-            expect(await db.runQueryCount(queryAll())).toBe(1);
+            (0, vitest_1.expect)(deleted).toBe(items.filter(item => !item.even).length);
+            (0, vitest_1.expect)(await db.runQueryCount(queryAll())).toBe(1);
         });
     }
     // BUFFER
     if (support.bufferValues) {
-        test('buffer values', async () => {
+        (0, vitest_1.test)('buffer values', async () => {
             const s = 'helloWorld 1';
             const b1 = Buffer.from(s);
             const item = {
@@ -204,12 +205,12 @@ function runCommonDBTest(db, quirks = {}) {
             //   b1,
             //   b1Loaded,
             // })
-            expect(b1Loaded).toEqual(b1);
-            expect(b1Loaded.toString()).toBe(s);
+            (0, vitest_1.expect)(b1Loaded).toEqual(b1);
+            (0, vitest_1.expect)(b1Loaded.toString()).toBe(s);
         });
     }
     if (support.transactions) {
-        test('transaction happy path', async () => {
+        (0, vitest_1.test)('transaction happy path', async () => {
             // cleanup
             await db.deleteByQuery(queryAll());
             // saveBatch [item1, 2, 3]
@@ -225,7 +226,7 @@ function runCommonDBTest(db, quirks = {}) {
             const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
             expectMatch(expected, rows, quirks);
         });
-        test('transaction rollback', async () => {
+        (0, vitest_1.test)('transaction rollback', async () => {
             let err;
             try {
                 await db.runInTransaction(async (tx) => {
@@ -237,14 +238,14 @@ function runCommonDBTest(db, quirks = {}) {
             catch (err_) {
                 err = err_;
             }
-            expect(err).toBeDefined();
+            (0, vitest_1.expect)(err).toBeDefined();
             const { rows } = await db.runQuery(queryAll());
             const expected = [items[0], { ...items[2], k1: 'k1_mod' }];
             expectMatch(expected, rows, quirks);
         });
     }
     if (support.patchByQuery) {
-        test('patchByQuery', async () => {
+        (0, vitest_1.test)('patchByQuery', async () => {
             // cleanup, reset initial data
             await db.deleteByQuery(queryAll());
             await db.saveBatch(test_model_1.TEST_TABLE, items);
@@ -264,7 +265,7 @@ function runCommonDBTest(db, quirks = {}) {
         });
     }
     if (support.increment) {
-        test('incrementBatch', async () => {
+        (0, vitest_1.test)('incrementBatch', async () => {
             // cleanup, reset initial data
             await db.deleteByQuery(queryAll());
             await db.saveBatch(test_model_1.TEST_TABLE, items);
@@ -283,7 +284,7 @@ function runCommonDBTest(db, quirks = {}) {
         });
     }
     if (support.queries) {
-        test('cleanup', async () => {
+        (0, vitest_1.test)('cleanup', async () => {
             // CLEAN UP
             await db.deleteByQuery(queryAll());
         });
@@ -298,9 +299,9 @@ function expectMatch(expected, actual, quirks) {
         });
     }
     if (quirks.allowExtraPropertiesInResponse) {
-        expect(actual).toMatchObject(expected);
+        (0, vitest_1.expect)(actual).toMatchObject(expected);
     }
     else {
-        expect(actual).toEqual(expected);
+        (0, vitest_1.expect)(actual).toEqual(expected);
     }
 }

package/dist/testing/keyValueDBTest.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommonKeyValueDBTest = runCommonKeyValueDBTest;
 const js_lib_1 = require("@naturalcycles/js-lib");
+const vitest_1 = require("vitest");
 const test_model_1 = require("./test.model");
 const testIds = (0, js_lib_1._range)(1, 4).map(n => `id${n}`);
 const testEntries = testIds.map(id => [
@@ -9,7 +10,7 @@ const testEntries = testIds.map(id => [
     Buffer.from(`${id}value`),
 ]);
 function runCommonKeyValueDBTest(db) {
-    beforeAll(async () => {
+    (0, vitest_1.beforeAll)(async () => {
         // Tests in this suite are not isolated,
         // and failing tests can leave the DB in an unexpected state for other tests,
         // including the following test run.
@@ -17,98 +18,98 @@ function runCommonKeyValueDBTest(db) {
         const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
         await db.deleteByIds(test_model_1.TEST_TABLE, ids);
     });
-    afterAll(async () => {
+    (0, vitest_1.afterAll)(async () => {
         const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
         await db.deleteByIds(test_model_1.TEST_TABLE, ids);
     });
     const { support } = db;
-    test('ping', async () => {
+    (0, vitest_1.test)('ping', async () => {
         await db.ping();
     });
-    test('createTable', async () => {
+    (0, vitest_1.test)('createTable', async () => {
         await db.createTable(test_model_1.TEST_TABLE, { dropIfExists: true });
     });
-    test('deleteByIds non existing', async () => {
+    (0, vitest_1.test)('deleteByIds non existing', async () => {
         await db.deleteByIds(test_model_1.TEST_TABLE, testIds);
     });
-    test('getByIds should return empty', async () => {
+    (0, vitest_1.test)('getByIds should return empty', async () => {
         const results = await db.getByIds(test_model_1.TEST_TABLE, testIds);
-        expect(results).toEqual([]);
+        (0, vitest_1.expect)(results).toEqual([]);
     });
-    test('count should be 0', async () => {
-        expect(await db.count(test_model_1.TEST_TABLE)).toBe(0);
+    (0, vitest_1.test)('count should be 0', async () => {
+        (0, vitest_1.expect)(await db.count(test_model_1.TEST_TABLE)).toBe(0);
     });
-    test('saveBatch, then getByIds', async () => {
+    (0, vitest_1.test)('saveBatch, then getByIds', async () => {
         await db.saveBatch(test_model_1.TEST_TABLE, testEntries);
         const entries = await db.getByIds(test_model_1.TEST_TABLE, testIds);
         (0, js_lib_1._sortBy)(entries, e => e[0], true);
-        expect(entries).toEqual(testEntries);
+        (0, vitest_1.expect)(entries).toEqual(testEntries);
     });
     if (support.count) {
-        test('count should be 3', async () => {
-            expect(await db.count(test_model_1.TEST_TABLE)).toBe(3);
+        (0, vitest_1.test)('count should be 3', async () => {
+            (0, vitest_1.expect)(await db.count(test_model_1.TEST_TABLE)).toBe(3);
         });
     }
-    test('streamIds', async () => {
+    (0, vitest_1.test)('streamIds', async () => {
         const ids = await db.streamIds(test_model_1.TEST_TABLE).toArray();
         ids.sort();
-        expect(ids).toEqual(testIds);
+        (0, vitest_1.expect)(ids).toEqual(testIds);
     });
-    test('streamIds limited', async () => {
+    (0, vitest_1.test)('streamIds limited', async () => {
         const idsLimited = await db.streamIds(test_model_1.TEST_TABLE, 2).toArray();
         // Order is non-deterministic, so, cannot compare values
         // idsLimited.sort()
         // expect(idsLimited).toEqual(testIds.slice(0, 2))
-        expect(idsLimited.length).toBe(2);
+        (0, vitest_1.expect)(idsLimited.length).toBe(2);
     });
-    test('streamValues', async () => {
+    (0, vitest_1.test)('streamValues', async () => {
         const values = await db.streamValues(test_model_1.TEST_TABLE).toArray();
         values.sort();
-        expect(values).toEqual(testEntries.map(e => e[1]));
+        (0, vitest_1.expect)(values).toEqual(testEntries.map(e => e[1]));
     });
-    test('streamValues limited', async () => {
+    (0, vitest_1.test)('streamValues limited', async () => {
         const valuesLimited = await db.streamValues(test_model_1.TEST_TABLE, 2).toArray();
         // valuesLimited.sort()
         // expect(valuesLimited).toEqual(testEntries.map(e => e[1]).slice(0, 2))
-        expect(valuesLimited.length).toBe(2);
+        (0, vitest_1.expect)(valuesLimited.length).toBe(2);
     });
-    test('streamEntries', async () => {
+    (0, vitest_1.test)('streamEntries', async () => {
         const entries = await db.streamEntries(test_model_1.TEST_TABLE).toArray();
         entries.sort();
-        expect(entries).toEqual(testEntries);
+        (0, vitest_1.expect)(entries).toEqual(testEntries);
     });
-    test('streamEntries limited', async () => {
+    (0, vitest_1.test)('streamEntries limited', async () => {
         const entriesLimited = await db.streamEntries(test_model_1.TEST_TABLE, 2).toArray();
         // entriesLimited.sort()
         // expect(entriesLimited).toEqual(testEntries.slice(0, 2))
-        expect(entriesLimited.length).toBe(2);
+        (0, vitest_1.expect)(entriesLimited.length).toBe(2);
     });
-    test('deleteByIds should clear', async () => {
+    (0, vitest_1.test)('deleteByIds should clear', async () => {
         await db.deleteByIds(test_model_1.TEST_TABLE, testIds);
         const results = await db.getByIds(test_model_1.TEST_TABLE, testIds);
-        expect(results).toEqual([]);
+        (0, vitest_1.expect)(results).toEqual([]);
     });
     if (support.increment) {
         const id = 'nonExistingField';
         const id2 = 'nonExistingField2';
-        test('increment on a non-existing field should set the value to 1', async () => {
+        (0, vitest_1.test)('increment on a non-existing field should set the value to 1', async () => {
             const result = await db.incrementBatch(test_model_1.TEST_TABLE, [[id, 1]]);
-            expect(result).toEqual([[id, 1]]);
+            (0, vitest_1.expect)(result).toEqual([[id, 1]]);
         });
-        test('increment on a existing field should increase the value by one', async () => {
+        (0, vitest_1.test)('increment on a existing field should increase the value by one', async () => {
             const result = await db.incrementBatch(test_model_1.TEST_TABLE, [[id, 1]]);
-            expect(result).toEqual([[id, 2]]);
+            (0, vitest_1.expect)(result).toEqual([[id, 2]]);
         });
-        test('increment should increase the value by the specified amount', async () => {
+        (0, vitest_1.test)('increment should increase the value by the specified amount', async () => {
             const result = await db.incrementBatch(test_model_1.TEST_TABLE, [[id, 2]]);
-            expect(result).toEqual([[id, 4]]);
+            (0, vitest_1.expect)(result).toEqual([[id, 4]]);
         });
-        test('increment 2 ids at the same time', async () => {
+        (0, vitest_1.test)('increment 2 ids at the same time', async () => {
             const result = await db.incrementBatch(test_model_1.TEST_TABLE, [
                 [id, 1],
                 [id2, 2],
             ]);
-            expect(Object.fromEntries(result)).toEqual({
+            (0, vitest_1.expect)(Object.fromEntries(result)).toEqual({
                 [id]: 5,
                 [id2]: 2,
             });

package/dist/testing/keyValueDaoTest.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommonKeyValueDaoTest = runCommonKeyValueDaoTest;
 const js_lib_1 = require("@naturalcycles/js-lib");
+const vitest_1 = require("vitest");
 const commonKeyValueDao_1 = require("../kv/commonKeyValueDao");
 const test_model_1 = require("./test.model");
 const testItems = (0, test_model_1.createTestItemsBM)(4);
@@ -14,7 +15,7 @@ function runCommonKeyValueDaoTest(db) {
         // todo: make this test support "deflatedJson" transformer
     });
     const { support } = db;
-    beforeAll(async () => {
+    (0, vitest_1.beforeAll)(async () => {
         // Tests in this suite are not isolated,
         // and failing tests can leave the DB in an unexpected state for other tests,
         // including the following test run.
@@ -22,92 +23,92 @@ function runCommonKeyValueDaoTest(db) {
         const ids = await dao.streamIds().toArray();
         await dao.deleteByIds(ids);
     });
-    afterAll(async () => {
+    (0, vitest_1.afterAll)(async () => {
         const ids = await dao.streamIds().toArray();
         await dao.deleteByIds(ids);
     });
-    test('ping', async () => {
+    (0, vitest_1.test)('ping', async () => {
         await dao.ping();
     });
-    test('createTable', async () => {
+    (0, vitest_1.test)('createTable', async () => {
         await dao.createTable({ dropIfExists: true });
     });
-    test('deleteByIds non existing', async () => {
+    (0, vitest_1.test)('deleteByIds non existing', async () => {
         await dao.deleteByIds(testIds);
     });
-    test('getByIds should return empty', async () => {
+    (0, vitest_1.test)('getByIds should return empty', async () => {
         const results = await dao.getByIds(testIds);
-        expect(results).toEqual([]);
+        (0, vitest_1.expect)(results).toEqual([]);
     });
-    test('saveBatch, then getByIds', async () => {
+    (0, vitest_1.test)('saveBatch, then getByIds', async () => {
         await dao.saveBatch(testEntries);
         const entries = await dao.getByIds(testIds);
         // console.log(typeof entries[0]![1], entries[0]![1])
         (0, js_lib_1._sortBy)(entries, e => e[0], true);
-        expect(entries).toEqual(testEntries); // Jest doesn't allow to compare Buffers directly
+        (0, vitest_1.expect)(entries).toEqual(testEntries); // Jest doesn't allow to compare Buffers directly
         // expect(entries.map(e => e[0])).toEqual(testEntries.map(e => e[0]))
         // expect(entries.map(e => e[1].toString())).toEqual(testEntries.map(e => e[1].toString()))
     });
-    test('streamIds', async () => {
+    (0, vitest_1.test)('streamIds', async () => {
         const ids = await dao.streamIds().toArray();
         ids.sort();
-        expect(ids).toEqual(testIds);
+        (0, vitest_1.expect)(ids).toEqual(testIds);
     });
-    test('streamIds limited', async () => {
+    (0, vitest_1.test)('streamIds limited', async () => {
         const idsLimited = await dao.streamIds(2).toArray();
         // Order is non-deterministic, so, cannot compare values
         // idsLimited.sort()
         // expect(idsLimited).toEqual(testIds.slice(0, 2))
-        expect(idsLimited.length).toBe(2);
+        (0, vitest_1.expect)(idsLimited.length).toBe(2);
     });
-    test('streamValues', async () => {
+    (0, vitest_1.test)('streamValues', async () => {
         const values = await dao.streamValues().toArray();
         values.sort();
-        expect(values).toEqual(testEntries.map(e => e[1]));
+        (0, vitest_1.expect)(values).toEqual(testEntries.map(e => e[1]));
     });
-    test('streamValues limited', async () => {
+    (0, vitest_1.test)('streamValues limited', async () => {
         const valuesLimited = await dao.streamValues(2).toArray();
         // valuesLimited.sort()
         // expect(valuesLimited).toEqual(testEntries.map(e => e[1]).slice(0, 2))
-        expect(valuesLimited.length).toBe(2);
+        (0, vitest_1.expect)(valuesLimited.length).toBe(2);
     });
-    test('streamEntries', async () => {
+    (0, vitest_1.test)('streamEntries', async () => {
         const entries = await dao.streamEntries().toArray();
         entries.sort();
-        expect(entries).toEqual(testEntries);
+        (0, vitest_1.expect)(entries).toEqual(testEntries);
     });
-    test('streamEntries limited', async () => {
+    (0, vitest_1.test)('streamEntries limited', async () => {
         const entriesLimited = await dao.streamEntries(2).toArray();
         // entriesLimited.sort()
         // expect(entriesLimited).toEqual(testEntries.slice(0, 2))
-        expect(entriesLimited.length).toBe(2);
+        (0, vitest_1.expect)(entriesLimited.length).toBe(2);
     });
-    test('deleteByIds should clear', async () => {
+    (0, vitest_1.test)('deleteByIds should clear', async () => {
         await dao.deleteByIds(testIds);
         const results = await dao.getByIds(testIds);
-        expect(results).toEqual([]);
+        (0, vitest_1.expect)(results).toEqual([]);
     });
     if (support.increment) {
         const id = 'nonExistingField';
         const id2 = 'nonExistingField2';
-        test('increment on a non-existing field should set the value to 1', async () => {
+        (0, vitest_1.test)('increment on a non-existing field should set the value to 1', async () => {
             const result = await dao.increment(id);
-            expect(result).toBe(1);
+            (0, vitest_1.expect)(result).toBe(1);
         });
-        test('increment on a existing field should increase the value by one', async () => {
+        (0, vitest_1.test)('increment on a existing field should increase the value by one', async () => {
             const result = await dao.increment(id);
-            expect(result).toBe(2);
+            (0, vitest_1.expect)(result).toBe(2);
         });
-        test('increment should increase the value by the specified amount', async () => {
+        (0, vitest_1.test)('increment should increase the value by the specified amount', async () => {
             const result = await dao.increment(id, 2);
-            expect(result).toBe(4);
+            (0, vitest_1.expect)(result).toBe(4);
         });
-        test('increment 2 ids at the same time', async () => {
+        (0, vitest_1.test)('increment 2 ids at the same time', async () => {
             const result = await dao.incrementBatch([
                 [id, 1],
                 [id2, 2],
             ]);
-            expect(Object.fromEntries(result)).toEqual({
+            (0, vitest_1.expect)(Object.fromEntries(result)).toEqual({
                 [id]: 5,
                 [id2]: 2,
             });

package/dist/testing/test.model.d.ts

@@ -6,6 +6,9 @@ export interface TestItemBM extends BaseDBEntity {
     k3?: number;
     even?: boolean;
     b1?: Buffer;
+    nested?: {
+        foo: number;
+    };
 }
 export interface TestItemDBM extends TestItemBM {
 }

package/dist/testing/test.model.js

@@ -15,6 +15,9 @@ exports.testItemBMSchema = (0, nodejs_lib_1.objectSchema)({
     k3: nodejs_lib_1.numberSchema.optional(),
     even: nodejs_lib_1.booleanSchema.optional(),
     b1: nodejs_lib_1.binarySchema.optional(),
+    nested: (0, nodejs_lib_1.objectSchema)({
+        foo: nodejs_lib_1.numberSchema,
+    }).optional(),
 }).concat(nodejs_lib_1.baseDBEntitySchema);
 exports.testItemTMSchema = (0, nodejs_lib_1.objectSchema)({
     k1: nodejs_lib_1.stringSchema,
@@ -41,6 +44,7 @@ function createTestItemDBM(num = 1) {
         k2: `v${num * 2}`,
         k3: num,
         even: num % 2 === 0,
+        nested: { foo: num },
         created: MOCK_TS_2018_06_21,
         updated: MOCK_TS_2018_06_21,
     };

package/package.json

@@ -14,9 +14,10 @@
   },
   "devDependencies": {
     "@naturalcycles/bench-lib": "^3",
-    "@naturalcycles/dev-lib": "^15",
+    "@naturalcycles/dev-lib": "^16",
     "@types/node": "^22",
-    "jest": "^29"
+    "@vitest/coverage-v8": "^3",
+    "vitest": "^3"
   },
   "files": [
     "dist",
@@ -43,9 +44,9 @@
     "url": "https://github.com/NaturalCycles/db-lib"
   },
   "engines": {
-    "node": ">=22.10.0"
+    "node": ">=22.12.0"
   },
-  "version": "9.27.0",
+  "version": "10.0.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/adapter/inmemory/queryInMemory.ts

@@ -1,4 +1,4 @@
-import { _pick, ObjectWithId } from '@naturalcycles/js-lib'
+import { _get, _pick, ObjectWithId } from '@naturalcycles/js-lib'
 import { DBQuery, DBQueryFilterOperator } from '../../query/dbQuery'
 
 type FilterFn = (v: any, val: any) => boolean
@@ -22,7 +22,10 @@ export function queryInMemory<ROW extends ObjectWithId>(q: DBQuery<ROW>, rows: R
   // .filter
   // eslint-disable-next-line unicorn/no-array-reduce
   rows = q._filters.reduce((rows, filter) => {
-    return rows.filter(row => FILTER_FNS[filter.op](row[filter.name], filter.val))
+    return rows.filter(row => {
+      const value = _get(row, filter.name as string)
+      return FILTER_FNS[filter.op](value, filter.val)
+    })
   }, rows)
 
   // .select(fieldNames)

package/src/testing/daoTest.ts

@@ -1,6 +1,7 @@
 import { Readable } from 'node:stream'
 import { _deepCopy, _omit, _pick, _sortBy, localTime } from '@naturalcycles/js-lib'
 import { _pipeline } from '@naturalcycles/nodejs-lib'
+import { expect, test } from 'vitest'
 import { CommonDaoLogLevel, DBQuery } from '..'
 import { CommonDB } from '../common.db'
 import { CommonDao } from '../commondao/common.dao'
@@ -196,6 +197,19 @@ export function runCommonDaoTest(db: CommonDB, quirks: CommonDBImplementationQui
           quirks,
         )
       })
+
+      test('query nested property', async () => {
+        let rows = await dao
+          .query()
+          .filter('nested.foo' as any, '==', 1)
+          .runQuery()
+        rows = _sortBy(rows, r => r.id)
+        expectMatch(
+          expectedItems.filter(i => i.nested?.foo === 1),
+          rows,
+          quirks,
+        )
+      })
     }
 
     if (support.dbQueryOrder) {

package/src/testing/dbTest.ts

@@ -1,4 +1,5 @@
 import { _deepFreeze, _filterObject, _pick, _sortBy, localTime, pMap } from '@naturalcycles/js-lib'
+import { expect, test } from 'vitest'
 import { CommonDB, CommonDBType } from '../common.db'
 import { DBQuery } from '../query/dbQuery'
 import {

package/src/testing/keyValueDBTest.ts

@@ -1,4 +1,5 @@
 import { _range, _sortBy, KeyValueTuple } from '@naturalcycles/js-lib'
+import { afterAll, beforeAll, expect, test } from 'vitest'
 import { CommonKeyValueDB } from '../kv/commonKeyValueDB'
 import { TEST_TABLE } from './test.model'
 

package/src/testing/keyValueDaoTest.ts

@@ -1,4 +1,5 @@
 import { _sortBy } from '@naturalcycles/js-lib'
+import { afterAll, beforeAll, expect, test } from 'vitest'
 import { CommonKeyValueDao } from '../kv/commonKeyValueDao'
 import { CommonKeyValueDB, KeyValueDBTuple } from '../kv/commonKeyValueDB'
 import { createTestItemsBM, TEST_TABLE } from './test.model'

package/src/testing/test.model.ts

@@ -24,6 +24,9 @@ export interface TestItemBM extends BaseDBEntity {
   k3?: number
   even?: boolean
   b1?: Buffer
+  nested?: {
+    foo: number
+  }
 }
 
 export interface TestItemDBM extends TestItemBM {}
@@ -39,6 +42,9 @@ export const testItemBMSchema = objectSchema<TestItemBM>({
   k3: numberSchema.optional(),
   even: booleanSchema.optional(),
   b1: binarySchema.optional(),
+  nested: objectSchema({
+    foo: numberSchema,
+  }).optional(),
 }).concat(baseDBEntitySchema as any)
 
 export const testItemTMSchema = objectSchema<TestItemTM>({
@@ -68,6 +74,7 @@ export function createTestItemDBM(num = 1): TestItemDBM {
     k2: `v${num * 2}`,
     k3: num,
     even: num % 2 === 0,
+    nested: { foo: num },
     created: MOCK_TS_2018_06_21,
     updated: MOCK_TS_2018_06_21,
   }