@fragno-dev/db 0.1.11 → 0.1.13

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

@@ -1,6 +1,11 @@
-import type { AbstractQuery } from "../../query/query";
-import type { AnySchema } from "../../schema/create";
-import type { CompiledMutation, UOWDecoder, UOWExecutor } from "../../query/unit-of-work";
+import type { AbstractQuery, TableToUpdateValues } from "../../query/query";
+import type { AnySchema, AnyTable } from "../../schema/create";
+import type {
+  CompiledMutation,
+  UOWDecoder,
+  UOWExecutor,
+  ValidIndexName,
+} from "../../query/unit-of-work";
 import { decodeResult } from "../../query/result-transform";
 import { createKyselyUOWCompiler } from "./kysely-uow-compiler";
 import { executeKyselyRetrievalPhase, executeKyselyMutationPhase } from "./kysely-uow-executor";
@@ -9,10 +14,58 @@ import type { CompiledQuery, Kysely } from "kysely";
 import type { TableNameMapper } from "./kysely-shared";
 import type { ConnectionPool } from "../../shared/connection-pool";
 import type { SQLProvider } from "../../shared/providers";
+import { createCursorFromRecord, Cursor, type CursorResult } from "../../query/cursor";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type KyselyAny = Kysely<any>;
 
+/**
+ * Configuration options for creating a Kysely Unit of Work
+ */
+export interface KyselyUOWConfig {
+  /**
+   * Optional callback to receive compiled SQL queries for logging/debugging
+   * This callback is invoked for each query as it's compiled
+   */
+  onQuery?: (query: CompiledQuery) => void;
+  /**
+   * If true, the query will not be executed and the query will be returned. Not respected for UOWs
+   * since those have to be manually executed.
+   */
+  dryRun?: boolean;
+}
+
+/**
+ * Special builder for updateMany operations that captures configuration
+ */
+class UpdateManySpecialBuilder<TTable extends AnyTable> {
+  #indexName?: string;
+  #condition?: unknown;
+  #setValues?: TableToUpdateValues<TTable>;
+
+  whereIndex<TIndexName extends ValidIndexName<TTable>>(
+    indexName: TIndexName,
+    condition?: unknown,
+  ): this {
+    this.#indexName = indexName as string;
+    this.#condition = condition;
+    return this;
+  }
+
+  set(values: TableToUpdateValues<TTable>): this {
+    this.#setValues = values;
+    return this;
+  }
+
+  getConfig() {
+    return {
+      indexName: this.#indexName,
+      condition: this.#condition,
+      setValues: this.#setValues,
+    };
+  }
+}
+
 /**
  * Creates a Kysely-based query engine for the given schema.
  *
@@ -42,12 +95,18 @@ export function fromKysely<T extends AnySchema>(
   pool: ConnectionPool<KyselyAny>,
   provider: SQLProvider,
   mapper?: TableNameMapper,
-): AbstractQuery<T> {
-  function createUOW(name?: string): UnitOfWork<T, []> {
+  uowConfig?: KyselyUOWConfig,
+): AbstractQuery<T, KyselyUOWConfig> {
+  function createUOW(opts: { name?: string; config?: KyselyUOWConfig }) {
     const uowCompiler = createKyselyUOWCompiler(schema, pool, provider, mapper);
 
     const executor: UOWExecutor<CompiledQuery, unknown> = {
       async executeRetrievalPhase(retrievalBatch: CompiledQuery[]) {
+        // In dryRun mode, skip execution and return empty results
+        if (opts.config?.dryRun) {
+          return retrievalBatch.map(() => []);
+        }
+
         const conn = await pool.connect();
         try {
           return await executeKyselyRetrievalPhase(conn.db, retrievalBatch);
@@ -56,6 +115,14 @@ export function fromKysely<T extends AnySchema>(
         }
       },
       async executeMutationPhase(mutationBatch: CompiledMutation<CompiledQuery>[]) {
+        // In dryRun mode, skip execution and return success with mock internal IDs
+        if (opts.config?.dryRun) {
+          return {
+            success: true,
+            createdInternalIds: mutationBatch.map(() => null),
+          };
+        }
+
         const conn = await pool.connect();
         try {
           return await executeKyselyMutationPhase(conn.db, mutationBatch);
@@ -93,27 +160,95 @@ export function fromKysely<T extends AnySchema>(
 
         // Each result is an array of rows - decode each row
         const rowArray = rows as Record<string, unknown>[];
-        return rowArray.map((row) => decodeResult(row, op.table, provider));
+        const decodedRows = rowArray.map((row) => decodeResult(row, op.table, provider));
+
+        // 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;
+              }
+            }
+
+            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,
+            cursor,
+          };
+          return result;
+        }
+
+        return decodedRows;
       });
     };
 
-    return new UnitOfWork(schema, uowCompiler, executor, decoder, name);
+    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 {
     async find(tableName, builderFn) {
-      const uow = createUOW();
-      uow.find(tableName, builderFn);
+      const uow = createUOW({ config: uowConfig });
+      // Safe: builderFn returns a FindBuilder (or void), which matches UnitOfWork signature
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      uow.find(tableName, builderFn as any);
       // executeRetrieve returns an array of results (one per find operation)
       // Since we only have one find, unwrap the first result
       const [result]: unknown[][] = await uow.executeRetrieve();
       return result ?? [];
     },
 
+    async findWithCursor(tableName, builderFn) {
+      // Safe: builderFn returns a FindBuilder, which matches UnitOfWork signature
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const uow = createUOW({ config: uowConfig }).findWithCursor(tableName, builderFn as any);
+      // executeRetrieve returns an array of results (one per find operation)
+      // Since we only have one findWithCursor, unwrap the first result
+      const [result] = await uow.executeRetrieve();
+      return result as CursorResult<unknown>;
+    },
+
     async findFirst(tableName, builderFn) {
-      const uow = createUOW();
+      const uow = createUOW({ config: uowConfig });
       if (builderFn) {
-        uow.find(tableName, (b) => builderFn(b as never).pageSize(1));
+        uow.find(tableName, (b) => {
+          builderFn(b);
+          return b.pageSize(1);
+        });
       } else {
         uow.find(tableName, (b) => b.whereIndex("primary").pageSize(1));
       }
@@ -123,16 +258,15 @@ export function fromKysely<T extends AnySchema>(
     },
 
     async create(tableName, values) {
-      const uow = createUOW();
+      const uow = createUOW({ config: uowConfig });
       uow.create(tableName, values);
       const { success } = await uow.executeMutations();
       if (!success) {
-        // This should not happen because we don't `.check()` this call.
-        // TODO: Verify what happens when there are unique constraints
         throw new Error("Failed to create record");
       }
 
-      const [createdId] = uow.getCreatedIds();
+      const createdIds = uow.getCreatedIds();
+      const createdId = createdIds[0];
       if (!createdId) {
         throw new Error("Failed to get created ID");
       }
@@ -140,7 +274,7 @@ export function fromKysely<T extends AnySchema>(
     },
 
     async createMany(tableName, valuesArray) {
-      const uow = createUOW();
+      const uow = createUOW({ config: uowConfig });
       for (const values of valuesArray) {
         uow.create(tableName, values);
       }
@@ -153,8 +287,8 @@ export function fromKysely<T extends AnySchema>(
     },
 
     async update(tableName, id, builderFn) {
-      const uow = createUOW();
-      uow.update(tableName, id, builderFn as never);
+      const uow = createUOW({ config: uowConfig });
+      uow.update(tableName, id, builderFn);
       const { success } = await uow.executeMutations();
       if (!success) {
         throw new Error("Failed to update record (version conflict or record not found)");
@@ -162,51 +296,41 @@ export function fromKysely<T extends AnySchema>(
     },
 
     async updateMany(tableName, builderFn) {
-      // Create a special builder that captures both where and set operations
-      let whereConfig: { indexName?: string; condition?: unknown } = {};
-      let setValues: unknown;
-
-      const specialBuilder = {
-        whereIndex(indexName: string, condition?: unknown) {
-          whereConfig = { indexName, condition };
-          return this;
-        },
-        set(values: unknown) {
-          setValues = values;
-          return this;
-        },
-      };
+      const table = schema.tables[tableName];
+      if (!table) {
+        throw new Error(`Table ${tableName} not found in schema`);
+      }
 
+      const specialBuilder = new UpdateManySpecialBuilder<typeof table>();
       builderFn(specialBuilder);
 
-      if (!whereConfig.indexName) {
+      const { indexName, condition, setValues } = specialBuilder.getConfig();
+
+      if (!indexName) {
         throw new Error("whereIndex() must be called in updateMany");
       }
       if (!setValues) {
         throw new Error("set() must be called in updateMany");
       }
 
-      // First, find all matching records
-      const findUow = createUOW();
+      const findUow = createUOW({ config: uowConfig });
       findUow.find(tableName, (b) => {
-        if (whereConfig.condition) {
-          return b.whereIndex(whereConfig.indexName as never, whereConfig.condition as never);
+        if (condition) {
+          // Safe: condition is captured from whereIndex call with proper typing
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          return b.whereIndex(indexName as ValidIndexName<typeof table>, condition as any);
         }
-        return b.whereIndex(whereConfig.indexName as never);
+        return b.whereIndex(indexName as ValidIndexName<typeof table>);
       });
-      const findResults: unknown[][] = await findUow.executeRetrieve();
-      const records = findResults[0];
+      const [records]: unknown[][] = await findUow.executeRetrieve();
 
       if (!records || records.length === 0) {
         return;
       }
 
-      // Now update all found records
-      const updateUow = createUOW();
-      for (const record of records as never as Array<{ id: unknown }>) {
-        updateUow.update(tableName as string, record.id as string, (b) =>
-          b.set(setValues as never),
-        );
+      const updateUow = createUOW({ config: uowConfig });
+      for (const record of records as Array<{ id: unknown }>) {
+        updateUow.update(tableName, record.id as string, (b) => b.set(setValues));
       }
       const { success } = await updateUow.executeMutations();
       if (!success) {
@@ -215,8 +339,8 @@ export function fromKysely<T extends AnySchema>(
     },
 
     async delete(tableName, id, builderFn) {
-      const uow = createUOW();
-      uow.delete(tableName, id, builderFn as never);
+      const uow = createUOW({ config: uowConfig });
+      uow.delete(tableName, id, builderFn);
       const { success } = await uow.executeMutations();
       if (!success) {
         throw new Error("Failed to delete record (version conflict or record not found)");
@@ -224,43 +348,17 @@ export function fromKysely<T extends AnySchema>(
     },
 
     async deleteMany(tableName, builderFn) {
-      // Create a special builder that captures where configuration
-      let whereConfig: { indexName?: string; condition?: unknown } = {};
-
-      const specialBuilder = {
-        whereIndex(indexName: string, condition?: unknown) {
-          whereConfig = { indexName, condition };
-          return this;
-        },
-      };
-
-      // Safe: Call builderFn to capture the configuration
-      builderFn(specialBuilder as never);
-
-      if (!whereConfig.indexName) {
-        throw new Error("whereIndex() must be called in deleteMany");
-      }
+      const findUow = createUOW({ config: uowConfig });
+      findUow.find(tableName, builderFn);
+      const [records]: unknown[][] = await findUow.executeRetrieve();
 
-      // First, find all matching records
-      const findUow = createUOW();
-      findUow.find(tableName as string, (b) => {
-        if (whereConfig.condition) {
-          return b.whereIndex(whereConfig.indexName as never, whereConfig.condition as never);
-        }
-        return b.whereIndex(whereConfig.indexName as never);
-      });
-      const findResults2 = await findUow.executeRetrieve();
-      const records = (findResults2 as unknown as [unknown])[0];
-
-      // @ts-expect-error - Type narrowing doesn't work through unknown cast
       if (!records || records.length === 0) {
         return;
       }
 
-      // Now delete all found records
-      const deleteUow = createUOW();
-      for (const record of records as never as Array<{ id: unknown }>) {
-        deleteUow.delete(tableName as string, record.id as string);
+      const deleteUow = createUOW({ config: uowConfig });
+      for (const record of records as Array<{ id: unknown }>) {
+        deleteUow.delete(tableName, record.id as string);
       }
       const { success } = await deleteUow.executeMutations();
       if (!success) {
@@ -268,8 +366,14 @@ export function fromKysely<T extends AnySchema>(
       }
     },
 
-    createUnitOfWork(name) {
-      return createUOW(name);
+    createUnitOfWork(name, nestedUowConfig) {
+      return createUOW({
+        name,
+        config: {
+          ...uowConfig,
+          ...nestedUowConfig,
+        },
+      });
     },
-  } as AbstractQuery<T>;
+  } as AbstractQuery<T, KyselyUOWConfig>;
 }

package/src/adapters/kysely/kysely-uow-compiler.test.ts

@@ -5,6 +5,7 @@ import { UnitOfWork, type UOWDecoder } from "../../query/unit-of-work";
 import { createKyselyUOWCompiler } from "./kysely-uow-compiler";
 import type { ConnectionPool } from "../../shared/connection-pool";
 import { createKyselyConnectionPool } from "./kysely-connection-pool";
+import { Cursor } from "../../query/cursor";
 
 describe("kysely-uow-compiler", () => {
   const testSchema = schema((s) => {
@@ -252,7 +253,12 @@ describe("kysely-uow-compiler", () => {
 
     it("should compile find operation with cursor pagination using after", () => {
       const uow = createTestUOW();
-      const cursor = "eyJpbmRleFZhbHVlcyI6eyJuYW1lIjoiQWxpY2UifSwiZGlyZWN0aW9uIjoiZm9yd2FyZCJ9"; // {"indexValues":{"name":"Alice"},"direction":"forward"}
+      const cursor = new Cursor({
+        indexName: "idx_name",
+        orderDirection: "asc",
+        pageSize: 10,
+        indexValues: { name: "Alice" },
+      });
       uow.find("users", (b) =>
         b.whereIndex("idx_name").orderByIndex("idx_name", "asc").after(cursor).pageSize(10),
       );
@@ -269,7 +275,12 @@ describe("kysely-uow-compiler", () => {
 
     it("should compile find operation with cursor pagination using before", () => {
       const uow = createTestUOW();
-      const cursor = "eyJpbmRleFZhbHVlcyI6eyJuYW1lIjoiQm9iIn0sImRpcmVjdGlvbiI6ImJhY2t3YXJkIn0="; // {"indexValues":{"name":"Bob"},"direction":"backward"}
+      const cursor = new Cursor({
+        indexName: "idx_name",
+        orderDirection: "desc",
+        pageSize: 10,
+        indexValues: { name: "Bob" },
+      });
       uow.find("users", (b) =>
         b.whereIndex("idx_name").orderByIndex("idx_name", "desc").before(cursor).pageSize(10),
       );
@@ -286,7 +297,12 @@ describe("kysely-uow-compiler", () => {
 
     it("should compile find operation with cursor pagination and additional where conditions", () => {
       const uow = createTestUOW();
-      const cursor = "eyJpbmRleFZhbHVlcyI6eyJuYW1lIjoiQWxpY2UifSwiZGlyZWN0aW9uIjoiZm9yd2FyZCJ9";
+      const cursor = new Cursor({
+        indexName: "idx_name",
+        orderDirection: "asc",
+        pageSize: 5,
+        indexValues: { name: "Alice" },
+      });
       uow.find("users", (b) =>
         b
           .whereIndex("idx_name", (eb) => eb("name", "starts with", "John"))
@@ -913,4 +929,70 @@ describe("kysely-uow-compiler", () => {
       expect(compiled.mutationBatch).toHaveLength(1);
     });
   });
+
+  describe("create and use ID in same UOW", () => {
+    it("should support creating and using ID in same UOW", () => {
+      const uow = createTestUOW("create-user-and-post");
+
+      // Create user and capture the returned ID
+      const userId = uow.create("users", {
+        name: "John Doe",
+        email: "john@example.com",
+        age: 30,
+      });
+
+      // Use the returned FragnoId directly to create a post
+      // The compiler should extract externalId and generate a subquery
+      uow.create("posts", {
+        userId: userId,
+        title: "My First Post",
+        content: "This is my first post",
+      });
+
+      const compiler = createKyselyUOWCompiler(testSchema, pool, "postgresql");
+      const compiled = uow.compile(compiler);
+
+      // Should have no retrieval operations
+      expect(compiled.retrievalBatch).toHaveLength(0);
+
+      // Should have 2 mutation operations (create user, create post)
+      expect(compiled.mutationBatch).toHaveLength(2);
+
+      const [userCreate, postCreate] = compiled.mutationBatch;
+      assert(userCreate);
+      assert(postCreate);
+
+      // Verify user create SQL
+      expect(userCreate.query.sql).toMatchInlineSnapshot(
+        `"insert into "users" ("id", "name", "email", "age") values ($1, $2, $3, $4) returning "users"."id" as "id", "users"."name" as "name", "users"."email" as "email", "users"."age" as "age", "users"."invitedBy" as "invitedBy", "users"."_internalId" as "_internalId", "users"."_version" as "_version""`,
+      );
+      expect(userCreate.query.parameters).toMatchObject([
+        userId.externalId, // The generated ID
+        "John Doe",
+        "john@example.com",
+        30,
+      ]);
+      expect(userCreate.expectedAffectedRows).toBeNull();
+
+      // Verify post create SQL - FragnoId generates subquery to lookup internal ID
+      expect(postCreate.query.sql).toMatchInlineSnapshot(
+        `"insert into "posts" ("id", "title", "content", "userId") values ($1, $2, $3, (select "_internalId" from "users" where "id" = $4 limit $5)) returning "posts"."id" as "id", "posts"."title" as "title", "posts"."content" as "content", "posts"."userId" as "userId", "posts"."viewCount" as "viewCount", "posts"."_internalId" as "_internalId", "posts"."_version" as "_version""`,
+      );
+      expect(postCreate.query.parameters).toMatchObject([
+        expect.any(String), // generated post ID
+        "My First Post",
+        "This is my first post",
+        userId.externalId, // FragnoId's externalId is used in the subquery
+        1, // limit parameter
+      ]);
+      expect(postCreate.expectedAffectedRows).toBeNull();
+
+      // Verify the returned FragnoId has the expected structure
+      expect(userId).toMatchObject({
+        externalId: expect.any(String),
+        version: 0,
+        internalId: undefined,
+      });
+    });
+  });
 });

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

@@ -105,8 +105,9 @@ export function createKyselyUOWCompiler<TSchema extends AnySchema>(
 
           if ((after || before) && indexColumns.length > 0) {
             const cursor = after || before;
-            const cursorData = decodeCursor(cursor!);
-            const serializedValues = serializeCursorValues(cursorData, indexColumns, provider);
+            // Decode cursor if it's a string, otherwise use it as-is
+            const cursorObj = typeof cursor === "string" ? decodeCursor(cursor!) : cursor!;
+            const serializedValues = serializeCursorValues(cursorObj, indexColumns, provider);
 
             // Build tuple comparison for cursor pagination
             // For "after" with "asc": (col1, col2, ...) > (val1, val2, ...)

package/src/adapters/kysely/kysely-uow-executor.ts

@@ -1,4 +1,4 @@
-import type { Kysely, QueryResult } from "kysely";
+import type { CompiledQuery, Kysely, QueryResult } from "kysely";
 import type { CompiledMutation, MutationResult } from "../../query/unit-of-work";
 
 function getAffectedRows(result: QueryResult<unknown>): number {
@@ -43,9 +43,7 @@ function getAffectedRows(result: QueryResult<unknown>): number {
 export async function executeKyselyRetrievalPhase(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   kysely: Kysely<any>,
-  retrievalBatch: (Kysely<unknown>["executeQuery"] extends (query: infer Q) => unknown
-    ? Q
-    : never)[],
+  retrievalBatch: CompiledQuery[],
 ): Promise<unknown[]> {
   // If no retrieval operations, return empty array immediately
   if (retrievalBatch.length === 0) {
@@ -56,8 +54,8 @@ export async function executeKyselyRetrievalPhase(
 
   // Execute all retrieval queries inside a transaction for snapshot isolation
   await kysely.transaction().execute(async (tx) => {
-    for (const query of retrievalBatch) {
-      const result = await tx.executeQuery(query);
+    for (const compiledQuery of retrievalBatch) {
+      const result = await tx.executeQuery(compiledQuery);
       retrievalResults.push(result.rows);
     }
   });
@@ -87,9 +85,7 @@ export async function executeKyselyRetrievalPhase(
 export async function executeKyselyMutationPhase(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   kysely: Kysely<any>,
-  mutationBatch: CompiledMutation<
-    Kysely<unknown>["executeQuery"] extends (query: infer Q) => unknown ? Q : never
-  >[],
+  mutationBatch: CompiledMutation<CompiledQuery>[],
 ): Promise<MutationResult> {
   // If there are no mutations, return success immediately
   if (mutationBatch.length === 0) {

package/src/migration-engine/generation-engine.ts

@@ -34,7 +34,8 @@ export interface ExecuteMigrationResult {
 }
 
 export async function generateMigrationsOrSchema<
-  const TDatabases extends FragnoDatabase<AnySchema>[],
+  // oxlint-disable-next-line no-explicit-any
+  const TDatabases extends FragnoDatabase<AnySchema, any>[],
 >(
   databases: TDatabases,
   options?: {

package/src/mod.ts

@@ -1,8 +1,11 @@
 import type { DatabaseAdapter } from "./adapters/adapters";
 import type { AnySchema } from "./schema/create";
 import type { AbstractQuery } from "./query/query";
+import type { CursorResult } from "./query/cursor";
+import { Cursor } from "./query/cursor";
 
-export type { DatabaseAdapter };
+export type { DatabaseAdapter, CursorResult };
+export { Cursor };
 
 export const fragnoDatabaseFakeSymbol = "$fragno-database" as const;
 export const fragnoDatabaseLibraryVersion = "0.1" as const;
@@ -52,7 +55,7 @@ export class FragnoDatabaseDefinition<const T extends AnySchema> {
   /**
    * Creates a FragnoDatabase instance by binding an adapter to this definition.
    */
