@fragno-dev/db 0.1.14 → 0.2.0

package/src/adapters/drizzle/generate.ts

@@ -8,9 +8,13 @@ import {
   InternalIdColumn,
 } from "../../schema/create";
 import type { SQLProvider } from "../../shared/providers";
-import { schemaToDBType, type DBTypeLiteral } from "../../schema/serialize";
-import { createTableNameMapper, sanitizeNamespace } from "./shared";
-import { settingsSchema, SETTINGS_TABLE_NAME } from "../../shared/settings-schema";
+import {
+  createTableNameMapper,
+  sanitizeNamespace,
+  type TableNameMapper,
+} from "../shared/table-name-mapper";
+import { type DatabaseTypeLiteral } from "../../schema/type-conversion/type-mapping";
+import { createSQLTypeMapper } from "../../schema/type-conversion/create-sql-type-mapper";
 
 // ============================================================================
 // PROVIDER CONFIGURATION
@@ -99,10 +103,11 @@ function generateCustomType(
 
 function generateBinaryCustomType(ctx: GeneratorContext, customTypes: string[]): string {
   const name = "customBinary";
+  const typeMapper = createSQLTypeMapper(ctx.provider);
   const code = generateCustomType(ctx, name, {
     dataType: "Uint8Array",
     driverDataType: "Buffer",
-    databaseDataType: schemaToDBType({ type: "binary" }, ctx.provider),
+    databaseDataType: typeMapper.getDatabaseType({ type: "binary" }),
     fromDriverCode: "return new Uint8Array(value.buffer, value.byteOffset, value.byteLength)",
     toDriverCode: `return value instanceof Buffer? value : Buffer.from(value)`,
   });
@@ -125,15 +130,16 @@ interface ColumnTypeFunction {
 
 /**
  * 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: GeneratorContext,
   column: AnyColumn,
   customTypes: string[],
 ): ColumnTypeFunction {
-  // Get the canonical database type from schemaToDBType
-  const dbType = schemaToDBType(column, ctx.provider);
+  // Get the canonical database type from type mapper
+  const typeMapper = createSQLTypeMapper(ctx.provider);
+  const dbType = typeMapper.getDatabaseType(column);
 
   // Map database types to Drizzle function names
   return mapDBTypeToDrizzleFunction(ctx, dbType, column, customTypes);
@@ -144,7 +150,7 @@ function getColumnTypeFunction(
  */
 function mapDBTypeToDrizzleFunction(
   ctx: GeneratorContext,
-  dbType: DBTypeLiteral,
+  dbType: DatabaseTypeLiteral,
   column: AnyColumn,
   customTypes: string[],
 ): ColumnTypeFunction {
@@ -184,7 +190,11 @@ function mapDBTypeToDrizzleFunction(
       case "longblob":
         return { name: generateBinaryCustomType(ctx, customTypes), isCustomType: true };
       case "bigint":
-        return { name: "bigint" };
+        // MySQL bigint requires mode parameter
+        return { name: "bigint", params: [`{ mode: "number" }`] };
+      case "integer":
+        // MySQL uses "int" not "integer" in Drizzle ORM
+        return { name: "int" };
       default:
         if (dbType.startsWith("varchar(")) {
           const length = parseVarchar(dbType);
@@ -228,6 +238,24 @@ function mapDBTypeToDrizzleFunction(
   return { name: dbType };
 }
 
+// ============================================================================
+// TABLE NAME HELPERS
+// ============================================================================
+
+/**
+ * Get the physical table name (with namespace suffix) using the mapper if available
+ */
+function getPhysicalTableName(
+  logicalName: string,
+  namespace: string | undefined,
+  mapper: TableNameMapper | undefined,
+): string {
+  if (!namespace) {
+    return logicalName;
+  }
+  return mapper ? mapper.toPhysical(logicalName) : `${logicalName}_${sanitizeNamespace(namespace)}`;
+}
+
 // ============================================================================
 // COLUMN GENERATION
 // ============================================================================
@@ -315,8 +343,12 @@ function generateAllColumns(
 // CONSTRAINT GENERATION
 // ============================================================================
 
-function generateForeignKeys(ctx: GeneratorContext, table: AnyTable, namespace?: string): string[] {
-  const mapper = namespace ? createTableNameMapper(namespace) : undefined;
+function generateForeignKeys(
+  ctx: GeneratorContext,
+  table: AnyTable,
+  namespace?: string,
+  mapper?: TableNameMapper,
+): string[] {
   const keys: string[] = [];
 
   for (const relation of Object.values(table.relations)) {
@@ -338,7 +370,7 @@ function generateForeignKeys(ctx: GeneratorContext, table: AnyTable, namespace?:
       if (isSelfReference) {
         foreignColumns.push(`table.${actualRefCol}`);
       } else {
-        // Suffix the foreign table reference with namespace if provided
+        // Use sanitized TypeScript export name for identifier reference
         const foreignTableRef = namespace
           ? `${relation.table.ormName}_${sanitizeNamespace(namespace)}`
           : relation.table.ormName;
@@ -388,8 +420,12 @@ function generateTableConstraints(
   ctx: GeneratorContext,
   table: AnyTable,
   namespace?: string,
+  mapper?: TableNameMapper,
 ): string[] {
-  return [...generateForeignKeys(ctx, table, namespace), ...generateIndexes(ctx, table, namespace)];
+  return [
+    ...generateForeignKeys(ctx, table, namespace, mapper),
+    ...generateIndexes(ctx, table, namespace),
+  ];
 }
 
 // ============================================================================
@@ -401,20 +437,18 @@ function generateTable(
   table: AnyTable,
   customTypes: string[],
   namespace?: string,
+  mapper?: TableNameMapper,
 ): string {
   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 constraints = generateTableConstraints(ctx, table, namespace, mapper);
 
-  // Suffix table name with namespace if provided, and sanitize for use as database table name
-  // Database table names must also be valid identifiers to work with Drizzle's relational query system
-  const physicalTableName = namespace
-    ? `${table.ormName}_${sanitizeNamespace(namespace)}`
-    : table.ormName;
-  // Same sanitized name for TypeScript export
-  const exportName = physicalTableName;
+  // Physical table name in the database (respects mapper configuration)
+  const physicalTableName = getPhysicalTableName(table.ormName, namespace, mapper);
+  // TypeScript export name must always be sanitized to be a valid JavaScript identifier
+  const exportName = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
 
   const args: string[] = [`"${physicalTableName}"`, `{\n${columns.join(",\n")}\n}`];
 
@@ -434,6 +468,7 @@ function generateRelation(
   table: AnyTable,
   namespace?: string,
   inverseRelations?: Array<{ fromTable: AnyTable; relation: Relation }>,
+  _mapper?: TableNameMapper,
 ): string | undefined {
   const relations: string[] = [];
   let hasOne = false;
@@ -455,7 +490,7 @@ function generateRelation(
       const fields: string[] = [];
       const references: string[] = [];
 
-      // Use sanitized namespace for identifier references
+      // Use sanitized TypeScript export names for identifier references
       const tableRef = namespace
         ? `${table.ormName}_${sanitizeNamespace(namespace)}`
         : table.ormName;
@@ -493,6 +528,7 @@ function generateRelation(
       if (relation.type === "one") {
         hasMany = true;
 
+        // Use sanitized TypeScript export name for identifier reference
         const fromTableRef = namespace
           ? `${fromTable.ormName}_${sanitizeNamespace(namespace)}`
           : fromTable.ormName;
@@ -523,13 +559,14 @@ function generateRelation(
   }
   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`;
+  // Use sanitized names for TypeScript export identifiers
+  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")}
 }));`;
 }
@@ -546,22 +583,22 @@ function generateFragmentSchemaExport(
   schema: AnySchema,
   namespace: string,
   tablesWithRelations?: Set<string>,
+  _mapper?: TableNameMapper,
 ): string {
   const drizzleEntries: string[] = [];
 
   for (const table of Object.values(schema.tables)) {
-    const physicalExportName = namespace
+    // TypeScript export name (always sanitized for valid JS identifiers)
+    const exportName = namespace
       ? `${table.ormName}_${sanitizeNamespace(namespace)}`
       : table.ormName;
 
     // Add physical table name to drizzle schema
-    drizzleEntries.push(`  ${physicalExportName}: ${physicalExportName}`);
+    drizzleEntries.push(`  ${exportName}: ${exportName}`);
 
     // Include relations for this table if they exist (either explicit or inverse)
     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}`);
     }
@@ -570,11 +607,11 @@ function generateFragmentSchemaExport(
     // The key insight: Drizzle needs BOTH the table alias AND its relations alias
     // in the same schema object for relational queries to work
     if (namespace) {
-      drizzleEntries.push(`  ${table.ormName}: ${physicalExportName}`);
+      drizzleEntries.push(`  ${table.ormName}: ${exportName}`);
 
       // Also add the relations under the aliased name if they exist
       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}`);
       }
@@ -584,6 +621,7 @@ function generateFragmentSchemaExport(
   // Add schema version as a number
   drizzleEntries.push(`  schemaVersion: ${schema.version}`);
 
+  // Use logical name (not physical) for the schema export variable name, sanitized for valid JS identifier
   const exportName = namespace ? `${sanitizeNamespace(namespace)}_schema` : "_schema";
 
   return `export const ${exportName} = {\n${drizzleEntries.join(",\n")}\n}`;
@@ -601,25 +639,15 @@ export 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
  */
-function generateSettingsTable(ctx: GeneratorContext): string {
-  // Use centralized settings schema
-
-  // Extract the table from the schema
-  const settingsTable =
-    settingsSchema.tables[SETTINGS_TABLE_NAME as keyof typeof settingsSchema.tables];
-
-  // Generate the table using the existing generateTable function
-  const customTypes: string[] = [];
-  return generateTable(ctx, settingsTable, customTypes);
-}
-
 /**
- * Generate a schema file from one or more fragments with a shared settings table
+ * Generate a schema file from one or more fragments with automatic de-duplication
  */
 export function generateSchema(
   fragments: { namespace: string; schema: AnySchema }[],
@@ -629,20 +657,13 @@ export function generateSchema(
   const ctx = createContext(provider, options?.idGeneratorImport);
   const customTypes: string[] = [];
   const sections: string[] = [];
+  const getMapper =
+    options?.mapperFactory ||
+    ((ns: string | undefined) => (ns ? createTableNameMapper(ns, true) : undefined));
 
-  // Generate settings table first
-  sections.push("");
-  sections.push("// ============================================================================");
-  sections.push("// Settings Table (shared across all fragments)");
-  sections.push("// ============================================================================");
-  sections.push("");
-  sections.push(generateSettingsTable(ctx));
-  sections.push("");
-  sections.push(`export const fragnoDbSettingSchemaVersion = ${settingsSchema.version};`);
-
-  // Generate each fragment's tables
-  for (const { namespace, schema } of fragments) {
+  for (const { schema, namespace } of fragments) {
     const fragmentTables: string[] = [];
+    const mapper = getMapper(namespace);
 
     // Add section header
     fragmentTables.push("");
@@ -656,7 +677,7 @@ export function generateSchema(
 
     // Generate tables for this fragment
     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);
     }
@@ -683,6 +704,7 @@ export function generateSchema(
         table,
         namespace,
         inverseRelations.get(table.name),
+        mapper,
       );
       if (relationCode) {
         fragmentTables.push("");
@@ -691,9 +713,13 @@ export function generateSchema(
       }
     }
 
-    // Generate schema export object
-    fragmentTables.push("");
-    fragmentTables.push(generateFragmentSchemaExport(schema, namespace, tablesWithRelations));
+    // Generate schema export object (skip for empty namespace to avoid duplicate _schema exports)
+    if (namespace !== "") {
+      fragmentTables.push("");
+      fragmentTables.push(
+        generateFragmentSchemaExport(schema, namespace, tablesWithRelations, mapper),
+      );
+    }
 
     sections.push(...fragmentTables);
   }

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

@@ -158,6 +158,23 @@ describe("generateSchema and migrate", () => {
       	"_version" integer DEFAULT 0 NOT NULL
       );
 
+      CREATE TABLE "fragno_hooks" (
+      	"id" varchar(30) NOT NULL,
+      	"namespace" text NOT NULL,
+      	"hookName" text NOT NULL,
+      	"payload" json NOT NULL,
+      	"status" text NOT NULL,
+      	"attempts" integer DEFAULT 0 NOT NULL,
+      	"maxAttempts" integer DEFAULT 5 NOT NULL,
+      	"lastAttemptAt" timestamp,
+      	"nextRetryAt" timestamp,
+      	"error" text,
+      	"createdAt" timestamp DEFAULT now() NOT NULL,
+      	"nonce" text NOT NULL,
+      	"_internalId" bigserial PRIMARY KEY NOT NULL,
+      	"_version" integer DEFAULT 0 NOT NULL
+      );
+
       CREATE TABLE "users" (
       	"id" varchar(30) NOT NULL,
       	"name" text NOT NULL,
@@ -231,6 +248,8 @@ describe("generateSchema and migrate", () => {
       ALTER TABLE "postTags" ADD CONSTRAINT "postTags_posts_post_fk" FOREIGN KEY ("postId") REFERENCES "public"."posts"("_internalId") ON DELETE no action ON UPDATE no action;
       ALTER TABLE "postTags" ADD CONSTRAINT "postTags_tags_tag_fk" FOREIGN KEY ("tagId") REFERENCES "public"."tags"("_internalId") ON DELETE no action ON UPDATE no action;
       CREATE UNIQUE INDEX "unique_key" ON "fragno_db_settings" USING btree ("key");
+      CREATE INDEX "idx_namespace_status_retry" ON "fragno_hooks" USING btree ("namespace","status","nextRetryAt");
+      CREATE INDEX "idx_nonce" ON "fragno_hooks" USING btree ("nonce");
       CREATE UNIQUE INDEX "idx_users_email" ON "users" USING btree ("email");
       CREATE INDEX "idx_users_name" ON "users" USING btree ("name");
       CREATE INDEX "idx_users_active" ON "users" USING btree ("isActive");

package/src/adapters/drizzle/shared.ts

@@ -22,40 +22,6 @@ export function parseDrizzle(drizzle: unknown) {
   return [db, drizzleTables] as const;
 }
 
-/**
- * Maps logical table names (used by fragment authors) to physical table names (with namespace suffix)
- */
-export interface TableNameMapper {
-  toPhysical(logicalName: string): string;
-  toLogical(physicalName: string): string;
-}
-
-/**
- * Sanitize a namespace to be a valid JavaScript identifier
- * Replaces hyphens and other invalid characters with underscores
- */
-export function sanitizeNamespace(namespace: string): string {
-  return namespace.replace(/[^a-zA-Z0-9_]/g, "_");
-}
-
-/**
- * Creates a table name mapper for a given namespace.
- * Physical names have format: {logicalName}_{sanitizedNamespace}
- * The namespace is sanitized to match TypeScript export names used in the schema
- */
-export function createTableNameMapper(namespace: string): TableNameMapper {
-  const sanitized = sanitizeNamespace(namespace);
-  return {
-    toPhysical: (logicalName: string) => `${logicalName}_${sanitized}`,
-    toLogical: (physicalName: string) => {
-      if (physicalName.endsWith(`_${sanitized}`)) {
-        return physicalName.slice(0, -(sanitized.length + 1));
-      }
-      return physicalName;
-    },
-  };
-}
-
 export interface DrizzleResult {
   rows: Record<string, unknown>[];
   affectedRows: number;

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

@@ -1,7 +1,8 @@
-import { mkdir, writeFile, rm } from "node:fs/promises";
+import { mkdir, writeFile, rm, access } from "node:fs/promises";
 import { join } from "node:path";
 import { generateSchema, type SupportedProvider } from "./generate";
 import type { Schema } from "../../schema/create";
+import { internalSchema } from "../../fragments/internal-fragment";
 
 /**
  * Writes a Fragno schema to a temporary TypeScript file and dynamically imports it.
@@ -34,20 +35,50 @@ export async function writeAndLoadSchema(
   // Generate unique schema file path
   const schemaFilePath = join(
     testDir,
-    `test-schema-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.ts`,
+    `test-schema-${testFileName}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.ts`,
   );
 
   // Generate and write the Drizzle schema to file
-  // Use empty namespace for tests to avoid table name prefixing
-  const drizzleSchemaTs = generateSchema([{ namespace: namespace ?? "", schema }], dialect);
+  // Always include settings schema first (as done in generation-engine.ts), then the test schema
+  // De-duplicate: if the test schema IS the settings schema, don't add it twice
+  const fragments: Array<{ namespace: string; schema: Schema }> = [
+    { namespace: "", schema: internalSchema },
+  ];
+
+  if (schema !== internalSchema) {
+    fragments.push({ namespace: namespace ?? "", schema });
+  }
+
+  const drizzleSchemaTs = generateSchema(fragments, dialect);
   await writeFile(schemaFilePath, drizzleSchemaTs, "utf-8");
 
+  // Ensure the file is accessible before importing (handle race conditions)
+  let retries = 0;
+  const maxRetries = 10;
+  while (retries < maxRetries) {
+    try {
+      await access(schemaFilePath);
+      break;
+    } catch {
+      if (retries === maxRetries - 1) {
+        throw new Error(`Schema file was not accessible after writing: ${schemaFilePath}`);
+      }
+      // Wait a bit before retrying
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      retries++;
+    }
+  }
+
   // Dynamically import the generated schema (with cache busting)
   const schemaModule = await import(`${schemaFilePath}?t=${Date.now()}`);
 
   // Cleanup function to remove the test-specific directory
   const cleanup = async () => {
-    await rm(testDir, { recursive: true, force: true });
+    try {
+      await rm(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore error if directory doesn't exist
+    }
   };
 
   return {

package/src/adapters/generic-sql/README.md

@@ -0,0 +1,14 @@
+# Generic SQL Adapter
+
+## Goals:
+
+- Follow roughly the Kysely interfaces so that we can use Kysely adapters.
+- Use this to replace ALL query execution logic.
+- "Own" the result transformation step.
+- Optionally able to create SQL migrations internally.
+- Be able to map names (tables, columns, constraints, etc)
+- Be able to run migrations directly from the Fragment
+
+## Non-goal:
+
+- Generate schemas in ORM-specific DSLs, this is left to the ORM adapters.

package/src/adapters/generic-sql/driver-config.ts

@@ -0,0 +1,144 @@
+export const supportedDatabases = ["sqlite", "postgresql", "mysql"] as const;
+export type SupportedDatabase = (typeof supportedDatabases)[number];
+
+export const supportedDriverTypes = [
+  "sqlocal",
+  "cloudflare_durable_objects",
+  "better-sqlite3",
+  "pg",
+  "pglite",
+  "mysql2",
+] as const;
+
+export type SupportedDriverType = (typeof supportedDriverTypes)[number];
+
+export abstract class DriverConfig<T extends SupportedDriverType = SupportedDriverType> {
+  abstract readonly driverType: T;
+  abstract readonly databaseType: SupportedDatabase;
+
+  abstract readonly supportsReturning: boolean;
+  abstract readonly supportsJson: boolean;
+
+  /**
+   * Column name for internal ID in RETURNING results.
+   * Only defined if supportsReturning is true.
+   */
+  abstract readonly internalIdColumn: string | undefined;
+
+  get supportsRowsAffected(): boolean {
+    return !!this.extractAffectedRows;
+  }
+
+  /**
+   * Extract the number of affected rows from a query result.
+   * Only implemented for drivers that support affected rows reporting.
+   *
+   * @param result - The query result from the SQL driver
+   * @returns The number of affected rows as bigint
+   * @throws Error if affected rows information is not found in the result
+   */
+  extractAffectedRows?(result: Record<string, unknown>): bigint;
+}
+
+export class SQLocalDriverConfig extends DriverConfig<"sqlocal"> {
+  override readonly driverType = "sqlocal";
+  override readonly databaseType = "sqlite";
+  override readonly supportsReturning = true;
+  override readonly supportsJson = false;
+  override readonly internalIdColumn = "_internalId";
+}
+
+export class CloudflareDurableObjectsDriverConfig extends DriverConfig<"cloudflare_durable_objects"> {
+  override readonly driverType = "cloudflare_durable_objects";
+  override readonly databaseType = "sqlite";
+  override readonly supportsReturning = true;
+  override readonly supportsJson = false;
+  override readonly internalIdColumn = "_internalId";
+}
+
+export class BetterSQLite3DriverConfig extends DriverConfig<"better-sqlite3"> {
+  override readonly driverType = "better-sqlite3";
+  override readonly databaseType = "sqlite";
+  override readonly supportsReturning = true;
+  override readonly supportsJson = false;
+  override readonly internalIdColumn = "_internalId";
+
+  override extractAffectedRows(result: Record<string, unknown>): bigint {
+    if ("numAffectedRows" in result) {
+      const value = result["numAffectedRows"];
+      if (typeof value === "bigint") {
+        return value;
+      }
+      if (typeof value === "number") {
+        return BigInt(value);
+      }
+    }
+
+    throw new Error(
+      `No affected rows found in result: ${JSON.stringify(result)}. Driver ${this.driverType} is expected to support affected rows.`,
+    );
+  }
+}
+
+export class NodePostgresDriverConfig extends DriverConfig<"pg"> {
+  override readonly driverType = "pg";
+  override readonly databaseType = "postgresql";
+  override readonly supportsReturning = true;
+  override readonly supportsJson = true;
+  override readonly internalIdColumn = "_internalId";
+
+  override extractAffectedRows(result: Record<string, unknown>): bigint {
+    if ("numAffectedRows" in result) {
+      const value = result["numAffectedRows"];
+      if (typeof value === "bigint") {
+        return value;
+      }
+      if (typeof value === "number") {
+        return BigInt(value);
+      }
+    }
+    if ("numChangedRows" in result) {
+      const value = result["numChangedRows"];
+      if (typeof value === "bigint") {
+        return value;
+      }
+      if (typeof value === "number") {
+        return BigInt(value);
+      }
+    }
+    throw new Error(
+      `No affected rows found in result: ${JSON.stringify(result)}. Driver ${this.driverType} is expected to support affected rows.`,
+    );
+  }
+}
+
+export class PGLiteDriverConfig extends DriverConfig<"pglite"> {
+  override readonly driverType = "pglite";
+  override readonly databaseType = "postgresql";
+  override readonly supportsReturning = true;
+  override readonly supportsJson = true;
+  override readonly internalIdColumn = "_internalId";
+
+  override extractAffectedRows(result: Record<string, unknown>): bigint {
+    if ("affectedRows" in result) {
+      const value = result["affectedRows"];
+      if (typeof value === "bigint") {
+        return value;
+      }
+      if (typeof value === "number") {
+        return BigInt(value);
+      }
+    }
+    throw new Error(
+      `No affected rows found in result: ${JSON.stringify(result)}. Driver ${this.driverType} is expected to support affected rows.`,
+    );
+  }
+}
+
+export class MySQL2DriverConfig extends DriverConfig<"mysql2"> {
+  override readonly driverType = "mysql2";
+  override readonly databaseType = "mysql";
+  override readonly supportsReturning = false;
+  override readonly supportsJson = true;
+  override readonly internalIdColumn = undefined;
+}