@fragno-dev/test 0.1.11 → 0.1.13

package/src/index.test.ts

@@ -1,10 +1,10 @@
-import { describe, expect, it, afterEach } from "vitest";
+import { describe, expect, expectTypeOf, it } from "vitest";
 import { column, idColumn, schema } from "@fragno-dev/db/schema";
-import { defineFragmentWithDatabase } from "@fragno-dev/db/fragment";
-import { createDatabaseFragmentForTest } from "./index";
-import { unlinkSync, existsSync } from "node:fs";
-import { defineRoute, defineRoutes } from "@fragno-dev/core";
-import { z } from "zod";
+import { withDatabase } from "@fragno-dev/db";
+import { defineFragment } from "@fragno-dev/core";
+import { instantiate } from "@fragno-dev/core";
+import { buildDatabaseFragmentsTest } from "./db-test";
+import type { ExtractFragmentServices } from "@fragno-dev/core/route";
 
 // Test schema with multiple versions
 const testSchema = schema((s) => {
@@ -22,518 +22,132 @@ const testSchema = schema((s) => {
 });
 
 // Test fragment definition
-const testFragmentDef = defineFragmentWithDatabase<{}>("test-fragment")
-  .withDatabase(testSchema)
-  .withServices(({ orm }) => {
+const testFragmentDef = defineFragment<{}>("test-fragment")
+  .extend(withDatabase(testSchema))
+  .providesBaseService(({ deps }) => {
     return {
       createUser: async (data: { name: string; email: string; age?: number | null }) => {
-        const id = await orm.create("users", data);
+        const id = await deps.db.create("users", data);
         return { ...data, id: id.valueOf() };
       },
       getUsers: async () => {
-        const users = await orm.find("users", (b) =>
+        const users = await deps.db.find("users", (b) =>
           b.whereIndex("idx_users_all", (eb) => eb("id", "!=", "")),
         );
         return users.map((u) => ({ ...u, id: u.id.valueOf() }));
       },
     };
-  });
-
-describe("createDatabaseFragmentForTest", () => {
-  describe("databasePath option", () => {
-    const testDbPath = "./test-fragno.pglite";
-
-    afterEach(() => {
-      // Clean up test database files
-      if (existsSync(testDbPath)) {
-        try {
-          unlinkSync(testDbPath);
-        } catch {
-          // Ignore cleanup errors
-        }
-      }
-    });
-
-    it("should use in-memory database by default", async () => {
-      const { fragment } = await createDatabaseFragmentForTest(testFragmentDef, [], {
-        adapter: { type: "kysely-sqlite" },
-      });
-
-      // Should be able to create and query users
-      const user = await fragment.services.createUser({
-        name: "Test User",
-        email: "test@example.com",
-        age: 25,
-      });
-
-      expect(user).toMatchObject({
-        id: expect.any(String),
-        name: "Test User",
-        email: "test@example.com",
-        age: 25,
-      });
-
-      const users = await fragment.services.getUsers();
-      expect(users).toHaveLength(1);
-      expect(users[0]).toMatchObject(user);
-    });
-
-    it("should create database at specified path", async () => {
-      const { fragment } = await createDatabaseFragmentForTest(testFragmentDef, [], {
-        adapter: { type: "kysely-sqlite", databasePath: testDbPath },
-      });
-
-      // Create a user
-      await fragment.services.createUser({
-        name: "Persisted User",
-        email: "persisted@example.com",
-        age: 30,
-      });
-
-      // Verify data exists in this instance
-      const users = await fragment.services.getUsers();
-      expect(users).toHaveLength(1);
-      expect(users[0]).toMatchObject({
-        name: "Persisted User",
-        email: "persisted@example.com",
-        age: 30,
-      });
-    });
-  });
-
-  describe("migrateToVersion option", () => {
-    it("should migrate to latest version by default", async () => {
-      const { fragment } = await createDatabaseFragmentForTest(testFragmentDef, [], {
-        adapter: { type: "kysely-sqlite" },
-      });
-
-      // Should have the 'age' column from version 2
-      const user = await fragment.services.createUser({
-        name: "Test User",
-        email: "test@example.com",
-        age: 25,
-      });
-
-      expect(user).toMatchObject({
-        id: expect.any(String),
-        name: "Test User",
-        email: "test@example.com",
-        age: 25,
-      });
+  })
+  .build();
+
+describe("buildDatabaseFragmentsTest", () => {
+  it("should create and use a database fragment", async () => {
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("test", instantiate(testFragmentDef).withConfig({}).withRoutes([]))
+      .build();
+
+    const fragment = fragments.test;
+
+    // Should be able to create and query users
+    const user = await fragment.services.createUser({
+      name: "Test User",
+      email: "test@example.com",
+      age: 25,
     });
 
-    it("should migrate to specific version when specified", async () => {
-      // Migrate to version 1 (before 'age' column was added)
-      const { test } = await createDatabaseFragmentForTest(testFragmentDef, [], {
-        adapter: { type: "kysely-sqlite" },
-        migrateToVersion: 1,
-      });
-
-      // Query the database directly to check schema
-      // In version 1, we should be able to insert without the age column
-      const tableName = "users_test-fragment-db";
-      await test.kysely
-        .insertInto(tableName)
-        .values({
-          id: "test-id-1",
-          name: "V1 User",
-          email: "v1@example.com",
-        })
-        .execute();
-
-      const result = await test.kysely.selectFrom(tableName).selectAll().execute();
-
-      expect(result).toHaveLength(1);
-      expect(result[0]).toMatchObject({
-        id: "test-id-1",
-        name: "V1 User",
-        email: "v1@example.com",
-      });
-      // In version 1, the age column should not exist
-      expect(result[0]).not.toHaveProperty("age");
+    expect(user).toMatchObject({
+      id: expect.any(String),
+      name: "Test User",
+      email: "test@example.com",
+      age: 25,
     });
 
-    it("should allow creating user with age when migrated to version 2", async () => {
-      // Explicitly migrate to version 2
-      const { fragment, test } = await createDatabaseFragmentForTest(testFragmentDef, [], {
-        adapter: { type: "kysely-sqlite" },
-        migrateToVersion: 2,
-      });
-
-      // Should be able to use age column
-      const user = await fragment.services.createUser({
-        name: "V2 User",
-        email: "v2@example.com",
-        age: 35,
-      });
-
-      expect(user).toMatchObject({
-        id: expect.any(String),
-        name: "V2 User",
-        email: "v2@example.com",
-        age: 35,
-      });
-
-      const tableName = "users_test-fragment-db";
-      const result = await test.kysely.selectFrom(tableName).selectAll().execute();
+    const users = await fragment.services.getUsers();
+    expect(users).toHaveLength(1);
+    expect(users[0]).toMatchObject(user);
 
-      expect(result).toHaveLength(1);
-      expect(result[0]).toMatchObject({
-        name: "V2 User",
-        email: "v2@example.com",
-        age: 35,
-      });
-    });
+    await test.cleanup();
   });
 
-  describe("combined options", () => {
-    const testDbPath = "./test-combined.pglite";
-
-    afterEach(() => {
-      if (existsSync(testDbPath)) {
-        try {
-          unlinkSync(testDbPath);
-        } catch {
-          // Ignore cleanup errors
-        }
-      }
-    });
-
-    it("should work with both databasePath and migrateToVersion", async () => {
-      const { fragment } = await createDatabaseFragmentForTest(testFragmentDef, [], {
-        adapter: { type: "kysely-sqlite", databasePath: testDbPath },
-        migrateToVersion: 2,
-      });
-
-      // Create user at version 2 (with age support)
-      const user = await fragment.services.createUser({
-        name: "Combined Test",
-        email: "combined@example.com",
-        age: 40,
-      });
-
-      expect(user).toMatchObject({
-        id: expect.any(String),
-        name: "Combined Test",
-        email: "combined@example.com",
-        age: 40,
-      });
-
-      const users = await fragment.services.getUsers();
-      expect(users).toHaveLength(1);
-      expect(users[0]).toMatchObject({
-        name: "Combined Test",
-        email: "combined@example.com",
-        age: 40,
-      });
-    });
+  it("should throw error for non-database fragment", async () => {
+    const nonDbFragmentDef = defineFragment<{}>("non-db-fragment")
+      .providesBaseService(() => ({}))
+      .build();
+
+    await expect(
+      buildDatabaseFragmentsTest()
+        .withTestAdapter({ type: "kysely-sqlite" })
+        .withFragment("nonDb", instantiate(nonDbFragmentDef).withConfig({}).withRoutes([]))
+        .build(),
+    ).rejects.toThrow("Fragment 'non-db-fragment' does not have a database schema");
   });
 
-  describe("fragment initialization", () => {
-    it("should provide kysely instance", async () => {
-      const { test } = await createDatabaseFragmentForTest(testFragmentDef, [], {
-        adapter: { type: "kysely-sqlite" },
-      });
-
-      expect(test.kysely).toBeDefined();
-      expect(typeof test.kysely.selectFrom).toBe("function");
-    });
+  it("should reset database by truncating tables", async () => {
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("test", instantiate(testFragmentDef).withConfig({}).withRoutes([]))
+      .build();
 
-    it("should provide adapter instance", async () => {
-      const { test } = await createDatabaseFragmentForTest(testFragmentDef, [], {
-        adapter: { type: "kysely-sqlite" },
-      });
+    const fragment = fragments.test;
 
-      expect(test.adapter).toBeDefined();
-      expect(typeof test.adapter.createMigrationEngine).toBe("function");
+    // Create some users
+    await fragment.services.createUser({
+      name: "User 1",
+      email: "user1@example.com",
+      age: 25,
     });
 
-    it("should have all standard fragment test properties", async () => {
-      const { fragment } = await createDatabaseFragmentForTest(testFragmentDef, [], {
-        adapter: { type: "kysely-sqlite" },
-      });
+    // Verify users exist
+    let users = await fragment.services.getUsers();
+    expect(users).toHaveLength(1);
 
-      expect(fragment.services).toBeDefined();
-    });
+    // Reset the database
+    await test.resetDatabase();
 
-    it("should throw error for non-database fragment", async () => {
-      // Create a fragment without database
-      const nonDbFragment = {
-        definition: {
-          name: "non-db-fragment",
-          additionalContext: {},
-        },
-        $requiredOptions: {},
-      };
+    // Verify database is empty
+    users = await fragment.services.getUsers();
+    expect(users).toHaveLength(0);
 
-      await expect(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        createDatabaseFragmentForTest(nonDbFragment as any, [], {
-          adapter: { type: "kysely-sqlite" },
-        }),
-      ).rejects.toThrow("Fragment 'non-db-fragment' does not have a database schema");
-    });
+    // Cleanup
+    await test.cleanup();
   });
 
-  describe("route handling with defineRoutes", () => {
-    it("should handle route factory with multiple routes", async () => {
-      type Config = {};
-      type Deps = {};
-      type Services = {
-        createUser: (data: { name: string; email: string; age?: number | null }) => Promise<{
-          name: string;
-          email: string;
-          age?: number | null;
-          id: string;
-        }>;
-        getUsers: () => Promise<{ name: string; email: string; age: number | null; id: string }[]>;
-      };
+  it("should expose db property for direct ORM queries", async () => {
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("test", instantiate(testFragmentDef).withConfig({}).withRoutes([]))
+      .build();
 
-      const routeFactory = defineRoutes<Config, Deps, Services>().create(({ services }) => [
-        defineRoute({
-          method: "POST",
-          path: "/users",
-          inputSchema: z.object({
-            name: z.string(),
-            email: z.string(),
-            age: z.number().nullable().optional(),
-          }),
-          outputSchema: z.object({
-            id: z.string(),
-            name: z.string(),
-            email: z.string(),
-            age: z.number().nullable().optional(),
-          }),
-          handler: async ({ input }, { json }) => {
-            if (input) {
-              const data = await input.valid();
-              const user = await services.createUser(data);
-              return json(user);
-            }
-            return json({ id: "", name: "", email: "", age: null });
-          },
-        }),
-        defineRoute({
-          method: "GET",
-          path: "/users",
-          outputSchema: z.array(
-            z.object({
-              id: z.string(),
-              name: z.string(),
-              email: z.string(),
-              age: z.number().nullable(),
-            }),
-          ),
-          handler: async (_ctx, { json }) => {
-            const users = await services.getUsers();
-            return json(users);
-          },
-        }),
-      ]);
+    const fragment = fragments.test;
 
-      const routes = [routeFactory] as const;
-      const { fragment } = await createDatabaseFragmentForTest(testFragmentDef, routes, {
-        adapter: { type: "kysely-sqlite" },
-      });
-      // Test creating a user
-      const createResponse = await fragment.callRoute("POST", "/users", {
-        body: { name: "John Doe", email: "john@example.com", age: 30 },
-      });
-
-      expect(createResponse.type).toBe("json");
-      if (createResponse.type === "json") {
-        expect(createResponse.data).toMatchObject({
-          id: expect.any(String),
-          name: "John Doe",
-          email: "john@example.com",
-          age: 30,
-        });
-      }
-
-      // Test getting users
-      const getUsersResponse = await fragment.callRoute("GET", "/users");
-
-      expect(getUsersResponse.type).toBe("json");
-      if (getUsersResponse.type === "json") {
-        expect(getUsersResponse.data).toHaveLength(1);
-        expect(getUsersResponse.data[0]).toMatchObject({
-          id: expect.any(String),
-          name: "John Doe",
-          email: "john@example.com",
-          age: 30,
-        });
-      }
+    // Test creating a record directly using test.db
+    const userId = await fragment.db.create("users", {
+      name: "Direct DB User",
+      email: "direct@example.com",
+      age: 28,
     });
-  });
 
-  describe("resetDatabase", () => {
-    const adapters = [
-      { name: "Kysely SQLite", adapter: { type: "kysely-sqlite" as const } },
-      { name: "Kysely PGLite", adapter: { type: "kysely-pglite" as const } },
-      { name: "Drizzle PGLite", adapter: { type: "drizzle-pglite" as const } },
-    ];
-
-    for (const { name, adapter } of adapters) {
-      describe(name, () => {
-        it("should clear all data and recreate a fresh database", async () => {
-          // Don't destructure so we can access the updated fragment through getters after reset
-          const result = await createDatabaseFragmentForTest(testFragmentDef, [], {
-            adapter,
-          });
-
-          // Create some users
-          await result.services.createUser({
-            name: "User 1",
-            email: "user1@example.com",
-            age: 25,
-          });
-          await result.services.createUser({
-            name: "User 2",
-            email: "user2@example.com",
-            age: 30,
-          });
-
-          // Verify users exist
-          let users = await result.services.getUsers();
-          expect(users).toHaveLength(2);
-
-          // Reset the database
-          await result.test.resetDatabase();
-
-          // Verify database is empty (accessing through result to get updated fragment)
-          users = await result.services.getUsers();
-          expect(users).toHaveLength(0);
-
-          // Verify we can still create new users after reset
-          const newUser = await result.services.createUser({
-            name: "User After Reset",
-            email: "after@example.com",
-            age: 35,
-          });
-
-          expect(newUser).toMatchObject({
-            id: expect.any(String),
-            name: "User After Reset",
-            email: "after@example.com",
-            age: 35,
-          });
-
-          users = await result.services.getUsers();
-          expect(users).toHaveLength(1);
-          expect(users[0]).toMatchObject(newUser);
-
-          // Cleanup
-          await result.test.cleanup();
-        }, 10000);
-      });
-    }
-  });
+    expect(userId).toBeDefined();
+    expect(typeof userId.valueOf()).toBe("string");
 
-  describe("db property access", () => {
-    const adapters = [
-      { name: "Kysely SQLite", adapter: { type: "kysely-sqlite" as const } },
-      { name: "Kysely PGLite", adapter: { type: "kysely-pglite" as const } },
-      { name: "Drizzle PGLite", adapter: { type: "drizzle-pglite" as const } },
-    ];
-
-    for (const { name, adapter } of adapters) {
-      describe(name, () => {
-        it("should expose db property for direct ORM queries", async () => {
-          const { test } = await createDatabaseFragmentForTest(testFragmentDef, [], {
-            adapter,
-          });
-
-          // Test creating a record directly using test.db
-          const userId = await test.db.create("users", {
-            name: "Direct DB User",
-            email: "direct@example.com",
-            age: 28,
-          });
-
-          expect(userId).toBeDefined();
-          expect(typeof userId.valueOf()).toBe("string");
-
-          // Test finding records using test.db
-          const users = await test.db.find("users", (b) =>
-            b.whereIndex("idx_users_all", (eb) => eb("id", "=", userId)),
-          );
+    // Test finding records using test.db
+    const users = await fragment.db.find("users", (b) =>
+      b.whereIndex("idx_users_all", (eb) => eb("id", "=", userId)),
+    );
 
-          expect(users).toHaveLength(1);
-          expect(users[0]).toMatchObject({
-            id: userId,
-            name: "Direct DB User",
-            email: "direct@example.com",
-            age: 28,
-          });
-
-          // Test findFirst using test.db
-          const user = await test.db.findFirst("users", (b) =>
-            b.whereIndex("idx_users_all", (eb) => eb("id", "=", userId)),
-          );
+    expect(users).toHaveLength(1);
+    expect(users[0]).toMatchObject({
+      id: userId,
+      name: "Direct DB User",
+      email: "direct@example.com",
+      age: 28,
+    });
 
-          expect(user).toMatchObject({
-            id: userId,
-            name: "Direct DB User",
-            email: "direct@example.com",
-            age: 28,
-          });
-
-          // Cleanup
-          await test.cleanup();
-        }, 10000);
-
-        it("should maintain db property after resetDatabase", async () => {
-          const result = await createDatabaseFragmentForTest(testFragmentDef, [], {
-            adapter,
-          });
-
-          // Create initial data using test.db
-          await result.test.db.create("users", {
-            name: "Before Reset",
-            email: "before@example.com",
-            age: 25,
-          });
-
-          // Verify db works before reset
-          expect(result.test.db).toBeDefined();
-          expect(typeof result.test.db.create).toBe("function");
-
-          // Verify data exists
-          let users = await result.test.db.find("users");
-          expect(users).toHaveLength(1);
-
-          // Reset database
-          await result.test.resetDatabase();
-
-          // Verify database was actually reset (no data)
-          users = await result.test.db.find("users");
-          expect(users).toHaveLength(0);
-
-          // Verify we can still use the ORM after reset
-          const newUserId = await result.test.db.create("users", {
-            name: "After Reset",
-            email: "after@example.com",
-            age: 30,
-          });
-
-          expect(newUserId).toBeDefined();
-
-          const newUsers = await result.test.db.find("users");
-          expect(newUsers).toHaveLength(1);
-          expect(newUsers[0]).toMatchObject({
-            name: "After Reset",
-            email: "after@example.com",
-            age: 30,
-          });
-
-          // Cleanup
-          await result.test.cleanup();
-        }, 10000);
-      });
-    }
+    await test.cleanup();
   });
 
-  describe("multiple adapters with auth-like schema", () => {
+  it("should work with multi-table schema", async () => {
     // Simplified auth schema for testing
     const authSchema = schema((s) => {
       return s
@@ -553,84 +167,211 @@ describe("createDatabaseFragmentForTest", () => {
         });
     });
 
-    const authFragmentDef = defineFragmentWithDatabase<{}>("auth-test")
-      .withDatabase(authSchema)
-      .withServices(({ orm }) => {
+    const authFragmentDef = defineFragment<{}>("auth-test")
+      .extend(withDatabase(authSchema))
+      .providesBaseService(({ deps }) => {
         return {
           createUser: async (email: string, passwordHash: string) => {
-            const id = await orm.create("user", { email, passwordHash });
+            const id = await deps.db.create("user", { email, passwordHash });
             return { id: id.valueOf(), email, passwordHash };
           },
           createSession: async (userId: string) => {
             const expiresAt = new Date();
             expiresAt.setDate(expiresAt.getDate() + 30);
-            const id = await orm.create("session", { userId, expiresAt });
+            const id = await deps.db.create("session", { userId, expiresAt });
             return { id: id.valueOf(), userId, expiresAt };
           },
-          getUserByEmail: async (email: string) => {
-            const user = await orm.findFirst("user", (b) =>
-              b.whereIndex("idx_user_email", (eb) => eb("email", "=", email)),
-            );
-            if (!user) {
-              return null;
-            }
-            return { id: user.id.valueOf(), email: user.email, passwordHash: user.passwordHash };
-          },
         };
+      })
+      .build();
+
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("auth", instantiate(authFragmentDef).withConfig({}).withRoutes([]))
+      .build();
+
+    const fragment = fragments.auth;
+
+    // Create a user
+    const user = await fragment.services.createUser("test@test.com", "hashed-password");
+    expect(user).toMatchObject({
+      id: expect.any(String),
+      email: "test@test.com",
+      passwordHash: "hashed-password",
+    });
+
+    // Create a session for the user
+    const session = await fragment.services.createSession(user.id);
+    expect(session).toMatchObject({
+      id: expect.any(String),
+      userId: user.id,
+      expiresAt: expect.any(Date),
+    });
+
+    await test.cleanup();
+  });
+});
+
+describe("multi-fragment tests", () => {
+  // Create two different schemas
+  const userSchema = schema((s) => {
+    return s.addTable("user", (t) => {
+      return t
+        .addColumn("id", idColumn())
+        .addColumn("name", column("string"))
+        .addColumn("email", column("string"))
+        .createIndex("idx_user_all", ["id"]);
+    });
+  });
+
+  const postSchema = schema((s) => {
+    return s.addTable("post", (t) => {
+      return t
+        .addColumn("id", idColumn())
+        .addColumn("title", column("string"))
+        .addColumn("userId", column("string"))
+        .createIndex("idx_post_all", ["id"]);
+    });
+  });
+
+  const userFragmentDef = defineFragment<{}>("user-fragment")
+    .extend(withDatabase(userSchema))
+    .providesBaseService(({ deps }) => {
+      return {
+        createUser: async (data: { name: string; email: string }) => {
+          const id = await deps.db.create("user", data);
+          return { ...data, id: id.valueOf() };
+        },
+        getUsers: async () => {
+          const users = await deps.db.find("user", (b) =>
+            b.whereIndex("idx_user_all", (eb) => eb("id", "!=", "")),
+          );
+          return users.map((u) => ({ ...u, id: u.id.valueOf() }));
+        },
+      };
+    })
+    .build();
+
+  const postFragmentDef = defineFragment<{}>("post-fragment")
+    .extend(withDatabase(postSchema))
+    .providesBaseService(({ deps }) => {
+      return {
+        createPost: async (data: { title: string; userId: string }) => {
+          const id = await deps.db.create("post", data);
+          return { ...data, id: id.valueOf() };
+        },
+        getPosts: async () => {
+          const posts = await deps.db.find("post", (b) =>
+            b.whereIndex("idx_post_all", (eb) => eb("id", "!=", "")),
+          );
+          return posts.map((p) => ({ ...p, id: p.id.valueOf() }));
+        },
+      };
+    })
+    .build();
+
+  const adapters = [
+    { name: "Kysely SQLite", adapter: { type: "kysely-sqlite" as const } },
+    { name: "Kysely PGLite", adapter: { type: "kysely-pglite" as const } },
+    { name: "Drizzle PGLite", adapter: { type: "drizzle-pglite" as const } },
+  ];
+
+  for (const { name, adapter } of adapters) {
+    it(`should allow multiple fragments to share the same database adapter - ${name}`, async () => {
+      // Create both fragments with shared adapter
+      const { fragments, test } = await buildDatabaseFragmentsTest()
+        .withTestAdapter(adapter)
+        .withFragment("user", instantiate(userFragmentDef).withConfig({}).withRoutes([]))
+        .withFragment("post", instantiate(postFragmentDef).withConfig({}).withRoutes([]))
+        .build();
+
+      // Create a user
+      const user = await fragments.user.services.createUser({
+        name: "John Doe",
+        email: "john@example.com",
+      });
+
+      expect(user).toMatchObject({
+        id: expect.any(String),
+        name: "John Doe",
+        email: "john@example.com",
       });
 
-    const adapters = [
-      { name: "Kysely SQLite", adapter: { type: "kysely-sqlite" as const } },
-      { name: "Kysely PGLite", adapter: { type: "kysely-pglite" as const } },
-      { name: "Drizzle PGLite", adapter: { type: "drizzle-pglite" as const } },
-    ];
-
-    for (const { name, adapter } of adapters) {
-      describe(name, () => {
-        it("should create user and session", async () => {
-          const { fragment, test } = await createDatabaseFragmentForTest(authFragmentDef, [], {
-            adapter,
-          });
-
-          // Create a user
-          const user = await fragment.services.createUser("test@test.com", "hashed-password");
-          expect(user).toMatchObject({
-            id: expect.any(String),
-            email: "test@test.com",
-            passwordHash: "hashed-password",
-          });
-
-          // Create a session for the user
-          const session = await fragment.services.createSession(user.id);
-          expect(session).toMatchObject({
-            id: expect.any(String),
-            userId: user.id,
-            expiresAt: expect.any(Date),
-          });
-
-          // Find user by email
-          const foundUser = await fragment.services.getUserByEmail("test@test.com");
-          expect(foundUser).toMatchObject({
-            id: user.id,
-            email: "test@test.com",
-            passwordHash: "hashed-password",
-          });
-
-          // Cleanup
-          await test.cleanup();
-        }, 10000);
-
-        it("should return null when user not found", async () => {
-          const { fragment, test } = await createDatabaseFragmentForTest(authFragmentDef, [], {
-            adapter,
-          });
-
-          const notFound = await fragment.services.getUserByEmail("nonexistent@test.com");
-          expect(notFound).toBeNull();
-
-          await test.cleanup();
-        }, 10000);
+      // Create a post with the user's ID
+      const post = await fragments.post.services.createPost({
+        title: "My First Post",
+        userId: user.id,
       });
+
+      expect(post).toMatchObject({
+        id: expect.any(String),
+        title: "My First Post",
+        userId: user.id,
+      });
+
+      // Verify data exists
+      const users = await fragments.user.services.getUsers();
+      expect(users).toHaveLength(1);
+
+      const posts = await fragments.post.services.getPosts();
+      expect(posts).toHaveLength(1);
+      expect(posts[0]!.userId).toBe(user.id);
+
+      // Cleanup (centralized - cleans up all fragments)
+      await test.cleanup();
+    }, 10000);
+  }
+});
+
+describe("ExtractFragmentServices", () => {
+  it("extracts provided services from database fragment with new API", () => {
+    const testSchema = schema((s) => s);
+
+    interface ITestService {
+      doSomething: (input: string) => Promise<string>;
+      doSomethingElse: (input: number) => Promise<number>;
     }
+
+    const fragment = defineFragment<{}>("test-db-fragment")
+      .extend(withDatabase(testSchema))
+      .providesService(
+        "test",
+        (): ITestService => ({
+          doSomething: async (input: string) => input.toUpperCase(),
+          doSomethingElse: async (input: number) => input * 2,
+        }),
+      )
+      .build();
+
+    type Services = ExtractFragmentServices<typeof fragment>;
+
+    // Should include the provided service
+    expectTypeOf<Services>().toMatchObjectType<{
+      test: ITestService;
+    }>();
+  });
+
+  it("merges base services and provided services in database fragment", () => {
+    const testSchema = schema((s) => s);
+
+    const fragment = defineFragment<{}>("test-db-fragment")
+      .extend(withDatabase(testSchema))
+      .providesBaseService(() => ({
+        internalService: async () => "internal",
+      }))
+      .providesService("externalService", () => ({
+        publicMethod: async () => "public",
+      }))
+      .build();
+
+    type Services = ExtractFragmentServices<typeof fragment>;
+
+    // Should include both base services and provided services
+    expectTypeOf<Services>().toMatchObjectType<{
+      internalService: () => Promise<string>;
+      externalService: {
+        publicMethod: () => Promise<string>;
+      };
+    }>();
   });
 });