@fragno-dev/db 0.2.1 → 0.3.0

package/src/db-fragment-instantiator.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, assert } from "vitest";
 import { instantiate, defineFragment } from "@fragno-dev/core";
 import { defineRoutes } from "@fragno-dev/core/route";
@@ -7,14 +10,22 @@ import type { DatabaseAdapter } from "./adapters/adapters";
 import type { SimpleQueryInterface } from "./query/simple-query-interface";
 import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
 import { z } from "zod";
+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()).addColumn("name", column("string"));
   });
 });
 
+// Schema with dashes in the name (used to test namespace sanitization)
+const dashedSchema = schema("my-fragment", (s) => {
+  return s.addTable("items", (t) => {
+    return t.addColumn("id", idColumn()).addColumn("label", column("string"));
+  });
+});
+
 type TestSchema = typeof testSchema;
 
 // Mock database adapter
@@ -29,11 +40,21 @@ function createMockAdapter(): DatabaseAdapter {
             findMany: vi.fn(),
           })),
           restrict: vi.fn(() => createMockRestrictedUow()),
+          signalReadyForRetrieval: vi.fn(),
+          signalReadyForMutation: vi.fn(),
+          retrievalPhase: Promise.resolve([]),
+          mutationPhase: Promise.resolve(),
         })),
         restrict: vi.fn(() => createMockRestrictedUow()),
+        getRetrievalOperations: vi.fn(() => []),
+        getMutationOperations: vi.fn(() => []),
         table: vi.fn(() => ({
           findMany: vi.fn(),
         })),
+        signalReadyForRetrieval: vi.fn(),
+        signalReadyForMutation: vi.fn(),
+        retrievalPhase: Promise.resolve([]),
+        mutationPhase: Promise.resolve(),
       });
 
       return {
@@ -43,16 +64,26 @@ function createMockAdapter(): DatabaseAdapter {
             findMany: vi.fn(),
           })),
           restrict: vi.fn(() => createMockRestrictedUow()),
+          signalReadyForRetrieval: vi.fn(),
+          signalReadyForMutation: vi.fn(),
+          retrievalPhase: Promise.resolve([]),
+          mutationPhase: Promise.resolve(),
         })),
         restrict: vi.fn(() => createMockRestrictedUow()),
-        executeRetrieve: vi.fn(),
-        executeMutations: vi.fn(),
+        executeRetrieve: vi.fn(async () => {}),
+        executeMutations: vi.fn(async () => ({ success: true })),
         commit: vi.fn(),
         rollback: vi.fn(),
+        registerSchema: vi.fn(),
         reset: vi.fn(),
+        getRetrievalOperations: vi.fn(() => []),
+        getMutationOperations: vi.fn(() => []),
+        getCreatedIds: vi.fn(() => []),
         table: vi.fn(() => ({
           findMany: vi.fn(),
         })),
+        idempotencyKey: "test-nonce",
+        state: "building-retrieval",
       };
     }),
     type: "mock",
