deepbase-indexeddb 3.10.1 → 3.11.0

package/README.md

@@ -268,6 +268,23 @@ const values = await db.values('users');
 const entries = await db.entries('users');
 ```
 
+### Query Operations
+
+```javascript
+// Chain a query over the object at path and run it with a terminal method
+const adults = await db.query('users').where('age', '>=', 18).orderBy('name').toArray();
+// [{ id: 'alice', value: { name: 'Alice', age: 30 } }, ...]
+
+const first = await db.query('users').where('age', '>=', 18).first();
+const total = await db.query('users').count();
+const hasAny = await db.query('users').any();
+```
+
+`query()` reads the object at the path with `get()` and evaluates the chain in
+memory, so it walks the object already read: v1 pushes no filters to IndexedDB
+and uses no indexes. Terminals resolve to `{ id, value }` records, where `id` is
+the property name and `value` the stored value.
+
 ## 🔒 Concurrency Safety
 
 The IndexedDB driver includes built-in operation queuing to prevent race conditions:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepbase-indexeddb",
-  "version": "3.10.1",
+  "version": "3.11.0",
   "description": "⚡ DeepBase IndexedDB - browser storage driver",
   "type": "module",
   "main": "src/index.cjs",
@@ -15,10 +15,7 @@
   },
   "dependencies": {},
   "peerDependencies": {
-    "deepbase": "^3.10.1"
-  },
-  "scripts": {
-    "test": "echo \"IndexedDB tests require browser environment. See test/test.html\""
+    "deepbase": "^3.11.0"
   },
   "repository": {
     "type": "git",
@@ -41,5 +38,9 @@
   "bugs": {
     "url": "https://github.com/clasen/DeepBase/issues"
   },
-  "homepage": "https://github.com/clasen/DeepBase/tree/main/packages/driver-indexeddb"
-}
+  "homepage": "https://github.com/clasen/DeepBase/tree/main/packages/driver-indexeddb",
+  "scripts": {
+    "test": "echo \"IndexedDB tests need a browser: run npm run test:browser (headless Chrome) or open test/test.html over HTTP\"",
+    "test:browser": "node test/run-headless.js"
+  }
+}

package/src/IndexedDBDriver.js

@@ -1,4 +1,4 @@
-import { DeepBaseDriver } from 'deepbase';
+import { DeepBaseDriver, evaluateQuery, removeKey } from 'deepbase';
 
 export class IndexedDBDriver extends DeepBaseDriver {
   static _instances = {};
@@ -81,6 +81,14 @@ export class IndexedDBDriver extends DeepBaseDriver {
       ? JSON.parse(JSON.stringify(value))
       : value;
   }
+
+  async query(path, steps) {
+    if (!this._connected) {
+      throw new Error('Database not connected. Call connect() first.');
+    }
+
+    return evaluateQuery(await this.get(...path), steps, { path });
+  }
   
   async set(...args) {
     return this._queueOperation(async () => {
@@ -126,8 +134,7 @@ export class IndexedDBDriver extends DeepBaseDriver {
       const key = keys.pop();
       const parentObj = this._getRecursive(rootObj, keys.slice());
       
-      if (parentObj && parentObj.hasOwnProperty(key)) {
-        delete parentObj[key];
+      if (removeKey(parentObj, key)) {
         await this._setRoot(rootObj);
       }
     });
@@ -367,4 +374,3 @@ export class IndexedDBDriver extends DeepBaseDriver {
 }
 
 export default IndexedDBDriver;
-

package/test/README.md

@@ -4,10 +4,27 @@ Since IndexedDB is a browser API, tests must be run in a browser environment.
 
 ## Running Tests
 
-1. Open `test.html` in a web browser
-2. Tests will automatically run when the page loads
-3. You can also click "Run All Tests" button to re-run tests
-4. Use "Clear Database" to reset the test database
+Serve the repository over HTTP and open `test.html` in a browser:
+
+```bash
+# from the repository root
+python3 -m http.server 8791
+# then open http://127.0.0.1:8791/packages/driver-indexeddb/test/test.html
+```
+
+Opening the file directly (`file://`) does not work: the page loads ES modules, which the browser blocks outside `http(s)`, and the library uses bare specifiers that the import map inside `test.html` resolves. Once served, tests run automatically on load, the "Run All Tests" button re-runs them, and "Clear Database" resets the test database.
+
+### Headless
+
+`run-headless.js` serves the repository itself and drives a local Chrome/Chromium build through the DevTools protocol, so no npm dependency is required:
+
+```bash
+node packages/driver-indexeddb/test/run-headless.js
+# or point at a specific binary:
+CHROME_PATH="/path/to/chrome" node packages/driver-indexeddb/test/run-headless.js
+```
+
+It prints one line per test, exits non-zero when any test fails, and accepts `--port <port>` and `--timeout <ms>`.
 
 ## Test Files
 
