rewrite libsql and cloudflare sqlite's to use the generic adapter

app/src/data/connection/connection-test-suite.ts

@@ -1,5 +1,9 @@
 import type { TestRunner } from "core/test";
 import { Connection, type FieldSpec } from "./Connection";
+import { getPath } from "core/utils";
+import * as proto from "data/prototype";
+import { createApp } from "App";
+import type { MaybePromise } from "core/types";
 
 // @todo: add various datatypes: string, number, boolean, object, array, null, undefined, date, etc.
 // @todo: add toDriver/fromDriver tests on all types and fields
@@ -10,77 +14,92 @@ export function connectionTestSuite(
       makeConnection,
       rawDialectDetails,
    }: {
-      makeConnection: () => Connection;
+      makeConnection: () => MaybePromise<{
+         connection: Connection;
+         dispose: () => MaybePromise<void>;
+      }>;
       rawDialectDetails: string[];
    },
 ) {
-   const { test, expect, describe } = testRunner;
+   const { test, expect, describe, beforeEach, afterEach, afterAll } = testRunner;
 
-   test("pings", async () => {
-      const connection = makeConnection();
-      const res = await connection.ping();
-      expect(res).toBe(true);
-   });
+   describe("base", () => {
+      let ctx: Awaited<ReturnType<typeof makeConnection>>;
+      beforeEach(async () => {
+         ctx = await makeConnection();
+      });
+      afterEach(async () => {
+         await ctx.dispose();
+      });
 
-   test("initializes", async () => {
-      const connection = makeConnection();
-      await connection.init();
-      // @ts-expect-error
-      expect(connection.initialized).toBe(true);
-      expect(connection.client).toBeDefined();
-   });
+      test("pings", async () => {
+         const res = await ctx.connection.ping();
+         expect(res).toBe(true);
+      });
 
-   test("isConnection", async () => {
-      const connection = makeConnection();
-      expect(Connection.isConnection(connection)).toBe(true);
-   });
-
-   test("getFieldSchema", async () => {
-      const c = makeConnection();
-      const specToNode = (spec: FieldSpec) => {
+      test("initializes", async () => {
+         await ctx.connection.init();
          // @ts-expect-error
-         const schema = c.kysely.schema.createTable("test").addColumn(...c.getFieldSchema(spec));
-         return schema.toOperationNode();
-      };
+         expect(ctx.connection.initialized).toBe(true);
+         expect(ctx.connection.client).toBeDefined();
+      });
 
-      {
-         // primary
-         const node = specToNode({
-            type: "integer",
-            name: "id",
-            primary: true,
-         });
-         const col = node.columns[0]!;
-         expect(col.primaryKey).toBe(true);
-         expect(col.notNull).toBe(true);
-      }
+      test("isConnection", async () => {
+         expect(Connection.isConnection(ctx.connection)).toBe(true);
+      });
 
-      {
-         // normal
-         const node = specToNode({
-            type: "text",
-            name: "text",
-         });
-         const col = node.columns[0]!;
-         expect(!col.primaryKey).toBe(true);
-         expect(!col.notNull).toBe(true);
-      }
+      test("getFieldSchema", async () => {
+         const specToNode = (spec: FieldSpec) => {
+            const schema = ctx.connection.kysely.schema
+               .createTable("test")
+               // @ts-expect-error
+               .addColumn(...ctx.connection.getFieldSchema(spec));
+            return schema.toOperationNode();
+         };
 
-      {
-         // nullable (expect to be same as normal)
-         const node = specToNode({
-            type: "text",
-            name: "text",
-            nullable: true,
-         });
-         const col = node.columns[0]!;
-         expect(!col.primaryKey).toBe(true);
-         expect(!col.notNull).toBe(true);
-      }
+         {
+            // primary
+            const node = specToNode({
+               type: "integer",
+               name: "id",
+               primary: true,
+            });
+            const col = node.columns[0]!;
+            expect(col.primaryKey).toBe(true);
+            expect(col.notNull).toBe(true);
+         }
+
+         {
+            // normal
+            const node = specToNode({
+               type: "text",
+               name: "text",
+            });
+            const col = node.columns[0]!;
+            expect(!col.primaryKey).toBe(true);
+            expect(!col.notNull).toBe(true);
+         }
+
+         {
+            // nullable (expect to be same as normal)
+            const node = specToNode({
+               type: "text",
+               name: "text",
+               nullable: true,
+            });
+            const col = node.columns[0]!;
+            expect(!col.primaryKey).toBe(true);
+            expect(!col.notNull).toBe(true);
+         }
+      });
    });
 
    describe("schema", async () => {
-      const connection = makeConnection();
+      const { connection, dispose } = await makeConnection();
+      afterAll(async () => {
+         await dispose();
+      });
+
       const fields = [
          {
             type: "integer",
@@ -118,14 +137,16 @@ export function connectionTestSuite(
          const qb = connection.kysely.selectFrom("test").selectAll();
          const res = await connection.executeQuery(qb);
          expect(res.rows).toEqual([expected]);
-         expect(rawDialectDetails.every((detail) => detail in res)).toBe(true);
+         expect(rawDialectDetails.every((detail) => getPath(res, detail) !== undefined)).toBe(true);
 
          {
             const res = await connection.executeQueries(qb, qb);
             expect(res.length).toBe(2);
             res.map((r) => {
                expect(r.rows).toEqual([expected]);
-               expect(rawDialectDetails.every((detail) => detail in r)).toBe(true);
+               expect(rawDialectDetails.every((detail) => getPath(r, detail) !== undefined)).toBe(
+                  true,
+               );
             });
          }
       });
@@ -187,4 +208,146 @@ export function connectionTestSuite(
          },
       ]);
    });
+
+   describe("integration", async () => {
+      let ctx: Awaited<ReturnType<typeof makeConnection>>;
+      beforeEach(async () => {
+         ctx = await makeConnection();
+      });
+      afterEach(async () => {
+         await ctx.dispose();
+      });
+
+      test("should create app and ping", async () => {
+         const app = createApp({
+            connection: ctx.connection,
+         });
+         await app.build();
+
+         expect(app.version()).toBeDefined();
+         expect(await app.em.ping()).toBe(true);
+      });
+
+      test("should create a basic schema", async () => {
+         const schema = proto.em(
+            {
+               posts: proto.entity("posts", {
+                  title: proto.text().required(),
+                  content: proto.text(),
+               }),
+               comments: proto.entity("comments", {
+                  content: proto.text(),
+               }),
+            },
+            (fns, s) => {
+               fns.relation(s.comments).manyToOne(s.posts);
+               fns.index(s.posts).on(["title"], true);
+            },
+         );
+
+         const app = createApp({
+            connection: ctx.connection,
+            initialConfig: {
+               data: schema.toJSON(),
+            },
+         });
+
+         await app.build();
+
+         expect(app.em.entities.length).toBe(2);
+         expect(app.em.entities.map((e) => e.name)).toEqual(["posts", "comments"]);
+
+         const api = app.getApi();
+
+         expect(
+            (
+               await api.data.createMany("posts", [
+                  {
+                     title: "Hello",
+                     content: "World",
+                  },
+                  {
+                     title: "Hello 2",
+                     content: "World 2",
+                  },
+               ])
+            ).data,
+         ).toEqual([
+            {
+               id: 1,
+               title: "Hello",
+               content: "World",
+            },
+            {
+               id: 2,
+               title: "Hello 2",
+               content: "World 2",
+            },
+         ] as any);
+
+         // try to create an existing
+         expect(
+            (
+               await api.data.createOne("posts", {
+                  title: "Hello",
+               })
+            ).ok,
+         ).toBe(false);
+
+         // add a comment to a post
+         await api.data.createOne("comments", {
+            content: "Hello",
+            posts_id: 1,
+         });
+
+         // and then query using a `with` property
+         const result = await api.data.readMany("posts", { with: ["comments"] });
+         expect(result.length).toBe(2);
+         expect(result[0]?.comments?.length).toBe(1);
+         expect(result[0]?.comments?.[0]?.content).toBe("Hello");
+         expect(result[1]?.comments?.length).toBe(0);
+      });
+
+      test("should support uuid", async () => {
+         const schema = proto.em(
+            {
+               posts: proto.entity(
+                  "posts",
+                  {
+                     title: proto.text().required(),
+                     content: proto.text(),
+                  },
+                  {
+                     primary_format: "uuid",
+                  },
+               ),
+               comments: proto.entity("comments", {
+                  content: proto.text(),
+               }),
+            },
+            (fns, s) => {
+               fns.relation(s.comments).manyToOne(s.posts);
+               fns.index(s.posts).on(["title"], true);
+            },
+         );
+
+         const app = createApp({
+            connection: ctx.connection,
+            initialConfig: {
+               data: schema.toJSON(),
+            },
+         });
+
+         await app.build();
+         const config = app.toJSON();
+         // @ts-expect-error
+         expect(config.data.entities?.posts.fields?.id.config?.format).toBe("uuid");
+
+         const em = app.em;
+         const mutator = em.mutator(em.entity("posts"));
+         const data = await mutator.insertOne({ title: "Hello", content: "World" });
+         expect(data.data.id).toBeString();
+         expect(String(data.data.id).length).toBe(36);
+      });
+   });
 }

app/src/data/connection/sqlite/GenericSqliteConnection.ts

@@ -61,7 +61,7 @@ export class GenericSqliteConnection<DB = unknown> extends SqliteConnection<DB>
    override async executeQueries<O extends ConnQuery[]>(...qbs: O): Promise<ConnQueryResults<O>> {
       const executor = await this.getExecutor();
       if (!executor.batch) {
-         console.warn("Batching is not supported by this database");
+         //$console.debug("Batching is not supported by this database");
          return super.executeQueries(...qbs);
       }
 

app/src/data/connection/sqlite/SqliteIntrospector.ts

@@ -68,32 +68,34 @@ export class SqliteIntrospector extends BaseIntrospector {
       return tables.map((table) => ({
          name: table.name,
          isView: table.type === "view",
-         columns: table.columns.map((col) => {
-            const autoIncrementCol = table.sql
-               ?.split(/[\(\),]/)
-               ?.find((it) => it.toLowerCase().includes("autoincrement"))
-               ?.trimStart()
-               ?.split(/\s+/)?.[0]
-               ?.replace(/["`]/g, "");
+         columns:
+            table.columns?.map((col) => {
+               const autoIncrementCol = table.sql
+                  ?.split(/[\(\),]/)
+                  ?.find((it) => it.toLowerCase().includes("autoincrement"))
+                  ?.trimStart()
+                  ?.split(/\s+/)?.[0]
+                  ?.replace(/["`]/g, "");
 
-            return {
-               name: col.name,
-               dataType: col.type,
-               isNullable: !col.notnull,
-               isAutoIncrementing: col.name === autoIncrementCol,
-               hasDefaultValue: col.dflt_value != null,
-               comment: undefined,
-            };
-         }),
-         indices: table.indices.map((index) => ({
-            name: index.name,
-            table: table.name,
-            isUnique: index.sql?.match(/unique/i) != null,
-            columns: index.columns.map((col) => ({
-               name: col.name,
-               order: col.seqno,
-            })),
-         })),
+               return {
+                  name: col.name,
+                  dataType: col.type,
+                  isNullable: !col.notnull,
+                  isAutoIncrementing: col.name === autoIncrementCol,
+                  hasDefaultValue: col.dflt_value != null,
+                  comment: undefined,
+               };
+            }) ?? [],
+         indices:
+            table.indices?.map((index) => ({
+               name: index.name,
+               table: table.name,
+               isUnique: index.sql?.match(/unique/i) != null,
+               columns: index.columns.map((col) => ({
+                  name: col.name,
+                  order: col.seqno,
+               })),
+            })) ?? [],
       }));
    }
 }

app/src/data/connection/sqlite/libsql/LibsqlConnection.spec.ts

@@ -1,12 +1,15 @@
 import { connectionTestSuite } from "../../connection-test-suite";
-import { LibsqlConnection } from "./LibsqlConnection";
+import { libsql } from "./LibsqlConnection";
 import { bunTestRunner } from "adapter/bun/test";
 import { describe } from "bun:test";
 import { createClient } from "@libsql/client";
 
 describe("LibsqlConnection", () => {
    connectionTestSuite(bunTestRunner, {
-      makeConnection: () => new LibsqlConnection(createClient({ url: ":memory:" })),
-      rawDialectDetails: ["rowsAffected", "lastInsertRowid"],
+      makeConnection: () => ({
+         connection: libsql(createClient({ url: ":memory:" })),
+         dispose: async () => {},
+      }),
+      rawDialectDetails: [],
    });
 });

app/src/data/connection/sqlite/libsql/LibsqlConnection.ts

@@ -1,9 +1,13 @@
-import type { Client, Config, InStatement } from "@libsql/client";
+import type { Client, Config, ResultSet } from "@libsql/client";
 import { createClient } from "libsql-stateless-easy";
-import { LibsqlDialect } from "./LibsqlDialect";
 import { FilterNumericKeysPlugin } from "data/plugins/FilterNumericKeysPlugin";
-import { type ConnQuery, type ConnQueryResults, SqliteConnection } from "bknd/data";
+import {
+   genericSqlite,
+   type GenericSqliteConnection,
+} from "data/connection/sqlite/GenericSqliteConnection";
+import type { QueryResult } from "kysely";
 
+export type LibsqlConnection = GenericSqliteConnection<Client>;
 export type LibSqlCredentials = Config;
 
 function getClient(clientOrCredentials: Client | LibSqlCredentials): Client {
@@ -15,39 +19,50 @@ function getClient(clientOrCredentials: Client | LibSqlCredentials): Client {
    return clientOrCredentials as Client;
 }
 
-export class LibsqlConnection extends SqliteConnection<Client> {
-   override name = "libsql";
-   protected override readonly supported = {
-      batching: true,
-      softscans: true,
-   };
+export function libsql(config: LibSqlCredentials | Client) {
+   const db = getClient(config);
 
-   constructor(clientOrCredentials: Client | LibSqlCredentials) {
-      const client = getClient(clientOrCredentials);
-
-      super({
-         excludeTables: ["libsql_wasm_func_table"],
-         dialect: LibsqlDialect,
-         dialectArgs: [{ client }],
-         additionalPlugins: [new FilterNumericKeysPlugin()],
-      });
-
-      this.client = client;
-   }
-
-   override async executeQueries<O extends ConnQuery[]>(...qbs: O): Promise<ConnQueryResults<O>> {
-      const compiled = this.getCompiled(...qbs);
-      const stms: InStatement[] = compiled.map((q) => {
-         return {
-            sql: q.sql,
-            args: q.parameters as any[],
+   return genericSqlite(
+      "libsql",
+      db,
+      (utils) => {
+         const mapResult = (result: ResultSet): QueryResult<any> => ({
+            insertId: result.lastInsertRowid,
+            numAffectedRows: BigInt(result.rowsAffected),
+            rows: result.rows,
+         });
+         const execute = async (sql: string, parameters?: any[] | readonly any[]) => {
+            const result = await db.execute({ sql, args: [...(parameters || [])] });
+            return mapResult(result);
          };
-      });
 
-      return this.withTransformedRows(await this.client.batch(stms)) as any;
-   }
-}
-
-export function libsql(credentials: Client | LibSqlCredentials): LibsqlConnection {
-   return new LibsqlConnection(credentials);
+         return {
+            db,
+            batch: async (stmts) => {
+               const results = await db.batch(
+                  stmts.map(({ sql, parameters }) => ({
+                     sql,
+                     args: parameters as any[],
+                  })),
+               );
+               return results.map(mapResult);
+            },
+            query: utils.buildQueryFn({
+               all: async (sql, parameters) => {
+                  return (await execute(sql, parameters)).rows;
+               },
+               run: execute,
+            }),
+            close: () => db.close(),
+         };
+      },
+      {
+         supports: {
+            batching: true,
+            softscans: true,
+         },
+         additionalPlugins: [new FilterNumericKeysPlugin()],
+         excludeTables: ["libsql_wasm_func_table"],
+      },
+   );
 }

app/src/data/connection/sqlite/libsql/LibsqlDialect.ts

@@ -1,145 +0,0 @@
-import type { Client, Transaction, InValue } from "@libsql/client";
-import {
-   SqliteAdapter,
-   SqliteIntrospector,
-   SqliteQueryCompiler,
-   type Kysely,
-   type Dialect,
-   type DialectAdapter,
-   type Driver,
-   type DatabaseIntrospector,
-   type QueryCompiler,
-   type TransactionSettings,
-   type DatabaseConnection,
-   type QueryResult,
-   type CompiledQuery,
-} from "kysely";
-
-export type LibsqlDialectConfig = {
-   client: Client;
-};
-
-export class LibsqlDialect implements Dialect {
-   #config: LibsqlDialectConfig;
-
-   constructor(config: LibsqlDialectConfig) {
-      this.#config = config;
-   }
-
-   createAdapter(): DialectAdapter {
-      return new SqliteAdapter();
-   }
-
-   createDriver(): Driver {
-      let client: Client;
-      let closeClient: boolean;
-      if ("client" in this.#config) {
-         client = this.#config.client;
-         closeClient = false;
-      } else {
-         throw new Error("Please specify either `client` or `url` in the LibsqlDialect config");
-      }
-
-      return new LibsqlDriver(client, closeClient);
-   }
-
-   createIntrospector(db: Kysely<any>): DatabaseIntrospector {
-      return new SqliteIntrospector(db);
-   }
-
-   createQueryCompiler(): QueryCompiler {
-      return new SqliteQueryCompiler();
-   }
-}
-
-export class LibsqlDriver implements Driver {
-   client: Client;
-   #closeClient: boolean;
-
-   constructor(client: Client, closeClient: boolean) {
-      this.client = client;
-      this.#closeClient = closeClient;
-   }
-
-   async init(): Promise<void> {}
-
-   async acquireConnection(): Promise<LibsqlConnection> {
-      return new LibsqlConnection(this.client);
-   }
-
-   async beginTransaction(
-      connection: LibsqlConnection,
-      _settings: TransactionSettings,
-   ): Promise<void> {
-      await connection.beginTransaction();
-   }
-
-   async commitTransaction(connection: LibsqlConnection): Promise<void> {
-      await connection.commitTransaction();
-   }
-
-   async rollbackTransaction(connection: LibsqlConnection): Promise<void> {
-      await connection.rollbackTransaction();
-   }
-
-   async releaseConnection(_conn: LibsqlConnection): Promise<void> {}
-
-   async destroy(): Promise<void> {
-      if (this.#closeClient) {
-         this.client.close();
-      }
-   }
-}
-
-export class LibsqlConnection implements DatabaseConnection {
-   client: Client;
-   #transaction?: Transaction;
-
-   constructor(client: Client) {
-      this.client = client;
-   }
-
-   async executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>> {
-      const target = this.#transaction ?? this.client;
-      const result = await target.execute({
-         sql: compiledQuery.sql,
-         args: compiledQuery.parameters as Array<InValue>,
-      });
-      return {
-         insertId: result.lastInsertRowid,
-         numAffectedRows: BigInt(result.rowsAffected),
-         rows: result.rows as Array<R>,
-      };
-   }
-
-   async beginTransaction() {
-      if (this.#transaction) {
-         throw new Error("Transaction already in progress");
-      }
-      this.#transaction = await this.client.transaction();
-   }
-
-   async commitTransaction() {
-      if (!this.#transaction) {
-         throw new Error("No transaction to commit");
-      }
-      await this.#transaction.commit();
-      this.#transaction = undefined;
-   }
-
-   async rollbackTransaction() {
-      if (!this.#transaction) {
-         throw new Error("No transaction to rollback");
-      }
-      await this.#transaction.rollback();
-      this.#transaction = undefined;
-   }
-
-   // biome-ignore lint/correctness/useYield: <explanation>
-   async *streamQuery<R>(
-      _compiledQuery: CompiledQuery,
-      _chunkSize: number,
-   ): AsyncIterableIterator<QueryResult<R>> {
-      throw new Error("Libsql Driver does not support streaming yet");
-   }
-}