@fragno-dev/db 0.3.0 → 0.4.1

package/src/dispatchers/node/index.ts

@@ -1,87 +1,50 @@
-import type { DurableHooksProcessor } from "../../hooks/durable-hooks-processor";
+import { createDurableHooksProcessorGroup } from "../../hooks/durable-hooks-processor";
+import { getDurableHooksRuntimeByToken } from "../../hooks/durable-hooks-runtime";
+import type { AnyFragnoInstantiatedDatabaseFragment } from "../../mod";
+import { createDurableHooksDispatcher, type DurableHooksDispatcher } from "./dispatcher";
 
-export type DurableHooksDispatcher = {
-  wake: () => Promise<void>;
-  startPolling: () => void;
-  stopPolling: () => void;
-};
-
-export type DurableHooksDispatcherOptions = {
-  processor: DurableHooksProcessor;
+export type DurableHooksProcessorOptions = {
   pollIntervalMs?: number;
   onError?: (error: unknown) => void;
 };
 
-export function createDurableHooksDispatcher(
-  options: DurableHooksDispatcherOptions,
-): DurableHooksDispatcher {
-  const pollIntervalMs = options.pollIntervalMs ?? 5000;
-  const onError =
-    options.onError ??
-    ((error: unknown) => {
-      console.error("Durable hooks dispatcher error", error);
-    });
-  let timer: ReturnType<typeof setInterval> | undefined;
-  let processing = false;
-  let queued = false;
-  let currentPromise: Promise<void> | undefined;
-
-  const runProcess = () => {
-    if (processing) {
-      queued = true;
-      return currentPromise ?? Promise.resolve();
-    }
+export type { DurableHooksDispatcher };
 
-    processing = true;
-    currentPromise = (async () => {
-      do {
-        queued = false;
-        try {
-          await options.processor.process();
-        } catch (error) {
-          onError(error);
-        }
-      } while (queued);
-      processing = false;
-    })();
+type DurableHooksInternal = {
+  durableHooksToken?: object;
+};
 
-    return currentPromise;
+export function createDurableHooksProcessor(
+  fragments: readonly AnyFragnoInstantiatedDatabaseFragment[],
+  options: DurableHooksProcessorOptions = {},
+): DurableHooksDispatcher {
+  const processor = createDurableHooksProcessorGroup(fragments, {
+    onError: options.onError,
+  });
+  const dispatcher = createDurableHooksDispatcher({
+    processor,
+    pollIntervalMs: options.pollIntervalMs,
+    onError: options.onError,
+  });
+
+  const notifier = {
+    notify: (context: Parameters<typeof dispatcher.notify>[0]) => {
+      dispatcher.notify(context);
+    },
   };
 
-  const poll = async () => {
-    try {
-      const nextWakeAt = await options.processor.getNextWakeAt();
-      if (!nextWakeAt) {
-        return;
-      }
-      if (Date.now() >= nextWakeAt.getTime()) {
-        await runProcess();
-      }
-    } catch (error) {
-      onError(error);
+  for (const fragment of fragments) {
+    const internal = fragment.$internal as DurableHooksInternal | undefined;
+    const durableHooksToken = internal?.durableHooksToken;
+    if (!durableHooksToken) {
+      continue;
     }
-  };
-
-  return {
-    wake: async () => {
-      await runProcess();
-    },
-    startPolling: () => {
-      if (timer) {
-        return;
-      }
-
-      timer = setInterval(() => {
-        void poll();
-      }, pollIntervalMs);
-    },
-    stopPolling: () => {
-      if (!timer) {
-        return;
-      }
+    const runtime = getDurableHooksRuntimeByToken(durableHooksToken);
+    if (!runtime) {
+      continue;
+    }
+    runtime.config.notifier = notifier;
+  }
 
-      clearInterval(timer);
-      timer = undefined;
-    },
-  };
+  return dispatcher;
 }

package/src/durable-hooks.test.ts

@@ -0,0 +1,80 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import SQLite from "better-sqlite3";
+import { SqliteDialect } from "kysely";
+
+import { defineFragment, instantiate } from "@fragno-dev/core";
+
+import { BetterSQLite3DriverConfig } from "./adapters/generic-sql/driver-config";
+import { SqlAdapter } from "./adapters/generic-sql/generic-sql-adapter";
+import { getDurableHooksService } from "./durable-hooks";
+import { internalSchema } from "./fragments/internal-fragment";
+import { getInternalFragment } from "./internal/adapter-registry";
+import { schema, column, idColumn } from "./schema/create";
+import { withDatabase } from "./with-database";
+
+const testSchema = schema("test", (s) =>
+  s.addTable("items", (t) => t.addColumn("id", idColumn()).addColumn("name", column("string"))),
+);
+
+const testFragmentDefinition = defineFragment("test")
+  .extend(withDatabase(testSchema))
+  .provideHooks(({ defineHook }) => ({
+    onTest: defineHook(async function () {}),
+  }))
+  .build();
+
+describe("getDurableHooksService", () => {
+  let baseAdapter: SqlAdapter;
+  let hookAdapter: SqlAdapter;
+
+  beforeAll(async () => {
+    const baseDb = new SQLite(":memory:");
+    const hookDb = new SQLite(":memory:");
+
+    baseAdapter = new SqlAdapter({
+      dialect: new SqliteDialect({ database: baseDb }),
+      driverConfig: new BetterSQLite3DriverConfig(),
+    });
+
+    hookAdapter = new SqlAdapter({
+      dialect: new SqliteDialect({ database: hookDb }),
+      driverConfig: new BetterSQLite3DriverConfig(),
+    });
+
+    (
+      baseAdapter as SqlAdapter & { getHookProcessingAdapter?: () => SqlAdapter }
+    ).getHookProcessingAdapter = () => hookAdapter;
+
+    const baseInternalMigrations = baseAdapter.prepareMigrations(internalSchema, null);
+    await baseInternalMigrations.executeWithDriver(baseAdapter.driver, 0);
+
+    const hookInternalMigrations = hookAdapter.prepareMigrations(internalSchema, null);
+    await hookInternalMigrations.executeWithDriver(hookAdapter.driver, 0);
+
+    const testMigrations = baseAdapter.prepareMigrations(testSchema, "test");
+    await testMigrations.executeWithDriver(baseAdapter.driver, 0);
+  }, 12000);
+
+  afterAll(async () => {
+    await baseAdapter.close();
+    await hookAdapter.close();
+  });
+
+  it("uses the hook processing adapter when reading durable hooks", () => {
+    const fragment = instantiate(testFragmentDefinition)
+      .withConfig({})
+      .withOptions({ databaseAdapter: baseAdapter })
+      .build();
+
+    const { hookService, hooksEnabled, namespace } = getDurableHooksService(fragment);
+
+    const baseInternal = getInternalFragment(baseAdapter);
+    const hookInternal = getInternalFragment(hookAdapter);
+
+    expect(hooksEnabled).toBe(true);
+    expect(namespace).toBe("test");
+    expect(hookService).toBe(hookInternal.services.hookService);
+    expect(hookService).not.toBe(baseInternal.services.hookService);
+  });
+});

package/src/durable-hooks.ts

@@ -0,0 +1,67 @@
+import type { DatabaseAdapter } from "./adapters/adapters";
+import type { InternalFragmentInstance } from "./fragments/internal-fragment";
+import { getDurableHooksRuntimeByToken } from "./hooks/durable-hooks-runtime";
+import type { HookStatus } from "./hooks/hooks";
+import { getInternalFragment } from "./internal/adapter-registry";
+import type { AnyFragnoInstantiatedDatabaseFragment } from "./mod";
+import type { FragnoId } from "./schema/create";
+
+export type { AnyFragnoInstantiatedDatabaseFragment };
+
+export type DurableHookStatus = HookStatus;
+
+export type DurableHookRecord = {
+  id: FragnoId;
+  namespace: string;
+  hookName: string;
+  payload: unknown;
+  status: DurableHookStatus;
+  attempts: number;
+  maxAttempts: number;
+  lastAttemptAt: Date | null;
+  nextRetryAt: Date | null;
+  createdAt: Date;
+  error: string | null;
+  nonce: string;
+};
+
+export type DurableHooksService = InternalFragmentInstance["services"]["hookService"];
+
+export type DurableHooksAccessor = {
+  namespace: string;
+  hooksEnabled: boolean;
+  hookService: DurableHooksService;
+};
+
+export function getDurableHooksService(
+  fragment: AnyFragnoInstantiatedDatabaseFragment,
+): DurableHooksAccessor {
+  const internal = fragment.$internal as { durableHooksToken?: object } | undefined;
+  const durableHooksToken = internal?.durableHooksToken;
+  const runtime = durableHooksToken ? getDurableHooksRuntimeByToken(durableHooksToken) : undefined;
+  const deps = fragment.$internal?.deps as
+    | {
+        databaseAdapter?: DatabaseAdapter<unknown>;
+        namespace?: string | null;
+        schema?: { name?: string };
+      }
+    | undefined;
+
+  if (!deps?.databaseAdapter) {
+    throw new Error("Database adapter is missing for durable hooks.");
+  }
+
+  const namespace = runtime?.config.namespace ?? deps.namespace ?? deps.schema?.name ?? "";
+  if (!namespace) {
+    throw new Error("Durable hooks namespace is missing.");
+  }
+
+  const hookAdapter = deps.databaseAdapter.getHookProcessingAdapter?.() ?? deps.databaseAdapter;
+  const internalFragment = runtime?.config.internalFragment ?? getInternalFragment(hookAdapter);
+
+  return {
+    namespace,
+    hooksEnabled: Boolean(durableHooksToken),
+    hookService: internalFragment.services.hookService,
+  };
+}