qubu 0.3.5 → 0.4.1

package/dist/vite.d.mts

@@ -1,9 +1,8 @@
 //#region src/vite/globals.d.ts
 /**
- * Public runtime names that the `"use qubu"` transform can auto-import.
- * Keep this catalog aligned with the ordinary authoring surface of `qubu`;
- * fragment internals, dialect construction, and schema extensions belong to
- * the layered entrypoints.
+ * Public runtime names that the `"use qubu"` transform can auto-import. Keep this catalog aligned
+ * with the ordinary authoring surface of `qubu`; fragment internals, dialect construction, and
+ * schema extensions belong to the layered entrypoints.
  */
 declare const qubuGlobals: readonly ["add", "alias", "all", "allowAll", "and", "asc", "asValue", "avg", "bigint", "between", "binary", "boolean", "call", "caseWhen", "cast", "check", "coalesce", "column", "concat", "count", "countDistinct", "correlate", "crossJoin", "cte", "date", "denseRank", "defaultValues", "deleteFrom", "desc", "distinct", "divide", "eq", "except", "execute", "executeRows", "externalDefault", "externalGeneratedColumn", "exists", "fetchFirst", "fetchNext", "foreignKey", "from", "fullJoin", "generatedColumn", "gt", "gte", "groupBy", "having", "identityColumn", "inList", "inQuery", "index", "innerJoin", "insertInto", "insertSelect", "integer", "intersect", "isDistinctFrom", "isNotDistinctFrom", "isNotNull", "isNull", "isTrue", "json", "jsonBoolean", "jsonExists", "jsonNumber", "jsonPath", "jsonText", "lateral", "leftJoin", "like", "lower", "lt", "lte", "max", "min", "modulo", "multiply", "naturalJoin", "nativeColumn", "nativeStorage", "ne", "not", "notExists", "notIn", "notLike", "nullsFirst", "nullsLast", "numeric", "nullable", "offset", "omit", "or", "order", "orderBy", "over", "portableStorage", "primaryKey", "qubu", "references", "recursiveCte", "render", "returning", "rightJoin", "rank", "rowNumber", "scalar", "schema", "schemaCall", "select", "sql", "stream", "subtract", "sum", "table", "text", "timestamp", "union", "unionAll", "unique", "uniqueConstraint", "update", "upper", "value", "values", "where", "withCte", "uuid"];
 type QubuGlobal = (typeof qubuGlobals)[number];
@@ -25,8 +24,8 @@ interface QubuViteTransformResult {
 }
 /** A Vite-compatible plugin without a runtime dependency on Vite itself. */
 interface QubuVitePlugin {
-  readonly name: 'qubu:compiler-hint';
-  readonly enforce: 'pre';
+  readonly name: "qubu:compiler-hint";
+  readonly enforce: "pre";
   transform(code: string, id: string): QubuViteTransformResult | null;
 }
 declare function qubu(options?: QubuVitePluginOptions): QubuVitePlugin;

package/dist/vite.mjs

