@fragno-dev/db 0.2.2 → 0.4.1

package/src/db-fragment-instantiator.test.ts

@@ -1,83 +1,107 @@
 import { describe, it, expect, vi, assert } from "vitest";
-import { instantiate, defineFragment } from "@fragno-dev/core";
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
 import { defineRoutes } from "@fragno-dev/core/route";
-import { withDatabase } from "./with-database";
-import { schema, idColumn, column } from "./schema/create";
+import { z } from "zod";
+
+import { instantiate, defineFragment } from "@fragno-dev/core";
+
 import type { DatabaseAdapter } from "./adapters/adapters";
+import { suffixNamingStrategy } from "./naming/sql-naming";
 import type { SimpleQueryInterface } from "./query/simple-query-interface";
-import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
-import { z } from "zod";
+import { schema, idColumn, column } from "./schema/create";
+import { withDatabase } from "./with-database";
 
 // 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
 function createMockAdapter(): DatabaseAdapter {
-  const mockdb = {
-    createUnitOfWork: vi.fn(() => {
-      // Create a mock restricted UOW
-      const createMockRestrictedUow = () => ({
-        forSchema: vi.fn((schema) => ({
-          schema,
-          table: vi.fn(() => ({
-            findMany: vi.fn(),
-          })),
-          restrict: vi.fn(() => createMockRestrictedUow()),
-          signalReadyForRetrieval: vi.fn(),
-          signalReadyForMutation: vi.fn(),
-          retrievalPhase: Promise.resolve([]),
-          mutationPhase: Promise.resolve(),
-        })),
-        restrict: vi.fn(() => createMockRestrictedUow()),
-        table: vi.fn(() => ({
-          findMany: vi.fn(),
-        })),
-        signalReadyForRetrieval: vi.fn(),
-        signalReadyForMutation: vi.fn(),
-        retrievalPhase: Promise.resolve([]),
-        mutationPhase: Promise.resolve(),
-      });
+  const createMockRestrictedUow = () => ({
+    forSchema: vi.fn((schema) => ({
+      schema,
+      table: vi.fn(() => ({
+        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(),
+  });
+
+  const createMockUow = () => ({
+    forSchema: vi.fn((schema) => ({
+      schema,
+      table: vi.fn(() => ({
+        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(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(() => []),
+    triggerHook: vi.fn(),
+    getTriggeredHooks: vi.fn(() => []),
+    table: vi.fn(() => ({
+      findMany: vi.fn(),
+    })),
+    idempotencyKey: "test-nonce",
+    state: "building-retrieval",
+  });
 
-      return {
-        forSchema: vi.fn((schema) => ({
-          schema,
-          table: vi.fn(() => ({
-            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(async () => {}),
-        executeMutations: vi.fn(async () => ({ success: true })),
-        commit: vi.fn(),
-        rollback: vi.fn(),
-        reset: vi.fn(),
-        table: vi.fn(() => ({
-          findMany: vi.fn(),
-        })),
-        idempotencyKey: "test-nonce",
-        state: "building-retrieval",
-      };
-    }),
+  const mockdb = {
+    createUnitOfWork: vi.fn(() => createMockUow()),
+    createBaseUnitOfWork: vi.fn(() => createMockUow()),
     type: "mock",
   } as unknown as SimpleQueryInterface<TestSchema>;
 
   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;
 }
 
@@ -149,11 +173,11 @@ describe("db-fragment-instantiator", () => {
   });
 
   describe("implicit database dependencies", () => {
-    it("should provide db dependency to services", () => {
+    it("should provide databaseAdapter dependency to services", () => {
       const definition = defineFragment("test-db-fragment")
         .extend(withDatabase(testSchema))
         .providesBaseService(({ deps }) => ({
-          getDb: () => deps.db,
+          getAdapter: () => deps.databaseAdapter,
         }))
         .build();
 
@@ -162,9 +186,8 @@ describe("db-fragment-instantiator", () => {
         .withOptions({ databaseAdapter: mockAdapter })
         .build();
 
-      const db = fragment.services.getDb();
-      expect(db).toBeDefined();
-      expect(db.createUnitOfWork).toBeDefined();
+      const adapter = fragment.services.getAdapter();
+      expect(adapter).toBe(mockAdapter);
     });
 
     it("should provide schema dependency to services", () => {
@@ -206,7 +229,7 @@ describe("db-fragment-instantiator", () => {
 
   describe("database operations with UOW", () => {
     it("should allow accessing schema-typed UOW in handlers via handlerTx", async () => {
-      const testSchemaWithCounter = schema((s) => {
+      const testSchemaWithCounter = schema("testschemawithcounter", (s) => {
         return s.addTable("counters", (t) => {
           return t.addColumn("id", idColumn()).addColumn("value", column("integer"));
         });
@@ -310,27 +333,48 @@ describe("db-fragment-instantiator", () => {
         .withOptions({ databaseAdapter: mockAdapter })
         .build();
 
-      const result = await fragment.inContext(async function () {
-        return await this.handlerTx()
-          .withServiceCalls(() => [fragment.services.getUowExists()] as const)
-          .transform(({ serviceResult: [exists] }) => exists)
-          .execute();
-      });
+      const result = await fragment.callServices(() => fragment.services.getUowExists());
       expect(result).toBe(true);
     });
+
+    it("should allow calling multiple services at once via callServices", async () => {
+      const definition = defineFragment("test-db-fragment")
+        .extend(withDatabase(testSchema))
+        .providesBaseService(({ defineService }) =>
+          defineService({
+            getUowExists: function () {
+              return this.serviceTx(testSchema)
+                .mutate(({ uow }) => !!uow)
+                .build();
+            },
+          }),
+        )
+        .build();
+
+      const mockAdapter = createMockAdapter();
+      const fragment = instantiate(definition)
+        .withOptions({ databaseAdapter: mockAdapter })
+        .build();
+
+      const results = await fragment.callServices(
+        () => [fragment.services.getUowExists(), fragment.services.getUowExists()] as const,
+      );
+
+      expect(results).toEqual([true, true]);
+    });
   });
 
   describe("UOW isolation per request", () => {
     it("should create fresh UOW for each request", async () => {
-      let createUowCallCount = 0;
+      let createBaseUowCallCount = 0;
       const mockAdapter = createMockAdapter();
       const queryEngine = mockAdapter.createQueryEngine(testSchema, "test");
 
-      // Track how many times createUnitOfWork is called
-      const originalCreateUow = queryEngine.createUnitOfWork;
-      queryEngine.createUnitOfWork = vi.fn(() => {
-        createUowCallCount++;
-        return originalCreateUow();
+      // Track how many times createBaseUnitOfWork is called
+      const originalCreateBaseUow = queryEngine.createBaseUnitOfWork;
+      queryEngine.createBaseUnitOfWork = vi.fn(() => {
+        createBaseUowCallCount++;
+        return originalCreateBaseUow();
       });
 
       const definition = defineFragment("test-db-fragment")
@@ -362,31 +406,29 @@ describe("db-fragment-instantiator", () => {
       await fragment.handler(new Request("http://localhost/api/test"));
       await fragment.handler(new Request("http://localhost/api/test"));
 
-      // Verify that createUnitOfWork was called twice (once per request)
-      expect(createUowCallCount).toBe(2);
-      expect(queryEngine.createUnitOfWork).toHaveBeenCalledTimes(2);
+      // Verify that createBaseUnitOfWork was called twice (once per request)
+      expect(createBaseUowCallCount).toBe(2);
+      expect(queryEngine.createBaseUnitOfWork).toHaveBeenCalledTimes(2);
     });
   });
 
   describe("withDependencies with database context", () => {
-    it("should provide db and databaseAdapter in withDependencies context", () => {
+    it("should provide databaseAdapter in withDependencies context", () => {
       interface Config {
         prefix: string;
       }
 
       const definition = defineFragment<Config>("test-db-fragment")
         .extend(withDatabase(testSchema))
-        .withDependencies(({ config, db, databaseAdapter }) => ({
+        .withDependencies(({ config, databaseAdapter }) => ({
           userService: {
             prefix: config.prefix,
             hasAdapter: !!databaseAdapter,
-            hasDb: !!db,
           },
         }))
         .providesBaseService(({ deps }) => ({
           getUserServicePrefix: () => deps.userService.prefix,
           hasAdapter: () => deps.userService.hasAdapter,
-          hasDb: () => deps.userService.hasDb,
         }))
         .build();
 
@@ -398,7 +440,6 @@ describe("db-fragment-instantiator", () => {
 
       expect(fragment.services.getUserServicePrefix()).toBe("USER_");
       expect(fragment.services.hasAdapter()).toBe(true);
-      expect(fragment.services.hasDb()).toBe(true);
     });
   });
 
@@ -414,7 +455,7 @@ describe("db-fragment-instantiator", () => {
         .build();
 
       expect(fragment.$internal.deps).toBeDefined();
-      expect(fragment.$internal.deps).toHaveProperty("db");
+      expect(fragment.$internal.deps).toHaveProperty("databaseAdapter");
       expect(fragment.$internal.deps).toHaveProperty("schema");
       expect(fragment.$internal.deps).toHaveProperty("namespace");
       expect(fragment.$internal.deps).toHaveProperty("createUnitOfWork");
@@ -447,7 +488,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", () => {
@@ -468,7 +575,7 @@ describe("db-fragment-instantiator", () => {
         .build();
 
       expect(fragment.$internal.deps).toBeDefined();
-      expect(fragment.$internal.deps).toHaveProperty("db");
+      expect(fragment.$internal.deps).toHaveProperty("databaseAdapter");
       expect(fragment.$internal.deps).toHaveProperty("schema");
       expect(fragment.$internal.deps).toHaveProperty("namespace");
       expect(fragment.$internal.deps).toHaveProperty("createUnitOfWork");
@@ -478,18 +585,27 @@ 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.databaseAdapter).toBeDefined();
+        expect(fragment.$internal.deps.createUnitOfWork).toBeDefined();
+      } finally {
+        if (previous === undefined) {
+          delete process.env["FRAGNO_DATA_DIR"];
+        } else {
+          process.env["FRAGNO_DATA_DIR"] = previous;
+        }
+      }
     });
 
     it("should throw when serviceTx called outside request context", () => {

package/src/db-fragment-integration.test.ts

@@ -1,18 +1,21 @@
-import { SQLocalKysely } from "sqlocal/kysely";
 import { assert, beforeAll, describe, expect, it } from "vitest";
+
+import { defineRoutes } from "@fragno-dev/core/route";
+import { SQLocalKysely } from "sqlocal/kysely";
 import { z } from "zod";
-import { KyselyAdapter } from "./adapters/kysely/kysely-adapter";
-import { column, idColumn, referenceColumn, schema, type FragnoId } from "./schema/create";
+
 import { defineFragment, instantiate } from "@fragno-dev/core";
-import { defineRoutes } from "@fragno-dev/core/route";
-import { withDatabase } from "./with-database";
+
+import { SQLocalDriverConfig } from "./adapters/generic-sql/driver-config";
+import { SqlAdapter } from "./adapters/generic-sql/generic-sql-adapter";
 import type { FragnoPublicConfigWithDatabase } from "./db-fragment-definition-builder";
 import { ConcurrencyConflictError, type TxResult } from "./query/unit-of-work/execute-unit-of-work";
-import { SQLocalDriverConfig } from "./adapters/generic-sql/driver-config";
+import { column, idColumn, referenceColumn, schema, type FragnoId } from "./schema/create";
+import { withDatabase } from "./with-database";
 
 describe.sequential("Database Fragment Integration", () => {
   // Schema 1: Users fragment
-  const usersSchema = schema((s) => {
+  const usersSchema = schema("users", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -36,7 +39,7 @@ describe.sequential("Database Fragment Integration", () => {
   });
 
   // Schema 2: Orders fragment
-  const ordersSchema = schema((s) => {
+  const ordersSchema = schema("orders", (s) => {
     return s.addTable("orders", (t) => {
       return t
         .addColumn("id", idColumn())
@@ -50,7 +53,7 @@ describe.sequential("Database Fragment Integration", () => {
 
   // Define Users Fragment using the new unified serviceTx API
   const usersFragmentDef = defineFragment("users-fragment")
-    .extend(withDatabase(usersSchema, "users"))
+    .extend(withDatabase(usersSchema))
     .providesService("userService", ({ defineService }) => {
       return defineService({
         // Creates a user - returns TxResult<FragnoId>
@@ -118,7 +121,7 @@ describe.sequential("Database Fragment Integration", () => {
 
   // Define Orders Fragment with cross-fragment service dependency using new serviceTx API
   const ordersFragmentDef = defineFragment("orders-fragment")
-    .extend(withDatabase(ordersSchema, "orders"))
+    .extend(withDatabase(ordersSchema))
     .usesService<
       "userService",
       {
@@ -209,7 +212,7 @@ describe.sequential("Database Fragment Integration", () => {
     }),
   ]);
 
-  let adapter: KyselyAdapter;
+  let adapter: SqlAdapter;
   let usersFragment: ReturnType<typeof instantiateUsersFragment>;
   let ordersFragment: ReturnType<typeof instantiateOrdersFragment>;
 
@@ -239,7 +242,7 @@ describe.sequential("Database Fragment Integration", () => {
   beforeAll(async () => {
     // Create in-memory SQLite database with Kysely
     const { dialect } = new SQLocalKysely(":memory:");
-    adapter = new KyselyAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new SQLocalDriverConfig(),
     });
@@ -414,6 +417,8 @@ describe.sequential("Database Fragment Integration", () => {
 
     const result = await usersFragment.inContext(async function () {
       return await this.handlerTx()
+        // Add a retrieve op so retry is allowed for the forced conflict below.
+        .retrieve(({ forSchema }) => forSchema(usersSchema).find("users"))
         .mutate(({ forSchema, idempotencyKey, currentAttempt }) => {
           if (currentAttempt === 0) {
             firstIdempotencyKey = idempotencyKey;