@fragno-dev/db 0.2.2 → 0.4.1

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

@@ -1,3 +1,9 @@
+import {
+  schemaNamingStrategy,
+  suffixNamingStrategy,
+  type SqlNamingStrategy,
+} from "../../naming/sql-naming";
+
 export const supportedDatabases = ["sqlite", "postgresql", "mysql"] as const;
 export type SupportedDatabase = (typeof supportedDatabases)[number];
 
@@ -18,6 +24,7 @@ export abstract class DriverConfig<T extends SupportedDriverType = SupportedDriv
 
   abstract readonly supportsReturning: boolean;
   abstract readonly supportsJson: boolean;
+  abstract readonly outboxVersionstampStrategy: OutboxVersionstampStrategy;
 
   /**
    * Column name for internal ID in RETURNING results.
@@ -25,10 +32,17 @@ export abstract class DriverConfig<T extends SupportedDriverType = SupportedDriv
    */
   abstract readonly internalIdColumn: string | undefined;
 
+  /**
+   * SQLite storage selection is handled by adapters, not driver config.
+   */
   get supportsRowsAffected(): boolean {
     return !!this.extractAffectedRows;
   }
 
+  get defaultNamingStrategy(): SqlNamingStrategy {
+    return defaultNamingStrategyForDatabase(this.databaseType);
+  }
+
   /**
    * Extract the number of affected rows from a query result.
    * Only implemented for drivers that support affected rows reporting.
@@ -40,12 +54,31 @@ export abstract class DriverConfig<T extends SupportedDriverType = SupportedDriv
   extractAffectedRows?(result: Record<string, unknown>): bigint;
 }
 
+export const defaultNamingStrategyForDatabase = (
+  databaseType: SupportedDatabase,
+): SqlNamingStrategy => {
+  switch (databaseType) {
+    case "postgresql":
+      return schemaNamingStrategy;
+    case "sqlite":
+    case "mysql":
+    default:
+      return suffixNamingStrategy;
+  }
+};
+
+export type OutboxVersionstampStrategy =
+  | "update-returning"
+  | "insert-on-conflict-returning"
+  | "insert-on-duplicate-last-insert-id";
+
 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";
+  override readonly outboxVersionstampStrategy = "insert-on-conflict-returning";
 }
 
 export class CloudflareDurableObjectsDriverConfig extends DriverConfig<"cloudflare_durable_objects"> {
@@ -54,6 +87,7 @@ export class CloudflareDurableObjectsDriverConfig extends DriverConfig<"cloudfla
   override readonly supportsReturning = true;
   override readonly supportsJson = false;
   override readonly internalIdColumn = "_internalId";
+  override readonly outboxVersionstampStrategy = "insert-on-conflict-returning";
 }
 
 export class BetterSQLite3DriverConfig extends DriverConfig<"better-sqlite3"> {
@@ -62,6 +96,7 @@ export class BetterSQLite3DriverConfig extends DriverConfig<"better-sqlite3"> {
   override readonly supportsReturning = true;
   override readonly supportsJson = false;
   override readonly internalIdColumn = "_internalId";
+  override readonly outboxVersionstampStrategy = "insert-on-conflict-returning";
 
   override extractAffectedRows(result: Record<string, unknown>): bigint {
     if ("numAffectedRows" in result) {
@@ -86,6 +121,7 @@ export class NodePostgresDriverConfig extends DriverConfig<"pg"> {
   override readonly supportsReturning = true;
   override readonly supportsJson = true;
   override readonly internalIdColumn = "_internalId";
+  override readonly outboxVersionstampStrategy = "insert-on-conflict-returning";
 
   override extractAffectedRows(result: Record<string, unknown>): bigint {
     if ("numAffectedRows" in result) {
@@ -118,6 +154,7 @@ export class PGLiteDriverConfig extends DriverConfig<"pglite"> {
   override readonly supportsReturning = true;
   override readonly supportsJson = true;
   override readonly internalIdColumn = "_internalId";
+  override readonly outboxVersionstampStrategy = "insert-on-conflict-returning";
 
   override extractAffectedRows(result: Record<string, unknown>): bigint {
     if ("affectedRows" in result) {
@@ -141,4 +178,5 @@ export class MySQL2DriverConfig extends DriverConfig<"mysql2"> {
   override readonly supportsReturning = false;
   override readonly supportsJson = true;
   override readonly internalIdColumn = undefined;
+  override readonly outboxVersionstampStrategy = "insert-on-duplicate-last-insert-id";
 }

package/src/adapters/generic-sql/generic-sql-adapter.test.ts

@@ -1,12 +1,14 @@
-import { SQLocalKysely } from "sqlocal/kysely";
 import { assert, describe, expect, it } from "vitest";
-import { SQLocalDriverConfig } from "./driver-config";
-import { GenericSQLAdapter } from "./generic-sql-adapter";
-import { column, idColumn, schema } from "../../schema/create";
+
+import { SQLocalKysely } from "sqlocal/kysely";
+
 import { internalSchema } from "../../fragments/internal-fragment";
+import { column, idColumn, schema } from "../../schema/create";
+import { SQLocalDriverConfig } from "./driver-config";
+import { SqlAdapter } from "./generic-sql-adapter";
 
-describe("GenericSQLAdapter", () => {
-  const testSchema = schema((s) => {
+describe("SqlAdapter", () => {
+  const testSchema = schema("test", (s) => {
     return s.addTable("products", (t) => {
       return t
         .addColumn("id", idColumn())
@@ -16,11 +18,11 @@ describe("GenericSQLAdapter", () => {
     });
   });
 
-  it("Should be able to query using GenericSQLAdapter", async () => {
+  it("Should be able to query using SqlAdapter", async () => {
     const { dialect } = new SQLocalKysely(":memory:");
     const driverConfig = new SQLocalDriverConfig();
 
-    const adapter = new GenericSQLAdapter({ dialect, driverConfig });
+    const adapter = new SqlAdapter({ dialect, driverConfig });
 
     // Create settings table first (needed for version tracking)
     const settingsMigrations = adapter.prepareMigrations(internalSchema, "");

package/src/adapters/generic-sql/generic-sql-adapter.ts

@@ -1,55 +1,105 @@
 import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
+
+import { getOutboxConfigForAdapter } from "../../internal/outbox-state";
+import {
+  createNamingResolver,
+  type NamingResolver,
+  type SqlNamingStrategy,
+} from "../../naming/sql-naming";
+import { createSQLSerializer } from "../../query/serialize/create-sql-serializer";
+import type { SimpleQueryInterface } from "../../query/simple-query-interface";
+import type { UOWInstrumentation } from "../../query/unit-of-work/unit-of-work";
+import type { AnyColumn, AnySchema } from "../../schema/create";
+import { sql } from "../../sql-driver/sql";
+import type { CompiledQuery, Dialect, QueryResult } from "../../sql-driver/sql-driver";
+import { SqlDriverAdapter } from "../../sql-driver/sql-driver-adapter";
 import {
   fragnoDatabaseAdapterNameFakeSymbol,
   fragnoDatabaseAdapterVersionFakeSymbol,
   type DatabaseAdapter,
   type DatabaseContextStorage,
-  type TableNameMapper,
+  type DatabaseAdapterMetadata,
+  type SQLiteProfile,
 } from "../adapters";
-import type { CompiledQuery, Dialect, QueryResult } from "../../sql-driver/sql-driver";
-import { SqlDriverAdapter } from "../../sql-driver/sql-driver-adapter";
-import { sql } from "../../sql-driver/sql";
-import type { AnySchema } from "../../schema/create";
-import { createTableNameMapper } from "../shared/table-name-mapper";
-import type { SimpleQueryInterface } from "../../query/simple-query-interface";
-import { createExecutor } from "./generic-sql-uow-executor";
-import { UnitOfWorkDecoder } from "./uow-decoder";
-import { createPreparedMigrations, type PreparedMigrations } from "./migration/prepared-migrations";
-import type { DriverConfig } from "./driver-config";
-import { GenericSQLUOWOperationCompiler } from "./query/generic-sql-uow-operation-compiler";
-import { createUOWCompilerFromOperationCompiler } from "../shared/uow-operation-compiler";
 import {
   fromUnitOfWorkCompiler,
   type UnitOfWorkFactory,
 } from "../shared/from-unit-of-work-compiler";
+import { createUOWCompilerFromOperationCompiler } from "../shared/uow-operation-compiler";
+import type { DriverConfig } from "./driver-config";
+import { createExecutor } from "./generic-sql-uow-executor";
+import { createPreparedMigrations, type PreparedMigrations } from "./migration/prepared-migrations";
+import { GenericSQLUOWOperationCompiler } from "./query/generic-sql-uow-operation-compiler";
+import type { SQLiteStorageMode } from "./sqlite-storage";
+import { sqliteStorageDefault, sqliteStoragePrisma } from "./sqlite-storage";
+import { UnitOfWorkDecoder } from "./uow-decoder";
 
 export interface UnitOfWorkConfig {
   onQuery?: (query: CompiledQuery) => void;
   dryRun?: boolean;
+  instrumentation?: UOWInstrumentation;
 }
 
-export interface GenericSQLOptions {
+export interface SqlAdapterOptions {
   dialect: Dialect;
   driverConfig: DriverConfig;
   uowConfig?: UnitOfWorkConfig;
+  sqliteProfile?: SQLiteProfile;
+  sqliteStorageMode?: SQLiteStorageMode;
+  namingStrategy?: SqlNamingStrategy;
 }
 
-export class GenericSQLAdapter implements DatabaseAdapter<UnitOfWorkConfig> {
+export const sqliteProfiles: Record<SQLiteProfile, SQLiteStorageMode> = {
+  default: sqliteStorageDefault,
+  prisma: sqliteStoragePrisma,
+};
+
+export class SqlAdapter implements DatabaseAdapter<UnitOfWorkConfig> {
   readonly dialect: Dialect;
   readonly driverConfig: DriverConfig;
   readonly uowConfig?: UnitOfWorkConfig;
+  readonly sqliteStorageMode?: SQLiteStorageMode;
+  readonly sqliteProfile?: SQLiteProfile;
+  readonly adapterMetadata: DatabaseAdapterMetadata;
+  readonly namingStrategy: SqlNamingStrategy;
 
-  #schemaNamespaceMap = new WeakMap<AnySchema, string>();
+  #schemaNamespaceMap = new WeakMap<AnySchema, string | null>();
   #contextStorage: RequestContextStorage<DatabaseContextStorage>;
 
   #driver: SqlDriverAdapter;
 
-  constructor({ dialect, driverConfig, uowConfig }: GenericSQLOptions) {
+  constructor({
+    dialect,
+    driverConfig,
+    uowConfig,
+    sqliteProfile,
+    sqliteStorageMode,
+    namingStrategy,
+  }: SqlAdapterOptions) {
     this.dialect = dialect;
     this.driverConfig = driverConfig;
     this.uowConfig = uowConfig;
+    this.namingStrategy = namingStrategy ?? driverConfig.defaultNamingStrategy;
+    const resolvedProfile = sqliteProfile ?? "default";
 
-    this.#schemaNamespaceMap = new WeakMap<AnySchema, string>();
+    if (sqliteStorageMode && sqliteProfile) {
+      throw new Error("sqliteStorageMode cannot be used together with sqliteProfile.");
+    }
+
+    this.sqliteStorageMode =
+      driverConfig.databaseType === "sqlite"
+        ? (sqliteStorageMode ?? sqliteProfiles[resolvedProfile])
+        : undefined;
+    this.sqliteProfile =
+      driverConfig.databaseType === "sqlite" && !sqliteStorageMode ? resolvedProfile : undefined;
+
+    this.adapterMetadata = {
+      databaseType: driverConfig.databaseType,
+      sqliteProfile: this.sqliteProfile,
+      sqliteStorageMode: this.sqliteStorageMode,
+    };
+
+    this.#schemaNamespaceMap = new WeakMap<AnySchema, string | null>();
     this.#contextStorage = new RequestContextStorage();
 
     this.#driver = new SqlDriverAdapter(dialect);
@@ -60,11 +110,11 @@ export class GenericSQLAdapter implements DatabaseAdapter<UnitOfWorkConfig> {
   }
 
   get [fragnoDatabaseAdapterNameFakeSymbol](): string {
-    return "generic-sql";
+    return "sql";
   }
 
   get [fragnoDatabaseAdapterVersionFakeSymbol](): number {
-    return 0;
+    return 1;
   }
 
   get contextStorage(): RequestContextStorage<DatabaseContextStorage> {
@@ -77,23 +127,23 @@ export class GenericSQLAdapter implements DatabaseAdapter<UnitOfWorkConfig> {
 
   async isConnectionHealthy(): Promise<boolean> {
     const result = await this.#driver.executeQuery(sql`SELECT 1 as healthy`.compile(this.dialect));
-    return result.rows[0]["healthy"] === 1;
+    const healthyValue = result.rows[0]?.["healthy"];
+    return healthyValue === 1 || healthyValue === 1n || healthyValue === "1";
   }
 
-  prepareMigrations<T extends AnySchema>(schema: T, namespace: string): PreparedMigrations {
+  prepareMigrations<T extends AnySchema>(schema: T, namespace: string | null): PreparedMigrations {
+    const resolver = createNamingResolver(schema, namespace, this.namingStrategy);
     return createPreparedMigrations({
       schema,
-      namespace,
+      namespace: namespace ?? schema.name,
       database: this.driverConfig.databaseType,
-      mapper: namespace ? this.createTableNameMapper(namespace) : undefined,
+      driverConfig: this.driverConfig,
+      sqliteStorageMode: this.sqliteStorageMode,
+      resolver,
       driver: this.#driver,
     });
   }
 
-  createTableNameMapper(namespace: string): TableNameMapper {
-    return createTableNameMapper(namespace, false);
-  }
-
   async getSchemaVersion(namespace: string): Promise<string | undefined> {
     const key = `${namespace}.schema_version`;
     const query = sql`SELECT value FROM fragno_db_settings WHERE key = ${key};`.compile(
@@ -125,22 +175,55 @@ export class GenericSQLAdapter implements DatabaseAdapter<UnitOfWorkConfig> {
 
   createQueryEngine<T extends AnySchema>(
     schema: T,
-    namespace: string,
+    namespace: string | null,
   ): SimpleQueryInterface<T, UnitOfWorkConfig> {
     this.#schemaNamespaceMap.set(schema, namespace);
+    const resolver = createNamingResolver(schema, namespace, this.namingStrategy);
 
-    const operationCompiler = new GenericSQLUOWOperationCompiler(this.driverConfig, (ns) =>
-      ns ? this.createTableNameMapper(ns) : undefined,
+    const operationCompiler = new GenericSQLUOWOperationCompiler(
+      this.driverConfig,
+      this.sqliteStorageMode,
+      (schemaForResolver, namespaceForResolver): NamingResolver =>
+        createNamingResolver(schemaForResolver, namespaceForResolver, this.namingStrategy),
     );
 
     const factory: UnitOfWorkFactory = {
       compiler: createUOWCompilerFromOperationCompiler(operationCompiler),
-      executor: createExecutor(this.#driver, this.driverConfig, false),
-      decoder: new UnitOfWorkDecoder(this.driverConfig),
+      executor: createExecutor(this.#driver, this.driverConfig, {
+        dialect: this.dialect,
+        dryRun: false,
+        outbox: getOutboxConfigForAdapter(this),
+        namingStrategy: this.namingStrategy,
+      }),
+      decoder: new UnitOfWorkDecoder(this.driverConfig, this.sqliteStorageMode, resolver),
       uowConfig: this.uowConfig,
       schemaNamespaceMap: this.#schemaNamespaceMap,
     };
 
-    return fromUnitOfWorkCompiler(schema, factory);
+    const queryEngine = fromUnitOfWorkCompiler(schema, factory) as SimpleQueryInterface<
+      T,
+      UnitOfWorkConfig
+    >;
+
+    const serializer = createSQLSerializer(this.driverConfig, this.sqliteStorageMode);
+    const timestampColumn = { type: "timestamp" } as AnyColumn;
+
+    return {
+      ...queryEngine,
+      now: async () => {
+        const result = await this.#driver.executeQuery(
+          sql`SELECT CURRENT_TIMESTAMP as now`.compile(this.dialect),
+        );
+        const rawValue = result.rows[0]?.["now"];
+        if (rawValue === undefined || rawValue === null) {
+          throw new Error("Failed to fetch database time");
+        }
+        return serializer.deserialize(rawValue, timestampColumn) as Date;
+      },
+    };
   }
 }
+
+export type { SQLiteStorageMode } from "./sqlite-storage";
+export { sqliteStorageDefault, sqliteStoragePrisma } from "./sqlite-storage";
+export type { OutboxConfig } from "../../outbox/outbox";

package/src/adapters/generic-sql/generic-sql-uow-executor.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+
+import type { CompiledMutation } from "../../query/unit-of-work/unit-of-work";
+import type { CompiledQuery, Dialect } from "../../sql-driver/sql-driver";
+import type { SqlDriverAdapter } from "../../sql-driver/sql-driver-adapter";
+import { NodePostgresDriverConfig } from "./driver-config";
+import { executeMutation } from "./generic-sql-uow-executor";
+
+const createError = (code: string) => {
+  const error = new Error(`DB_ERROR_${code}`);
+  (error as { code?: string }).code = code;
+  return error;
+};
+
+const createAdapterThatThrows = (error: Error) =>
+  ({
+    transaction: async (
+      callback: (trx: { executeQuery: () => Promise<unknown> }) => Promise<unknown>,
+    ) =>
+      await callback({
+        executeQuery: async () => {
+          throw error;
+        },
+      }),
+  }) as unknown as SqlDriverAdapter;
+
+describe("executeMutation", () => {
+  const dialect = {
+    createAdapter: () => ({}) as Dialect["createAdapter"] extends () => infer T ? T : never,
+    createDriver: () => ({}) as Dialect["createDriver"] extends () => infer T ? T : never,
+    createQueryCompiler: () =>
+      ({}) as Dialect["createQueryCompiler"] extends () => infer T ? T : never,
+  } satisfies Dialect;
+  const compiledQuery: CompiledQuery = {
+    sql: "SELECT 1",
+    parameters: [],
+  };
+
+  const mutationBatch: CompiledMutation<CompiledQuery>[] = [
+    {
+      op: "update",
+      query: compiledQuery,
+      expectedAffectedRows: null,
+      expectedReturnedRows: null,
+    },
+  ];
+
+  it.each(["40001", "40P01"])("returns success=false on SQLSTATE %s", async (code) => {
+    const adapter = createAdapterThatThrows(createError(code));
+    const result = await executeMutation(adapter, new NodePostgresDriverConfig(), mutationBatch, {
+      dialect,
+    });
+    expect(result.success).toBe(false);
+  });
+});