feat: remove @databases dependency

The internals of the application use @databases/sqlite-sync, which has a
dependency on `better-sqlite3`. The convienience of @databases is great
for larger projects, applications, and is a fantastic abstraction.

We can can reduce our dependencies by removing @databases and using
`better-sqlite3` directly. It's a little more verbose, but manageable
for inside this library.

Author: gregdaynes

.gitignore

@@ -128,3 +128,8 @@ dist
 .yarn/build-state.yml
 .yarn/install-state.gz
 .pnp.*
+
+# sqlite files
+*.sqlite
+*.sqlite-wal
+*.sqlite-shm

bench-turbo.js

@@ -1,51 +1,77 @@
+import { styleText } from 'node:util'
 import Hold from './index.js'
 import crypto from 'node:crypto'
 
-export default function benchTurbo (holder) {
-  holder ||= Hold({ turbo: true })
+export default function benchTurbo (holder, {
+  targetTime = 500,
+  threshold = 1000,
+  maxRuns = 10,
+  growth = 1.01,
+  retraction = 0.99,
+  lower = 1,
+  upper = 1000000
+} = {}) {
   const records = []
+  let runCount = 0
+
+  function log ({ a, b, c, time, col = null }) {
+    const pad = (str) => `${str}`.padStart(('' + upper).length, ' ')
+    const aStr = col === 'a' ? styleText('green', pad(a)) : pad(a)
+    const bStr = col === 'b' ? styleText('green', pad(b)) : pad(b)
+    const cStr = col === 'c' ? styleText('green', pad(c)) : pad(c)
+    const timeStr = time < targetTime ? time.toFixed(3) : styleText('red', time.toFixed(3))
+
+    console.log(`Run: ${('' + runCount).padStart(('' + maxRuns).length, ' ')} |`, aStr, cStr, bStr, '|', timeStr + 'ms')
+  }
+
+  function record ({ a, c, b, time, col }) {
+    log(...arguments)
 
-  function record (rec, time) {
     records.push({
-      'Time (ms)': time,
-      'Record Count': rec,
-      'Recods per ms': Number((rec / time).toFixed(3))
+      Run: runCount,
+      'Time (ms)': Number(time.toFixed(3)),
+      'Record Count': arguments[0][col],
+      'Recods per ms': Number((arguments[0][col] / time).toFixed(3))
     })
   }
 
   function run (count) {
+    const db = Hold({ turbo: true })
+
     const tableName = crypto.createHash('sha1').update(('b' + new Date().valueOf() + count)).digest('hex')
-    holder.init(tableName, 'keyX', 'valueX')
+    db.init(tableName, 'keyX', 'valueX')
 
-    const entries = Array.from(Array(count)).map((_, i) => holder.prepare(tableName, `key${i}`, `value${i}`))
+    const entries = Array.from(Array(count)).map((_, i) => db.prepare(tableName, `key${i}`, `value${i}`))
 
     const start = performance.now()
-    holder.setBulk(tableName, 'keyX', entries)
+    db.setBulk(tableName, 'keyX', entries)
 
     return performance.now() - start
   }
 
   function bisect (a, b) {
-    if ((b - a) <= 1000) return Math.round((a + b) / 2)
+    runCount++
+    if ((b - a) <= threshold || runCount > maxRuns) return Math.round((a + b) / 2)
 
     const c = Math.round((a + b) / 2)
-
     const cTime = run(c)
-    if (cTime < 1000) {
-      record(c, cTime)
-      return bisect(c, Math.round(b * 1.02), 'c')
+
+    if (cTime < targetTime) {
+      record({ a, c, b, time: cTime, col: 'c' })
+      return bisect(c, Math.round(b * growth), 'c')
     }
 
     const aTime = run(a)
-    if (aTime < 1000) {
-      record(a, aTime)
+    if (aTime < targetTime) {
+      record({ a, b, c, time: aTime, col: 'a' })
       return bisect(a, c, 'a')
     }
 
-    return bisect(Math.round(a * 0.98), c, null)
+    log({ a, c, b, time: cTime })
+    return bisect(Math.round(a * retraction), c, null)
   }
 
-  bisect(1, 150000, null)
+  bisect(lower, upper, null)
 
   return records.sort((a, b) => b['Recods per ms'] - a['Recods per ms']).slice(0, 3)
 }

bench.js

@@ -19,33 +19,31 @@ bench
     diskIdx++
   }, {
     beforeAll () {
-      diskHolder = Hold({ location: './bench.db', enableWAL: false, exposeConnection: true })
+      diskHolder = Hold({ location: './bench.sqlite', enableWAL: false, exposeConnection: true })
 
       for (let i = 0; i < warmupIterations; i++) {
         diskHolder.set('disk', `key${i}`, 'value')
       }
     },
     afterAll () {
-      diskHolder.connection.dispose()
       diskHolder = null
-      unlinkSync('./bench.db')
+      unlinkSync('./bench.sqlite')
     }
   })
   .add('diskWAL', () => {
     diskWALHolder.set('diskWAL', `key${diskWALIdx}`, 'value')
     diskWALIdx++
   }, {
     beforeAll () {
-      diskWALHolder = Hold({ location: './bench-wal.db', exposeConnection: true })
+      diskWALHolder = Hold({ location: './bench-wal.sqlite', exposeConnection: true })
 
       for (let i = 0; i < warmupIterations; i++) {
         diskWALHolder.set('diskWAL', `key${i}`, 'value')
       }
     },
     afterAll () {
-      diskWALHolder.connection.dispose()
       diskWALHolder = null
-      unlinkSync('./bench-wal.db')
+      unlinkSync('./bench-wal.sqlite')
     }
   })
   .add('memory', () => {
@@ -60,7 +58,6 @@ bench
       }
     },
     afterAll () {
-      memoryHolder.connection.dispose()
       memoryHolder = null
     }
   })
@@ -76,7 +73,6 @@ bench
       }
     },
     afterAll () {
-      memorySerialJSONHolder.connection.dispose()
       memorySerialJSONHolder = null
     }
   })
@@ -92,7 +88,6 @@ bench
       }
     },
     afterAll () {
-      memorySerialJSONFastHolder.connection.dispose()
       memorySerialJSONFastHolder = null
     }
   })
@@ -108,7 +103,6 @@ bench
       }
     },
     afterAll () {
-      memoryComplexKeyHolder.connection.dispose()
       memoryComplexKeyHolder = null
     }
   })