@fragno-dev/db 0.1.1 → 0.1.3

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"),
-        _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+        value: text("value").notNull(),
+        _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).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: true }).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,59 @@ 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`);
+
+      // Handle different result formats across providers
+      // PostgreSQL/MySQL: { rows: [...] }
+      // SQLite: array directly or { rows: [...] }
+      if (Array.isArray(result)) {
+        return result.length > 0 && result[0]["healthy"] === 1;
+      } else {
+        const drizzleResult = result as DrizzleResult;
+        return drizzleResult.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,18 +44,19 @@ 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[]) =>
-        executeDrizzleRetrievalPhase(db, retrievalBatch),
+        executeDrizzleRetrievalPhase(db, retrievalBatch, provider),
       executeMutationPhase: (mutationBatch: CompiledMutation<DrizzleCompiledQuery>[]) =>
-        executeDrizzleMutationPhase(db, mutationBatch),
+        executeDrizzleMutationPhase(db, mutationBatch, provider),
     };
 
     const decoder = createDrizzleUOWDecoder(schema, provider);

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"]);
       });
@@ -947,7 +953,7 @@ describe("drizzle-uow-compiler", () => {
       return async () => {
         await cleanup();
       };
-    }, 15000);
+    }, 20000);
 
     function createNestedUOW(name?: string) {
       const compiler = createDrizzleUOWCompiler(nestedSchema, nestedConfig);

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
@@ -92,6 +92,7 @@ function transformJoinArraysToObjects(
       joins?: JoinInfo[];
     };
   },
+  provider: SQLProvider,
 ): Record<string, unknown> {
   // Only process find operations with joins
   if (op.type !== "find" || !op.options?.joins) {
@@ -102,7 +103,17 @@ function transformJoinArraysToObjects(
 
   for (const join of op.options.joins) {
     const relationName = join.relation.name;
-    const value = row[relationName];
+    let value = row[relationName];
+
+    // For SQLite, json_array returns a JSON string that needs to be parsed
+    if (provider === "sqlite" && typeof value === "string") {
+      try {
+        value = JSON.parse(value) as unknown;
+      } catch {
+        // If parsing fails, skip this join
+        continue;
+      }
+    }
 
     // Skip if not an array (join didn't return data)
     if (!Array.isArray(value)) {
@@ -149,15 +160,21 @@ export function createDrizzleUOWDecoder<TSchema extends AnySchema>(
       // Handle count operations - return the count value directly
       if (op.type === "count") {
         if (result.rows.length > 0 && result.rows[0]) {
-          const row = result.rows[0];
-          return (row as Record<string, unknown>)["count"] as number;
+          const row = result.rows[0] as Record<string, unknown>;
+          const countValue = row["count"] ?? row["count(*)"];
+
+          if (typeof countValue !== "number") {
+            throw new Error(`Unexpected result for count, received: ${countValue}`);
+          }
+
+          return countValue;
         }
         return 0;
       }
 
       // Handle find operations - decode each row
       return result.rows.map((row) => {
-        const transformedRow = transformJoinArraysToObjects(row, op);
+        const transformedRow = transformJoinArraysToObjects(row, op, provider);
         return decodeResult(transformedRow, op.table, provider);
       });
     });