@uniflowed/sql 0.33.0 → 0.35.0

package/adapters/better-sqlite3.js

@@ -22,7 +22,7 @@ export interface BetterSqlite3Statement {
   readonly reader: boolean;
   all(...params: $ReadOnlyArray<SqlParam>): $ReadOnlyArray<mixed>;
   run(...params: $ReadOnlyArray<SqlParam>): {
-    readonly changes: number,
+    readonly changes        : number,
     readonly lastInsertRowid: number | bigint,
     ...
   };
@@ -36,15 +36,15 @@ export interface BetterSqlite3Database {
 }
 
 export type BetterSqlite3Options = {|
-  readonly begin?: string,
+  readonly begin?         : string,
   readonly statementCache?: number,
-  readonly maxParams?: number,
+  readonly maxParams?     : number,
 |};
 
 /** A [`Queryable`] and a [`SyncQueryable`] over one better-sqlite3 `Database`. */
 export function fromBetterSqlite3(
   database: BetterSqlite3Database,
-  options: BetterSqlite3Options = {},
+  options : BetterSqlite3Options = {},
 ): Queryable & SyncQueryable {
   const statement = statementCache((text) => {
     const prepared = database.prepare(text);
@@ -70,16 +70,16 @@ export function fromBetterSqlite3(
     }
     const result = prepared.run(...params);
     return {
-      rows: [],
+      rows        : [],
       rowsAffected: count(result.changes),
       lastInsertId: rowId(result.lastInsertRowid),
     };
   };
   return singleConnectionSync({
-    engine: "sqlite",
+    engine   : "sqlite",
     maxParams: options.maxParams ?? 32766,
-    begin: options.begin,
-    run: async (text, params, mode) => runSync(text, params, mode),
+    begin    : options.begin,
+    run      : async (text, params, mode) => runSync(text, params, mode),
     runSync,
   });
 }

package/adapters/bun-sqlite.js

@@ -21,7 +21,7 @@ import { DEFAULT_STATEMENT_CACHE, count, rowId, statementCache } from "../intern
 export interface BunSqliteStatement {
   values(...params: $ReadOnlyArray<SqlParam>): $ReadOnlyArray<mixed>;
   run(...params: $ReadOnlyArray<SqlParam>): {
-    readonly changes: number | bigint,
+    readonly changes        : number | bigint,
     readonly lastInsertRowid: number | bigint,
     ...
   };
@@ -34,15 +34,15 @@ export interface BunSqliteDatabase {
 }
 
 export type BunSqliteOptions = {|
-  readonly begin?: string,
+  readonly begin?         : string,
   readonly statementCache?: number,
-  readonly maxParams?: number,
+  readonly maxParams?     : number,
 |};
 
 /** A [`Queryable`] and a [`SyncQueryable`] over one `bun:sqlite` `Database`. */
 export function fromBunSqlite(
   database: BunSqliteDatabase,
-  options: BunSqliteOptions = {},
+  options : BunSqliteOptions = {},
 ): Queryable & SyncQueryable {
   const statement = statementCache((text) => {
     const prepared = database.prepare(text);
@@ -63,16 +63,16 @@ export function fromBunSqlite(
     }
     const result = prepared.run(...params);
     return {
-      rows: [],
+      rows        : [],
       rowsAffected: count(result.changes),
       lastInsertId: rowId(result.lastInsertRowid),
     };
   };
   return singleConnectionSync({
-    engine: "sqlite",
+    engine   : "sqlite",
     maxParams: options.maxParams ?? 32766,
-    begin: options.begin,
-    run: async (text, params, mode) => runSync(text, params, mode),
+    begin    : options.begin,
+    run      : async (text, params, mode) => runSync(text, params, mode),
     runSync,
   });
 }

package/adapters/d1.js

@@ -47,7 +47,7 @@ function toD1(param: SqlParam): mixed {
 /** A [`Queryable`] over a D1 binding. */
 export function fromD1(database: D1Database): Queryable {
   return {
-    engine: "sqlite",
+    engine   : "sqlite",
     maxParams: 100,
     query: async (text, params, mode) => {
       const statement = database.prepare(text).bind(...params.map(toD1));
@@ -63,7 +63,7 @@ export function fromD1(database: D1Database): Queryable {
       }
       const { meta } = await statement.run();
       return {
-        rows: [],
+        rows        : [],
         rowsAffected: count(meta.changes ?? 0),
         lastInsertId: rowId(meta.last_row_id),
       };

package/adapters/mysql2.js

@@ -34,13 +34,13 @@ export type Mysql2Field = {
 };
 
 type Mysql2Options = {|
-  readonly sql: string,
-  readonly values: $ReadOnlyArray<mixed>,
-  readonly rowsAsArray: true,
+  readonly sql              : string,
+  readonly values           : $ReadOnlyArray<mixed>,
+  readonly rowsAsArray      : true,
   readonly supportBigNumbers: true,
-  readonly bigNumberStrings: true,
-  readonly dateStrings: true,
-  readonly typeCast: (field: Mysql2Field, next: () => mixed) => mixed,
+  readonly bigNumberStrings : true,
+  readonly dateStrings      : true,
+  readonly typeCast         : (field: Mysql2Field, next: () => mixed) => mixed,
 |};
 
 type Mysql2Result =
@@ -93,12 +93,12 @@ function lastId(value: number | string): bigint | null {
 function runOn(connection: Mysql2Connection): Run {
   return async (text, params, mode): Promise<QueryResult> => {
     const options: Mysql2Options = {
-      sql: text,
-      values: params,
-      rowsAsArray: true,
+      sql              : text,
+      values           : params,
+      rowsAsArray      : true,
       supportBigNumbers: true,
-      bigNumberStrings: true,
-      dateStrings: true,
+      bigNumberStrings : true,
+      dateStrings      : true,
       typeCast,
     };
     const [result] =
@@ -125,9 +125,9 @@ function connection(client: Mysql2Connection): Connection {
 /** A [`Queryable`] over a `mysql2/promise` pool. */
 export function fromMysql2Pool(pool: Mysql2Pool): Queryable {
   return {
-    engine: "mysql",
+    engine   : "mysql",
     maxParams: 65535,
-    query: runOn(pool),
+    query    : runOn(pool),
     transaction: async <T>(body: (tx: Queryable) => Promise<T>): Promise<T> => {
       const client = await pool.getConnection();
       try {

package/adapters/node-sqlite.js

@@ -22,7 +22,7 @@ import { DEFAULT_STATEMENT_CACHE, count, rowId, statementCache } from "../intern
 export interface NodeSqliteStatement {
   all(...params: $ReadOnlyArray<SqlParam>): $ReadOnlyArray<mixed>;
   run(...params: $ReadOnlyArray<SqlParam>): {
-    readonly changes: number | bigint,
+    readonly changes        : number | bigint,
     readonly lastInsertRowid: number | bigint,
     ...
   };
@@ -51,7 +51,7 @@ function prepared(database: NodeSqliteDatabase, text: string): NodeSqliteStateme
   // failing on the call below.
   if (!("setReturnArrays" in statement)) {
     throw new SqlError({
-      kind: "unsupported",
+      kind   : "unsupported",
       feature: "node:sqlite without StatementSync#setReturnArrays (Node 24.0 or 22.16 and newer)",
     });
   }
@@ -62,7 +62,7 @@ function prepared(database: NodeSqliteDatabase, text: string): NodeSqliteStateme
 /** A [`Queryable`] and a [`SyncQueryable`] over one `DatabaseSync`. */
 export function fromNodeSqlite(
   database: NodeSqliteDatabase,
-  options: NodeSqliteOptions = {},
+  options : NodeSqliteOptions = {},
 ): Queryable & SyncQueryable {
   const statement = statementCache(
     (text) => prepared(database, text),
@@ -83,16 +83,16 @@ export function fromNodeSqlite(
     }
     const result = prepared.run(...params);
     return {
-      rows: [],
+      rows        : [],
       rowsAffected: count(result.changes),
       lastInsertId: rowId(result.lastInsertRowid),
     };
   };
   return singleConnectionSync({
-    engine: "sqlite",
+    engine   : "sqlite",
     maxParams: options.maxParams ?? 32766,
-    begin: options.begin,
-    run: async (text, params, mode) => runSync(text, params, mode),
+    begin    : options.begin,
+    run      : async (text, params, mode) => runSync(text, params, mode),
     runSync,
   });
 }

package/adapters/pg.js

@@ -18,10 +18,10 @@ import { singleConnection, transactionOn } from "../index.js";
 type PgResult = { readonly rows: $ReadOnlyArray<mixed>, readonly rowCount: number | null, ... };
 
 type PgQuery = {|
-  readonly text: string,
-  readonly values: $ReadOnlyArray<mixed>,
+  readonly text   : string,
+  readonly values : $ReadOnlyArray<mixed>,
   readonly rowMode: "array",
-  readonly types: {| readonly getTypeParser: () => (value: string) => string |},
+  readonly types  : {| readonly getTypeParser: () => (value: string) => string |},
 |};
 
 /** A connected `pg.Client` or a client checked out of a pool. */
@@ -67,9 +67,9 @@ export function fromPgClient(client: PgClient): Queryable {
 /** A [`Queryable`] over a `pg.Pool`. */
 export function fromPgPool(pool: PgPool): Queryable {
   return {
-    engine: "postgresql",
+    engine   : "postgresql",
     maxParams: 65535,
-    query: runOn(pool),
+    query    : runOn(pool),
     transaction: async <T>(body: (tx: Queryable) => Promise<T>): Promise<T> => {
       const client = await pool.connect();
       let broken: mixed = undefined;

package/adapters/pglite.js

@@ -18,15 +18,15 @@ import { singleConnection } from "../index.js";
 /** The part of a `PGlite` instance this uses. */
 export interface PGliteDatabase {
   query(
-    text: string,
+    text  : string,
     params: $ReadOnlyArray<SqlParam>,
     options: {|
-      readonly rowMode: "array",
-      readonly parsers: { readonly [string]: (value: string) => mixed },
+      readonly rowMode    : "array",
+      readonly parsers    : { readonly [string]: (value: string) => mixed },
       readonly serializers: { readonly [string]: (value: mixed) => mixed },
     |},
   ): Promise<{ readonly rows: $ReadOnlyArray<mixed>, readonly affectedRows?: number, ... }>;
-  readonly parsers: { readonly [string]: mixed };
+  readonly parsers    : { readonly [string]: mixed };
   readonly serializers: { readonly [string]: mixed };
 }
 
@@ -50,7 +50,7 @@ export function fromPGlite(database: PGliteDatabase): Queryable {
   let parsers: { readonly [string]: (value: mixed) => mixed } = {};
   let serializers: { readonly [string]: (value: mixed) => mixed } = {};
   return singleConnection({
-    engine: "postgresql",
+    engine   : "postgresql",
     maxParams: 65535,
     run: async (text, params) => {
       const size = Object.keys(database.parsers).length + Object.keys(database.serializers).length;

package/adapters/postgres.js

@@ -30,8 +30,8 @@ type Unsafe = { raw(): RawRows, ... };
 /** What postgres.js's `Sql` and its transaction handles have in common. */
 export interface PostgresQueries {
   unsafe(
-    text: string,
-    params: $ReadOnlyArray<mixed>,
+    text    : string,
+    params  : $ReadOnlyArray<mixed>,
     options?: {| readonly prepare?: boolean |},
   ): Unsafe;
   typed(value: SqlParam, oid: number): mixed;
@@ -83,7 +83,7 @@ async function scoped<T>(tx: PostgresTransaction, body: (tx: Queryable) => Promi
   let open = true;
   const query = run(tx);
   const queryable: Queryable = {
-    engine: "postgresql",
+    engine   : "postgresql",
     maxParams: 65535,
     query: (statement, params, mode) =>
       open ? query(statement, params, mode) : Promise.reject(new SqlError({ kind: "closed" })),
@@ -102,9 +102,9 @@ async function scoped<T>(tx: PostgresTransaction, body: (tx: Queryable) => Promi
 /** A [`Queryable`] over a postgres.js `Sql`. */
 export function fromPostgres(sql: PostgresSql): Queryable {
   return {
-    engine: "postgresql",
+    engine   : "postgresql",
     maxParams: 65535,
-    query: run(sql),
+    query    : run(sql),
     transaction: <T>(body: (tx: Queryable) => Promise<T>): Promise<T> =>
       sql.begin((tx) => scoped(tx, body)),
   };

package/index.js

@@ -91,7 +91,7 @@ export type Queryable = {
  * body would deadlock the same way `await db.query` does inside `transaction`.
  */
 export type SyncQueryable = {
-  readonly engine: Engine,
+  readonly engine   : Engine,
   readonly maxParams: number,
   querySync(text: string, params: $ReadOnlyArray<SqlParam>, mode: QueryMode): QueryResult,
   readonly transactionSync?: <T>(body: (tx: SyncQueryable) => T) => T,
@@ -155,19 +155,19 @@ function explain(failure: SqlFailure, query: string | null): string {
   return (
     where +
     match (failure) {
-      {kind: "decode", expected: const expected, value: const value} =>
+      {kind: "decode", expected: const expected, value: const value}  =>
         `expected ${expected} from the database, got ${show(value)}`,
-      {kind: "encode", expected: const expected, value: const value} =>
+      {kind: "encode", expected: const expected, value: const value}  =>
         `expected ${expected} as a parameter, got ${show(value)}`,
       {kind: "shape", expected: const expected, actual: const actual} =>
         `the adapter returned ${actual} columns where the query has ${expected}; ` +
           "regenerate with `uf sqlc generate`, or check that the adapter returns rows as arrays",
-      {kind: "closed"} => "the transaction has already committed or rolled back",
-      {kind: "unsupported", feature: const feature} =>
+      {kind: "closed"}                                                => "the transaction has already committed or rolled back",
+      {kind: "unsupported", feature: const feature}                   =>
         `${feature} is not supported by this adapter`,
-      {kind: "params", width: const width, max: const max} =>
+      {kind: "params", width: const width, max: const max}            =>
         `a :copyfrom row binds ${width} parameters and this adapter allows ${max}`,
-      {kind: "row", index: const index, length: const length} =>
+      {kind: "row", index: const index, length: const length}         =>
         `a :copyfrom row has ${length} fields and the statement reads index ${index}`,
     }
   );
@@ -229,11 +229,11 @@ function allRows<T>(rows: $ReadOnlyArray<Row>, width: number, decode: (row: Row)
 
 /** `:one` — the first row, or `null`. */
 export async function one<T>(
-  db: Queryable,
-  name: string,
-  text: string,
+  db    : Queryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
-  width: number,
+  width : number,
   decode: (row: Row) => T,
 ): Promise<T | null> {
   try {
@@ -246,11 +246,11 @@ export async function one<T>(
 
 /** `:one` on a [`SyncQueryable`]. */
 export function oneSync<T>(
-  db: SyncQueryable,
-  name: string,
-  text: string,
+  db    : SyncQueryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
-  width: number,
+  width : number,
   decode: (row: Row) => T,
 ): T | null {
   try {
@@ -263,11 +263,11 @@ export function oneSync<T>(
 
 /** `:many` — every row. */
 export async function many<T>(
-  db: Queryable,
-  name: string,
-  text: string,
+  db    : Queryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
-  width: number,
+  width : number,
   decode: (row: Row) => T,
 ): Promise<Array<T>> {
   try {
@@ -280,11 +280,11 @@ export async function many<T>(
 
 /** `:many` on a [`SyncQueryable`]. */
 export function manySync<T>(
-  db: SyncQueryable,
-  name: string,
-  text: string,
+  db    : SyncQueryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
-  width: number,
+  width : number,
   decode: (row: Row) => T,
 ): Array<T> {
   try {
@@ -296,9 +296,9 @@ export function manySync<T>(
 }
 
 async function run(
-  db: Queryable,
-  name: string,
-  text: string,
+  db    : Queryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
 ): Promise<QueryResult> {
   try {
@@ -309,9 +309,9 @@ async function run(
 }
 
 function executed(
-  db: SyncQueryable,
-  name: string,
-  text: string,
+  db    : SyncQueryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
 ): QueryResult {
   try {
@@ -323,9 +323,9 @@ function executed(
 
 /** `:exec`. */
 export async function exec(
-  db: Queryable,
-  name: string,
-  text: string,
+  db    : Queryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
 ): Promise<void> {
   await run(db, name, text, params);
@@ -333,9 +333,9 @@ export async function exec(
 
 /** `:exec` on a [`SyncQueryable`]. */
 export function execSync(
-  db: SyncQueryable,
-  name: string,
-  text: string,
+  db    : SyncQueryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
 ): void {
   executed(db, name, text, params);
@@ -343,9 +343,9 @@ export function execSync(
 
 /** `:execrows` — how many rows the statement changed. */
 export async function execRows(
-  db: Queryable,
-  name: string,
-  text: string,
+  db    : Queryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
 ): Promise<number> {
   return (await run(db, name, text, params)).rowsAffected;
@@ -353,9 +353,9 @@ export async function execRows(
 
 /** `:execrows` on a [`SyncQueryable`]. */
 export function execRowsSync(
-  db: SyncQueryable,
-  name: string,
-  text: string,
+  db    : SyncQueryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
 ): number {
   return executed(db, name, text, params).rowsAffected;
@@ -369,9 +369,9 @@ export type ExecResult = {|
 
 /** `:execresult` — the affected-row count and, on MySQL and SQLite, the last id. */
 export async function execResult(
-  db: Queryable,
-  name: string,
-  text: string,
+  db    : Queryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
 ): Promise<ExecResult> {
   const { rowsAffected, lastInsertId } = await run(db, name, text, params);
@@ -380,9 +380,9 @@ export async function execResult(
 
 /** `:execresult` on a [`SyncQueryable`]. */
 export function execResultSync(
-  db: SyncQueryable,
-  name: string,
-  text: string,
+  db    : SyncQueryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
 ): ExecResult {
   const { rowsAffected, lastInsertId } = executed(db, name, text, params);
@@ -403,9 +403,9 @@ function insertedId(result: QueryResult, name: string): bigint {
  * `:one`, and this throws rather than resolve to a made-up zero.
  */
 export async function execLastId(
-  db: Queryable,
-  name: string,
-  text: string,
+  db    : Queryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
 ): Promise<bigint> {
   return insertedId(await run(db, name, text, params), name);
@@ -413,9 +413,9 @@ export async function execLastId(
 
 /** `:execlastid` on a [`SyncQueryable`]. */
 export function execLastIdSync(
-  db: SyncQueryable,
-  name: string,
-  text: string,
+  db    : SyncQueryable,
+  name  : string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
 ): bigint {
   return insertedId(executed(db, name, text, params), name);
@@ -453,7 +453,7 @@ export function slice(values: $ReadOnlyArray<SqlParam>): Slice {
  * should match.
  */
 export function expand(
-  parts: $ReadOnlyArray<string>,
+  parts : $ReadOnlyArray<string>,
   values: $ReadOnlyArray<SqlParam | Slice>,
 ): {| readonly text: string, readonly params: $ReadOnlyArray<SqlParam> |} {
   const params: Array<SqlParam> = [];
@@ -485,10 +485,10 @@ export function expand(
  * `VALUES ($1, $2)` is `tuple: ["(", ", ", ")"]`, `refs: [0, 1]`.
  */
 export type CopyPlan = {|
-  readonly head: string,
+  readonly head : string,
   readonly tuple: $ReadOnlyArray<string>,
-  readonly refs: $ReadOnlyArray<number>,
-  readonly tail: string,
+  readonly refs : $ReadOnlyArray<number>,
+  readonly tail : string,
 |};
 
 /** The most rows one statement carries when a row has no parameters at all. */
@@ -496,9 +496,9 @@ const COPY_ROWS_WITHOUT_PARAMS = 1000;
 
 function copyChunk(
   engine: Engine,
-  plan: CopyPlan,
-  chunk: $ReadOnlyArray<$ReadOnlyArray<SqlParam>>,
-  name: string,
+  plan  : CopyPlan,
+  chunk : $ReadOnlyArray<$ReadOnlyArray<SqlParam>>,
+  name  : string,
 ): {| readonly text: string, readonly params: $ReadOnlyArray<SqlParam> |} {
   const width = plan.refs.length;
   const params: Array<SqlParam> = [];
@@ -536,7 +536,7 @@ function copyWidth(db: { readonly maxParams: number, ... }, plan: CopyPlan, name
  * now several statements. Resolves to the number of rows inserted.
  */
 export async function copyFrom(
-  db: Queryable,
+  db  : Queryable,
   name: string,
   plan: CopyPlan,
   rows: $ReadOnlyArray<$ReadOnlyArray<SqlParam>>,
@@ -562,7 +562,7 @@ export async function copyFrom(
 
 /** `:copyfrom` on a [`SyncQueryable`]. */
 export function copyFromSync(
-  db: SyncQueryable,
+  db  : SyncQueryable,
   name: string,
   plan: CopyPlan,
   rows: $ReadOnlyArray<$ReadOnlyArray<SqlParam>>,
@@ -598,9 +598,9 @@ export function copyFromSync(
  * order without one, and the docs say so.
  */
 export async function batch<A, R>(
-  db: Queryable,
+  db   : Queryable,
   items: $ReadOnlyArray<A>,
-  body: (q: Queryable, item: A) => Promise<R>,
+  body : (q: Queryable, item: A) => Promise<R>,
 ): Promise<Array<R>> {
   const each = async (q: Queryable): Promise<Array<R>> => {
     const out: Array<R> = [];
@@ -623,9 +623,9 @@ export async function batch<A, R>(
  * items still run in order, on this thread.
  */
 export function batchSync<A, R>(
-  db: SyncQueryable,
+  db   : SyncQueryable,
   items: $ReadOnlyArray<A>,
-  body: (q: SyncQueryable, item: A) => R,
+  body : (q: SyncQueryable, item: A) => R,
 ): Array<R> {
   const each = (q: SyncQueryable): Array<R> => {
     const out: Array<R> = [];
@@ -646,23 +646,23 @@ export function batchSync<A, R>(
 
 /** How an adapter runs one statement on one connection. */
 export type Run = (
-  text: string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
-  mode: QueryMode,
+  mode  : QueryMode,
 ) => Promise<QueryResult>;
 
 /** [`Run`] for a driver that finishes the statement before returning. */
 export type RunSync = (
-  text: string,
+  text  : string,
   params: $ReadOnlyArray<SqlParam>,
-  mode: QueryMode,
+  mode  : QueryMode,
 ) => QueryResult;
 
 /** What [`transactionOn`] needs from an adapter. */
 export type Connection = {|
-  readonly engine: Engine,
+  readonly engine   : Engine,
   readonly maxParams: number,
-  readonly run: Run,
+  readonly run      : Run,
   /** Present when the driver can also run a statement on the calling thread. */
   readonly runSync?: RunSync,
   /** The statement that opens a transaction; `BEGIN` unless the adapter knows better. */
@@ -681,7 +681,7 @@ export type Connection = {|
  */
 export async function transactionOn<T>(
   connection: Connection,
-  body: (tx: Queryable) => Promise<T>,
+  body      : (tx: Queryable) => Promise<T>,
 ): Promise<T> {
   await connection.run(connection.begin ?? "BEGIN", [], "exec");
   return scoped(connection, 0, body, "COMMIT", "ROLLBACK");
@@ -689,10 +689,10 @@ export async function transactionOn<T>(
 
 async function scoped<T>(
   connection: Connection,
-  depth: number,
-  body: (tx: Queryable) => Promise<T>,
-  commit: string,
-  rollback: string,
+  depth     : number,
+  body      : (tx: Queryable) => Promise<T>,
+  commit    : string,
+  rollback  : string,
 ): Promise<T> {
   let open = true;
   const guarded: Run = (text, params, mode) => {
@@ -702,9 +702,9 @@ async function scoped<T>(
     return connection.run(text, params, mode);
   };
   const tx: Queryable = {
-    engine: connection.engine,
+    engine   : connection.engine,
     maxParams: connection.maxParams,
-    query: guarded,
+    query    : guarded,
     transaction: async <U>(inner: (tx: Queryable) => Promise<U>): Promise<U> => {
       const savepoint = `uf_sp_${depth + 1}`;
       await guarded(`SAVEPOINT ${savepoint}`, [], "exec");
@@ -773,12 +773,12 @@ export function transactionOnSync<T>(connection: Connection, body: (tx: SyncQuer
 }
 
 function scopedSync<T>(
-  runSync: RunSync,
+  runSync   : RunSync,
   connection: Connection,
-  depth: number,
-  body: (tx: SyncQueryable) => T,
-  commit: string,
-  rollback: string,
+  depth     : number,
+  body      : (tx: SyncQueryable) => T,
+  commit    : string,
+  rollback  : string,
 ): T {
   let open = true;
   const guarded: RunSync = (text, params, mode) => {
@@ -788,7 +788,7 @@ function scopedSync<T>(
     return runSync(text, params, mode);
   };
   const tx: SyncQueryable = {
-    engine: connection.engine,
+    engine   : connection.engine,
     maxParams: connection.maxParams,
     querySync: guarded,
     transactionSync: <U>(inner: (tx: SyncQueryable) => U): U => {
@@ -863,9 +863,9 @@ function connect(connection: Connection): Handle {
   const runSync = connection.runSync;
 
   const query = async (
-    text: string,
+    text  : string,
     params: $ReadOnlyArray<SqlParam>,
-    mode: QueryMode,
+    mode  : QueryMode,
   ): Promise<QueryResult> => {
     if (syncOpen) {
       unsupported("an asynchronous query while a synchronous transaction is open");
@@ -894,9 +894,9 @@ function connect(connection: Connection): Handle {
     }
   };
   const querySync = (
-    text: string,
+    text  : string,
     params: $ReadOnlyArray<SqlParam>,
-    mode: QueryMode,
+    mode  : QueryMode,
   ): QueryResult => {
     const run =
       connection.runSync ?? unsupported("a synchronous query on an asynchronous connection");
@@ -930,7 +930,7 @@ function connect(connection: Connection): Handle {
     }
   };
   return {
-    engine: connection.engine,
+    engine   : connection.engine,
     maxParams: connection.maxParams,
     query,
     transaction,

package/internal/shared.js

@@ -161,9 +161,9 @@ export function bytesParam(expected: string, value: mixed): Uint8Array {
 
 /** One of an enum's labels. */
 export function label<T extends string>(
-  values: $ReadOnlyArray<T>,
+  values  : $ReadOnlyArray<T>,
   expected: string,
-  value: mixed,
+  value   : mixed,
 ): T {
   const index = typeof value === "string" ? values.findIndex((item) => item === value) : -1;
   if (index < 0) {
@@ -174,9 +174,9 @@ export function label<T extends string>(
 
 /** Encode one of an enum's labels, refusing a string that is not one. */
 export function labelParam<T extends string>(
-  values: $ReadOnlyArray<T>,
+  values  : $ReadOnlyArray<T>,
   expected: string,
-  value: mixed,
+  value   : mixed,
 ): T {
   const index = typeof value === "string" ? values.findIndex((item) => item === value) : -1;
   if (index < 0) {

package/internal/statements.js

@@ -13,7 +13,7 @@ export const DEFAULT_STATEMENT_CACHE = 256;
 
 export function statementCache<S>(
   prepare: (text: string) => S,
-  limit: number,
+  limit  : number,
 ): (text: string) => S {
   const cache: Map<string, S> = new Map();
   return (text) => {

package/mysql.js

@@ -34,8 +34,8 @@ export type MysqlParam = null | string | Uint8Array;
 /** How one MySQL type becomes a Flow value and back. */
 export type Codec<T> = {|
   readonly sqlType: string,
-  readonly decode: (value: mixed) => T,
-  readonly encode: (value: T) => MysqlParam,
+  readonly decode : (value: mixed) => T,
+  readonly encode : (value: T) => MysqlParam,
 |};
 
 /** `TINYINT` through `INT`, signed or unsigned, and `YEAR`: all fit a `number`. */
@@ -55,7 +55,7 @@ export function integer(sqlType: string): Codec<number> {
 /** `BIGINT`, signed or unsigned, exactly. */
 export const bigint: Codec<bigint> = {
   sqlType: "bigint",
-  decode: (value) => bigintFrom("bigint", value),
+  decode : (value) => bigintFrom("bigint", value),
   encode: (value) => {
     if (typeof value !== "bigint") {
       return encodeError("bigint (a bigint)", value);
@@ -169,14 +169,14 @@ export function bytes(sqlType: string): Codec<Uint8Array> {
 /** `JSON`. */
 export const json: Codec<JsonValue> = {
   sqlType: "json",
-  decode: (value) => jsonFromText(value),
-  encode: (value) => jsonParam(value),
+  decode : (value) => jsonFromText(value),
+  encode : (value) => jsonParam(value),
 };
 
 /** A result sqlc could not type. */
 export const unknown: Codec<mixed> = {
   sqlType: "unknown",
-  decode: (value) => value,
+  decode : (value) => value,
   encode: (value) => {
     if (value === null || typeof value === "string" || value instanceof Uint8Array) {
       return value;
@@ -194,7 +194,7 @@ export const unknown: Codec<mixed> = {
 /** An `ENUM(…)` column, from its values in declaration order. */
 export function enumeration<T extends string>(
   sqlType: string,
-  values: $ReadOnlyArray<T>,
+  values : $ReadOnlyArray<T>,
 ): Codec<T> {
   const expected = `${sqlType} (${enumName(values)})`;
   return {
@@ -209,14 +209,14 @@ export function enumeration<T extends string>(
  * value back to what `codec` writes.
  */
 export function map<T, U>(
-  codec: Codec<T>,
+  codec : Codec<T>,
   decode: (value: T) => U,
   encode: (value: U) => T,
 ): Codec<U> {
   return {
     sqlType: codec.sqlType,
-    decode: (value) => decode(codec.decode(value)),
-    encode: (value) => codec.encode(encode(value)),
+    decode : (value) => decode(codec.decode(value)),
+    encode : (value) => codec.encode(encode(value)),
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/sql",
-  "version": "0.33.0",
+  "version": "0.35.0",
   "description": "The runtime for sqlc's Flow target: exact codecs and driver adapters, part of the Unified Toolchain for Flow.",
   "type": "module",
   "license": "MIT",

package/postgresql.js

@@ -39,8 +39,8 @@ export type ArrayNode = string | null | $ReadOnlyArray<ArrayNode>;
 export type Codec<T> = {|
   /** For messages: `int8`, `text[]`. */
   readonly sqlType: string,
-  readonly decode: (value: mixed) => T,
-  readonly encode: (value: T) => string,
+  readonly decode : (value: mixed) => T,
+  readonly encode : (value: T) => string,
   readonly element: (node: ArrayNode) => T,
   /** The value as it appears inside `{…}`: quoted, or a nested literal. */
   readonly literal: (value: T) => string,
@@ -54,9 +54,9 @@ function quote(text: string): string {
 
 /** A scalar codec from its two text conversions. */
 export function scalar<T>(
-  sqlType: string,
+  sqlType : string,
   fromText: (text: string) => T,
-  toText: (value: T) => string,
+  toText  : (value: T) => string,
 ): Codec<T> {
   const decode = (value: mixed): T => {
     if (typeof value !== "string") {
@@ -78,7 +78,7 @@ export function scalar<T>(
       return fromText(node);
     },
     literal: (value) => quote(toText(value)),
-    depth: 0,
+    depth  : 0,
   };
 }
 
@@ -381,7 +381,7 @@ export const timestamptz: Codec<Date> = scalar("timestamptz", instantFromText, i
 /** A value sqlc could not type (`any`, `anyelement`, …): whatever the server printed. */
 export const unknown: Codec<mixed> = {
   sqlType: "unknown",
-  decode: (value) => value,
+  decode : (value) => value,
   encode: (value) => {
     if (typeof value === "string") {
       return value;
@@ -396,7 +396,7 @@ export const unknown: Codec<mixed> = {
   },
   element: (node) => node,
   literal: (value) => (value === null ? "NULL" : quote(String(value))),
-  depth: 0,
+  depth  : 0,
 };
 
 // ---------------------------------------------------------------------------
@@ -405,7 +405,7 @@ export const unknown: Codec<mixed> = {
 /** A codec for a `CREATE TYPE … AS ENUM`, from its labels in declaration order. */
 export function enumeration<T extends string>(
   sqlType: string,
-  values: $ReadOnlyArray<T>,
+  values : $ReadOnlyArray<T>,
 ): Codec<T> {
   const expected = `${sqlType} (${enumName(values)})`;
   return scalar(
@@ -550,10 +550,10 @@ export function array<T>(element: Codec<T>): Codec<$ReadOnlyArray<T>> {
       // An empty array has no dimensions at all, whatever the column says.
       return root.length === 0 ? [] : fromNode(root);
     },
-    encode: toLiteral,
+    encode : toLiteral,
     element: (node) => (Array.isArray(node) && node.length === 0 ? [] : fromNode(node)),
     literal: toLiteral,
-    depth: element.depth + 1,
+    depth  : element.depth + 1,
   };
 }
 
@@ -563,17 +563,17 @@ export function array<T>(element: Codec<T>): Codec<$ReadOnlyArray<T>> {
  * options, where `decode` is the application's own check.
  */
 export function map<T, U>(
-  codec: Codec<T>,
+  codec : Codec<T>,
   decode: (value: T) => U,
   encode: (value: U) => T,
 ): Codec<U> {
   return {
     sqlType: codec.sqlType,
-    decode: (value) => decode(codec.decode(value)),
-    encode: (value) => codec.encode(encode(value)),
+    decode : (value) => decode(codec.decode(value)),
+    encode : (value) => codec.encode(encode(value)),
     element: (node) => decode(codec.element(node)),
     literal: (value) => codec.literal(encode(value)),
-    depth: codec.depth,
+    depth  : codec.depth,
   };
 }
 

package/sqlite.js

@@ -31,8 +31,8 @@ import {
 /** How one declared type becomes a Flow value and back. */
 export type Codec<T> = {|
   readonly sqlType: string,
-  readonly decode: (value: mixed) => T,
-  readonly encode: (value: T) => SqlParam,
+  readonly decode : (value: mixed) => T,
+  readonly encode : (value: T) => SqlParam,
 |};
 
 /** `INTEGER` as a `number`, which throws past 2^53 instead of rounding. */
@@ -50,8 +50,8 @@ export const integer: Codec<number> = {
 /** `INTEGER` as a `bigint`, for `sqliteInteger: "bigint"`. */
 export const integerAsBigint: Codec<bigint> = {
   sqlType: "INTEGER",
-  decode: (value) => bigintFrom("INTEGER", value),
-  encode: (value) => bigintParam("INTEGER (a bigint)", value),
+  decode : (value) => bigintFrom("INTEGER", value),
+  encode : (value) => bigintParam("INTEGER (a bigint)", value),
 };
 
 /** `REAL`, `DOUBLE`, `FLOAT`, and `NUMERIC`/`DECIMAL`, which SQLite stores as one or an INTEGER. */
@@ -106,21 +106,21 @@ export const string: Codec<string> = text("TEXT");
 /** `BLOB`. */
 export const blob: Codec<Uint8Array> = {
   sqlType: "BLOB",
-  decode: (value) => bytesFrom("BLOB", value),
-  encode: (value) => bytesParam("BLOB (a Uint8Array)", value),
+  decode : (value) => bytesFrom("BLOB", value),
+  encode : (value) => bytesParam("BLOB (a Uint8Array)", value),
 };
 
 /** `JSON` and `JSONB` (sqlc reads the latter through `json()`), stored as text. */
 export const json: Codec<JsonValue> = {
   sqlType: "JSON",
-  decode: (value) => jsonFromText(value),
-  encode: (value) => jsonParam(value),
+  decode : (value) => jsonFromText(value),
+  encode : (value) => jsonParam(value),
 };
 
 /** A declared type with no affinity uf can type, or a result sqlc could not. */
 export const unknown: Codec<mixed> = {
   sqlType: "unknown",
-  decode: (value) => value,
+  decode : (value) => value,
   encode: (value) => {
     if (
       value === null ||
@@ -141,7 +141,7 @@ export const unknown: Codec<mixed> = {
 /** A `CHECK (x IN (…))`-style enum sqlc was told about through an override. */
 export function enumeration<T extends string>(
   sqlType: string,
-  values: $ReadOnlyArray<T>,
+  values : $ReadOnlyArray<T>,
 ): Codec<T> {
   const expected = `${sqlType} (${enumName(values)})`;
   return {
@@ -156,14 +156,14 @@ export function enumeration<T extends string>(
  * value back to what `codec` writes.
  */
 export function map<T, U>(
-  codec: Codec<T>,
+  codec : Codec<T>,
   decode: (value: T) => U,
   encode: (value: U) => T,
 ): Codec<U> {
   return {
     sqlType: codec.sqlType,
-    decode: (value) => decode(codec.decode(value)),
-    encode: (value) => codec.encode(encode(value)),
+    decode : (value) => decode(codec.decode(value)),
+    encode : (value) => codec.encode(encode(value)),
   };
 }