@@ -70,10 +70,9 @@ function isWhitespace$1(character) {
 //#endregion
 //#region src/vite/globals.ts
 /**
-* Public runtime names that the `"use qubu"` transform can auto-import.
-* Keep this catalog aligned with the ordinary authoring surface of `qubu`;
-* fragment internals, dialect construction, and schema extensions belong to
-* the layered entrypoints.
+* Public runtime names that the `"use qubu"` transform can auto-import. Keep this catalog aligned
+* with the ordinary authoring surface of `qubu`; fragment internals, dialect construction, and
+* schema extensions belong to the layered entrypoints.
 */
 const qubuGlobals = [
 	"add",

package/docs/dialects-and-execution.md

@@ -20,8 +20,8 @@ Construct the query without choosing a driver, then render it with the policy
 the adapter expects:
 
 ```ts
-import { render } from 'qubu'
-import { postgresDialect } from 'qubu/postgres'
+import { render } from "qubu"
+import { postgresDialect } from "qubu/postgres"
 
 const standard = render(query)
 const postgres = render(query, postgresDialect())
@@ -40,15 +40,11 @@ capability requirement to the rendering boundary. PostgreSQL's `ilike()` is
 the first such feature:
 
 ```ts
-import { from, like, render, select, where } from 'qubu'
-import { ilike, postgresDialect } from 'qubu/postgres'
-import { sqliteDialect } from 'qubu/sqlite'
+import { from, like, render, select, where } from "qubu"
+import { ilike, postgresDialect } from "qubu/postgres"
+import { sqliteDialect } from "qubu/sqlite"
 
-const postgresQuery = select(
-  { name: users.name },
-  from(users),
-  where(ilike(users.name, '%ada%'))
-)
+const postgresQuery = select({ name: users.name }, from(users), where(ilike(users.name, "%ada%")))
 
 render(postgresQuery, postgresDialect()) // supported
 render(postgresQuery, sqliteDialect()) // TypeScript error
@@ -59,14 +55,10 @@ received from an untyped integration. Use the portable operator when the
 query must render across dialects:
 
 ```ts
-import { from, like, render, select, where } from 'qubu'
-import { sqliteDialect } from 'qubu/sqlite'
+import { from, like, render, select, where } from "qubu"
+import { sqliteDialect } from "qubu/sqlite"
 
-const portableQuery = select(
-  { name: users.name },
-  from(users),
-  where(like(users.name, '%ada%'))
-)
+const portableQuery = select({ name: users.name }, from(users), where(like(users.name, "%ada%")))
 
 render(portableQuery)
 render(portableQuery, sqliteDialect())
@@ -81,45 +73,94 @@ does not re-export concrete dialect constructors.
 
 ## The adapter owns the driver
 
-Qubu does not open connections, bind values for a particular client, or decode
-rows. An adapter receives an `ExecutionRequest` and returns an
-`ExecutionResult`. A `TransactionalQueryAdapter` can also pin one driver
-connection for a callback transaction:
+Qubu does not open connections or bind values for a particular client. An
+adapter receives an `ExecutionRequest` and returns driver-normalized object
+rows. Qubu then uses the query's result shape and the adapter's decoder policy
+to produce the typed `ExecutionResult`. A `TransactionalQueryAdapter` can also
+pin one driver connection for a callback transaction:
 
 ```ts
-import { qubu } from 'qubu'
-import { postgresDialect } from 'qubu/postgres'
-import type { ExecutionRequest, ExecutionResult, QueryAdapter } from 'qubu'
+import { qubu } from "qubu"
+import { postgresDialect } from "qubu/postgres"
+import type { ExecutionRequest, QueryAdapter } from "qubu"
 
 declare const driver: {
   query<TRow extends object>(
     text: string,
     parameters: readonly unknown[],
-    options: { signal?: AbortSignal }
+    options: { signal?: AbortSignal },
   ): Promise<{ rows: readonly TRow[]; rowCount: number | null }>
 }
 
 const adapter: QueryAdapter = {
   dialect: postgresDialect(),
-  async execute<TRow extends object>(request: ExecutionRequest) {
+  async execute(request: ExecutionRequest) {
     const { statement, queryKind, signal } = request
-    const result = await driver.query<TRow>(
+    const result = await driver.query<Record<string, unknown>>(
       statement.text,
       statement.parameters,
-      { signal }
+      { signal },
     )
     return {
       rows: result.rows,
-      ...(queryKind !== 'select' &&
-      queryKind !== 'set' &&
-      result.rowCount !== null
+      ...(queryKind !== "select" && queryKind !== "set" && result.rowCount !== null
         ? { affectedRows: result.rowCount }
         : {}),
-    } satisfies ExecutionResult<TRow>
+    }
   },
 }
 ```
 
+### Decode schema-aware result values
+
+Portable boolean, date, timestamp, and JSON columns retain their logical
+result domains through projection aliases, derived queries, CTEs, set
+operations, and mutation `RETURNING`. Register only the conversions required
+by the selected driver configuration:
+
+```ts
+import {
+  booleanResultDecoder,
+  dateResultDecoder,
+  jsonTextResultDecoder,
+  timestampResultDecoder,
+} from "qubu"
+import type { AdapterExecutionResult, QueryAdapter, RenderedQuery } from "qubu"
+import { sqliteDialect } from "qubu/sqlite"
+
+declare const sqliteDriver: {
+  execute(statement: RenderedQuery): Promise<AdapterExecutionResult>
+}
+
+const adapter: QueryAdapter = {
+  dialect: sqliteDialect(),
+  decoders: {
+    boolean: booleanResultDecoder,
+    date: dateResultDecoder,
+    timestamp: timestampResultDecoder,
+    json: jsonTextResultDecoder,
+  },
+  async execute(request) {
+    return sqliteDriver.execute(request.statement)
+  },
+}
+```
+
+Do not register `jsonTextResultDecoder` when the driver already returns parsed
+JSON. A JSON string is otherwise ambiguous: it may be serialized JSON or an
+already-decoded JSON string scalar. With no registered decoder, Qubu preserves
+the driver's value.
+
+Use a column decoder for a custom stored type, or `mapResult()` for one
+expression. Both override adapter policy for that field:
+
+```ts
+import { column, mapResult, value } from "qubu"
+
+const score = column<number>({ decode: (value) => Number(value) })
+const decodedTotal = mapResult(value("42"), (value) => Number(value))
+```
+
 ## Stream read results
 
 Add `StreamingQueryAdapter` when a driver can return rows through an
@@ -129,45 +170,41 @@ Mutations stay on `execute()` and `executeRows()`, including mutations with
 `RETURNING`.
 
 ```ts
-import { qubu } from 'qubu'
-import type {
-  ExecutionRequest,
-  ExecutionResult,
-  StreamingQueryAdapter,
-} from 'qubu'
-import { postgresDialect } from 'qubu/postgres'
+import { qubu } from "qubu"
+import type { ExecutionRequest, StreamingQueryAdapter } from "qubu"
+import { postgresDialect } from "qubu/postgres"
 
 declare const driver: {
   query<TRow extends object>(
     text: string,
     parameters: readonly unknown[],
-    options: { signal?: AbortSignal }
+    options: { signal?: AbortSignal },
   ): Promise<{ rows: readonly TRow[]; rowCount: number | null }>
   stream<TRow extends object>(
     text: string,
     parameters: readonly unknown[],
-    options: { signal?: AbortSignal }
+    options: { signal?: AbortSignal },
   ): AsyncIterable<TRow>
 }
 
 const adapter: StreamingQueryAdapter = {
   dialect: postgresDialect(),
-  async execute<TRow extends object>(request: ExecutionRequest) {
-    const result = await driver.query<TRow>(
+  async execute(request: ExecutionRequest) {
+    const result = await driver.query<Record<string, unknown>>(
       request.statement.text,
       request.statement.parameters,
-      { signal: request.signal }
+      { signal: request.signal },
     )
     return {
       rows: result.rows,
       ...(result.rowCount === null ? {} : { affectedRows: result.rowCount }),
-    } satisfies ExecutionResult<TRow>
+    }
   },
-  stream<TRow extends object>(request: ExecutionRequest) {
-    return driver.stream<TRow>(
+  stream(request: ExecutionRequest) {
+    return driver.stream<Record<string, unknown>>(
       request.statement.text,
       request.statement.parameters,
-      { signal: request.signal }
+      { signal: request.signal },
     )
   },
 }
@@ -178,11 +215,11 @@ for await (const row of db.stream(readQuery)) {
 }
 ```
 
-Qubu renders the query before calling `stream()` and passes the selected
-dialect, ordered raw parameters, query kind, and optional `AbortSignal` in the
-same `ExecutionRequest` used by `execute()`. The adapter binds values, decodes
-rows, and returns the iterable. Qubu does not open a cursor or connection,
-iterate the result, buffer rows, or impose a fetch size.
+Qubu renders the query with the selected dialect before calling `stream()`. It
+passes ordered raw parameters, query kind, result shape, and the optional
+`AbortSignal` in the same `ExecutionRequest` used by `execute()`. The adapter
+binds values and returns the iterable. Qubu lazily decodes each row without
+opening a cursor or connection, buffering rows, or imposing a fetch size.
 
 The adapter owns the iterator's cleanup contract:
 
@@ -212,10 +249,10 @@ transaction callback receives a streaming client. The adapter must keep its
 cursor and connection valid until the callback's streams finish or close:
 
 ```ts
-declare const transactionalAdapter: import('qubu').StreamingTransactionalQueryAdapter
+declare const transactionalAdapter: import("qubu").StreamingTransactionalQueryAdapter
 const transactionalDb = qubu(transactionalAdapter)
 
-await transactionalDb.transaction(async transaction => {
+await transactionalDb.transaction(async (transaction) => {
   for await (const row of transaction.stream(readQuery)) {
     consume(row)
   }
@@ -234,17 +271,17 @@ standalone `explain()` function and the bound `db.explain()` method render a
 plan request without calling `execute()`:
 
 ```ts
-import { explain, qubu } from 'qubu'
-import type { ExplainableQueryAdapter } from 'qubu'
-import { postgresDialect } from 'qubu/postgres'
+import { explain, qubu } from "qubu"
+import type { ExplainableQueryAdapter } from "qubu"
+import { postgresDialect } from "qubu/postgres"
 
-type PostgresPlanRow = { 'QUERY PLAN': string }
+type PostgresPlanRow = { "QUERY PLAN": string }
 
 declare const driver: {
   query<TRow extends object>(
     text: string,
     parameters: readonly unknown[],
-    options: { signal?: AbortSignal }
+    options: { signal?: AbortSignal },
   ): Promise<{ rows: readonly TRow[] }>
 }
 
@@ -257,7 +294,7 @@ const adapter: ExplainableQueryAdapter<PostgresPlanRow> = {
     const result = await driver.query<PostgresPlanRow>(
       request.statement.text,
       request.statement.parameters,
-      { signal: request.signal }
+      { signal: request.signal },
     )
     return { rows: result.rows }
   },
@@ -322,13 +359,13 @@ Use a transactional adapter when several queries must share one commit or
 rollback boundary:
 
 ```ts
-import { qubu } from 'qubu'
-import type { TransactionalQueryAdapter } from 'qubu'
+import { qubu } from "qubu"
+import type { TransactionalQueryAdapter } from "qubu"
 
 declare const transactionalAdapter: TransactionalQueryAdapter
 const transactionalDb = qubu(transactionalAdapter)
 
-const result = await transactionalDb.transaction(async transaction => {
+const result = await transactionalDb.transaction(async (transaction) => {
   await transaction.execute(firstMutation)
   await transaction.execute(secondMutation)
   return transaction.rows(readQuery)
@@ -353,18 +390,18 @@ The standalone functions remain useful when the adapter varies by call or a
 small module does not need a bound client:
 
 ```ts
-import { execute, executeRows } from 'qubu'
+import { execute, executeRows } from "qubu"
 
 const result = await execute(query, adapter)
 const rows = await executeRows(readQuery, adapter)
 ```
 
-| Result field   | Type                         | Adapter contract                                                                      |
-| -------------- | ---------------------------- | ------------------------------------------------------------------------------------- |
-| `rows`         | `readonly TRow[]`            | Always present; use an empty array for a mutation without returned rows               |
-| `affectedRows` | `number \| bigint`           | Rows inserted, updated, or deleted when the driver reports an affected count          |
-| `changedRows`  | `number \| bigint`           | Rows whose stored values changed when the driver distinguishes them from matched rows |
-| `insertId`     | `string \| number \| bigint` | One insert identifier when the driver reports it                                      |
+| Result field   | Adapter type                         | Contract                                                                              |
+| -------------- | ------------------------------------ | ------------------------------------------------------------------------------------- |
+| `rows`         | `readonly Record<string, unknown>[]` | Key by rendered aliases; Qubu returns the decoded `readonly TRow[]`                   |
+| `affectedRows` | `number \| bigint`                   | Rows inserted, updated, or deleted when the driver reports an affected count          |
+| `changedRows`  | `number \| bigint`                   | Rows whose stored values changed when the driver distinguishes them from matched rows |
+| `insertId`     | `string \| number \| bigint`         | One insert identifier when the driver reports it                                      |
 
 The last three fields are optional. For example, an adapter can map PostgreSQL
 `rowCount`, MySQL `affectedRows`, `changedRows`, and `insertId`, or SQLite
@@ -373,9 +410,11 @@ report accurately. Qubu does not derive mutation metadata from returned rows.
 
 The adapter's `dialect` becomes the default for standalone and bound execution.
 A `dialect` in the execution options overrides that rendering policy. Qubu
-passes `signal` and the query's `queryKind` to the adapter without changing
+passes `signal`, `queryKind`, and `resultShape` to the adapter without changing
 them. The adapter decides whether and how its driver supports cancellation.
-Driver errors pass through unchanged.
+Driver errors pass through unchanged. Decoder failures become a
+`ResultDecodingError` that identifies the row and field without exposing the
+raw value.
 
 ```mermaid
 sequenceDiagram
@@ -386,11 +425,12 @@ sequenceDiagram
 
   App->>Qubu: db.execute(query, options)
   Qubu->>Qubu: render with selected dialect
-  Qubu->>Adapter: statement + queryKind + signal
+  Qubu->>Adapter: statement + queryKind + resultShape + signal
   Adapter->>Driver: bind and execute
   Driver-->>Adapter: driver result or error
-  Adapter-->>Qubu: typed rows + optional mutation facts
-  Qubu-->>App: result envelope or rows
+  Adapter-->>Qubu: normalized object rows + optional mutation facts
+  Qubu->>Qubu: apply field and adapter decoders
+  Qubu-->>App: typed result envelope or rows
 ```
 
 ## Create a small custom dialect
@@ -399,13 +439,13 @@ Use `createDialect()` when a driver needs a different policy but the query
 syntax stays portable:
 
 ```ts
-import { render } from 'qubu'
-import { createDialect } from 'qubu/core'
+import { render } from "qubu"
+import { createDialect } from "qubu/core"
 
 const namedParameters = createDialect({
-  name: 'named-parameters',
-  placeholder: position => `:p${position}`,
-  castTypes: { text: 'STRING' },
+  name: "named-parameters",
+  placeholder: (position) => `:p${position}`,
+  castTypes: { text: "STRING" },
 })
 
 const statement = render(query, namedParameters)

package/docs/getting-started.md

@@ -24,9 +24,9 @@ Use `table()` once for each query-facing table. Column helpers describe the
 application values that can be selected and, for mutations, written.
 
 ```ts
-import { integer, table, text } from 'qubu'
+import { integer, table, text } from "qubu"
 
-const users = table('users', {
+const users = table("users", {
   id: integer(),
   name: text(),
   email: text({ nullable: true }),
@@ -44,7 +44,7 @@ it, then renders the normalized statement in SQL order. The example uses the
 `users` table from the previous section.
 
 ```ts
-import { eq, from, render, select, where } from 'qubu'
+import { eq, from, render, select, where } from "qubu"
 
 const query = select(
   {
@@ -52,7 +52,7 @@ const query = select(
     displayName: users.name,
   },
   from(users),
-  where(eq(users.id, 7))
+  where(eq(users.id, 7)),
 )
 
 const statement = render(query)

package/docs/guides/better-auth.md

@@ -0,0 +1,57 @@
+# Better Auth
+
+> Derive Qubu-owned auth tables and run Better Auth through a transactional Qubu client.
+
+Install the integration next to Qubu and Better Auth:
+
+```sh
+pnpm add qubu @qubu/better-auth better-auth
+```
+
+Define the Better Auth options once. The schema derivation reads Better Auth's
+resolved public metadata, so core tables, renamed models and fields, additional
+fields, plugin tables, references, unique constraints, and compound indexes all
+participate.
+
+```ts
+import { betterAuth } from "better-auth"
+import type { BetterAuthOptions } from "better-auth/types"
+import { twoFactor } from "better-auth/plugins"
+import { betterAuthSchema, qubuAdapter } from "@qubu/better-auth"
+import { qubu } from "qubu"
+import { pgAdapter } from "@qubu/adapter-pg"
+
+const options = {
+  user: {
+    modelName: "auth_users",
+    additionalFields: {
+      locale: { type: "string", required: false },
+    },
+  },
+  plugins: [twoFactor()],
+} satisfies BetterAuthOptions
+
+const authSchema = betterAuthSchema(options, "postgresql")
+const db = qubu(pgAdapter(pool))
+
+export const auth = betterAuth({
+  ...options,
+  database: qubuAdapter(db, { schema: authSchema }),
+})
+```
+
+`authSchema` is an ordinary Qubu `Schema`. Hand it to Qubu snapshot, diff,
+migration-plan, and DDL workflows. The adapter's Better Auth `createSchema`
+hook emits a TypeScript module that reconstructs the same Qubu-owned metadata.
+
+The package never imports PostgreSQL, MySQL, or SQLite drivers. It executes
+through Qubu's query and transaction boundaries. PostgreSQL and SQLite use one
+limited mutation statement for atomic consume and guarded increment operations;
+MySQL locks one selected row inside the Qubu-owned transaction. A client without
+transaction support, or a dialect other than PostgreSQL, MySQL, or SQLite, is
+rejected during adapter construction.
+
+Better Auth enum metadata is currently rejected because Qubu cannot preserve
+the closed value set as a portable column without adding a database constraint.
+The error includes the model and field path instead of silently widening it to
+text.

package/docs/guides/compose-queries.md

@@ -8,37 +8,19 @@
 Attach it with `withCte()` and use the CTE source in `from()`:
 
 ```ts
-import {
-  cte,
-  eq,
-  from,
-  integer,
-  select,
-  table,
-  text,
-  where,
-  withCte,
-} from 'qubu'
-
-const users = table('users', {
+import { cte, eq, from, integer, select, table, text, where, withCte } from "qubu"
+
+const users = table("users", {
   id: integer(),
   name: text(),
 })
 
 const activeUsers = cte(
-  'active_users',
-  select(
-    { id: users.id, name: users.name },
-    from(users),
-    where(eq(users.id, 7))
-  )
+  "active_users",
+  select({ id: users.id, name: users.name }, from(users), where(eq(users.id, 7))),
 )
 
-const report = select(
-  { displayName: activeUsers.name },
-  withCte(activeUsers),
-  from(activeUsers)
-)
+const report = select({ displayName: activeUsers.name }, withCte(activeUsers), from(activeUsers))
 ```
 
 `activeUsers.name` is a typed column derived from the first query's row shape.
@@ -53,24 +35,10 @@ member. The callback receives a typed self-reference; introduce it through
 `from()` or a join before selecting its fields:
 
 ```ts
-import {
-  add,
-  cast,
-  from,
-  integer,
-  lt,
-  recursiveCte,
-  select,
-  value,
-  where,
-  withCte,
-} from 'qubu'
-
-const numbers = recursiveCte(
-  'numbers',
-  select({ value: cast(value(1), integer()) }),
-  self =>
-    select({ value: add(self.value, 1) }, from(self), where(lt(self.value, 3)))
+import { add, cast, from, integer, lt, recursiveCte, select, value, where, withCte } from "qubu"
+
+const numbers = recursiveCte("numbers", select({ value: cast(value(1), integer()) }), (self) =>
+  select({ value: add(self.value, 1) }, from(self), where(lt(self.value, 3))),
 )
 
 const query = select({ value: numbers.value }, withCte(numbers), from(numbers))
@@ -89,11 +57,11 @@ recursive CTEs can share one `withCte()` clause.
 Alias a query when it should be used as an inline source:
 
 ```ts
-import { alias, from, lower, select } from 'qubu'
-import type { SqlTypeOf } from 'qubu'
+import { alias, from, lower, select } from "qubu"
+import type { SqlTypeOf } from "qubu"
 
 const names = select({ name: lower(users.name) }, from(users))
-const namesSource = alias(names, 'names')
+const namesSource = alias(names, "names")
 
 const query = select({ name: namesSource.name }, from(namesSource))
 type NameSqlDomain = SqlTypeOf<typeof namesSource.name>
@@ -112,7 +80,7 @@ so downstream text operations remain checked without redeclaring the field.
 `scalar()` turns a query with exactly one selected field into an expression:
 
 ```ts
-import { from, scalar, select, value } from 'qubu'
+import { from, scalar, select, value } from "qubu"
 
 const firstId = select({ id: users.id }, from(users))
 const query = select(
@@ -120,7 +88,7 @@ const query = select(
     name: users.name,
     firstId: scalar(firstId),
   },
-  from(users)
+  from(users),
 )
 ```
 
@@ -139,7 +107,7 @@ Set operations preserve the left query's row shape. Both queries must select
 compatible rows:
 
 ```ts
-import { eq, from, select, unionAll, where } from 'qubu'
+import { eq, from, select, unionAll, where } from "qubu"
 
 const first = select({ id: users.id }, from(users))
 const second = select({ id: users.id }, from(users), where(eq(users.id, 7)))
@@ -156,17 +124,12 @@ are collected in traversal order.
 Build reusable pieces as ordinary values and pass them into the final query:
 
 ```ts
-import { desc, eq, from, orderBy, select, where } from 'qubu'
+import { desc, eq, from, orderBy, select, where } from "qubu"
 
 const byId = where(eq(users.id, 7))
 const newest = orderBy(desc(users.id))
 
-const query = select(
-  { id: users.id, name: users.name },
-  from(users),
-  byId,
-  newest
-)
+const query = select({ id: users.id, name: users.name }, from(users), byId, newest)
 ```
 
 This makes it possible to share a predicate or projection without mutating a
@@ -185,13 +148,10 @@ generic function retains its exact source identity.
 For an application-level requirement, describe the required JavaScript row:
 
 ```ts
-import { eq, where } from 'qubu'
-import type { TableLike } from 'qubu'
+import { eq, where } from "qubu"
+import type { TableLike } from "qubu"
 
-function byStringId<TTable extends TableLike<{ id: string }>>(
-  table: TTable,
-  id: string
-) {
+function byStringId<TTable extends TableLike<{ id: string }>>(table: TTable, id: string) {
   return where(eq(table.columns.id, id))
 }
 ```
@@ -203,18 +163,15 @@ extra fields and rejects `string | null`, but it does not distinguish
 Use `FieldLike` when the fragment depends on SQL semantics:
 
 ```ts
-import { eq, where } from 'qubu'
-import type { FieldLike, SourceLike, SqlTextLike } from 'qubu'
+import { eq, where } from "qubu"
+import type { FieldLike, SourceLike, SqlTextLike } from "qubu"
 
 type NonNullTextId = FieldLike<{
   sqlType: SqlTextLike
   nullable: false
 }>
 
-function byTextId<TSource extends SourceLike<{ id: NonNullTextId }>>(
-  source: TSource,
-  id: string
-) {
+function byTextId<TSource extends SourceLike<{ id: NonNullTextId }>>(source: TSource, id: string) {
   return where(eq(source.columns.id, id))
 }
 ```