@weft-js/db 0.1.1 → 0.1.3

package/src/kysely.ts

@@ -2,7 +2,18 @@
 // builder gets them from the spec, never from a request.
 
 import type { ExpressionBuilder, Kysely, SelectQueryBuilder } from 'kysely'
-import { likeOf, pageOf, plan, rowOf, storedId, written, type DbAdapter, type ListParams, type ListSource, type SourceSpec } from '@weft-js/start/list'
+import {
+  likeOf,
+  pageOf,
+  plan,
+  rowOf,
+  storedId,
+  written,
+  type DbAdapter,
+  type ListParams,
+  type ListSource,
+  type SourceSpec,
+} from '@weft-js/start/list'
 import { StartError } from '@weft-js/start/data'
 import { driver } from './driver'
 
@@ -18,8 +29,78 @@ export interface KyselySpec extends SourceSpec {
 type Tables = Record<string, Record<string, unknown>>
 type Eb = ExpressionBuilder<Tables, string>
 
+type KyselyList<Row> = {
+  db: Kysely<Tables>
+  spec: KyselySpec
+  table: string
+  columns: string[]
+  idColumn: string
+  reading: (row: object) => Row
+}
+
+async function listRows<Row>(p: ListParams, context: KyselyList<Row>) {
+  const { db, spec, table, columns, idColumn, reading } = context
+  const q = plan(spec, p)
+  const filtered = <O>(from: SelectQueryBuilder<Tables, string, O>) => {
+    let b = from
+    for (const w of q.where) {
+      const some = w.values.filter((v) => v !== null)
+      b = b.where((eb: Eb) =>
+        eb.or([
+          ...(some.length ? [eb(w.column, 'in', some)] : []),
+          ...(w.values.includes(null) ? [eb(w.column, 'is', null)] : []),
+        ]),
+      )
+    }
+    if (q.search) {
+      const like = likeOf(q.search.text)
+      b = b.where((eb: Eb) =>
+        eb.or(
+          q.search!.columns.map((c) => sql<boolean>`lower(${sql.ref(c)}) like ${like} escape '!'`),
+        ),
+      )
+    }
+    return b
+  }
+  let b = filtered(db.selectFrom(table).select(columns))
+  const dir = q.sort?.dir === 'desc' ? 'desc' : 'asc',
+    cmp = dir === 'desc' ? '<' : '>'
+  if (p.after) {
+    const [value, id] = p.after
+    b = b.where((eb: Eb) =>
+      q.sort
+        ? eb.or([
+            eb(q.sort.column, cmp, value),
+            eb.and([eb(q.sort.column, '=', value), eb(idColumn, cmp, id)]),
+          ])
+        : eb(idColumn, '>', id),
+    )
+  }
+  b = q.sort ? b.orderBy(q.sort.column, dir).orderBy(idColumn, dir) : b.orderBy(idColumn, 'asc')
+  const cursor = p.mode === 'cursor'
+  const rows = (
+    await b
+      .limit(cursor ? p.limit + 1 : p.limit)
+      .offset(p.offset)
+      .execute()
+  ).map(reading)
+  const total = cursor
+    ? undefined
+    : Number(
+        (
+          await filtered(
+            db.selectFrom(table).select(sql<unknown>`count(*)`.as('n')),
+          ).executeTakeFirstOrThrow()
+        ).n,
+      )
+  return pageOf(rows, p, { sort: q.sort?.field, id: q.id.field }, total)
+}
+
 /** A `ListSource` over one table of any `Kysely<DB>`. */
-export function kyselySource<Row = Record<string, unknown>, DB = unknown>(handle: Kysely<DB>, spec: KyselySpec): ListSource<Row> {
+export function kyselySource<Row = Record<string, unknown>, DB = unknown>(
+  handle: Kysely<DB>,
+  spec: KyselySpec,
+): ListSource<Row> {
   const db = handle as unknown as Kysely<Tables>
   const { table, returning = true } = spec
   const columns = Object.values(spec.columns)
@@ -30,38 +111,23 @@ export function kyselySource<Row = Record<string, unknown>, DB = unknown>(handle
     return r ? reading(r) : null
   }
   return {
-    async list(p: ListParams) {
-      const q = plan(spec, p)
-      const filtered = <O>(from: SelectQueryBuilder<Tables, string, O>) => {
-        let b = from
-        for (const w of q.where) {
-          const some = w.values.filter(v => v !== null)
-          b = b.where((eb: Eb) => eb.or([...(some.length ? [eb(w.column, 'in', some)] : []), ...(w.values.includes(null) ? [eb(w.column, 'is', null)] : [])]))
-        }
-        if (q.search) {
-          const like = likeOf(q.search.text)
-          b = b.where((eb: Eb) => eb.or(q.search!.columns.map(c => sql<boolean>`lower(${sql.ref(c)}) like ${like} escape '!'`)))
-        }
-        return b
-      }
-      let b = filtered(db.selectFrom(table).select(columns))
-      const dir = q.sort?.dir === 'desc' ? 'desc' : 'asc', cmp = dir === 'desc' ? '<' : '>'
-      if (p.after) {
-        const [value, id] = p.after
-        b = b.where((eb: Eb) => (q.sort ? eb.or([eb(q.sort.column, cmp, value), eb.and([eb(q.sort.column, '=', value), eb(idColumn, cmp, id)])]) : eb(idColumn, '>', id)))
-      }
-      b = q.sort ? b.orderBy(q.sort.column, dir).orderBy(idColumn, dir) : b.orderBy(idColumn, 'asc')
-      const cursor = p.mode === 'cursor'
-      const rows = (await b.limit(cursor ? p.limit + 1 : p.limit).offset(p.offset).execute()).map(reading)
-      const total = cursor ? undefined : Number((await filtered(db.selectFrom(table).select(sql<unknown>`count(*)`.as('n'))).executeTakeFirstOrThrow()).n)
-      return pageOf(rows, p, { sort: q.sort?.field, id: q.id.field }, total)
+    list(p: ListParams) {
+      return listRows(p, { db, spec, table, columns, idColumn, reading })
     },
     get: byId,
     async create(data) {
       const row = written(spec, data, true)
       const id = row[idColumn]
-      if (returning) return reading(await db.insertInto(table).values(row).returning(columns).executeTakeFirstOrThrow())
-      if (id === undefined) throw new StartError('Q002', '`create` needs the id: MySQL can\'t return a row', 'generate it before the insert')
+      if (returning)
+        return reading(
+          await db.insertInto(table).values(row).returning(columns).executeTakeFirstOrThrow(),
+        )
+      if (id === undefined)
+        throw new StartError(
+          'Q002',
+          "`create` needs the id: MySQL can't return a row",
+          'generate it before the insert',
+        )
       await db.insertInto(table).values(row).execute()
       return (await byId(id))!
     },
@@ -69,7 +135,12 @@ export function kyselySource<Row = Record<string, unknown>, DB = unknown>(handle
       const row = written(spec, patch)
       if (!Object.keys(row).length) return byId(id)
       if (returning) {
-        const r = await db.updateTable(table).set(row).where(idColumn, '=', id).returning(columns).executeTakeFirst()
+        const r = await db
+          .updateTable(table)
+          .set(row)
+          .where(idColumn, '=', id)
+          .returning(columns)
+          .executeTakeFirst()
         return r ? reading(r) : null
       }
       if (!(await byId(id))) return null
@@ -77,10 +148,15 @@ export function kyselySource<Row = Record<string, unknown>, DB = unknown>(handle
       return byId(id)
     },
     async remove(id) {
-      return (await db.deleteFrom(table).where(idColumn, '=', id).executeTakeFirst()).numDeletedRows > 0n
+      return (
+        (await db.deleteFrom(table).where(idColumn, '=', id).executeTakeFirst()).numDeletedRows > 0n
+      )
     },
   }
 }
 
 /** `db.adapter@1` over a table of a Kysely instance. */
-export const adapter: DbAdapter<Kysely<unknown>> = { name: 'kysely', source: (t, spec) => kyselySource(t, spec as KyselySpec) }
+export const adapter: DbAdapter<Kysely<unknown>> = {
+  name: 'kysely',
+  source: (t, spec) => kyselySource(t, spec as KyselySpec),
+}

package/src/mongo.ts

@@ -2,12 +2,25 @@
 // checked scalar and a search is an escaped `$regex`, so a request has no way to name an operator. Takes
 // whatever has the driver's collection methods, so `mongodb` is the app's dependency.
 
-import { pageOf, plan, rowOf, storedId, written, type DbAdapter, type ListParams, type ListSource, type SourceSpec } from '@weft-js/start/list'
+import {
+  pageOf,
+  plan,
+  rowOf,
+  storedId,
+  written,
+  type DbAdapter,
+  type ListParams,
+  type ListSource,
+  type SourceSpec,
+} from '@weft-js/start/list'
 import { hub } from '@weft-js/start/hub'
 import type { Source } from '@weft-js/start/changes'
 
 /** What a change stream hands over, as far as anything here reads it. */
-export interface MongoEvent extends MongoChange { ns?: { coll?: string }; fullDocument?: { tags?: string[] } }
+export interface MongoEvent extends MongoChange {
+  ns?: { coll?: string }
+  fullDocument?: { tags?: string[] }
+}
 
 /** The driver's change stream. */
 export type MongoStream = AsyncIterable<MongoEvent> & { close?(): Promise<unknown> }
@@ -24,45 +37,89 @@ export interface MongoCollection {
   watch(pipeline?: object[], options?: object): MongoStream
 }
 
-const regex = (text: string) => ({ $regex: text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), $options: 'i' })
+const regex = (text: string) => ({
+  $regex: text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'),
+  $options: 'i',
+})
 
 /** A `ListSource` over one collection. */
-export function mongoSource<Row = Record<string, unknown>>(collection: MongoCollection, spec: SourceSpec): ListSource<Row> {
+export function mongoSource<Row = Record<string, unknown>>(
+  collection: MongoCollection,
+  spec: SourceSpec,
+): ListSource<Row> {
   const stored = Object.values(spec.columns)
   const idColumn = storedId(spec)
-  const projection = Object.fromEntries([...stored.map(c => [c, 1]), ...(stored.includes('_id') ? [] : [['_id', 0]])])
+  const projection = Object.fromEntries([
+    ...stored.map((c) => [c, 1]),
+    ...(stored.includes('_id') ? [] : [['_id', 0]]),
+  ])
   const reading = rowOf<Row>(spec)
   return {
     async list(p: ListParams) {
       const q = plan(spec, p)
-      const and: object[] = q.where.map(w => ({ [w.column]: w.values.length === 1 ? { $eq: w.values[0] } : { $in: w.values } }))
-      if (q.search) and.push({ $or: q.search.columns.map(c => ({ [c]: regex(q.search!.text) })) })
+      const and: object[] = q.where.map((w) => ({
+        [w.column]: w.values.length === 1 ? { $eq: w.values[0] } : { $in: w.values },
+      }))
+      if (q.search) and.push({ $or: q.search.columns.map((c) => ({ [c]: regex(q.search!.text) })) })
       const filter = and.length ? { $and: and } : {}
-      const dir = q.sort?.dir === 'desc' ? -1 : 1, cmp = dir < 0 ? '$lt' : '$gt'
-      const keyset = p.after && (q.sort
-        ? { $or: [{ [q.sort.column]: { [cmp]: p.after[0] } }, { [q.sort.column]: { $eq: p.after[0] }, [idColumn]: { [cmp]: p.after[1] } }] }
-        : { [idColumn]: { $gt: p.after[1] } })
+      const dir = q.sort?.dir === 'desc' ? -1 : 1,
+        cmp = dir < 0 ? '$lt' : '$gt'
+      const keyset =
+        p.after &&
+        (q.sort
+          ? {
+              $or: [
+                { [q.sort.column]: { [cmp]: p.after[0] } },
+                { [q.sort.column]: { $eq: p.after[0] }, [idColumn]: { [cmp]: p.after[1] } },
+              ],
+            }
+          : { [idColumn]: { $gt: p.after[1] } })
       const sort = q.sort ? { [q.sort.column]: dir, [idColumn]: dir } : { [idColumn]: 1 }
       const cursor = p.mode === 'cursor'
-      const rows = (await collection.find(keyset ? { $and: [...and, keyset] } : filter, { projection, sort, skip: p.offset, limit: cursor ? p.limit + 1 : p.limit }).toArray()).map(reading)
-      return pageOf(rows, p, { sort: q.sort?.field, id: q.id.field }, cursor ? undefined : await collection.countDocuments(filter))
+      const rows = (
+        await collection
+          .find(keyset ? { $and: [...and, keyset] } : filter, {
+            projection,
+            sort,
+            skip: p.offset,
+            limit: cursor ? p.limit + 1 : p.limit,
+          })
+          .toArray()
+      ).map(reading)
+      return pageOf(
+        rows,
+        p,
+        { sort: q.sort?.field, id: q.id.field },
+        cursor ? undefined : await collection.countDocuments(filter),
+      )
+    },
+    get: async (id) => {
+      const r = await collection.findOne({ [idColumn]: { $eq: id } }, { projection })
+      return r ? reading(r) : null
     },
-    get: async id => { const r = await collection.findOne({ [idColumn]: { $eq: id } }, { projection }); return r ? reading(r) : null },
     async create(data) {
       const doc = written(spec, data, true)
       await collection.insertOne({ ...doc })
       return reading(doc)
     },
     async update(id, patch) {
-      const r = await collection.findOneAndUpdate({ [idColumn]: { $eq: id } }, { $set: written(spec, patch) }, { projection, returnDocument: 'after' })
+      const r = await collection.findOneAndUpdate(
+        { [idColumn]: { $eq: id } },
+        { $set: written(spec, patch) },
+        { projection, returnDocument: 'after' },
+      )
       return r ? reading(r) : null
     },
-    remove: async id => ((await collection.deleteOne({ [idColumn]: { $eq: id } })).deletedCount ?? 0) > 0,
+    remove: async (id) =>
+      ((await collection.deleteOne({ [idColumn]: { $eq: id } })).deletedCount ?? 0) > 0,
   }
 }
 
 /** `db.adapter@1` over a Mongo collection. */
-export const adapter: DbAdapter<MongoCollection> = { name: 'mongo', source: (t, spec) => mongoSource(t, spec) }
+export const adapter: DbAdapter<MongoCollection> = {
+  name: 'mongo',
+  source: (t, spec) => mongoSource(t, spec),
+}
 
 /** The methods of the driver's `Db` the change feed calls. */
 export interface MongoDb {
@@ -80,7 +137,11 @@ const said = (e: unknown) => (e as { message?: string } | null)?.message ?? Stri
  * barrier is a capped collection's insert, so the oplog puts it after the writes it covers. After a lost stream every
  * collection is poked: the resume token is not kept, because a poke is cheaper than a stale page.
  */
-export function mongoChanges(db: MongoDb, collections: string[], options: { retry?: number; external?: boolean } = {}): Source {
+export function mongoChanges(
+  db: MongoDb,
+  collections: string[],
+  options: { retry?: number; external?: boolean } = {},
+): Source {
   const retry = options.retry ?? 1000
   return {
     name: 'mongodb',
@@ -90,17 +151,34 @@ export function mongoChanges(db: MongoDb, collections: string[], options: { retr
     async probe() {
       try {
         const hello = await db.command({ hello: 1 })
-        if (hello.setName || hello.msg === 'isdbgrid') return { mode: 'feed', via: 'mongo-change-stream' }
-        return { mode: 'off', via: 'none', why: 'a standalone mongod has no oplog, so no change streams', fix: 'run it as a replica set: a single member is enough (`mongod --replSet rs0`, then `rs.initiate()`)' }
+        if (hello.setName || hello.msg === 'isdbgrid')
+          return { mode: 'feed', via: 'mongo-change-stream' }
+        return {
+          mode: 'off',
+          via: 'none',
+          why: 'a standalone mongod has no oplog, so no change streams',
+          fix: 'run it as a replica set: a single member is enough (`mongod --replSet rs0`, then `rs.initiate()`)',
+        }
       } catch (e) {
-        return { mode: 'off', via: 'none', why: `MongoDB didn't answer: ${said(e)}`, fix: 'check the connection string' }
+        return {
+          mode: 'off',
+          via: 'none',
+          why: `MongoDB didn't answer: ${said(e)}`,
+          fix: 'check the connection string',
+        }
       }
     },
     async start(sink, how) {
       if (how.mode === 'off') return () => {}
       await db.createCollection?.(BARRIER, { capped: true, size: 1 << 20 }).catch(() => {})
-      let stream: MongoStream | undefined, stopped = false, timer: ReturnType<typeof setTimeout> | undefined, again = false
-      const pipeline = [{ $match: { 'ns.coll': { $in: [...collections, BARRIER] } } }, { $project: { operationType: 1, documentKey: 1, 'ns.coll': 1, 'fullDocument.tags': 1 } }]
+      let stream: MongoStream | undefined,
+        stopped = false,
+        timer: ReturnType<typeof setTimeout> | undefined,
+        again = false
+      const pipeline = [
+        { $match: { 'ns.coll': { $in: [...collections, BARRIER] } } },
+        { $project: { operationType: 1, documentKey: 1, 'ns.coll': 1, 'fullDocument.tags': 1 } },
+      ]
       const run = async () => {
         if (stopped) return
         try {
@@ -109,9 +187,18 @@ export function mongoChanges(db: MongoDb, collections: string[], options: { retr
           sink.up()
           again = true
           for await (const c of stream) {
-            if (c.ns?.coll === BARRIER) { if (c.fullDocument?.tags) sink.settled(c.fullDocument.tags); continue }
-            if (!['insert', 'update', 'replace', 'delete'].includes(c.operationType) || !c.ns?.coll) continue
-            sink.changes([{ table: c.ns.coll, ...(c.documentKey?._id !== undefined && { id: String(c.documentKey._id) }) }])
+            if (c.ns?.coll === BARRIER) {
+              if (c.fullDocument?.tags) sink.settled(c.fullDocument.tags)
+              continue
+            }
+            if (!['insert', 'update', 'replace', 'delete'].includes(c.operationType) || !c.ns?.coll)
+              continue
+            sink.changes([
+              {
+                table: c.ns.coll,
+                ...(c.documentKey?._id !== undefined && { id: String(c.documentKey._id) }),
+              },
+            ])
           }
         } catch (e) {
           if (!stopped) sink.down(`change stream: ${said(e)}`)
@@ -125,12 +212,15 @@ export function mongoChanges(db: MongoDb, collections: string[], options: { retr
         await stream?.close?.()
       }
     },
-    settle: async tags => void (await db.collection(BARRIER).insertOne({ tags })),
+    settle: async (tags) => void (await db.collection(BARRIER).insertOne({ tags })),
   }
 }
 
 /** The fields of a change-stream event that say what happened to which row. */
-export interface MongoChange { operationType: string; documentKey?: { _id?: string | number | { toString(): string } } }
+export interface MongoChange {
+  operationType: string
+  documentKey?: { _id?: string | number | { toString(): string } }
+}
 
 /** The tags of one change: the collection's, and the row's. Never the row itself. */
 export function changeTags(change: MongoChange, tag: string): string[] {
@@ -153,12 +243,17 @@ export interface WatchOptions {
  * Writes from cron, a shell or another service reach `.live` queries, as tags. Needs a replica set. After a lost stream
  * the whole collection's tag is poked, because what happened meanwhile is unknown. Returns the way to stop.
  */
-export function watchMongo(collection: MongoCollection, options: WatchOptions = {}): () => Promise<void> {
+export function watchMongo(
+  collection: MongoCollection,
+  options: WatchOptions = {},
+): () => Promise<void> {
   const tag = options.tag ?? collection.collectionName
   if (!tag) throw new Error('`watchMongo` needs a `tag`')
   const poke = options.poke ?? ((tags: string[]) => hub().poke(tags))
   const retry = options.retry ?? 1000
-  let stream: MongoStream | undefined, stopped = false, timer: ReturnType<typeof setTimeout> | undefined
+  let stream: MongoStream | undefined,
+    stopped = false,
+    timer: ReturnType<typeof setTimeout> | undefined
   const run = async (again: boolean) => {
     if (stopped) return
     try {

package/src/native/auth.ts

@@ -1,16 +1,40 @@
-// Better Auth on Native (research 34 §5): Better Auth speaks Kysely, so this is a Kysely dialect over Native's own
-// connection. One connection on every engine and runtime, with no second driver and no ORM in the app's code.
+// Better Auth uses a Kysely dialect over Native's connection, without a second driver.
 
 import type { Dialect } from 'kysely'
 import { driver } from '../driver'
 import type { NativeDb } from './index'
 
-const { MysqlAdapter, MysqlIntrospector, MysqlQueryCompiler, PostgresAdapter, PostgresIntrospector, PostgresQueryCompiler, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } = await driver('@weft-js/db/plugin-native/auth', 'kysely', () => import('kysely'))
+const {
+  MysqlAdapter,
+  MysqlIntrospector,
+  MysqlQueryCompiler,
+  PostgresAdapter,
+  PostgresIntrospector,
+  PostgresQueryCompiler,
+  SqliteAdapter,
+  SqliteIntrospector,
+  SqliteQueryCompiler,
+} = await driver('@weft-js/db/plugin-native/auth', 'kysely', () => import('kysely'))
 
 const PARTS = {
-  sqlite: { adapter: SqliteAdapter, compiler: SqliteQueryCompiler, introspector: SqliteIntrospector, type: 'sqlite' },
-  postgresql: { adapter: PostgresAdapter, compiler: PostgresQueryCompiler, introspector: PostgresIntrospector, type: 'postgres' },
-  mysql: { adapter: MysqlAdapter, compiler: MysqlQueryCompiler, introspector: MysqlIntrospector, type: 'mysql' },
+  sqlite: {
+    adapter: SqliteAdapter,
+    compiler: SqliteQueryCompiler,
+    introspector: SqliteIntrospector,
+    type: 'sqlite',
+  },
+  postgresql: {
+    adapter: PostgresAdapter,
+    compiler: PostgresQueryCompiler,
+    introspector: PostgresIntrospector,
+    type: 'postgres',
+  },
+  mysql: {
+    adapter: MysqlAdapter,
+    compiler: MysqlQueryCompiler,
+    introspector: MysqlIntrospector,
+    type: 'mysql',
+  },
 } as const
 
 /** Better Auth's `database` option on a Native client. It runs without transactions, which Better Auth treats as optional. */
@@ -18,10 +42,13 @@ export function nativeAuth(db: NativeDb) {
   const { adapter, compiler, introspector, type } = PARTS[db.$weft.dialect]
   const connection = {
     async executeQuery({ sql, parameters }: { sql: string; parameters: readonly unknown[] }) {
-      const out = await db.query(sql, [...parameters]) as unknown
+      const out = (await db.query(sql, [...parameters])) as unknown
       // mysql2 answers a write with a header, not rows.
       if (Array.isArray(out)) return { rows: out }
-      return { rows: [], numAffectedRows: BigInt((out as { affectedRows?: number }).affectedRows ?? 0) }
+      return {
+        rows: [],
+        numAffectedRows: BigInt((out as { affectedRows?: number }).affectedRows ?? 0),
+      }
     },
     streamQuery(): never {
       throw new Error('Native has no streaming queries')
@@ -38,7 +65,8 @@ export function nativeAuth(db: NativeDb) {
       commitTransaction: async () => {},
       rollbackTransaction: async () => {},
     }),
-    createIntrospector: (kysely: ConstructorParameters<typeof SqliteIntrospector>[0]) => new introspector(kysely),
+    createIntrospector: (kysely: ConstructorParameters<typeof SqliteIntrospector>[0]) =>
+      new introspector(kysely),
     createQueryCompiler: () => new compiler(),
   } as unknown as Dialect
   return { dialect, type, transaction: false }

package/src/native/index.ts

@@ -1,5 +1,4 @@
-// The no-ORM client (research 34 §4): one `sql` tag over any driver. Values always go to the driver as parameters, so
-// a template can't build SQL from a value. An engine file supplies the driver; `createNative` takes your own the same way.
+// SQL template values always go to the driver as parameters.
 
 import { gate, register, touch, type DbHandle, type Migration } from '@weft-js/start/db/core'
 
@@ -9,11 +8,9 @@ export type Row = Record<string, unknown>
 /** What an engine supplies: statements, files of them, a transaction and a lock. */
 export interface Driver<D = unknown> {
   dialect: DbHandle['dialect']
-  /** The client underneath, for anything `sql` doesn't cover. */
   raw: D
   /** Run one statement with bound values, and return its rows as objects. */
   query(text: string, params: unknown[]): Promise<Row[]>
-  /** Run a whole file of statements. */
   exec(text: string): Promise<void>
   /** Run `fn` on one connection, committed when it resolves. */
   transaction<T>(fn: (driver: Pick<Driver, 'query'>) => Promise<T>): Promise<T>
@@ -34,29 +31,43 @@ export interface NativeDb<D = unknown> {
   $weft: DbHandle
 }
 
-const placeholder = (dialect: DbHandle['dialect'], i: number) => (dialect === 'postgresql' ? `$${i + 1}` : '?')
+const placeholder = (dialect: DbHandle['dialect'], i: number) =>
+  dialect === 'postgresql' ? `$${i + 1}` : '?'
 
-const tag = (handle: DbHandle, query: Driver['query']): Sql => (strings, ...values) => {
-  const text = strings.reduce((out, part, i) => out + placeholder(handle.dialect, i - 1) + part)
-  touch(handle, text)
-  return query(text, values)
-}
+const tag =
+  (handle: DbHandle, query: Driver['query']): Sql =>
+  (strings, ...values) => {
+    const text = strings.reduce((out, part, i) => out + placeholder(handle.dialect, i - 1) + part)
+    touch(handle, text)
+    return query(text, values)
+  }
 
 /** A client over any `Driver`, with its migrations behind the same gate as every statement. */
-export function createNative<D>(driver: Driver<D>, { migrate = true }: { migrate?: boolean | undefined } = {}): NativeDb<D> {
+export function createNative<D>(
+  driver: Driver<D>,
+  { migrate = true }: { migrate?: boolean | undefined } = {},
+): NativeDb<D> {
   const handle: DbHandle = {
     dialect: driver.dialect,
     exempt: new Set(),
-    migrate: (list: Migration[]) => driver.locked(async () => {
-      await driver.exec('create table if not exists __weft_migrations (tag varchar(255) primary key)')
-      const done = new Set((await driver.query('select tag from __weft_migrations', [])).map(r => r.tag))
-      for (const m of list) {
-        if (done.has(m.tag)) continue
-        // A file with only comments is a migration still being written; some engines refuse an empty query.
-        if (m.sql.replace(/--.*$/gm, '').trim()) await driver.exec(m.sql)
-        await driver.query(`insert into __weft_migrations (tag) values (${placeholder(driver.dialect, 0)})`, [m.tag])
-      }
-    }),
+    migrate: (list: Migration[]) =>
+      driver.locked(async () => {
+        await driver.exec(
+          'create table if not exists __weft_migrations (tag varchar(255) primary key)',
+        )
+        const done = new Set(
+          (await driver.query('select tag from __weft_migrations', [])).map((r) => r.tag),
+        )
+        for (const m of list) {
+          if (done.has(m.tag)) continue
+          // A file with only comments is a migration still being written; some engines refuse an empty query.
+          if (m.sql.replace(/--.*$/gm, '').trim()) await driver.exec(m.sql)
+          await driver.query(
+            `insert into __weft_migrations (tag) values (${placeholder(driver.dialect, 0)})`,
+            [m.tag],
+          )
+        }
+      }),
   }
   const ready = gate(handle, migrate)
   const query: Driver['query'] = async (text, params) => (await ready(), driver.query(text, params))
@@ -64,8 +75,10 @@ export function createNative<D>(driver: Driver<D>, { migrate = true }: { migrate
     sql: tag(handle, query),
     query,
     driver: driver.raw,
-    transaction: async <T>(fn: (tx: { sql: Sql }) => Promise<T>) => (await ready(), driver.transaction(tx => fn({ sql: tag(handle, tx.query) }))),
+    transaction: async <T>(fn: (tx: { sql: Sql }) => Promise<T>) => (
+      await ready(),
+      driver.transaction((tx) => fn({ sql: tag(handle, tx.query) }))
+    ),
   }
   return register(db, handle)
 }
-

package/src/native/mysql.ts

@@ -4,13 +4,25 @@
 import { driver } from '../driver'
 import { createNative, type Driver, type Row } from './index'
 
-const { createConnection, createPool } = await driver('@weft-js/db/plugin-native/mysql', 'mysql2', () => import('mysql2/promise'))
+const { createConnection, createPool } = await driver(
+  '@weft-js/db/plugin-native/mysql',
+  'mysql2',
+  () => import('mysql2/promise'),
+)
 
 const LOCK = 'weft_migrations'
 type ExecuteValues = Parameters<Awaited<ReturnType<typeof createConnection>>['execute']>[1]
 
 /** A client on a mysql2 pool. */
-export function createDb({ url, migrate, max = 10 }: { url: string; migrate?: boolean; max?: number }) {
+export function createDb({
+  url,
+  migrate,
+  max = 10,
+}: {
+  url: string
+  migrate?: boolean
+  max?: number
+}) {
   const uri = url || 'mysql://localhost/build'
   // No `maxIdle` below the limit: that starts mysql2's reaper, a timer that keeps a finished `weft build` alive forever.
   const pool = createPool({ uri, connectionLimit: max })
@@ -31,7 +43,9 @@ export function createDb({ url, migrate, max = 10 }: { url: string; migrate?: bo
       const c = await pool.getConnection()
       try {
         await c.beginTransaction()
-        const out = await fn({ query: (text, params) => rows(c.execute(text, params as ExecuteValues)) })
+        const out = await fn({
+          query: (text, params) => rows(c.execute(text, params as ExecuteValues)),
+        })
         await c.commit()
         return out
       } catch (e) {
@@ -44,8 +58,11 @@ export function createDb({ url, migrate, max = 10 }: { url: string; migrate?: bo
     async locked(fn) {
       const c = await pool.getConnection()
       try {
-        const [got] = await c.query('select get_lock(?, 60) as got', [LOCK]) as unknown as [{ got: unknown }[]]
-        if (Number(got[0]?.got) !== 1) throw new Error('another instance held the migration lock for 60s')
+        const [got] = (await c.query('select get_lock(?, 60) as got', [LOCK])) as unknown as [
+          { got: unknown }[],
+        ]
+        if (Number(got[0]?.got) !== 1)
+          throw new Error('another instance held the migration lock for 60s')
         return await fn()
       } finally {
         await c.query('select release_lock(?)', [LOCK]).catch(() => {})