@weft-js/db 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,6 @@
 # @weft-js/db
 
-> **Early release (0.1.0).** APIs will change between minor versions.
+> **Early release (0.1.x).** APIs can change between minor versions.
 
 Database layers and list sources for [`@weft-js/start`](../start). Each driver is an optional peer dependency, and each
 subpath loads only its own.
@@ -21,7 +21,7 @@ this package), `prisma` or `native`.
 |---|---|
 | `@weft-js/db/plugin-native/<engine>` | `createDb({ url })`: a `sql` tag over the driver, with no ORM. Values always go to the driver as parameters. `<engine>` is `sqlite`, `postgres` or `mysql` |
 | `@weft-js/db/plugin-native/auth` | `nativeAuth(db)`: a Better Auth database adapter over that client |
-| `@weft-js/db/plugin-prisma` | `withWeft(client, dialect)`: the same Prisma client, with what weft needs to run its migrations and check its tags |
+| `@weft-js/db/plugin-prisma` | `withWeft(client, dialect)`: the same Prisma client, with what Weft needs to run its migrations and check its tags |
 | `@weft-js/db/sql`, `/kysely`, `/prisma`, `/mongo`, `/dynamodb`, `/firestore` | List sources: the rows behind a `query` that takes `listInput` from `@weft-js/start/list`, paged, filtered, sorted and searched |
 
 The layers and the list sources each have a `/plugin` subpath for `weft.config.ts`, so `weft check` and the plugin lock know it's there.
