connection: rewrote query execution, batching, added generic sqlite, added node/bun sqlite, aligned repo/mutator results

app/src/adapter/bun/connection/BunSqliteConnection.spec.ts

@@ -0,0 +1,12 @@
+import { connectionTestSuite } from "data/connection/connection-test-suite";
+import { bunSqlite } from "./BunSqliteConnection";
+import { bunTestRunner } from "adapter/bun/test";
+import { describe } from "bun:test";
+import { Database } from "bun:sqlite";
+
+describe("BunSqliteConnection", () => {
+   connectionTestSuite(bunTestRunner, {
+      makeConnection: () => bunSqlite({ database: new Database(":memory:") }),
+      rawDialectDetails: [],
+   });
+});

app/src/adapter/bun/connection/BunSqliteConnection.ts

@@ -0,0 +1,41 @@
+import type { Database } from "bun:sqlite";
+import {
+   buildQueryFn,
+   GenericSqliteConnection,
+   parseBigInt,
+   type IGenericSqlite,
+} from "data/connection/sqlite/GenericSqliteConnection";
+
+export type BunSqliteConnectionConfig = {
+   database: Database;
+};
+
+function bunSqliteExecutor(db: Database, cache: boolean): IGenericSqlite<Database> {
+   const fn = cache ? "query" : "prepare";
+   const getStmt = (sql: string) => db[fn](sql);
+
+   return {
+      db,
+      query: buildQueryFn({
+         all: (sql, parameters) => getStmt(sql).all(...(parameters || [])),
+         run: (sql, parameters) => {
+            const { changes, lastInsertRowid } = getStmt(sql).run(...(parameters || []));
+            return {
+               insertId: parseBigInt(lastInsertRowid),
+               numAffectedRows: parseBigInt(changes),
+            };
+         },
+      }),
+      close: () => db.close(),
+   };
+}
+
+export function bunSqlite(config: BunSqliteConnectionConfig) {
+   return new GenericSqliteConnection(
+      config.database,
+      () => bunSqliteExecutor(config.database, false),
+      {
+         name: "bun-sqlite",
+      },
+   );
+}

app/src/adapter/bun/test.ts

