@fragno-dev/db 0.3.0 → 0.4.1

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

@@ -1,16 +1,20 @@
+import { describe, it, expect, vi, assert } from "vitest";
+
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { describe, it, expect, vi, assert } from "vitest";
-import { instantiate, defineFragment } from "@fragno-dev/core";
-import { defineRoutes } from "@fragno-dev/core/route";
-import { withDatabase } from "./with-database";
-import { schema, idColumn, column } from "./schema/create";
-import type { DatabaseAdapter } from "./adapters/adapters";
-import type { SimpleQueryInterface } from "./query/simple-query-interface";
+
 import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
+import { defineRoutes } from "@fragno-dev/core/route";
 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 { schema, idColumn, column } from "./schema/create";
+import { withDatabase } from "./with-database";
 
 // Create a test schema
 const testSchema = schema("test", (s) => {
@@ -30,62 +34,64 @@ 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()),
-        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 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(),
+  });
 
-      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(),
-        registerSchema: vi.fn(),
-        reset: vi.fn(),
-        getRetrievalOperations: vi.fn(() => []),
-        getMutationOperations: vi.fn(() => []),
-        getCreatedIds: vi.fn(() => []),
-        table: vi.fn(() => ({
-          findMany: vi.fn(),
-        })),
-        idempotencyKey: "test-nonce",
-        state: "building-retrieval",
-      };
-    }),
+  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",
+  });
+
+  const mockdb = {
+    createUnitOfWork: vi.fn(() => createMockUow()),
+    createBaseUnitOfWork: vi.fn(() => createMockUow()),
     type: "mock",
   } as unknown as SimpleQueryInterface<TestSchema>;
 
@@ -167,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();
 
@@ -180,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", () => {
@@ -328,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")
@@ -380,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();
 
@@ -416,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);
     });
   });
 