@@ -55,4 +72,3 @@ Tests should work in:
 - Safari 10+
 - Edge (all versions)
 - Opera 15+
-

package/test/run-headless.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+/**
+ * Run test.html in headless Chrome/Chromium without adding npm dependencies.
+ *
+ * The script serves the repository over HTTP (ES modules and the page import
+ * map need http(s)), launches a local Chrome build with the DevTools protocol,
+ * waits for the page test runner and reports every test result.
+ *
+ * Usage: node test/run-headless.js [--port 8791] [--timeout 90000] [--keep-open]
+ * Env:   CHROME_PATH=/path/to/chrome
+ */
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(here, '../../..');
+const pagePath = '/packages/driver-indexeddb/test/test.html';
+
+const MIME_TYPES = {
+  '.css': 'text/css',
+  '.html': 'text/html',
+  '.js': 'text/javascript',
+  '.json': 'application/json',
+  '.mjs': 'text/javascript',
+};
+
+function parseArgs(argv) {
+  const options = { port: 8791, timeout: 90000, keepOpen: false };
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === '--port') options.port = Number(argv[++index]);
+    else if (arg === '--timeout') options.timeout = Number(argv[++index]);
+    else if (arg === '--keep-open') options.keepOpen = true;
+  }
+  return options;
+}
+
+function findChrome() {
+  if (process.env.CHROME_PATH) return process.env.CHROME_PATH;
+
+  const candidates = [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+    '/usr/bin/google-chrome',
+    '/usr/bin/chromium',
+    '/usr/bin/chromium-browser',
+    'C:/Program Files/Google/Chrome/Application/chrome.exe',
+  ];
+  return candidates.find(candidate => fs.existsSync(candidate));
+}
+
+function startServer(port) {
+  const server = http.createServer((request, response) => {
+    const requested = decodeURIComponent(new URL(request.url, 'http://localhost').pathname);
+    const file = path.join(repoRoot, requested);
+
+    if (!file.startsWith(repoRoot) || !fs.existsSync(file) || fs.statSync(file).isDirectory()) {
+      response.writeHead(404);
+      response.end('not found');
+      return;
+    }
+
+    response.writeHead(200, { 'content-type': MIME_TYPES[path.extname(file)] ?? 'application/octet-stream' });
+    fs.createReadStream(file).pipe(response);
+  });
+
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(port, '127.0.0.1', () => resolve(server));
+  });
+}
+
+function startChrome(executablePath) {
+  const userDataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'deepbase-chrome-'));
+  // chrome-headless-shell is already headless and rejects the flag.
+  const headlessFlag = path.basename(executablePath).includes('headless') ? [] : ['--headless=new'];
+  const child = spawn(executablePath, [
+    ...headlessFlag,
+    '--disable-gpu',
+    '--no-first-run',
+    '--no-default-browser-check',
+    '--remote-debugging-port=0',
+    `--user-data-dir=${userDataDir}`,
+    'about:blank',
+  ], { stdio: ['ignore', 'pipe', 'pipe'] });
+
+  return new Promise((resolve, reject) => {
+    let stderr = '';
+    const timer = setTimeout(() => reject(new Error(`Chrome did not report a DevTools endpoint:\n${stderr}`)), 30000);
+
+    child.stderr.on('data', chunk => {
+      stderr += chunk;
+      const match = /DevTools listening on (ws:\/\/\S+)/.exec(stderr);
+      if (match) {
+        clearTimeout(timer);
+        resolve({ child, browserUrl: match[1], userDataDir });
+      }
+    });
+    child.once('error', reject);
+    child.once('exit', code => {
+      clearTimeout(timer);
+      reject(new Error(`Chrome exited early with code ${code}:\n${stderr}`));
+    });
+  });
+}
+
+function connect(browserUrl) {
+  const socket = new WebSocket(browserUrl);
+  const pending = new Map();
+  const listeners = new Set();
+  let nextId = 0;
+
+  socket.addEventListener('message', event => {
+    const message = JSON.parse(event.data);
+    if (message.id !== undefined && pending.has(message.id)) {
+      const { resolve, reject } = pending.get(message.id);
+      pending.delete(message.id);
+      if (message.error) reject(new Error(message.error.message));
+      else resolve(message.result);
+      return;
+    }
+    for (const listener of listeners) listener(message);
+  });
+
+  const ready = new Promise((resolve, reject) => {
+    socket.addEventListener('open', () => resolve());
+    socket.addEventListener('error', () => reject(new Error('Could not connect to the DevTools endpoint')));
+  });
+
+  return {
+    ready,
+    onMessage(listener) {
+      listeners.add(listener);
+    },
+    send(method, params = {}, sessionId) {
+      const id = ++nextId;
+      return new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        socket.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
+      });
+    },
+    close() {
+      socket.close();
+    },
+  };
+}
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const executablePath = findChrome();
+  if (!executablePath) {
+    throw new Error('No Chrome/Chromium found. Set CHROME_PATH to a browser binary.');
+  }
+
+  const server = await startServer(options.port);
+  const chrome = await startChrome(executablePath);
+  const client = connect(chrome.browserUrl);
+  let exitCode = 0;
+
+  try {
+    await client.ready;
+    const { targetId } = await client.send('Target.createTarget', { url: 'about:blank' });
+    const { sessionId } = await client.send('Target.attachToTarget', { targetId, flatten: true });
+    await client.send('Runtime.enable', {}, sessionId);
+    await client.send('Page.enable', {}, sessionId);
+    await client.send('Page.navigate', { url: `http://127.0.0.1:${options.port}${pagePath}` }, sessionId);
+
+    const deadline = Date.now() + options.timeout;
+    let payload;
+    while (Date.now() < deadline) {
+      const { result } = await client.send('Runtime.evaluate', {
+        expression: `(() => {
+          if (typeof testResults === 'undefined') return 'pending';
+          const summary = document.querySelector('#summary');
+          if (!summary || !summary.textContent.trim()) return 'pending';
+          return JSON.stringify({ results: testResults, summary: summary.textContent.replace(/\\s+/g, ' ').trim() });
+        })()`,
+        returnByValue: true,
+      }, sessionId);
+
+      if (result.value && result.value !== 'pending') {
+        payload = JSON.parse(result.value);
+        break;
+      }
+      await sleep(250);
+    }
+
+    if (!payload) throw new Error(`The page did not finish its tests within ${options.timeout}ms`);
+
+    console.log(payload.summary);
+    for (const test of payload.results) {
+      console.log(`${test.passed ? 'PASS' : 'FAIL'}: ${test.name}${test.passed ? '' : ` :: ${test.error}`}`);
+    }
+
+    const failed = payload.results.filter(test => !test.passed).length;
+    console.log(`total=${payload.results.length} ok=${payload.results.length - failed} fallos=${failed}`);
+    exitCode = failed === 0 ? 0 : 1;
+
+    if (options.keepOpen) {
+      console.log('--keep-open: press Ctrl+C to stop the browser');
+      await new Promise(() => {});
+    }
+  } finally {
+    client.close();
+    const stopped = new Promise(resolve => chrome.child.once('exit', resolve));
+    chrome.child.kill('SIGKILL');
+    await Promise.race([stopped, sleep(3000)]);
+    server.close();
+    try {
+      fs.rmSync(chrome.userDataDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+    } catch {
+      // The profile directory is disposable; Chrome may still be releasing files.
+    }
+  }
+
+  process.exitCode = exitCode;
+}
+
+main().catch(error => {
+  console.error(error.message);
+  process.exitCode = 1;
+});

