@fragno-dev/test 0.1.12 → 0.1.13

package/src/index.test.ts

@@ -1,8 +1,10 @@
 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, createDatabaseFragmentsForTest } from "./index";
-import type { ExtractFragmentServices } from "@fragno-dev/core/api/route";
+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) => {
@@ -20,31 +22,32 @@ const testSchema = schema((s) => {
 });
 
 // Test fragment definition
-const testFragmentDef = defineFragmentWithDatabase<{}>("test-fragment")
-  .withDatabase(testSchema)
-  .providesService(({ db }) => {
+const testFragmentDef = defineFragment<{}>("test-fragment")
+  .extend(withDatabase(testSchema))
+  .providesBaseService(({ deps }) => {
     return {
       createUser: async (data: { name: string; email: string; age?: number | null }) => {
-        const id = await db.create("users", data);
+        const id = await deps.db.create("users", data);
         return { ...data, id: id.valueOf() };
       },
       getUsers: async () => {
-        const users = await db.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() }));
       },
     };
-  });
+  })
+  .build();
 
-describe("createDatabaseFragmentForTest", () => {
+describe("buildDatabaseFragmentsTest", () => {
   it("should create and use a database fragment", async () => {
-    const { fragment, test } = await createDatabaseFragmentForTest(
-      { definition: testFragmentDef, routes: [] },
-      {
-        adapter: { type: "kysely-sqlite" },
-      },
-    );
+    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({
@@ -68,32 +71,25 @@ describe("createDatabaseFragmentForTest", () => {
   });
 
   it("should throw error for non-database fragment", async () => {
-    const nonDbFragment = {
-      definition: {
-        name: "non-db-fragment",
-        additionalContext: {},
-      },
-      $requiredOptions: {},
-    };
+    const nonDbFragmentDef = defineFragment<{}>("non-db-fragment")
+      .providesBaseService(() => ({}))
+      .build();
 
     await expect(
-      createDatabaseFragmentForTest(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        { definition: nonDbFragment as any, routes: [] },
-        {
-          adapter: { type: "kysely-sqlite" },
-        },
-      ),
+      buildDatabaseFragmentsTest()
+        .withTestAdapter({ type: "kysely-sqlite" })
+        .withFragment("nonDb", instantiate(nonDbFragmentDef).withConfig({}).withRoutes([]))
+        .build(),
     ).rejects.toThrow("Fragment 'non-db-fragment' does not have a database schema");
   });
 
   it("should reset database by truncating tables", async () => {
-    const { fragment, test } = await createDatabaseFragmentForTest(
-      { definition: testFragmentDef, routes: [] },
-      {
-        adapter: { type: "kysely-sqlite" },
-      },
-    );
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("test", instantiate(testFragmentDef).withConfig({}).withRoutes([]))
+      .build();
+
+    const fragment = fragments.test;
 
     // Create some users
     await fragment.services.createUser({
@@ -118,12 +114,12 @@ describe("createDatabaseFragmentForTest", () => {
   });
 
   it("should expose db property for direct ORM queries", async () => {
-    const { fragment, test } = await createDatabaseFragmentForTest(
-      { definition: testFragmentDef, routes: [] },
-      {
-        adapter: { type: "kysely-sqlite" },
-      },
-    );
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("test", instantiate(testFragmentDef).withConfig({}).withRoutes([]))
+      .build();
+
+    const fragment = fragments.test;
 
     // Test creating a record directly using test.db
     const userId = await fragment.db.create("users", {
@@ -171,29 +167,30 @@ describe("createDatabaseFragmentForTest", () => {
         });
     });
 
-    const authFragmentDef = defineFragmentWithDatabase<{}>("auth-test")
-      .withDatabase(authSchema)
-      .providesService(({ db }) => {
+    const authFragmentDef = defineFragment<{}>("auth-test")
+      .extend(withDatabase(authSchema))
+      .providesBaseService(({ deps }) => {
         return {
           createUser: async (email: string, passwordHash: string) => {
-            const id = await db.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 db.create("session", { userId, expiresAt });
+            const id = await deps.db.create("session", { userId, expiresAt });
             return { id: id.valueOf(), userId, expiresAt };
           },
         };
-      });
+      })
+      .build();
 
-    const { fragment, test } = await createDatabaseFragmentForTest(
-      { definition: authFragmentDef, routes: [] },
-      {
-        adapter: { type: "kysely-sqlite" },
-      },
-    );
+    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");
@@ -215,7 +212,7 @@ describe("createDatabaseFragmentForTest", () => {
   });
 });
 
-describe("createDatabaseFragmentsForTest", () => {
+describe("multi-fragment tests", () => {
   // Create two different schemas
   const userSchema = schema((s) => {
     return s.addTable("user", (t) => {
@@ -237,39 +234,41 @@ describe("createDatabaseFragmentsForTest", () => {
     });
   });
 
-  const userFragmentDef = defineFragmentWithDatabase<{}>("user-fragment")
-    .withDatabase(userSchema)
-    .providesService(({ db }) => {
+  const userFragmentDef = defineFragment<{}>("user-fragment")
+    .extend(withDatabase(userSchema))
+    .providesBaseService(({ deps }) => {
       return {
         createUser: async (data: { name: string; email: string }) => {
-          const id = await db.create("user", data);
+          const id = await deps.db.create("user", data);
           return { ...data, id: id.valueOf() };
         },
         getUsers: async () => {
-          const users = await db.find("user", (b) =>
+          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 = defineFragmentWithDatabase<{}>("post-fragment")
-    .withDatabase(postSchema)
-    .providesService(({ db }) => {
+  const postFragmentDef = defineFragment<{}>("post-fragment")
+    .extend(withDatabase(postSchema))
+    .providesBaseService(({ deps }) => {
       return {
         createPost: async (data: { title: string; userId: string }) => {
-          const id = await db.create("post", data);
+          const id = await deps.db.create("post", data);
           return { ...data, id: id.valueOf() };
         },
         getPosts: async () => {
-          const posts = await db.find("post", (b) =>
+          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 } },
@@ -279,19 +278,15 @@ describe("createDatabaseFragmentsForTest", () => {
 
   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 using array input
-      const { fragments, test } = await createDatabaseFragmentsForTest(
-        [
-          { definition: userFragmentDef, routes: [] },
-          { definition: postFragmentDef, routes: [] },
-        ],
-        { adapter },
-      );
-
-      const [userFragment, postFragment] = fragments;
+      // 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 userFragment!.services.createUser({
+      const user = await fragments.user.services.createUser({
         name: "John Doe",
         email: "john@example.com",
       });
@@ -303,7 +298,7 @@ describe("createDatabaseFragmentsForTest", () => {
       });
 
       // Create a post with the user's ID
-      const post = await postFragment!.services.createPost({
+      const post = await fragments.post.services.createPost({
         title: "My First Post",
         userId: user.id,
       });
@@ -315,10 +310,10 @@ describe("createDatabaseFragmentsForTest", () => {
       });
 
       // Verify data exists
-      const users = await userFragment!.services.getUsers();
+      const users = await fragments.user.services.getUsers();
       expect(users).toHaveLength(1);
 
-      const posts = await postFragment!.services.getPosts();
+      const posts = await fragments.post.services.getPosts();
       expect(posts).toHaveLength(1);
       expect(posts[0]!.userId).toBe(user.id);
 
@@ -329,7 +324,7 @@ describe("createDatabaseFragmentsForTest", () => {
 });
 
 describe("ExtractFragmentServices", () => {
-  it("extracts provided services from database fragment with .providesService()", () => {
+  it("extracts provided services from database fragment with new API", () => {
     const testSchema = schema((s) => s);
 
     interface ITestService {
@@ -337,12 +332,16 @@ describe("ExtractFragmentServices", () => {
       doSomethingElse: (input: number) => Promise<number>;
     }
 
-    const fragment = defineFragmentWithDatabase<{}>("test-db-fragment")
-      .withDatabase(testSchema)
-      .providesService("test", {
-        doSomething: async (input: string) => input.toUpperCase(),
-        doSomethingElse: async (input: number) => input * 2,
-      });
+    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>;
 
@@ -352,21 +351,22 @@ describe("ExtractFragmentServices", () => {
     }>();
   });
 
-  it("merges unnamed .providesService() and named .providesService() in database fragment", () => {
+  it("merges base services and provided services in database fragment", () => {
     const testSchema = schema((s) => s);
 
-    const fragment = defineFragmentWithDatabase<{}>("test-db-fragment")
-      .withDatabase(testSchema)
-      .providesService(() => ({
+    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 internal services and provided services
+    // Should include both base services and provided services
     expectTypeOf<Services>().toMatchObjectType<{
       internalService: () => Promise<string>;
       externalService: {