@fragno-dev/db 0.1.12 → 0.1.14

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

@@ -14,6 +14,7 @@ import {
   type TableNameMapper,
   parseDrizzle,
   type DBType,
+  createTableNameMapper,
 } from "./shared";
 import { encodeValues, ReferenceSubquery } from "../../query/result-transform";
 import { serialize } from "../../schema/serialize";
@@ -33,30 +34,42 @@ export type DrizzleCompiledQuery = {
  * This compiler translates UOW operations into Drizzle query functions
  * that can be executed as a batch/transaction.
  *
- * @param schema - The database schema
  * @param pool - Connection pool for acquiring database connections
  * @param provider - SQL provider (sqlite, mysql, postgresql)
- * @param mapper - Optional table name mapper for namespace prefixing
+ * @param mapper - Optional table name mapper for namespace prefixing (fallback for operations without explicit namespace)
  * @returns A UOWCompiler instance for Drizzle
  */
-export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
-  schema: TSchema,
+export function createDrizzleUOWCompiler(
   pool: ConnectionPool<DBType>,
   provider: "sqlite" | "mysql" | "postgresql",
   mapper?: TableNameMapper,
-): UOWCompiler<TSchema, DrizzleCompiledQuery> {
+): UOWCompiler<DrizzleCompiledQuery> {
   // Get db synchronously for compilation (doesn't execute, just builds SQL)
   // TODO: We don't even need a Drizzle instance with a db client attached here. `drizzle({ schema })` is enough.
   const dbRaw = pool.getDatabaseSync();
   const [db, drizzleTables] = parseDrizzle(dbRaw);
 
+  /**
+   * Get the mapper for a specific operation
+   * Uses operation's namespace if provided, otherwise falls back to the default mapper
+   */
+  function getMapperForOperation(namespace: string | undefined): TableNameMapper | undefined {
+    if (namespace) {
+      return createTableNameMapper(namespace);
+    }
+    return mapper;
+  }
+
   /**
    * Convert a Fragno table to a Drizzle table
    * @throws Error if table is not found in Drizzle schema
    */
-  function toDrizzleTable(table: AnyTable): TableType {
-    // Map logical table name to physical table name using the mapper
-    const physicalTableName = mapper ? mapper.toPhysical(table.ormName) : table.ormName;
+  function toDrizzleTable(table: AnyTable, namespace: string | undefined): TableType {
+    // Get the mapper for this operation's namespace
+    const opMapper = getMapperForOperation(namespace);
+
+    // Map logical table name to physical table name using the operation-specific mapper
+    const physicalTableName = opMapper ? opMapper.toPhysical(table.ormName) : table.ormName;
     const out = drizzleTables[physicalTableName];
     if (out) {
       return out;
@@ -71,13 +84,17 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
    * Convert a Fragno column to a Drizzle column
    * @throws Error if column is not found in Drizzle table
    */
-  function toDrizzleColumn(col: AnyColumn): ColumnType {
+  function toDrizzleColumn(
+    schema: AnySchema,
+    namespace: string | undefined,
+    col: AnyColumn,
+  ): ColumnType {
     const fragnoTable = schema.tables[col.tableName];
     if (!fragnoTable) {
       throw new Error(`[Drizzle] Unknown table ${col.tableName} for column ${col.ormName}.`);
     }
 
-    const table = toDrizzleTable(fragnoTable);
+    const table = toDrizzleTable(fragnoTable, namespace);
     const out = table[col.ormName];
     if (out) {
       return out;
@@ -89,13 +106,17 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
   /**
    * Build a WHERE clause from a condition using Drizzle's query builder
    */
-  function buildWhere(condition: Condition): Drizzle.SQL | undefined {
+  function buildWhere(
+    schema: AnySchema,
+    namespace: string | undefined,
+    condition: Condition,
+  ): Drizzle.SQL | undefined {
     if (condition.type === "compare") {
-      const left = toDrizzleColumn(condition.a);
+      const left = toDrizzleColumn(schema, namespace, condition.a);
       const op = condition.operator;
       let right = condition.b;
       if (right instanceof Column) {
-        right = toDrizzleColumn(right);
+        right = toDrizzleColumn(schema, namespace, right);
       } else {
         // Handle string references - convert external ID to internal ID via subquery
         if (condition.a.role === "reference" && typeof right === "string") {
@@ -181,11 +202,11 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
     }
 
     if (condition.type === "and") {
-      return Drizzle.and(...condition.items.map((item) => buildWhere(item)));
+      return Drizzle.and(...condition.items.map((item) => buildWhere(schema, namespace, item)));
     }
 
     if (condition.type === "not") {
-      const result = buildWhere(condition.item);
+      const result = buildWhere(schema, namespace, condition.item);
       if (!result) {
         return;
       }
@@ -193,7 +214,7 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
       return Drizzle.not(result);
     }
 
-    return Drizzle.or(...condition.items.map((item) => buildWhere(item)));
+    return Drizzle.or(...condition.items.map((item) => buildWhere(schema, namespace, item)));
   }
 
   /**
@@ -229,7 +250,7 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
    * Get table from schema by name
    * @throws Error if table is not found in schema
    */
-  function getTable(name: unknown): AnyTable {
+  function getTable(schema: AnySchema, name: unknown): AnyTable {
     const table = schema.tables[name as string];
     if (!table) {
       throw new Error(`Invalid table name ${name}.`);
@@ -260,6 +281,8 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
    * Process joins recursively to support nested joins with orderBy and limit
    */
   function processJoins(
+    schema: AnySchema,
+    namespace: string | undefined,
     joins: CompiledJoin[],
   ): Record<string, Drizzle.DBQueryConfig<"many", boolean>> {
     const result: Record<string, Drizzle.DBQueryConfig<"many", boolean>> = {};
@@ -286,7 +309,7 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
       let joinOrderBy: Drizzle.SQL[] | undefined;
       if (options.orderBy && options.orderBy.length > 0) {
         joinOrderBy = options.orderBy.map(([col, direction]) => {
-          const drizzleCol = toDrizzleColumn(col);
+          const drizzleCol = toDrizzleColumn(schema, namespace, col);
           return direction === "asc" ? Drizzle.asc(drizzleCol) : Drizzle.desc(drizzleCol);
         });
       }
@@ -294,7 +317,7 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
       // Build WHERE clause for this join if provided
       let joinWhere: Drizzle.SQL | undefined;
       if (options.where) {
-        joinWhere = buildWhere(options.where);
+        joinWhere = buildWhere(schema, namespace, options.where);
       }
 
       // Build the join config
@@ -307,7 +330,7 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
 
       // Recursively process nested joins
       if (options.join && options.join.length > 0) {
-        joinConfig.with = processJoins(options.join);
+        joinConfig.with = processJoins(schema, namespace, options.join);
       }
 
       result[joinName] = joinConfig;
@@ -317,7 +340,8 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
   }
 
   return {
-    compileRetrievalOperation(op: RetrievalOperation<TSchema>): DrizzleCompiledQuery | null {
+    compileRetrievalOperation(op: RetrievalOperation<AnySchema>): DrizzleCompiledQuery | null {
+      const schema = op.schema;
       switch (op.type) {
         case "count": {
           // Build WHERE clause
@@ -329,11 +353,11 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
               return null;
             }
             if (condition !== true) {
-              whereClause = buildWhere(condition);
+              whereClause = buildWhere(schema, op.namespace, condition);
             }
           }
 
-          const drizzleTable = toDrizzleTable(op.table);
+          const drizzleTable = toDrizzleTable(op.table, op.namespace);
           const query = db.select({ count: Drizzle.count() }).from(drizzleTable);
 
           const compiledQuery = whereClause ? query.where(whereClause).toSQL() : query.toSQL();
@@ -377,7 +401,7 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
           let orderBy: Drizzle.SQL[] | undefined;
           if (indexColumns.length > 0) {
             orderBy = indexColumns.map((col) => {
-              const drizzleCol = toDrizzleColumn(col);
+              const drizzleCol = toDrizzleColumn(schema, op.namespace, col);
               return orderDirection === "asc" ? Drizzle.asc(drizzleCol) : Drizzle.desc(drizzleCol);
             });
           }
@@ -413,7 +437,7 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
               return null;
             }
             if (condition !== true) {
-              const clause = buildWhere(condition);
+              const clause = buildWhere(schema, op.namespace, condition);
               if (clause) {
                 whereClauses.push(clause);
               }
@@ -423,8 +447,9 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
           // Add cursor-based pagination conditions
           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, ...)
@@ -435,12 +460,12 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
 
             if (indexColumns.length === 1) {
               // Simple single-column case
-              const col = toDrizzleColumn(indexColumns[0]!);
+              const col = toDrizzleColumn(schema, op.namespace, indexColumns[0]!);
               const val = serializedValues[indexColumns[0]!.ormName];
               whereClauses.push(useGreaterThan ? Drizzle.gt(col, val) : Drizzle.lt(col, val));
             } else {
               // Multi-column tuple comparison using SQL
-              const drizzleCols = indexColumns.map((c) => toDrizzleColumn(c));
+              const drizzleCols = indexColumns.map((c) => toDrizzleColumn(schema, op.namespace, c));
               const vals = indexColumns.map((c) => serializedValues[c.ormName]);
               const operator = useGreaterThan ? ">" : "<";
               // Safe cast: building a SQL comparison expression for cursor pagination
@@ -468,23 +493,37 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
 
           // Process joins recursively to support nested joins
           if (joins) {
-            queryConfig.with = processJoins(joins);
+            queryConfig.with = processJoins(schema, op.namespace, joins);
+          }
+
+          // For multi-schema support: get the mapper for the operation's namespace
+          const opMapper = getMapperForOperation(op.namespace);
+          const physicalTableName = opMapper
+            ? opMapper.toPhysical(op.table.ormName)
+            : op.table.ormName;
+          const tableQuery = db.query[physicalTableName];
+
+          if (!tableQuery) {
+            throw new Error(
+              `[Drizzle] Table ${op.table.ormName} (physical: ${physicalTableName}) not found in db.query. ` +
+                `Available tables: ${Object.keys(db.query).join(", ")}`,
+            );
           }
 
-          const physicalTableName = mapper ? mapper.toPhysical(op.table.ormName) : op.table.ormName;
-          const compiledQuery = db.query[physicalTableName].findMany(queryConfig).toSQL();
+          const compiledQuery = tableQuery.findMany(queryConfig).toSQL();
           return compiledQuery;
         }
       }
     },
 
     compileMutationOperation(
-      op: MutationOperation<TSchema>,
+      op: MutationOperation<AnySchema>,
     ): CompiledMutation<DrizzleCompiledQuery> | null {
+      const schema = op.schema;
       switch (op.type) {
         case "create": {
-          const table = getTable(op.table);
-          const drizzleTable = toDrizzleTable(table);
+          const table = getTable(schema, op.table);
+          const drizzleTable = toDrizzleTable(table, op.namespace);
           // encodeValues now handles runtime defaults automatically
           const encodedValues = encodeValues(op.values, table, true, provider);
           const values = processReferenceSubqueries(encodedValues);
@@ -497,10 +536,10 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
         }
 
         case "update": {
-          const table = getTable(op.table);
+          const table = getTable(schema, op.table);
           const idColumn = table.getIdColumn();
           const versionColumn = table.getVersionColumn();
-          const drizzleTable = toDrizzleTable(table);
+          const drizzleTable = toDrizzleTable(table, op.namespace);
 
           const externalId = typeof op.id === "string" ? op.id : op.id.externalId;
           const versionToCheck = getVersionToCheck(op.id, op.checkVersion);
@@ -522,7 +561,8 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
             return null;
           }
 
-          const whereClause = condition === true ? undefined : buildWhere(condition);
+          const whereClause =
+            condition === true ? undefined : buildWhere(schema, op.namespace, condition);
           const encodedSetValues = encodeValues(op.set, table, false, provider);
           const setValues = processReferenceSubqueries(encodedSetValues);
 
@@ -540,10 +580,10 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
         }
 
         case "delete": {
-          const table = getTable(op.table);
+          const table = getTable(schema, op.table);
           const idColumn = table.getIdColumn();
           const versionColumn = table.getVersionColumn();
-          const drizzleTable = toDrizzleTable(table);
+          const drizzleTable = toDrizzleTable(table, op.namespace);
 
           if (!op.id) {
             throw new Error(
@@ -581,7 +621,8 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
             return null;
           }
 
-          const whereClause = condition === true ? undefined : buildWhere(condition);
+          const whereClause =
+            condition === true ? undefined : buildWhere(schema, op.namespace, condition);
 
           const compiledQuery = db.delete(drizzleTable).where(whereClause).toSQL();
           return {

package/src/adapters/drizzle/drizzle-uow-decoder.ts

@@ -4,6 +4,7 @@ import type { RetrievalOperation, UOWDecoder } from "../../query/unit-of-work";
 import { decodeResult } from "../../query/result-transform";
 import { getOrderedJoinColumns } from "./join-column-utils";
 import type { DrizzleResult } from "./shared";
+import { createCursorFromRecord, Cursor, type CursorResult } from "../../query/cursor";
 
 /**
  * Join information with nested join support
@@ -142,17 +143,14 @@ function transformJoinArraysToObjects(
   return transformedRow;
 }
 
-export function createDrizzleUOWDecoder<TSchema extends AnySchema>(
-  _schema: TSchema,
-  provider: SQLProvider,
-): UOWDecoder<TSchema, DrizzleResult> {
+export function createDrizzleUOWDecoder(provider: SQLProvider): UOWDecoder<DrizzleResult> {
   return (rawResults, ops) => {
     if (rawResults.length !== ops.length) {
       throw new Error("rawResults and ops must have the same length");
     }
 
     return rawResults.map((result, index) => {
-      const op = ops[index] as RetrievalOperation<TSchema>;
+      const op = ops[index] as RetrievalOperation<AnySchema>;
       if (!op) {
         throw new Error("op must be defined");
       }
@@ -173,10 +171,48 @@ export function createDrizzleUOWDecoder<TSchema extends AnySchema>(
       }
 
       // Handle find operations - decode each row
-      return result.rows.map((row) => {
+      const decodedRows = result.rows.map((row) => {
         const transformedRow = transformJoinArraysToObjects(row, op, provider);
         return decodeResult(transformedRow, 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 cursorResult: CursorResult<unknown> = {
+          items: decodedRows,
+          cursor,
+        };
+        return cursorResult;
+      }
+
+      return decodedRows;
     });
   };
 }

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

@@ -10,7 +10,7 @@ import {
   type FragnoId,
   type FragnoReference,
 } from "../../schema/create";
-import { encodeCursor } from "../../query/cursor";
+import { Cursor } from "../../query/cursor";
 
 describe("KyselyAdapter PGLite", () => {
   const testSchema = schema((s) => {
@@ -396,10 +396,12 @@ describe("KyselyAdapter PGLite", () => {
 
     // Get cursor for pagination (using the last item from page 1)
     const lastItem = page1Results[page1Results.length - 1]!;
-    const cursor = encodeCursor({
+    const cursor = new Cursor({
+      indexName: "name_idx",
+      orderDirection: "asc",
+      pageSize: 2,
       indexValues: { name: lastItem.name },
-      direction: "forward",
-    });
+    }).encode();
 
     // Get page 2 using the cursor
     const page2 = queryEngine
@@ -785,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
@@ -824,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");
@@ -872,4 +874,100 @@ describe("KyselyAdapter PGLite", () => {
     // Verify the foreign key relationship is correct
     expect(post?.user_id.internalId).toBe(user?.id.internalId);
   });
+
+  it("should support cursor-based pagination with findWithCursor()", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+
+    // Create multiple users for pagination testing with unique prefix
+    const prefix = "CursorPagTest";
+    const userIds: FragnoId[] = [];
+    for (let i = 1; i <= 25; i++) {
+      const userId = await queryEngine.create("users", {
+        name: `${prefix} ${i.toString().padStart(2, "0")}`,
+        age: 20 + i,
+      });
+      userIds.push(userId);
+    }
+
+    // Fetch first page with cursor (filter by prefix to avoid other test data)
+    const firstPage = await queryEngine.findWithCursor("users", (b) =>
+      b.whereIndex("name_idx").orderByIndex("name_idx", "asc").pageSize(10),
+    );
+
+    // Check structure
+    expect(firstPage).toHaveProperty("items");
+    expect(firstPage).toHaveProperty("cursor");
+    expect(Array.isArray(firstPage.items)).toBe(true);
+    expect(firstPage.items.length).toBeGreaterThan(0);
+
+    assert(firstPage.cursor instanceof Cursor);
+
+    // Fetch second page using cursor
+    const secondPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_idx")
+        .after(firstPage.cursor!)
+        .orderByIndex("name_idx", "asc")
+        .pageSize(10),
+    );
+
+    expect(secondPage.items.length).toBeGreaterThan(0);
+
+    // Verify no overlap - all names in second page should be different from first page
+    const firstPageNames = new Set(firstPage.items.map((u) => u.name));
+    const secondPageNames = secondPage.items.map((u) => u.name);
+
+    for (const name of secondPageNames) {
+      expect(firstPageNames.has(name)).toBe(false);
+    }
+
+    // Verify ordering - last item of first page should come before first item of second page
+    const firstPageLast = firstPage.items[firstPage.items.length - 1].name;
+    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),
+    );
+    const testUserNames = testUsers.filter((u) => u.name.startsWith(prefix)).map((u) => u.name);
+    expect(testUserNames).toHaveLength(25);
+  });
+
+  it("should support findWithCursor() in Unit of Work", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+
+    // Create test users if not already present
+    const existingUsers = await queryEngine.find("users", (b) =>
+      b.whereIndex("name_idx").pageSize(1),
+    );
+
+    if (existingUsers.length === 0) {
+      for (let i = 1; i <= 5; i++) {
+        await queryEngine.create("users", {
+          name: `UOW Cursor User ${i}`,
+          age: 30 + i,
+        });
+      }
+    }
+
+    // Use findWithCursor in UOW
+    const uow = queryEngine
+      .createUnitOfWork("cursor-test")
+      .findWithCursor("users", (b) =>
+        b.whereIndex("name_idx").orderByIndex("name_idx", "asc").pageSize(3),
+      );
+
+    const [result] = await uow.executeRetrieve();
+
+    // Verify result structure
+    expect(result).toHaveProperty("items");
+    expect(result).toHaveProperty("cursor");
+    expect(Array.isArray(result.items)).toBe(true);
+    expect(result.items.length).toBeGreaterThan(0);
+
+    if (result.items.length === 3) {
+      expect(result.cursor).toBeInstanceOf(Cursor);
+    }
+  });
 });

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

@@ -28,6 +28,7 @@ export interface KyselyConfig {
 export class KyselyAdapter implements DatabaseAdapter<KyselyUOWConfig> {
   #connectionPool: ConnectionPool<KyselyAny>;
   #provider: SQLProvider;
+  #schemaNamespaceMap = new WeakMap<AnySchema, string>();
 
   constructor(config: KyselyConfig) {
     this.#connectionPool = createKyselyConnectionPool(config.db);
@@ -46,13 +47,27 @@ export class KyselyAdapter implements DatabaseAdapter<KyselyUOWConfig> {
     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> {