package/test/test.html

@@ -99,6 +99,16 @@
   <div id="tests"></div>
   <div id="summary"></div>
 
+  <!-- Served over HTTP, the browser needs an import map for the bare specifiers
+       the library uses: "deepbase" in the drivers and "nanoid" in the core. -->
+  <script type="importmap">
+    {
+      "imports": {
+        "deepbase": "../../core/src/index.js",
+        "nanoid": "../../../node_modules/nanoid/index.browser.js"
+      }
+    }
+  </script>
   <script type="module">
     // Import DeepBase (now works in browser without bundler thanks to dynamic imports!)
     import DeepBase from '../../core/src/index.js';
@@ -162,6 +172,11 @@
         { name: 'Shift from array', fn: testShift },
         { name: 'Concurrent operations', fn: testConcurrency },
         { name: 'Complex nested objects', fn: testComplexObjects },
+        { name: 'Array pop/shift/del', fn: testArrayOperations },
+        { name: 'Query filter and nested paths', fn: testQueryFilters },
+        { name: 'Query order, skip and take', fn: testQueryOrderAndPagination },
+        { name: 'Query select and terminals', fn: testQuerySelectAndTerminals },
+        { name: 'Query missing path and invalid target', fn: testQueryValidation },
         { name: 'Disconnect', fn: testDisconnect }
       ];
 
