@fragno-dev/db 0.1.13 → 0.1.15

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);
               }
@@ -436,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
@@ -459,9 +483,13 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
 
           const whereClause = whereClauses.length > 0 ? Drizzle.and(...whereClauses) : undefined;
 
+          // For cursor pagination, fetch one extra item to determine if there's a next page
+          // Only apply this when using the high-level findWithCursor() API (op.withCursor === true)
+          const effectiveLimit = pageSize && op.withCursor ? pageSize + 1 : pageSize;
+
           const queryConfig: Drizzle.DBQueryConfig<"many", boolean> = {
             columns,
-            limit: pageSize,
+            limit: effectiveLimit,
             where: whereClause,
             orderBy,
             with: {},
@@ -469,39 +497,54 @@ 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);
           }
 
-          const physicalTableName = mapper ? mapper.toPhysical(op.table.ormName) : op.table.ormName;
-          const compiledQuery = db.query[physicalTableName].findMany(queryConfig).toSQL();
+          // 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 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 encodedValues = encodeValues(op.values, table, true, provider, true);
           const values = processReferenceSubqueries(encodedValues);
 
           const compiledQuery = db.insert(drizzleTable).values(values).toSQL();
           return {
             query: compiledQuery,
             expectedAffectedRows: null, // creates don't need affected row checks
+            expectedReturnedRows: null,
           };
         }
 
         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);
@@ -523,8 +566,9 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
             return null;
           }
 
-          const whereClause = condition === true ? undefined : buildWhere(condition);
-          const encodedSetValues = encodeValues(op.set, table, false, provider);
+          const whereClause =
+            condition === true ? undefined : buildWhere(schema, op.namespace, condition);
+          const encodedSetValues = encodeValues(op.set, table, false, provider, true);
           const setValues = processReferenceSubqueries(encodedSetValues);
 
           // Automatically increment _version for optimistic concurrency control
@@ -537,14 +581,15 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
           return {
             query: compiledQuery,
             expectedAffectedRows: op.checkVersion ? 1 : null,
+            expectedReturnedRows: null,
           };
         }
 
         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(
@@ -582,12 +627,48 @@ 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 {
             query: compiledQuery,
             expectedAffectedRows: op.checkVersion ? 1 : null,
+            expectedReturnedRows: null,
+          };
+        }
+
+        case "check": {
+          const table = getTable(schema, op.table);
+          const idColumn = table.getIdColumn();
+          const versionColumn = table.getVersionColumn();
+          const drizzleTable = toDrizzleTable(table, op.namespace);
+
+          const externalId = op.id.externalId;
+          const version = op.id.version;
+
+          // Build WHERE clause that filters by ID and version
+          const condition = buildCondition(table.columns, (eb) =>
+            eb.and(eb(idColumn.ormName, "=", externalId), eb(versionColumn.ormName, "=", version)),
+          );
+
+          if (typeof condition === "boolean") {
+            throw new Error("Condition is a boolean, but should be a condition object.");
+          }
+
+          // Build a SELECT query to check if the row exists with the correct version
+          // Use sql`1` to select a constant with an alias
+          const compiledQuery = db
+            .select({ exists: Drizzle.sql<number>`1`.as("exists") })
+            .from(drizzleTable)
+            .where(buildWhere(schema, op.namespace, condition))
+            .limit(1)
+            .toSQL();
+
+          return {
+            query: compiledQuery,
+            expectedAffectedRows: null,
+            expectedReturnedRows: 1, // Check that exactly 1 row was returned
           };
         }
       }

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

@@ -143,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");
       }
@@ -182,35 +179,45 @@ export function createDrizzleUOWDecoder<TSchema 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 cursorResult: CursorResult<unknown> = {
-          items: decodedRows,
+          items,
           cursor,
+          hasNextPage,
         };
         return cursorResult;
       }

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

@@ -75,7 +75,6 @@ function toSQL(query: DrizzleCompiledQuery, provider: "sqlite" | "mysql" | "post
 
   const queryChunks =
     provider === "sqlite" ? sqliteToSQL(sqlString, params) : postgresToSQL(sqlString, params);
-
   return new SQL(queryChunks);
 }
 
@@ -160,7 +159,24 @@ function extractCreatedInternalId(result: unknown): bigint | null {
   return null;
 }
 
+function validateReturnedRows(result: unknown, expected: number): void {
+  // For SELECT queries, check the number of rows returned
+  // Result can be an array (sync) or an object with rows property (async)
+  let rowCount = 0;
+  if (Array.isArray(result)) {
+    rowCount = result.length;
+  } else if (result && typeof result === "object" && "rows" in result) {
+    const rows = (result as { rows: unknown[] }).rows;
+    rowCount = Array.isArray(rows) ? rows.length : 0;
+  }
+
+  if (rowCount !== expected) {
+    throw new Error(`Version conflict: expected ${expected} rows returned, but got ${rowCount}`);
+  }
+}
+
 function validateAffectedRows(result: unknown, expected: number): void {
+  // For UPDATE/DELETE queries, check affected rows
   const actual = getAffectedRows(result);
   if (actual !== expected) {
     throw new Error(`Version conflict: expected ${expected} rows affected, but got ${actual}`);
@@ -235,21 +251,32 @@ export async function executeDrizzleMutationPhase(
       db,
       provider,
       (syncDb) => {
-        for (const { query, expectedAffectedRows } of mutationBatch) {
+        for (const { query, expectedAffectedRows, expectedReturnedRows } of mutationBatch) {
           const sqlObj = toSQL(query, provider);
+
           // Type assertion needed due to drizzle-orm version mismatch in dependencies
-          const result = syncDb.run(sqlObj as never);
+          const result =
+            expectedReturnedRows !== null
+              ? syncDb.all(sqlObj as never)
+              : syncDb.run(sqlObj as never);
 
-          if (expectedAffectedRows === null) {
+          if (expectedAffectedRows === null && expectedReturnedRows === null) {
             createdInternalIds.push(extractCreatedInternalId(result));
-          } else {
+          }
+
+          if (expectedReturnedRows !== null) {
+            validateReturnedRows(result, expectedReturnedRows);
+          }
+
+          if (expectedAffectedRows !== null) {
             validateAffectedRows(result, expectedAffectedRows);
           }
         }
       },
       async (tx) => {
-        for (const { query, expectedAffectedRows } of mutationBatch) {
+        for (const { query, expectedAffectedRows, expectedReturnedRows } of mutationBatch) {
           const sqlObj = toSQL(query, provider);
+
           // Fallback to run when execute is not available (e.g., libsql)
           const executeMethod = tx.execute ?? tx.run;
           if (!executeMethod) {
@@ -257,9 +284,15 @@ export async function executeDrizzleMutationPhase(
           }
           const result = await executeMethod.call(tx, sqlObj);
 
-          if (expectedAffectedRows === null) {
+          if (expectedAffectedRows === null && expectedReturnedRows === null) {
             createdInternalIds.push(extractCreatedInternalId(result));
-          } else {
+          }
+
+          if (expectedReturnedRows !== null) {
+            validateReturnedRows(result, expectedReturnedRows);
+          }
+
+          if (expectedAffectedRows !== null) {
             validateAffectedRows(result, expectedAffectedRows);
           }
         }