@fragno-dev/db 0.1.7 → 0.1.9

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

@@ -388,6 +388,131 @@ describe("drizzle-uow-compiler", () => {
       ]);
     });
 
+    it("should compile create operation with external id string for reference column", () => {
+      const uow = createTestUOW();
+      // Create a post with userId as just an external id string
+      uow.create("posts", {
+        title: "Test Post",
+        content: "Post content",
+        userId: "user_external_id_123",
+        viewCount: 5,
+      });
+
+      const compiler = createDrizzleUOWCompiler(testSchema, pool, "postgresql");
+      const compiled = uow.compile(compiler);
+      const [batch] = compiled.mutationBatch;
+      assert(batch);
+      expect(batch.expectedAffectedRows).toBeNull();
+      expect(batch.query.sql).toMatchInlineSnapshot(
+        `"insert into "posts" ("id", "title", "content", "userId", "viewCount", "_internalId", "_version") values ($1, $2, $3, (select "_internalId" from "users" where "id" = $4 limit 1), $5, default, default)"`,
+      );
+      expect(batch.query.params).toMatchObject([
+        expect.any(String), // auto-generated post ID
+        "Test Post",
+        "Post content",
+        "user_external_id_123", // external id string
+        5, // viewCount
+      ]);
+    });
+
+    it("should compile create operation with bigint for reference column (no subquery)", () => {
+      const uow = createTestUOW();
+      // Create a post with userId as a bigint directly (internal ID)
+      uow.create("posts", {
+        title: "Direct ID Post",
+        content: "Content with direct bigint",
+        userId: 12345n,
+      });
+
+      const compiler = createDrizzleUOWCompiler(testSchema, pool, "postgresql");
+      const compiled = uow.compile(compiler);
+      const [batch] = compiled.mutationBatch;
+      assert(batch);
+      expect(batch.expectedAffectedRows).toBeNull();
+      // Should NOT have a subquery when using bigint directly
+      expect(batch.query.sql).not.toMatch(/\(select.*from.*users/i);
+      expect(batch.query.sql).toMatchInlineSnapshot(
+        `"insert into "posts" ("id", "title", "content", "userId", "viewCount", "_internalId", "_version") values ($1, $2, $3, $4, default, default, default)"`,
+      );
+      expect(batch.query.params).toMatchObject([
+        expect.any(String), // auto-generated post ID
+        "Direct ID Post",
+        "Content with direct bigint",
+        12345n, // bigint internal ID directly
+      ]);
+    });
+
+    it("should compile create operation with FragnoId object for reference column", () => {
+      const uow = createTestUOW();
+      const userId = FragnoId.fromExternal("user_ext_789", 0);
+      // Create a post with userId as a FragnoId object
+      uow.create("posts", {
+        title: "Post with FragnoId",
+        content: "Content",
+        userId,
+      });
+
+      const compiler = createDrizzleUOWCompiler(testSchema, pool, "postgresql");
+      const compiled = uow.compile(compiler);
+      const [batch] = compiled.mutationBatch;
+      assert(batch);
+      expect(batch.expectedAffectedRows).toBeNull();
+      // FragnoId should use internal ID directly (no subquery needed if available)
+      // But since we don't have the internal ID populated in the test, it should serialize
+      expect(batch.query.sql).toMatchInlineSnapshot(
+        `"insert into "posts" ("id", "title", "content", "userId", "viewCount", "_internalId", "_version") values ($1, $2, $3, $4, default, default, default)"`,
+      );
+    });
+
+    it("should compile update operation with external id string for reference column", () => {
+      const uow = createTestUOW();
+      const postId = FragnoId.fromExternal("post123", 0);
+      uow.update("posts", postId, (b) =>
+        b.set({
+          userId: "new_user_external_id_456",
+        }),
+      );
+
+      const compiler = createDrizzleUOWCompiler(testSchema, pool, "postgresql");
+      const compiled = uow.compile(compiler);
+      const [batch] = compiled.mutationBatch;
+      assert(batch);
+      expect(batch.expectedAffectedRows).toBeNull();
+      // Should generate a subquery for the string external ID in UPDATE
+      expect(batch.query.sql).toMatchInlineSnapshot(
+        `"update "posts" set "userId" = (select "_internalId" from "users" where "id" = $1 limit 1), "_version" = COALESCE(_version, 0) + 1 where "posts"."id" = $2"`,
+      );
+      expect(batch.query.params).toMatchObject([
+        "new_user_external_id_456", // external id string
+        "post123", // post external id
+      ]);
+    });
+
+    it("should compile update operation with bigint for reference column (no subquery)", () => {
+      const uow = createTestUOW();
+      const postId = FragnoId.fromExternal("post456", 0);
+      uow.update("posts", postId, (b) =>
+        b.set({
+          userId: 99999n,
+        }),
+      );
+
+      const compiler = createDrizzleUOWCompiler(testSchema, pool, "postgresql");
+      const compiled = uow.compile(compiler);
+      const [batch] = compiled.mutationBatch;
+      assert(batch);
+      expect(batch.expectedAffectedRows).toBeNull();
+      // Should NOT have a subquery when using bigint directly
+      expect(batch.query.sql).not.toMatch(/\(select.*from.*users/i);
+      expect(batch.query.sql).toMatchInlineSnapshot(
+        `"update "posts" set "userId" = $1, "_version" = COALESCE(_version, 0) + 1 where "posts"."id" = $2"`,
+      );
+      expect(batch.query.params).toMatchObject([
+        99999n, // bigint internal ID directly
+        "post456", // post external id
+      ]);
+    });
+
     it("should compile update operation with ID", () => {
       const uow = createTestUOW();
       const userId = FragnoId.fromExternal("user123", 0);
@@ -1082,4 +1207,101 @@ describe("drizzle-uow-compiler", () => {
       );
     });
   });
+
+  describe("auth schema with session joins", () => {
+    const authSchema = schema((s) => {
+      return s
+        .addTable("user", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("email", column("string"))
+            .addColumn("passwordHash", column("string"))
+            .addColumn(
+              "createdAt",
+              column("timestamp").defaultTo$((b) => b.now()),
+            )
+            .createIndex("idx_user_email", ["email"]);
+        })
+        .addTable("session", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("userId", referenceColumn())
+            .addColumn("expiresAt", column("timestamp"))
+            .addColumn(
+              "createdAt",
+              column("timestamp").defaultTo$((b) => b.now()),
+            )
+            .createIndex("idx_session_user", ["userId"]);
+        })
+        .addReference("sessionOwner", {
+          from: {
+            table: "session",
+            column: "userId",
+          },
+          to: {
+            table: "user",
+            column: "id",
+          },
+          type: "one",
+        });
+    });
+
+    let authDb: DBType;
+    let authPool: ConnectionPool<DBType>;
+
+    beforeAll(async () => {
+      // Write schema to file and dynamically import it
+      const { schemaModule, cleanup } = await writeAndLoadSchema(
+        "drizzle-uow-compiler-auth",
+        authSchema,
+        "postgresql",
+      );
+
+      // Create Drizzle instance with PGLite (in-memory Postgres)
+      authDb = drizzle({
+        schema: schemaModule,
+      }) as unknown as DBType;
+
+      // Wrap in connection pool
+      authPool = createDrizzleConnectionPool(authDb);
+
+      return async () => {
+        await cleanup();
+      };
+    }, 12000);
+
+    function createAuthUOW(name?: string) {
+      const compiler = createDrizzleUOWCompiler(authSchema, authPool, "postgresql");
+      const mockExecutor = {
+        executeRetrievalPhase: async () => [],
+        executeMutationPhase: async () => ({ success: true, createdInternalIds: [] }),
+      };
+      const mockDecoder: UOWDecoder<typeof authSchema> = (rawResults, operations) => {
+        if (rawResults.length !== operations.length) {
+          throw new Error("rawResults and ops must have the same length");
+        }
+        return rawResults;
+      };
+      return new UnitOfWork(authSchema, compiler, mockExecutor, mockDecoder, name);
+    }
+
+    it("should compile find session with user join", () => {
+      const uow = createAuthUOW();
+      const sessionId = "session123";
+      uow.find("session", (b) =>
+        b
+          .whereIndex("primary", (eb) => eb("id", "=", sessionId))
+          .join((j) => j.sessionOwner((b) => b.select(["id", "email"]))),
+      );
+
+      const compiler = createDrizzleUOWCompiler(authSchema, authPool, "postgresql");
+      const compiled = uow.compile(compiler);
+
+      expect(compiled.retrievalBatch).toHaveLength(1);
+      expect(compiled.retrievalBatch[0].sql).toMatchInlineSnapshot(
+        `"select "session"."id", "session"."userId", "session"."expiresAt", "session"."createdAt", "session"."_internalId", "session"."_version", "session_sessionOwner"."data" as "sessionOwner" from "session" "session" left join lateral (select json_build_array("session_sessionOwner"."id", "session_sessionOwner"."email", "session_sessionOwner"."_internalId", "session_sessionOwner"."_version") as "data" from (select * from "user" "session_sessionOwner" where "session_sessionOwner"."_internalId" = "session"."userId" limit $1) "session_sessionOwner") "session_sessionOwner" on true where "session"."id" = $2"`,
+      );
+      expect(compiled.retrievalBatch[0].params).toEqual([1, sessionId]);
+    });
+  });
 });

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