@@ -1,6 +1,7 @@
-import { expect, test, mock } from "bun:test";
+import { expect, test, mock, describe } from "bun:test";
 
 export const bunTestRunner = {
+   describe,
    expect,
    test,
    mock,

app/src/adapter/cloudflare/connection/D1Connection.ts

@@ -1,65 +1,42 @@
 /// <reference types="@cloudflare/workers-types" />
 
-import { KyselyPluginRunner, SqliteConnection, SqliteIntrospector } from "bknd/data";
-import type { QB } from "data/connection/Connection";
-import { type DatabaseIntrospector, Kysely, ParseJSONResultsPlugin } from "kysely";
+import { SqliteConnection } from "bknd/data";
+import type { ConnQuery, ConnQueryResults } from "data/connection/Connection";
 import { D1Dialect } from "kysely-d1";
 
 export type D1ConnectionConfig<DB extends D1Database | D1DatabaseSession = D1Database> = {
    binding: DB;
 };
 
-class CustomD1Dialect extends D1Dialect {
-   override createIntrospector(db: Kysely<any>): DatabaseIntrospector {
-      return new SqliteIntrospector(db, {
-         excludeTables: ["_cf_KV", "_cf_METADATA"],
-      });
-   }
-}
-
 export class D1Connection<
    DB extends D1Database | D1DatabaseSession = D1Database,
-> extends SqliteConnection {
+> extends SqliteConnection<DB> {
+   override name = "sqlite-d1";
+
    protected override readonly supported = {
       batching: true,
+      softscans: false,
    };
 
    constructor(private config: D1ConnectionConfig<DB>) {
-      const plugins = [new ParseJSONResultsPlugin()];
-
-      const kysely = new Kysely({
-         dialect: new CustomD1Dialect({ database: config.binding as D1Database }),
-         plugins,
+      super({
+         excludeTables: ["_cf_KV", "_cf_METADATA"],
+         dialect: D1Dialect,
+         dialectArgs: [{ database: config.binding as D1Database }],
       });
-      super(kysely, {}, plugins);
    }
 
-   get client(): DB {
-      return this.config.binding;
-   }
+   override async executeQueries<O extends ConnQuery[]>(...qbs: O): Promise<ConnQueryResults<O>> {
+      const compiled = this.getCompiled(...qbs);
 
-   protected override async batch<Queries extends QB[]>(
-      queries: [...Queries],
-   ): Promise<{
-      [K in keyof Queries]: Awaited<ReturnType<Queries[K]["execute"]>>;
-   }> {
       const db = this.config.binding;
 
       const res = await db.batch(
-         queries.map((q) => {
-            const { sql, parameters } = q.compile();
+         compiled.map(({ sql, parameters }) => {
             return db.prepare(sql).bind(...parameters);
          }),
       );
 
-      // let it run through plugins
-      const kyselyPlugins = new KyselyPluginRunner(this.plugins);
-      const data: any = [];
-      for (const r of res) {
-         const rows = await kyselyPlugins.transformResultRows(r.results);
-         data.push(rows);
-      }
-
-      return data;
+      return this.withTransformedRows(res, "results") as any;
    }
 }

app/src/adapter/node/connection/NodeSqliteConnection.ts

@@ -0,0 +1,46 @@
+import {
+   buildQueryFn,
+   GenericSqliteConnection,
+   parseBigInt,
+   type IGenericSqlite,
+} from "../../../data/connection/sqlite/GenericSqliteConnection";
+import type { DatabaseSync } from "node:sqlite";
+
+export type NodeSqliteConnectionConfig = {
+   database: DatabaseSync;
+};
+
+function nodeSqliteExecutor(db: DatabaseSync): IGenericSqlite<DatabaseSync> {
+   const getStmt = (sql: string) => {
+      const stmt = db.prepare(sql);
+      //stmt.setReadBigInts(true);
+      return stmt;
+   };
+
+   return {
+      db,
+      query: buildQueryFn({
+         all: (sql, parameters = []) => getStmt(sql).all(...parameters),
+         run: (sql, parameters = []) => {
+            const { changes, lastInsertRowid } = getStmt(sql).run(...parameters);
+            return {
+               insertId: parseBigInt(lastInsertRowid),
+               numAffectedRows: parseBigInt(changes),
+            };
+         },
+      }),
+      close: () => db.close(),
+      iterator: (isSelect, sql, parameters = []) => {
+         if (!isSelect) {
+            throw new Error("Only support select in stream()");
+         }
+         return getStmt(sql).iterate(...parameters) as any;
+      },
+   };
+}
+
+export function nodeSqlite(config: NodeSqliteConnectionConfig) {
+   return new GenericSqliteConnection(config.database, () => nodeSqliteExecutor(config.database), {
+      name: "node-sqlite",
+   });
+}

app/src/adapter/node/connection/NodeSqliteConnection.vi-test.ts

@@ -0,0 +1,11 @@
+import { nodeSqlite } from "./NodeSqliteConnection";
+import { DatabaseSync } from "node:sqlite";
+import { connectionTestSuite } from "data/connection/connection-test-suite";
+import { describe, test, expect } from "vitest";
+
+describe("NodeSqliteConnection", () => {
+   connectionTestSuite({ describe, test, expect } as any, {
+      makeConnection: () => nodeSqlite({ database: new DatabaseSync(":memory:") }),
+      rawDialectDetails: [],
+   });
+});

app/src/adapter/node/node.adapter.vi-test.ts

@@ -1,14 +1,14 @@
-import { describe, before, after } from "node:test";
+import { describe, beforeAll, afterAll } from "vitest";
 import * as node from "./node.adapter";
 import { adapterTestSuite } from "adapter/adapter-test-suite";
-import { nodeTestRunner } from "adapter/node/test";
+import { viTestRunner } from "adapter/node/vitest";
 import { disableConsoleLog, enableConsoleLog } from "core/utils";
 
-before(() => disableConsoleLog());
-after(enableConsoleLog);
+beforeAll(() => disableConsoleLog());
+afterAll(enableConsoleLog);
 
 describe("node adapter", () => {
-   adapterTestSuite(nodeTestRunner, {
+   adapterTestSuite(viTestRunner, {
       makeApp: node.createApp,
       makeHandler: node.createHandler,
    });

app/src/adapter/node/test.ts

@@ -1,5 +1,5 @@
 import nodeAssert from "node:assert/strict";
-import { test } from "node:test";
+import { test, describe } from "node:test";
 import type { Matcher, Test, TestFn, TestRunner } from "core/test";
 
 // Track mock function calls
@@ -85,6 +85,7 @@ nodeTest.skipIf = (condition: boolean): Test => {
 };
 
 export const nodeTestRunner: TestRunner = {
+   describe,
    test: nodeTest,
    mock: createMockFunction,
    expect: <T = unknown>(actual?: T, failMsg?: string) => ({

app/src/adapter/node/vitest.ts

@@ -0,0 +1,50 @@
+import type { TestFn, TestRunner, Test } from "core/test";
+import { describe, test, expect, vi } from "vitest";
+
+function vitestTest(label: string, fn: TestFn, options?: any) {
+   return test(label, fn as any);
+}
+vitestTest.if = (condition: boolean): Test => {
+   if (condition) {
+      return vitestTest;
+   }
+   return (() => {}) as any;
+};
+vitestTest.skip = (label: string, fn: TestFn) => {
+   return test.skip(label, fn as any);
+};
+vitestTest.skipIf = (condition: boolean): Test => {
+   if (condition) {
+      return (() => {}) as any;
+   }
+   return vitestTest;
+};
+
+const vitestExpect = <T = unknown>(actual: T, parentFailMsg?: string) => {
+   return {
+      toEqual: (expected: T, failMsg = parentFailMsg) => {
+         expect(actual, failMsg).toEqual(expected);
+      },
+      toBe: (expected: T, failMsg = parentFailMsg) => {
+         expect(actual, failMsg).toBe(expected);
+      },
+      toBeString: () => expect(typeof actual, parentFailMsg).toBe("string"),
+      toBeUndefined: () => expect(actual, parentFailMsg).toBeUndefined(),
+      toBeDefined: () => expect(actual, parentFailMsg).toBeDefined(),
+      toBeOneOf: (expected: T | Array<T> | Iterable<T>, failMsg = parentFailMsg) => {
+         const e = Array.isArray(expected) ? expected : [expected];
+         expect(actual, failMsg).toBeOneOf(e);
+      },
+      toHaveBeenCalled: () => expect(actual, parentFailMsg).toHaveBeenCalled(),
+      toHaveBeenCalledTimes: (expected: number, failMsg = parentFailMsg) => {
+         expect(actual, failMsg).toHaveBeenCalledTimes(expected);
+      },
+   };
+};
+
+export const viTestRunner: TestRunner = {
+   describe,
+   test: vitestTest,
+   expect: vitestExpect as any,
+   mock: (fn) => vi.fn(fn),
+};