@fragno-dev/db 0.1.14 → 0.1.15

package/src/query/unit-of-work-multi-schema.test.ts

@@ -1,64 +0,0 @@
-import { describe, test } from "vitest";
-import { schema, column, idColumn, referenceColumn } from "../schema/create";
-import type { UOWCompiler, UOWExecutor, UOWDecoder } from "./unit-of-work";
-import { createUnitOfWork } from "./unit-of-work";
-
-// Test schemas
-const schema1 = schema((s) =>
-  s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", column("string"))),
-);
-
-const schema2 = schema((s) =>
-  s.addTable("posts", (t) =>
-    t
-      .addColumn("id", idColumn())
-      .addColumn("userId", referenceColumn())
-      .addColumn("title", column("string")),
-  ),
-);
-
-// Mock compiler, executor, and decoder
-const mockCompiler: UOWCompiler<string> = {
-  compileRetrievalOperation: (op) => `RETRIEVE-${op.type}-${op.table.name}-${op.indexName}`,
-  compileMutationOperation: (op) => ({
-    query: `MUTATE-${op.type}`,
-    expectedAffectedRows: null,
-  }),
-};
-
-const mockExecutor: UOWExecutor<string, string> = {
-  executeRetrievalPhase: async (queries) => queries.map((q) => `RESULT-${q}`),
-  executeMutationPhase: async () => ({ success: true, createdInternalIds: [] }),
-};
-
-const mockDecoder: UOWDecoder<string> = (rawResults) => rawResults.map((r) => ({ decoded: r }));
-
-describe("Multi-Schema Unit of Work", () => {
-  test("chained operations on view accumulate result types", async () => {
-    const uow = createUnitOfWork(schema1, mockCompiler, mockExecutor, mockDecoder);
-
-    // Chain multiple finds on same view
-    const _view1 = uow
-      .forSchema(schema1)
-      .find("users", (b) => b.whereIndex("primary").select(["id"]))
-      .find("users", (b) => b.whereIndex("primary").select(["name"]));
-
-    const _view2 = uow
-      .forSchema(schema2)
-      .find("posts", (b) => b.whereIndex("primary").select(["title"]));
-
-    await uow.executeRetrieve();
-
-    // const [[users1, users2], [posts]] = await Promise.all([view1.retrievalPhase, view2.retrievalPhase]);
-
-    // const [users1, users2] = await view1.retrievalPhase;
-
-    // // expect(users1)
-
-    // // expectTypeOf(users1).toMatchObjectType<{ id: FragnoId; name: string }[]>();
-    // console.log({ users1, users2 });
-
-    // const [posts] = await view2.retrievalPhase;
-    // console.log({ posts });
-  });
-});

package/src/shared/settings-schema.ts

@@ -1,61 +0,0 @@
-import type { AbstractQuery } from "../query/query";
-import { schema, idColumn, column, type FragnoId } from "../schema/create";
-
-export const SETTINGS_TABLE_NAME = "fragno_db_settings" as const;
-export const SETTINGS_NAMESPACE = "fragno-db-settings" as const;
-
-export const settingsSchema = schema((s) => {
-  return s.addTable(SETTINGS_TABLE_NAME, (t) => {
-    return t
-      .addColumn("id", idColumn())
-      .addColumn("key", column("string"))
-      .addColumn("value", column("string"))
-      .createIndex("unique_key", ["key"], { unique: true });
-  });
-});
-
-export function createSettingsManager(
-  // oxlint-disable-next-line no-explicit-any
-  queryEngine: AbstractQuery<typeof settingsSchema, any>,
-  namespace: string,
-) {
-  return {
-    async get(key: string): Promise<{ id: FragnoId; key: string; value: string } | undefined> {
-      const uow = queryEngine
-        .createUnitOfWork()
-        .find(SETTINGS_TABLE_NAME, (b) =>
-          b.whereIndex("unique_key", (eb) => eb("key", "=", `${namespace}.${key}`)),
-        );
-      const [[result]] = await uow.executeRetrieve();
-      return result; // Safe: result can be undefined if key doesn't exist
-    },
-
-    async set(key: string, value: string) {
-      const uow = queryEngine
-        .createUnitOfWork("createSettingsManager#set")
-        .find(SETTINGS_TABLE_NAME, (b) =>
-          b.whereIndex("unique_key", (eb) => eb("key", "=", `${namespace}.${key}`)),
-        );
-      const [[existing]] = await uow.executeRetrieve();
-
-      if (existing) {
-        uow.update(SETTINGS_TABLE_NAME, existing.id, (b) => b.set({ value }).check());
-      } else {
-        uow.create(SETTINGS_TABLE_NAME, {
-          key: `${namespace}.${key}`,
-          value,
-        });
-      }
-
-      const { success } = await uow.executeMutations();
-
-      if (!success) {
-        throw new Error("Failed to set schema version");
-      }
-    },
-
-    async delete(id: FragnoId) {
-      await queryEngine.delete(SETTINGS_TABLE_NAME, id);
-    },
-  };
-}

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

@@ -1,102 +0,0 @@
-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

@@ -1,182 +0,0 @@
-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();
-    });
-  });
-});