@fragno-dev/db 0.1.1 → 0.1.2

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

@@ -80,6 +80,7 @@ describe("DrizzleAdapter PGLite", () => {
       "drizzle-adapter-pglite",
       testSchema,
       "postgresql",
+      "namespace",
     );
 
     // Create Drizzle instance with PGLite (in-memory Postgres)
@@ -103,13 +104,16 @@ describe("DrizzleAdapter PGLite", () => {
       provider: "postgresql",
     });
 
+    expect(await adapter.isConnectionHealthy()).toBe(true);
+
     return async () => {
       await cleanup();
     };
   }, 12000);
 
   it("should execute Unit of Work with version checking", async () => {
-    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+    // Pass namespace to ensure mapper translates logical table names to physical (prefixed) names
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
     // Create initial user using UOW
     const createUow = queryEngine.createUnitOfWork("create-user").create("users", {
@@ -194,7 +198,7 @@ describe("DrizzleAdapter PGLite", () => {
   });
 
   it("should support count operations", async () => {
-    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
     // Create some users
     await queryEngine
@@ -215,7 +219,7 @@ describe("DrizzleAdapter PGLite", () => {
   });
 
   it("should support cursor-based pagination", async () => {
-    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
     const createUow = queryEngine
       .createUnitOfWork("create-users")
@@ -262,7 +266,7 @@ describe("DrizzleAdapter PGLite", () => {
   });
 
   it("should support joins", async () => {
-    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
     const queries: DrizzleCompiledQuery[] = [];
 
     const createUow = queryEngine
@@ -298,7 +302,7 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [query] = queries;
     expect(query.sql).toMatchInlineSnapshot(
-      `"select "emails"."id", "emails"."user_id", "emails"."email", "emails"."is_primary", "emails"."_internalId", "emails"."_version", "emails_user"."data" as "user" from "emails" "emails" left join lateral (select json_build_array("emails_user"."name", "emails_user"."id", "emails_user"."age", "emails_user"."_internalId", "emails_user"."_version") as "data" from (select * from "users" "emails_user" where "emails_user"."_internalId" = "emails"."user_id" limit $1) "emails_user") "emails_user" on true"`,
+      `"select "emails_namespace"."id", "emails_namespace"."user_id", "emails_namespace"."email", "emails_namespace"."is_primary", "emails_namespace"."_internalId", "emails_namespace"."_version", "emails_namespace_user"."data" as "user" from "emails_namespace" "emails_namespace" left join lateral (select json_build_array("emails_namespace_user"."name", "emails_namespace_user"."id", "emails_namespace_user"."age", "emails_namespace_user"."_internalId", "emails_namespace_user"."_version") as "data" from (select * from "users_namespace" "emails_namespace_user" where "emails_namespace_user"."_internalId" = "emails_namespace"."user_id" limit $1) "emails_namespace_user") "emails_namespace_user" on true"`,
     );
 
     expect(email).toMatchObject({
@@ -323,7 +327,7 @@ describe("DrizzleAdapter PGLite", () => {
   });
 
   it("should support complex nested joins (comments -> post -> author)", async () => {
-    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
     const queries: DrizzleCompiledQuery[] = [];
 
     // Create a user (author)
@@ -427,7 +431,7 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [query] = queries;
     expect(query.sql).toMatchInlineSnapshot(
-      `"select "comments"."id", "comments"."post_id", "comments"."user_id", "comments"."text", "comments"."_internalId", "comments"."_version", "comments_post"."data" as "post", "comments_commenter"."data" as "commenter" from "comments" "comments" left join lateral (select json_build_array("comments_post"."id", "comments_post"."title", "comments_post"."content", "comments_post"."_internalId", "comments_post"."_version", "comments_post_author"."data") as "data" from (select * from "posts" "comments_post" where "comments_post"."_internalId" = "comments"."post_id" order by "comments_post"."id" desc limit $1) "comments_post" left join lateral (select json_build_array("comments_post_author"."id", "comments_post_author"."name", "comments_post_author"."age", "comments_post_author"."_internalId", "comments_post_author"."_version") as "data" from (select * from "users" "comments_post_author" where "comments_post_author"."_internalId" = "comments_post"."user_id" order by "comments_post_author"."name" asc limit $2) "comments_post_author") "comments_post_author" on true) "comments_post" on true left join lateral (select json_build_array("comments_commenter"."id", "comments_commenter"."name", "comments_commenter"."_internalId", "comments_commenter"."_version") as "data" from (select * from "users" "comments_commenter" where "comments_commenter"."_internalId" = "comments"."user_id" limit $3) "comments_commenter") "comments_commenter" on true"`,
+      `"select "comments_namespace"."id", "comments_namespace"."post_id", "comments_namespace"."user_id", "comments_namespace"."text", "comments_namespace"."_internalId", "comments_namespace"."_version", "comments_namespace_post"."data" as "post", "comments_namespace_commenter"."data" as "commenter" from "comments_namespace" "comments_namespace" left join lateral (select json_build_array("comments_namespace_post"."id", "comments_namespace_post"."title", "comments_namespace_post"."content", "comments_namespace_post"."_internalId", "comments_namespace_post"."_version", "comments_namespace_post_author"."data") as "data" from (select * from "posts_namespace" "comments_namespace_post" where "comments_namespace_post"."_internalId" = "comments_namespace"."post_id" order by "comments_namespace_post"."id" desc limit $1) "comments_namespace_post" left join lateral (select json_build_array("comments_namespace_post_author"."id", "comments_namespace_post_author"."name", "comments_namespace_post_author"."age", "comments_namespace_post_author"."_internalId", "comments_namespace_post_author"."_version") as "data" from (select * from "users_namespace" "comments_namespace_post_author" where "comments_namespace_post_author"."_internalId" = "comments_namespace_post"."user_id" order by "comments_namespace_post_author"."name" asc limit $2) "comments_namespace_post_author") "comments_namespace_post_author" on true) "comments_namespace_post" on true left join lateral (select json_build_array("comments_namespace_commenter"."id", "comments_namespace_commenter"."name", "comments_namespace_commenter"."_internalId", "comments_namespace_commenter"."_version") as "data" from (select * from "users_namespace" "comments_namespace_commenter" where "comments_namespace_commenter"."_internalId" = "comments_namespace"."user_id" limit $3) "comments_namespace_commenter") "comments_namespace_commenter" on true"`,
     );
   });
 });

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

@@ -15,7 +15,7 @@ describe("DrizzleAdapter", () => {
       provider: "postgresql",
     });
 
-    const generator = adapter.createSchemaGenerator(testSchema, "test");
+    const generator = adapter.createSchemaGenerator([{ schema: testSchema, namespace: "test" }]);
     const result = generator.generateSchema({ path: "schema.ts" });
 
     expect(result.path).toBe("schema.ts");
@@ -23,22 +23,38 @@ describe("DrizzleAdapter", () => {
       "import { pgTable, varchar, text, bigserial, integer, uniqueIndex } from "drizzle-orm/pg-core"
       import { createId } from "@fragno-dev/db/id"
 
-      export const users = pgTable("users", {
-        id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
-        name: text("name").notNull(),
-        _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
-        _version: integer("_version").notNull().default(0)
-      })
+      // ============================================================================
+      // Settings Table (shared across all fragments)
+      // ============================================================================
 
       export const fragno_db_settings = pgTable("fragno_db_settings", {
         id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
         key: text("key").notNull(),
-        value: text("value").notNull().default("1"),
+        value: text("value").notNull(),
         _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
         _version: integer("_version").notNull().default(0)
       }, (table) => [
         uniqueIndex("unique_key").on(table.key)
-      ])"
+      ])
+
+      export const fragnoDbSettingSchemaVersion = 1;
+
+      // ============================================================================
+      // Fragment: test
+      // ============================================================================
+
+      export const users_test = pgTable("users_test", {
+        id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        name: text("name").notNull(),
+        _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+        _version: integer("_version").notNull().default(0)
+      })
+
+      export const test_schema = {
+        "users_test": users_test,
+        users: users_test,
+        schemaVersion: 1
+      }"
     `);
   });
 
@@ -48,7 +64,7 @@ describe("DrizzleAdapter", () => {
       provider: "sqlite",
     });
 
-    const generator = adapter.createSchemaGenerator(testSchema, "test");
+    const generator = adapter.createSchemaGenerator([{ schema: testSchema, namespace: "test" }]);
     const result = generator.generateSchema({ path: "schema.ts" });
 
     expect(result.path).toBe("schema.ts");
@@ -56,22 +72,38 @@ describe("DrizzleAdapter", () => {
       "import { sqliteTable, text, integer, uniqueIndex } from "drizzle-orm/sqlite-core"
       import { createId } from "@fragno-dev/db/id"
 
-      export const users = sqliteTable("users", {
-        id: text("id").notNull().$defaultFn(() => createId()),
-        name: text("name").notNull(),
-        _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
-        _version: integer("_version").notNull().default(0)
-      })
+      // ============================================================================
+      // Settings Table (shared across all fragments)
+      // ============================================================================
 
       export const fragno_db_settings = sqliteTable("fragno_db_settings", {
         id: text("id").notNull().$defaultFn(() => createId()),
         key: text("key").notNull(),
-        value: text("value").notNull().default("1"),
+        value: text("value").notNull(),
         _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
         _version: integer("_version").notNull().default(0)
       }, (table) => [
         uniqueIndex("unique_key").on(table.key)
-      ])"
+      ])
+
+      export const fragnoDbSettingSchemaVersion = 1;
+
+      // ============================================================================
+      // Fragment: test
+      // ============================================================================
+
+      export const users_test = sqliteTable("users_test", {
+        id: text("id").notNull().$defaultFn(() => createId()),
+        name: text("name").notNull(),
+        _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+        _version: integer("_version").notNull().default(0)
+      })
+
+      export const test_schema = {
+        "users_test": users_test,
+        users: users_test,
+        schemaVersion: 1
+      }"
     `);
   });
 
@@ -81,10 +113,10 @@ describe("DrizzleAdapter", () => {
       provider: "postgresql",
     });
 
-    const generator = adapter.createSchemaGenerator(testSchema, "myapp");
+    const generator = adapter.createSchemaGenerator([{ schema: testSchema, namespace: "myapp" }]);
     const result = generator.generateSchema();
 
-    expect(result.path).toBe("drizzle-schema-myapp.ts");
+    expect(result.path).toBe("fragno-schema.ts");
   });
 
   it("should preserve original schema tables", () => {
@@ -93,7 +125,7 @@ describe("DrizzleAdapter", () => {
       provider: "postgresql",
     });
 
-    const generator = adapter.createSchemaGenerator(testSchema, "test");
+    const generator = adapter.createSchemaGenerator([{ schema: testSchema, namespace: "test" }]);
     const result = generator.generateSchema();
 
     // Original table should still be there
@@ -101,22 +133,38 @@ describe("DrizzleAdapter", () => {
       "import { pgTable, varchar, text, bigserial, integer, uniqueIndex } from "drizzle-orm/pg-core"
       import { createId } from "@fragno-dev/db/id"
 
-      export const users = pgTable("users", {
-        id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
-        name: text("name").notNull(),
-        _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
-        _version: integer("_version").notNull().default(0)
-      })
+      // ============================================================================
+      // Settings Table (shared across all fragments)
+      // ============================================================================
 
       export const fragno_db_settings = pgTable("fragno_db_settings", {
         id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
         key: text("key").notNull(),
-        value: text("value").notNull().default("1"),
+        value: text("value").notNull(),
         _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
         _version: integer("_version").notNull().default(0)
       }, (table) => [
         uniqueIndex("unique_key").on(table.key)
-      ])"
+      ])
+
+      export const fragnoDbSettingSchemaVersion = 1;
+
+      // ============================================================================
+      // Fragment: test
+      // ============================================================================
+
+      export const users_test = pgTable("users_test", {
+        id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        name: text("name").notNull(),
+        _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+        _version: integer("_version").notNull().default(0)
+      })
+
+      export const test_schema = {
+        "users_test": users_test,
+        users: users_test,
+        schemaVersion: 1
+      }"
     `);
   });
 });

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

@@ -1,19 +1,12 @@
 import type { DatabaseAdapter } from "../adapters";
-import {
-  column,
-  idColumn,
-  schema,
-  SchemaBuilder,
-  type AnySchema,
-  type FragnoId,
-} from "../../schema/create";
+import { type AnySchema } from "../../schema/create";
 import type { AbstractQuery } from "../../query/query";
 import type { SchemaGenerator } from "../../schema-generator/schema-generator";
 import { generateSchema } from "./generate";
 import { fromDrizzle, type DrizzleUOWConfig } from "./drizzle-query";
-import { createId } from "../../id";
-
-const SETTINGS_TABLE_NAME = "fragno_db_settings" as const;
+import { createTableNameMapper, type DBType, type DrizzleResult } from "./shared";
+import { createSettingsManager, settingsSchema } from "../../shared/settings-schema";
+import { sql } from "drizzle-orm";
 
 export interface DrizzleConfig {
   db: unknown;
@@ -27,92 +20,52 @@ export class DrizzleAdapter implements DatabaseAdapter<DrizzleUOWConfig> {
     this.#drizzleConfig = config;
   }
 
-  #createFullSchema<T extends AnySchema>(schema: T) {
-    return new SchemaBuilder()
-      .mergeWithExistingSchema(schema)
-      .mergeWithExistingSchema(createSettingsSchema(schema.version))
-      .build();
+  get provider(): "sqlite" | "mysql" | "postgresql" {
+    return this.#drizzleConfig.provider;
+  }
+
+  async isConnectionHealthy(): Promise<boolean> {
+    try {
+      const result = (await (this.#drizzleConfig.db as DBType).execute(
+        sql`SELECT 1 as healthy`,
+      )) as DrizzleResult;
+      return result.rows[0]["healthy"] === 1;
+    } catch {
+      return false;
+    }
   }
 
   async getSchemaVersion(namespace: string): Promise<string | undefined> {
-    const queryEngine = this.createQueryEngine(createSettingsSchema(0), namespace);
+    const queryEngine = this.createQueryEngine(settingsSchema, namespace);
     const manager = createSettingsManager(queryEngine, namespace);
-    const randomId = createId();
-
-    const result = await manager.createKeyWithDefault(randomId);
-    if (result) {
-      await manager.delete(result.id);
-    }
 
+    // Try to read the version key directly
+    const result = await manager.get("version");
     return result?.value;
   }
 
   createQueryEngine<TSchema extends AnySchema>(
     schema: TSchema,
-    _namespace: string,
+    namespace: string,
   ): AbstractQuery<TSchema, DrizzleUOWConfig> {
-    return fromDrizzle(schema, this.#drizzleConfig);
+    // Only create mapper if namespace is non-empty
+    const mapper = namespace ? createTableNameMapper(namespace) : undefined;
+    return fromDrizzle(schema, this.#drizzleConfig, mapper);
   }
 
-  createSchemaGenerator(schema: AnySchema, namespace: string): SchemaGenerator {
+  createSchemaGenerator(
+    fragments: { schema: AnySchema; namespace: string }[],
+    options?: { path?: string },
+  ): SchemaGenerator {
     return {
-      generateSchema: (options) => {
-        const path = options?.path ?? `drizzle-schema-${namespace}.ts`;
-
-        const schemaWithSettingsTable = this.#createFullSchema(schema);
+      generateSchema: (genOptions) => {
+        const path = genOptions?.path ?? options?.path ?? "fragno-schema.ts";
 
         return {
-          schema: generateSchema(schemaWithSettingsTable, this.#drizzleConfig.provider),
+          schema: generateSchema(fragments, this.#drizzleConfig.provider),
           path,
         };
       },
     };
   }
 }
-
-function createSettingsSchema(version: number) {
-  return schema((s) => {
-    return s.addTable(SETTINGS_TABLE_NAME, (t) => {
-      return t
-        .addColumn("id", idColumn())
-        .addColumn("key", column("string"))
-        .addColumn("value", column("string").defaultTo(String(version)))
-        .createIndex("unique_key", ["key"], { unique: true });
-    });
-  });
-}
-
-function createSettingsManager(
-  queryEngine: AbstractQuery<ReturnType<typeof createSettingsSchema>, DrizzleUOWConfig>,
-  namespace: string,
-) {
-  return {
-    async createKeyWithDefault(key: string) {
-      const writeUow = queryEngine
-        .createUnitOfWork("createKeyWithDefault")
-        .create(SETTINGS_TABLE_NAME, {
-          key: `${namespace}.${key}`,
-        });
-      const { success } = await writeUow.executeMutations();
-      if (!success) {
-        throw new Error("Failed to create key with default");
-      }
-
-      return this.get(key);
-    },
-
-    async get(key: string): Promise<{ id: FragnoId; key: string; value: string } | undefined> {
-      const uow = queryEngine
-        .createUnitOfWork()
-        .find(SETTINGS_TABLE_NAME, (b) =>
-          b.whereIndex("unique_key", (eb) => eb("key", "=", `${namespace}.${key}`)),
-        );
-      const [[result]] = await uow.executeRetrieve();
-      return result; // FIXME: result should be maybe undefined
-    },
-
-    async delete(id: FragnoId) {
-      await queryEngine.delete(SETTINGS_TABLE_NAME, id);
-    },
-  };
-}

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

@@ -5,14 +5,9 @@ import type { CompiledMutation, UOWExecutor } from "../../query/unit-of-work";
 import { createDrizzleUOWCompiler, type DrizzleCompiledQuery } from "./drizzle-uow-compiler";
 import { executeDrizzleRetrievalPhase, executeDrizzleMutationPhase } from "./drizzle-uow-executor";
 import { UnitOfWork } from "../../query/unit-of-work";
-import { parseDrizzle } from "./shared";
+import { parseDrizzle, type DrizzleResult, type TableNameMapper } from "./shared";
 import { createDrizzleUOWDecoder } from "./drizzle-uow-decoder";
 
-export interface DrizzleResult {
-  rows: Record<string, unknown>[];
-  affectedRows: number;
-}
-
 /**
  * Configuration options for creating a Drizzle Unit of Work
  */
@@ -33,6 +28,7 @@ export interface DrizzleUOWConfig {
  *
  * @param schema - The database schema definition
  * @param config - Drizzle configuration containing the database instance and provider
+ * @param mapper - Optional table name mapper for namespace prefixing
  * @returns An AbstractQuery instance for performing database operations
  *
  * @example
@@ -48,12 +44,13 @@ export interface DrizzleUOWConfig {
 export function fromDrizzle<T extends AnySchema>(
   schema: T,
   config: DrizzleConfig,
+  mapper?: TableNameMapper,
 ): AbstractQuery<T, DrizzleUOWConfig> {
   const [db] = parseDrizzle(config.db);
   const { provider } = config;
 
   function createUOW(name?: string, uowConfig?: DrizzleUOWConfig) {
-    const uowCompiler = createDrizzleUOWCompiler(schema, config, uowConfig?.onQuery);
+    const uowCompiler = createDrizzleUOWCompiler(schema, config, mapper, uowConfig?.onQuery);
 
     const executor: UOWExecutor<DrizzleCompiledQuery, DrizzleResult> = {
       executeRetrievalPhase: (retrievalBatch: DrizzleCompiledQuery[]) =>

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

@@ -755,9 +755,15 @@ describe("drizzle-uow-compiler", () => {
         return t
           .addColumn("id", idColumn())
           .addColumn("message", column("string"))
-          .addColumn("sessionId", column("string").defaultTo$("auto")) // runtime auto
-          .addColumn("timestamp", column("timestamp").defaultTo$("now")) // runtime now
-          .addColumn("counter", column("integer").defaultTo$((() => 42) as () => number)) // runtime function
+          .addColumn(
+            "sessionId",
+            column("string").defaultTo$((b) => b.cuid()),
+          ) // runtime cuid
+          .addColumn(
+            "timestamp",
+            column("timestamp").defaultTo$((b) => b.now()),
+          ) // runtime now
+          .addColumn("counter", column("integer").defaultTo$(42)) // runtime function
           .addColumn("status", column("string").defaultTo("pending")) // static default
           .createIndex("idx_session", ["sessionId"]);
       });

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

@@ -9,7 +9,7 @@ import type {
 } from "../../query/unit-of-work";
 import { buildCondition, type Condition } from "../../query/condition-builder";
 import type { DrizzleConfig } from "./drizzle-adapter";
-import { type ColumnType, type TableType, parseDrizzle } from "./shared";
+import { type ColumnType, type TableType, type TableNameMapper, parseDrizzle } from "./shared";
 import { encodeValues, ReferenceSubquery } from "../../query/result-transform";
 import { serialize } from "../../schema/serialize";
 import { decodeCursor, serializeCursorValues } from "../../query/cursor";
@@ -29,12 +29,14 @@ export type DrizzleCompiledQuery = {
  *
  * @param schema - The database schema
  * @param config - Drizzle configuration
+ * @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>(
   schema: TSchema,
   config: DrizzleConfig,
+  mapper?: TableNameMapper,
   onQuery?: (query: DrizzleCompiledQuery) => void,
 ): UOWCompiler<TSchema, DrizzleCompiledQuery> {
   const [db, drizzleTables] = parseDrizzle(config.db);
@@ -45,14 +47,15 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
    * @throws Error if table is not found in Drizzle schema
    */
   function toDrizzleTable(table: AnyTable): TableType {
-    const tableName = table.ormName;
-    const out = drizzleTables[tableName];
+    // Map logical table name to physical table name using the mapper
+    const physicalTableName = mapper ? mapper.toPhysical(table.ormName) : table.ormName;
+    const out = drizzleTables[physicalTableName];
     if (out) {
       return out;
     }
 
     throw new Error(
-      `[Drizzle] Unknown table name ${tableName}, is it included in your Drizzle schema?`,
+      `[Drizzle] Unknown table name ${physicalTableName} (logical: ${table.ormName}), is it included in your Drizzle schema?`,
     );
   }
 
@@ -150,7 +153,9 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
 
     if (condition.type === "not") {
       const result = buildWhere(condition.item);
-      if (!result) return;
+      if (!result) {
+        return;
+      }
 
       return Drizzle.not(result);
     }
@@ -435,7 +440,8 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
             queryConfig.with = processJoins(joins);
           }
 
-          const compiledQuery = db.query[op.table.ormName].findMany(queryConfig).toSQL();
+          const physicalTableName = mapper ? mapper.toPhysical(op.table.ormName) : op.table.ormName;
+          const compiledQuery = db.query[physicalTableName].findMany(queryConfig).toSQL();
           onQuery?.(compiledQuery);
           return compiledQuery;
         }

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

@@ -2,8 +2,8 @@ import type { AnySchema, AnyTable } from "../../schema/create";
 import type { SQLProvider } from "../../shared/providers";
 import type { RetrievalOperation, UOWDecoder } from "../../query/unit-of-work";
 import { decodeResult } from "../../query/result-transform";
-import type { DrizzleResult } from "./drizzle-query";
 import { getOrderedJoinColumns } from "./join-column-utils";
+import type { DrizzleResult } from "./shared";
 
 /**
  * Join information with nested join support

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

@@ -2,7 +2,7 @@ import { SQL, StringChunk, sql, type SQLChunk } from "drizzle-orm";
 import type { CompiledMutation, MutationResult } from "../../query/unit-of-work";
 import type { DBType } from "./shared";
 import type { DrizzleCompiledQuery } from "./drizzle-uow-compiler";
-import type { DrizzleResult } from "./drizzle-query";
+import type { DrizzleResult } from "./shared";
 
 /**
  * Convert a DrizzleCompiledQuery (SQL string + params) to a Drizzle SQL object