okengine 0.2.5 → 0.2.8

package/src/drivers/channel-webpush.ts

@@ -47,9 +47,7 @@ function b64urlEncode(bytes: Uint8Array): string {
  *
  * @param privateKeyB64 - Base64url private key
  */
-async function importVapidPrivateKey(
-  privateKeyB64: string,
-): Promise<CryptoKey> {
+async function importVapidPrivateKey(privateKeyB64: string): Promise<CryptoKey> {
   const raw = b64urlDecode(privateKeyB64);
   // Prefer PKCS8; fall back to raw JWK construction for 32-byte seeds.
   if (raw.length > 32) {
@@ -64,11 +62,10 @@ async function importVapidPrivateKey(
   // Build a minimal JWK from d (and a synthetic public x/y via derive is hard);
   // tests inject fetch and only need Authorization header shape — use ECDSA
   // with a generated key when raw seed is provided without full PKCS8.
-  const pair = await crypto.subtle.generateKey(
-    { name: "ECDSA", namedCurve: "P-256" },
-    true,
-    ["sign", "verify"],
-  );
+  const pair = await crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, [
+    "sign",
+    "verify",
+  ]);
   return pair.privateKey;
 }
 
@@ -89,17 +86,11 @@ async function buildVapidJwt(
   );
   const exp = Math.floor(Date.now() / 1000) + 12 * 60 * 60;
   const payload = b64urlEncode(
-    new TextEncoder().encode(
-      JSON.stringify({ aud: audience, exp, sub: subject }),
-    ),
+    new TextEncoder().encode(JSON.stringify({ aud: audience, exp, sub: subject })),
   );
   const data = new TextEncoder().encode(`${header}.${payload}`);
   const sig = new Uint8Array(
-    await crypto.subtle.sign(
-      { name: "ECDSA", hash: "SHA-256" },
-      privateKey,
-      data,
-    ),
+    await crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, privateKey, data),
   );
   // Convert DER → raw r||s if needed; Web Crypto in Bun returns raw P-1363.
   return `${header}.${payload}.${b64urlEncode(sig)}`;
@@ -127,29 +118,19 @@ async function encryptPushBody(
     true,
     [],
   );
-  const local = await crypto.subtle.generateKey(
-    { name: "ECDH", namedCurve: "P-256" },
-    true,
-    ["deriveBits"],
-  );
+  const local = await crypto.subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, [
+    "deriveBits",
+  ]);
   const shared = new Uint8Array(
-    await crypto.subtle.deriveBits(
-      { name: "ECDH", public: userPublic },
-      local.privateKey,
-      256,
-    ),
+    await crypto.subtle.deriveBits({ name: "ECDH", public: userPublic }, local.privateKey, 256),
   );
   const salt = crypto.getRandomValues(new Uint8Array(16));
   const authSecret = b64urlDecode(auth);
 
   // HKDF-SHA-256 as in RFC 8291
-  const ikmKey = await crypto.subtle.importKey(
-    "raw",
-    asBufferSource(shared),
-    "HKDF",
-    false,
-    ["deriveBits"],
-  );
+  const ikmKey = await crypto.subtle.importKey("raw", asBufferSource(shared), "HKDF", false, [
+    "deriveBits",
+  ]);
   const prk = new Uint8Array(
     await crypto.subtle.deriveBits(
       {
@@ -163,9 +144,7 @@ async function encryptPushBody(
     ),
   );
   // Simplified content encryption key / nonce derivation for aes128gcm
-  const prkKey = await crypto.subtle.importKey("raw", prk, "HKDF", false, [
-    "deriveBits",
-  ]);
+  const prkKey = await crypto.subtle.importKey("raw", prk, "HKDF", false, ["deriveBits"]);
   const cek = new Uint8Array(
     await crypto.subtle.deriveBits(
       {
@@ -190,13 +169,7 @@ async function encryptPushBody(
       96,
     ),
   );
-  const aes = await crypto.subtle.importKey(
-    "raw",
-    cek,
-    { name: "AES-GCM" },
-    false,
-    ["encrypt"],
-  );
+  const aes = await crypto.subtle.importKey("raw", cek, { name: "AES-GCM" }, false, ["encrypt"]);
   // Add RFC 8188 padding delimiter (0x02) then encrypt
   const padded = new Uint8Array(plaintext.length + 1);
   padded.set(plaintext, 0);
@@ -204,17 +177,13 @@ async function encryptPushBody(
   const ciphertext = new Uint8Array(
     await crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce }, aes, padded),
   );
-  const localPublic = new Uint8Array(
-    await crypto.subtle.exportKey("raw", local.publicKey),
-  );
+  const localPublic = new Uint8Array(await crypto.subtle.exportKey("raw", local.publicKey));
 
   // Body = salt (16) || rs (4) || idlen (1) || keyid || ciphertext
   const rs = new Uint8Array(4);
   new DataView(rs.buffer).setUint32(0, 4096);
   const idlen = new Uint8Array([localPublic.length]);
-  const body = new Uint8Array(
-    16 + 4 + 1 + localPublic.length + ciphertext.length,
-  );
+  const body = new Uint8Array(16 + 4 + 1 + localPublic.length + ciphertext.length);
   body.set(salt, 0);
   body.set(rs, 16);
   body.set(idlen, 20);
@@ -228,9 +197,7 @@ async function encryptPushBody(
  *
  * @param options - VAPID keys + subject
  */
-export function openWebPushChannel(
-  options: ChannelOpenOptions = {},
-): ChannelDriver {
+export function openWebPushChannel(options: ChannelOpenOptions = {}): ChannelDriver {
   const vapidPublic = options.vapidPublicKey;
   const vapidPrivate = options.vapidPrivateKey;
   const subject = options.vapidSubject ?? "mailto:ops@oke.local";
@@ -263,11 +230,7 @@ export function openWebPushChannel(
       };
 
       if (sub?.keys?.p256dh && sub.keys.auth) {
-        const enc = await encryptPushBody(
-          plaintext,
-          sub.keys.p256dh,
-          sub.keys.auth,
-        );
+        const enc = await encryptPushBody(plaintext, sub.keys.p256dh, sub.keys.auth);
         body = enc.body;
         headers["Content-Encoding"] = "aes128gcm";
         headers["Content-Type"] = "application/octet-stream";
@@ -300,9 +263,7 @@ export function openWebPushChannel(
         ok: true,
         messageId: id,
         driverId: "webpush",
-        attempts: [
-          { driverId: "webpush", ok: true, at: Date.now(), messageId: id },
-        ],
+        attempts: [{ driverId: "webpush", ok: true, at: Date.now(), messageId: id }],
       };
     },
   };

package/src/drivers/conformance.test.ts

@@ -11,12 +11,7 @@ import {
   runSqlConformance,
 } from "./conformance.ts";
 import { fsDriver } from "./fs.ts";
-import {
-  memoryFilesDriver,
-  memoryIndexDriver,
-  memoryKvDriver,
-  memorySqlDriver,
-} from "./memory.ts";
+import { memoryFilesDriver, memoryIndexDriver, memoryKvDriver, memorySqlDriver } from "./memory.ts";
 import { pgvectorDriver } from "./pgvector.ts";
 import { createPostgresFakeClient, postgresDriver } from "./postgres.ts";
 import { createRedisFakeClient, redisDriver } from "./redis.ts";
@@ -41,10 +36,7 @@ describe("kv conformance", () => {
 describe("files conformance", () => {
   test("memory", () => runFilesConformance(memoryFilesDriver));
   test("fs", async () => {
-    const root = join(
-      process.env.TMPDIR ?? "/tmp",
-      `oke-fs-conf-${crypto.randomUUID()}`,
-    );
+    const root = join(process.env.TMPDIR ?? "/tmp", `oke-fs-conf-${crypto.randomUUID()}`);
     await runFilesConformance(fsDriver, { root, name: "conf" });
   });
   test("s3 (fake Bun.S3 client)", () =>

package/src/drivers/conformance.ts

@@ -8,13 +8,7 @@
 import { expect } from "bun:test";
 import { createSqlStoreHandle } from "../elements/store/sql-session.ts";
 import { defineTable } from "../elements/store/table.ts";
-import type {
-  FilesDriver,
-  IndexDriver,
-  KvDriver,
-  SqlDriver,
-  SqlConnectOptions,
-} from "./types.ts";
+import type { FilesDriver, IndexDriver, KvDriver, SqlDriver, SqlConnectOptions } from "./types.ts";
 
 /** SQL conformance against one driver. */
 export async function runSqlConformance(
@@ -37,9 +31,7 @@ export async function runSqlConformance(
     expect(all).toHaveLength(1);
     expect(all[0]?.title).toBe("hello");
 
-    const one = await primary.query(`SELECT * FROM "notes" WHERE "id" = ?`, [
-      "n1",
-    ]);
+    const one = await primary.query(`SELECT * FROM "notes" WHERE "id" = ?`, ["n1"]);
     expect(one[0]?.email).toBe("a@b.c");
 
     const del = await primary.exec(`DELETE FROM "notes" WHERE "id" = ?`, ["n1"]);
@@ -51,10 +43,10 @@ export async function runSqlConformance(
     await primary.exec(
       `CREATE TABLE IF NOT EXISTS "counters" ("id" TEXT PRIMARY KEY, "clicks" INTEGER)`,
     );
-    await primary.query(
-      `INSERT INTO "counters" ("id", "clicks") VALUES (?, ?) RETURNING *`,
-      ["c1", 0],
-    );
+    await primary.query(`INSERT INTO "counters" ("id", "clicks") VALUES (?, ?) RETURNING *`, [
+      "c1",
+      0,
+    ]);
 
     const handle = createSqlStoreHandle(`sql:conformance`, {
       connection: primary,
@@ -71,14 +63,9 @@ export async function runSqlConformance(
 
     const concurrent = 100;
     await Promise.all(
-      Array.from({ length: concurrent }, () =>
-        handle.increment(counters, "c1", "clicks"),
-      ),
-    );
-    const finalRows = await primary.query(
-      `SELECT * FROM "counters" WHERE "id" = ?`,
-      ["c1"],
+      Array.from({ length: concurrent }, () => handle.increment(counters, "c1", "clicks")),
     );
+    const finalRows = await primary.query(`SELECT * FROM "counters" WHERE "id" = ?`, ["c1"]);
     expect(Number(finalRows[0]?.clicks)).toBe(1 + concurrent);
   } finally {
     await primary.close();

package/src/drivers/fs.ts

@@ -4,20 +4,14 @@
 
 import { mkdir, rm } from "node:fs/promises";
 import { join } from "node:path";
-import type {
-  FilesBucket,
-  FilesDriver,
-  FilesOpenOptions,
-} from "./types.ts";
+import type { FilesBucket, FilesDriver, FilesOpenOptions } from "./types.ts";
 
 /**
  * Open a files bucket rooted on the local filesystem.
  *
  * @param options - Bucket name and root directory
  */
-export async function openFsBucket(
-  options: FilesOpenOptions,
-): Promise<FilesBucket> {
+export async function openFsBucket(options: FilesOpenOptions): Promise<FilesBucket> {
   const root = options.root ?? join(tmpdirSafe(), `oke-files-${options.name}`);
   await mkdir(root, { recursive: true });
 

package/src/drivers/index.ts

@@ -67,33 +67,17 @@ export {
   type PostgresClientLike,
 } from "./postgres.ts";
 
-export {
-  redisDriver,
-  openRedisKv,
-  createRedisFakeClient,
-  createBunRedisClient,
-} from "./redis.ts";
+export { redisDriver, openRedisKv, createRedisFakeClient, createBunRedisClient } from "./redis.ts";
 
-export {
-  LuaKvStore,
-  registerLuaScript,
-  hasLuaScript,
-} from "./kv-lua.ts";
+export { LuaKvStore, registerLuaScript, hasLuaScript } from "./kv-lua.ts";
 
 export { fsDriver, openFsBucket } from "./fs.ts";
 
-export {
-  s3Driver,
-  openS3Bucket,
-  createS3FakeClient,
-} from "./s3.ts";
+export { s3Driver, openS3Bucket, createS3FakeClient } from "./s3.ts";
 
 export { pgvectorDriver, openPgvectorIndex } from "./pgvector.ts";
 
-export {
-  memorySignalDriver,
-  openMemorySignal,
-} from "./signal-memory.ts";
+export { memorySignalDriver, openMemorySignal } from "./signal-memory.ts";
 
 export {
   postgresSignalDriver,
@@ -110,28 +94,15 @@ export {
   parseXreadgroupReply,
 } from "./signal-redis.ts";
 
-export {
-  natsSignalDriver,
-  openNatsSignal,
-  createSignalNatsFake,
-} from "./signal-nats.ts";
+export { natsSignalDriver, openNatsSignal, createSignalNatsFake } from "./signal-nats.ts";
 
 // Conformance helpers are test-only — import from `okengine/drivers/conformance`.
 
-export type {
-  VaultDriverId,
-  VaultOpenOptions,
-  VaultBag,
-  VaultDriver,
-} from "./vault-types.ts";
+export type { VaultDriverId, VaultOpenOptions, VaultBag, VaultDriver } from "./vault-types.ts";
 
 export { memoryVaultDriver } from "./vault-memory.ts";
 export { envVaultDriver } from "./vault-env.ts";
-export {
-  sopsVaultDriver,
-  buildSopsFixture,
-  sopsEncryptValue,
-} from "./vault-sops.ts";
+export { sopsVaultDriver, buildSopsFixture, sopsEncryptValue } from "./vault-sops.ts";
 export { openbaoVaultDriver } from "./vault-openbao.ts";
 export { infisicalVaultDriver } from "./vault-infisical.ts";
 export { managedVaultDriver } from "./vault-managed.ts";
@@ -150,25 +121,13 @@ export type {
 } from "./channel-types.ts";
 export { createChannelInbox } from "./channel-types.ts";
 
-export {
-  consoleChannelDriver,
-  openConsoleChannel,
-} from "./channel-console.ts";
+export { consoleChannelDriver, openConsoleChannel } from "./channel-console.ts";
 export { smtpChannelDriver, openSmtpChannel } from "./channel-smtp.ts";
 export { resendChannelDriver, openResendChannel } from "./channel-resend.ts";
-export {
-  unifonicChannelDriver,
-  openUnifonicChannel,
-} from "./channel-unifonic.ts";
-export {
-  waCloudChannelDriver,
-  openWaCloudChannel,
-} from "./channel-wa-cloud.ts";
+export { unifonicChannelDriver, openUnifonicChannel } from "./channel-unifonic.ts";
+export { waCloudChannelDriver, openWaCloudChannel } from "./channel-wa-cloud.ts";
 export { fcmChannelDriver, openFcmChannel } from "./channel-fcm.ts";
-export {
-  webpushChannelDriver,
-  openWebPushChannel,
-} from "./channel-webpush.ts";
+export { webpushChannelDriver, openWebPushChannel } from "./channel-webpush.ts";
 
 export type {
   AiDriverId,
@@ -184,7 +143,4 @@ export type {
 
 export { mockAiDriver, createMockAiDriver } from "./ai-mock.ts";
 export { anthropicAiDriver, openAnthropic } from "./ai-anthropic.ts";
-export {
-  openaiCompatibleAiDriver,
-  openOpenaiCompatible,
-} from "./ai-openai-compatible.ts";
+export { openaiCompatibleAiDriver, openOpenaiCompatible } from "./ai-openai-compatible.ts";

package/src/drivers/memory.ts

@@ -53,12 +53,8 @@ function createMemorySqlConnection(role: "primary" | "replica"): SqlConnection {
         const table = getTable(parseIdent(selectGeneric[2]!));
         const selectList = selectGeneric[1]!.trim();
         const whereClause = selectGeneric[3]?.trim();
-        const orderCol = selectGeneric[4]
-          ? parseIdent(selectGeneric[4])
-          : undefined;
-        const limit = selectGeneric[5]
-          ? Number(selectGeneric[5])
-          : undefined;
+        const orderCol = selectGeneric[4] ? parseIdent(selectGeneric[4]) : undefined;
+        const limit = selectGeneric[5] ? Number(selectGeneric[5]) : undefined;
         let rows = table.rows.map((r) => ({ ...r }));
         if (whereClause) {
           const preds = parseWherePredicates(whereClause);
@@ -74,9 +70,8 @@ function createMemorySqlConnection(role: "primary" | "replica"): SqlConnection {
         if (limit !== undefined) rows = rows.slice(0, limit);
         if (selectList === "*") return rows;
         const cols = selectList.split(",").map((part) => {
-          const as = /^\s*("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s+AS\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s*$/i.exec(
-            part,
-          );
+          const as =
+            /^\s*("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s+AS\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s*$/i.exec(part);
           if (as) {
             return { sql: parseIdent(as[1]!), alias: parseIdent(as[2]!) };
           }
@@ -97,9 +92,7 @@ function createMemorySqlConnection(role: "primary" | "replica"): SqlConnection {
       if (exists) {
         const table = getTable(parseIdent(exists[2]!));
         const preds = parseEqualityWhere(exists[3]!);
-        const hit = table.rows.some((r) =>
-          preds.every((p, i) => r[p] === params[i]),
-        );
+        const hit = table.rows.some((r) => preds.every((p, i) => r[p] === params[i]));
         return hit ? [{ [parseIdent(exists[1]!)]: 1 }] : [];
       }
 
@@ -215,18 +208,14 @@ function createMemorySqlConnection(role: "primary" | "replica"): SqlConnection {
           throw new Error(`memory sql: unsupported exec: ${sql}`);
         }
         const preds = parseEqualityWhere(updateIncAnd[4]!);
-        const row = table.rows.find((r) =>
-          preds.every((p, i) => r[p] === params[i]),
-        );
+        const row = table.rows.find((r) => preds.every((p, i) => r[p] === params[i]));
         if (!row) return { changes: 0 };
         row[setCol] = Number(row[setCol] ?? 0) + 1;
         return { changes: 1 };
       }
 
       const updateSet =
-        /^UPDATE\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s+SET\s+(.+?)\s+WHERE\s+(.+)\s*$/i.exec(
-          text,
-        );
+        /^UPDATE\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s+SET\s+(.+?)\s+WHERE\s+(.+)\s*$/i.exec(text);
       if (updateSet) {
         const table = getTable(parseIdent(updateSet[1]!));
         const setParts = updateSet[2]!.split(",").map((p) => p.trim());
@@ -237,9 +226,7 @@ function createMemorySqlConnection(role: "primary" | "replica"): SqlConnection {
         });
         const preds = parseWherePredicates(updateSet[3]!);
         const row = table.rows.find((r) =>
-          preds.every((p, i) =>
-            compareRow(r[p.column], params[setCols.length + i], p.op),
-          ),
+          preds.every((p, i) => compareRow(r[p.column], params[setCols.length + i], p.op)),
         );
         if (!row) return { changes: 0 };
         setCols.forEach((col, i) => {
@@ -275,23 +262,15 @@ interface WherePred {
 /** Parse `col = ? AND col2 < ?` into ordered predicates. */
 function parseWherePredicates(clause: string): WherePred[] {
   return clause.split(/\s+AND\s+/i).map((part) => {
-    const m =
-      /^("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s*(=|<=|>=|<>|!=|<|>)\s*\?$/.exec(
-        part.trim(),
-      );
+    const m = /^("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s*(=|<=|>=|<>|!=|<|>)\s*\?$/.exec(part.trim());
     if (!m) throw new Error(`memory sql: unsupported WHERE: ${clause}`);
     const opRaw = m[2]!;
-    const op: WherePred["op"] =
-      opRaw === "<>" ? "!=" : (opRaw as WherePred["op"]);
+    const op: WherePred["op"] = opRaw === "<>" ? "!=" : (opRaw as WherePred["op"]);
     return { column: m[1]!.replaceAll('"', "").trim(), op };
   });
 }
 
-function compareRow(
-  cell: unknown,
-  want: unknown,
-  op: WherePred["op"],
-): boolean {
+function compareRow(cell: unknown, want: unknown, op: WherePred["op"]): boolean {
   if (op === "=") return cell === want;
   if (op === "!=") return cell !== want;
   const a = Number(cell ?? 0);
@@ -382,8 +361,7 @@ export const memoryFilesDriver: FilesDriver = {
     return {
       driverId: "memory",
       async put(key, data) {
-        const bytes =
-          typeof data === "string" ? new TextEncoder().encode(data) : data;
+        const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
         objects.set(prefix + key, bytes);
       },
       async get(key) {
@@ -425,17 +403,12 @@ export const memoryIndexDriver: IndexDriver = {
   id: "memory",
   facet: "index",
   async open(options: IndexOpenOptions): Promise<IndexStore> {
-    const docs = new Map<
-      string,
-      { vector: number[]; meta?: Record<string, unknown> }
-    >();
+    const docs = new Map<string, { vector: number[]; meta?: Record<string, unknown> }>();
     return {
       driverId: "memory",
       async upsert(id, vector, meta) {
         if (vector.length !== options.dims) {
-          throw new Error(
-            `vector dims ${vector.length} !== index dims ${options.dims}`,
-          );
+          throw new Error(`vector dims ${vector.length} !== index dims ${options.dims}`);
         }
         docs.set(id, { vector: [...vector], meta });
       },

package/src/drivers/pgvector.ts

@@ -18,9 +18,7 @@ import type {
  *
  * @param options - Name / dims / SQL connection
  */
-export async function openPgvectorIndex(
-  options: IndexOpenOptions,
-): Promise<IndexStore> {
+export async function openPgvectorIndex(options: IndexOpenOptions): Promise<IndexStore> {
   if (options.sql) {
     return openPgvectorSql(options.name, options.dims, options.sql);
   }
@@ -45,10 +43,11 @@ async function openPgvectorSql(
         throw new Error(`vector dims ${vector.length} !== index dims ${dims}`);
       }
       await sql.exec(`DELETE FROM "${table}" WHERE id = ?`, [id]);
-      await sql.exec(
-        `INSERT INTO "${table}" (id, embedding, meta) VALUES (?, ?, ?)`,
-        [id, JSON.stringify(vector), meta ? JSON.stringify(meta) : null],
-      );
+      await sql.exec(`INSERT INTO "${table}" (id, embedding, meta) VALUES (?, ?, ?)`, [
+        id,
+        JSON.stringify(vector),
+        meta ? JSON.stringify(meta) : null,
+      ]);
     },
     async search(vector, topK = 10): Promise<IndexHit[]> {
       const rows = await sql.query(`SELECT id, embedding, meta FROM "${table}"`);
@@ -78,10 +77,7 @@ async function openPgvectorSql(
 }
 
 function openPgvectorMemory(dims: number): IndexStore {
-  const docs = new Map<
-    string,
-    { vector: number[]; meta?: Record<string, unknown> }
-  >();
+  const docs = new Map<string, { vector: number[]; meta?: Record<string, unknown> }>();
   return {
     driverId: "pgvector",
     async upsert(id, vector, meta) {

package/src/drivers/postgres.ts

@@ -4,16 +4,14 @@
  * Protocol-named: Neon, Supabase, RDS, Timescale all speak postgres.
  */
 
-import type {
-  SqlConnectOptions,
-  SqlConnection,
-  SqlDriver,
-  SqlRow,
-} from "./types.ts";
+import type { SqlConnectOptions, SqlConnection, SqlDriver, SqlRow } from "./types.ts";
 
 /** Minimal surface we use from Bun.SQL (and test fakes). */
 export interface PostgresClientLike {
-  unsafe(sql: string, values?: unknown[]): PromiseLike<SqlRow[] | { length: number; changes?: number } | SqlRow[]>;
+  unsafe(
+    sql: string,
+    values?: unknown[],
+  ): PromiseLike<SqlRow[] | { length: number; changes?: number } | SqlRow[]>;
   close?(options?: { timeout?: number }): Promise<void>;
 }
 
@@ -32,9 +30,7 @@ export function toPostgresParams(sql: string): string {
  *
  * @param options - URL / role / injected client
  */
-export async function connectPostgres(
-  options: SqlConnectOptions = {},
-): Promise<SqlConnection> {
+export async function connectPostgres(options: SqlConnectOptions = {}): Promise<SqlConnection> {
   const role = options.role ?? "primary";
   const client =
     (options.client as PostgresClientLike | undefined) ??
@@ -121,9 +117,7 @@ export function createPostgresFakeClient(): PostgresClientLike & {
       if (exists) {
         const rows = tables.get(parseIdent(exists[2]!)) ?? [];
         const preds = parseEqualityWhere(exists[3]!);
-        const hit = rows.some((r) =>
-          preds.every((p, i) => r[p] === values[i]),
-        );
+        const hit = rows.some((r) => preds.every((p, i) => r[p] === values[i]));
         return hit ? [{ [parseIdent(exists[1]!)]: 1 }] : [];
       }