@@ -37,7 +37,6 @@ export type DrizzleCompiledQuery = {
  * @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 onQuery - Optional callback to receive compiled queries for logging/debugging
  * @returns A UOWCompiler instance for Drizzle
  */
 export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
@@ -45,7 +44,6 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
   pool: ConnectionPool<DBType>,
   provider: "sqlite" | "mysql" | "postgresql",
   mapper?: TableNameMapper,
-  onQuery?: (query: DrizzleCompiledQuery) => void,
 ): UOWCompiler<TSchema, 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.
@@ -185,16 +183,15 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
         const externalId = value.externalIdValue;
         const internalIdCol = refTable.getInternalIdColumn();
         const idCol = refTable.getIdColumn();
-        const drizzleRefTable = toDrizzleTable(refTable);
-        const drizzleIdCol = toDrizzleColumn(idCol);
 
-        // Create a parameterized SQL subquery using Drizzle's query builder
+        // Map logical table name to physical table name using the mapper
+        const physicalTableName = mapper ? mapper.toPhysical(refTable.ormName) : refTable.ormName;
+
+        // Build a SQL subquery using Drizzle's sql template
+        // This creates a subquery: (SELECT _internalId FROM table WHERE id = ? LIMIT 1)
         // Safe cast: we're building a SQL subquery that returns a single bigint value