@@ -432,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");
@@ -552,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");
@@ -574,7 +597,8 @@ describe("db-fragment-instantiator", () => {
       try {
         const fragment = instantiate(definition).withOptions({}).build();
         expect(fragment.$internal.options.databaseAdapter).toBeDefined();
-        expect(fragment.$internal.deps.db).toBeDefined();
+        expect(fragment.$internal.deps.databaseAdapter).toBeDefined();
+        expect(fragment.$internal.deps.createUnitOfWork).toBeDefined();
       } finally {
         if (previous === undefined) {
           delete process.env["FRAGNO_DATA_DIR"];

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

@@ -1,14 +1,17 @@
-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 { SqlAdapter } from "./adapters/generic-sql/generic-sql-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

package/src/dispatchers/cloudflare-do/dispatcher.ts

@@ -0,0 +1,204 @@
+import { DurableHooksLogger } from "../../hooks/durable-hooks-logger";
+import type { DurableHooksProcessor } from "../../hooks/durable-hooks-processor";
+import type { HookNotifyContext, HookNotifySource } from "../../hooks/hooks";
+
+type AlarmStorage = {
+  setAlarm?: (timestamp: number | Date) => Promise<void>;
+  deleteAlarm?: () => Promise<void>;
+};
+
+export type DurableHooksDispatcherDurableObjectState = {
+  readonly storage: AlarmStorage;
+};
+
+export type DurableHooksDispatcherDurableObjectHandler = {
+  fetch?: (request: Request) => Promise<Response>;
+  notify?: (context: HookNotifyContext) => void | Promise<void>;
+  alarm?: () => Promise<void>;
+};
+
+export type DurableHooksDispatcherDurableObjectFactory<TEnv = unknown> = (
+  state: DurableHooksDispatcherDurableObjectState,
+  env: TEnv,
+) => DurableHooksDispatcherDurableObjectHandler;
+
+export type DurableHooksDispatcherDurableObjectOptions<TEnv = unknown> = {
+  createProcessor: (context: {
+    state: DurableHooksDispatcherDurableObjectState;
+    env: TEnv;
+  }) => DurableHooksProcessor;
+  onProcessError?: (error: unknown) => void;
+};
+
+export function createDurableHooksDispatcherDurableObject<TEnv>(
+  options: DurableHooksDispatcherDurableObjectOptions<TEnv>,
+): DurableHooksDispatcherDurableObjectFactory<TEnv> {
+  return (state, env) => {
+    const processor = options.createProcessor({ state, env });
+    const onProcessError =
+      options.onProcessError ??
+      ((error: unknown) => {
+        DurableHooksLogger.error("Durable hooks dispatcher error", {
+          namespace: processor.namespace,
+          fields: { error: DurableHooksLogger.toErrorMessage(error) },
+        });
+      });
+    const safeOnProcessError = (error: unknown) => {
+      void Promise.resolve()
+        .then(() => onProcessError(error))
+        .catch((callbackError) => {
+          DurableHooksLogger.error("Durable hooks dispatcher onProcessError callback failed", {
+            namespace: processor.namespace,
+            fields: { error: DurableHooksLogger.toErrorMessage(callbackError) },
+          });
+        });
+    };
+    const rawSetAlarm = state.storage.setAlarm;
+    const rawDeleteAlarm = state.storage.deleteAlarm;
+
+    if (!rawSetAlarm) {
+      throw new Error(
+        "Durable hooks dispatcher requires state.storage.setAlarm to schedule alarms.",
+      );
+    }
+    const setAlarm = rawSetAlarm.bind(state.storage);
+    const deleteAlarm = rawDeleteAlarm?.bind(state.storage);
+
+    let processing = false;
+    let queued = false;
+    let currentPromise: Promise<void> | undefined;
+    let alarmRefreshQueued = false;
+    let alarmRefreshPromise: Promise<void> | undefined;
+    let latestAlarmRefreshSource: HookNotifySource = "request";
+
+    const runProcess = () => {
+      if (processing) {
+        queued = true;
+        return currentPromise ?? Promise.resolve();
+      }
+
+      processing = true;
+      currentPromise = (async () => {
+        try {
+          do {
+            queued = false;
+            try {
+              const startedAt = Date.now();
+              DurableHooksLogger.debug("Durable hooks alarm start", {
+                namespace: processor.namespace,
+              });
+              const processed = await processor.processDue();
+              DurableHooksLogger.debug("Durable hooks alarm processed", {
+                namespace: processor.namespace,
+                fields: {
+                  processed,
+                  ms: Date.now() - startedAt,
+                },
+              });
+            } catch (error) {
+              DurableHooksLogger.error("Durable hooks alarm failed", {
+                namespace: processor.namespace,
+                fields: { error: DurableHooksLogger.toErrorMessage(error) },
+              });
+              safeOnProcessError(error);
+            }
+          } while (queued);
+        } finally {
+          processing = false;
+          currentPromise = undefined;
+        }
+      })();
+
+      return currentPromise;
+    };
+
+    const scheduleNextAlarm = async (source: HookNotifySource) => {
+      DurableHooksLogger.debug("Durable hooks alarm schedule requested", {
+        namespace: processor.namespace,
+        fields: {
+          source,
+        },
+      });
+      const nextWakeAt = await processor.getNextWakeAt();
+      if (!nextWakeAt) {
+        await deleteAlarm?.();
+        DurableHooksLogger.debug("Durable hooks alarm cleared", {
+          namespace: processor.namespace,
+          fields: {
+            source,
+          },
+        });
+        return;
+      }
+
+      const now = Date.now();
+      const scheduledAt = new Date(Math.max(nextWakeAt.getTime(), now));
+      await setAlarm(scheduledAt);
+      DurableHooksLogger.debug("Durable hooks alarm scheduled", {
+        namespace: processor.namespace,
+        fields: {
+          source,
+          nextWakeAt: nextWakeAt.toISOString(),
+          scheduledAt: scheduledAt.toISOString(),
+        },
+      });
+    };
+
+    const refreshAlarm = (source: HookNotifySource): Promise<void> => {
+      latestAlarmRefreshSource = source;
+      if (alarmRefreshPromise) {
+        alarmRefreshQueued = true;
+        return alarmRefreshPromise;
+      }
+
+      alarmRefreshPromise = (async () => {
+        do {
+          alarmRefreshQueued = false;
+          await scheduleNextAlarm(latestAlarmRefreshSource);
+        } while (alarmRefreshQueued);
+      })().finally(() => {
+        alarmRefreshPromise = undefined;
+      });
+
+      return alarmRefreshPromise;
+    };
+
+    DurableHooksLogger.debug("Durable hooks dispatcher init", {
+      namespace: processor.namespace,
+    });
+    void refreshAlarm("alarm").catch((error) => {
+      DurableHooksLogger.error("Durable hooks alarm schedule failed", {
+        namespace: processor.namespace,
+        fields: { error: DurableHooksLogger.toErrorMessage(error) },
+      });
+      safeOnProcessError(error);
+    });
+
+    return {
+      notify: (context) => {
+        const schedulePromise = refreshAlarm(context.source);
+        const handledPromise = schedulePromise.catch((error) => {
+          DurableHooksLogger.error("Durable hooks alarm schedule failed", {
+            namespace: processor.namespace,
+            fields: { error: DurableHooksLogger.toErrorMessage(error) },
+          });
+          safeOnProcessError(error);
+        });
+        if (context.waitUntil) {
+          context.waitUntil(handledPromise);
+        } else {
+          void handledPromise;
+        }
+        return handledPromise;
+      },
+      alarm: async () => {
+        try {
+          await runProcess();
+          await refreshAlarm("alarm");
+        } catch (error) {
+          safeOnProcessError(error);
+        }
+      },
+    };
+  };
+}