@weft-js/db 0.1.1 → 0.1.2

package/src/native/index.ts

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

package/src/native/mysql.ts

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

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),
+}