@fragno-dev/db 0.1.13 → 0.1.14

package/src/uow-context-integration.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect } from "vitest";
+import { defineFragmentWithDatabase } from "./fragment";
+import { createFragment } from "@fragno-dev/core";
+import { schema, column, idColumn } from "./schema/create";
+
+describe("UOW Context Integration", () => {
+  it("should bind services to use serviceContext", () => {
+    // Create a schema
+    const testSchema = schema((s) => {
+      return s.addTable("user", (t) => {
+        return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+      });
+    });
+
+    // Define fragment with service that uses this.getUnitOfWork()
+    const fragmentDef = defineFragmentWithDatabase<{}>("test-fragment")
+      .withDatabase(testSchema, "test")
+      .providesService(({ defineService }) =>
+        defineService({
+          createUser: function (name: string) {
+            const uow = this.getUnitOfWork(testSchema);
+            const userId = uow.create("user", { name });
+            return { userId: userId.valueOf(), name };
+          },
+        }),
+      );
+
+    // Mock database adapter
+    const mockSchemaView = {
+      create: () => ({ valueOf: () => 1 }),
+    };
+    const mockUow = {
+      forSchema: () => mockSchemaView,
+    };
+    const mockAdapter = {
+      createQueryEngine: () => ({
+        createUnitOfWork: () => mockUow,
+      }),
+    };
+
+    // Create fragment instance - services should be bound
+    const fragment = createFragment(fragmentDef, {}, [], {
+      mountRoute: "/api/test",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      databaseAdapter: mockAdapter as any,
+    });
+
+    // Verify services are defined
+    expect(fragment.services).toBeDefined();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect((fragment.services as any).createUser).toBeDefined();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(typeof (fragment.services as any).createUser).toBe("function");
+  });
+
+  it("should bind providesService services properly", () => {
+    const schema1 = schema((s) => {
+      return s.addTable("post", (t) => {
+        return t.addColumn("id", idColumn()).addColumn("title", column("string"));
+      });
+    });
+
+    // Fragment with providesService
+    const fragmentDef = defineFragmentWithDatabase<{}>("fragment1")
+      .withDatabase(schema1, "fragment1")
+      .providesService(({ defineService }) =>
+        defineService({
+          createPost: function (title: string) {
+            const uow = this.getUnitOfWork(schema1);
+            const postId = uow.create("post", { title });
+            return { postId: postId.valueOf(), title };
+          },
+        }),
+      );
+
+    // Mock adapter
+    const mockSchemaView = {
+      create: () => ({ valueOf: () => 2 }),
+    };
+    const mockUow = {
+      forSchema: () => mockSchemaView,
+    };
+    const mockAdapter = {
+      createQueryEngine: () => ({
+        createUnitOfWork: () => mockUow,
+      }),
+    };
+
+    // Create fragment
+    const fragment = createFragment(fragmentDef, {}, [], {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      databaseAdapter: mockAdapter as any,
+    });
+
+    // Verify service is properly bound
+    expect(fragment.services).toBeDefined();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect((fragment.services as any).createPost).toBeDefined();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(typeof (fragment.services as any).createPost).toBe("function");
+  });
+});

