@fragno-dev/db 0.1.15 → 0.2.0

package/README.md

@@ -1,13 +1,128 @@
 # @fragno-dev/db
 
-## Attribution & Original Source
+Optional, ORM-agnostic database layer for Fragno libraries.
 
-**Important:** A significant portion of this package's codebase is adopted from
-[fumadb](https://github.com/fuma-nama/fumadb), which is licensed under the MIT License.
+Library authors define a type-safe schema; users plug in their existing Kysely or Drizzle setup so
+data is written directly into their database.
 
-- **Project:** fumadb
-- **Author:** Fuma Nama and contributors
-- **License:** MIT
-- **Source:** https://github.com/fuma-nama/fumadb
+Full docs live at
+[Database integration for library authors](https://fragno.dev/docs/fragno/for-library-authors/database-integration/overview).
 
-We are grateful to Fuma Nama for their excellent work on the original implementation.
+## Who is this for?
+
+- **Library authors** who want to ship a full-stack library that needs persistent storage, without
+  owning the user's database.
+
+Your library defines the schema and queries; your users provide the database adapter.
+
+## Quick start
+
+### 1. Install
+
+```bash
+npm install @fragno-dev/db @fragno-dev/core
+# or
+pnpm add @fragno-dev/db @fragno-dev/core
+```
+
+And make sure to install the CLI to perform migrations / schema generation:
+
+```bash
+npm install --save-dev @fragno-dev/cli
+# or
+pnpm add --dev @fragno-dev/cli
+```
+
+### 2. Define a schema
+
+```ts
+// schema.ts
+import { schema, idColumn, column } from "@fragno-dev/db/schema";
+
+export const commentSchema = schema((s) => {
+  return s
+    .addTable("comment", (t) => {
+      return t
+        .addColumn("id", idColumn())
+        .addColumn("content", column("string"))
+        .addColumn("userId", column("string"))
+        .addColumn("postId", column("string"));
+    })
+    .addTable("user", (t) => {
+      return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+    });
+});
+```
+
+### 3. Attach it to your library
+
+```ts
+// index.ts
+import { defineFragment, instantiate } from "@fragno-dev/core";
+import { withDatabase, type FragnoPublicConfigWithDatabase } from "@fragno-dev/db";
+import { commentSchema } from "./schema";
+
+export interface CommentLibraryConfig {
+  maxCommentsPerPost?: number;
+}
+
+const commentLibraryDef = defineFragment<CommentLibraryConfig>("comment-library")
+  // --> use .extend to add the database layer <--
+  .extend(withDatabase(commentSchema))
+  .providesBaseService(({ db }) => {
+    return {
+      createComment: async (data: { content: string; userId: string; postId: string }) => {
+        const id = await db.create("comment", data);
+        return { id: id.toJSON(), ...data };
+      },
+    };
+  })
+  .build();
+
+export function createCommentLibrary(
+  config: CommentLibraryConfig = {},
+  options: FragnoPublicConfigWithDatabase,
+) {
+  return instantiate(commentLibraryDef)
+    .withConfig(config)
+    .withRoutes([])
+    .withOptions(options)
+    .build();
+}
+```
+
+Your users pass their own database adapter (Kysely or Drizzle) via `options`.
+
+## Key features
+
+- **Schema definition**: define tables, columns, indexes, and relations with a fluent, typed API.
+- **Type-safe ORM**: full TypeScript inference for queries and results.
+- **User-owned database**: your library never owns the database; users provide the adapter.
+- **ORM agnostic**: works with Kysely or Drizzle (and more to come).
+- **Namespaced tables**: avoids conflicts with user tables.
+
+## ORM and database support
+
+`@fragno-dev/db` works with:
+
+- **Kysely**
+- **Drizzle**
+
+Backed by Postgres and SQLite, including PGLite and Cloudflare Durable Objects.
+
+## Docs and examples
+
+- **Overview**:
+  [Database integration for library authors](https://fragno.dev/docs/fragno/for-library-authors/database-integration/overview)
+- **Schemas**:
+  [Defining schemas](https://fragno.dev/docs/fragno/for-library-authors/database-integration/defining-schemas)
+- **Querying**:
+  [Querying API](https://fragno.dev/docs/fragno/for-library-authors/database-integration/querying)
+- **Example library**:
+  [`example-fragments/fragno-db-library`](https://github.com/rejot-dev/fragno/tree/main/example-fragments/fragno-db-library)
+
+## Attribution
+
+**Important:** A portion of this package's codebase is adopted from
+[fumadb](https://github.com/fuma-nama/fumadb), which is licensed under the MIT License. We are
+grateful to Fuma Nama (and contributors) for their excellent work on the original implementation.

package/dist/adapters/adapters.d.ts

@@ -1,8 +1,8 @@
 import { AnySchema } from "../schema/create.js";
-import { Migrator } from "../migration-engine/create.js";
-import { IUnitOfWork } from "../query/unit-of-work.js";
-import { AbstractQuery } from "../query/query.js";
+import { IUnitOfWork } from "../query/unit-of-work/unit-of-work.js";
+import { SimpleQueryInterface } from "../query/simple-query-interface.js";
 import { SchemaGenerator } from "../schema-generator/schema-generator.js";
+import { PreparedMigrations } from "./generic-sql/migration/prepared-migrations.js";
 import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
 
 //#region src/adapters/adapters.d.ts
@@ -34,8 +34,8 @@ interface DatabaseAdapter<TUOWConfig = void> {
    * Get current schema version, undefined if not initialized.
    */
   getSchemaVersion(namespace: string): Promise<string | undefined>;
-  createQueryEngine: <const T extends AnySchema>(schema: T, namespace: string) => AbstractQuery<T, TUOWConfig>;
-  createMigrationEngine?: <const T extends AnySchema>(schema: T, namespace: string) => Migrator;
+  createQueryEngine: <const T extends AnySchema>(schema: T, namespace: string) => SimpleQueryInterface<T, TUOWConfig>;
+  prepareMigrations?: <const T extends AnySchema>(schema: T, namespace: string) => PreparedMigrations;
   /**
    * Generate a combined schema file from one or more fragments.
    * If not implemented, schema generation is not supported for this adapter.

package/dist/adapters/adapters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapters.d.ts","names":[],"sources":["../../src/adapters/adapters.ts"],"sourcesContent":[],"mappings":";;;;;;;;cAOa;cACA;AADb;AACA;AAMA;AAOA;AAKiB,KAZL,sBAAA,GAYoB;EAC7B,GAAA,EAZI,WAYJ;CACA;;;;AAamC,UApBrB,eAAA,CAoBqB;EAC1B,UAAA,CAAA,WAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EAES,SAAA,CAAA,YAAA,EAAA,MAAA,CAAA,EAAA,MAAA;;AAAd,UAlBU,eAkBV,CAAA,aAAA,IAAA,CAAA,CAAA;EAEoC,CAnBxC,mCAAA,CAmBwC,EAAA,MAAA;EAAmB,CAlB3D,sCAAA,CAkB2D,EAAA,MAAA;EAAyB;;;;EAiB1D,SAAA,cAAA,EA7BF,qBA6BE,CA7BoB,sBA6BpB,CAAA;EAEd;;;uCA1BwB;sCAED,mBAC1B,yBAEL,cAAc,GAAG;2CAEmB,mBAAmB,yBAAyB;;;;;;YAO9D;;;;QAElB;;;;;gDAMyC;6BAEnB;eAEd"}
+{"version":3,"file":"adapters.d.ts","names":[],"sources":["../../src/adapters/adapters.ts"],"sourcesContent":[],"mappings":";;;;;;;;cAOa;cACA;AADb;AACA;AAMA;AAOA;AAKiB,KAZL,sBAAA,GAYoB;EAC7B,GAAA,EAZI,WAYJ;CACA;;;;AAamC,UApBrB,eAAA,CAoBqB;EAC1B,UAAA,CAAA,WAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EAEgB,SAAA,CAAA,YAAA,EAAA,MAAA,CAAA,EAAA,MAAA;;AAArB,UAlBU,eAkBV,CAAA,aAAA,IAAA,CAAA,CAAA;EAEgC,CAnBpC,mCAAA,CAmBoC,EAAA,MAAA;EAC3B,CAnBT,sCAAA,CAmBS,EAAA,MAAA;EAEL;;;;EAiBsB,SAAA,cAAA,EAhCF,qBAgCE,CAhCoB,sBAgCpB,CAAA;EAEd;;;uCA7BwB;sCAED,mBAC1B,yBAEL,qBAAqB,GAAG;uCAEQ,mBAC3B,yBAEL;;;;;;YAOkB;;;;QAElB;;;;;gDAMyC;6BAEnB;eAEd"}

package/dist/adapters/adapters.js.map

@@ -1 +1 @@
-{"version":3,"file":"adapters.js","names":[],"sources":["../../src/adapters/adapters.ts"],"sourcesContent":["import type { Migrator } from \"../migration-engine/create\";\nimport type { AbstractQuery } from \"../query/query\";\nimport type { SchemaGenerator } from \"../schema-generator/schema-generator\";\nimport type { AnySchema } from \"../schema/create\";\nimport type { RequestContextStorage } from \"@fragno-dev/core/internal/request-context-storage\";\nimport type { IUnitOfWork } from \"../query/unit-of-work\";\n\nexport const fragnoDatabaseAdapterNameFakeSymbol = \"$fragno-database-adapter-name\" as const;\nexport const fragnoDatabaseAdapterVersionFakeSymbol = \"$fragno-database-adapter-version\" as const;\n\n/**\n * Storage type for database context - stores the Unit of Work.\n * This is shared across all fragments using the same adapter.\n */\nexport type DatabaseContextStorage = {\n  uow: IUnitOfWork;\n};\n\n/**\n * Maps logical table names (used by fragment authors) to physical table names (with namespace suffix)\n */\nexport interface TableNameMapper {\n  toPhysical(logicalName: string): string;\n  toLogical(physicalName: string): string;\n}\n\nexport interface DatabaseAdapter<TUOWConfig = void> {\n  [fragnoDatabaseAdapterNameFakeSymbol]: string;\n  [fragnoDatabaseAdapterVersionFakeSymbol]: number;\n\n  /**\n   * Request context storage shared across all fragments using this adapter.\n   * This allows multiple fragments to participate in the same Unit of Work.\n   */\n  readonly contextStorage: RequestContextStorage<DatabaseContextStorage>;\n\n  /**\n   * Get current schema version, undefined if not initialized.\n   */\n  getSchemaVersion(namespace: string): Promise<string | undefined>;\n\n  createQueryEngine: <const T extends AnySchema>(\n    schema: T,\n    namespace: string,\n  ) => AbstractQuery<T, TUOWConfig>;\n\n  createMigrationEngine?: <const T extends AnySchema>(schema: T, namespace: string) => Migrator;\n\n  /**\n   * Generate a combined schema file from one or more fragments.\n   * If not implemented, schema generation is not supported for this adapter.\n   */\n  createSchemaGenerator?: (\n    fragments: { schema: AnySchema; namespace: string }[],\n    options?: { path?: string },\n  ) => SchemaGenerator;\n\n  /**\n   * Creates a table name mapper for the given namespace.\n   * Used to convert between logical table names and physical table names.\n   */\n  createTableNameMapper: (namespace: string) => TableNameMapper;\n\n  isConnectionHealthy: () => Promise<boolean>;\n\n  close: () => Promise<void>;\n}\n"],"mappings":";AAOA,MAAa,sCAAsC;AACnD,MAAa,yCAAyC"}
+{"version":3,"file":"adapters.js","names":[],"sources":["../../src/adapters/adapters.ts"],"sourcesContent":["import type { SimpleQueryInterface } from \"../query/simple-query-interface\";\nimport type { SchemaGenerator } from \"../schema-generator/schema-generator\";\nimport type { AnySchema } from \"../schema/create\";\nimport type { RequestContextStorage } from \"@fragno-dev/core/internal/request-context-storage\";\nimport type { IUnitOfWork } from \"../query/unit-of-work/unit-of-work\";\nimport type { PreparedMigrations } from \"./generic-sql/migration/prepared-migrations\";\n\nexport const fragnoDatabaseAdapterNameFakeSymbol = \"$fragno-database-adapter-name\" as const;\nexport const fragnoDatabaseAdapterVersionFakeSymbol = \"$fragno-database-adapter-version\" as const;\n\n/**\n * Storage type for database context - stores the Unit of Work.\n * This is shared across all fragments using the same adapter.\n */\nexport type DatabaseContextStorage = {\n  uow: IUnitOfWork;\n};\n\n/**\n * Maps logical table names (used by fragment authors) to physical table names (with namespace suffix)\n */\nexport interface TableNameMapper {\n  toPhysical(logicalName: string): string;\n  toLogical(physicalName: string): string;\n}\n\nexport interface DatabaseAdapter<TUOWConfig = void> {\n  [fragnoDatabaseAdapterNameFakeSymbol]: string;\n  [fragnoDatabaseAdapterVersionFakeSymbol]: number;\n\n  /**\n   * Request context storage shared across all fragments using this adapter.\n   * This allows multiple fragments to participate in the same Unit of Work.\n   */\n  readonly contextStorage: RequestContextStorage<DatabaseContextStorage>;\n\n  /**\n   * Get current schema version, undefined if not initialized.\n   */\n  getSchemaVersion(namespace: string): Promise<string | undefined>;\n\n  createQueryEngine: <const T extends AnySchema>(\n    schema: T,\n    namespace: string,\n  ) => SimpleQueryInterface<T, TUOWConfig>;\n\n  prepareMigrations?: <const T extends AnySchema>(\n    schema: T,\n    namespace: string,\n  ) => PreparedMigrations;\n\n  /**\n   * Generate a combined schema file from one or more fragments.\n   * If not implemented, schema generation is not supported for this adapter.\n   */\n  createSchemaGenerator?: (\n    fragments: { schema: AnySchema; namespace: string }[],\n    options?: { path?: string },\n  ) => SchemaGenerator;\n\n  /**\n   * Creates a table name mapper for the given namespace.\n   * Used to convert between logical table names and physical table names.\n   */\n  createTableNameMapper: (namespace: string) => TableNameMapper;\n\n  isConnectionHealthy: () => Promise<boolean>;\n\n  close: () => Promise<void>;\n}\n"],"mappings":";AAOA,MAAa,sCAAsC;AACnD,MAAa,yCAAyC"}

package/dist/adapters/drizzle/drizzle-adapter.d.ts

@@ -1,28 +1,13 @@
 import { AnySchema } from "../../schema/create.js";
-import { AbstractQuery } from "../../query/query.js";
 import { SchemaGenerator } from "../../schema-generator/schema-generator.js";
-import { DatabaseAdapter, DatabaseContextStorage, fragnoDatabaseAdapterNameFakeSymbol, fragnoDatabaseAdapterVersionFakeSymbol } from "../adapters.js";
-import { TableNameMapper } from "./shared.js";
-import { DrizzleUOWConfig } from "./drizzle-query.js";
-import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
+import { TableNameMapper } from "../shared/table-name-mapper.js";
+import { DatabaseAdapter } from "../adapters.js";
+import { GenericSQLAdapter, GenericSQLOptions, UnitOfWorkConfig } from "../generic-sql/generic-sql-adapter.js";
 
 //#region src/adapters/drizzle/drizzle-adapter.d.ts
-interface DrizzleConfig {
-  db: unknown | (() => unknown | Promise<unknown>);
-  provider: "sqlite" | "mysql" | "postgresql";
-}
-declare class DrizzleAdapter implements DatabaseAdapter<DrizzleUOWConfig> {
-  #private;
-  constructor(config: DrizzleConfig);
-  get [fragnoDatabaseAdapterNameFakeSymbol](): string;
-  get [fragnoDatabaseAdapterVersionFakeSymbol](): number;
-  get contextStorage(): RequestContextStorage<DatabaseContextStorage>;
-  close(): Promise<void>;
+declare class DrizzleAdapter extends GenericSQLAdapter implements DatabaseAdapter<UnitOfWorkConfig> {
+  constructor(options: GenericSQLOptions);
   createTableNameMapper(namespace: string): TableNameMapper;
-  get provider(): "sqlite" | "mysql" | "postgresql";
-  isConnectionHealthy(): Promise<boolean>;
-  getSchemaVersion(namespace: string): Promise<string | undefined>;
-  createQueryEngine<TSchema extends AnySchema>(schema: TSchema, namespace: string): AbstractQuery<TSchema, DrizzleUOWConfig>;
   createSchemaGenerator(fragments: {
     schema: AnySchema;
     namespace: string;
@@ -31,5 +16,5 @@ declare class DrizzleAdapter implements DatabaseAdapter<DrizzleUOWConfig> {
   }): SchemaGenerator;
 }
 //#endregion
-export { DrizzleAdapter, DrizzleConfig };
+export { DrizzleAdapter };
 //# sourceMappingURL=drizzle-adapter.d.ts.map

package/dist/adapters/drizzle/drizzle-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"drizzle-adapter.d.ts","names":[],"sources":["../../../src/adapters/drizzle/drizzle-adapter.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAiBiB,aAAA;iCACgB;EADhB,QAAA,EAAA,QAAa,GAAA,OACG,GAAA,YAAO;AAIxC;AAAuD,cAA1C,cAAA,YAA0B,eAAgB,CAAA,gBAAA,CAAA,CAAA;EAMjC,CAAA,OAAA;EAQf,WAAA,CAAA,MAAA,EARe,aAQf;EAIA,KAJA,mCAAA,GAIA,EAAA,MAAA;EAIuC,KAJvC,sCAAA,GAIuC,EAAA,MAAA;EAAtB,IAAA,cAAA,CAAA,CAAA,EAAA,qBAAA,CAAsB,sBAAtB,CAAA;EAIP,KAAA,CAAA,CAAA,EAAA,OAAA,CAAA,IAAA,CAAA;EAAO,qBAAA,CAAA,SAAA,EAAA,MAAA,CAAA,EAAA,eAAA;EAYO,IAAA,QAAA,CAAA,CAAA,EAAA,QAAA,GAAA,OAAA,GAAA,YAAA;EAqBc,mBAAA,CAAA,CAAA,EArBd,OAqBc,CAAA,OAAA,CAAA;EAeT,gBAAA,CAAA,SAAA,EAAA,MAAA,CAAA,EAfS,OAeT,CAAA,MAAA,GAAA,SAAA,CAAA;EACxB,iBAAA,CAAA,gBADwB,SACxB,CAAA,CAAA,MAAA,EAAA,OAAA,EAAA,SAAA,EAAA,MAAA,CAAA,EAEP,aAFO,CAEO,OAFP,EAEgB,gBAFhB,CAAA;EAEO,qBAAA,CAAA,SAAA,EAAA;IAAS,MAAA,EAiBH,SAjBG;IAAvB,SAAA,EAAA,MAAA;EAiBoB,CAAA,EAAA,EAAA,OA9Fc,CA8Fd,EAAA;IAEpB,IAAA,CAAA,EAAA,MAAA;EAhGkC,CAAA,CAAA,EAgGlC,eAhGkC"}
+{"version":3,"file":"drizzle-adapter.d.ts","names":[],"sources":["../../../src/adapters/drizzle/drizzle-adapter.ts"],"sourcesContent":[],"mappings":";;;;;;;cAYa,cAAA,SAAuB,iBAAA,YAA6B,gBAAgB;uBAC1D;4CAAiB;EAD3B,qBAAe,CAAA,SAAA,EAAA;IAAqD,MAAA,EAUxD,SAVwD;IAC1D,SAAA,EAAA,MAAA;EAAiB,CAAA,EAAA,EAAA,OAWnC,CAXmC,EAAA;IASf,IAAA,CAAA,EAAA,MAAA;EAEpB,CAAA,CAAA,EAAA,eAAA"}

package/dist/adapters/drizzle/drizzle-adapter.js

@@ -1,68 +1,21 @@
 import "../../schema/create.js";
-import { RequestContextStorage } from "../../packages/fragno/dist/api/request-context-storage.js";
-import { SETTINGS_TABLE_NAME, settingsSchema } from "../../fragments/internal-fragment.js";
-import { fragnoDatabaseAdapterNameFakeSymbol, fragnoDatabaseAdapterVersionFakeSymbol } from "../adapters.js";
-import { createTableNameMapper } from "./shared.js";
+import { createTableNameMapper } from "../shared/table-name-mapper.js";
 import { generateSchema } from "./generate.js";
-import { fromDrizzle } from "./drizzle-query.js";
-import { createDrizzleConnectionPool } from "./drizzle-connection-pool.js";
-import { sql } from "drizzle-orm";
+import { GenericSQLAdapter } from "../generic-sql/generic-sql-adapter.js";
 
 //#region src/adapters/drizzle/drizzle-adapter.ts
-var DrizzleAdapter = class {
-	#connectionPool;
-	#provider;
-	#schemaNamespaceMap = /* @__PURE__ */ new WeakMap();
-	#contextStorage;
-	constructor(config) {
-		this.#connectionPool = createDrizzleConnectionPool(config.db);
-		this.#provider = config.provider;
-		this.#contextStorage = new RequestContextStorage();
-	}
-	get [fragnoDatabaseAdapterNameFakeSymbol]() {
-		return "drizzle";
-	}
-	get [fragnoDatabaseAdapterVersionFakeSymbol]() {
-		return 0;
-	}
-	get contextStorage() {
-		return this.#contextStorage;
-	}
-	async close() {
-		await this.#connectionPool.close();
+var DrizzleAdapter = class extends GenericSQLAdapter {
+	constructor(options) {
+		super(options);
 	}
 	createTableNameMapper(namespace) {
-		return createTableNameMapper(namespace);
-	}
-	get provider() {
-		return this.#provider;
-	}
-	async isConnectionHealthy() {
-		const conn = await this.#connectionPool.connect();
-		try {
-			const result = await conn.db.execute(sql`SELECT 1 as healthy`);
-			if (Array.isArray(result)) return result.length > 0 && result[0]["healthy"] === 1;
-			else return result.rows[0]["healthy"] === 1;
-		} catch {
-			return false;
-		} finally {
-			await conn.release();
-		}
-	}
-	async getSchemaVersion(namespace) {
-		const [[result]] = await this.createQueryEngine(settingsSchema, "").createUnitOfWork().find(SETTINGS_TABLE_NAME, (b) => b.whereIndex("unique_key", (eb) => eb("key", "=", `${namespace}.schema_version`))).executeRetrieve();
-		return result?.value;
-	}
-	createQueryEngine(schema, namespace) {
-		this.#schemaNamespaceMap.set(schema, namespace);
-		const mapper = namespace ? createTableNameMapper(namespace) : void 0;
-		return fromDrizzle(schema, this.#connectionPool, this.#provider, mapper, void 0, this.#schemaNamespaceMap);
+		return createTableNameMapper(namespace, false);
 	}
 	createSchemaGenerator(fragments, options) {
 		return { generateSchema: (genOptions) => {
 			const path = genOptions?.path ?? options?.path ?? "fragno-schema.ts";
 			return {
-				schema: generateSchema(fragments, this.#provider),
+				schema: generateSchema(fragments, this.driverConfig.databaseType, { mapperFactory: (ns) => ns ? this.createTableNameMapper(ns) : void 0 }),
 				path
 			};
 		} };

package/dist/adapters/drizzle/drizzle-adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"drizzle-adapter.js","names":["#connectionPool","#provider","#contextStorage","#schemaNamespaceMap"],"sources":["../../../src/adapters/drizzle/drizzle-adapter.ts"],"sourcesContent":["import type { DatabaseAdapter, DatabaseContextStorage } from \"../adapters\";\nimport { type AnySchema } from \"../../schema/create\";\nimport type { AbstractQuery } from \"../../query/query\";\nimport type { SchemaGenerator } from \"../../schema-generator/schema-generator\";\nimport { generateSchema } from \"./generate\";\nimport { fromDrizzle, type DrizzleUOWConfig } from \"./drizzle-query\";\nimport { createTableNameMapper, type DBType, type DrizzleResult } from \"./shared\";\nimport { sql } from \"drizzle-orm\";\nimport { settingsSchema, SETTINGS_TABLE_NAME } from \"../../fragments/internal-fragment\";\nimport {\n  fragnoDatabaseAdapterNameFakeSymbol,\n  fragnoDatabaseAdapterVersionFakeSymbol,\n} from \"../adapters\";\nimport type { ConnectionPool } from \"../../shared/connection-pool\";\nimport { createDrizzleConnectionPool } from \"./drizzle-connection-pool\";\nimport { RequestContextStorage } from \"@fragno-dev/core/internal/request-context-storage\";\n\nexport interface DrizzleConfig {\n  db: unknown | (() => unknown | Promise<unknown>);\n  provider: \"sqlite\" | \"mysql\" | \"postgresql\";\n}\n\nexport class DrizzleAdapter implements DatabaseAdapter<DrizzleUOWConfig> {\n  #connectionPool: ConnectionPool<DBType>;\n  #provider: \"sqlite\" | \"mysql\" | \"postgresql\";\n  #schemaNamespaceMap = new WeakMap<AnySchema, string>();\n  #contextStorage: RequestContextStorage<DatabaseContextStorage>;\n\n  constructor(config: DrizzleConfig) {\n    this.#connectionPool = createDrizzleConnectionPool(\n      config.db as DBType | (() => DBType | Promise<DBType>),\n    );\n    this.#provider = config.provider;\n    this.#contextStorage = new RequestContextStorage();\n  }\n\n  get [fragnoDatabaseAdapterNameFakeSymbol](): string {\n    return \"drizzle\";\n  }\n\n  get [fragnoDatabaseAdapterVersionFakeSymbol](): number {\n    return 0;\n  }\n\n  get contextStorage(): RequestContextStorage<DatabaseContextStorage> {\n    return this.#contextStorage;\n  }\n\n  async close(): Promise<void> {\n    await this.#connectionPool.close();\n  }\n\n  createTableNameMapper(namespace: string) {\n    return createTableNameMapper(namespace);\n  }\n\n  get provider(): \"sqlite\" | \"mysql\" | \"postgresql\" {\n    return this.#provider;\n  }\n\n  async isConnectionHealthy(): Promise<boolean> {\n    const conn = await this.#connectionPool.connect();\n    try {\n      const result = await conn.db.execute(sql`SELECT 1 as healthy`);\n\n      // Handle different result formats across providers\n      // PostgreSQL/MySQL: { rows: [...] }\n      // SQLite: array directly or { rows: [...] }\n      if (Array.isArray(result)) {\n        return result.length > 0 && result[0][\"healthy\"] === 1;\n      } else {\n        const drizzleResult = result as DrizzleResult;\n        return drizzleResult.rows[0][\"healthy\"] === 1;\n      }\n    } catch {\n      return false;\n    } finally {\n      await conn.release();\n    }\n  }\n\n  async getSchemaVersion(namespace: string): Promise<string | undefined> {\n    // Note: This looks up arbitrary fragment schema versions (e.g., \"my-fragment.schema_version\")\n    // which are different from Fragno's internal settings (prefixed with SETTINGS_NAMESPACE)\n    // So we can't use the internal fragment here, we need direct query engine access\n    const queryEngine = this.createQueryEngine(settingsSchema, \"\");\n\n    const uow = queryEngine\n      .createUnitOfWork()\n      .find(SETTINGS_TABLE_NAME, (b) =>\n        b.whereIndex(\"unique_key\", (eb) => eb(\"key\", \"=\", `${namespace}.schema_version`)),\n      );\n    const [[result]] = await uow.executeRetrieve();\n    return result?.value;\n  }\n\n  createQueryEngine<TSchema extends AnySchema>(\n    schema: TSchema,\n    namespace: string,\n  ): AbstractQuery<TSchema, DrizzleUOWConfig> {\n    // Register schema-namespace mapping\n    this.#schemaNamespaceMap.set(schema, namespace);\n\n    // Only create mapper if namespace is non-empty\n    const mapper = namespace ? createTableNameMapper(namespace) : undefined;\n    return fromDrizzle(\n      schema,\n      this.#connectionPool,\n      this.#provider,\n      mapper,\n      undefined,\n      this.#schemaNamespaceMap,\n    );\n  }\n\n  createSchemaGenerator(\n    fragments: { schema: AnySchema; namespace: string }[],\n    options?: { path?: string },\n  ): SchemaGenerator {\n    return {\n      generateSchema: (genOptions) => {\n        const path = genOptions?.path ?? options?.path ?? \"fragno-schema.ts\";\n\n        return {\n          schema: generateSchema(fragments, this.#provider),\n          path,\n        };\n      },\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;AAsBA,IAAa,iBAAb,MAAyE;CACvE;CACA;CACA,sCAAsB,IAAI,SAA4B;CACtD;CAEA,YAAY,QAAuB;AACjC,QAAKA,iBAAkB,4BACrB,OAAO,GACR;AACD,QAAKC,WAAY,OAAO;AACxB,QAAKC,iBAAkB,IAAI,uBAAuB;;CAGpD,KAAK,uCAA+C;AAClD,SAAO;;CAGT,KAAK,0CAAkD;AACrD,SAAO;;CAGT,IAAI,iBAAgE;AAClE,SAAO,MAAKA;;CAGd,MAAM,QAAuB;AAC3B,QAAM,MAAKF,eAAgB,OAAO;;CAGpC,sBAAsB,WAAmB;AACvC,SAAO,sBAAsB,UAAU;;CAGzC,IAAI,WAA8C;AAChD,SAAO,MAAKC;;CAGd,MAAM,sBAAwC;EAC5C,MAAM,OAAO,MAAM,MAAKD,eAAgB,SAAS;AACjD,MAAI;GACF,MAAM,SAAS,MAAM,KAAK,GAAG,QAAQ,GAAG,sBAAsB;AAK9D,OAAI,MAAM,QAAQ,OAAO,CACvB,QAAO,OAAO,SAAS,KAAK,OAAO,GAAG,eAAe;OAGrD,QADsB,OACD,KAAK,GAAG,eAAe;UAExC;AACN,UAAO;YACC;AACR,SAAM,KAAK,SAAS;;;CAIxB,MAAM,iBAAiB,WAAgD;EAWrE,MAAM,CAAC,CAAC,WAAW,MAPC,KAAK,kBAAkB,gBAAgB,GAAG,CAG3D,kBAAkB,CAClB,KAAK,sBAAsB,MAC1B,EAAE,WAAW,eAAe,OAAO,GAAG,OAAO,KAAK,GAAG,UAAU,iBAAiB,CAAC,CAClF,CAC0B,iBAAiB;AAC9C,SAAO,QAAQ;;CAGjB,kBACE,QACA,WAC0C;AAE1C,QAAKG,mBAAoB,IAAI,QAAQ,UAAU;EAG/C,MAAM,SAAS,YAAY,sBAAsB,UAAU,GAAG;AAC9D,SAAO,YACL,QACA,MAAKH,gBACL,MAAKC,UACL,QACA,QACA,MAAKE,mBACN;;CAGH,sBACE,WACA,SACiB;AACjB,SAAO,EACL,iBAAiB,eAAe;GAC9B,MAAM,OAAO,YAAY,QAAQ,SAAS,QAAQ;AAElD,UAAO;IACL,QAAQ,eAAe,WAAW,MAAKF,SAAU;IACjD;IACD;KAEJ"}
+{"version":3,"file":"drizzle-adapter.js","names":[],"sources":["../../../src/adapters/drizzle/drizzle-adapter.ts"],"sourcesContent":["import type { DatabaseAdapter } from \"../adapters\";\nimport { type AnySchema } from \"../../schema/create\";\nimport type { SchemaGenerator } from \"../../schema-generator/schema-generator\";\nimport { generateSchema } from \"./generate\";\nimport { createTableNameMapper } from \"../shared/table-name-mapper\";\n\nimport {\n  GenericSQLAdapter,\n  type GenericSQLOptions,\n  type UnitOfWorkConfig,\n} from \"../generic-sql/generic-sql-adapter\";\n\nexport class DrizzleAdapter extends GenericSQLAdapter implements DatabaseAdapter<UnitOfWorkConfig> {\n  constructor(options: GenericSQLOptions) {\n    super(options);\n  }\n\n  override createTableNameMapper(namespace: string) {\n    return createTableNameMapper(namespace, false);\n  }\n\n  createSchemaGenerator(\n    fragments: { schema: AnySchema; namespace: string }[],\n    options?: { path?: string },\n  ): SchemaGenerator {\n    return {\n      generateSchema: (genOptions) => {\n        const path = genOptions?.path ?? options?.path ?? \"fragno-schema.ts\";\n\n        return {\n          schema: generateSchema(fragments, this.driverConfig.databaseType, {\n            mapperFactory: (ns) => (ns ? this.createTableNameMapper(ns) : undefined),\n          }),\n          path,\n        };\n      },\n    };\n  }\n}\n"],"mappings":";;;;;;AAYA,IAAa,iBAAb,cAAoC,kBAA+D;CACjG,YAAY,SAA4B;AACtC,QAAM,QAAQ;;CAGhB,AAAS,sBAAsB,WAAmB;AAChD,SAAO,sBAAsB,WAAW,MAAM;;CAGhD,sBACE,WACA,SACiB;AACjB,SAAO,EACL,iBAAiB,eAAe;GAC9B,MAAM,OAAO,YAAY,QAAQ,SAAS,QAAQ;AAElD,UAAO;IACL,QAAQ,eAAe,WAAW,KAAK,aAAa,cAAc,EAChE,gBAAgB,OAAQ,KAAK,KAAK,sBAAsB,GAAG,GAAG,QAC/D,CAAC;IACF;IACD;KAEJ"}

package/dist/adapters/drizzle/generate.d.ts

@@ -1,4 +1,5 @@
 import { AnySchema } from "../../schema/create.js";
+import { TableNameMapper } from "../shared/table-name-mapper.js";
 import { SQLProvider } from "../../shared/providers.js";
 
 //#region src/adapters/drizzle/generate.d.ts
@@ -11,6 +12,8 @@ interface GenerateSchemaOptions {
     /** Module to import from */
     from: string;
   };
+  /** Optional mapper factory for creating table name mappers with custom sanitization */
+  mapperFactory?: (namespace: string | undefined) => TableNameMapper | undefined;
 }
 /**
  * Generate a settings table for storing fragment versions

package/dist/adapters/drizzle/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","names":[],"sources":["../../../src/adapters/drizzle/generate.ts"],"sourcesContent":[],"mappings":";;;;KA6BY,iBAAA,GAAoB,QAAQ;UAyjBvB,qBAAA;EAzjBL;EAyjBK,iBAAA,CAAA,EAAA;IAgBD;IAC0B,IAAA,EAAA,MAAA;IAC9B;IACA,IAAA,EAAA,MAAA;EAAqB,CAAA;;;;;;;;iBAHjB,cAAA;;UAC0B;eAC9B,6BACA"}
+{"version":3,"file":"generate.d.ts","names":[],"sources":["../../../src/adapters/drizzle/generate.ts"],"sourcesContent":[],"mappings":";;;;;KAkCY,iBAAA,GAAoB,QAAQ;UAulBvB,qBAAA;EAvlBL;EAulBK,iBAAA,CAAA,EAAA;IAkBD;IAC0B,IAAA,EAAA,MAAA;IAC9B;IACA,IAAA,EAAA,MAAA;EAAqB,CAAA;;qDAZoB;;;;;;;;iBASrC,cAAA;;UAC0B;eAC9B,6BACA"}

package/dist/adapters/drizzle/generate.js

@@ -1,8 +1,8 @@
 import { InternalIdColumn } from "../../schema/create.js";
-import { schemaToDBType } from "../../schema/serialize.js";
 import { importGenerator } from "../../util/import-generator.js";
 import { ident, parseVarchar } from "../../util/parse.js";
-import { createTableNameMapper, sanitizeNamespace } from "./shared.js";
+import { createTableNameMapper, sanitizeNamespace } from "../shared/table-name-mapper.js";
+import { createSQLTypeMapper } from "../../schema/type-conversion/create-sql-type-mapper.js";
 
 //#region src/adapters/drizzle/generate.ts
 const PROVIDER_IMPORTS = {
@@ -50,7 +50,7 @@ function generateBinaryCustomType(ctx, customTypes) {
 	const code = generateCustomType(ctx, name, {
 		dataType: "Uint8Array",
 		driverDataType: "Buffer",
-		databaseDataType: schemaToDBType({ type: "binary" }, ctx.provider),
+		databaseDataType: createSQLTypeMapper(ctx.provider).getDatabaseType({ type: "binary" }),
 		fromDriverCode: "return new Uint8Array(value.buffer, value.byteOffset, value.byteLength)",
 		toDriverCode: `return value instanceof Buffer? value : Buffer.from(value)`
 	});
@@ -59,10 +59,10 @@ function generateBinaryCustomType(ctx, customTypes) {
 }
 /**
 * Maps SQL database types to Drizzle function names and parameters.
-* Uses schemaToDBType as the source of truth for type conversion.
+* Uses SQLTypeMapper as the source of truth for type conversion.
 */
 function getColumnTypeFunction(ctx, column, customTypes) {
-	return mapDBTypeToDrizzleFunction(ctx, schemaToDBType(column, ctx.provider), column, customTypes);
+	return mapDBTypeToDrizzleFunction(ctx, createSQLTypeMapper(ctx.provider).getDatabaseType(column), column, customTypes);
 }
 /**
 * Maps a database type string to a Drizzle function name and parameters.
@@ -142,6 +142,13 @@ function mapDBTypeToDrizzleFunction(ctx, dbType, column, customTypes) {
 	}
 	return { name: dbType };
 }
+/**
+* Get the physical table name (with namespace suffix) using the mapper if available
+*/
+function getPhysicalTableName(logicalName, namespace, mapper) {
+	if (!namespace) return logicalName;
+	return mapper ? mapper.toPhysical(logicalName) : `${logicalName}_${sanitizeNamespace(namespace)}`;
+}
 function generateColumnDefinition(ctx, column, customTypes) {
 	const parts = [];
 	const typeFn = getColumnTypeFunction(ctx, column, customTypes);
@@ -180,8 +187,7 @@ function generateColumnDefinition(ctx, column, customTypes) {
 function generateAllColumns(ctx, table, customTypes) {
 	return Object.values(table.columns).map((column) => generateColumnDefinition(ctx, column, customTypes));
 }
-function generateForeignKeys(ctx, table, namespace) {
-	const mapper = namespace ? createTableNameMapper(namespace) : void 0;
+function generateForeignKeys(ctx, table, namespace, mapper) {
 	const keys = [];
 	for (const relation of Object.values(table.relations)) {
 		if (relation.type === "many") continue;
@@ -222,21 +228,21 @@ function generateIndexes(ctx, table, namespace) {
 	}
 	return indexes;
 }
-function generateTableConstraints(ctx, table, namespace) {
-	return [...generateForeignKeys(ctx, table, namespace), ...generateIndexes(ctx, table, namespace)];
+function generateTableConstraints(ctx, table, namespace, mapper) {
+	return [...generateForeignKeys(ctx, table, namespace, mapper), ...generateIndexes(ctx, table, namespace)];
 }
-function generateTable(ctx, table, customTypes, namespace) {
+function generateTable(ctx, table, customTypes, namespace, mapper) {
 	const tableFn = PROVIDER_TABLE_FUNCTIONS[ctx.provider];
 	ctx.imports.addImport(tableFn, ctx.importSource);
 	const columns = generateAllColumns(ctx, table, customTypes);
-	const constraints = generateTableConstraints(ctx, table, namespace);
-	const physicalTableName = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
-	const exportName = physicalTableName;
+	const constraints = generateTableConstraints(ctx, table, namespace, mapper);
+	const physicalTableName = getPhysicalTableName(table.ormName, namespace, mapper);
+	const exportName = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
 	const args = [`"${physicalTableName}"`, `{\n${columns.join(",\n")}\n}`];
 	if (constraints.length > 0) args.push(`(table) => [\n${ident(constraints.join(",\n"))}\n]`);
 	return `export const ${exportName} = ${tableFn}(${args.join(", ")})`;
 }
-function generateRelation(ctx, table, namespace, inverseRelations) {
+function generateRelation(ctx, table, namespace, inverseRelations, _mapper) {
 	const relations = [];
 	let hasOne = false;
 	let hasMany = false;
@@ -247,10 +253,10 @@ function generateRelation(ctx, table, namespace, inverseRelations) {
 		if (relation.type === "one") {
 			const fields = [];
 			const references = [];
-			const tableRef$1 = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
+			const tableRef = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
 			const relatedTableRef = namespace ? `${relation.table.ormName}_${sanitizeNamespace(namespace)}` : relation.table.ormName;
 			for (const [left, right] of relation.on) {
-				fields.push(`${tableRef$1}.${left}`);
+				fields.push(`${tableRef}.${left}`);
 				const actualRight = right === "id" ? "_internalId" : right;
 				references.push(`${relatedTableRef}.${actualRight}`);
 			}
@@ -274,10 +280,10 @@ function generateRelation(ctx, table, namespace, inverseRelations) {
 	if (hasOne) params.push("one");
 	if (hasMany) params.push("many");
 	const relationParams = params.length > 0 ? `{ ${params.join(", ")} }` : "{}";
-	const tableRef = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
-	const relationsName = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}Relations` : `${table.ormName}Relations`;
+	const exportTableRef = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
+	const relationsName = namespace ? `${exportTableRef}Relations` : `${table.ormName}Relations`;
 	ctx.imports.addImport("relations", "drizzle-orm");
-	return `export const ${relationsName} = relations(${tableRef}, (${relationParams}) => ({
+	return `export const ${relationsName} = relations(${exportTableRef}, (${relationParams}) => ({
 ${relations.join(",\n")}
 }));`;
 }
@@ -285,19 +291,19 @@ ${relations.join(",\n")}
 * Generate a schema export object for a fragment
 * This groups all tables by their logical names for easier access
 */
-function generateFragmentSchemaExport(schema, namespace, tablesWithRelations) {
+function generateFragmentSchemaExport(schema, namespace, tablesWithRelations, _mapper) {
 	const drizzleEntries = [];
 	for (const table of Object.values(schema.tables)) {
-		const physicalExportName = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
-		drizzleEntries.push(`  ${physicalExportName}: ${physicalExportName}`);
+		const exportName = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
+		drizzleEntries.push(`  ${exportName}: ${exportName}`);
 		if (tablesWithRelations?.has(table.name)) {
-			const relationsName = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}Relations` : `${table.ormName}Relations`;
+			const relationsName = namespace ? `${exportName}Relations` : `${table.ormName}Relations`;
 			drizzleEntries.push(`  ${relationsName}: ${relationsName}`);
 		}
 		if (namespace) {
-			drizzleEntries.push(`  ${table.ormName}: ${physicalExportName}`);
+			drizzleEntries.push(`  ${table.ormName}: ${exportName}`);
 			if (tablesWithRelations?.has(table.name)) {
-				const physicalRelationsName = `${table.ormName}_${sanitizeNamespace(namespace)}Relations`;
+				const physicalRelationsName = `${exportName}Relations`;
 				const aliasRelationsName = `${table.ormName}Relations`;
 				drizzleEntries.push(`  ${aliasRelationsName}: ${physicalRelationsName}`);
 			}
@@ -316,14 +322,16 @@ function generateSchema(fragments, provider, options) {
 	const ctx = createContext(provider, options?.idGeneratorImport);
 	const customTypes = [];
 	const sections = [];
+	const getMapper = options?.mapperFactory || ((ns) => ns ? createTableNameMapper(ns, true) : void 0);
 	for (const { schema, namespace } of fragments) {
 		const fragmentTables = [];
+		const mapper = getMapper(namespace);
 		fragmentTables.push("");
 		fragmentTables.push("// ============================================================================");
 		fragmentTables.push(`// Fragment: ${namespace}`);
 		fragmentTables.push("// ============================================================================");
 		for (const table of Object.values(schema.tables)) {
-			const tableCode = generateTable(ctx, table, customTypes, namespace);
+			const tableCode = generateTable(ctx, table, customTypes, namespace, mapper);
 			fragmentTables.push("");
 			fragmentTables.push(tableCode);
 		}
@@ -338,7 +346,7 @@ function generateSchema(fragments, provider, options) {
 		}
 		const tablesWithRelations = /* @__PURE__ */ new Set();
 		for (const table of Object.values(schema.tables)) {
-			const relationCode = generateRelation(ctx, table, namespace, inverseRelations.get(table.name));
+			const relationCode = generateRelation(ctx, table, namespace, inverseRelations.get(table.name), mapper);
 			if (relationCode) {
 				fragmentTables.push("");
 				fragmentTables.push(relationCode);
@@ -347,7 +355,7 @@ function generateSchema(fragments, provider, options) {
 		}
 		if (namespace !== "") {
 			fragmentTables.push("");
-			fragmentTables.push(generateFragmentSchemaExport(schema, namespace, tablesWithRelations));
+			fragmentTables.push(generateFragmentSchemaExport(schema, namespace, tablesWithRelations, mapper));
 		}
 		sections.push(...fragmentTables);
 	}