@@ -29,3 +29,10 @@ The layers and the list sources each have a `/plugin` subpath for `weft.config.t
 ## Docs
 
 `weft docs start` covers the database: `ctx.db`, migrations with `weft db generate`, and change feeds.
+
+## Links
+
+- [Source](https://github.com/Ravonus/weft/tree/main/packages/db)
+- [Weft on GitHub](https://github.com/Ravonus/weft): the framework, the docs and every package
+- [Changelog](https://github.com/Ravonus/weft/blob/main/CHANGELOG.md)
+- [Issues](https://github.com/Ravonus/weft/issues)

package/package.json

@@ -1,8 +1,17 @@
 {
   "name": "@weft-js/db",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "weft's data layers and list sources in one package: each driver is an optional peer, and a subpath loads only its own",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ravonus/weft.git",
+    "directory": "packages/db"
+  },
+  "homepage": "https://github.com/Ravonus/weft/tree/main/packages/db#readme",
+  "bugs": {
+    "url": "https://github.com/Ravonus/weft/issues"
+  },
   "type": "module",
   "exports": {
     "./sql": "./src/sql.ts",
@@ -30,14 +39,14 @@
     "@aws-sdk/client-dynamodb": "^3.0.0",
     "@aws-sdk/lib-dynamodb": "^3.0.0",
     "@prisma/client": ">=6",
-    "@weft-js/start": "^0.1.0",
+    "@weft-js/start": "^0.1.2",
     "better-auth": "^1.7.0",
     "firebase-admin": ">=12",
     "kysely": "^0.29.0",
     "mongodb": ">=6",
     "mysql2": "^3.24.0",
     "postgres": ">=3",
-    "@weft-js/core": "^0.1.0"
+    "@weft-js/core": "^0.1.2"
   },
   "peerDependenciesMeta": {
     "@aws-sdk/client-dynamodb": {
@@ -83,4 +92,4 @@
     "README.md",
     "LICENSE"
   ]
-}
+}

package/plugins/dynamodb.mjs

@@ -9,8 +9,16 @@ export const dynamoSource = definePlugin({
   weft: '*',
   permissions: { net: ['driver:aws-sdk'] },
   contribute: () => ({
-    provides: [provide(slot, { key: 'dynamodb', sides: { server: { module: '@weft-js/db/dynamodb', export: 'adapter' } } })],
-    agents: { title: 'Lists (dynamodb)', text: 'Build a source once, in a server module, with `columns`: only those are selected, returned or written. Then `query({ input: listInput({ sort, filter, search }), run: ({ input }) => source.list(input) })`. warp `Table` reads what comes back. Cursor mode only, and a sort needs a partition and an index.' },
+    provides: [
+      provide(slot, {
+        key: 'dynamodb',
+        sides: { server: { module: '@weft-js/db/dynamodb', export: 'adapter' } },
+      }),
+    ],
+    agents: {
+      title: 'Lists (dynamodb)',
+      text: 'Build a source once, in a server module, with `columns`: only those are selected, returned or written. Then `query({ input: listInput({ sort, filter, search }), run: ({ input }) => source.list(input) })`. warp `Table` reads what comes back. Cursor mode only, and a sort needs a partition and an index.',
+    },
   }),
 })
 

package/plugins/firestore.mjs

@@ -9,8 +9,16 @@ export const firestoreSource = definePlugin({
   weft: '*',
   permissions: { net: ['driver:firebase-admin'] },
   contribute: () => ({
-    provides: [provide(slot, { key: 'firestore', sides: { server: { module: '@weft-js/db/firestore', export: 'adapter' } } })],
-    agents: { title: 'Lists (firestore)', text: 'Build a source once, in a server module, with `columns`: only those are selected, returned or written. Then `query({ input: listInput({ sort, filter, search }), run: ({ input }) => source.list(input) })`. warp `Table` reads what comes back. Search is by prefix on one field, and only without another sort.' },
+    provides: [
+      provide(slot, {
+        key: 'firestore',
+        sides: { server: { module: '@weft-js/db/firestore', export: 'adapter' } },
+      }),
+    ],
+    agents: {
+      title: 'Lists (firestore)',
+      text: 'Build a source once, in a server module, with `columns`: only those are selected, returned or written. Then `query({ input: listInput({ sort, filter, search }), run: ({ input }) => source.list(input) })`. warp `Table` reads what comes back. Search is by prefix on one field, and only without another sort.',
+    },
   }),
 })
 

package/plugins/kysely.mjs

@@ -9,8 +9,16 @@ export const kyselySource = definePlugin({
   weft: '*',
   permissions: { net: ['driver:kysely'] },
   contribute: () => ({
-    provides: [provide(slot, { key: 'kysely', sides: { server: { module: '@weft-js/db/kysely', export: 'adapter' } } })],
-    agents: { title: 'Lists (kysely)', text: 'Build a source once, in a server module, with `columns`: only those are selected, returned or written. Then `query({ input: listInput({ sort, filter, search }), run: ({ input }) => source.list(input) })`. warp `Table` reads what comes back.' },
+    provides: [
+      provide(slot, {
+        key: 'kysely',
+        sides: { server: { module: '@weft-js/db/kysely', export: 'adapter' } },
+      }),
+    ],
+    agents: {
+      title: 'Lists (kysely)',
+      text: 'Build a source once, in a server module, with `columns`: only those are selected, returned or written. Then `query({ input: listInput({ sort, filter, search }), run: ({ input }) => source.list(input) })`. warp `Table` reads what comes back.',
+    },
   }),
 })
 

package/plugins/mongo.mjs

@@ -9,8 +9,16 @@ export const mongoSource = definePlugin({
   weft: '*',
   permissions: { net: ['driver:mongodb'] },
   contribute: () => ({
-    provides: [provide(slot, { key: 'mongo', sides: { server: { module: '@weft-js/db/mongo', export: 'adapter' } } })],
-    agents: { title: 'Lists (mongo)', text: 'Build a source once, in a server module, with `columns`: only those are selected, returned or written. Then `query({ input: listInput({ sort, filter, search }), run: ({ input }) => source.list(input) })`. warp `Table` reads what comes back. `watchMongo` turns writes from anywhere into tag pokes.' },
+    provides: [
+      provide(slot, {
+        key: 'mongo',
+        sides: { server: { module: '@weft-js/db/mongo', export: 'adapter' } },
+      }),
+    ],
+    agents: {
+      title: 'Lists (mongo)',
+      text: 'Build a source once, in a server module, with `columns`: only those are selected, returned or written. Then `query({ input: listInput({ sort, filter, search }), run: ({ input }) => source.list(input) })`. warp `Table` reads what comes back. `watchMongo` turns writes from anywhere into tag pokes.',
+    },
   }),
 })
 

package/plugins/native.mjs

@@ -10,9 +10,12 @@ const DIR = 'migrations'
 function generate(root, name = 'change') {
   const dir = join(root, DIR)
   mkdirSync(dir, { recursive: true })
-  const next = readdirSync(dir).filter(f => f.endsWith('.sql')).length
+  const next = readdirSync(dir).filter((f) => f.endsWith('.sql')).length
   const file = `${String(next).padStart(4, '0')}_${name.replace(/[^\w-]/g, '_')}.sql`
-  writeFileSync(join(dir, file), '-- Applies on the next request. Migrations run once, in file order.\n')
+  writeFileSync(
+    join(dir, file),
+    '-- Applies on the next request. Migrations run once, in file order.\n',
+  )
   return `${DIR}/${file}`
 }
 
@@ -23,8 +26,17 @@ export const native = definePlugin({
   permissions: { fs: { read: ['migrations/**'], write: ['migrations/**'] } },
   contribute: () => ({
     db: { layer: 'native', migrations: DIR, generate },
-    agents: { title: 'Database (Native)', text: 'No ORM: `ctx.db.sql` is a tagged template, and values are always bound, never concatenated. Rows are plain objects. `ctx.db.transaction(tx => …)` gives `tx.sql`, and `ctx.db.driver` is the real driver. `weft db generate <name>` starts a file in `migrations/`; write the SQL by hand. Validate input with your own Zod schemas.' },
-    map: [{ want: 'Change the database', call: '`weft db generate <name>`, then write the SQL in `migrations/`', have: 'no ORM' }],
+    agents: {
+      title: 'Database (Native)',
+      text: 'No ORM: `ctx.db.sql` is a tagged template, and values are always bound, never concatenated. Rows are plain objects. `ctx.db.transaction(tx => …)` gives `tx.sql`, and `ctx.db.driver` is the real driver. `weft db generate <name>` starts a file in `migrations/`; write the SQL by hand. Validate input with your own Zod schemas.',
+    },
+    map: [
+      {
+        want: 'Change the database',
+        call: '`weft db generate <name>`, then write the SQL in `migrations/`',
+        have: 'no ORM',
+      },
+    ],
   }),
 })
 

package/plugins/prisma-client.mjs

@@ -11,19 +11,33 @@ const DIR = 'prisma/migrations'
 function run(root, args) {
   let bin
   try {
-    bin = join(dirname(createRequire(join(root, 'package.json')).resolve('prisma/package.json')), 'build/index.js')
+    bin = join(
+      dirname(createRequire(join(root, 'package.json')).resolve('prisma/package.json')),
+      'build/index.js',
+    )
   } catch {
     throw Object.assign(new Error('prisma is not installed in this project'), { code: 'E_USAGE' })
   }
   const r = spawnSync(process.execPath, [bin, ...args], { cwd: root, encoding: 'utf8' })
-  if (r.status !== 0) throw Object.assign(new Error(`prisma ${args[0]} failed:\n${r.stdout}${r.stderr}`), { code: 'E_INTERNAL' })
+  if (r.status !== 0)
+    throw Object.assign(new Error(`prisma ${args[0]} failed:\n${r.stdout}${r.stderr}`), {
+      code: 'E_INTERNAL',
+    })
   return r.stdout
 }
 
 function generate(root, name = 'change') {
   run(root, ['generate'])
-  if (existsSync(join(root, DIR))) return run(root, ['migrate', 'dev', '--create-only', '--name', name]).trim()
-  const sql = run(root, ['migrate', 'diff', '--from-empty', '--to-schema', 'prisma/schema.prisma', '--script'])
+  if (existsSync(join(root, DIR)))
+    return run(root, ['migrate', 'dev', '--create-only', '--name', name]).trim()
+  const sql = run(root, [
+    'migrate',
+    'diff',
+    '--from-empty',
+    '--to-schema',
+    'prisma/schema.prisma',
+    '--script',
+  ])
   const dir = join(root, DIR, '00000000000000_init')
   mkdirSync(dir, { recursive: true })
   writeFileSync(join(dir, 'migration.sql'), sql)
@@ -37,8 +51,17 @@ export const prisma = definePlugin({
   permissions: { fs: { read: ['prisma/**'], write: ['prisma/migrations/**'] }, spawn: ['node'] },
   contribute: () => ({
     db: { layer: 'prisma', schema: 'prisma/schema.prisma', migrations: DIR, generate },
-    agents: { title: 'Database (Prisma)', text: '`ctx.db` is the real Prisma client, so Prisma\'s docs apply. The schema is `prisma/schema.prisma`; after changing it, run `weft db generate <name>`, which updates the client and adds a migration that applies on the next request.' },
-    map: [{ want: 'Change the database', call: 'Edit `prisma/schema.prisma`, then `weft db generate <name>`', have: 'Prisma' }],
+    agents: {
+      title: 'Database (Prisma)',
+      text: "`ctx.db` is the real Prisma client, so Prisma's docs apply. The schema is `prisma/schema.prisma`; after changing it, run `weft db generate <name>`, which updates the client and adds a migration that applies on the next request.",
+    },
+    map: [
+      {
+        want: 'Change the database',
+        call: 'Edit `prisma/schema.prisma`, then `weft db generate <name>`',
+        have: 'Prisma',
+      },
+    ],
   }),
 })
 

package/plugins/prisma.mjs

@@ -9,8 +9,16 @@ export const prismaSource = definePlugin({
   weft: '*',
   permissions: { net: ['driver:prisma'] },
   contribute: () => ({
-    provides: [provide(slot, { key: 'prisma', sides: { server: { module: '@weft-js/db/prisma', export: 'adapter' } } })],
-    agents: { title: 'Lists (prisma)', text: 'Build a source once, in a server module, with `columns`: only those are selected, returned or written. Then `query({ input: listInput({ sort, filter, search }), run: ({ input }) => source.list(input) })`. warp `Table` reads what comes back.' },
+    provides: [
+      provide(slot, {
+        key: 'prisma',
+        sides: { server: { module: '@weft-js/db/prisma', export: 'adapter' } },
+      }),
+    ],
+    agents: {
+      title: 'Lists (prisma)',
+      text: 'Build a source once, in a server module, with `columns`: only those are selected, returned or written. Then `query({ input: listInput({ sort, filter, search }), run: ({ input }) => source.list(input) })`. warp `Table` reads what comes back.',
+    },
   }),
 })
 

package/plugins/sql.mjs

@@ -9,8 +9,16 @@ export const sqlSource = definePlugin({
   weft: '*',
   permissions: { net: ['driver:query'] },
   contribute: () => ({
-    provides: [provide(slot, { key: 'sql', sides: { server: { module: '@weft-js/db/sql', export: 'adapter' } } })],
-    agents: { title: 'Lists (sql)', text: 'Build a source once, in a server module, with `columns`: only those are selected, returned or written. Then `query({ input: listInput({ sort, filter, search }), run: ({ input }) => source.list(input) })`. warp `Table` reads what comes back.' },
+    provides: [
+      provide(slot, {
+        key: 'sql',
+        sides: { server: { module: '@weft-js/db/sql', export: 'adapter' } },
+      }),
+    ],
+    agents: {
+      title: 'Lists (sql)',
+      text: 'Build a source once, in a server module, with `columns`: only those are selected, returned or written. Then `query({ input: listInput({ sort, filter, search }), run: ({ input }) => source.list(input) })`. warp `Table` reads what comes back.',
+    },
   }),
 })
 

package/src/driver.ts

@@ -1,12 +1,15 @@
-// Each driver is an optional peer: nobody installs Prisma or Mongo to use SQLite. A subpath that needs one loads it here,
-// at the top of its own module, so a missing driver says what to install instead of failing somewhere in a bundle.
+// Optional peers load at the subpath so missing drivers report what to install.
 
 const MISSING = new Set(['ERR_MODULE_NOT_FOUND', 'MODULE_NOT_FOUND'])
 
 /** True when this failure is `pkg` itself not being there, not something inside it failing to load. */
 const isMissing = (error: unknown, pkg: string) => {
   const { code = '', message } = (error ?? {}) as { code?: string; message?: unknown }
-  return (MISSING.has(code) || /cannot find (module|package)|failed to (load|resolve)/i.test(String(message))) && String(message).includes(pkg)
+  return (
+    (MISSING.has(code) ||
+      /cannot find (module|package)|failed to (load|resolve)/i.test(String(message))) &&
+    String(message).includes(pkg)
+  )
 }
 
 /** `await driver('@weft-js/db/kysely', 'kysely', () => import('kysely'))`. The import stays literal so a bundler still sees it. */
@@ -14,7 +17,11 @@ export async function driver<T>(subpath: string, pkg: string, load: () => Promis
   try {
     return await load()
   } catch (error) {
-    if (isMissing(error, pkg)) throw new Error(`${subpath} needs the \`${pkg}\` driver, which isn't installed. Run: npm install ${pkg}`, { cause: error })
+    if (isMissing(error, pkg))
+      throw new Error(
+        `${subpath} needs the \`${pkg}\` driver, which isn't installed. Run: npm install ${pkg}`,
+        { cause: error },
+      )
     throw error
   }
 }