@@ -60,16 +91,17 @@ function createMockAdapter(): DatabaseAdapter {
 
   return {
     createQueryEngine: vi.fn(() => mockdb),
-    migrate: vi.fn(),
+    getSchemaVersion: vi.fn(async () => undefined),
     close: vi.fn(),
     type: "mock",
     contextStorage: new RequestContextStorage(),
+    namingStrategy: suffixNamingStrategy,
   } as unknown as DatabaseAdapter;
 }
 
 describe("db-fragment-instantiator", () => {
   describe("Unit of Work in request context", () => {
-    it("should provide executeRestrictedUnitOfWork on this context in route handlers", async () => {
+    it("should provide handlerTx on this context in route handlers", async () => {
       const definition = defineFragment("test-db-fragment")
         .extend(withDatabase(testSchema))
         .build();
@@ -79,10 +111,10 @@ describe("db-fragment-instantiator", () => {
           method: "GET",
           path: "/test",
           handler: async function (_input, { json }) {
-            // Access executeRestrictedUnitOfWork from this context
-            expect(this.uow).toBeDefined();
+            // Access handlerTx from this context
+            expect(this.handlerTx).toBeDefined();
 
-            return json({ hasExecuteMethod: !!this.uow });
+            return json({ hasHandlerTxBuilder: !!this.handlerTx });
           },
         }),
       ]);
@@ -96,10 +128,10 @@ describe("db-fragment-instantiator", () => {
       const response = await fragment.handler(new Request("http://localhost/api/test"));
       const data = await response.json();
 
-      expect(data).toEqual({ hasExecuteMethod: true });
+      expect(data).toEqual({ hasHandlerTxBuilder: true });
     });
 
-    it("should provide schema-typed UOW via executeRestrictedUnitOfWork", async () => {
+    it("should provide schema-typed UOW via handlerTx", async () => {
       const definition = defineFragment("test-db-fragment")
         .extend(withDatabase(testSchema))
         .build();
@@ -109,10 +141,12 @@ describe("db-fragment-instantiator", () => {
           method: "GET",
           path: "/test",
           handler: async function (_input, { json }) {
-            const result = await this.uow(async ({ forSchema }) => {
-              const uow = forSchema(testSchema);
-              return { hasSchemaUow: !!uow };
-            });
+            const result = await this.handlerTx()
+              .mutate(({ forSchema }) => {
+                const uow = forSchema(testSchema);
+                return { hasSchemaUow: !!uow };
+              })
+              .execute();
 
             return json(result);
           },
@@ -189,8 +223,8 @@ describe("db-fragment-instantiator", () => {
   });
 
   describe("database operations with UOW", () => {
-    it("should allow accessing schema-typed UOW in handlers via executeRestrictedUnitOfWork", async () => {
-      const testSchemaWithCounter = schema((s) => {
+    it("should allow accessing schema-typed UOW in handlers via handlerTx", async () => {
+      const testSchemaWithCounter = schema("testschemawithcounter", (s) => {
         return s.addTable("counters", (t) => {
           return t.addColumn("id", idColumn()).addColumn("value", column("integer"));
         });
@@ -205,11 +239,13 @@ describe("db-fragment-instantiator", () => {
           method: "GET",
           path: "/counters",
           handler: async function (_input, { json }) {
-            const result = await this.uow(async ({ forSchema }) => {
-              const uow = forSchema(testSchemaWithCounter);
-              // Verify that we can access the UOW
-              return { hasCountersTable: !!uow };
-            });
+            const result = await this.handlerTx()
+              .mutate(({ forSchema }) => {
+                const uow = forSchema(testSchemaWithCounter);
+                // Verify that we can access the UOW
+                return { hasCountersTable: !!uow };
+              })
+              .execute();
 
             return json(result);
           },
@@ -230,14 +266,15 @@ describe("db-fragment-instantiator", () => {
   });
 
   describe("service integration with UOW", () => {
-    it("should allow services to access UOW via forSchema", async () => {
+    it("should allow services to access UOW via serviceTx", async () => {
       const definition = defineFragment("test-db-fragment")
         .extend(withDatabase(testSchema))
         .providesBaseService(({ defineService }) =>
           defineService({
             checkTypedUowExists: function () {
-              const uow = this.uow(testSchema);
-              return !!uow;
+              return this.serviceTx(testSchema)
+                .mutate(({ uow }) => !!uow)
+                .build();
             },
           }),
         )
@@ -249,7 +286,10 @@ describe("db-fragment-instantiator", () => {
           path: "/check",
           outputSchema: z.object({ hasTypedUow: z.boolean() }),
           handler: async function (_input, { json }) {
-            const hasTypedUow = services.checkTypedUowExists();
+            const hasTypedUow = await this.handlerTx()
+              .withServiceCalls(() => [services.checkTypedUowExists()] as const)
+              .transform(({ serviceResult: [result] }) => result)
+              .execute();
             return json({ hasTypedUow });
           },
         }),
@@ -266,73 +306,18 @@ describe("db-fragment-instantiator", () => {
       assert(response.type === "json");
       expect(response.data).toEqual({ hasTypedUow: true });
     });
-
-    it.skip("should share same UOW across multiple service calls from handler", async () => {
-      const definition = defineFragment("test-db-fragment")
-        .extend(withDatabase(testSchema))
-        .providesService("helpers", ({ defineService }) =>
-          defineService({
-            logUow: function () {
-              return this.uow(testSchema);
-            },
-          }),
-        )
-        .providesService("main", ({ defineService }) =>
-          defineService({
-            markUow: function () {
-              return this.uow(testSchema);
-            },
-          }),
-        )
-        .build();
-
-      const routes = defineRoutes(definition).create(({ services, defineRoute }) => [
-        defineRoute({
-          method: "GET",
-          path: "/nested",
-          handler: async function (_input, { json }) {
-            // Mark the UOW with an ID
-            const uow1 = services.main.markUow();
-            const uow2 = services.helpers.logUow();
-            const uow3 = services.main.markUow();
-
-            console.log({
-              x: uow1 === uow2,
-              y: uow2 === uow3,
-              z: uow1 === uow3,
-            });
-
-            return json({
-              same: uow1 === uow2 && uow2 === uow3,
-            });
-          },
-        }),
-      ]);
-
-      const mockAdapter = createMockAdapter();
-      const fragment = instantiate(definition)
-        .withRoutes([routes])
-        .withOptions({ mountRoute: "/api", databaseAdapter: mockAdapter })
-        .build();
-
-      const response = await fragment.handler(new Request("http://localhost/api/nested"));
-      const data = await response.json();
-
-      expect(data).toEqual({
-        same: true,
-      });
-    });
   });
 
   describe("inContext with database fragments", () => {
-    it("should allow calling services with UOW via inContext", () => {
+    it("should allow calling services with UOW via inContext", async () => {
       const definition = defineFragment("test-db-fragment")
         .extend(withDatabase(testSchema))
         .providesBaseService(({ defineService }) =>
           defineService({
             getUowExists: function () {
-              const uow = this.uow(testSchema);
-              return !!uow;
+              return this.serviceTx(testSchema)
+                .mutate(({ uow }) => !!uow)
+                .build();
             },
           }),
         )
@@ -343,7 +328,12 @@ describe("db-fragment-instantiator", () => {
         .withOptions({ databaseAdapter: mockAdapter })
         .build();
 
-      const result = fragment.inContext(() => fragment.services.getUowExists());
+      const result = await fragment.inContext(async function () {
+        return await this.handlerTx()
+          .withServiceCalls(() => [fragment.services.getUowExists()] as const)
+          .transform(({ serviceResult: [exists] }) => exists)
+          .execute();
+      });
       expect(result).toBe(true);
     });
   });
@@ -370,10 +360,12 @@ describe("db-fragment-instantiator", () => {
           method: "GET",
           path: "/test",
           handler: async function (_input, { json }) {
-            const result = await this.uow(async ({ forSchema }) => {
-              const uow = forSchema(testSchema);
-              return { hasUow: !!uow };
-            });
+            const result = await this.handlerTx()
+              .mutate(({ forSchema }) => {
+                const uow = forSchema(testSchema);
+                return { hasUow: !!uow };
+              })
+              .execute();
             return json(result);
           },
         }),
@@ -473,7 +465,73 @@ describe("db-fragment-instantiator", () => {
         .build();
 
       expect(fragment.$internal.deps.schema).toBe(testSchema);
-      expect(fragment.$internal.deps.namespace).toBe("test-db-fragment");
+      expect(fragment.$internal.deps.namespace).toBe("test");
+    });
+
+    it("should use databaseNamespace override when provided", () => {
+      const definition = defineFragment("test-db-fragment")
+        .extend(withDatabase(testSchema))
+        .build();
+
+      const mockAdapter = createMockAdapter();
+      const fragment = instantiate(definition)
+        .withOptions({
+          mountRoute: "/api",
+          databaseAdapter: mockAdapter,
+          databaseNamespace: "custom-namespace",
+        })
+        .build();
+
+      expect(fragment.$internal.deps.namespace).toBe("custom-namespace");
+    });
+
+    it("should allow explicit null namespace override", () => {
+      const definition = defineFragment("test-db-fragment")
+        .extend(withDatabase(testSchema))
+        .build();
+
+      const mockAdapter = createMockAdapter();
+      const fragment = instantiate(definition)
+        .withOptions({
+          mountRoute: "/api",
+          databaseAdapter: mockAdapter,
+          databaseNamespace: null,
+        })
+        .build();
+
+      expect(fragment.$internal.deps.namespace).toBeNull();
+    });
+
+    it("should sanitize dashes in schema.name when used as default namespace", () => {
+      const definition = defineFragment("test-dashed-fragment")
+        .extend(withDatabase(dashedSchema))
+        .build();
+
+      const mockAdapter = createMockAdapter();
+      const fragment = instantiate(definition)
+        .withOptions({ mountRoute: "/api", databaseAdapter: mockAdapter })
+        .build();
+
+      // schema.name is "my-fragment", but default namespace should be sanitized to "my_fragment"
+      expect(fragment.$internal.deps.namespace).toBe("my_fragment");
+    });
+
+    it("should NOT sanitize explicit databaseNamespace even when it contains dashes", () => {
+      const definition = defineFragment("test-dashed-fragment")
+        .extend(withDatabase(dashedSchema))
+        .build();
+
+      const mockAdapter = createMockAdapter();
+      const fragment = instantiate(definition)
+        .withOptions({
+          mountRoute: "/api",
+          databaseAdapter: mockAdapter,
+          databaseNamespace: "my-fragment",
+        })
+        .build();
+
+      // Explicit override should be used as-is, dashes preserved
+      expect(fragment.$internal.deps.namespace).toBe("my-fragment");
     });
 
     it("should populate $internal when using providesBaseService without withDependencies", () => {
@@ -504,27 +562,37 @@ describe("db-fragment-instantiator", () => {
     });
   });
 
-  describe("error handling", () => {
-    it("should throw when databaseAdapter is not provided", () => {
+  describe("default adapter", () => {
+    it("should default to sqlite adapter when databaseAdapter is not provided", () => {
       const definition = defineFragment("test-db-fragment")
         .extend(withDatabase(testSchema))
         .build();
-
-      expect(() => {
-        instantiate(definition)
-          // @ts-expect-error - Test case
-          .withOptions({})
-          .build();
-      }).toThrow("Database fragment requires a database adapter");
+      const previous = process.env["FRAGNO_DATA_DIR"];
+      const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "fragno-db-default-"));
+      process.env["FRAGNO_DATA_DIR"] = dataDir;
+
+      try {
+        const fragment = instantiate(definition).withOptions({}).build();
+        expect(fragment.$internal.options.databaseAdapter).toBeDefined();
+        expect(fragment.$internal.deps.db).toBeDefined();
+      } finally {
+        if (previous === undefined) {
+          delete process.env["FRAGNO_DATA_DIR"];
+        } else {
+          process.env["FRAGNO_DATA_DIR"] = previous;
+        }
+      }
     });
 
-    it("should throw when forSchema called outside request context", () => {
+    it("should throw when serviceTx called outside request context", () => {
       const definition = defineFragment("test-db-fragment")
         .extend(withDatabase(testSchema))
         .providesBaseService(({ defineService }) =>
           defineService({
             tryGetUow: function () {
-              return this.uow(testSchema);
+              return this.serviceTx(testSchema)
+                .mutate(({ uow }) => uow)
+                .build();
             },
           }),
         )