@weft-js/db 0.1.1 → 0.1.3

package/src/native/postgres.ts

@@ -3,24 +3,42 @@
 import { driver } from '../driver'
 import { createNative, type Driver, type Row } from './index'
 
-const { default: postgres } = await driver('@weft-js/db/plugin-native/postgres', 'postgres', () => import('postgres'))
+const { default: postgres } = await driver(
+  '@weft-js/db/plugin-native/postgres',
+  'postgres',
+  () => import('postgres'),
+)
 
 const LOCK = 7_301_987
 
 /** A client on a postgres.js connection pool. */
-export function createDb({ url, migrate, max = 10 }: { url: string; migrate?: boolean; max?: number }) {
-  const client = postgres(url || 'postgres://localhost/build', { max, idle_timeout: 20, onnotice: () => {} })
-  const on = (c: { unsafe: typeof client.unsafe }) => (text: string, params: unknown[]) => c.unsafe(text, params as Parameters<typeof client.unsafe>[1]) as unknown as Promise<Row[]>
+export function createDb({
+  url,
+  migrate,
+  max = 10,
+}: {
+  url: string
+  migrate?: boolean
+  max?: number
+}) {
+  const client = postgres(url || 'postgres://localhost/build', {
+    max,
+    idle_timeout: 20,
+    onnotice: () => {},
+  })
+  const on = (c: { unsafe: typeof client.unsafe }) => (text: string, params: unknown[]) =>
+    c.unsafe(text, params as Parameters<typeof client.unsafe>[1]) as unknown as Promise<Row[]>
   const engine: Driver<typeof client> = {
     dialect: 'postgresql',
     raw: client,
     query: on(client),
-    exec: async text => void (await client.unsafe(text)),
-    transaction: fn => client.begin(tx => fn({ query: on(tx) })),
-    locked: fn => client.begin(async tx => {
-      await tx.unsafe(`select pg_advisory_xact_lock(${LOCK})`)
-      return fn()
-    }),
+    exec: async (text) => void (await client.unsafe(text)),
+    transaction: (fn) => client.begin((tx) => fn({ query: on(tx) })),
+    locked: (fn) =>
+      client.begin(async (tx) => {
+        await tx.unsafe(`select pg_advisory_xact_lock(${LOCK})`)
+        return fn()
+      }),
   }
   return createNative(engine, { migrate })
 }

package/src/native/sqlite.ts

@@ -18,12 +18,21 @@ async function open(path: string): Promise<Conn> {
   if ('Bun' in globalThis) {
     const { Database } = await import('bun:sqlite')
     const db = new Database(path, { create: true })
-    conn = { all: (text, params) => db.prepare(text).all(...params), exec: text => void db.run(text) }
+    conn = {
+      all: (text, params) => db.prepare(text).all(...params),
+      exec: (text) => void db.run(text),
+    }
   } else {
     const { DatabaseSync } = await import('node:sqlite')
     const db = new DatabaseSync(path)
     // `node:sqlite` on Deno refuses a boolean, which SQLite stores as 0 or 1 anyway.
-    conn = { all: (text, params) => db.prepare(text).all(...(params.map(v => (typeof v === 'boolean' ? Number(v) : v)) as SQLInputValue[])), exec: text => db.exec(text) }
+    conn = {
+      all: (text, params) =>
+        db
+          .prepare(text)
+          .all(...(params.map((v) => (typeof v === 'boolean' ? Number(v) : v)) as SQLInputValue[])),
+      exec: (text) => db.exec(text),
+    }
   }
   if (path !== ':memory:') conn.exec('pragma journal_mode = wal')
   conn.exec('pragma foreign_keys = on; pragma busy_timeout = 5000')
@@ -31,7 +40,10 @@ async function open(path: string): Promise<Conn> {
 }
 
 /** A client on one SQLite file, or `:memory:`. */
-export function createDb({ url = 'file:.data/app.db', migrate }: { url?: string; migrate?: boolean } = {}) {
+export function createDb({
+  url = 'file:.data/app.db',
+  migrate,
+}: { url?: string; migrate?: boolean } = {}) {
   const path = url.replace(/^file:/, '')
   let conn: Promise<Conn> | undefined
   const connect = () => (conn ??= open(path))
@@ -46,13 +58,15 @@ export function createDb({ url = 'file:.data/app.db', migrate }: { url?: string;
     dialect: 'sqlite',
     raw: connect,
     query,
-    exec: async text => (await connect()).exec(text),
+    exec: async (text) => (await connect()).exec(text),
     async transaction(fn) {
       if (inside.getStore()) return fn({ query })
       const c = await connect()
       const before = gate
       let release!: () => void
-      gate = new Promise<void>(ok => { release = ok })
+      gate = new Promise<void>((ok) => {
+        release = ok
+      })
       await before
       try {
         c.exec('begin')
@@ -68,7 +82,7 @@ export function createDb({ url = 'file:.data/app.db', migrate }: { url?: string;
         release()
       }
     },
-    locked: fn => fn(),
+    locked: (fn) => fn(),
   }
   return createNative(driver, { migrate })
 }

package/src/prisma-client.ts

@@ -1,4 +1,4 @@
-// Prisma on weft's seam (research 34 §4): `withWeft(client, dialect)` returns the same client with the handle the server
+// Prisma: `withWeft(client, dialect)` returns the same client with the handle the server
 // migrates and Q011 reads. Migrations are `prisma/migrations`, applied here because `prisma migrate deploy` isn't in a
 // production bundle. Interactive transactions keep the lock and the statements on one connection. It stays Prisma's own
 // client, so weft can't hold a statement: the server runs the gate per request instead, and a failed run doesn't fail it.
@@ -13,39 +13,68 @@ interface Tx {
 }
 interface Client extends Tx {
   $on?(event: 'query', fn: (e: { query: string }) => void): void
-  $transaction<T>(fn: (tx: Tx) => Promise<T>, options: { maxWait: number; timeout: number }): Promise<T>
+  $transaction<T>(
+    fn: (tx: Tx) => Promise<T>,
+    options: { maxWait: number; timeout: number },
+  ): Promise<T>
 }
 
 const LOCK = 7_301_988
-const statements = (sql: string) => sql.split(/;[ \t]*(?:\r?\n|$)/).map(s => s.replace(/^(\s*--.*\n)+/, '').trim()).filter(Boolean)
+const statements = (sql: string) =>
+  sql
+    .split(/;[ \t]*(?:\r?\n|$)/)
+    .map((s) => s.replace(/^(\s*--.*\n)+/, '').trim())
+    .filter(Boolean)
 
 /** The same client, with `$weft`: the handle the server migrates and Q011 reads. */
-export function withWeft<C extends object>(client: C, dialect: Dialect, { migrate = true }: { migrate?: boolean | undefined } = {}): C & { $weft: DbHandle } {
+export function withWeft<C extends object>(
+  client: C,
+  dialect: Dialect,
+  { migrate = true }: { migrate?: boolean | undefined } = {},
+): C & { $weft: DbHandle } {
   const c = client as unknown as Client
   const handle: DbHandle = {
     dialect,
     exempt: new Set(),
-    migrate: (list: Migration[]) => c.$transaction(async tx => {
-      if (dialect === 'postgresql') await tx.$queryRawUnsafe(`select pg_advisory_xact_lock(${LOCK})::text`)
-      if (dialect === 'mysql') {
-        const got = await tx.$queryRawUnsafe<{ got: unknown }[]>(`select get_lock('weft_migrations', 60) as got`)
-        if (Number(got[0]?.got) !== 1) throw new Error('another instance held the migration lock for 60s')
-      }
-      try {
-        await tx.$executeRawUnsafe('create table if not exists __weft_migrations (tag varchar(255) primary key)')
-        const done = new Set((await tx.$queryRawUnsafe<{ tag: string }[]>('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.$executeRawUnsafe(s)
-          await tx.$executeRawUnsafe(`insert into __weft_migrations (tag) values (${dialect === 'postgresql' ? '$1' : '?'})`, m.tag)
-        }
-      } finally {
-        // MySQL's lock belongs to the connection, not the transaction: a failed run would keep it in the pool.
-        if (dialect === 'mysql') await tx.$queryRawUnsafe(`select release_lock('weft_migrations')`).catch(() => {})
-      }
-    }, { maxWait: 60_000, timeout: 120_000 }),
+    migrate: (list: Migration[]) =>
+      c.$transaction(
+        async (tx) => {
+          if (dialect === 'postgresql')
+            await tx.$queryRawUnsafe(`select pg_advisory_xact_lock(${LOCK})::text`)
+          if (dialect === 'mysql') {
+            const got = await tx.$queryRawUnsafe<{ got: unknown }[]>(
+              `select get_lock('weft_migrations', 60) as got`,
+            )
+            if (Number(got[0]?.got) !== 1)
+              throw new Error('another instance held the migration lock for 60s')
+          }
+          try {
+            await tx.$executeRawUnsafe(
+              'create table if not exists __weft_migrations (tag varchar(255) primary key)',
+            )
+            const done = new Set(
+              (
+                await tx.$queryRawUnsafe<{ tag: string }[]>('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.$executeRawUnsafe(s)
+              await tx.$executeRawUnsafe(
+                `insert into __weft_migrations (tag) values (${dialect === 'postgresql' ? '$1' : '?'})`,
+                m.tag,
+              )
+            }
+          } finally {
+            // MySQL's lock belongs to the connection, not the transaction: a failed run would keep it in the pool.
+            if (dialect === 'mysql')
+              await tx.$queryRawUnsafe(`select release_lock('weft_migrations')`).catch(() => {})
+          }
+        },
+        { maxWait: 60_000, timeout: 120_000 },
+      ),
   }
-  c.$on?.('query', e => touch(handle, e.query))
+  c.$on?.('query', (e) => touch(handle, e.query))
   ;(runtime.dbs ??= new Set()).add(gate(handle, migrate))
   return register(client, handle)
 }

package/src/prisma.ts

@@ -1,7 +1,17 @@
 // A list source over a Prisma model delegate: `prismaSource(ctx.db.task, { columns })`. It only reads what a delegate
 // has, so it needs nothing from `@prisma/client` and works with any generated client.
 
-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'
 
 /** What a generated client's model has, whatever its schema. */
 export interface PrismaDelegate {
@@ -21,42 +31,106 @@ export interface PrismaSpec extends SourceSpec {
 
 const MISSING = 'P2025'
 
+type PrismaList<Row> = {
+  model: PrismaDelegate
+  spec: PrismaSpec
+  select: Record<string, boolean>
+  idColumn: string
+  reading: (row: object) => Row
+  escaped: boolean
+}
+
+async function listRows<Row>(p: ListParams, context: PrismaList<Row>) {
+  const { model, spec, select, idColumn, reading, escaped } = context
+  const q = plan(spec, p)
+  const and: object[] = q.where.map((w) => {
+    const some = w.values.filter((v) => v !== null)
+    return {
+      OR: [
+        ...(some.length ? [{ [w.column]: { in: some } }] : []),
+        ...(w.values.includes(null) ? [{ [w.column]: null }] : []),
+      ],
+    }
+  })
+  if (q.search) {
+    const term = q.search.text.replace(/[\\%_]/g, '\\$&')
+    and.push({
+      OR: q.search.columns.map((c) => ({
+        [c]: { contains: term, ...(escaped ? { mode: 'insensitive' } : {}) },
+      })),
+    })
+  }
+  const where = { AND: and }
+  const dir = q.sort?.dir === 'desc' ? 'desc' : 'asc',
+    cmp = dir === 'desc' ? 'lt' : 'gt'
+  const keyset = p.after
+    ? q.sort
+      ? {
+          OR: [
+            { [q.sort.column]: { [cmp]: p.after[0] } },
+            { [q.sort.column]: p.after[0], [idColumn]: { [cmp]: p.after[1] } },
+          ],
+        }
+      : { [idColumn]: { gt: p.after[1] } }
+    : undefined
+  const orderBy = q.sort ? [{ [q.sort.column]: dir }, { [idColumn]: dir }] : [{ [idColumn]: 'asc' }]
+  const cursor = p.mode === 'cursor'
+  const rows = (
+    await model.findMany({
+      select,
+      where: keyset ? { AND: [where, keyset] } : where,
+      orderBy,
+      take: cursor ? p.limit + 1 : p.limit,
+      skip: p.offset,
+    })
+  ).map(reading)
+  return pageOf(
+    rows,
+    p,
+    { sort: q.sort?.field, id: q.id.field },
+    cursor ? undefined : await model.count({ where }),
+  )
+}
+
 /** A `ListSource` over one Prisma model. */
-export function prismaSource<Row = Record<string, unknown>>(model: PrismaDelegate, spec: PrismaSpec): ListSource<Row> {
-  const select = Object.fromEntries(Object.values(spec.columns).map(c => [c, true]))
+export function prismaSource<Row = Record<string, unknown>>(
+  model: PrismaDelegate,
+  spec: PrismaSpec,
+): ListSource<Row> {
+  const select = Object.fromEntries(Object.values(spec.columns).map((c) => [c, true]))
   const reading = rowOf<Row>(spec)
   const idColumn = storedId(spec)
-  const missing = (e: unknown) => { if ((e as { code?: string } | null)?.code !== MISSING) throw e; return null }
+  const missing = (e: unknown) => {
+    if ((e as { code?: string } | null)?.code !== MISSING) throw e
+    return null
+  }
   // Prisma leaves `%` and `_` as wildcards in `contains`, so a term with either is checked again here.
   const escaped = spec.insensitive !== false
   return {
     limits: { search: 'cased' },
-    async list(p: ListParams) {
-      const q = plan(spec, p)
-      const and: object[] = q.where.map(w => {
-        const some = w.values.filter(v => v !== null)
-        return { OR: [...(some.length ? [{ [w.column]: { in: some } }] : []), ...(w.values.includes(null) ? [{ [w.column]: null }] : [])] }
-      })
-      if (q.search) {
-        const term = q.search.text.replace(/[\\%_]/g, '\\$&')
-        and.push({ OR: q.search.columns.map(c => ({ [c]: { contains: term, ...(escaped ? { mode: 'insensitive' } : {}) } })) })
-      }
-      const where = { AND: and }
-      const dir = q.sort?.dir === 'desc' ? 'desc' : 'asc', cmp = dir === 'desc' ? 'lt' : 'gt'
-      const keyset = p.after
-        ? q.sort ? { OR: [{ [q.sort.column]: { [cmp]: p.after[0] } }, { [q.sort.column]: p.after[0], [idColumn]: { [cmp]: p.after[1] } }] } : { [idColumn]: { gt: p.after[1] } }
-        : undefined
-      const orderBy = q.sort ? [{ [q.sort.column]: dir }, { [idColumn]: dir }] : [{ [idColumn]: 'asc' }]
-      const cursor = p.mode === 'cursor'
-      const rows = (await model.findMany({ select, where: keyset ? { AND: [where, keyset] } : where, orderBy, take: cursor ? p.limit + 1 : p.limit, skip: p.offset })).map(reading)
-      return pageOf(rows, p, { sort: q.sort?.field, id: q.id.field }, cursor ? undefined : await model.count({ where }))
+    list(p: ListParams) {
+      return listRows(p, { model, spec, select, idColumn, reading, escaped })
+    },
+    get: async (id) => {
+      const r = await model.findUnique({ where: { [idColumn]: id }, select })
+      return r ? reading(r) : null
     },
-    get: async id => { const r = await model.findUnique({ where: { [idColumn]: id }, select }); return r ? reading(r) : null },
-    create: async data => reading(await model.create({ data: written(spec, data, true), select })),
-    update: (id, patch) => { const data = written(spec, patch); return model.update({ where: { [idColumn]: id }, data, select }).then(reading, missing) },
-    remove: id => model.delete({ where: { [idColumn]: id }, select: { [idColumn]: true } }).then(() => true, e => missing(e) ?? false),
+    create: async (data) =>
+      reading(await model.create({ data: written(spec, data, true), select })),
+    update: (id, patch) => {
+      const data = written(spec, patch)
+      return model.update({ where: { [idColumn]: id }, data, select }).then(reading, missing)
+    },
+    remove: (id) =>
+      model.delete({ where: { [idColumn]: id }, select: { [idColumn]: true } }).then(
+        () => true,
+        (e) => missing(e) ?? false,
+      ),
   }
 }
 
 /** `db.adapter@1` over a Prisma model. */
-export const adapter: DbAdapter<PrismaDelegate> = { name: 'prisma', source: (t, spec) => prismaSource(t, spec) }
+export const adapter: DbAdapter<PrismaDelegate> = {
+  name: 'prisma',
+  source: (t, spec) => prismaSource(t, spec),
+}

package/src/sql.ts

@@ -1,7 +1,18 @@
 // A list source from bound SQL: `columns` is required, identifiers come only from it, and every value
 // is a parameter. `target` is anything with `query(text, params)`: `ctx.db` from `@weft-js/db/plugin-native`, or a driver.
 
-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'
 
 /** Whatever runs a bound statement, and says which dialect it speaks. */
@@ -12,20 +23,101 @@ export interface SqlTarget {
 }
 
 /** A source's allowlist, and the table it covers. */
-export interface SqlSpec extends SourceSpec { table: string }
+export interface SqlSpec extends SourceSpec {
+  table: string
+}
 
 const IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/
 
 function ident(dialect: string) {
   const q = dialect === 'mysql' ? '`' : '"'
   return (name: string) => {
-    if (!IDENT.test(name)) throw new StartError('Q002', `\`${name}\` is not a plain identifier, so it can't go in SQL`, 'use a column name')
+    if (!IDENT.test(name))
+      throw new StartError(
+        'Q002',
+        `\`${name}\` is not a plain identifier, so it can't go in SQL`,
+        'use a column name',
+      )
     return `${q}${name}${q}`
   }
 }
 
+function listSql<Row>({
+  target,
+  spec,
+  q,
+  bind,
+  read,
+  table,
+  select,
+  idColumn,
+}: {
+  target: SqlTarget
+  spec: SqlSpec
+  q: (name: string) => string
+  bind: (params: unknown[]) => (value: unknown) => string
+  read: (text: string, params: unknown[]) => Promise<Row[]>
+  table: string
+  select: string
+  idColumn: string
+}): ListSource<Row>['list'] {
+  return async function list(p: ListParams) {
+    const qp = plan(spec, p)
+    const params: unknown[] = []
+    const put = bind(params)
+    const parts = qp.where.map((w) => {
+      const some = w.values.filter((v) => v !== null)
+      const hit =
+        some.length === 1
+          ? `${q(w.column)} = ${put(some[0])}`
+          : some.length
+            ? `${q(w.column)} in (${some.map(put).join(', ')})`
+            : ''
+      return w.values.includes(null) ? `(${hit ? `${hit} or ` : ''}${q(w.column)} is null)` : hit
+    })
+    if (qp.search) {
+      const text = likeOf(qp.search.text)
+      parts.push(
+        `(${qp.search.columns.map((c) => `lower(${q(c)}) like ${put(text)} escape '!'`).join(' or ')})`,
+      )
+    }
+    const filtered = [...parts],
+      mark = params.length // what the count binds: the keyset isn't part of it
+    const cmp = qp.sort?.dir === 'desc' ? '<' : '>'
+    if (p.after) {
+      const [value, id] = p.after
+      const col = qp.sort && q(qp.sort.column)
+      parts.push(
+        col
+          ? `(${col} ${cmp} ${put(value)} or (${col} = ${put(value)} and ${idColumn} ${cmp} ${put(id)}))`
+          : `${idColumn} > ${put(id)}`,
+      )
+    }
+    const where = (conditions: string[]) =>
+      conditions.length ? ` where ${conditions.join(' and ')}` : ''
+    const dir = qp.sort?.dir === 'desc' ? 'desc' : 'asc'
+    const order = qp.sort ? `${q(qp.sort.column)} ${dir}, ${idColumn} ${dir}` : `${idColumn} asc`
+    const cursor = p.mode === 'cursor'
+    const counted = params.slice(0, mark)
+    const rows = await read(
+      `select ${select} from ${table}${where(parts)} order by ${order} limit ${Math.trunc(cursor ? p.limit + 1 : p.limit)} offset ${Math.trunc(p.offset)}`,
+      params,
+    )
+    const total = cursor
+      ? undefined
+      : Number(
+          (await target.query(`select count(*) as n from ${table}${where(filtered)}`, counted))[0]!
+            .n,
+        )
+    return pageOf(rows, p, { sort: qp.sort?.field, id: qp.id.field }, total)
+  }
+}
+
 /** A `ListSource` over one table, as bound SQL. */
-export function sqlSource<Row = Record<string, unknown>>(target: SqlTarget, spec: SqlSpec): ListSource<Row> {
+export function sqlSource<Row = Record<string, unknown>>(
+  target: SqlTarget,
+  spec: SqlSpec,
+): ListSource<Row> {
   const dialect = target.dialect ?? target.$weft?.dialect ?? 'postgresql'
   const q = ident(dialect)
   for (const c of [spec.table, ...Object.values(spec.columns)]) q(c)
@@ -37,52 +129,47 @@ export function sqlSource<Row = Record<string, unknown>>(target: SqlTarget, spec
     params.push(v)
     return dialect === 'postgresql' ? `$${params.length}` : '?'
   }
-  const read = async (text: string, params: unknown[]) => (await target.query(text, params)).map(reading)
-  const byId = (id: unknown) => { const params: unknown[] = []; return read(`select ${select} from ${table} where ${idColumn} = ${bind(params)(id)}`, params).then(r => r[0] ?? null) }
+  const read = async (text: string, params: unknown[]) =>
+    (await target.query(text, params)).map(reading)
+  const byId = (id: unknown) => {
+    const params: unknown[] = []
+    return read(
+      `select ${select} from ${table} where ${idColumn} = ${bind(params)(id)}`,
+      params,
+    ).then((r) => r[0] ?? null)
+  }
   return {
-    async list(p: ListParams) {
-      const qp = plan(spec, p)
-      const params: unknown[] = []
-      const put = bind(params)
-      const parts = qp.where.map(w => {
-        const some = w.values.filter(v => v !== null)
-        const hit = some.length === 1 ? `${q(w.column)} = ${put(some[0])}` : some.length ? `${q(w.column)} in (${some.map(put).join(', ')})` : ''
-        return w.values.includes(null) ? `(${hit ? `${hit} or ` : ''}${q(w.column)} is null)` : hit
-      })
-      if (qp.search) {
-        const text = likeOf(qp.search.text)
-        parts.push(`(${qp.search.columns.map(c => `lower(${q(c)}) like ${put(text)} escape '!'`).join(' or ')})`)
-      }
-      const filtered = [...parts], mark = params.length // what the count binds: the keyset isn't part of it
-      const cmp = qp.sort?.dir === 'desc' ? '<' : '>'
-      if (p.after) {
-        const [value, id] = p.after
-        const col = qp.sort && q(qp.sort.column)
-        parts.push(col ? `(${col} ${cmp} ${put(value)} or (${col} = ${put(value)} and ${idColumn} ${cmp} ${put(id)}))` : `${idColumn} > ${put(id)}`)
-      }
-      const where = (list: string[]) => (list.length ? ` where ${list.join(' and ')}` : '')
-      const dir = qp.sort?.dir === 'desc' ? 'desc' : 'asc'
-      const order = qp.sort ? `${q(qp.sort.column)} ${dir}, ${idColumn} ${dir}` : `${idColumn} asc`
-      const cursor = p.mode === 'cursor'
-      const counted = params.slice(0, mark)
-      const rows = await read(`select ${select} from ${table}${where(parts)} order by ${order} limit ${Math.trunc(cursor ? p.limit + 1 : p.limit)} offset ${Math.trunc(p.offset)}`, params)
-      const total = cursor ? undefined : Number((await target.query(`select count(*) as n from ${table}${where(filtered)}`, counted))[0]!.n)
-      return pageOf(rows, p, { sort: qp.sort?.field, id: qp.id.field }, total)
-    },
+    list: listSql({ target, spec, q, bind, read, table, select, idColumn }),
     get: byId,
     async create(data) {
       const row = written(spec, data, true)
       const id = data[spec.id ?? 'id']
-      if (id === undefined) throw new StartError('Q002', '`create` needs the id: a generated one can\'t be read back on every dialect', 'generate it before the insert')
-      const keys = Object.keys(row), params: unknown[] = [], put = bind(params)
-      await target.query(`insert into ${table} (${keys.map(q).join(', ')}) values (${keys.map(k => put(row[k])).join(', ')})`, params)
+      if (id === undefined)
+        throw new StartError(
+          'Q002',
+          "`create` needs the id: a generated one can't be read back on every dialect",
+          'generate it before the insert',
+        )
+      const keys = Object.keys(row),
+        params: unknown[] = [],
+        put = bind(params)
+      await target.query(
+        `insert into ${table} (${keys.map(q).join(', ')}) values (${keys.map((k) => put(row[k])).join(', ')})`,
+        params,
+      )
       return (await byId(id))!
     },
     async update(id, patch) {
-      const row = written(spec, patch), params: unknown[] = [], put = bind(params)
-      const sets = Object.keys(row).map(k => `${q(k)} = ${put(row[k])}`)
+      const row = written(spec, patch),
+        params: unknown[] = [],
+        put = bind(params)
+      const sets = Object.keys(row).map((k) => `${q(k)} = ${put(row[k])}`)
       if (!(await byId(id))) return null
-      if (sets.length) await target.query(`update ${table} set ${sets.join(', ')} where ${idColumn} = ${put(id)}`, params)
+      if (sets.length)
+        await target.query(
+          `update ${table} set ${sets.join(', ')} where ${idColumn} = ${put(id)}`,
+          params,
+        )
       return byId(id)
     },
     async remove(id) {
@@ -95,13 +182,24 @@ export function sqlSource<Row = Record<string, unknown>>(target: SqlTarget, spec
 }
 
 /** `db.adapter@1` over bound SQL. */
-export const adapter: DbAdapter<SqlTarget> = { name: 'sql', source: (t, spec) => sqlSource(t, spec as SqlSpec) }
+export const adapter: DbAdapter<SqlTarget> = {
+  name: 'sql',
+  source: (t, spec) => sqlSource(t, spec as SqlSpec),
+}
 
 /**
  * A trigger so writes from anywhere (cron, psql, another service) reach `.live` queries, on the postgres bus: tags, never
  * rows. Run the text once in a migration.
  */
-export function postgresTrigger({ table, id = 'id', tag = table }: { table: string; id?: string; tag?: string }): string {
+export function postgresTrigger({
+  table,
+  id = 'id',
+  tag = table,
+}: {
+  table: string
+  id?: string
+  tag?: string
+}): string {
   const q = ident('postgresql')
   if (!/^[\w:-]+$/.test(tag)) throw new StartError('Q002', `\`${tag}\` can't be a tag in a trigger`)
   const fn = `weft_poke_${table}`