@fragno-dev/db 0.1.13 → 0.1.15

package/src/adapters/drizzle/test-utils.ts

@@ -1,7 +1,8 @@
-import { mkdir, writeFile, rm } from "node:fs/promises";
+import { mkdir, writeFile, rm, access } from "node:fs/promises";
 import { join } from "node:path";
 import { generateSchema, type SupportedProvider } from "./generate";
 import type { Schema } from "../../schema/create";
+import { settingsSchema } from "../../fragments/internal-fragment";
 
 /**
  * Writes a Fragno schema to a temporary TypeScript file and dynamically imports it.
@@ -34,20 +35,50 @@ export async function writeAndLoadSchema(
   // Generate unique schema file path
   const schemaFilePath = join(
     testDir,
-    `test-schema-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.ts`,
+    `test-schema-${testFileName}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.ts`,
   );
 
   // Generate and write the Drizzle schema to file
-  // Use empty namespace for tests to avoid table name prefixing
-  const drizzleSchemaTs = generateSchema([{ namespace: namespace ?? "", schema }], dialect);
+  // Always include settings schema first (as done in generation-engine.ts), then the test schema
+  // De-duplicate: if the test schema IS the settings schema, don't add it twice
+  const fragments: Array<{ namespace: string; schema: Schema }> = [
+    { namespace: "", schema: settingsSchema },
+  ];
+
+  if (schema !== settingsSchema) {
+    fragments.push({ namespace: namespace ?? "", schema });
+  }
+
+  const drizzleSchemaTs = generateSchema(fragments, dialect);
   await writeFile(schemaFilePath, drizzleSchemaTs, "utf-8");
 
+  // Ensure the file is accessible before importing (handle race conditions)
+  let retries = 0;
+  const maxRetries = 10;
+  while (retries < maxRetries) {
+    try {
+      await access(schemaFilePath);
+      break;
+    } catch {
+      if (retries === maxRetries - 1) {
+        throw new Error(`Schema file was not accessible after writing: ${schemaFilePath}`);
+      }
+      // Wait a bit before retrying
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      retries++;
+    }
+  }
+
   // Dynamically import the generated schema (with cache busting)
   const schemaModule = await import(`${schemaFilePath}?t=${Date.now()}`);
 
   // Cleanup function to remove the test-specific directory
   const cleanup = async () => {
-    await rm(testDir, { recursive: true, force: true });
+    try {
+      await rm(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore error if directory doesn't exist
+    }
   };
 
   return {

package/src/adapters/kysely/kysely-adapter-pglite.test.ts

@@ -787,7 +787,7 @@ describe("KyselyAdapter PGLite", () => {
     });
   });
 
-  it("should handle timestamps and timezones correctly", async () => {
+  it("should handle timestamps and time zones correctly", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "test");
 
     // Create a user
@@ -826,7 +826,7 @@ describe("KyselyAdapter PGLite", () => {
     const specificDate = new Date("2024-06-15T14:30:00Z");
     expect(specificDate.toISOString()).toBe("2024-06-15T14:30:00.000Z");
 
-    // Verify that dates from different timezones are handled correctly
+    // Verify that dates from different time zones are handled correctly
     const localDate = new Date("2024-06-15T14:30:00");
     expect(localDate).toBeInstanceOf(Date);
     expect(typeof localDate.getTimezoneOffset()).toBe("number");
@@ -878,10 +878,11 @@ describe("KyselyAdapter PGLite", () => {
   it("should support cursor-based pagination with findWithCursor()", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "test");
 
-    // Create multiple users for pagination testing with unique prefix
+    // Create exactly 15 users for precise pagination testing with unique prefix
     const prefix = "CursorPagTest";
+
     const userIds: FragnoId[] = [];
-    for (let i = 1; i <= 25; i++) {
+    for (let i = 1; i <= 15; i++) {
       const userId = await queryEngine.create("users", {
         name: `${prefix} ${i.toString().padStart(2, "0")}`,
         age: 20 + i,
@@ -889,29 +890,35 @@ describe("KyselyAdapter PGLite", () => {
       userIds.push(userId);
     }
 
-    // Fetch first page with cursor (filter by prefix to avoid other test data)
+    // Fetch first page with cursor (pageSize=10, total=15 items)
     const firstPage = await queryEngine.findWithCursor("users", (b) =>
-      b.whereIndex("name_idx").orderByIndex("name_idx", "asc").pageSize(10),
+      b
+        .whereIndex("name_idx", (eb) => eb("name", "starts with", prefix))
+        .orderByIndex("name_idx", "asc")
+        .pageSize(10),
     );
 
-    // Check structure
+    // Check structure and hasNextPage
     expect(firstPage).toHaveProperty("items");
     expect(firstPage).toHaveProperty("cursor");
+    expect(firstPage).toHaveProperty("hasNextPage");
     expect(Array.isArray(firstPage.items)).toBe(true);
-    expect(firstPage.items.length).toBeGreaterThan(0);
+    expect(firstPage.items).toHaveLength(10);
+    expect(firstPage.hasNextPage).toBe(true);
+    expect(firstPage.cursor).toBeInstanceOf(Cursor);
 
-    assert(firstPage.cursor instanceof Cursor);
-
-    // Fetch second page using cursor
+    // Fetch second page using cursor (last page with 5 remaining items)
     const secondPage = await queryEngine.findWithCursor("users", (b) =>
       b
-        .whereIndex("name_idx")
+        .whereIndex("name_idx", (eb) => eb("name", "starts with", prefix))
         .after(firstPage.cursor!)
         .orderByIndex("name_idx", "asc")
         .pageSize(10),
     );
 
-    expect(secondPage.items.length).toBeGreaterThan(0);
+    expect(secondPage.items).toHaveLength(5);
+    expect(secondPage.hasNextPage).toBe(false);
+    expect(secondPage.cursor).toBeUndefined();
 
     // Verify no overlap - all names in second page should be different from first page
     const firstPageNames = new Set(firstPage.items.map((u) => u.name));
@@ -926,12 +933,16 @@ describe("KyselyAdapter PGLite", () => {
     const secondPageFirst = secondPage.items[0].name;
     expect(firstPageLast < secondPageFirst).toBe(true);
 
-    // Verify our test data is present
-    const testUsers = await queryEngine.find("users", (b) =>
-      b.whereIndex("name_idx").pageSize(100),
+    // Test empty results
+    const emptyPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_idx", (eb) => eb("name", "starts with", "NonExistentPrefix"))
+        .orderByIndex("name_idx", "asc")
+        .pageSize(10),
     );
-    const testUserNames = testUsers.filter((u) => u.name.startsWith(prefix)).map((u) => u.name);
-    expect(testUserNames).toHaveLength(25);
+    expect(emptyPage.items).toHaveLength(0);
+    expect(emptyPage.hasNextPage).toBe(false);
+    expect(emptyPage.cursor).toBeUndefined();
   });
 
   it("should support findWithCursor() in Unit of Work", async () => {
@@ -960,14 +971,47 @@ describe("KyselyAdapter PGLite", () => {
 
     const [result] = await uow.executeRetrieve();
 
-    // Verify result structure
+    // Verify result structure including hasNextPage
     expect(result).toHaveProperty("items");
     expect(result).toHaveProperty("cursor");
+    expect(result).toHaveProperty("hasNextPage");
     expect(Array.isArray(result.items)).toBe(true);
     expect(result.items.length).toBeGreaterThan(0);
+    expect(typeof result.hasNextPage).toBe("boolean");
+    expect(result.cursor).toBeInstanceOf(Cursor);
+  });
 
-    if (result.items.length === 3) {
-      expect(result.cursor).toBeInstanceOf(Cursor);
-    }
+  it("should fail check() when version changes", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+
+    // Create a user
+    const userId = await queryEngine.create("users", {
+      name: "Version Conflict User",
+      age: 40,
+    });
+
+    // Update the user to increment their version
+    await queryEngine.updateMany("users", (b) =>
+      b.whereIndex("primary", (eb) => eb("id", "=", userId)).set({ age: 41 }),
+    );
+
+    // Try to check with the old version (should fail)
+    const uow = queryEngine.createUnitOfWork("check-stale-version");
+    uow.check("users", userId); // This has version 0, but the user now has version 1
+    uow.create("posts", {
+      user_id: userId,
+      title: "Should Not Be Created",
+      content: "Content",
+    });
+
+    const { success } = await uow.executeMutations();
+    expect(success).toBe(false);
+
+    // Verify the post was NOT created
+    const posts = await queryEngine.find("posts", (b) =>
+      b.whereIndex("posts_user_idx", (eb) => eb("user_id", "=", userId)),
+    );
+    const conflictPosts = posts.filter((p) => p.title === "Should Not Be Created");
+    expect(conflictPosts).toHaveLength(0);
   });
 });

package/src/adapters/kysely/kysely-adapter-sqlite.test.ts

@@ -0,0 +1,156 @@
+import { Kysely } from "kysely";
+import { SQLocalKysely } from "sqlocal/kysely";
+import { beforeAll, describe, expect, it } from "vitest";
+import { KyselyAdapter } from "./kysely-adapter";
+import { column, idColumn, referenceColumn, schema } from "../../schema/create";
+
+describe("KyselyAdapter SQLite", () => {
+  const testSchema = schema((s) => {
+    return s
+      .addTable("accounts", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("userId", column("string"))
+          .addColumn("balance", column("integer"))
+          .createIndex("idx_user", ["userId"]);
+      })
+      .addTable("transactions", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("fromAccountId", referenceColumn())
+          .addColumn("toAccountId", referenceColumn())
+          .addColumn("amount", column("integer"));
+      })
+      .addReference("fromAccount", {
+        type: "one",
+        from: { table: "transactions", column: "fromAccountId" },
+        to: { table: "accounts", column: "id" },
+      })
+      .addReference("toAccount", {
+        type: "one",
+        from: { table: "transactions", column: "toAccountId" },
+        to: { table: "accounts", column: "id" },
+      });
+  });
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let kysely: Kysely<any>;
+  let adapter: KyselyAdapter;
+
+  beforeAll(async () => {
+    const { dialect } = new SQLocalKysely(":memory:");
+    kysely = new Kysely({
+      dialect,
+    });
+
+    adapter = new KyselyAdapter({
+      db: kysely,
+      provider: "sqlite",
+    });
+
+    // Run migrations
+    const migrator = adapter.createMigrationEngine(testSchema, "test");
+    const preparedMigration = await migrator.prepareMigration({
+      updateSettings: false,
+    });
+    await preparedMigration.execute();
+  });
+
+  // TODO(Wilco): The SQLocal adapter does not return the number of affected rows for updates/deletes.
+  //              (this only seems to happens when the query is compiled and then executed with executeQuery())
+  it.todo("should perform a balance transfer between accounts", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+
+    // Create two accounts with initial balances
+    const account1Id = await queryEngine.create("accounts", {
+      userId: "user1",
+      balance: 1000,
+    });
+
+    const account2Id = await queryEngine.create("accounts", {
+      userId: "user2",
+      balance: 500,
+    });
+
+    // Verify initial balances
+    const initialAccount1 = await queryEngine.findFirst("accounts", (b) => {
+      return b.whereIndex("primary", (eb) => eb("id", "=", account1Id));
+    });
+
+    const initialAccount2 = await queryEngine.findFirst("accounts", (b) => {
+      return b.whereIndex("primary", (eb) => eb("id", "=", account2Id));
+    });
+
+    expect(initialAccount1?.balance).toBe(1000);
+    expect(initialAccount2?.balance).toBe(500);
+
+    // Perform a balance transfer using Unit of Work
+    const transferAmount = 300;
+
+    // Read current balances - chain the calls to properly set generics
+    const uow = queryEngine
+      .createUnitOfWork("balance-transfer")
+      .find("accounts", (b) => {
+        return b.whereIndex("primary", (eb) => eb("id", "=", account1Id));
+      })
+      .find("accounts", (b) => {
+        return b.whereIndex("primary", (eb) => eb("id", "=", account2Id));
+      });
+
+    // Execute retrieval phase
+    const [[fromAccount], [toAccount]] = await uow.executeRetrieve();
+
+    expect(fromAccount).toBeDefined();
+    expect(toAccount).toBeDefined();
+
+    // Mutation phase: update balances and record transaction
+    uow.update("accounts", account1Id, (b) => {
+      return b.set({ balance: fromAccount!.balance - transferAmount }).check();
+    });
+
+    uow.update("accounts", account2Id, (b) => {
+      return b.set({ balance: toAccount!.balance + transferAmount }).check();
+    });
+
+    uow.create("transactions", {
+      fromAccountId: account1Id,
+      toAccountId: account2Id,
+      amount: transferAmount,
+    });
+
+    // Execute mutations
+    const { success } = await uow.executeMutations();
+    expect(success).toBe(true);
+
+    // Verify final balances
+    const finalAccount1 = await queryEngine.findFirst("accounts", (b) => {
+      return b.whereIndex("primary", (eb) => eb("id", "=", account1Id));
+    });
+
+    const finalAccount2 = await queryEngine.findFirst("accounts", (b) => {
+      return b.whereIndex("primary", (eb) => eb("id", "=", account2Id));
+    });
+
+    expect(finalAccount1?.balance).toBe(700); // 1000 - 300
+    expect(finalAccount2?.balance).toBe(800); // 500 + 300
+
+    // Verify versions were incremented
+    expect(finalAccount1?.id.version).toBe(1);
+    expect(finalAccount2?.id.version).toBe(1);
+
+    // Verify transaction was recorded
+    const transaction = await queryEngine.findFirst("transactions", (b) => {
+      return b.whereIndex("primary");
+    });
+
+    expect(transaction).toMatchObject({
+      fromAccountId: expect.objectContaining({
+        internalId: account1Id.internalId,
+      }),
+      toAccountId: expect.objectContaining({
+        internalId: account2Id.internalId,
+      }),
+      amount: transferAmount,
+    });
+  });
+});

package/src/adapters/kysely/kysely-adapter.ts

@@ -4,6 +4,7 @@ import {
   fragnoDatabaseAdapterNameFakeSymbol,
   fragnoDatabaseAdapterVersionFakeSymbol,
   type DatabaseAdapter,
+  type DatabaseContextStorage,
 } from "../adapters";
 import { createMigrator, type Migrator } from "../../migration-engine/create";
 import type { AnySchema } from "../../schema/create";
@@ -13,9 +14,10 @@ import type { AbstractQuery } from "../../query/query";
 import { fromKysely, type KyselyUOWConfig } from "./kysely-query";
 import { createTableNameMapper } from "./kysely-shared";
 import { createHash } from "node:crypto";
-import { SETTINGS_TABLE_NAME } from "../../shared/settings-schema";
+import { SETTINGS_TABLE_NAME } from "../../fragments/internal-fragment";
 import type { ConnectionPool } from "../../shared/connection-pool";
 import { createKyselyConnectionPool } from "./kysely-connection-pool";
+import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type KyselyAny = Kysely<any>;
@@ -28,10 +30,13 @@ export interface KyselyConfig {
 export class KyselyAdapter implements DatabaseAdapter<KyselyUOWConfig> {
   #connectionPool: ConnectionPool<KyselyAny>;
   #provider: SQLProvider;
+  #schemaNamespaceMap = new WeakMap<AnySchema, string>();
+  #contextStorage: RequestContextStorage<DatabaseContextStorage>;
 
   constructor(config: KyselyConfig) {
     this.#connectionPool = createKyselyConnectionPool(config.db);
     this.#provider = config.provider;
+    this.#contextStorage = new RequestContextStorage();
   }
 
   get [fragnoDatabaseAdapterNameFakeSymbol](): string {
@@ -42,17 +47,35 @@ export class KyselyAdapter implements DatabaseAdapter<KyselyUOWConfig> {
     return 0;
   }
 
+  get contextStorage(): RequestContextStorage<DatabaseContextStorage> {
+    return this.#contextStorage;
+  }
+
   async close(): Promise<void> {
     await this.#connectionPool.close();
   }
 
+  createTableNameMapper(namespace: string) {
+    return createTableNameMapper(namespace);
+  }
+
   createQueryEngine<T extends AnySchema>(
     schema: T,
     namespace: string,
   ): AbstractQuery<T, KyselyUOWConfig> {
+    // Register schema-namespace mapping
+    this.#schemaNamespaceMap.set(schema, namespace);
+
     // Only create mapper if namespace is non-empty
     const mapper = namespace ? createTableNameMapper(namespace) : undefined;
-    return fromKysely(schema, this.#connectionPool, this.#provider, mapper);
+    return fromKysely(
+      schema,
+      this.#connectionPool,
+      this.#provider,
+      mapper,
+      undefined,
+      this.#schemaNamespaceMap,
+    );
   }
 
   async isConnectionHealthy(): Promise<boolean> {

package/src/adapters/kysely/kysely-query-compiler.ts

@@ -1,16 +1,12 @@
-import type { CompiledQuery, Kysely } from "kysely";
+import type { CompiledQuery } from "kysely";
 import type { AnySchema, AnyTable } from "../../schema/create";
 import { buildCondition } from "../../query/condition-builder";
 import { buildFindOptions } from "../../query/orm/orm";
 import { createKyselyQueryBuilder } from "./kysely-query-builder";
 import type { ConditionBuilder, Condition } from "../../query/condition-builder";
-import type { TableNameMapper } from "./kysely-shared";
-import type { ConnectionPool } from "../../shared/connection-pool";
+import { createKysely, type TableNameMapper } from "./kysely-shared";
 import type { SQLProvider } from "../../shared/providers";
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type KyselyAny = Kysely<any>;
-
 /**
  * Internal query compiler interface for Kysely
  * Used by the UOW compiler to generate compiled queries
@@ -31,12 +27,11 @@ export interface KyselyQueryCompiler {
 
 export function createKyselyQueryCompiler<T extends AnySchema>(
   schema: T,
-  pool: ConnectionPool<KyselyAny>,
   provider: SQLProvider,
   mapper?: TableNameMapper,
 ): KyselyQueryCompiler {
   // Get kysely instance for query building (compilation doesn't execute, just builds SQL)
-  const kysely = pool.getDatabaseSync();
+  const kysely = createKysely(provider);
   const queryBuilder = createKyselyQueryBuilder(kysely, provider, mapper);
 
   function toTable(name: unknown): AnyTable {

package/src/adapters/kysely/kysely-query.ts

@@ -77,6 +77,8 @@ class UpdateManySpecialBuilder<TTable extends AnyTable> {
  * @param pool - Connection pool for acquiring database connections
  * @param provider - SQL provider (postgresql, mysql, sqlite, etc.)
  * @param mapper - Optional table name mapper for namespace prefixing
+ * @param uowConfig - Optional UOW configuration
+ * @param schemaNamespaceMap - Optional WeakMap for schema-to-namespace lookups
  * @returns An AbstractQuery instance for performing database operations
  *
  * @example
@@ -96,9 +98,10 @@ export function fromKysely<T extends AnySchema>(
   provider: SQLProvider,
   mapper?: TableNameMapper,
   uowConfig?: KyselyUOWConfig,
+  schemaNamespaceMap?: WeakMap<AnySchema, string>,
 ): AbstractQuery<T, KyselyUOWConfig> {
   function createUOW(opts: { name?: string; config?: KyselyUOWConfig }) {
-    const uowCompiler = createKyselyUOWCompiler(schema, pool, provider, mapper);
+    const uowCompiler = createKyselyUOWCompiler(provider, mapper);
 
     const executor: UOWExecutor<CompiledQuery, unknown> = {
       async executeRetrievalPhase(retrievalBatch: CompiledQuery[]) {
@@ -133,7 +136,7 @@ export function fromKysely<T extends AnySchema>(
     };
 
     // Create a decoder function to transform raw results into application format
-    const decoder: UOWDecoder<T> = (rawResults, ops) => {
+    const decoder: UOWDecoder<unknown> = (rawResults, ops) => {
       if (rawResults.length !== ops.length) {
         throw new Error("rawResults and ops must have the same length");
       }
@@ -165,35 +168,45 @@ export function fromKysely<T extends AnySchema>(
         // If cursor generation is requested, wrap in CursorResult
         if (op.withCursor) {
           let cursor: Cursor | undefined;
-
-          // Generate cursor from last item if results exist
-          if (decodedRows.length > 0 && op.options.orderByIndex && op.options.pageSize) {
-            const lastItem = decodedRows[decodedRows.length - 1];
-            const indexName = op.options.orderByIndex.indexName;
-
-            // Get index columns
-            let indexColumns;
-            if (indexName === "_primary") {
-              indexColumns = [op.table.getIdColumn()];
-            } else {
-              const index = op.table.indexes[indexName];
-              if (index) {
-                indexColumns = index.columns;
+          let hasNextPage = false;
+          let items = decodedRows;
+
+          // Check if there are more results (we fetched pageSize + 1)
+          if (op.options.pageSize && decodedRows.length > op.options.pageSize) {
+            hasNextPage = true;
+            // Trim to requested pageSize
+            items = decodedRows.slice(0, op.options.pageSize);
+
+            // Generate cursor from the last item we're returning
+            if (op.options.orderByIndex) {
+              const lastItem = items[items.length - 1];
+              const indexName = op.options.orderByIndex.indexName;
+
+              // Get index columns
+              let indexColumns;
+              if (indexName === "_primary") {
+                indexColumns = [op.table.getIdColumn()];
+              } else {
+                const index = op.table.indexes[indexName];
+                if (index) {
+                  indexColumns = index.columns;
+                }
               }
-            }
 
-            if (indexColumns && lastItem) {
-              cursor = createCursorFromRecord(lastItem as Record<string, unknown>, indexColumns, {
-                indexName: op.options.orderByIndex.indexName,
-                orderDirection: op.options.orderByIndex.direction,
-                pageSize: op.options.pageSize,
-              });
+              if (indexColumns && lastItem) {
+                cursor = createCursorFromRecord(lastItem as Record<string, unknown>, indexColumns, {
+                  indexName: op.options.orderByIndex.indexName,
+                  orderDirection: op.options.orderByIndex.direction,
+                  pageSize: op.options.pageSize,
+                });
+              }
             }
           }
 
           const result: CursorResult<unknown> = {
-            items: decodedRows,
+            items,
             cursor,
+            hasNextPage,
           };
           return result;
         }
@@ -204,20 +217,27 @@ export function fromKysely<T extends AnySchema>(
 
     const { onQuery, ...restUowConfig } = opts.config ?? {};
 
-    return new UnitOfWork(schema, uowCompiler, executor, decoder, opts.name, {
-      ...restUowConfig,
-      onQuery: (query) => {
-        // CompiledMutation has { query: CompiledQuery, expectedAffectedRows: number | null }
-        // CompiledQuery has { query: QueryAST, sql: string, parameters: unknown[] }
-        // Check for expectedAffectedRows to distinguish CompiledMutation from CompiledQuery
-        const actualQuery =
-          query && typeof query === "object" && "expectedAffectedRows" in query
-            ? (query as CompiledMutation<CompiledQuery>).query
-            : (query as CompiledQuery);
-
-        opts.config?.onQuery?.(actualQuery);
+    return new UnitOfWork(
+      uowCompiler,
+      executor,
+      decoder,
+      opts.name,
+      {
+        ...restUowConfig,
+        onQuery: (query) => {
+          // CompiledMutation has { query: CompiledQuery, expectedAffectedRows: number | null }
+          // CompiledQuery has { query: QueryAST, sql: string, parameters: unknown[] }
+          // Check for expectedAffectedRows to distinguish CompiledMutation from CompiledQuery
+          const actualQuery =
+            query && typeof query === "object" && "expectedAffectedRows" in query
+              ? (query as CompiledMutation<CompiledQuery>).query
+              : (query as CompiledQuery);
+
+          opts.config?.onQuery?.(actualQuery);
+        },
       },
-    });
+      schemaNamespaceMap,
+    ).forSchema(schema);
   }
 
   return {

package/src/adapters/kysely/kysely-shared.ts

@@ -1,3 +1,7 @@
+import { Kysely } from "kysely";
+import type { SQLProvider } from "../../shared/providers";
+import { MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
+
 /**
  * Maps logical table names (used by fragment authors) to physical table names (with namespace suffix)
  */
@@ -21,3 +25,33 @@ export function createTableNameMapper(namespace: string): TableNameMapper {
     },
   };
 }
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type KyselyAny = Kysely<any>;
+
+/**
+ * Creates a Kysely instance that can only build queries, not execute them.
+ */
+export function createKysely(provider: SQLProvider): KyselyAny {
+  // oxlint-disable-next-line no-explicit-any
+  const fakeObj = {} as any;
+  switch (provider) {
+    case "postgresql":
+    case "cockroachdb":
+      return new Kysely({
+        dialect: new PostgresDialect(fakeObj),
+      });
+
+    case "mysql":
+      return new Kysely({
+        dialect: new MysqlDialect(fakeObj),
+      });
+
+    case "sqlite":
+      return new Kysely({
+        dialect: new SqliteDialect(fakeObj),
+      });
+  }
+
+  throw new Error(`Unsupported provider: ${provider}`);
+}