@weft-js/db 0.1.1 → 0.1.2

package/src/firestore.ts

@@ -2,13 +2,29 @@
 // document id is the row's id. Firestore can't search inside a string, and a range is one field at a time, so `search`
 // is a prefix on the first search column, and can't be combined with another sort.
 
-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 { StartError } from '@weft-js/start/data'
 
-const NAME = '__name__', HIGH = '', IN_MAX = 30
+const NAME = '__name__',
+  HIGH = '',
+  IN_MAX = 30
 
 /** One document, read. */
-export interface FirestoreDoc { id: string; exists: boolean; data(): object | undefined }
+export interface FirestoreDoc {
+  id: string
+  exists: boolean
+  data(): object | undefined
+}
 
 /** Where one document lives. */
 export interface FirestoreRef {
@@ -35,39 +51,78 @@ export interface FirestoreCollection {
   doc(id?: string): FirestoreRef
 }
 
+type FirestoreList<Row> = {
+  collection: FirestoreCollection
+  spec: SourceSpec
+  stored: string[]
+  idColumn: string
+  idField: string
+  row: (doc: FirestoreDoc) => Row
+}
+
+async function listRows<Row>(p: ListParams, context: FirestoreList<Row>) {
+  const { collection, spec, stored, idColumn, idField, row } = context
+  const q = plan(spec, p)
+  let b = collection.select(...stored)
+  for (const w of q.where) {
+    if (w.values.length > IN_MAX)
+      throw new StartError('Q002', `Firestore takes ${IN_MAX} values in a filter`, 'ask for fewer')
+    b =
+      w.values.length === 1
+        ? b.where(w.column, '==' as never, w.values[0])
+        : b.where(w.column, 'in' as never, w.values)
+  }
+  let first = q.sort?.column === idColumn ? null : (q.sort?.column ?? null)
+  const dir = q.sort?.dir ?? 'asc'
+  if (q.search) {
+    const field = q.search.columns[0]!
+    if (first && first !== field)
+      throw new StartError(
+        'Q002',
+        "Firestore can't search one field and sort by another",
+        'drop one',
+      )
+    first = field
+    b = b
+      .where(field, '>=' as never, q.search.text)
+      .where(field, '<=' as never, q.search.text + HIGH)
+  }
+  const counted = b
+  if (first) b = b.orderBy(first, dir)
+  b = b.orderBy(NAME, dir)
+  if (p.after) b = first ? b.startAfter(p.after[0], p.after[1]) : b.startAfter(p.after[1])
+  const cursor = p.mode === 'cursor'
+  if (p.offset) b = b.offset(p.offset)
+  const rows = (await b.limit(cursor ? p.limit + 1 : p.limit).get()).docs.map(row)
+  const total = cursor ? undefined : (await counted.count().get()).data().count
+  return pageOf(
+    rows,
+    p,
+    {
+      sort:
+        q.sort?.field ??
+        (first ? Object.keys(spec.columns).find((k) => spec.columns[k] === first) : undefined),
+      id: idField,
+    },
+    total,
+  )
+}
+
 /** A `ListSource` over one collection, keyed by document id. */
-export function firestoreSource<Row = Record<string, unknown>>(collection: FirestoreCollection, spec: SourceSpec): ListSource<Row> {
+export function firestoreSource<Row = Record<string, unknown>>(
+  collection: FirestoreCollection,
+  spec: SourceSpec,
+): ListSource<Row> {
   const reading = rowOf<Row>(spec)
-  const idField = spec.id ?? 'id', idColumn = storedId(spec)
-  const stored = Object.values(spec.columns).filter(c => c !== idColumn)
+  const idField = spec.id ?? 'id',
+    idColumn = storedId(spec)
+  const stored = Object.values(spec.columns).filter((c) => c !== idColumn)
   const row = (doc: FirestoreDoc) => reading({ [idColumn]: doc.id, ...doc.data() })
   const at = (id: unknown) => collection.doc(String(id))
   return {
     limits: { search: 'prefix' },
-    async list(p: ListParams) {
-      const q = plan(spec, p)
-      let b = collection.select(...stored)
-      for (const w of q.where) {
-        if (w.values.length > IN_MAX) throw new StartError('Q002', `Firestore takes ${IN_MAX} values in a filter`, 'ask for fewer')
-        b = w.values.length === 1 ? b.where(w.column, '==' as never, w.values[0]) : b.where(w.column, 'in' as never, w.values)
-      }
-      let first = q.sort?.column === idColumn ? null : q.sort?.column ?? null
-      const dir = q.sort?.dir ?? 'asc'
-      if (q.search) {
-        const field = q.search.columns[0]!
-        if (first && first !== field) throw new StartError('Q002', 'Firestore can\'t search one field and sort by another', 'drop one')
-        first = field
-        b = b.where(field, '>=' as never, q.search.text).where(field, '<=' as never, q.search.text + HIGH)
-      }
-      const counted = b
-      if (first) b = b.orderBy(first, dir)
-      b = b.orderBy(NAME, dir)
-      if (p.after) b = first ? b.startAfter(p.after[0], p.after[1]) : b.startAfter(p.after[1])
-      const cursor = p.mode === 'cursor'
-      if (p.offset) b = b.offset(p.offset)
-      const rows = (await b.limit(cursor ? p.limit + 1 : p.limit).get()).docs.map(row)
-      const total = cursor ? undefined : (await counted.count().get()).data().count
-      return pageOf(rows, p, { sort: q.sort?.field ?? (first ? Object.keys(spec.columns).find(k => spec.columns[k] === first) : undefined), id: idField }, total)
+    list(p: ListParams) {
+      return listRows(p, { collection, spec, stored, idColumn, idField, row })
     },
     async get(id) {
       const doc = await at(id).get()
@@ -96,4 +151,7 @@ export function firestoreSource<Row = Record<string, unknown>>(collection: Fires
 }
 
 /** `db.adapter@1` over a Firestore collection. */
-export const adapter: DbAdapter<FirestoreCollection> = { name: 'firestore', source: (t, spec) => firestoreSource(t, spec) }
+export const adapter: DbAdapter<FirestoreCollection> = {
+  name: 'firestore',
+  source: (t, spec) => firestoreSource(t, spec),
+}

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 }