package/src/uow-context.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect } from "vitest";
+import { uowStorage, serviceContext, withUnitOfWork } from "./fragment";
+import type { IUnitOfWorkBase } from "./query/unit-of-work";
+import { schema, idColumn } from "./schema/create";
+
+// Create a simple test schema for tests
+const testSchema = schema((s) => {
+  return s.addTable("test", (t) => {
+    return t.addColumn("id", idColumn());
+  });
+});
+
+describe("UOW Context", () => {
+  describe("serviceContext.getUnitOfWork", () => {
+    it("should throw error when called outside context", () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      expect(() => serviceContext.getUnitOfWork(testSchema as any)).toThrow(
+        "No UnitOfWork in context. Service must be called within a route handler.",
+      );
+    });
+
+    it("should return scoped UOW when called inside withUnitOfWork", async () => {
+      const mockSchemaView = { test: "schema-view" };
+      const mockUow = {
+        test: "uow",
+        forSchema: () => mockSchemaView,
+      } as unknown as IUnitOfWorkBase;
+
+      await withUnitOfWork(mockUow, () => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const uow = serviceContext.getUnitOfWork(testSchema as any);
+        expect(uow).toBe(mockSchemaView);
+      });
+    });
+
+    it("should allow nested withUnitOfWork calls", async () => {
+      const view1 = { id: 1 };
+      const view2 = { id: 2 };
+      const uow1 = {
+        id: 1,
+        forSchema: () => view1,
+      } as unknown as IUnitOfWorkBase;
+      const uow2 = {
+        id: 2,
+        forSchema: () => view2,
+      } as unknown as IUnitOfWorkBase;
+
+      await withUnitOfWork(uow1, async () => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        expect(serviceContext.getUnitOfWork(testSchema as any)).toBe(view1);
+
+        await withUnitOfWork(uow2, () => {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          expect(serviceContext.getUnitOfWork(testSchema as any)).toBe(view2);
+        });
+
+        // Should be back to uow1 after nested context
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        expect(serviceContext.getUnitOfWork(testSchema as any)).toBe(view1);
+      });
+    });
+
+    it("should isolate UOW between parallel async calls", async () => {
+      const view1 = { id: 1 };
+      const view2 = { id: 2 };
+      const uow1 = {
+        id: 1,
+        forSchema: () => view1,
+      } as unknown as IUnitOfWorkBase;
+      const uow2 = {
+        id: 2,
+        forSchema: () => view2,
+      } as unknown as IUnitOfWorkBase;
+
+      const promise1 = withUnitOfWork(uow1, async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return serviceContext.getUnitOfWork(testSchema as any);
+      });
+
+      const promise2 = withUnitOfWork(uow2, async () => {
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return serviceContext.getUnitOfWork(testSchema as any);
+      });
+
+      const [result1, result2] = await Promise.all([promise1, promise2]);
+
+      expect(result1).toBe(view1);
+      expect(result2).toBe(view2);
+    });
+  });
+
+  describe("uowStorage", () => {
+    it("should return undefined when no UOW is stored", () => {
+      const stored = uowStorage.getStore();
+      expect(stored).toBeUndefined();
+    });
+
+    it("should store and retrieve UOW", async () => {
+      const mockUow = { test: "uow" } as unknown as IUnitOfWorkBase;
+
+      await withUnitOfWork(mockUow, () => {
+        const stored = uowStorage.getStore();
+        expect(stored).toBe(mockUow);
+      });
+
+      // Should be undefined after exiting context
+      const stored = uowStorage.getStore();
+      expect(stored).toBeUndefined();
+    });
+  });
+
+  describe("withUnitOfWork", () => {
+    it("should execute callback with UOW in context", async () => {
+      const mockSchemaView = { test: "schema-view" };
+      const mockUow = {
+        test: "uow",
+        forSchema: () => mockSchemaView,
+      } as unknown as IUnitOfWorkBase;
+      let called = false;
+
+      await withUnitOfWork(mockUow, () => {
+        called = true;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        expect(serviceContext.getUnitOfWork(testSchema as any)).toBe(mockSchemaView);
+      });
+
+      expect(called).toBe(true);
+    });
+
+    it("should return callback result", async () => {
+      const mockUow = { test: "uow" } as unknown as IUnitOfWorkBase;
+      const result = await withUnitOfWork(mockUow, () => "test-result");
+
+      expect(result).toBe("test-result");
+    });
+
+    it("should handle async callbacks", async () => {
+      const mockUow = { test: "uow" } as unknown as IUnitOfWorkBase;
+
+      const result = await withUnitOfWork(mockUow, async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return "async-result";
+      });
+
+      expect(result).toBe("async-result");
+    });
+
+    it("should propagate errors from callback", async () => {
+      const mockUow = { test: "uow" } as unknown as IUnitOfWorkBase;
+
+      let error: Error | null = null;
+      try {
+        await withUnitOfWork(mockUow, () => {
+          throw new Error("test error");
+        });
+      } catch (e) {
+        error = e as Error;
+      }
+
+      expect(error).toBeInstanceOf(Error);
+      expect(error?.message).toBe("test error");
+    });
+
+    it("should clean up context after error", async () => {
+      const mockUow = { test: "uow" } as unknown as IUnitOfWorkBase;
+
+      try {
+        await withUnitOfWork(mockUow, () => {
+          throw new Error("test error");
+        });
+      } catch {
+        // Expected error
+      }
+
+      // UOW should no longer be in context
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      expect(() => serviceContext.getUnitOfWork(testSchema as any)).toThrow();
+    });
+  });
+});

