@fragno-dev/db 0.1.15 → 0.2.0

package/src/adapters/drizzle/{drizzle-adapter-sqlite.test.ts → drizzle-adapter-sqlite3.test.ts}

@@ -1,19 +1,13 @@
-import { drizzle } from "drizzle-orm/libsql";
-import { createClient } from "@libsql/client";
+import SQLite from "better-sqlite3";
+import { SqliteDialect } from "kysely";
 import { DrizzleAdapter } from "./drizzle-adapter";
 import { beforeAll, describe, expect, expectTypeOf, it, assert } from "vitest";
 import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
-import type { DBType } from "./shared";
-import { createRequire } from "node:module";
-import { writeAndLoadSchema } from "./test-utils";
 import { Cursor } from "../../query/cursor";
-import { executeUnitOfWork } from "../../query/execute-unit-of-work";
-import { ExponentialBackoffRetryPolicy } from "../../query/retry-policy";
-
-// Import drizzle-kit for migrations
-const require = createRequire(import.meta.url);
-const { generateSQLiteDrizzleJson, generateSQLiteMigration } =
-  require("drizzle-kit/api") as typeof import("drizzle-kit/api");
+import { executeUnitOfWork } from "../../query/unit-of-work/execute-unit-of-work";
+import { ExponentialBackoffRetryPolicy } from "../../query/unit-of-work/retry-policy";
+import { BetterSQLite3DriverConfig } from "../generic-sql/driver-config";
+import { internalSchema } from "../../fragments/internal-fragment";
 
 describe("DrizzleAdapter SQLite", () => {
   const testSchema = schema((s) => {
@@ -98,56 +92,38 @@ describe("DrizzleAdapter SQLite", () => {
   });
 
   let adapter: DrizzleAdapter;
-  let db: DBType;
-  // let sqliteDb: Database.Database;
+  let sqliteDatabase: InstanceType<typeof SQLite>;
 
   beforeAll(async () => {
-    // Write schema to file and dynamically import it
-    const { schemaModule, cleanup } = await writeAndLoadSchema(
-      "drizzle-adapter-sqlite",
-      testSchema,
-      "sqlite",
-      "namespace",
-    );
-
-    // Write second schema to file and dynamically import it
-    const { schemaModule: schemaModule2, cleanup: cleanup2 } = await writeAndLoadSchema(
-      "drizzle-adapter-sqlite-schema2",
-      schema2,
-      "sqlite",
-      "namespace2",
-    );
+    sqliteDatabase = new SQLite(":memory:");
 
-    const client = createClient({
-      url: "file::memory:?cache=shared",
+    const dialect = new SqliteDialect({
+      database: sqliteDatabase,
     });
 
-    // Merge both schema modules for the db
-    const mergedSchema = { ...schemaModule, ...schemaModule2 };
-
-    db = drizzle(client, {
-      schema: mergedSchema,
-    }) as unknown as DBType;
-
-    // Generate and run migrations for both schemas
-    const emptyJson = await generateSQLiteDrizzleJson({});
-    const targetJson = await generateSQLiteDrizzleJson(mergedSchema);
+    adapter = new DrizzleAdapter({
+      dialect,
+      driverConfig: new BetterSQLite3DriverConfig(),
+    });
 
-    const migrationStatements = await generateSQLiteMigration(emptyJson, targetJson);
+    // Create settings table first (needed for version tracking)
+    {
+      const migrations = adapter.prepareMigrations(internalSchema, "");
+      await migrations.executeWithDriver(adapter.driver, 0);
+    }
 
-    for (const statement of migrationStatements) {
-      await client.execute(statement);
+    {
+      const migrations = adapter.prepareMigrations(testSchema, "namespace");
+      await migrations.executeWithDriver(adapter.driver, 0);
     }
 
-    adapter = new DrizzleAdapter({
-      db,
-      provider: "sqlite",
-    });
+    {
+      const migrations = adapter.prepareMigrations(schema2, "namespace2");
+      await migrations.executeWithDriver(adapter.driver, 0);
+    }
 
     return async () => {
-      client.close();
-      await cleanup();
-      await cleanup2();
+      await adapter.close();
     };
   }, 12000);
 
@@ -383,17 +359,17 @@ describe("DrizzleAdapter SQLite", () => {
     expect(email).toMatchObject({
       id: expect.objectContaining({
         externalId: expect.stringMatching(/^[a-z0-9]{20,}$/),
-        internalId: expect.any(Number),
+        internalId: expect.any(BigInt),
       }),
       user_id: expect.objectContaining({
-        internalId: expect.any(Number),
+        internalId: expect.any(BigInt),
       }),
       email: "test@example.com",
       is_primary: true,
       user: {
         id: expect.objectContaining({
           externalId: expect.stringMatching(/^[a-z0-9]{20,}$/),
-          internalId: expect.any(Number),
+          internalId: expect.any(BigInt),
         }),
         name: "Email User",
         age: 20,
@@ -476,7 +452,7 @@ describe("DrizzleAdapter SQLite", () => {
     expect(comment).toMatchObject({
       id: expect.objectContaining({
         externalId: expect.stringMatching(/^[a-z0-9]{20,}$/),
-        internalId: expect.any(Number),
+        internalId: expect.any(BigInt),
       }),
       text: "Great post!",
       // Post join (first level)

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

@@ -1,116 +1,22 @@
-import type { DatabaseAdapter, DatabaseContextStorage } from "../adapters";
+import type { DatabaseAdapter } 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 { 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>);
-  provider: "sqlite" | "mysql" | "postgresql";
-}
-
-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 {
-    return "drizzle";
-  }
-
-  get [fragnoDatabaseAdapterVersionFakeSymbol](): number {
-    return 0;
-  }
-
-  get contextStorage(): RequestContextStorage<DatabaseContextStorage> {
-    return this.#contextStorage;
-  }
+import { createTableNameMapper } from "../shared/table-name-mapper";
 
-  async close(): Promise<void> {
-    await this.#connectionPool.close();
-  }
-
-  createTableNameMapper(namespace: string) {
-    return createTableNameMapper(namespace);
-  }
-
-  get provider(): "sqlite" | "mysql" | "postgresql" {
-    return this.#provider;
-  }
-
-  async isConnectionHealthy(): Promise<boolean> {
-    const conn = await this.#connectionPool.connect();
-    try {
-      const result = await conn.db.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;
-    } finally {
-      await conn.release();
-    }
-  }
-
-  async getSchemaVersion(namespace: string): Promise<string | undefined> {
-    // 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, "");
+import {
+  GenericSQLAdapter,
+  type GenericSQLOptions,
+  type UnitOfWorkConfig,
+} from "../generic-sql/generic-sql-adapter";
 
-    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;
+export class DrizzleAdapter extends GenericSQLAdapter implements DatabaseAdapter<UnitOfWorkConfig> {
+  constructor(options: GenericSQLOptions) {
+    super(options);
   }
 
-  createQueryEngine<TSchema extends AnySchema>(
-    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,
-      undefined,
-      this.#schemaNamespaceMap,
-    );
+  override createTableNameMapper(namespace: string) {
+    return createTableNameMapper(namespace, false);
   }
 
   createSchemaGenerator(
@@ -122,7 +28,9 @@ export class DrizzleAdapter implements DatabaseAdapter<DrizzleUOWConfig> {
         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) : undefined),
+          }),
           path,
         };
       },

package/src/adapters/drizzle/generate.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
 import { column, idColumn, referenceColumn, schema } from "../../schema/create";
 import { generateSchema } from "./generate";
-import { settingsSchema } from "../../fragments/internal-fragment";
+import { internalSchema } from "../../fragments/internal-fragment";
 
 describe("generateSchema", () => {
   const testSchema = schema((s) => {
@@ -1072,7 +1072,7 @@ describe("generateSchema", () => {
       // This test verifies generateSchema works correctly with already-deduplicated inputs
       const generated = generateSchema(
         [
-          { namespace: "", schema: settingsSchema }, // Internal fragment (namespace: "")
+          { namespace: "", schema: internalSchema }, // Internal fragment (namespace: "")
           { namespace: "fragment1", schema: fragment1Schema },
           { namespace: "fragment2", schema: fragment2Schema },
         ],

package/src/adapters/drizzle/generate.ts

@@ -8,8 +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 {
+  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
@@ -98,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)`,
   });
@@ -124,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);
@@ -143,7 +150,7 @@ function getColumnTypeFunction(
  */
 function mapDBTypeToDrizzleFunction(
   ctx: GeneratorContext,
-  dbType: DBTypeLiteral,
+  dbType: DatabaseTypeLiteral,
   column: AnyColumn,
   customTypes: string[],
 ): ColumnTypeFunction {
@@ -231,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
 // ============================================================================
@@ -318,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)) {
@@ -341,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;
@@ -391,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),
+  ];
 }
 
 // ============================================================================
@@ -404,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}`];
 
@@ -437,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;
@@ -458,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;
@@ -496,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;
@@ -526,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")}
 }));`;
 }
@@ -549,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}`);
     }
@@ -573,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}`);
       }
@@ -587,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}`;
@@ -604,6 +639,8 @@ 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;
 }
 
 /**
@@ -620,9 +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));
 
   for (const { schema, namespace } of fragments) {
     const fragmentTables: string[] = [];
+    const mapper = getMapper(namespace);
 
     // Add section header
     fragmentTables.push("");
@@ -636,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);
     }
@@ -663,6 +704,7 @@ export function generateSchema(
         table,
         namespace,
         inverseRelations.get(table.name),
+        mapper,
       );
       if (relationCode) {
         fragmentTables.push("");
@@ -674,7 +716,9 @@ export function generateSchema(
     // Generate schema export object (skip for empty namespace to avoid duplicate _schema exports)
     if (namespace !== "") {
       fragmentTables.push("");
-      fragmentTables.push(generateFragmentSchemaExport(schema, namespace, tablesWithRelations));
+      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;