@fragno-dev/db 0.2.1 → 0.3.0

package/src/adapters/shared/from-unit-of-work-compiler.ts

@@ -5,6 +5,7 @@ import type {
   UOWCompiler,
   UOWDecoder,
   UOWExecutor,
+  UOWInstrumentation,
   ValidIndexName,
 } from "../../query/unit-of-work/unit-of-work";
 import { UnitOfWork } from "../../query/unit-of-work/unit-of-work";
@@ -25,6 +26,7 @@ export interface UnitOfWorkConfig {
    * since those have to be manually executed.
    */
   dryRun?: boolean;
+  instrumentation?: UOWInstrumentation;
 }
 
 /**
@@ -50,7 +52,7 @@ export interface UnitOfWorkFactory {
   /**
    * Optional WeakMap for schema-to-namespace lookups
    */
-  schemaNamespaceMap?: WeakMap<AnySchema, string>;
+  schemaNamespaceMap?: WeakMap<AnySchema, string | null>;
 }
 
 /**

package/src/adapters/shared/uow-operation-compiler.ts

@@ -8,7 +8,7 @@ import type {
 } from "../../query/unit-of-work/unit-of-work";
 import { Cursor } from "../../query/cursor";
 import type { DriverConfig } from "../generic-sql/driver-config";
-import { createTableNameMapper, type TableNameMapper } from "./table-name-mapper";
+import { createNamingResolver, type NamingResolver } from "../../naming/sql-naming";
 
 /**
  * Options for compiling a find operation with cursor pagination
@@ -55,24 +55,24 @@ export interface CursorConditionResult {
  */
 export abstract class UOWOperationCompiler<TCompiledQuery> {
   #driverConfig: DriverConfig;
-  #mapperFactory?: (namespace: string | undefined) => TableNameMapper | undefined;
+  #resolverFactory?: (schema: AnySchema, namespace: string | null) => NamingResolver;
 
   constructor(
     driverConfig: DriverConfig,
-    mapperFactory?: (namespace: string | undefined) => TableNameMapper | undefined,
+    resolverFactory?: (schema: AnySchema, namespace: string | null) => NamingResolver,
   ) {
     this.#driverConfig = driverConfig;
-    this.#mapperFactory = mapperFactory;
+    this.#resolverFactory = resolverFactory;
   }
 
   protected get driverConfig(): DriverConfig {
     return this.#driverConfig;
   }
 
-  protected get mapperFactory():
-    | ((namespace: string | undefined) => TableNameMapper | undefined)
+  protected get resolverFactory():
+    | ((schema: AnySchema, namespace: string | null) => NamingResolver)
     | undefined {
-    return this.#mapperFactory;
+    return this.#resolverFactory;
   }
 
   abstract compileCount(
@@ -105,12 +105,18 @@ export abstract class UOWOperationCompiler<TCompiledQuery> {
   /**
    * Get the mapper for a specific operation based on its namespace
    */
-  protected getMapperForOperation(namespace: string | undefined): TableNameMapper | undefined {
-    return this.#mapperFactory
-      ? this.#mapperFactory(namespace)
-      : namespace
-        ? createTableNameMapper(namespace)
-        : undefined;
+  protected getNamingResolver(
+    schema: AnySchema,
+    namespace: string | null | undefined,
+  ): NamingResolver {
+    if (this.#resolverFactory) {
+      return this.#resolverFactory(schema, namespace ?? null);
+    }
+    return createNamingResolver(
+      schema,
+      namespace ?? null,
+      this.#driverConfig.defaultNamingStrategy,
+    );
   }
 
   /**
@@ -154,9 +160,13 @@ export abstract class UOWOperationCompiler<TCompiledQuery> {
   /**
    * Get the physical table name for an operation, applying namespace mapping if needed
    */
-  protected getPhysicalTableName(logicalName: string, namespace: string | undefined): string {
-    const mapper = this.getMapperForOperation(namespace);
-    return mapper ? mapper.toPhysical(logicalName) : logicalName;
+  protected getPhysicalTableName(
+    schema: AnySchema,
+    logicalName: string,
+    namespace: string | undefined,
+  ): string {
+    const resolver = this.getNamingResolver(schema, namespace ?? null);
+    return resolver.getTableName(logicalName);
   }
 }
 

package/src/adapters/sql/index.ts

@@ -0,0 +1,12 @@
+export {
+  SqlAdapter,
+  type SqlAdapterOptions,
+  type UnitOfWorkConfig,
+  type OutboxConfig,
+  sqliteProfiles,
+  sqliteStorageDefault,
+  sqliteStoragePrisma,
+  type SQLiteStorageMode,
+} from "../generic-sql/generic-sql-adapter";
+
+export type { SQLiteProfile } from "../adapters";

package/src/db-fragment-definition-builder.test.ts

@@ -1,3 +1,6 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { describe, it, expect, vi, expectTypeOf } from "vitest";
 import { defineFragment } from "@fragno-dev/core";
 import {
@@ -8,9 +11,12 @@ import { withDatabase } from "./with-database";
 import { schema, column, idColumn } from "./schema/create";
 import type { SimpleQueryInterface } from "./query/simple-query-interface";
 import type { DatabaseAdapter } from "./adapters/adapters";
+import * as executeUnitOfWork from "./query/unit-of-work/execute-unit-of-work";
+import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
+import { suffixNamingStrategy } from "./naming/sql-naming";
 
 // Create a test schema
-const testSchema = schema((s) => {
+const testSchema = schema("test", (s) => {
   return s.addTable("users", (t) => {
     return t
       .addColumn("id", idColumn())
@@ -28,13 +34,17 @@ function createMockAdapter(): DatabaseAdapter {
       forSchema: vi.fn(),
       executeRetrieve: vi.fn(),
       executeMutations: vi.fn(),
+      registerSchema: vi.fn(),
+      reset: vi.fn(),
     })),
   } as unknown as SimpleQueryInterface<TestSchema>;
 
   return {
     createQueryEngine: vi.fn(() => mockdb),
-    migrate: vi.fn(),
+    getSchemaVersion: vi.fn(async () => undefined),
     close: vi.fn(),
+    contextStorage: new RequestContextStorage(),
+    namingStrategy: suffixNamingStrategy,
   } as unknown as DatabaseAdapter;
 }
 
@@ -697,7 +707,7 @@ describe("DatabaseFragmentDefinitionBuilder", () => {
       expect(storage.uow).toBeDefined();
     });
 
-    it("should provide DatabaseServiceContext with forSchema and DatabaseHandlerContext with executeRestrictedUnitOfWork", () => {
+    it("should provide DatabaseServiceContext with serviceTx and DatabaseHandlerContext with handlerTx", () => {
       const mockAdapter = createMockAdapter();
 
       const definition = withDatabase(testSchema)(defineFragment("db-frag")).build();
@@ -716,8 +726,8 @@ describe("DatabaseFragmentDefinitionBuilder", () => {
         storage: mockStorage,
       });
 
-      expect(typeof contexts.serviceContext.uow).toBe("function");
-      expect(typeof contexts.handlerContext.uow).toBe("function");
+      expect(typeof contexts.serviceContext.serviceTx).toBe("function");
+      expect(typeof contexts.handlerContext.handlerTx).toBe("function");
     });
   });
 
@@ -734,10 +744,7 @@ describe("DatabaseFragmentDefinitionBuilder", () => {
 
       const mockAdapter = createMockAdapter();
 
-      const definition = withDatabase(
-        testSchema,
-        "my-namespace",
-      )(defineFragment<Config>("complex-db-frag"))
+      const definition = withDatabase(testSchema)(defineFragment<Config>("complex-db-frag"))
         .withDependencies(({ config }) => ({
           connectionString: config.dbConnectionString,
           debug: config.debug,
@@ -805,17 +812,29 @@ describe("DatabaseFragmentDefinitionBuilder", () => {
     });
   });
 
-  describe("error handling", () => {
-    it("should throw error if database adapter is missing", () => {
+  describe("default adapter", () => {
+    it("should default to sqlite adapter when database adapter is missing", () => {
+      const previous = process.env["FRAGNO_DATA_DIR"];
+      const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "fragno-db-default-"));
+      process.env["FRAGNO_DATA_DIR"] = dataDir;
+
       const definition = withDatabase(testSchema)(defineFragment("db-frag")).build();
 
-      expect(() => {
-        definition.dependencies!({
+      try {
+        const deps = definition.dependencies!({
           config: {},
-          // @ts-expect-error No databaseAdapter - intentionally invalid for runtime error test
           options: {},
         });
-      }).toThrow("Database fragment requires a database adapter");
+
+        expect(deps.db).toBeDefined();
+        expect(deps.createUnitOfWork).toBeDefined();
+      } finally {
+        if (previous === undefined) {
+          delete process.env["FRAGNO_DATA_DIR"];
+        } else {
+          process.env["FRAGNO_DATA_DIR"] = previous;
+        }
+      }
     });
   });
 
@@ -845,43 +864,58 @@ describe("DatabaseFragmentDefinitionBuilder", () => {
     });
   });
 
-  // describe("defineService", () => {
-  //   it("getUnitOfWork should be available in defineService", () => {
-  //     const mockAdapter = createMockAdapter();
-
-  //     const definition = withDatabase(testSchema)(defineFragment("db-frag"))
-  //       .withDependencies(() => ({ apiKey: "key" }))
-  //       .providesBaseService(({ deps, defineService }) => {
-  //         expect(deps.apiKey).toBe("key");
-  //         expect(deps.db).toBeDefined();
-  //         expect(defineService).toBeDefined();
-
-  //         return defineService({
-  //           getUsers: function () {
-  //             return typeof this.getUnitOfWork;
-  //           },
-  //         });
-  //       })
-  //       .build();
-
-  //     expect(definition.baseServices).toBeDefined();
-
-  //     // Get implicit deps first
-  //     const deps = definition.dependencies!({
-  //       config: {},
-  //       options: { databaseAdapter: mockAdapter },
-  //     });
-
-  //     const services = definition.baseServices!({
-  //       config: {},
-  //       options: { databaseAdapter: mockAdapter },
-  //       deps,
-  //       serviceDeps: {},
-  //       privateServices: {},
-  //       defineService: (svc) => svc,
-  //     });
-
-  //     expect(services.getUsers()).toBe("function");
-  //   });
-  // });
+  describe("serviceTx hooks propagation", () => {
+    it("should pass hooks to createServiceTxBuilder", () => {
+      const mockAdapter = createMockAdapter();
+
+      // Define hooks type
+      type TestHooks = {
+        onUserCreated: (payload: { email: string }) => void;
+      };
+
+      // Create a fragment with hooks
+      const definition = withDatabase(testSchema)(defineFragment("db-frag-with-hooks"))
+        .provideHooks<TestHooks>(({ defineHook }) => ({
+          onUserCreated: defineHook(function (payload: { email: string }) {
+            // Hook implementation
+            console.log("User created:", payload.email);
+          }),
+        }))
+        .build();
+
+      // Create a mock storage
+      const mockStorage = {
+        getStore: () => ({
+          uow: mockAdapter.createQueryEngine(testSchema, "test").createUnitOfWork(),
+        }),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any;
+
+      // Spy on createServiceTxBuilder
+      const createServiceTxBuilderSpy = vi.spyOn(executeUnitOfWork, "createServiceTxBuilder");
+
+      // Get the contexts which includes serviceTx
+      const contexts = definition.createThisContext!({
+        config: {},
+        options: { databaseAdapter: mockAdapter },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        deps: {} as any,
+        storage: mockStorage,
+      });
+
+      // Call serviceTx - this should pass hooks to createServiceTxBuilder
+      contexts.serviceContext.serviceTx(testSchema);
+
+      // Verify createServiceTxBuilder was called with 3 arguments (schema, uow, hooks)
+      expect(createServiceTxBuilderSpy).toHaveBeenCalledOnce();
+      const callArgs = createServiceTxBuilderSpy.mock.calls[0];
+      expect(callArgs).toHaveLength(3);
+      expect(callArgs[0]).toBe(testSchema); // schema
+      expect(callArgs[1]).toBeDefined(); // uow
+      expect(callArgs[2]).toBeDefined(); // hooks - this is what we're testing
+      expect(callArgs[2]).toHaveProperty("onUserCreated");
+
+      createServiceTxBuilderSpy.mockRestore();
+    });
+  });
 });