package/src/fragment.test.ts

@@ -1,341 +0,0 @@
-import { test, expect, describe, expectTypeOf } from "vitest";
-import { defineFragmentWithDatabase, type FragnoPublicConfigWithDatabase } from "./fragment";
-import { createFragment, defineRoute, type FragnoPublicClientConfig } from "@fragno-dev/core";
-import { createClientBuilder } from "@fragno-dev/core/client";
-import { schema, idColumn, column } from "./schema/create";
-import type { AbstractQuery } from "./query/query";
-import type { DatabaseAdapter } from "./mod";
-import { z } from "zod";
-import {
-  fragnoDatabaseAdapterNameFakeSymbol,
-  fragnoDatabaseAdapterVersionFakeSymbol,
-} from "./adapters/adapters";
-
-type Empty = Record<never, never>;
-
-const mockDatabaseAdapter: DatabaseAdapter = {
-  [fragnoDatabaseAdapterNameFakeSymbol]: "mock",
-  [fragnoDatabaseAdapterVersionFakeSymbol]: 0,
-  close: () => Promise.resolve(),
-  createQueryEngine: () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return {} as any;
-  },
-  getSchemaVersion: () => Promise.resolve("0"),
-  createMigrationEngine: () => {
-    throw new Error("Not implemented");
-  },
-  createSchemaGenerator: () => {
-    throw new Error("Not implemented");
-  },
-  isConnectionHealthy: () => Promise.resolve(true),
-};
-
-describe("DatabaseFragmentBuilder", () => {
-  describe("Type inference", () => {
-    test("defineFragmentWithDatabase infers schema type from withDatabase", () => {
-      const _testSchema = schema((s) =>
-        s.addTable("users", (t) =>
-          t.addColumn("id", idColumn()).addColumn("name", column("string")),
-        ),
-      );
-
-      const _fragment = defineFragmentWithDatabase("test").withDatabase(_testSchema);
-
-      // Type check that withDatabase returns a builder with the schema
-      expectTypeOf(_fragment.definition.name).toEqualTypeOf<string>();
-    });
-
-    test("withDatabase correctly transforms schema type", () => {
-      const _testSchema1 = schema((s) =>
-        s.addTable("users", (t) =>
-          t.addColumn("id", idColumn()).addColumn("name", column("string")),
-        ),
-      );
-
-      const _testSchema2 = schema((s) =>
-        s.addTable("posts", (t) =>
-          t.addColumn("id", idColumn()).addColumn("title", column("string")),
-        ),
-      );
-
-      const fragment1 = defineFragmentWithDatabase("test").withDatabase(_testSchema1);
-      const fragment2 = fragment1.withDatabase(_testSchema2);
-
-      // Type check that we can chain withDatabase
-      expectTypeOf(fragment1.definition.name).toEqualTypeOf<string>();
-      expectTypeOf(fragment2.definition.name).toEqualTypeOf<string>();
-    });
-
-    test("withDependencies has access to config, fragnoConfig, and orm", () => {
-      const _testSchema = schema((s) =>
-        s.addTable("users", (t) =>
-          t.addColumn("id", idColumn()).addColumn("name", column("string")),
-        ),
-      );
-
-      const _fragment = defineFragmentWithDatabase("test")
-        .withDatabase(_testSchema)
-        .withDependencies(({ fragnoConfig, orm }) => {
-          expectTypeOf(fragnoConfig).toEqualTypeOf<{ mountRoute?: string }>();
-          expectTypeOf(orm).toEqualTypeOf<AbstractQuery<typeof _testSchema>>();
-
-          return {
-            userService: {
-              getUser: async (id: string) => ({ id, name: "Test" }),
-            },
-          };
-        });
-
-      // Type check that the fragment has the expected structure
-      expectTypeOf(_fragment.definition.name).toEqualTypeOf<string>();
-    });
-
-    test("withServices has access to config, fragnoConfig, deps, and orm", () => {
-      const _testSchema = schema((s) =>
-        s.addTable("users", (t) =>
-          t.addColumn("id", idColumn()).addColumn("name", column("string")),
-        ),
-      );
-
-      const _fragment = defineFragmentWithDatabase("test")
-        .withDatabase(_testSchema)
-        .withDependencies(({ orm }) => ({
-          userRepo: {
-            create: (name: string) => orm.create("users", { name }),
-          },
-        }))
-        .withServices(({ fragnoConfig, deps, orm }) => {
-          expectTypeOf(fragnoConfig).toEqualTypeOf<{ mountRoute?: string }>();
-          expectTypeOf(deps).toEqualTypeOf<{
-            userRepo: {
-              create: (name: string) => ReturnType<AbstractQuery<typeof _testSchema>["create"]>;
-            };
-          }>();
-          expectTypeOf(orm).toEqualTypeOf<AbstractQuery<typeof _testSchema>>();
-
-          return {
-            cacheService: {
-              get: (_key: string) => "cached",
-            },
-          };
-        });
-
-      // Type check that the fragment has the expected structure
-      expectTypeOf(_fragment.definition.name).toEqualTypeOf<string>();
-    });
-  });
-
-  describe("Builder pattern", () => {
-    test("Builder methods return new instances", () => {
-      const _testSchema1 = schema((s) =>
-        s.addTable("users", (t) =>
-          t.addColumn("id", idColumn()).addColumn("name", column("string")),
-        ),
-      );
-
-      const _testSchema2 = schema((s) =>
-        s.addTable("posts", (t) =>
-          t.addColumn("id", idColumn()).addColumn("title", column("string")),
-        ),
-      );
-
-      const builder1 = defineFragmentWithDatabase("test");
-      const builder2 = builder1.withDatabase(_testSchema1);
-      const builder3 = builder2.withDatabase(_testSchema2);
-      const builder4 = builder3.withDependencies(() => ({ dep1: "value1" }));
-      const builder5 = builder4.withServices(() => ({ service1: "value1" }));
-
-      expect(builder1).not.toBe(builder2);
-      expect(builder2).not.toBe(builder3);
-      expect(builder3).not.toBe(builder4);
-      expect(builder4).not.toBe(builder5);
-    });
-
-    test("Each builder step preserves previous configuration", () => {
-      const _testSchema = schema((s) =>
-        s.addTable("users", (t) =>
-          t.addColumn("id", idColumn()).addColumn("name", column("string")),
-        ),
-      );
-
-      const fragment = defineFragmentWithDatabase("my-db-lib")
-        .withDatabase(_testSchema)
-        .withDependencies(({ orm }) => ({
-          client: "test client",
-          orm,
-        }))
-        .withServices(({ deps }) => ({
-          service: `Service using ${deps.client}`,
-        }));
-
-      expect(fragment.definition.name).toBe("my-db-lib");
-      expect(fragment.definition.dependencies).toBeDefined();
-      expect(fragment.definition.services).toBeDefined();
-    });
-  });
-
-  describe("Fragment instantiation", () => {
-    test("createFragment works with database adapter", async () => {
-      const testSchema = schema((s) =>
-        s.addTable("users", (t) =>
-          t.addColumn("id", idColumn()).addColumn("name", column("string")),
-        ),
-      );
-
-      const fragmentDef = defineFragmentWithDatabase("test-db")
-        .withDatabase(testSchema)
-        .withDependencies(({ orm }) => ({
-          userService: {
-            createUser: (name: string) => orm.create("users", { name }),
-          },
-        }))
-        .withServices(() => ({
-          logger: { log: (s: string) => console.log(s) },
-        }));
-
-      const options: FragnoPublicConfigWithDatabase = {
-        databaseAdapter: mockDatabaseAdapter,
-      };
-
-      const fragment = createFragment(fragmentDef, {}, [], options);
-
-      expect(fragment.config.name).toBe("test-db");
-      expect(fragment.deps).toHaveProperty("userService");
-      expect(fragment.services).toHaveProperty("logger");
-    });
-
-    test("throws error when database adapter is missing from dependencies", () => {
-      const testSchema = schema((s) =>
-        s.addTable("users", (t) =>
-          t.addColumn("id", idColumn()).addColumn("name", column("string")),
-        ),
-      );
-
-      const fragmentDef = defineFragmentWithDatabase("test-db")
-        .withDatabase(testSchema)
-        .withDependencies(() => ({
-          service: "test",
-        }));
-
-      expect(() => {
-        // @ts-expect-error - Test case
-        createFragment(fragmentDef, {}, [], {});
-      }).toThrow(/requires a database adapter/);
-    });
-
-    test("throws error when database adapter is missing from services", () => {
-      const testSchema = schema((s) =>
-        s.addTable("users", (t) =>
-          t.addColumn("id", idColumn()).addColumn("name", column("string")),
-        ),
-      );
-
-      const fragmentDef = defineFragmentWithDatabase("test-db")
-        .withDatabase(testSchema)
-        .withDependencies(() => ({
-          service: "test",
-        }))
-        .withServices(() => ({
-          serviceValue: "test",
-        }));
-
-      const options: FragnoPublicConfigWithDatabase = {
-        databaseAdapter: mockDatabaseAdapter,
-      };
-
-      // Services are called after dependencies, so this should work
-      const fragment = createFragment(fragmentDef, {}, [], options);
-      expect(fragment.services).toHaveProperty("serviceValue");
-    });
-
-    test("throws error when schema is not provided via withDatabase", () => {
-      const fragmentDef = defineFragmentWithDatabase<Empty>("test-db").withDependencies(() => ({
-        service: "test",
-      }));
-
-      const options: FragnoPublicConfigWithDatabase = {
-        databaseAdapter: mockDatabaseAdapter,
-      };
-
-      expect(() => {
-        createFragment(fragmentDef, {}, [], options);
-      }).toThrow(/requires a schema/);
-    });
-
-    test("orm is accessible in both dependencies and services", async () => {
-      const testSchema = schema((s) =>
-        s.addTable("users", (t) =>
-          t.addColumn("id", idColumn()).addColumn("name", column("string")),
-        ),
-      );
-
-      let depsOrm: AbstractQuery<typeof testSchema> | undefined;
-      let servicesOrm: AbstractQuery<typeof testSchema> | undefined;
-
-      const fragmentDef = defineFragmentWithDatabase("test-db")
-        .withDatabase(testSchema)
-        .withDependencies(({ orm }) => {
-          depsOrm = orm;
-          return { dep: "value" };
-        })
-        .withServices(({ orm }) => {
-          servicesOrm = orm;
-          return { service: "value" };
-        });
-
-      const options: FragnoPublicConfigWithDatabase = {
-        databaseAdapter: mockDatabaseAdapter,
-      };
-
-      createFragment(fragmentDef, {}, [], options);
-
-      expect(depsOrm).toBeDefined();
-      expect(servicesOrm).toBeDefined();
-    });
-  });
-
-  describe("Client builder integration", () => {
-    test("createClientBuilder works with database fragment", () => {
-      const testSchema = schema((s) =>
-        s.addTable("users", (t) =>
-          t.addColumn("id", idColumn()).addColumn("name", column("string")),
-        ),
-      );
-
-      const fragmentDef = defineFragmentWithDatabase("test-db")
-        .withDatabase(testSchema)
-        .withServices(({ orm }) => ({
-          getUserById: (id: string) =>
-            orm.findFirst("users", (b) => b.whereIndex("primary", (eb) => eb("id", "=", id))),
-        }));
-
-      const routes = [
-        defineRoute({
-          method: "GET",
-          path: "/users",
-          outputSchema: z.array(
-            z.object({
-              id: z.string(),
-              name: z.string(),
-            }),
-          ),
-          handler: async (_ctx, { json }) => json([]),
-        }),
-      ] as const;
-
-      const clientConfig: FragnoPublicClientConfig = {
-        baseUrl: "http://localhost:3000",
-      };
-
-      const builder = createClientBuilder(fragmentDef, clientConfig, routes);
-
-      expect(builder).toBeDefined();
-      expectTypeOf(builder.createHook).toBeFunction();
-
-      const useUsers = builder.createHook("/users");
-      expect(useUsers).toHaveProperty("route");
-      expect(useUsers.route.path).toBe("/users");
-    });
-  });
-});