@@ -366,6 +381,220 @@
       return `Complex object stored and retrieved successfully`;
     }
 
+    // query() reads the object at the path with get() and evaluates the chain in
+    // memory, so these checks mirror core/test/query-scenario.js.
+    async function testArrayOperations() {
+      const arrayDb = new window.DeepBase(new window.IndexedDBDriver({
+        name: 'deepbase-array-test',
+        version: 1
+      }));
+      await arrayDb.connect();
+
+      try {
+        await arrayDb.del();
+
+        await arrayDb.set('myArray', [1, 2, 3, 4, 5]);
+        assertQueryValue(await arrayDb.pop('myArray'), 5, 'pop returns the last element');
+        assertQueryValue(await arrayDb.get('myArray'), [1, 2, 3, 4], 'pop shrinks the array');
+
+        await arrayDb.set('myArray', [1, 2, 3, 4, 5]);
+        assertQueryValue(await arrayDb.shift('myArray'), 1, 'shift returns the first element');
+        assertQueryValue(await arrayDb.get('myArray'), [2, 3, 4, 5], 'shift shrinks the array');
+
+        await arrayDb.set('myArray', ['a', 'b', 'c', 'd']);
+        await arrayDb.del('myArray', '1');
+        assertQueryValue(await arrayDb.get('myArray'), ['a', 'c', 'd'], 'del splices the index');
+
+        await arrayDb.set('myArray', [1, 2, 3]);
+        await arrayDb.del('myArray', '9');
+        await arrayDb.del('myArray', 'not-an-index');
+        assertQueryValue(await arrayDb.get('myArray'), [1, 2, 3], 'del ignores indexes it does not have');
+
+        await arrayDb.set('config', 'tags', ['a', 'b', 'c']);
+        assertQueryValue(await arrayDb.pop('config', 'tags'), 'c', 'nested pop');
+        assertQueryValue(await arrayDb.get('config', 'tags'), ['a', 'b'], 'nested pop shrinks the array');
+
+        await arrayDb.set('queue', 'a', { n: 1 });
+        await arrayDb.set('queue', 'b', { n: 2 });
+        assertQueryValue(await arrayDb.shift('queue'), { n: 1 }, 'shift still works on keyed collections');
+        assertQueryValue(await arrayDb.get('queue'), { b: { n: 2 } }, 'keyed collection keeps its remaining key');
+
+        return 'Arrays shrink on pop/shift/del and keyed collections keep working';
+      } finally {
+        await arrayDb.del();
+        await arrayDb.disconnect();
+      }
+    }
+
+    const QUERY_RECORDS = {
+      u1: { name: 'Ana', age: 31, address: { city: 'Rosario' } },
+      u2: { name: 'Beto', age: 18 },
+      u3: { name: 'Caro', age: 45, address: { city: 'Córdoba' } },
+      u4: { name: 'Dani', age: 18, address: { city: 'Rosario' } },
+      u5: { name: 'Eva' },
+      u6: { name: 'Fabi', age: null }
+    };
+
+    const QUERY_IDS = Object.keys(QUERY_RECORDS);
+
+    function assertQueryValue(actual, expected, label) {
+      if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+        throw new Error(`${label}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+      }
+    }
+
+    async function seedQueryFixture(queryDb) {
+      await queryDb.del();
+      for (const id of QUERY_IDS) {
+        await queryDb.set('users', id, QUERY_RECORDS[id]);
+      }
+      await queryDb.set('flag', true);
+      await queryDb.set('list', [1, 2, 3]);
+      await queryDb.set('settings', 'theme', 'dark');
+    }
+
+    async function withQueryFixture(run) {
+      const queryDb = new window.DeepBase(new window.IndexedDBDriver({
+        name: 'deepbase-query-test',
+        version: 1
+      }));
+      await queryDb.connect();
+      try {
+        await seedQueryFixture(queryDb);
+        return await run(queryDb);
+      } finally {
+        await queryDb.disconnect();
+      }
+    }
+
+    async function testQueryFilters() {
+      return withQueryFixture(async queryDb => {
+        const ids = records => records.map(record => record.id);
+
+        assertQueryValue(ids(await queryDb.query('users').toArray()), QUERY_IDS, 'records ordered by key');
+        assertQueryValue(ids(await queryDb.query('users').where('age', '=', 18).toArray()), ['u2', 'u4'], 'equality');
+        assertQueryValue(ids(await queryDb.query('users').where('age', '!=', 18).toArray()), ['u1', 'u3', 'u6'], 'inequality');
+        assertQueryValue(ids(await queryDb.query('users').where('age', '>', 18).toArray()), ['u1', 'u3'], 'greater than');
+        assertQueryValue(ids(await queryDb.query('users').where('age', '>=', 31).toArray()), ['u1', 'u3'], 'greater or equal');
+        assertQueryValue(ids(await queryDb.query('users').where('age', '<', 31).toArray()), ['u2', 'u4'], 'less than');
+        assertQueryValue(ids(await queryDb.query('users').where('age', '<=', 18).toArray()), ['u2', 'u4'], 'less or equal');
+        assertQueryValue(ids(await queryDb.query('users').where('name', 'in', ['Ana', 'Caro']).toArray()), ['u1', 'u3'], 'in');
+        assertQueryValue(await queryDb.query('users').where('name', 'in', []).toArray(), [], 'in with an empty list');
+
+        assertQueryValue(
+          ids(await queryDb.query('users').where('age', '>=', 18).where('address.city', '=', 'Rosario').toArray()),
+          ['u1', 'u4'],
+          'several where() steps'
+        );
+        assertQueryValue(ids(await queryDb.query('users').where('address.city', '=', 'Rosario').toArray()), ['u1', 'u4'], 'nested field');
+        assertQueryValue(ids(await queryDb.query('users').where(['address', 'city'], '=', 'Córdoba').toArray()), ['u3'], 'path segments');
+        assertQueryValue(ids(await queryDb.query('users').where('address.city', '=', 'Salta').toArray()), [], 'unmatched nested field');
+
+        assertQueryValue(ids(await queryDb.query('users').where('age', '=', null).toArray()), ['u6'], 'explicit null');
+        assertQueryValue(ids(await queryDb.query('users').where('missing', '=', null).toArray()), [], 'missing field');
+        assertQueryValue(ids(await queryDb.query('users').where('address.city', '=', null).toArray()), [], 'missing nested field');
+
+        assertQueryValue(await queryDb.query('users').where('age', '=', '18').toArray(), [], 'equality without coercion');
+        assertQueryValue(await queryDb.query('users').where('age', '>', '20').toArray(), [], 'range without coercion');
+        assertQueryValue(await queryDb.query('users').where('name', 'in', [1, 2]).toArray(), [], 'in without coercion');
+
+        return 'Filter and nested path results matched the shared fixture';
+      });
+    }
+
+    async function testQueryOrderAndPagination() {
+      return withQueryFixture(async queryDb => {
+        const ids = records => records.map(record => record.id);
+
+        assertQueryValue(ids(await queryDb.query('users').orderBy('age').toArray()), ['u2', 'u4', 'u1', 'u3', 'u5', 'u6'], 'ascending order');
+        assertQueryValue(ids(await queryDb.query('users').orderBy('age', 'desc').toArray()), ['u5', 'u6', 'u3', 'u1', 'u2', 'u4'], 'descending order');
+        assertQueryValue(ids(await queryDb.query('users').orderBy('address.city').toArray()), ['u3', 'u1', 'u4', 'u2', 'u5', 'u6'], 'nested field order');
+        assertQueryValue(ids(await queryDb.query('users').orderBy(['address', 'city'], 'desc').toArray()), ['u2', 'u5', 'u6', 'u1', 'u4', 'u3'], 'nested path descending order');
+
+        assertQueryValue(ids(await queryDb.query('users').orderBy('age').skip(1).take(2).toArray()), ['u4', 'u1'], 'skip then take');
+        assertQueryValue(ids(await queryDb.query('users').skip(4).toArray()), ['u5', 'u6'], 'skip');
+        assertQueryValue(ids(await queryDb.query('users').take(0).toArray()), [], 'take zero');
+        assertQueryValue(ids(await queryDb.query('users').skip(10).toArray()), [], 'skip past the end');
+        assertQueryValue(ids(await queryDb.query('users').take(2).where('age', '>', 18).toArray()), ['u1'], 'take before where');
+
+        return 'Order and pagination results matched the shared fixture';
+      });
+    }
+
+    async function testQuerySelectAndTerminals() {
+      return withQueryFixture(async queryDb => {
+        const values = records => records.map(record => record.value);
+
+        assertQueryValue(
+          values(await queryDb.query('users').select('name').toArray()),
+          QUERY_IDS.map(id => ({ name: QUERY_RECORDS[id].name })),
+          'select a single field'
+        );
+        assertQueryValue(
+          values(await queryDb.query('users').select('name', 'address.city').toArray()),
+          [
+            { name: 'Ana', address: { city: 'Rosario' } },
+            { name: 'Beto' },
+            { name: 'Caro', address: { city: 'Córdoba' } },
+            { name: 'Dani', address: { city: 'Rosario' } },
+            { name: 'Eva' },
+            { name: 'Fabi' }
+          ],
+          'select paths'
+        );
+        assertQueryValue(
+          values(await queryDb.query('users').select(['age']).where('age', '>', 30).toArray()),
+          [{ age: 31 }, { age: 45 }],
+          'select after where'
+        );
+        assertQueryValue(
+          values(await queryDb.query('users').select('missing').toArray()),
+          [{}, {}, {}, {}, {}, {}],
+          'select a missing field'
+        );
+
+        assertQueryValue(await queryDb.query('users').first(), { id: 'u1', value: QUERY_RECORDS.u1 }, 'first record');
+        assertQueryValue(await queryDb.query('users').orderBy('age', 'desc').first(), { id: 'u5', value: QUERY_RECORDS.u5 }, 'first after orderBy');
+        assertQueryValue(await queryDb.query('users').where('age', '<', 10).first(), null, 'first with no match');
+        assertQueryValue(await queryDb.query('users').count(), 6, 'count');
+        assertQueryValue(await queryDb.query('users').where('age', '=', 18).count(), 2, 'count with where');
+        assertQueryValue(await queryDb.query('users').any(), true, 'any');
+        assertQueryValue(await queryDb.query('users').where('age', '>', 100).any(), false, 'any with no match');
+
+        return 'Projection and terminal results matched the shared fixture';
+      });
+    }
+
+    async function testQueryValidation() {
+      return withQueryFixture(async queryDb => {
+        assertQueryValue(await queryDb.query('missing').toArray(), [], 'missing path toArray');
+        assertQueryValue(await queryDb.query('users', 'nobody').toArray(), [], 'missing nested path');
+        assertQueryValue(await queryDb.query('missing').first(), null, 'missing path first');
+        assertQueryValue(await queryDb.query('missing').count(), 0, 'missing path count');
+        assertQueryValue(await queryDb.query('missing').any(), false, 'missing path any');
+
+        const rejectsQuery = async (promise, pattern, label) => {
+          try {
+            await promise;
+          } catch (error) {
+            if (pattern.test(error.message)) return;
+            throw new Error(`${label}: unexpected error "${error.message}"`);
+          }
+          throw new Error(`${label}: expected the query to reject`);
+        };
+
+        await rejectsQuery(queryDb.query('flag').toArray(), /requires an object at "flag", received boolean/, 'boolean target');
+        await rejectsQuery(queryDb.query('list').toArray(), /requires an object at "list", received array/, 'array target');
+        await rejectsQuery(queryDb.query('settings', 'theme').toArray(), /requires an object at "settings.theme", received string/, 'string target');
+
+        const rootRecords = await queryDb.query().toArray();
+        assertQueryValue(rootRecords.map(record => record.id), ['flag', 'list', 'settings', 'users'], 'root keys');
+        assertQueryValue(await queryDb.query().count(), 4, 'root count');
+
+        return 'Missing paths, invalid targets and the root query matched the shared fixture';
+      });
+    }
+
     async function testDisconnect() {
       await db.disconnect();
       return 'Database disconnected';
@@ -379,4 +608,3 @@
   </script>
 </body>
 </html>
-