-        processed[key] = db
-          .select({ value: drizzleRefTable[internalIdCol.ormName] })
-          .from(drizzleRefTable)
-          .where(Drizzle.eq(drizzleIdCol, externalId))
-          .limit(1) as unknown;
+        processed[key] =
+          Drizzle.sql`(select ${Drizzle.sql.identifier(internalIdCol.name)} from ${Drizzle.sql.identifier(physicalTableName)} where ${Drizzle.sql.identifier(idCol.name)} = ${externalId} limit 1)`;
       } else {
         processed[key] = value;
       }
@@ -315,7 +312,6 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
           const query = db.select({ count: Drizzle.count() }).from(drizzleTable);
 
           const compiledQuery = whereClause ? query.where(whereClause).toSQL() : query.toSQL();
-          onQuery?.(compiledQuery);
           return compiledQuery;
         }
 
@@ -452,7 +448,6 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
 
           const physicalTableName = mapper ? mapper.toPhysical(op.table.ormName) : op.table.ormName;
           const compiledQuery = db.query[physicalTableName].findMany(queryConfig).toSQL();
-          onQuery?.(compiledQuery);
           return compiledQuery;
         }
       }
@@ -470,7 +465,6 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
           const values = processReferenceSubqueries(encodedValues);
 
           const compiledQuery = db.insert(drizzleTable).values(values).toSQL();
-          onQuery?.(compiledQuery);
           return {
             query: compiledQuery,
             expectedAffectedRows: null, // creates don't need affected row checks
@@ -514,7 +508,6 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
           ) as unknown;
 
           const compiledQuery = db.update(drizzleTable).set(setValues).where(whereClause).toSQL();
-          onQuery?.(compiledQuery);
           return {
             query: compiledQuery,
             expectedAffectedRows: op.checkVersion ? 1 : null,
@@ -527,7 +520,23 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
           const versionColumn = table.getVersionColumn();
           const drizzleTable = toDrizzleTable(table);
 
+          if (!op.id) {
+            throw new Error(
+              `[Drizzle] Delete operation on table "${op.table}" has undefined id. ` +
+                `Make sure you're passing a valid FragnoId or string ID.`,
+            );
+          }
+
           const externalId = typeof op.id === "string" ? op.id : op.id.externalId;
+
+          if (!externalId) {
+            throw new Error(
+              `[Drizzle] Delete operation on table "${op.table}" has invalid id. ` +
+                `The FragnoId object exists but has no externalId. ` +
+                `Received: ${JSON.stringify(op.id)}. ` +
+                `Make sure the record was properly loaded from the database.`,
+            );
+          }
           const versionToCheck = getVersionToCheck(op.id, op.checkVersion);
 
           // Build WHERE clause that filters by ID and optionally by version
@@ -550,7 +559,6 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
           const whereClause = condition === true ? undefined : buildWhere(condition);
 
           const compiledQuery = db.delete(drizzleTable).where(whereClause).toSQL();
-          onQuery?.(compiledQuery);
           return {
             query: compiledQuery,
             expectedAffectedRows: op.checkVersion ? 1 : null,