@fragno-dev/db 0.2.1 → 0.3.0

package/src/adapters/generic-sql/query/sql-query-compiler.ts

@@ -11,7 +11,8 @@ import type { SqlBool } from "kysely";
 import type { AnyColumn, AnyTable } from "../../../schema/create";
 import type { Condition } from "../../../query/condition-builder";
 import type { DriverConfig, SupportedDatabase } from "../driver-config";
-import type { TableNameMapper } from "../../shared/table-name-mapper";
+import type { SQLiteStorageMode } from "../sqlite-storage";
+import type { NamingResolver } from "../../../naming/sql-naming";
 import { buildWhere, fullSQLName } from "./where-builder";
 import { mapSelect, extendSelect } from "./select-builder";
 import type { CompiledJoin } from "../../../query/orm/orm";
@@ -97,15 +98,22 @@ export abstract class SQLQueryCompiler {
   protected readonly db: AnyKysely;
   protected readonly driverConfig: DriverConfig;
   protected readonly database: SupportedDatabase;
-  protected readonly mapper?: TableNameMapper;
+  protected readonly resolver?: NamingResolver;
   protected readonly encoder: UnitOfWorkEncoder;
-
-  constructor(db: AnyKysely, driverConfig: DriverConfig, mapper?: TableNameMapper) {
+  protected readonly sqliteStorageMode?: SQLiteStorageMode;
+
+  constructor(
+    db: AnyKysely,
+    driverConfig: DriverConfig,
+    sqliteStorageMode?: SQLiteStorageMode,
+    resolver?: NamingResolver,
+  ) {
     this.db = db;
     this.driverConfig = driverConfig;
     this.database = driverConfig.databaseType;
-    this.mapper = mapper;
-    this.encoder = new UnitOfWorkEncoder(driverConfig, db, mapper);
+    this.resolver = resolver;
+    this.sqliteStorageMode = sqliteStorageMode;
+    this.encoder = new UnitOfWorkEncoder(driverConfig, db, sqliteStorageMode, resolver);
   }
 
   /**
@@ -133,14 +141,21 @@ export abstract class SQLQueryCompiler {
    * Get the physical table name, applying namespace mapping if provided.
    */
   protected getTableName(table: AnyTable): string {
-    return this.mapper ? this.mapper.toPhysical(table.name) : table.name;
+    return this.resolver ? this.resolver.getTableName(table.name) : table.name;
   }
 
   /**
    * Build WHERE clause from a condition tree.
    */
   protected buildWhereClause(condition: Condition, eb: AnyExpressionBuilder, table: AnyTable) {
-    return buildWhere(condition, eb, this.driverConfig, this.mapper, table);
+    return buildWhere(
+      condition,
+      eb,
+      this.driverConfig,
+      this.sqliteStorageMode,
+      this.resolver,
+      table,
+    );
   }
 
   /**
@@ -171,7 +186,7 @@ export abstract class SQLQueryCompiler {
 
       // Update select
       mappedSelect.push(
-        ...mapSelect(joinOptions.select, targetTable, {
+        ...mapSelect(joinOptions.select, targetTable, this.resolver, {
           relation: fullPath, // Use full path with colons for column aliases
           tableName: joinName, // Use underscore version for table name
         }),
@@ -188,9 +203,22 @@ export abstract class SQLQueryCompiler {
 
             conditions.push(
               eb(
-                `${parentTableName}.${parentTable.columns[left].name}`,
+                `${parentTableName}.${
+                  this.resolver
+                    ? this.resolver.getColumnName(parentTable.name, parentTable.columns[left].name)
+                    : parentTable.columns[left].name
+                }`,
                 "=",
-                eb.ref(`${joinName}.${targetTable.columns[actualRight].name}`),
+                eb.ref(
+                  `${joinName}.${
+                    this.resolver
+                      ? this.resolver.getColumnName(
+                          targetTable.name,
+                          targetTable.columns[actualRight].name,
+                        )
+                      : targetTable.columns[actualRight].name
+                  }`,
+                ),
               ),
             );
           }
@@ -259,7 +287,7 @@ export abstract class SQLQueryCompiler {
     // Apply ORDER BY
     if (options.orderBy) {
       for (const [col, mode] of options.orderBy) {
-        query = query.orderBy(fullSQLName(col, this.mapper), mode);
+        query = query.orderBy(fullSQLName(col, this.resolver), mode);
       }
     }
 
@@ -274,7 +302,9 @@ export abstract class SQLQueryCompiler {
 
     const compiledSelect = selectBuilder.compile();
     mappedSelect.push(
-      ...mapSelect(compiledSelect.result, table, { tableName: this.getTableName(table) }),
+      ...mapSelect(compiledSelect.result, table, this.resolver, {
+        tableName: this.getTableName(table),
+      }),
     );
 
     return query.select(mappedSelect).compile();
@@ -297,7 +327,9 @@ export abstract class SQLQueryCompiler {
 
     // Apply RETURNING if supported
     if (this.driverConfig.supportsReturning) {
-      const columns = mapSelect(true, table, { tableName: this.getTableName(table) });
+      const columns = mapSelect(true, table, this.resolver, {
+        tableName: this.getTableName(table),
+      });
       insert = this.applyReturning(insert, columns);
     }
 
@@ -316,7 +348,10 @@ export abstract class SQLQueryCompiler {
 
     // Add version increment (must be added after encoding, as a raw SQL expression)
     const versionCol = table.getVersionColumn();
-    encoded[versionCol.name] = sql.raw(`COALESCE(${versionCol.name}, 0) + 1`);
+    const versionColumnName = this.resolver
+      ? this.resolver.getColumnName(table.name, versionCol.name)
+      : versionCol.name;
+    encoded[versionColumnName] = sql`coalesce(${sql.ref(versionColumnName)}, 0) + 1`;
 
     let query = this.db.updateTable(this.getTableName(table)).set(encoded);
 

package/src/adapters/generic-sql/query/where-builder.test.ts

@@ -4,9 +4,11 @@ import { column, idColumn, referenceColumn, schema } from "../../../schema/creat
 import { fullSQLName, buildWhere, processReferenceSubqueries } from "./where-builder";
 import { ReferenceSubquery } from "../../../query/value-encoding";
 import { BetterSQLite3DriverConfig, NodePostgresDriverConfig } from "../driver-config";
+import { dbNow } from "../../../query/db-now";
+import { createNamingResolver, type SqlNamingStrategy } from "../../../naming/sql-naming";
 
 describe("where-builder", () => {
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -15,7 +17,8 @@ describe("where-builder", () => {
           .addColumn("email", column("string"))
           .addColumn("age", column("integer").nullable())
           .addColumn("isActive", column("bool"))
-          .addColumn("createdAt", column("timestamp"));
+          .addColumn("createdAt", column("timestamp"))
+          .addColumn("birthDate", column("date").nullable());
       })
       .addTable("posts", (t) => {
         return t
@@ -52,12 +55,18 @@ describe("where-builder", () => {
       expect(result).toBe("users.id");
     });
 
-    it("should work with table name mapper", () => {
-      const mapper = {
-        toPhysical: (ormName: string) => `prefix_${ormName}`,
-        toLogical: (physicalName: string) => physicalName.replace("prefix_", ""),
+    it("should work with naming resolver", () => {
+      const namingStrategy: SqlNamingStrategy = {
+        namespaceScope: "suffix",
+        namespaceToSchema: (namespace) => namespace,
+        tableName: (logicalTable) => `prefix_${logicalTable}`,
+        columnName: (logicalColumn) => logicalColumn,
+        indexName: (logicalIndex) => logicalIndex,
+        uniqueIndexName: (logicalIndex) => logicalIndex,
+        foreignKeyName: ({ referenceName }) => referenceName,
       };
-      const result = fullSQLName(usersTable.columns.name, mapper);
+      const resolver = createNamingResolver(testSchema, "namespace", namingStrategy);
+      const result = fullSQLName(usersTable.columns.name, resolver);
       expect(result).toBe("prefix_users.name");
     });
   });
@@ -111,6 +120,56 @@ describe("where-builder", () => {
     };
 
     describe("comparison operators", () => {
+      it("should serialize dbNow to CURRENT_TIMESTAMP", () => {
+        const condition = {
+          type: "compare" as const,
+          a: usersTable.columns.createdAt,
+          operator: "<=" as const,
+          b: dbNow(),
+        };
+
+        type TestDB = { users: { id: string } };
+        const db = new Kysely<TestDB>({
+          dialect: new PostgresDialect({ pool: {} as any }), // eslint-disable-line @typescript-eslint/no-explicit-any
+        });
+
+        const query = db
+          .selectFrom("users")
+          .select("id")
+          .where((eb) => buildWhere(condition, eb, new NodePostgresDriverConfig()));
+
+        expect(query.compile().sql).toContain("CURRENT_TIMESTAMP");
+      });
+
+      it("should respect sqlite date storage for dbNow", () => {
+        const condition = {
+          type: "compare" as const,
+          a: usersTable.columns.birthDate,
+          operator: "<=" as const,
+          b: dbNow(),
+        };
+
+        type TestDB = { users: { id: string } };
+        const db = new Kysely<TestDB>({
+          dialect: new PostgresDialect({ pool: {} as any }), // eslint-disable-line @typescript-eslint/no-explicit-any
+        });
+
+        const query = db
+          .selectFrom("users")
+          .select("id")
+          .where((eb) =>
+            buildWhere(condition, eb, new BetterSQLite3DriverConfig(), {
+              timestampStorage: "epoch-ms",
+              dateStorage: "iso-text",
+              bigintStorage: "blob",
+            }),
+          );
+
+        const sqlText = query.compile().sql;
+        expect(sqlText).toContain("CURRENT_TIMESTAMP");
+        expect(sqlText).not.toContain("julianday");
+      });
+
       it("should build simple equality comparison", () => {
         const condition = {
           type: "compare" as const,
@@ -532,6 +591,7 @@ describe("where-builder", () => {
           eb,
           new NodePostgresDriverConfig(),
           undefined,
+          undefined,
           postsTable,
         );
 
@@ -561,6 +621,7 @@ describe("where-builder", () => {
           createMockEB(),
           new NodePostgresDriverConfig(),
           undefined,
+          undefined,
           postsTable,
         );
 
@@ -573,11 +634,17 @@ describe("where-builder", () => {
         });
       });
 
-      it("should generate subquery with table name mapper", () => {
-        const mapper = {
-          toPhysical: (ormName: string) => `prefix_${ormName}`,
-          toLogical: (physicalName: string) => physicalName.replace("prefix_", ""),
+      it("should generate subquery with naming resolver", () => {
+        const namingStrategy: SqlNamingStrategy = {
+          namespaceScope: "suffix",
+          namespaceToSchema: (namespace) => namespace,
+          tableName: (logicalTable) => `prefix_${logicalTable}`,
+          columnName: (logicalColumn) => logicalColumn,
+          indexName: (logicalIndex) => logicalIndex,
+          uniqueIndexName: (logicalIndex) => logicalIndex,
+          foreignKeyName: ({ referenceName }) => referenceName,
         };
+        const resolver = createNamingResolver(testSchema, "namespace", namingStrategy);
 
         const condition = {
           type: "compare" as const,
@@ -591,7 +658,8 @@ describe("where-builder", () => {
           condition,
           eb,
           new NodePostgresDriverConfig(),
-          mapper,
+          undefined,
+          resolver,
           postsTable,
         );
 
@@ -682,17 +750,23 @@ describe("where-builder", () => {
       expect(processed).toEqual(values);
     });
 
-    it("should use table name mapper when provided", () => {
-      const mapper = {
-        toPhysical: (ormName: string) => `prefix_${ormName}`,
-        toLogical: (physicalName: string) => physicalName.replace("prefix_", ""),
+    it("should use naming resolver when provided", () => {
+      const namingStrategy: SqlNamingStrategy = {
+        namespaceScope: "suffix",
+        namespaceToSchema: (namespace) => namespace,
+        tableName: (logicalTable) => `prefix_${logicalTable}`,
+        columnName: (logicalColumn) => logicalColumn,
+        indexName: (logicalIndex) => logicalIndex,
+        uniqueIndexName: (logicalIndex) => logicalIndex,
+        foreignKeyName: ({ referenceName }) => referenceName,
       };
+      const resolver = createNamingResolver(testSchema, "namespace", namingStrategy);
 
       const values = {
         userId: new ReferenceSubquery(usersTable, "user-123"),
       };
 
-      const processed = processReferenceSubqueries(values, kysely, mapper);
+      const processed = processReferenceSubqueries(values, kysely, resolver);
 
       // Compile the subquery to check it uses the mapped table name
       const subquery = processed["userId"] as unknown as { compile: () => { sql: string } };

package/src/adapters/generic-sql/query/where-builder.ts

@@ -8,22 +8,25 @@ import {
 } from "../../../schema/create";
 import type { Condition } from "../../../query/condition-builder";
 import { createSQLSerializer } from "../../../query/serialize/create-sql-serializer";
-import type { TableNameMapper } from "../../shared/table-name-mapper";
+import type { NamingResolver } from "../../../naming/sql-naming";
 import type { DriverConfig } from "../driver-config";
+import { sqliteStorageDefault, type SQLiteStorageMode } from "../sqlite-storage";
 import { ReferenceSubquery, resolveFragnoIdValue } from "../../../query/value-encoding";
+import { isDbNow } from "../../../query/db-now";
 import type { AnyKysely, AnyExpressionBuilder, AnyExpressionWrapper } from "./sql-query-compiler";
 
 /**
  * Returns the fully qualified SQL name for a column (table.column).
  *
  * @param column - The column to get the full name for
- * @param mapper - Optional table name mapper for namespace prefixing
+ * @param resolver - Optional naming resolver for namespace prefixing
  * @returns The fully qualified SQL name in the format "tableName.columnName"
  * @internal
  */
-export function fullSQLName(column: AnyColumn, mapper?: TableNameMapper): string {
-  const tableName = mapper ? mapper.toPhysical(column.tableName) : column.tableName;
-  return `${tableName}.${column.name}`;
+export function fullSQLName(column: AnyColumn, resolver?: NamingResolver): string {
+  const tableName = resolver ? resolver.getTableName(column.tableName) : column.tableName;
+  const columnName = resolver ? resolver.getColumnName(column.tableName, column.name) : column.name;
+  return `${tableName}.${columnName}`;
 }
 
 /**
@@ -36,7 +39,7 @@ export function fullSQLName(column: AnyColumn, mapper?: TableNameMapper): string
  * @param condition - The condition tree to build the WHERE clause from
  * @param eb - Kysely expression builder for constructing SQL expressions
  * @param database - The database type (affects SQL generation)
- * @param mapper - Optional table name mapper for namespace prefixing
+ * @param resolver - Optional naming resolver for namespace prefixing
  * @param table - The table being queried (used for resolving reference columns)
  * @returns A Kysely expression wrapper representing the WHERE clause
  * @internal
@@ -45,10 +48,11 @@ export function buildWhere(
   condition: Condition,
   eb: AnyExpressionBuilder,
   driverConfig: DriverConfig,
-  mapper?: TableNameMapper,
+  sqliteStorageMode?: SQLiteStorageMode,
+  resolver?: NamingResolver,
   table?: AnyTable,
 ): AnyExpressionWrapper {
-  const serializer = createSQLSerializer(driverConfig);
+  const serializer = createSQLSerializer(driverConfig, sqliteStorageMode);
 
   if (condition.type === "compare") {
     const left = condition.a;
@@ -56,25 +60,46 @@ export function buildWhere(
     let val = condition.b;
 
     if (!(val instanceof Column)) {
-      // Handle reference columns specially
-      if (left.role === "reference" && table) {
+      if (isDbNow(val)) {
+        if (driverConfig.databaseType === "sqlite") {
+          const storageMode = sqliteStorageMode ?? sqliteStorageDefault;
+          const storage =
+            left.type === "date" ? storageMode.dateStorage : storageMode.timestampStorage;
+          if ((left.type === "timestamp" || left.type === "date") && storage === "epoch-ms") {
+            val = sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`;
+          } else {
+            val = sql`CURRENT_TIMESTAMP`;
+          }
+        } else {
+          val = sql`CURRENT_TIMESTAMP`;
+        }
+      } else if (left.role === "reference" && table) {
+        // Handle reference columns specially
         if (typeof val === "string") {
           // String external ID - create subquery to lookup internal ID
           const relation = Object.values(table.relations).find((rel) =>
-            rel.on.some(([localCol]) => localCol === left.ormName),
+            rel.on.some(([localCol]) => localCol === left.name),
           );
           if (relation) {
             const refTable = relation.table;
             const internalIdCol = refTable.getInternalIdColumn();
             const idCol = refTable.getIdColumn();
-            const physicalTableName = mapper
-              ? mapper.toPhysical(refTable.ormName)
-              : refTable.ormName;
+            const physicalTableName = resolver
+              ? resolver.getTableName(refTable.name)
+              : refTable.name;
 
             val = eb
               .selectFrom(physicalTableName)
-              .select(internalIdCol.name)
-              .where(idCol.name, "=", val)
+              .select(
+                resolver
+                  ? resolver.getColumnName(refTable.name, internalIdCol.name)
+                  : internalIdCol.name,
+              )
+              .where(
+                resolver ? resolver.getColumnName(refTable.name, idCol.name) : idCol.name,
+                "=",
+                val,
+              )
               .limit(1);
           }
         } else if (val instanceof FragnoId && val.internalId !== undefined) {
@@ -83,20 +108,28 @@ export function buildWhere(
         } else if (val instanceof FragnoId && val.internalId === undefined) {
           // FragnoId without internal ID - create subquery using external ID
           const relation = Object.values(table.relations).find((rel) =>
-            rel.on.some(([localCol]) => localCol === left.ormName),
+            rel.on.some(([localCol]) => localCol === left.name),
           );
           if (relation) {
             const refTable = relation.table;
             const internalIdCol = refTable.getInternalIdColumn();
             const idCol = refTable.getIdColumn();
-            const physicalTableName = mapper
-              ? mapper.toPhysical(refTable.ormName)
-              : refTable.ormName;
+            const physicalTableName = resolver
+              ? resolver.getTableName(refTable.name)
+              : refTable.name;
 
             val = eb
               .selectFrom(physicalTableName)
-              .select(internalIdCol.name)
-              .where(idCol.name, "=", val.externalId)
+              .select(
+                resolver
+                  ? resolver.getColumnName(refTable.name, internalIdCol.name)
+                  : internalIdCol.name,
+              )
+              .where(
+                resolver ? resolver.getColumnName(refTable.name, idCol.name) : idCol.name,
+                "=",
+                val.externalId,
+              )
               .limit(1);
           }
         } else if (val instanceof FragnoReference) {
@@ -122,54 +155,68 @@ export function buildWhere(
         v = "like";
         rhs =
           val instanceof Column
-            ? sql`concat('%', ${eb.ref(fullSQLName(val, mapper))}, '%')`
+            ? sql`concat('%', ${eb.ref(fullSQLName(val, resolver))}, '%')`
             : `%${val}%`;
         break;
       case "not contains":
         v = "not like";
         rhs =
           val instanceof Column
-            ? sql`concat('%', ${eb.ref(fullSQLName(val, mapper))}, '%')`
+            ? sql`concat('%', ${eb.ref(fullSQLName(val, resolver))}, '%')`
             : `%${val}%`;
         break;
       case "starts with":
         v = "like";
         rhs =
-          val instanceof Column ? sql`concat(${eb.ref(fullSQLName(val, mapper))}, '%')` : `${val}%`;
+          val instanceof Column
+            ? sql`concat(${eb.ref(fullSQLName(val, resolver))}, '%')`
+            : `${val}%`;
         break;
       case "not starts with":
         v = "not like";
         rhs =
-          val instanceof Column ? sql`concat(${eb.ref(fullSQLName(val, mapper))}, '%')` : `${val}%`;
+          val instanceof Column
+            ? sql`concat(${eb.ref(fullSQLName(val, resolver))}, '%')`
+            : `${val}%`;
         break;
       case "ends with":
         v = "like";
         rhs =
-          val instanceof Column ? sql`concat('%', ${eb.ref(fullSQLName(val, mapper))})` : `%${val}`;
+          val instanceof Column
+            ? sql`concat('%', ${eb.ref(fullSQLName(val, resolver))})`
+            : `%${val}`;
         break;
       case "not ends with":
         v = "not like";
         rhs =
-          val instanceof Column ? sql`concat('%', ${eb.ref(fullSQLName(val, mapper))})` : `%${val}`;
+          val instanceof Column
+            ? sql`concat('%', ${eb.ref(fullSQLName(val, resolver))})`
+            : `%${val}`;
         break;
       default:
         v = op;
-        rhs = val instanceof Column ? eb.ref(fullSQLName(val, mapper)) : val;
+        rhs = val instanceof Column ? eb.ref(fullSQLName(val, resolver)) : val;
     }
 
-    return eb(fullSQLName(left, mapper), v, rhs);
+    return eb(fullSQLName(left, resolver), v, rhs);
   }
 
   // Nested conditions
   if (condition.type === "and") {
-    return eb.and(condition.items.map((v) => buildWhere(v, eb, driverConfig, mapper, table)));
+    return eb.and(
+      condition.items.map((v) =>
+        buildWhere(v, eb, driverConfig, sqliteStorageMode, resolver, table),
+      ),
+    );
   }
 
   if (condition.type === "not") {
-    return eb.not(buildWhere(condition.item, eb, driverConfig, mapper, table));
+    return eb.not(buildWhere(condition.item, eb, driverConfig, sqliteStorageMode, resolver, table));
   }
 
-  return eb.or(condition.items.map((v) => buildWhere(v, eb, driverConfig, mapper, table)));
+  return eb.or(
+    condition.items.map((v) => buildWhere(v, eb, driverConfig, sqliteStorageMode, resolver, table)),
+  );
 }
 
 /**
@@ -177,17 +224,18 @@ export function buildWhere(
  *
  * @param values - The encoded values that may contain ReferenceSubquery objects
  * @param kysely - The Kysely database instance for building subqueries
- * @param mapper - Optional table name mapper for namespace prefixing
+ * @param resolver - Optional naming resolver for namespace prefixing
  * @returns Processed values with subqueries in place of ReferenceSubquery markers
  * @internal
  */
 export function processReferenceSubqueries(
   values: Record<string, unknown>,
   kysely: AnyKysely,
-  mapper?: TableNameMapper,
+  resolver?: NamingResolver,
 ): Record<string, unknown> {
   const processed: Record<string, unknown> = {};
-  const getTableName = (table: AnyTable) => (mapper ? mapper.toPhysical(table.name) : table.name);
+  const getTableName = (table: AnyTable) =>
+    resolver ? resolver.getTableName(table.name) : table.name;
 
   for (const [key, value] of Object.entries(values)) {
     if (value instanceof ReferenceSubquery) {
@@ -196,11 +244,15 @@ export function processReferenceSubqueries(
       const tableName = getTableName(refTable);
       const internalIdCol = refTable.getInternalIdColumn().name;
       const idCol = refTable.getIdColumn().name;
+      const internalIdColumnName = resolver
+        ? resolver.getColumnName(refTable.name, internalIdCol)
+        : internalIdCol;
+      const idColumnName = resolver ? resolver.getColumnName(refTable.name, idCol) : idCol;
 
       processed[key] = kysely
         .selectFrom(tableName)
-        .select(internalIdCol)
-        .where(idCol, "=", externalId)
+        .select(internalIdColumnName)
+        .where(idColumnName, "=", externalId)
         .limit(1);
     } else {
       processed[key] = value;

package/src/adapters/{kysely/kysely-adapter-pglite.test.ts → generic-sql/sql-adapter-pglite-migrations.test.ts}

@@ -1,6 +1,6 @@
 import { KyselyPGlite } from "kysely-pglite";
 import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
-import { KyselyAdapter } from "./kysely-adapter";
+import { SqlAdapter } from "./generic-sql-adapter";
 import {
   column,
   idColumn,
@@ -10,11 +10,11 @@ import {
   type FragnoReference,
 } from "../../schema/create";
 import { Cursor } from "../../query/cursor";
-import { PGLiteDriverConfig } from "../generic-sql/driver-config";
+import { PGLiteDriverConfig } from "./driver-config";
 import { internalSchema } from "../../fragments/internal-fragment";
 
-describe("KyselyAdapter PGLite", () => {
-  const testSchema = schema((s) => {
+describe("SqlAdapter PGLite", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -96,12 +96,12 @@ describe("KyselyAdapter PGLite", () => {
       });
   });
 
-  let adapter: KyselyAdapter;
+  let adapter: SqlAdapter;
 
   beforeAll(async () => {
     const { dialect } = await KyselyPGlite.create();
 
-    adapter = new KyselyAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new PGLiteDriverConfig(),
     });