@fragno-dev/db 0.1.13 → 0.1.15

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

@@ -1,18 +1,19 @@
-import type { DatabaseAdapter } from "../adapters";
+import type { DatabaseAdapter, DatabaseContextStorage } from "../adapters";
 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 { createTableNameMapper, type DBType, type DrizzleResult } from "./shared";
-import { createSettingsManager, settingsSchema } from "../../shared/settings-schema";
 import { sql } from "drizzle-orm";
+import { settingsSchema, SETTINGS_TABLE_NAME } from "../../fragments/internal-fragment";
 import {
   fragnoDatabaseAdapterNameFakeSymbol,
   fragnoDatabaseAdapterVersionFakeSymbol,
 } from "../adapters";
 import type { ConnectionPool } from "../../shared/connection-pool";
 import { createDrizzleConnectionPool } from "./drizzle-connection-pool";
+import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
 
 export interface DrizzleConfig {
   db: unknown | (() => unknown | Promise<unknown>);
@@ -22,12 +23,15 @@ export interface DrizzleConfig {
 export class DrizzleAdapter implements DatabaseAdapter<DrizzleUOWConfig> {
   #connectionPool: ConnectionPool<DBType>;
   #provider: "sqlite" | "mysql" | "postgresql";
+  #schemaNamespaceMap = new WeakMap<AnySchema, string>();
+  #contextStorage: RequestContextStorage<DatabaseContextStorage>;
 
   constructor(config: DrizzleConfig) {
     this.#connectionPool = createDrizzleConnectionPool(
       config.db as DBType | (() => DBType | Promise<DBType>),
     );
     this.#provider = config.provider;
+    this.#contextStorage = new RequestContextStorage();
   }
 
   get [fragnoDatabaseAdapterNameFakeSymbol](): string {
@@ -38,10 +42,18 @@ export class DrizzleAdapter implements DatabaseAdapter<DrizzleUOWConfig> {
     return 0;
   }
 
+  get contextStorage(): RequestContextStorage<DatabaseContextStorage> {
+    return this.#contextStorage;
+  }
+
   async close(): Promise<void> {
     await this.#connectionPool.close();
   }
 
+  createTableNameMapper(namespace: string) {
+    return createTableNameMapper(namespace);
+  }
+
   get provider(): "sqlite" | "mysql" | "postgresql" {
     return this.#provider;
   }
@@ -68,11 +80,17 @@ export class DrizzleAdapter implements DatabaseAdapter<DrizzleUOWConfig> {
   }
 
   async getSchemaVersion(namespace: string): Promise<string | undefined> {
-    const queryEngine = this.createQueryEngine(settingsSchema, namespace);
-    const manager = createSettingsManager(queryEngine, namespace);
+    // Note: This looks up arbitrary fragment schema versions (e.g., "my-fragment.schema_version")
+    // which are different from Fragno's internal settings (prefixed with SETTINGS_NAMESPACE)
+    // So we can't use the internal fragment here, we need direct query engine access
+    const queryEngine = this.createQueryEngine(settingsSchema, "");
 
-    // Try to read the version key directly
-    const result = await manager.get("version");
+    const uow = queryEngine
+      .createUnitOfWork()
+      .find(SETTINGS_TABLE_NAME, (b) =>
+        b.whereIndex("unique_key", (eb) => eb("key", "=", `${namespace}.schema_version`)),
+      );
+    const [[result]] = await uow.executeRetrieve();
     return result?.value;
   }
 
@@ -80,9 +98,19 @@ export class DrizzleAdapter implements DatabaseAdapter<DrizzleUOWConfig> {
     schema: TSchema,
     namespace: string,
   ): AbstractQuery<TSchema, DrizzleUOWConfig> {
+    // Register schema-namespace mapping
+    this.#schemaNamespaceMap.set(schema, namespace);
+
     // Only create mapper if namespace is non-empty
     const mapper = namespace ? createTableNameMapper(namespace) : undefined;
-    return fromDrizzle(schema, this.#connectionPool, this.#provider, mapper);
+    return fromDrizzle(
+      schema,
+      this.#connectionPool,
+      this.#provider,
+      mapper,
+      undefined,
+      this.#schemaNamespaceMap,
+    );
   }
 
   createSchemaGenerator(

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

@@ -68,6 +68,8 @@ class UpdateManySpecialBuilder<TTable extends AnyTable> {
  * @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 uowConfig - Optional UOW configuration
+ * @param schemaNamespaceMap - Optional WeakMap for schema-to-namespace lookups
  * @returns An AbstractQuery instance for performing database operations
  *
  * @example
@@ -84,9 +86,10 @@ export function fromDrizzle<T extends AnySchema>(
   provider: "sqlite" | "mysql" | "postgresql",
   mapper?: TableNameMapper,
   uowConfig?: DrizzleUOWConfig,
+  schemaNamespaceMap?: WeakMap<AnySchema, string>,
 ): AbstractQuery<T, DrizzleUOWConfig> {
   function createUOW(opts: { name?: string; config?: DrizzleUOWConfig }) {
-    const uowCompiler = createDrizzleUOWCompiler(schema, pool, provider, mapper);
+    const uowCompiler = createDrizzleUOWCompiler(pool, provider, mapper);
 
     const executor: UOWExecutor<DrizzleCompiledQuery, DrizzleResult> = {
       async executeRetrievalPhase(retrievalBatch: DrizzleCompiledQuery[]) {
@@ -125,24 +128,31 @@ export function fromDrizzle<T extends AnySchema>(
       },
     };
 
-    const decoder = createDrizzleUOWDecoder(schema, provider);
+    const decoder = createDrizzleUOWDecoder(provider);
 
     const { onQuery, ...restUowConfig } = opts.config ?? {};
 
-    return new UnitOfWork(schema, uowCompiler, executor, decoder, opts.name, {
-      ...restUowConfig,
-      onQuery: (query) => {
-        // Handle both CompiledQuery and CompiledMutation structures
-        // Retrieval operations return DrizzleCompiledQuery directly: { sql, params }
-        // Mutation operations return CompiledMutation: { query: DrizzleCompiledQuery, expectedAffectedRows }
-        const actualQuery =
-          query && typeof query === "object" && "query" in query
-            ? (query as CompiledMutation<DrizzleCompiledQuery>).query
-            : (query as DrizzleCompiledQuery);
-
-        opts.config?.onQuery?.(actualQuery);
+    return new UnitOfWork(
+      uowCompiler,
+      executor,
+      decoder,
+      opts.name,
+      {
+        ...restUowConfig,
+        onQuery: (query) => {
+          // Handle both CompiledQuery and CompiledMutation structures
+          // Retrieval operations return DrizzleCompiledQuery directly: { sql, params }
+          // Mutation operations return CompiledMutation: { query: DrizzleCompiledQuery, expectedAffectedRows }
+          const actualQuery =
+            query && typeof query === "object" && "query" in query
+              ? (query as CompiledMutation<DrizzleCompiledQuery>).query
+              : (query as DrizzleCompiledQuery);
+
+          opts.config?.onQuery?.(actualQuery);
+        },
       },
-    });
+      schemaNamespaceMap,
+    ).forSchema(schema);
   }
 
   return {