okengine 0.2.6 → 0.3.2

package/src/drivers/memory.ts

@@ -45,38 +45,47 @@ function createMemorySqlConnection(role: "primary" | "replica"): SqlConnection {
     async query(sql, params = []) {
       const text = sql.trim();
 
+      const countStar =
+        /^SELECT\s+COUNT\(\*\)\s+AS\s+"?[a-zA-Z_][a-zA-Z0-9_]*"?\s+FROM\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s*(?:WHERE\s+(.+?))?\s*$/i.exec(
+          text,
+        );
+      if (countStar) {
+        const table = getTable(parseIdent(countStar[1]!));
+        const whereClause = countStar[2]?.trim();
+        let rows = table.rows;
+        if (whereClause) {
+          const ast = parseWhere(whereClause);
+          rows = rows.filter((r) => evalWhere(ast, r, params, { i: 0 }));
+        }
+        return [{ count: rows.length }];
+      }
+
       const selectGeneric =
-        /^SELECT\s+(.+?)\s+FROM\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s*(?:WHERE\s+(.+?))?(?:\s+ORDER\s+BY\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?))?(?:\s+LIMIT\s+(\d+))?\s*$/i.exec(
+        /^SELECT\s+(.+?)\s+FROM\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s*(?:WHERE\s+(.+?))?(?:\s+ORDER\s+BY\s+(.+?))?(?:\s+LIMIT\s+(\d+))?(?:\s+OFFSET\s+(\d+))?\s*$/i.exec(
           text,
         );
       if (selectGeneric && !/^\s*1\s+AS\s+/i.test(selectGeneric[1]!)) {
         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 orderClause = selectGeneric[4]?.trim();
+        const limit = selectGeneric[5] ? Number(selectGeneric[5]) : undefined;
+        const offset = selectGeneric[6] ? Number(selectGeneric[6]) : undefined;
         let rows = table.rows.map((r) => ({ ...r }));
         if (whereClause) {
-          const preds = parseWherePredicates(whereClause);
-          rows = rows.filter((r) =>
-            preds.every((p, i) => compareRow(r[p.column], params[i], p.op)),
-          );
+          const ast = parseWhere(whereClause);
+          rows = rows.filter((r) => evalWhere(ast, r, params, { i: 0 }));
         }
-        if (orderCol) {
-          rows = [...rows].sort((a, b) =>
-            String(a[orderCol] ?? "").localeCompare(String(b[orderCol] ?? "")),
-          );
+        if (orderClause) {
+          const terms = parseOrderTerms(orderClause);
+          rows = [...rows].sort((a, b) => compareByTerms(a, b, terms));
         }
+        if (offset !== undefined) rows = rows.slice(offset);
         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 +106,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 +222,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());
@@ -235,12 +238,8 @@ function createMemorySqlConnection(role: "primary" | "replica"): SqlConnection {
           if (!m) throw new Error(`memory sql: unsupported SET: ${part}`);
           return parseIdent(m[1]!);
         });
-        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),
-          ),
-        );
+        const ast = parseWhere(updateSet[3]!);
+        const row = table.rows.find((r) => evalWhere(ast, r, params, { i: setCols.length }));
         if (!row) return { changes: 0 };
         setCols.forEach((col, i) => {
           row[col] = params[i];
@@ -256,60 +255,279 @@ function createMemorySqlConnection(role: "primary" | "replica"): SqlConnection {
   };
 }
 
-/** Parse `col = ? AND col2 = ?` into ordered column names. */
+/** One comparison operator for the memory SQL driver. */
+type WhereOp =
+  | "="
+  | "<"
+  | ">"
+  | "<="
+  | ">="
+  | "!="
+  | "like"
+  | "ilike"
+  | "in"
+  | "is null"
+  | "is not null";
+
+/** WHERE condition AST node — leaf comparison or AND/OR group. */
+type WhereNode =
+  | { readonly kind: "cmp"; readonly column: string; readonly op: WhereOp; readonly arity: number }
+  | { readonly kind: "and"; readonly children: readonly WhereNode[] }
+  | { readonly kind: "or"; readonly children: readonly WhereNode[] };
+
+/** One `ORDER BY` term. */
+interface OrderTerm {
+  readonly column: string;
+  readonly direction: "ASC" | "DESC";
+}
+
+/**
+ * Parse a WHERE clause into an AST. Supports parenthesized groups, `AND` /
+ * `OR`, binary comparisons, and `like` / `ilike` — the shapes the store
+ * session compiler emits. Anything else throws.
+ *
+ * @param clause - WHERE text (without the `WHERE` keyword)
+ */
+function parseWhere(clause: string): WhereNode {
+  const tokens = tokenizeWhere(clause);
+  const unsupported = (): Error => new Error(`memory sql: unsupported WHERE: ${clause}`);
+  let pos = 0;
+
+  const peek = (): string | undefined => tokens[pos];
+  const parseLevel = (keyword: "AND" | "OR", down: () => WhereNode): WhereNode => {
+    const first = down();
+    if (peek()?.toUpperCase() !== keyword) return first;
+    const rest: WhereNode[] = [];
+    do {
+      pos++;
+      rest.push(down());
+    } while (peek()?.toUpperCase() === keyword);
+    const children = [first, ...rest];
+    return keyword === "AND" ? { kind: "and", children } : { kind: "or", children };
+  };
+  const parseFactor = (): WhereNode => {
+    if (peek() === "(") {
+      pos++;
+      const node = parseLevel("OR", () => parseLevel("AND", parseFactor));
+      if (peek() !== ")") throw unsupported();
+      pos++;
+      return node;
+    }
+    const colTok = tokens[pos++];
+    const opTok = tokens[pos++];
+    if (colTok === undefined || opTok === undefined) throw unsupported();
+    if (opTok.toLowerCase() === "is") {
+      const second = tokens[pos++]?.toLowerCase();
+      const nullOp =
+        second === "null"
+          ? "is null"
+          : second === "not" && tokens[pos++]?.toLowerCase() === "null"
+            ? "is not null"
+            : undefined;
+      if (nullOp === undefined) throw unsupported();
+      return { kind: "cmp", column: colTok.replaceAll('"', "").trim(), op: nullOp, arity: 0 };
+    }
+    if (opTok.toLowerCase() === "in") {
+      if (peek() !== "(") throw unsupported();
+      pos++;
+      let arity = 0;
+      while (peek() === "?") {
+        arity++;
+        pos++;
+        if (peek() === ",") pos++;
+      }
+      if (arity === 0 || peek() !== ")") throw unsupported();
+      pos++;
+      return { kind: "cmp", column: colTok.replaceAll('"', "").trim(), op: "in", arity };
+    }
+    const paramTok = tokens[pos++];
+    if (paramTok !== "?") throw unsupported();
+    const op = asWhereOp(opTok);
+    if (op === undefined) throw unsupported();
+    return { kind: "cmp", column: colTok.replaceAll('"', "").trim(), op, arity: 1 };
+  };
+
+  const node = parseLevel("OR", () => parseLevel("AND", parseFactor));
+  if (pos !== tokens.length) throw unsupported();
+  return node;
+}
+
+function tokenizeWhere(clause: string): string[] {
+  const out: string[] = [];
+  let i = 0;
+  while (i < clause.length) {
+    const ch = clause[i]!;
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (ch === "(" || ch === ")" || ch === "?" || ch === ",") {
+      out.push(ch);
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      const end = clause.indexOf('"', i + 1);
+      if (end === -1) throw new Error(`memory sql: unsupported WHERE: ${clause}`);
+      out.push(clause.slice(i, end + 1));
+      i = end + 1;
+      continue;
+    }
+    const two = clause.slice(i, i + 2);
+    if (two === "<=" || two === ">=" || two === "<>" || two === "!=") {
+      out.push(two);
+      i += 2;
+      continue;
+    }
+    if (ch === "=" || ch === "<" || ch === ">") {
+      out.push(ch);
+      i++;
+      continue;
+    }
+    const word = /^[a-zA-Z_][a-zA-Z0-9_]*/.exec(clause.slice(i));
+    if (word) {
+      out.push(word[0]);
+      i += word[0].length;
+      continue;
+    }
+    throw new Error(`memory sql: unsupported WHERE: ${clause}`);
+  }
+  return out;
+}
+
+function asWhereOp(token: string): WhereOp | undefined {
+  switch (token.toLowerCase()) {
+    case "=":
+      return "=";
+    case "<":
+      return "<";
+    case ">":
+      return ">";
+    case "<=":
+      return "<=";
+    case ">=":
+      return ">=";
+    case "!=":
+    case "<>":
+      return "!=";
+    case "like":
+      return "like";
+    case "ilike":
+      return "ilike";
+    default:
+      return undefined;
+  }
+}
+
+/** Evaluate a WHERE AST against a row, consuming `?` params in order. */
+function evalWhere(
+  node: WhereNode,
+  row: SqlRow,
+  params: readonly unknown[],
+  state: { i: number },
+): boolean {
+  if (node.kind === "and") {
+    return node.children.every((c) => evalWhere(c, row, params, state));
+  }
+  if (node.kind === "or") {
+    return node.children.some((c) => evalWhere(c, row, params, state));
+  }
+  if (node.op === "is null") {
+    return row[node.column] === null || row[node.column] === undefined;
+  }
+  if (node.op === "is not null") {
+    return row[node.column] !== null && row[node.column] !== undefined;
+  }
+  if (node.op === "in") {
+    const wants = params.slice(state.i, state.i + node.arity);
+    state.i += node.arity;
+    return wants.some((w) => compareRow(row[node.column], w, "="));
+  }
+  const want = params[state.i++];
+  return compareRow(row[node.column], want, node.op);
+}
+
+/** Parse `col = ? AND col2 = ?` into ordered column names (equality-only). */
 function parseEqualityWhere(clause: string): string[] {
-  return parseWherePredicates(clause).map((p) => {
-    if (p.op !== "=") {
+  const node = parseWhere(clause);
+  const cols: string[] = [];
+  const walk = (n: WhereNode): void => {
+    if (n.kind === "and") {
+      n.children.forEach(walk);
+      return;
+    }
+    if (n.kind === "or" || n.op !== "=") {
       throw new Error(`memory sql: unsupported WHERE: ${clause}`);
     }
-    return p.column;
-  });
+    cols.push(n.column);
+  };
+  walk(node);
+  return cols;
 }
 
-/** One WHERE predicate for the memory SQL driver. */
-interface WherePred {
-  readonly column: string;
-  readonly op: "=" | "<" | ">" | "<=" | ">=" | "!=";
+/** Parse `"a" DESC, "b"` into ordered terms (default ASC). */
+function parseOrderTerms(clause: string): OrderTerm[] {
+  return clause.split(",").map((part) => {
+    const m = /^\s*("?[a-zA-Z_][a-zA-Z0-9_]*"?)(?:\s+(ASC|DESC))?\s*$/i.exec(part);
+    if (!m) throw new Error(`memory sql: unsupported ORDER BY: ${clause}`);
+    return {
+      column: m[1]!.replaceAll('"', "").trim(),
+      direction: (m[2]?.toUpperCase() ?? "ASC") as OrderTerm["direction"],
+    };
+  });
 }
 
-/** 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(),
-      );
-    if (!m) throw new Error(`memory sql: unsupported WHERE: ${clause}`);
-    const opRaw = m[2]!;
-    const op: WherePred["op"] =
-      opRaw === "<>" ? "!=" : (opRaw as WherePred["op"]);
-    return { column: m[1]!.replaceAll('"', "").trim(), op };
-  });
+function compareByTerms(a: SqlRow, b: SqlRow, terms: readonly OrderTerm[]): number {
+  for (const term of terms) {
+    const av = a[term.column];
+    const bv = b[term.column];
+    let cmp: number;
+    if (typeof av === "number" && typeof bv === "number") {
+      cmp = av - bv;
+    } else {
+      cmp = String(av ?? "").localeCompare(String(bv ?? ""));
+    }
+    if (cmp !== 0) return term.direction === "DESC" ? -cmp : cmp;
+  }
+  return 0;
 }
 
-function compareRow(
-  cell: unknown,
-  want: unknown,
-  op: WherePred["op"],
-): boolean {
+function compareRow(cell: unknown, want: unknown, op: WhereOp): boolean {
   if (op === "=") return cell === want;
   if (op === "!=") return cell !== want;
-  const a = Number(cell ?? 0);
-  const b = Number(want ?? 0);
+  // sqlite parity: LIKE is case-insensitive for ASCII; ILIKE matches it.
+  if (op === "like" || op === "ilike") return likeMatch(cell, want);
+  let cmp: number;
+  if (typeof cell === "number" && typeof want === "number") {
+    cmp = cell - want;
+  } else if (typeof cell === "string" && typeof want === "string") {
+    cmp = cell.localeCompare(want);
+  } else {
+    cmp = Number(cell ?? 0) - Number(want ?? 0);
+  }
   switch (op) {
     case "<":
-      return a < b;
+      return cmp < 0;
     case ">":
-      return a > b;
+      return cmp > 0;
     case "<=":
-      return a <= b;
+      return cmp <= 0;
     case ">=":
-      return a >= b;
+      return cmp >= 0;
     default:
       return false;
   }
 }
 
+function likeMatch(cell: unknown, pattern: unknown): boolean {
+  const text = String(cell ?? "");
+  const source = String(pattern ?? "")
+    .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+    .replace(/%/g, ".*")
+    .replace(/_/g, ".");
+  return new RegExp(`^${source}$`, "i").test(text);
+}
+
 /** Memory SQL driver. */
 export const memorySqlDriver: SqlDriver = {
   id: "memory",
@@ -382,8 +600,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 +642,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 }] : [];
       }
 

package/src/drivers/redis.ts

@@ -5,24 +5,15 @@
  */
 
 import { LuaKvStore } from "./kv-lua.ts";
-import type {
-  KvClientLike,
-  KvDriver,
-  KvNamespace,
-  KvOpenOptions,
-} from "./types.ts";
+import type { KvClientLike, KvDriver, KvNamespace, KvOpenOptions } from "./types.ts";
 
 /**
  * Open a KV namespace over the redis protocol.
  *
  * @param options - Name / URL / injected client
  */
-export async function openRedisKv(
-  options: KvOpenOptions,
-): Promise<KvNamespace> {
-  const client: KvClientLike =
-    options.client ??
-    createBunRedisClient(options.url);
+export async function openRedisKv(options: KvOpenOptions): Promise<KvNamespace> {
+  const client: KvClientLike = options.client ?? createBunRedisClient(options.url);
 
   const prefix = `oke:kv:${options.name}:`;
 
@@ -39,8 +30,7 @@ export async function openRedisKv(
     },
     async set(key, value, ttl) {
       const payload = JSON.stringify(value);
-      const ex =
-        ttl !== undefined ? Math.max(1, Math.ceil(ttlToSeconds(ttl))) : undefined;
+      const ex = ttl !== undefined ? Math.max(1, Math.ceil(ttlToSeconds(ttl))) : undefined;
       if (ex !== undefined) {
         await client.set(prefix + key, payload, { ex });
       } else {
@@ -70,11 +60,7 @@ export async function openRedisKv(
         return (await client.eval(script, prefixed.length, ...keysAndArgs)) as T;
       }
       if (client.send) {
-        return (await client.send("EVAL", [
-          script,
-          String(prefixed.length),
-          ...keysAndArgs,
-        ])) as T;
+        return (await client.send("EVAL", [script, String(prefixed.length), ...keysAndArgs])) as T;
       }
       throw new Error("redis kv.eval: client lacks eval/send");
     },
@@ -90,10 +76,7 @@ export async function openRedisKv(
  * @param client - Redis-like client
  * @param match - MATCH pattern
  */
-async function scanAll(
-  client: KvClientLike,
-  match: string,
-): Promise<string[]> {
+async function scanAll(client: KvClientLike, match: string): Promise<string[]> {
   if (client.scan) {
     const out: string[] = [];
     let cursor = "0";
@@ -111,13 +94,10 @@ async function scanAll(
     const out: string[] = [];
     let cursor = "0";
     do {
-      const reply = (await client.send("SCAN", [
-        cursor,
-        "MATCH",
-        match,
-        "COUNT",
-        "100",
-      ])) as [string, string[]];
+      const reply = (await client.send("SCAN", [cursor, "MATCH", match, "COUNT", "100"])) as [
+        string,
+        string[],
+      ];
       const next = String(reply[0]);
       const batch = reply[1] ?? [];
       out.push(...batch);
@@ -125,9 +105,7 @@ async function scanAll(
     } while (cursor !== "0");
     return out;
   }
-  throw new Error(
-    "redis kv.list: client lacks SCAN — key browse refused rather than KEYS *",
-  );
+  throw new Error("redis kv.list: client lacks SCAN — key browse refused rather than KEYS *");
 }
 
 function ttlToSeconds(ttl: string): number {
@@ -159,8 +137,7 @@ function ttlToSeconds(ttl: string): number {
  * @param url - Optional Redis URL
  */
 export function createBunRedisClient(url?: string): KvClientLike {
-  const redis =
-    url !== undefined ? new Bun.RedisClient(url) : Bun.redis;
+  const redis = url !== undefined ? new Bun.RedisClient(url) : Bun.redis;
 
   return {
     get: (key) => redis.get(key),
@@ -224,8 +201,7 @@ export function createRedisFakeClient(nowMs?: () => number): KvClientLike & {
     },
     async scan(cursor, opts) {
       const match = opts?.match ?? "*";
-      const prefix =
-        match.endsWith("*") ? match.slice(0, -1) : match;
+      const prefix = match.endsWith("*") ? match.slice(0, -1) : match;
       const all = [...data.keys()].filter((k) =>
         match.endsWith("*") ? k.startsWith(prefix) : k === match,
       );