@weft-js/db 0.0.0-stage → 0.1.1

package/src/prisma.ts

@@ -0,0 +1,62 @@
+// 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'
+
+/** What a generated client's model has, whatever its schema. */
+export interface PrismaDelegate {
+  findMany(args: unknown): Promise<object[]>
+  findUnique(args: unknown): Promise<object | null>
+  count(args: unknown): Promise<number>
+  create(args: unknown): Promise<object>
+  update(args: unknown): Promise<object>
+  delete(args: unknown): Promise<object>
+}
+
+/** A source's allowlist, and how `search` compares. */
+export interface PrismaSpec extends SourceSpec {
+  /** `mode: 'insensitive'` on `contains`, which Postgres and Mongo have. SQLite and MySQL compare without case already. Default true. */
+  insensitive?: boolean
+}
+
+const MISSING = 'P2025'
+
+/** 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]))
+  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 }
+  // 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 }))
+    },
+    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),
+  }
+}
+
+/** `db.adapter@1` over a Prisma model. */
+export const adapter: DbAdapter<PrismaDelegate> = { name: 'prisma', source: (t, spec) => prismaSource(t, spec) }

package/src/sql.ts

@@ -0,0 +1,118 @@
+// 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 { StartError } from '@weft-js/start/data'
+
+/** Whatever runs a bound statement, and says which dialect it speaks. */
+export interface SqlTarget {
+  query(text: string, params: unknown[]): Promise<Record<string, unknown>[]>
+  dialect?: 'postgresql' | 'sqlite' | 'mysql'
+  $weft?: { dialect: 'postgresql' | 'sqlite' | 'mysql' }
+}
+
+/** A source's allowlist, and the table it covers. */
+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')
+    return `${q}${name}${q}`
+  }
+}
+
+/** A `ListSource` over one table, as bound SQL. */
+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)
+  const table = q(spec.table)
+  const select = Object.values(spec.columns).map(q).join(', ')
+  const reading = rowOf<Row>(spec)
+  const idColumn = q(storedId(spec))
+  const bind = (params: unknown[]) => (v: unknown) => {
+    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) }
+  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)
+    },
+    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)
+      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])}`)
+      if (!(await byId(id))) return null
+      if (sets.length) await target.query(`update ${table} set ${sets.join(', ')} where ${idColumn} = ${put(id)}`, params)
+      return byId(id)
+    },
+    async remove(id) {
+      if (!(await byId(id))) return false
+      const params: unknown[] = []
+      await target.query(`delete from ${table} where ${idColumn} = ${bind(params)(id)}`, params)
+      return true
+    },
+  }
+}
+
+/** `db.adapter@1` over bound SQL. */
+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 {
+  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}`
+  return `create or replace function ${q(fn)}() returns trigger language plpgsql as $$
+declare row_id text;
+begin
+  if tg_op = 'DELETE' then row_id := old.${q(id)}::text; else row_id := new.${q(id)}::text; end if;
+  perform pg_notify('weft_bus', '=weft:poke' || chr(10) || json_build_object('t', json_build_array('${tag}', '${tag}:' || row_id))::text);
+  return null;
+end $$;
+drop trigger if exists ${q(fn)} on ${q(table)};
+create trigger ${q(fn)} after insert or update or delete on ${q(table)} for each row execute function ${q(fn)}();
+`
+}