package/src/dynamodb.ts

@@ -1,19 +1,42 @@
 // A list source over a DynamoDB table, through a `DynamoDBDocumentClient`. DynamoDB has no offset and sorts only inside a
 // partition, so this is cursor mode only: a `Scan` by default, and a `Query` when `partition` and `sortKey` name an index.
 
-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'
 import { driver } from './driver'
 
-const { DeleteCommand, GetCommand, PutCommand, QueryCommand, ScanCommand, UpdateCommand } = await driver('@weft-js/db/dynamodb', '@aws-sdk/lib-dynamodb', () => import('@aws-sdk/lib-dynamodb'))
+const { DeleteCommand, GetCommand, PutCommand, QueryCommand, ScanCommand, UpdateCommand } =
+  await driver(
+    '@weft-js/db/dynamodb',
+    '@aws-sdk/lib-dynamodb',
+    () => import('@aws-sdk/lib-dynamodb'),
+  )
 
 type Item = Record<string, unknown>
 
 /** What a command answers, as far as a source reads it. */
-export interface DynamoReply { Item?: Item | undefined; Items?: Item[] | undefined; Attributes?: Item | undefined; LastEvaluatedKey?: Item | undefined }
+export interface DynamoReply {
+  Item?: Item | undefined
+  Items?: Item[] | undefined
+  Attributes?: Item | undefined
+  LastEvaluatedKey?: Item | undefined
+}
 
 /** A `DynamoDBDocumentClient`, or anything else that sends these commands, and the table to send them to. */
