@live-change/db-client 0.9.225 → 0.9.227

package/bin/client.js

@@ -2,6 +2,8 @@
 
 import dump from '../lib/dump.js'
 import exec from '../lib/exec.js'
+import filterDump from '../lib/filterDump.js'
+import statsDump from '../lib/statsDump.js'
 import request from '../lib/request.js'
 import get from '../lib/get.js'
 import observe from '../lib/observe.js'
@@ -10,8 +12,8 @@ import parseList from '../lib/parseList.js'
 import yargs from 'yargs'
 
 process.on('unhandledRejection', (reason, event) => {
-  console.log('Unhandled Rejection at: Promise', 
-    "reason", reason, "stack", reason.stack, "promise", reason.promise)
+  console.error('Unhandled Rejection at: Promise',
+    "reason", reason, "stack", reason && reason.stack, "promise", reason && reason.promise)
 })
 
 process.on('uncaughtException', function (err) {
@@ -52,6 +54,36 @@ function execOptions(yargs) {
   yargs.option('targetDb', {
     describe: 'target database name'
   })
+  yargs.option('progressFile', {
+    describe: 'progress file path (default lcdbc-exec.progress); set false to disable. line= is last successful request; after timeout use --fromLine <inFlightLine> to retry',
+    type: 'string',
+    default: 'lcdbc-exec.progress'
+  })
+  yargs.option('fromLine', {
+    describe: '1-based inclusive file line to start from (matches progress line=). After success continue with line+1; after timeout retry with inFlightLine',
+    type: 'number',
+    default: 0
+  })
+  yargs.option('skipIndex', {
+    describe: 'skip createIndex requests (restore tables/logs only)',
+    type: 'boolean',
+    default: false
+  })
+  yargs.option('onlyIndex', {
+    describe: 'run only createIndex requests (and sync barriers)',
+    type: 'boolean',
+    default: false
+  })
+  yargs.option('requestTimeout', {
+    describe: 'request timeout in ms (0 = no timeout)',
+    type: 'number',
+    default: 0
+  })
+  yargs.option('excludeTable', {
+    describe: 'exclude put/putOldLog data for table or log name (repeatable)',
+    type: 'string',
+    array: true
+  })
 }
 
 yargs(process.argv.slice(2)) // eslint-disable-line
@@ -125,8 +157,64 @@ yargs(process.argv.slice(2)) // eslint-disable-line
       })
     }, argv => {
       exec({
-        serverUrl: argv.serverUrl, verbose: argv.verbose, file: argv.file,
-        targetDb: argv.targetDb
+        serverUrl: argv.serverUrl,
+        verbose: argv.verbose,
+        file: argv.file,
+        targetDb: argv.targetDb,
+        progressFile: argv.progressFile,
+        fromLine: argv.fromLine,
+        skipIndex: argv.skipIndex,
+        onlyIndex: argv.onlyIndex,
+        requestTimeout: argv.requestTimeout,
+        excludeTable: argv.excludeTable
+      }).catch((error) => {
+        console.error(error && error.stack ? error.stack : error)
+        process.exit(1)
+      })
+    })
+    .command('filter [file]', 'filter dump jsonl to stdout (drop put/putOldLog for tables)', (yargs) => {
+      yargs.positional('file', {
+        describe: 'dump file (default stdin)',
+        default: '-'
+      })
+      yargs.option('excludeTable', {
+        describe: 'exclude put/putOldLog data for table or log name (repeatable)',
+        type: 'string',
+        array: true,
+        demandOption: true
+      })
+    }, argv => {
+      filterDump({
+        file: argv.file,
+        excludeTable: argv.excludeTable
+      }).catch((error) => {
+        console.error(error && error.stack ? error.stack : error)
+        process.exit(1)
+      })
+    })
+    .command('stats [file]', 'summarize dump put/putOldLog counts and sizes', (yargs) => {
+      yargs.positional('file', {
+        describe: 'dump file (default stdin)',
+        default: '-'
+      })
+      yargs.option('sort', {
+        describe: 'sort by bytes or entries (descending)',
+        choices: ['bytes', 'entries'],
+        default: 'bytes'
+      })
+      yargs.option('human', {
+        describe: 'human-readable sizes (KiB/MiB/GiB)',
+        type: 'boolean',
+        default: false
+      })
+    }, argv => {
+      statsDump({
+        file: argv.file,
+        sort: argv.sort,
+        human: argv.human
+      }).catch((error) => {
+        console.error(error && error.stack ? error.stack : error)
+        process.exit(1)
       })
     })
     .option('verbose', {

package/lib/dumpCommands.js

@@ -0,0 +1,187 @@
+function parseDumpLine(line) {
+  const trimmed = typeof line === 'string' ? line.trim() : ''
+  if(!trimmed) return { skip: true }
+  try {
+    return { command: JSON.parse(trimmed) }
+  } catch(error) {
+    return {
+      error: error.message || String(error),
+      preview: trimmed.slice(0, 120)
+    }
+  }
+}
+
+function methodName(command) {
+  const method = command && command.method
+  if(!Array.isArray(method) || method.length === 0) return null
+  return method[method.length - 1]
+}
+
+function isCreateIndex(command) {
+  return methodName(command) === 'createIndex'
+}
+
+function isPut(command) {
+  return methodName(command) === 'put'
+}
+
+function isPutOldLog(command) {
+  return methodName(command) === 'putOldLog'
+}
+
+function putTableName(command) {
+  if(!isPut(command) && !isPutOldLog(command)) return null
+  const parameters = command && command.parameters
+  if(!Array.isArray(parameters) || parameters.length < 2) return null
+  return parameters[1]
+}
+
+function putObjectId(command) {
+  if(!isPut(command) && !isPutOldLog(command)) return null
+  const parameters = command && command.parameters
+  if(!Array.isArray(parameters) || parameters.length < 3) return null
+  const object = parameters[2]
+  if(!object || typeof object !== 'object') return null
+  return object.id ?? null
+}
+
+function shouldRunRequest(command, options = {}) {
+  const {
+    skipIndex = false,
+    onlyIndex = false,
+    excludeTables = []
+  } = options
+  const excludeSet = excludeTables instanceof Set
+    ? excludeTables
+    : new Set(Array.isArray(excludeTables) ? excludeTables : [])
+
+  if(command && command.type === 'sync') return true
+  if(!command || command.type !== 'request') return false
+
+  if(onlyIndex) return isCreateIndex(command)
+  if(skipIndex && isCreateIndex(command)) return false
+
+  if(excludeSet.size > 0 && (isPut(command) || isPutOldLog(command))) {
+    const tableName = putTableName(command)
+    if(tableName != null && excludeSet.has(tableName)) return false
+  }
+
+  return true
+}
+
+function statsMapKey(kind, name) {
+  return kind + '\0' + name
+}
+
+function accumulateDumpStats(statsMap, command, lineByteLength) {
+  if(!command || command.type !== 'request') return
+  let kind = null
+  if(isPut(command)) kind = 'table'
+  else if(isPutOldLog(command)) kind = 'log'
+  else return
+
+  const name = putTableName(command)
+  if(name == null) return
+
+  const bytes = Number(lineByteLength) || 0
+  const key = statsMapKey(kind, name)
+  const existing = statsMap.get(key)
+  if(existing) {
+    existing.entries += 1
+    existing.bytes += bytes
+  } else {
+    statsMap.set(key, { kind, name, entries: 1, bytes })
+  }
+}
+
+function dumpStatsRows(statsMap) {
+  return Array.from(statsMap.values())
+}
+
+function sortDumpStats(rows, sortBy = 'bytes') {
+  const key = sortBy === 'entries' ? 'entries' : 'bytes'
+  return [...rows].sort((a, b) => {
+    const diff = b[key] - a[key]
+    if(diff !== 0) return diff
+    if(a.kind !== b.kind) return a.kind < b.kind ? -1 : 1
+    return a.name < b.name ? -1 : (a.name > b.name ? 1 : 0)
+  })
+}
+
+function formatHumanBytes(bytes) {
+  const n = Number(bytes) || 0
+  if(n < 1024) return String(n)
+  const units = ['KiB', 'MiB', 'GiB', 'TiB']
+  let value = n
+  let unitIndex = -1
+  while(value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024
+    unitIndex++
+  }
+  const rounded = value >= 100 ? value.toFixed(0) : value >= 10 ? value.toFixed(1) : value.toFixed(2)
+  return rounded + units[unitIndex]
+}
+
+function formatDumpStatsTable(rows, options = {}) {
+  const { human = false } = options
+  const list = Array.isArray(rows) ? rows : []
+  let totalEntries = 0
+  let totalBytes = 0
+  for(const row of list) {
+    totalEntries += row.entries
+    totalBytes += row.bytes
+  }
+
+  const formatBytes = (n) => human ? formatHumanBytes(n) : String(n)
+  const kindWidth = Math.max(4, ...list.map((r) => String(r.kind).length), 0)
+  const nameWidth = Math.max(4, 5, ...list.map((r) => String(r.name).length))
+  const entriesWidth = Math.max(
+    7,
+    String(totalEntries).length,
+    ...list.map((r) => String(r.entries).length)
+  )
+  const bytesWidth = Math.max(
+    5,
+    formatBytes(totalBytes).length,
+    ...list.map((r) => formatBytes(r.bytes).length)
+  )
+
+  const lines = []
+  lines.push(
+    'KIND'.padEnd(kindWidth) + '  ' +
+    'NAME'.padEnd(nameWidth) + '  ' +
+    'ENTRIES'.padStart(entriesWidth) + '  ' +
+    'BYTES'.padStart(bytesWidth)
+  )
+  for(const row of list) {
+    lines.push(
+      String(row.kind).padEnd(kindWidth) + '  ' +
+      String(row.name).padEnd(nameWidth) + '  ' +
+      String(row.entries).padStart(entriesWidth) + '  ' +
+      formatBytes(row.bytes).padStart(bytesWidth)
+    )
+  }
+  lines.push(
+    ''.padEnd(kindWidth) + '  ' +
+    'TOTAL'.padEnd(nameWidth) + '  ' +
+    String(totalEntries).padStart(entriesWidth) + '  ' +
+    formatBytes(totalBytes).padStart(bytesWidth)
+  )
+  return lines.join('\n')
+}
+
+export {
+  parseDumpLine,
+  methodName,
+  isCreateIndex,
+  isPut,
+  isPutOldLog,
+  putTableName,
+  putObjectId,
+  shouldRunRequest,
+  accumulateDumpStats,
+  dumpStatsRows,
+  sortDumpStats,
+  formatHumanBytes,
+  formatDumpStatsTable
+}

package/lib/exec.js

@@ -1,12 +1,71 @@
+import fs from 'fs'
 import { client as WSClient } from "@live-change/dao-websocket"
 import lineReader from 'line-reader'
+import {
+  parseDumpLine,
+  methodName,
+  isPut,
+  isPutOldLog,
+  putTableName,
+  putObjectId,
+  shouldRunRequest
+} from './dumpCommands.js'
+
+function resolveProgressFile(progressFile) {
+  if(progressFile === false || progressFile === 'false') return null
+  if(progressFile === '' || progressFile == null) return null
+  return progressFile
+}
+
+function writeProgressFile(path, state) {
+  if(!path) return
+  const text = [
+    `line=${state.line ?? ''}`,
+    `inFlightLine=${state.inFlightLine ?? ''}`,
+    `inFlightMethod=${state.inFlightMethod ?? ''}`,
+    `inFlightTable=${state.inFlightTable ?? ''}`,
+    `inFlightId=${state.inFlightId ?? ''}`,
+    `updatedAt=${new Date().toISOString()}`
+  ].join('\n') + '\n'
+  try {
+    fs.writeFileSync(path, text)
+  } catch(error) {
+    console.error('failed to write progress file', path, error.message || error)
+  }
+}
 
 async function exec(options) {
-  let { serverUrl, verbose, file, targetDb } = options
+  let {
+    serverUrl,
+    verbose,
+    file,
+    targetDb,
+    progressFile = 'lcdbc-exec.progress',
+    fromLine = 0,
+    skipIndex = false,
+    onlyIndex = false,
+    requestTimeout = 0,
+    excludeTable
+  } = options
 
-  let done = false
+  if(skipIndex && onlyIndex) {
+    throw new Error('--skipIndex and --onlyIndex are mutually exclusive')
+  }
+
+  const excludeTables = new Set(
+    Array.isArray(excludeTable)
+      ? excludeTable
+      : (excludeTable ? [excludeTable] : [])
+  )
+  const progressPath = resolveProgressFile(progressFile)
+  const timeoutMs = requestTimeout > 0 ? requestTimeout : 0
 
+  let done = false
   let sourceDb
+  const startedTables = new Set()
+  let lastCompletedLine = 0
+  let inFlight = null
+  let progressTimer = null
 
   const clientPromise = new Promise((resolve, reject) => {
     const client = new WSClient("commandLine", serverUrl, {
@@ -19,6 +78,16 @@ async function exec(options) {
       },
       onDisconnect: () => {
         if(verbose) console.error("disconnected from server")
+        if(progressTimer) clearInterval(progressTimer)
+        if(progressPath) {
+          writeProgressFile(progressPath, {
+            line: lastCompletedLine,
+            inFlightLine: inFlight?.line,
+            inFlightMethod: inFlight?.method,
+            inFlightTable: inFlight?.table,
+            inFlightId: inFlight?.id
+          })
+        }
         if(!done) {
           console.error("disconnected before request done")
           process.exit(1)
@@ -35,6 +104,19 @@ async function exec(options) {
     const client = await clientPromise
     let currentPromises = []
     const maxPromises = 1
+    let lineNo = 0
+
+    if(progressPath) {
+      progressTimer = setInterval(() => {
+        writeProgressFile(progressPath, {
+          line: lastCompletedLine,
+          inFlightLine: inFlight?.line,
+          inFlightMethod: inFlight?.method,
+          inFlightTable: inFlight?.table,
+          inFlightId: inFlight?.id
+        })
+      }, 1000)
+    }
 
     function nextLine() {
       return new Promise(function(resolve, reject) {
@@ -44,47 +126,141 @@ async function exec(options) {
         })
       })
     }
-    while (reader.hasNextLine()) {
-      const line = await nextLine()
-      const command = JSON.parse(line)
-/*       console.log("COMMAND", command.type)
-      if(command.type == 'request') {
-        console.log("  ", command.method.join("."), command.parameters.slice(0,2).map(p=>JSON.stringify(p)).join(", "))
-      } */
-      switch(command.type) {
-        case 'request' :
-          while(currentPromises.length > maxPromises) {
-            await currentPromises[0]
-            currentPromises.shift()
-          }
-          if(!sourceDb) {
-            sourceDb = command.parameters[0]
-          }
-          if(targetDb) {
-            if(sourceDb != command.parameters[0])
-              throw new Error(`source database changed from ${sourceDb} to ${command.parameters[0]}`)
-            command.parameters[0] = targetDb
-          }
-          //console.log("REQUEST", command.method, command.parameters)
-          currentPromises.push(client.request(command.method, ...command.parameters))
-          break;
-        case 'sync' :
-          await Promise.all(currentPromises)
-          currentPromises = []
-          break;
+
+    function sendRequest(method, parameters) {
+      if(timeoutMs) {
+        return client.requestWithSettings({ requestTimeout: timeoutMs }, method, ...parameters)
       }
+      return client.request(method, ...parameters)
     }
-    reader.close(function(err) {
-      if (err) throw err
-    })
 
-    await Promise.all(currentPromises)
+    async function flushPending() {
+      while(currentPromises.length > 0) {
+        await currentPromises[0]
+        currentPromises.shift()
+      }
+    }
+
+    try {
+      while (reader.hasNextLine()) {
+        const line = await nextLine()
+        lineNo++
+
+        if(fromLine > 0 && lineNo < fromLine) continue
+
+        const parsed = parseDumpLine(line)
+        if(parsed.skip) {
+          lastCompletedLine = lineNo
+          continue
+        }
+        if(parsed.error) {
+          console.error(`skip bad json line ${lineNo}: ${parsed.preview}`)
+          lastCompletedLine = lineNo
+          continue
+        }
+
+        const command = parsed.command
+        if(command.type === 'sync') {
+          await flushPending()
+          lastCompletedLine = lineNo
+          continue
+        }
+
+        if(command.type !== 'request') {
+          lastCompletedLine = lineNo
+          continue
+        }
+
+        if(!shouldRunRequest(command, { skipIndex, onlyIndex, excludeTables })) {
+          lastCompletedLine = lineNo
+          continue
+        }
+
+        while(currentPromises.length > maxPromises) {
+          await currentPromises[0]
+          currentPromises.shift()
+        }
 
-    done = true
+        if(!sourceDb) {
+          sourceDb = command.parameters[0]
+        }
+        if(targetDb) {
+          if(sourceDb != command.parameters[0]) {
+            throw new Error(`source database changed from ${sourceDb} to ${command.parameters[0]}`)
+          }
+          command.parameters[0] = targetDb
+        }
 
-    client.dispose()
+        const method = methodName(command)
+        const table = putTableName(command)
+        const objectId = putObjectId(command)
 
+        if((isPut(command) || isPutOldLog(command)) && table && !startedTables.has(table)) {
+          startedTables.add(table)
+          console.error(`table put start: ${table} (line ${lineNo})`)
+        }
+
+        inFlight = {
+          line: lineNo,
+          method,
+          table: table || '',
+          id: objectId || ''
+        }
+
+        const requestPromise = sendRequest(command.method, command.parameters)
+          .then(() => {
+            lastCompletedLine = lineNo
+            if(inFlight && inFlight.line === lineNo) inFlight = null
+          })
+          .catch((error) => {
+            if(error === 'timeout' || error?.message === 'timeout') {
+              console.error(
+                `request timeout after ${timeoutMs}ms: ${method}`
+                + (table ? ` table=${table}` : '')
+                + (objectId != null ? ` id=${objectId}` : '')
+                + ` line=${lineNo}`
+              )
+              if(progressPath) {
+                writeProgressFile(progressPath, {
+                  line: lastCompletedLine,
+                  inFlightLine: lineNo,
+                  inFlightMethod: method,
+                  inFlightTable: table || '',
+                  inFlightId: objectId || ''
+                })
+              }
+              if(progressTimer) clearInterval(progressTimer)
+              process.exit(1)
+            }
+            throw error
+          })
+
+        currentPromises.push(requestPromise)
+      }
+
+      await flushPending()
+      reader.close(function(closeErr) {
+        if (closeErr) throw closeErr
+      })
+
+      done = true
+      if(progressTimer) clearInterval(progressTimer)
+      if(progressPath) {
+        writeProgressFile(progressPath, {
+          line: lastCompletedLine,
+          inFlightLine: '',
+          inFlightMethod: '',
+          inFlightTable: '',
+          inFlightId: ''
+        })
+      }
+      client.dispose()
+    } catch(error) {
+      if(progressTimer) clearInterval(progressTimer)
+      console.error(error && error.stack ? error.stack : error)
+      process.exit(1)
+    }
   })
 }
 
-export default exec
+export default exec

package/lib/filterDump.js

@@ -0,0 +1,69 @@
+import lineReader from 'line-reader'
+import {
+  parseDumpLine,
+  shouldRunRequest
+} from './dumpCommands.js'
+
+async function filterDump(options) {
+  const {
+    file = '-',
+    excludeTable
+  } = options
+
+  const excludeTables = Array.isArray(excludeTable)
+    ? excludeTable
+    : (excludeTable ? [excludeTable] : [])
+
+  if(excludeTables.length === 0) {
+    throw new Error('--excludeTable is required at least once')
+  }
+
+  const excludeSet = new Set(excludeTables)
+  let lineNo = 0
+
+  await new Promise((resolve, reject) => {
+    lineReader.open(file == '-' ? process.stdin : file, function(err, reader) {
+      if(err) return reject(err)
+
+      function nextLine() {
+        return new Promise(function(res, rej) {
+          reader.nextLine(function(readErr, line) {
+            if(readErr) return rej(readErr)
+            res(line)
+          })
+        })
+      }
+
+      ;(async () => {
+        try {
+          while(reader.hasNextLine()) {
+            const line = await nextLine()
+            lineNo++
+            const parsed = parseDumpLine(line)
+            if(parsed.skip) continue
+            if(parsed.error) {
+              console.error(`skip bad json line ${lineNo}: ${parsed.preview}`)
+              continue
+            }
+            const command = parsed.command
+            if(command.type === 'sync') {
+              process.stdout.write(line.endsWith('\n') ? line : line + '\n')
+              continue
+            }
+            if(command.type !== 'request') continue
+            if(!shouldRunRequest(command, { excludeTables: excludeSet })) continue
+            process.stdout.write(line.endsWith('\n') ? line : line + '\n')
+          }
+          reader.close(function(closeErr) {
+            if(closeErr) return reject(closeErr)
+            resolve()
+          })
+        } catch(error) {
+          reject(error)
+        }
+      })()
+    })
+  })
+}
+
+export default filterDump

package/lib/statsDump.js

@@ -0,0 +1,63 @@
+import lineReader from 'line-reader'
+import {
+  parseDumpLine,
+  accumulateDumpStats,
+  dumpStatsRows,
+  sortDumpStats,
+  formatDumpStatsTable
+} from './dumpCommands.js'
+
+async function statsDump(options) {
+  const {
+    file = '-',
+    sort = 'bytes',
+    human = false
+  } = options
+
+  const statsMap = new Map()
+  let lineNo = 0
+
+  await new Promise((resolve, reject) => {
+    lineReader.open(file == '-' ? process.stdin : file, function(err, reader) {
+      if(err) return reject(err)
+
+      function nextLine() {
+        return new Promise(function(res, rej) {
+          reader.nextLine(function(readErr, line) {
+            if(readErr) return rej(readErr)
+            res(line)
+          })
+        })
+      }
+
+      ;(async () => {
+        try {
+          while(reader.hasNextLine()) {
+            const line = await nextLine()
+            lineNo++
+            const parsed = parseDumpLine(line)
+            if(parsed.skip) continue
+            if(parsed.error) {
+              console.error(`skip bad json line ${lineNo}: ${parsed.preview}`)
+              continue
+            }
+            const command = parsed.command
+            const lineBytes = Buffer.byteLength(line, 'utf8')
+            accumulateDumpStats(statsMap, command, lineBytes)
+          }
+          reader.close(function(closeErr) {
+            if(closeErr) return reject(closeErr)
+            resolve()
+          })
+        } catch(error) {
+          reject(error)
+        }
+      })()
+    })
+  })
+
+  const rows = sortDumpStats(dumpStatsRows(statsMap), sort)
+  console.log(formatDumpStatsTable(rows, { human }))
+}
+
+export default statsDump

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/db-client",
-  "version": "0.9.225",
+  "version": "0.9.227",
   "description": "Database with observable data for live queries",
   "main": "index.js",
   "scripts": {
@@ -28,11 +28,11 @@
   },
   "type": "module",
   "dependencies": {
-    "@live-change/dao": "^0.9.225",
-    "@live-change/dao-websocket": "^0.9.225",
+    "@live-change/dao": "^0.9.227",
+    "@live-change/dao-websocket": "^0.9.227",
     "line-reader": "^0.4.0",
     "websocket": "^1.0.34",
     "yargs": "^17.7.2"
   },
-  "gitHead": "e44dc8b9eefd8b67c40a29b3117781662093c922"
+  "gitHead": "7d4dc92dcb9a50381292dded7d8766a3cadbecf9"
 }

package/tests/dumpCommands.js

@@ -0,0 +1,106 @@
+import test from 'tape'
+import {
+  parseDumpLine,
+  methodName,
+  isCreateIndex,
+  isPut,
+  isPutOldLog,
+  putTableName,
+  putObjectId,
+  shouldRunRequest
+} from '../lib/dumpCommands.js'
+
+test('parseDumpLine skips empty', (t) => {
+  t.deepEqual(parseDumpLine(''), { skip: true })
+  t.deepEqual(parseDumpLine('   '), { skip: true })
+  t.end()
+})
+
+test('parseDumpLine parses request', (t) => {
+  const line = JSON.stringify({
+    type: 'request',
+    method: ['database', 'put'],
+    parameters: ['db', 'tableA', { id: 'x1' }]
+  })
+  const parsed = parseDumpLine(line)
+  t.equal(parsed.command.type, 'request')
+  t.equal(methodName(parsed.command), 'put')
+  t.end()
+})
+
+test('parseDumpLine returns error for invalid json', (t) => {
+  const parsed = parseDumpLine('Unhandled Rejection at: Promise')
+  t.ok(parsed.error)
+  t.ok(parsed.preview.startsWith('Unhandled'))
+  t.end()
+})
+
+test('put helpers extract table and id', (t) => {
+  const command = {
+    type: 'request',
+    method: ['database', 'put'],
+    parameters: ['db', 'pageSnapshot', { id: 'abc' }]
+  }
+  t.ok(isPut(command))
+  t.notOk(isPutOldLog(command))
+  t.equal(putTableName(command), 'pageSnapshot')
+  t.equal(putObjectId(command), 'abc')
+  t.end()
+})
+
+test('shouldRunRequest skipIndex drops createIndex', (t) => {
+  const createIndex = {
+    type: 'request',
+    method: ['database', 'createIndex'],
+    parameters: ['db', 'byName', '()=>{}', {}]
+  }
+  const put = {
+    type: 'request',
+    method: ['database', 'put'],
+    parameters: ['db', 't', { id: '1' }]
+  }
+  t.ok(isCreateIndex(createIndex))
+  t.notOk(shouldRunRequest(createIndex, { skipIndex: true }))
+  t.ok(shouldRunRequest(put, { skipIndex: true }))
+  t.ok(shouldRunRequest({ type: 'sync' }, { skipIndex: true }))
+  t.end()
+})
+
+test('shouldRunRequest onlyIndex keeps createIndex and sync', (t) => {
+  const createIndex = {
+    type: 'request',
+    method: ['database', 'createIndex'],
+    parameters: ['db', 'byName', '()=>{}', {}]
+  }
+  const put = {
+    type: 'request',
+    method: ['database', 'put'],
+    parameters: ['db', 't', { id: '1' }]
+  }
+  t.ok(shouldRunRequest(createIndex, { onlyIndex: true }))
+  t.notOk(shouldRunRequest(put, { onlyIndex: true }))
+  t.ok(shouldRunRequest({ type: 'sync' }, { onlyIndex: true }))
+  t.end()
+})
+
+test('shouldRunRequest excludeTables drops put and putOldLog data', (t) => {
+  const put = {
+    type: 'request',
+    method: ['database', 'put'],
+    parameters: ['db', 'Foo', { id: '1' }]
+  }
+  const putOldLog = {
+    type: 'request',
+    method: ['database', 'putOldLog'],
+    parameters: ['db', 'Bar', { id: '2' }]
+  }
+  const createTable = {
+    type: 'request',
+    method: ['database', 'createTable'],
+    parameters: ['db', 'Foo']
+  }
+  t.notOk(shouldRunRequest(put, { excludeTables: ['Foo'] }))
+  t.notOk(shouldRunRequest(putOldLog, { excludeTables: ['Bar'] }))
+  t.ok(shouldRunRequest(createTable, { excludeTables: ['Foo'] }))
+  t.end()
+})

package/tests/statsDump.js

@@ -0,0 +1,94 @@
+import test from 'tape'
+import {
+  accumulateDumpStats,
+  dumpStatsRows,
+  sortDumpStats,
+  formatHumanBytes,
+  formatDumpStatsTable
+} from '../lib/dumpCommands.js'
+
+test('accumulateDumpStats sums put entries and bytes', (t) => {
+  const map = new Map()
+  const put = {
+    type: 'request',
+    method: ['database', 'put'],
+    parameters: ['db', 'Foo', { id: '1' }]
+  }
+  accumulateDumpStats(map, put, 100)
+  accumulateDumpStats(map, put, 50)
+  const rows = dumpStatsRows(map)
+  t.equal(rows.length, 1)
+  t.deepEqual(rows[0], { kind: 'table', name: 'Foo', entries: 2, bytes: 150 })
+  t.end()
+})
+
+test('accumulateDumpStats separates table and log with same name', (t) => {
+  const map = new Map()
+  accumulateDumpStats(map, {
+    type: 'request',
+    method: ['database', 'put'],
+    parameters: ['db', 'Same', { id: '1' }]
+  }, 10)
+  accumulateDumpStats(map, {
+    type: 'request',
+    method: ['database', 'putOldLog'],
+    parameters: ['db', 'Same', { id: '2' }]
+  }, 20)
+  const rows = sortDumpStats(dumpStatsRows(map), 'bytes')
+  t.equal(rows.length, 2)
+  t.equal(rows[0].kind, 'log')
+  t.equal(rows[0].bytes, 20)
+  t.equal(rows[1].kind, 'table')
+  t.equal(rows[1].bytes, 10)
+  t.end()
+})
+
+test('accumulateDumpStats ignores createTable sync and non-request', (t) => {
+  const map = new Map()
+  accumulateDumpStats(map, {
+    type: 'request',
+    method: ['database', 'createTable'],
+    parameters: ['db', 'Foo']
+  }, 999)
+  accumulateDumpStats(map, { type: 'sync' }, 50)
+  accumulateDumpStats(map, null, 10)
+  t.equal(dumpStatsRows(map).length, 0)
+  t.end()
+})
+
+test('sortDumpStats by entries descending', (t) => {
+  const rows = [
+    { kind: 'table', name: 'A', entries: 1, bytes: 1000 },
+    { kind: 'table', name: 'B', entries: 5, bytes: 10 },
+    { kind: 'log', name: 'C', entries: 3, bytes: 100 }
+  ]
+  const byEntries = sortDumpStats(rows, 'entries')
+  t.deepEqual(byEntries.map((r) => r.name), ['B', 'C', 'A'])
+  const byBytes = sortDumpStats(rows, 'bytes')
+  t.deepEqual(byBytes.map((r) => r.name), ['A', 'C', 'B'])
+  t.end()
+})
+
+test('formatHumanBytes', (t) => {
+  t.equal(formatHumanBytes(500), '500')
+  t.equal(formatHumanBytes(2048), '2.00KiB')
+  t.equal(formatHumanBytes(1024 * 1024), '1.00MiB')
+  t.end()
+})
+
+test('formatDumpStatsTable includes TOTAL and human sizes', (t) => {
+  const rows = [
+    { kind: 'log', name: 'BigLog', entries: 2, bytes: 2048 },
+    { kind: 'table', name: 'Small', entries: 1, bytes: 10 }
+  ]
+  const plain = formatDumpStatsTable(rows, { human: false })
+  t.ok(plain.includes('TOTAL'))
+  t.ok(plain.includes('BigLog'))
+  t.ok(plain.includes('2058'))
+  t.ok(plain.includes('3'))
+
+  const human = formatDumpStatsTable(rows, { human: true })
+  t.ok(human.includes('2.00KiB'))
+  t.ok(human.includes('TOTAL'))
+  t.end()
+})