@weft-js/start 0.1.1 → 0.1.3

package/src/db/changes-sqlite.ts

@@ -15,10 +15,20 @@ interface Conn {
 }
 
 // statfs(2) magic numbers: https://man7.org/linux/man-pages/man2/statfs.2.html
-const NETWORK = new Set([0x6969 /* nfs */, 0x517b /* smb */, 0xfe534d42 /* smb2 */, 0xff534d42 /* cifs */, 0x65735546 /* fuse */, 0x5346414f /* afs */, 0xc36400 /* ceph */, 0x47504653 /* gpfs */])
+const NETWORK = new Set([
+  0x6969 /* nfs */, 0x517b /* smb */, 0xfe534d42 /* smb2 */, 0xff534d42 /* cifs */,
+  0x65735546 /* fuse */, 0x5346414f /* afs */, 0xc36400 /* ceph */, 0x47504653 /* gpfs */,
+])
 
 /** Whether a file is on a network file system. `exec` and `statfs` are the test's way in. */
-export function onNetwork(path: string, { platform = process.platform, statfs = statfsSync, df = (p: string) => execFileSync('df', ['-P', p], { encoding: 'utf8' }) } = {}): boolean {
+export function onNetwork(
+  path: string,
+  {
+    platform = process.platform,
+    statfs = statfsSync,
+    df = (p: string) => execFileSync('df', ['-P', p], { encoding: 'utf8' }),
+  } = {},
+): boolean {
   try {
     if (platform === 'linux') return NETWORK.has(statfs(path).type)
     const device = df(path).trim().split('\n').at(-1)!.split(/\s+/)[0] ?? ''
@@ -28,84 +38,141 @@ export function onNetwork(path: string, { platform = process.platform, statfs =
   }
 }
 
-interface Options { path: string; open: (path: string) => Promise<Conn>; tables: string[]; interval?: number }
+interface Options {
+  path: string
+  open: (path: string) => Promise<Conn>
+  tables: string[]
+  interval?: number
+}
+
+async function startWatcher(
+  sink: Sink,
+  how: Probe,
+  o: Required<Options> & { set: (tick?: () => void, out?: Sink) => void },
+) {
+  const { path, open, tables, interval, set } = o
+  if (how.mode === 'off') return () => {}
+  const c = await open(path)
+  const version = () => (c.query('pragma data_version', [], 'values') as number[][])[0]![0]!
+  const usable = how.mode === 'feed'
+  const newest = () =>
+    (c.query(`select coalesce(max(seq), 0) from ${LOG}`, [], 'values') as number[][])[0]![0]!
+  let seq = usable ? newest() : 0
+  let at = version()
+  let timer: ReturnType<typeof setTimeout> | undefined
+  const read = () => {
+    const rows = c.query(
+      `select seq, tbl, pk from ${LOG} where seq > ? order by seq`,
+      [seq],
+      'values',
+    ) as [number, string, string | null][]
+    if (!rows.length) return
+    if (rows[0]![0] > seq + 1) sink.lost() // the log moved past us
+    const byTable = new Map<string, Set<string> | null>()
+    for (const [, table, id] of rows) {
+      if (id === null) byTable.set(table, null)
+      else if (byTable.get(table) !== null) {
+        const ids = byTable.get(table) ?? new Set()
+        ids.add(id)
+        byTable.set(table, ids.size > MAX_IDS ? null : ids)
+      }
+    }
+    seq = rows.at(-1)![0]
+    const list: Change[] = []
+    for (const [table, ids] of byTable)
+      ids ? list.push(...[...ids].map((id) => ({ table, id }))) : list.push({ table })
+    sink.changes(list)
+  }
+  const look = () => {
+    try {
+      const now = version()
+      if (now === at) return
+      at = now
+      if (usable) read()
+      else sink.changes(tables.map((table) => ({ table })))
+      sink.up()
+    } catch (e) {
+      sink.down(`SQLite watcher: ${(e as Error | null)?.message ?? String(e)}`)
+    }
+  }
+  set(look, sink)
+  const every = () => {
+    look()
+    timer = setTimeout(every, interval)
+    ;(timer as { unref?(): void }).unref?.()
+  }
+  every()
+  return () => {
+    set()
+    clearTimeout(timer)
+    c.close?.()
+  }
+}
 
 export function sqliteChanges({ path, open, tables, interval = 100 }: Options) {
-  const log = (c: Conn) => (c.query(`select count(*) from sqlite_master where name = '${LOG}'`, [], 'values') as number[][])[0]![0]! > 0
-  const triggers = (c: Conn) => (c.query(`select tbl_name from sqlite_master where type = 'trigger' and name like 'weft\\_changes\\_%\\_upd' escape '\\'`, [], 'values') as string[][]).map(r => r[0])
+  const log = (c: Conn) =>
+    (
+      c.query(
+        `select count(*) from sqlite_master where name = '${LOG}'`,
+        [],
+        'values',
+      ) as number[][]
+    )[0]![0]! > 0
+  const triggers = (c: Conn) =>
+    (
+      c.query(
+        `select tbl_name from sqlite_master where type = 'trigger' and name like 'weft\\_changes\\_%\\_upd' escape '\\'`,
+        [],
+        'values',
+      ) as string[][]
+    ).map((r) => r[0])
   let tick: (() => void) | undefined, out: Sink | undefined
 
   async function probe(): Promise<Probe> {
-    if (path === ':memory:') return { mode: 'off', via: 'none', why: 'an in-memory database has no other writers, and no second connection could see it', fix: 'use a file to have writes from other processes reach `.live`' }
-    if (onNetwork(existsSync(path) ? path : '.')) return { mode: 'off', via: 'none', why: `\`${path}\` is on a network file system: \`data_version\` and WAL don't work across hosts`, fix: 'put the database on a local disk, or move to Postgres' }
+    if (path === ':memory:')
+      return {
+        mode: 'off',
+        via: 'none',
+        why: 'an in-memory database has no other writers, and no second connection could see it',
+        fix: 'use a file to have writes from other processes reach `.live`',
+      }
+    if (onNetwork(existsSync(path) ? path : '.'))
+      return {
+        mode: 'off',
+        via: 'none',
+        why: `\`${path}\` is on a network file system: \`data_version\` and WAL don't work across hosts`,
+        fix: 'put the database on a local disk, or move to Postgres',
+      }
     const c = await open(path)
     try {
       const have = log(c) ? triggers(c) : []
-      const missing = tables.filter(t => !have.includes(t))
-      if (missing.length) return { mode: 'poll', via: 'sqlite-data-version', why: `no trigger on ${missing.map(t => `\`${t}\``).join(', ')}: any commit pokes every table, unrelated ones included`, fix: 'run `weft db live`' }
+      const missing = tables.filter((t) => !have.includes(t))
+      if (missing.length)
+        return {
+          mode: 'poll',
+          via: 'sqlite-data-version',
+          why: `no trigger on ${missing.map((t) => `\`${t}\``).join(', ')}: any commit pokes every table, unrelated ones included`,
+          fix: 'run `weft db live`',
+        }
       return { mode: 'feed', via: 'sqlite-data-version' }
     } finally {
       c.close?.()
     }
   }
 
-  async function start(sink: Sink, how: Probe) {
-    if (how.mode === 'off') return () => {}
-    const c = await open(path)
-    const version = () => (c.query('pragma data_version', [], 'values') as number[][])[0]![0]!
-    const usable = how.mode === 'feed'
-    const newest = () => (c.query(`select coalesce(max(seq), 0) from ${LOG}`, [], 'values') as number[][])[0]![0]!
-    let seq = usable ? newest() : 0
-    let at = version()
-    let timer: ReturnType<typeof setTimeout> | undefined
-    const read = () => {
-      const rows = c.query(`select seq, tbl, pk from ${LOG} where seq > ? order by seq`, [seq], 'values') as [number, string, string | null][]
-      if (!rows.length) return
-      if (rows[0]![0] > seq + 1) sink.lost() // the log moved past us
-      const byTable = new Map<string, Set<string> | null>()
-      for (const [, table, id] of rows) {
-        if (id === null) byTable.set(table, null)
-        else if (byTable.get(table) !== null) {
-          const ids = byTable.get(table) ?? new Set()
-          ids.add(id)
-          byTable.set(table, ids.size > MAX_IDS ? null : ids)
-        }
-      }
-      seq = rows.at(-1)![0]
-      const list: Change[] = []
-      for (const [table, ids] of byTable) ids ? list.push(...[...ids].map(id => ({ table, id }))) : list.push({ table })
-      sink.changes(list)
-    }
-    const look = () => {
-      try {
-        const now = version()
-        if (now === at) return
-        at = now
-        if (usable) read()
-        else sink.changes(tables.map(table => ({ table })))
-        sink.up()
-      } catch (e) {
-        sink.down(`SQLite watcher: ${(e as Error | null)?.message ?? String(e)}`)
-      }
-    }
-    tick = look
-    out = sink
-    const every = () => {
-      look()
-      timer = setTimeout(every, interval)
-      ;(timer as { unref?(): void }).unref?.()
-    }
-    every()
-    return () => {
-      tick = out = undefined
-      clearTimeout(timer)
-      c.close?.()
-    }
-  }
-
   return {
     probe,
-    start,
+    start: (sink: Sink, how: Probe) =>
+      startWatcher(sink, how, {
+        path,
+        open,
+        tables,
+        interval,
+        set: (next, target) => {
+          tick = next
+          out = target
+        },
+      }),
     /** In this process, so the barrier needs no trip: read what's committed now, and let the hub drop what the poke covers. */
     settle(tags: string[]) {
       tick?.()

package/src/db/core.ts

@@ -6,7 +6,10 @@ import { currentScope, runtime, StartError } from '../data'
 import type { Probe, Sink } from '../changes'
 
 /** One migration file: its name and the SQL. */
-export interface Migration { tag: string; sql: string }
+export interface Migration {
+  tag: string
+  sql: string
+}
 
 /** What every Weft database carries on `$weft`, whichever driver is under it. */
 export interface DbHandle {
@@ -16,15 +19,28 @@ export interface DbHandle {
   /** Tables Q011 doesn't report (Better Auth's). */
   exempt: Set<string>
   /** `dbChanges`'s source: loaded on the first use, so a database with no live tables loads none of it. */
-  changes?(tables: string[], options: { listenUrl?: string; interval?: number }): Promise<{ probe(): Promise<Probe>; start(sink: Sink, how: Probe): Promise<() => unknown>; settle?(tags: string[]): Promise<void> }>
+  changes?(
+    tables: string[],
+    options: { listenUrl?: string; interval?: number },
+  ): Promise<{
+    probe(): Promise<Probe>
+    start(sink: Sink, how: Probe): Promise<() => unknown>
+    settle?(tags: string[]): Promise<void>
+  }>
 }
 
-/** Attach weft's handle to a client. */
-export const register = <D extends object>(db: D, handle: DbHandle): D & { $weft: DbHandle } => Object.assign(db, { $weft: handle })
+/** Attach Weft's handle to a client. */
+export const register = <D extends object>(db: D, handle: DbHandle): D & { $weft: DbHandle } =>
+  Object.assign(db, { $weft: handle })
 
 /** The database can't be used: its connection, or a migration it needs. The client sees this; the server log gets the cause. */
 export const unavailable = (cause: unknown) =>
-  new StartError('Q016', 'the database is unavailable, or a migration failed', 'start it and check `DATABASE_URL`; the server log has the driver\'s error', { status: 503, cause })
+  new StartError(
+    'Q016',
+    'the database is unavailable, or a migration failed',
+    "start it and check `DATABASE_URL`; the server log has the driver's error",
+    { status: 503, cause },
+  )
 
 /**
  * What a provider awaits before each statement, or its connection call: resolved once the list the server's first request
@@ -40,11 +56,14 @@ export function gate(handle: DbHandle, migrate: boolean) {
     if (!migrate || !m) return undefined
     if (m !== applied) {
       applied = m
-      run = run.catch(() => {}).then(() => handle.migrate(m.list)).catch(e => {
-        if (applied === m) applied = undefined
-        m.report(e)
-        throw unavailable(e)
-      })
+      run = run
+        .catch(() => {})
+        .then(() => handle.migrate(m.list))
+        .catch((e) => {
+          if (applied === m) applied = undefined
+          m.report(e)
+          throw unavailable(e)
+        })
     }
     return run
   }
@@ -54,10 +73,16 @@ export function gate(handle: DbHandle, migrate: boolean) {
 export function touch(handle: DbHandle, sql: string) {
   const t = currentScope()?.touched
   if (!t) return
-  const target = /^\s*(?:insert\s+into|update|delete\s+from)\s+(?:["`]?\w+["`]?\.)?["`]?([\w$]+)/i.exec(sql)?.[1]
+  const target =
+    /^\s*(?:insert\s+into|update|delete\s+from)\s+(?:["`]?\w+["`]?\.)?["`]?([\w$]+)/i.exec(sql)?.[1]
   if (target && !handle.exempt.has(target)) t.write.add(target)
-  for (const m of sql.matchAll(/\b(?:from|join)\s+(?:["`]?\w+["`]?\.)?["`]?([\w$]+)/gi)) if (m[1] !== target && !handle.exempt.has(m[1]!)) t.read.add(m[1]!)
+  for (const m of sql.matchAll(/\b(?:from|join)\s+(?:["`]?\w+["`]?\.)?["`]?([\w$]+)/gi))
+    if (m[1] !== target && !handle.exempt.has(m[1]!)) t.read.add(m[1]!)
 }
 
 /** A migration file's statements (drizzle-kit separates them with this marker). */
-export const statements = (sql: string) => sql.split('--> statement-breakpoint').map(s => s.trim()).filter(Boolean)
+export const statements = (sql: string) =>
+  sql
+    .split('--> statement-breakpoint')
+    .map((s) => s.trim())
+    .filter(Boolean)

package/src/db/index.ts

@@ -2,7 +2,12 @@
 // schema per table, so a table is its own validator: `input: schemas.todos.insert.pick({ title: true })`.
 
 import { getTableName, isTable, type Table } from 'drizzle-orm'
-import { createInsertSchema, createSelectSchema, createUpdateSchema, type BuildSchema } from 'drizzle-zod'
+import {
+  createInsertSchema,
+  createSelectSchema,
+  createUpdateSchema,
+  type BuildSchema,
+} from 'drizzle-zod'
 
 export type { DbHandle, Migration } from './core'
 
@@ -11,15 +16,26 @@ type Select<T extends Table> = BuildSchema<'select', T['_']['columns'], undefine
 type Insert<T extends Table> = BuildSchema<'insert', T['_']['columns'], undefined, undefined>
 type Update<T extends Table> = BuildSchema<'update', T['_']['columns'], undefined, undefined>
 /** The select and insert types of each table in a schema. */
-export type Schemas<S> = { [K in keyof TablesOf<S>]: TablesOf<S>[K] extends infer T extends Table ? { select: Select<T>; insert: Insert<T>; update: Update<T> } : never }
+export type Schemas<S> = {
+  [K in keyof TablesOf<S>]: TablesOf<S>[K] extends infer T extends Table
+    ? { select: Select<T>; insert: Insert<T>; update: Update<T> }
+    : never
+}
 
 /** `refine`: per table, per column, what drizzle-zod takes: `{ todos: { title: s => s.trim().min(1) } }`. */
-export function schemasOf<S extends Record<string, unknown>>(schema: S, refine: { [K in keyof TablesOf<S>]?: Record<string, (s: never) => unknown> } = {}): Schemas<S> {
+export function schemasOf<S extends Record<string, unknown>>(
+  schema: S,
+  refine: { [K in keyof TablesOf<S>]?: Record<string, (s: never) => unknown> } = {},
+): Schemas<S> {
   const out: Record<string, unknown> = {}
   for (const [k, t] of Object.entries(schema)) {
     if (!isTable(t)) continue
     const r = (refine as Record<string, never>)[k]
-    out[k] = { select: createSelectSchema(t, r), insert: createInsertSchema(t, r), update: createUpdateSchema(t, r) }
+    out[k] = {
+      select: createSelectSchema(t, r),
+      insert: createInsertSchema(t, r),
+      update: createUpdateSchema(t, r),
+    }
   }
   return out as Schemas<S>
 }

package/src/db/mysql.ts

@@ -24,10 +24,19 @@ export type MysqlDb<S extends Record<string, unknown>> = MySql2Database<S> & { $
 const LOCK = 'weft_migrations'
 
 /** A pooled Drizzle client on MySQL, with this app's migrations and write tracking. */
-export function createDb<S extends Record<string, unknown>>({ schema, url, migrate = true, max = 10 }: MysqlOptions<S>): MysqlDb<S> {
+export function createDb<S extends Record<string, unknown>>({
+  schema,
+  url,
+  migrate = true,
+  max = 10,
+}: MysqlOptions<S>): MysqlDb<S> {
   if (!url && process.env.WEFT_BUILD) url = 'mysql://localhost/build' // a build loads this module and never connects
   if (!url?.startsWith('mysql://'))
-    throw new StartError('Q013', `\`@weft-js/start/db/mysql\` needs a \`mysql://\` URL, not \`${(url ?? '').replace(/\/\/.*@/, '//…@')}\``, 'set `DATABASE_URL`, or `createDb` from `@weft-js/start/db/sqlite`')
+    throw new StartError(
+      'Q013',
+      `\`@weft-js/start/db/mysql\` needs a \`mysql://\` URL, not \`${(url ?? '').replace(/\/\/.*@/, '//…@')}\``,
+      'set `DATABASE_URL`, or `createDb` from `@weft-js/start/db/sqlite`',
+    )
   // No `maxIdle` below the limit: that starts mysql2's reaper, a timer that keeps a finished `weft build` alive forever.
   const pool = createPool({ uri: url, connectionLimit: max })
   const handle: DbHandle = {
@@ -37,9 +46,11 @@ export function createDb<S extends Record<string, unknown>>({ schema, url, migra
       const c = await pool.getConnection()
       try {
         await c.query('select get_lock(?, 60)', [LOCK])
-        await c.query('create table if not exists __weft_migrations (tag varchar(255) primary key, at timestamp not null default current_timestamp)')
+        await c.query(
+          'create table if not exists __weft_migrations (tag varchar(255) primary key, at timestamp not null default current_timestamp)',
+        )
         const [rows] = await c.query('select tag from __weft_migrations')
-        const done = new Set((rows as { tag: string }[]).map(r => r.tag))
+        const done = new Set((rows as { tag: string }[]).map((r) => r.tag))
         for (const m of list) {
           if (done.has(m.tag)) continue
           for (const s of statements(m.sql)) await c.query(s)
@@ -50,7 +61,8 @@ export function createDb<S extends Record<string, unknown>>({ schema, url, migra
         c.release()
       }
     },
-    changes: (tables, o) => import('./changes-mysql').then(m => m.mysqlChanges({ ...o, pool, tables })),
+    changes: (tables, o) =>
+      import('./changes-mysql').then((m) => m.mysqlChanges({ ...o, pool, tables })),
   }
   const ready = gate(handle, migrate)
   // All Drizzle sends goes through these three, so holding them holds it; `handle.migrate` keeps the plain pool.
@@ -62,6 +74,10 @@ export function createDb<S extends Record<string, unknown>>({ schema, url, migra
       return async (...a: unknown[]) => (await ready(), v.apply(t, a))
     },
   })
-  const db = drizzle(held, { schema, mode: 'default', logger: { logQuery: sql => touch(handle, sql) } })
+  const db = drizzle(held, {
+    schema,
+    mode: 'default',
+    logger: { logQuery: (sql) => touch(handle, sql) },
+  })
   return register(db, handle)
 }

package/src/db/postgres.ts

@@ -16,28 +16,52 @@ export interface PostgresOptions<S extends Record<string, unknown>> {
   migrate?: boolean
   /** Pool size (default 10). */
   max?: number
+  /**
+   * Keep each statement prepared on its connection (default true). Drizzle asks for neither, and an unprepared statement
+   * with parameters is two round trips, a describe before every bind. Off behind a pooler in transaction mode. A long
+   * list isn't kept: each length is a statement of its own, and each statement stays in the connection's memory.
+   */
+  prepare?: boolean
 }
 
 /** Drizzle on postgres.js, with `$weft` for the framework's own needs. */
-export type PostgresDb<S extends Record<string, unknown>> = PostgresJsDatabase<S> & { $weft: DbHandle }
+export type PostgresDb<S extends Record<string, unknown>> = PostgresJsDatabase<S> & {
+  $weft: DbHandle
+}
 
 const LOCK = 7_301_986
+/** The most parameters a statement that's kept takes. Past it, `inArray` over a growing list is what's asking. */
+const KEPT = 32
 
 /** A pooled Drizzle client on Postgres, with this app's migrations and write tracking. */
-export function createDb<S extends Record<string, unknown>>({ schema, url, migrate = true, max = 10 }: PostgresOptions<S>): PostgresDb<S> {
+export function createDb<S extends Record<string, unknown>>({
+  schema,
+  url,
+  migrate = true,
+  max = 10,
+  prepare = true,
+}: PostgresOptions<S>): PostgresDb<S> {
   if (!url && process.env.WEFT_BUILD) url = 'postgres://localhost/build' // a build loads this module and never connects
   if (!/^postgres(ql)?:\/\//.test(url ?? ''))
-    throw new StartError('Q013', `\`@weft-js/start/db/postgres\` needs a \`postgres://\` URL, not \`${(url ?? '').replace(/\/\/.*@/, '//…@')}\``, 'set `DATABASE_URL`, or `createDb` from `@weft-js/start/db/sqlite` for a file')
+    throw new StartError(
+      'Q013',
+      `\`@weft-js/start/db/postgres\` needs a \`postgres://\` URL, not \`${(url ?? '').replace(/\/\/.*@/, '//…@')}\``,
+      'set `DATABASE_URL`, or `createDb` from `@weft-js/start/db/sqlite` for a file',
+    )
   // Idle connections close, so a stopped server can exit.
   const client = postgres(url, { max, idle_timeout: 20, onnotice: () => {} })
   const handle: DbHandle = {
     dialect: 'postgresql',
     exempt: new Set(),
     async migrate(list: Migration[]) {
-      await client.begin(async tx => {
+      await client.begin(async (tx) => {
         await tx.unsafe(`select pg_advisory_xact_lock(${LOCK})`)
-        await tx.unsafe('create table if not exists __weft_migrations (tag text primary key, at timestamptz not null default now())')
-        const done = new Set((await tx.unsafe('select tag from __weft_migrations')).map(r => r.tag))
+        await tx.unsafe(
+          'create table if not exists __weft_migrations (tag text primary key, at timestamptz not null default now())',
+        )
+        const done = new Set(
+          (await tx.unsafe('select tag from __weft_migrations')).map((r) => r.tag),
+        )
         for (const m of list) {
           if (done.has(m.tag)) continue
           for (const s of statements(m.sql)) await tx.unsafe(s)
@@ -45,21 +69,33 @@ export function createDb<S extends Record<string, unknown>>({ schema, url, migra
         }
       })
     },
-    changes: (tables, o) => import('./changes-postgres').then(m => m.postgresChanges({ ...o, url, client, tables })),
+    changes: (tables, o) =>
+      import('./changes-postgres').then((m) => m.postgresChanges({ ...o, url, client, tables })),
   }
   const ready = gate(handle, migrate)
   // All Drizzle sends goes through `unsafe` and `begin`, so holding those holds it; `handle.migrate` keeps the plain client.
   const held = new Proxy(client, {
     get(t, key) {
-      if (key === 'begin') return async (...a: Parameters<typeof t.begin>) => (await ready(), t.begin(...a))
+      if (key === 'begin')
+        return async (...a: Parameters<typeof t.begin>) => (await ready(), t.begin(...a))
       if (key !== 'unsafe') return Reflect.get(t, key)
-      return (...a: Parameters<typeof t.unsafe>) => {
-        const after = <T>(send: () => PromiseLike<T>) => Promise.resolve(ready()).then(send)
-        // oxlint-disable-next-line unicorn/no-thenable -- postgres.js's query is a lazy thenable, and Drizzle awaits it as one
-        return { values: () => after(() => t.unsafe(...a).values()), then: <A, B>(ok: (rows: unknown) => A, no: (e: unknown) => B) => after(() => t.unsafe(...a)).then(ok, no) }
+      return (
+        text: string,
+        params?: postgres.ParameterOrJSON<never>[],
+        options?: postgres.UnsafeQueryOptions,
+      ) => {
+        const send = () =>
+          t.unsafe(text, params, { ...options, prepare: prepare && (params?.length ?? 0) <= KEPT })
+        const after = <T>(go: () => PromiseLike<T>) => Promise.resolve(ready()).then(go)
+        // oxlint-disable unicorn/no-thenable -- postgres.js's query is a lazy thenable, and Drizzle awaits it as one
+        return {
+          values: () => after(() => send().values()),
+          then: <A, B>(ok: (rows: unknown) => A, no: (e: unknown) => B) =>
+            after(send).then(ok, no) /* oxlint-enable unicorn/no-thenable */,
+        }
       }
     },
   })
-  const db = drizzle(held, { schema, logger: { logQuery: sql => touch(handle, sql) } })
+  const db = drizzle(held, { schema, logger: { logQuery: (sql) => touch(handle, sql) } })
   return register(db, handle)
 }

package/src/db/sqlite.ts

@@ -32,8 +32,11 @@ export async function open(path: string): Promise<Conn> {
     const { Database } = await import('bun:sqlite')
     const db = new Database(path, { create: true })
     conn = {
-      query: (sql, params, method) => (method === 'run' ? void db.prepare(sql).run(...params) : pick(db.prepare(sql).values(...params), method)),
-      exec: sql => void db.run(sql),
+      query: (sql, params, method) =>
+        method === 'run'
+          ? void db.prepare(sql).run(...params)
+          : pick(db.prepare(sql).values(...params), method),
+      exec: (sql) => void db.run(sql),
       close: () => db.close(),
     }
   } else {
@@ -46,7 +49,7 @@ export async function open(path: string): Promise<Conn> {
         s.setReturnArrays(true)
         return pick(s.all(...(params as SQLInputValue[])) as unknown as unknown[][], method)
       },
-      exec: sql => db.exec(sql),
+      exec: (sql) => db.exec(sql),
       close: () => db.close(),
     }
   }
@@ -55,6 +58,26 @@ export async function open(path: string): Promise<Conn> {
   return conn
 }
 
+async function migrateSqlite(connect: () => Promise<Conn>, list: Migration[]) {
+  const c = await connect()
+  c.exec('create table if not exists __weft_migrations (tag text primary key, at integer not null)')
+  const done = new Set(
+    (c.query('select tag from __weft_migrations', [], 'values') as string[][]).map((r) => r[0]),
+  )
+  for (const m of list) {
+    if (done.has(m.tag)) continue
+    c.exec('begin')
+    try {
+      for (const s of statements(m.sql)) c.exec(s)
+      c.query('insert into __weft_migrations values (?, ?)', [m.tag, Date.now()], 'run')
+      c.exec('commit')
+    } catch (e) {
+      c.exec('rollback')
+      throw e
+    }
+  }
+}
+
 /** `createDb` on SQLite: the schema, the file, and whether to migrate on first use. */
 export interface SqliteOptions<S extends Record<string, unknown>> {
   schema: S
@@ -65,38 +88,37 @@ export interface SqliteOptions<S extends Record<string, unknown>> {
 }
 
 /** Drizzle over a local file, with `$weft` for the framework's own needs. */
-export type SqliteDb<S extends Record<string, unknown>> = SqliteRemoteDatabase<S> & { $weft: DbHandle }
+export type SqliteDb<S extends Record<string, unknown>> = SqliteRemoteDatabase<S> & {
+  $weft: DbHandle
+}
 
 /** A Drizzle client on a SQLite file, with this app's migrations and write tracking. */
-export function createDb<S extends Record<string, unknown>>({ schema, url = 'file:.data/app.db', migrate = true }: SqliteOptions<S>): SqliteDb<S> {
+export function createDb<S extends Record<string, unknown>>({
+  schema,
+  url = 'file:.data/app.db',
+  migrate = true,
+}: SqliteOptions<S>): SqliteDb<S> {
   if (/^[a-z][a-z0-9+.-]+:\/\//i.test(url) && !url.startsWith('file:'))
-    throw new StartError('Q013', `\`@weft-js/start/db/sqlite\` can't open \`${url.replace(/\/\/.*@/, '//…@')}\``, 'use `file:<path>`, or `createDb` from `@weft-js/start/db/postgres` for a Postgres URL')
+    throw new StartError(
+      'Q013',
+      `\`@weft-js/start/db/sqlite\` can't open \`${url.replace(/\/\/.*@/, '//…@')}\``,
+      'use `file:<path>`, or `createDb` from `@weft-js/start/db/postgres` for a Postgres URL',
+    )
   const path = url.replace(/^file:/, '')
   let conn: Promise<Conn> | undefined
-  const connect = () => (conn ??= open(path).catch(e => { conn = undefined; throw e }))
+  const connect = () =>
+    (conn ??= open(path).catch((e) => {
+      conn = undefined
+      throw e
+    }))
   const inside = new AsyncLocalStorage<boolean>()
   let held: Promise<unknown> = Promise.resolve()
   const handle: DbHandle = {
     dialect: 'sqlite',
     exempt: new Set(),
-    async migrate(list: Migration[]) {
-      const c = await connect()
-      c.exec('create table if not exists __weft_migrations (tag text primary key, at integer not null)')
-      const done = new Set((c.query('select tag from __weft_migrations', [], 'values') as string[][]).map(r => r[0]))
-      for (const m of list) {
-        if (done.has(m.tag)) continue
-        c.exec('begin')
-        try {
-          for (const s of statements(m.sql)) c.exec(s)
-          c.query('insert into __weft_migrations values (?, ?)', [m.tag, Date.now()], 'run')
-          c.exec('commit')
-        } catch (e) {
-          c.exec('rollback')
-          throw e
-        }
-      }
-    },
-    changes: (tables, o) => import('./changes-sqlite').then(m => m.sqliteChanges({ ...o, path, open, tables })),
+    migrate: (list) => migrateSqlite(connect, list),
+    changes: (tables, o) =>
+      import('./changes-sqlite').then((m) => m.sqliteChanges({ ...o, path, open, tables })),
   }
   const ready = gate(handle, migrate)
   const run = async (sql: string, params: unknown[], method: Method) => {
@@ -112,7 +134,9 @@ export function createDb<S extends Record<string, unknown>>({ schema, url = 'fil
     await held
     c.exec('begin')
     try {
-      const out = list.map(q => (touch(handle, q.sql), { rows: c.query(q.sql, q.params, q.method) as unknown[] }))
+      const out = list.map(
+        (q) => (touch(handle, q.sql), { rows: c.query(q.sql, q.params, q.method) as unknown[] }),
+      )
       c.exec('commit')
       return out
     } catch (e) {
@@ -127,7 +151,9 @@ export function createDb<S extends Record<string, unknown>>({ schema, url = 'fil
     await ready()
     const before = held
     let release!: () => void
-    held = new Promise<void>(ok => { release = ok })
+    held = new Promise<void>((ok) => {
+      release = ok
+    })
     await before
     try {
       return await inside.run(true, () => transaction(...args))

package/src/derive.d.mts

@@ -9,7 +9,10 @@ export function descriptionProblem(text: string): string | undefined
 /** A page's title and description, as a person would pick them out of its HTML. */
 export function pageText(html: string): { title?: string; description?: string }
 /** The site's URL, from its config or from what the host says about this deploy. */
-export function deployUrl(site: { url?: string | undefined } | undefined, env?: Record<string, string | undefined>): string | undefined
+export function deployUrl(
+  site: { url?: string | undefined } | undefined,
+  env?: Record<string, string | undefined>,
+): string | undefined
 /** The card title's font size, smaller for a longer title. */
 export function cardTitleSize(title: string): number
 /** `paths` in pages that each fit in a response header. */