-export interface DynamoTarget { client: { send(command: object): Promise<DynamoReply> }; table: string }
+export interface DynamoTarget {
+  client: { send(command: object): Promise<DynamoReply> }
+  table: string
+}
 
 /** A source's allowlist, and the index that lets a list sort. */
 export interface DynamoSpec extends SourceSpec {
@@ -27,62 +50,134 @@ export interface DynamoSpec extends SourceSpec {
 const CONDITION = 'ConditionalCheckFailedException'
 const PAGE = 1 << 12
 
+type DynamoList<Row> = {
+  client: DynamoTarget['client']
+  table: string
+  spec: DynamoSpec
+  idColumn: string
+  sortColumn: string | undefined
+  projection: string
+  names: Record<string, string>
+  reading: (row: object) => Row
+  idField: string
+}
+
+async function listRows<Row>(p: ListParams, context: DynamoList<Row>) {
+  const { client, table, spec, idColumn, sortColumn, projection, names, reading, idField } = context
+  if (p.mode === 'page')
+    throw new StartError('Q002', 'DynamoDB has no offset', "ask for `mode: 'cursor'`")
+  const q = plan(spec, p)
+  if (q.sort && q.sort.field !== spec.sortKey)
+    throw new StartError(
+      'Q002',
+      `DynamoDB can sort only on the index's key, not \`${q.sort.field}\``,
+      'set `sortKey`',
+    )
+  const values: Record<string, unknown> = {},
+    ExpressionAttributeNames: Record<string, string> = { ...names }
+  let n = 0
+  const value = (v: unknown) => {
+    const k = `:v${n++}`
+    values[k] = v
+    return k
+  }
+  const name = (c: string) => {
+    const k = `#n${n++}`
+    ExpressionAttributeNames[k] = c
+    return k
+  }
+  const parts = q.where.map((w) => {
+    const col = name(w.column)
+    return `(${w.values.map((v) => (v === null ? `attribute_not_exists(${col})` : `${col} = ${value(v)}`)).join(' or ')})`
+  })
+  if (q.search) {
+    const v = value(q.search.text)
+    parts.push(`(${q.search.columns.map((c) => `contains(${name(c)}, ${v})`).join(' or ')})`)
+  }
+  const query = spec.partition && sortColumn
+  const KeyConditionExpression = query
+    ? `${name(spec.partition!.column)} = ${value(spec.partition!.value)}`
+    : undefined
+  const start = p.after
+    ? {
+        [idColumn]: p.after[1],
+        ...(query
+          ? { [spec.partition!.column]: spec.partition!.value, [sortColumn]: p.after[0] }
+          : {}),
+      }
+    : undefined
+  const rows: Item[] = []
+  let ExclusiveStartKey: Item | undefined = start
+  // `Limit` counts what's read before the filter, so a page can take several trips.
+  do {
+    const input = {
+      TableName: table,
+      ProjectionExpression: projection,
+      ExpressionAttributeNames,
+      ...(Object.keys(values).length ? { ExpressionAttributeValues: values } : {}),
+      ...(parts.length ? { FilterExpression: parts.join(' and ') } : {}),
+      ...(ExclusiveStartKey ? { ExclusiveStartKey } : {}),
+      Limit: PAGE,
+    }
+    const r: DynamoReply = await client.send(
+      query
+        ? new QueryCommand({
+            ...input,
+            IndexName: spec.index,
+            KeyConditionExpression,
+            ScanIndexForward: q.sort?.dir !== 'desc',
+          })
+        : new ScanCommand(input),
+    )
+    rows.push(...(r.Items ?? []))
+    ExclusiveStartKey = r.LastEvaluatedKey
+  } while (ExclusiveStartKey && rows.length <= p.limit)
+  return pageOf(rows.slice(0, p.limit + 1).map(reading), p, {
+    sort: q.sort?.field ?? spec.sortKey,
+    id: idField,
+  })
+}
+
 /** A `ListSource` over one table, in cursor mode. */
-export function dynamoSource<Row = Record<string, unknown>>({ client, table }: DynamoTarget, spec: DynamoSpec): ListSource<Row> {
+export function dynamoSource<Row = Record<string, unknown>>(
+  { client, table }: DynamoTarget,
+  spec: DynamoSpec,
+): ListSource<Row> {
   const reading = rowOf<Row>(spec)
-  const idField = spec.id ?? 'id', idColumn = storedId(spec)
+  const idField = spec.id ?? 'id',
+    idColumn = storedId(spec)
   const key = (id: unknown) => ({ [idColumn]: id })
   const sortColumn = spec.sortKey && spec.columns[spec.sortKey]
   const stored = Object.values(spec.columns)
   const projection = stored.map((_, i) => `#c${i}`).join(', ')
   const names = Object.fromEntries(stored.map((c, i) => [`#c${i}`, c]))
   const byId = async (id: unknown) => {
-    const r = await client.send(new GetCommand({ TableName: table, Key: key(id), ConsistentRead: true }))
+    const r = await client.send(
+      new GetCommand({ TableName: table, Key: key(id), ConsistentRead: true }),
+    )
     return r.Item ? reading(r.Item) : null
   }
   return {
     limits: { page: false, search: 'cased', sort: spec.sortKey ? [spec.sortKey] : [] },
-    async list(p: ListParams) {
-      if (p.mode === 'page') throw new StartError('Q002', 'DynamoDB has no offset', 'ask for `mode: \'cursor\'`')
-      const q = plan(spec, p)
-      if (q.sort && q.sort.field !== spec.sortKey) throw new StartError('Q002', `DynamoDB can sort only on the index's key, not \`${q.sort.field}\``, 'set `sortKey`')
-      const values: Record<string, unknown> = {}, ExpressionAttributeNames: Record<string, string> = { ...names }
-      let n = 0
-      const value = (v: unknown) => { const k = `:v${n++}`; values[k] = v; return k }
-      const name = (c: string) => { const k = `#n${n++}`; ExpressionAttributeNames[k] = c; return k }
-      const parts = q.where.map(w => {
-        const col = name(w.column)
-        return `(${w.values.map(v => (v === null ? `attribute_not_exists(${col})` : `${col} = ${value(v)}`)).join(' or ')})`
+    list(p: ListParams) {
+      return listRows(p, {
+        client,
+        table,
+        spec,
+        idColumn,
+        sortColumn,
+        projection,
+        names,
+        reading,
+        idField,
       })
-      if (q.search) {
-        const v = value(q.search.text)
-        parts.push(`(${q.search.columns.map(c => `contains(${name(c)}, ${v})`).join(' or ')})`)
-      }
-      const query = spec.partition && sortColumn
-      const KeyConditionExpression = query ? `${name(spec.partition!.column)} = ${value(spec.partition!.value)}` : undefined
-      const start = p.after ? { [idColumn]: p.after[1], ...(query ? { [spec.partition!.column]: spec.partition!.value, [sortColumn]: p.after[0] } : {}) } : undefined
-      const rows: Item[] = []
-      let ExclusiveStartKey: Item | undefined = start
-      // `Limit` counts what's read before the filter, so a page can take several trips.
-      do {
-        const input = {
-          TableName: table,
-          ProjectionExpression: projection,
-          ExpressionAttributeNames,
-          ...(Object.keys(values).length ? { ExpressionAttributeValues: values } : {}),
-          ...(parts.length ? { FilterExpression: parts.join(' and ') } : {}),
-          ...(ExclusiveStartKey ? { ExclusiveStartKey } : {}),
-          Limit: PAGE,
-        }
-        const r: DynamoReply = await client.send(query ? new QueryCommand({ ...input, IndexName: spec.index, KeyConditionExpression, ScanIndexForward: q.sort?.dir !== 'desc' }) : new ScanCommand(input))
-        rows.push(...(r.Items ?? []))
-        ExclusiveStartKey = r.LastEvaluatedKey
-      } while (ExclusiveStartKey && rows.length <= p.limit)
-      return pageOf(rows.slice(0, p.limit + 1).map(reading), p, { sort: q.sort?.field ?? spec.sortKey, id: idField })
     },
     get: byId,
     async create(data) {
-      const Item = { ...written(spec, data, true), ...(spec.partition ? { [spec.partition.column]: spec.partition.value } : {}) }
+      const Item = {
+        ...written(spec, data, true),
+        ...(spec.partition ? { [spec.partition.column]: spec.partition.value } : {}),
+      }
       await client.send(new PutCommand({ TableName: table, Item }))
       return reading(Item)
     },
@@ -90,10 +185,24 @@ export function dynamoSource<Row = Record<string, unknown>>({ client, table }: D
       const row = written(spec, patch)
       const keys = Object.keys(row)
       if (!keys.length) return byId(id)
-      const ExpressionAttributeNames: Record<string, string> = { '#id': idColumn }, ExpressionAttributeValues: Record<string, unknown> = {}
-      keys.forEach((k, i) => { ExpressionAttributeNames[`#k${i}`] = k; ExpressionAttributeValues[`:k${i}`] = row[k] })
+      const ExpressionAttributeNames: Record<string, string> = { '#id': idColumn },
+        ExpressionAttributeValues: Record<string, unknown> = {}
+      keys.forEach((k, i) => {
+        ExpressionAttributeNames[`#k${i}`] = k
+        ExpressionAttributeValues[`:k${i}`] = row[k]
+      })
       try {
-        const r = await client.send(new UpdateCommand({ TableName: table, Key: key(id), ConditionExpression: 'attribute_exists(#id)', UpdateExpression: `set ${keys.map((_, i) => `#k${i} = :k${i}`).join(', ')}`, ExpressionAttributeNames, ExpressionAttributeValues, ReturnValues: 'ALL_NEW' }))
+        const r = await client.send(
+          new UpdateCommand({
+            TableName: table,
+            Key: key(id),
+            ConditionExpression: 'attribute_exists(#id)',
+            UpdateExpression: `set ${keys.map((_, i) => `#k${i} = :k${i}`).join(', ')}`,
+            ExpressionAttributeNames,
+            ExpressionAttributeValues,
+            ReturnValues: 'ALL_NEW',
+          }),
+        )
         return reading(r.Attributes!)
       } catch (e) {
         if ((e as { name?: string } | null)?.name === CONDITION) return null
@@ -101,10 +210,17 @@ export function dynamoSource<Row = Record<string, unknown>>({ client, table }: D
       }
     },
     async remove(id) {
-      return !!(await client.send(new DeleteCommand({ TableName: table, Key: key(id), ReturnValues: 'ALL_OLD' }))).Attributes
+      return !!(
+        await client.send(
+          new DeleteCommand({ TableName: table, Key: key(id), ReturnValues: 'ALL_OLD' }),
+        )
+      ).Attributes
     },
   }
 }
 
 /** `db.adapter@1` over a DynamoDB table. */
-export const adapter: DbAdapter<DynamoTarget> = { name: 'dynamodb', source: (t, spec) => dynamoSource(t, spec as DynamoSpec) }
+export const adapter: DbAdapter<DynamoTarget> = {
+  name: 'dynamodb',
+  source: (t, spec) => dynamoSource(t, spec as DynamoSpec),
+}