-  create(adapter: DatabaseAdapter): FragnoDatabase<T> {
+  create<TUOWConfig = void>(adapter: DatabaseAdapter<TUOWConfig>): FragnoDatabase<T, TUOWConfig> {
     return new FragnoDatabase({
       namespace: this.#namespace,
       schema: this.#schema,
@@ -65,12 +68,12 @@ export class FragnoDatabaseDefinition<const T extends AnySchema> {
  * A Fragno database instance with a bound adapter.
  * Created from a FragnoDatabaseDefinition by calling .create(adapter).
  */
-export class FragnoDatabase<const T extends AnySchema> {
+export class FragnoDatabase<const T extends AnySchema, TUOWConfig = void> {
   #namespace: string;
   #schema: T;
-  #adapter: DatabaseAdapter;
+  #adapter: DatabaseAdapter<TUOWConfig>;
 
-  constructor(options: { namespace: string; schema: T; adapter: DatabaseAdapter }) {
+  constructor(options: { namespace: string; schema: T; adapter: DatabaseAdapter<TUOWConfig> }) {
     this.#namespace = options.namespace;
     this.#schema = options.schema;
     this.#adapter = options.adapter;
@@ -80,7 +83,7 @@ export class FragnoDatabase<const T extends AnySchema> {
     return fragnoDatabaseFakeSymbol;
   }
 
-  async createClient(): Promise<AbstractQuery<T>> {
+  async createClient(): Promise<AbstractQuery<T, TUOWConfig>> {
     const dbVersion = await this.#adapter.getSchemaVersion(this.#namespace);
     if (dbVersion !== this.#schema.version.toString()) {
       throw new Error(
@@ -112,7 +115,7 @@ export class FragnoDatabase<const T extends AnySchema> {
     return this.#schema;
   }
 
-  get adapter(): DatabaseAdapter {
+  get adapter(): DatabaseAdapter<TUOWConfig> {
     return this.#adapter;
   }
 }
@@ -129,3 +132,5 @@ export {
   type FragnoPublicConfigWithDatabase,
   type DatabaseFragmentContext,
 } from "./fragment";
+
+export { decodeCursor, type CursorData } from "./query/cursor";