@fragno-dev/db 0.2.1 → 0.3.0

package/src/hooks/durable-hooks-processor.test.ts

@@ -0,0 +1,117 @@
+import SQLite from "better-sqlite3";
+import { SqliteDialect } from "kysely";
+import { beforeAll, describe, expect, it } from "vitest";
+import { defineFragment, instantiate } from "@fragno-dev/core";
+import { withDatabase } from "../with-database";
+import { schema, column, idColumn } from "../schema/create";
+import { SqlAdapter } from "../adapters/generic-sql/generic-sql-adapter";
+import { BetterSQLite3DriverConfig } from "../adapters/generic-sql/driver-config";
+import { internalSchema } from "../fragments/internal-fragment";
+import { createDurableHooksProcessor } from "./durable-hooks-processor";
+
+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("createDurableHooksProcessor", () => {
+  let adapter: SqlAdapter;
+  let fragment: ReturnType<typeof instantiateFragment>;
+
+  function instantiateFragment(options: { databaseAdapter: SqlAdapter }) {
+    return instantiate(testFragmentDefinition).withConfig({}).withOptions(options).build();
+  }
+
+  beforeAll(async () => {
+    const sqliteDatabase = new SQLite(":memory:");
+    const dialect = new SqliteDialect({ database: sqliteDatabase });
+
+    adapter = new SqlAdapter({
+      dialect,
+      driverConfig: new BetterSQLite3DriverConfig(),
+    });
+
+    const internalMigrations = adapter.prepareMigrations(internalSchema, null);
+    await internalMigrations.executeWithDriver(adapter.driver, 0);
+
+    const testMigrations = adapter.prepareMigrations(testSchema, "test");
+    await testMigrations.executeWithDriver(adapter.driver, 0);
+
+    fragment = instantiateFragment({ databaseAdapter: adapter });
+
+    return async () => {
+      await adapter.close();
+    };
+  }, 12000);
+
+  it("should process pending hooks and return counts", async () => {
+    const processor = createDurableHooksProcessor(fragment);
+    expect(processor).not.toBeNull();
+
+    const internalFragment = fragment.$internal.linkedFragments._fragno_internal;
+    await internalFragment.inContext(async function () {
+      await this.handlerTx()
+        .mutate(({ forSchema }) => {
+          const uow = forSchema(internalSchema);
+          uow.create("fragno_hooks", {
+            namespace: "test",
+            hookName: "onTest",
+            payload: { ok: true },
+            status: "pending",
+            attempts: 0,
+            maxAttempts: 1,
+            lastAttemptAt: null,
+            nextRetryAt: null,
+            error: null,
+            nonce: "test-nonce",
+          });
+        })
+        .execute();
+    });
+
+    const wakeAt = await processor!.getNextWakeAt();
+    expect(wakeAt).toBeInstanceOf(Date);
+
+    const processed = await processor!.process();
+    expect(processed).toBe(1);
+  });
+
+  it("should wake for stale processing hooks", async () => {
+    const processor = createDurableHooksProcessor(fragment);
+    expect(processor).not.toBeNull();
+
+    const internalFragment = fragment.$internal.linkedFragments._fragno_internal;
+    const services = internalFragment.services as { getDbNow?: () => Promise<Date> };
+    const baseNow = services.getDbNow ? await services.getDbNow() : new Date();
+
+    await internalFragment.inContext(async function () {
+      await this.handlerTx()
+        .mutate(({ forSchema }) => {
+          const uow = forSchema(internalSchema);
+          uow.create("fragno_hooks", {
+            namespace: "test",
+            hookName: "onTest",
+            payload: { ok: true },
+            status: "processing",
+            attempts: 0,
+            maxAttempts: 1,
+            lastAttemptAt: new Date(baseNow.getTime() - 20 * 60_000),
+            nextRetryAt: null,
+            error: null,
+            nonce: "test-nonce-stuck",
+          });
+        })
+        .execute();
+    });
+
+    const wakeAt = await processor!.getNextWakeAt();
+    expect(wakeAt).toBeInstanceOf(Date);
+    expect(wakeAt!.getTime()).toBeLessThanOrEqual(baseNow.getTime());
+  });
+});

package/src/hooks/durable-hooks-processor.ts

@@ -0,0 +1,67 @@
+import type { AnySchema } from "../schema/create";
+import type { AnyFragnoInstantiatedDatabaseFragment } from "../mod";
+import { createHookScheduler, type HookProcessorConfig } from "./hooks";
+
+export type DurableHooksProcessor = {
+  process: () => Promise<number>;
+  getNextWakeAt: () => Promise<Date | null>;
+  drain: () => Promise<void>;
+  namespace: string;
+};
+
+type DurableHooksInternal = {
+  durableHooks?: HookProcessorConfig;
+};
+
+const DEFAULT_STUCK_PROCESSING_TIMEOUT_MINUTES = 10;
+
+function resolveStuckProcessingTimeoutMinutes(value: number | false | undefined): number | false {
+  if (value === false) {
+    return false;
+  }
+  if (typeof value === "number") {
+    return value > 0 ? value : false;
+  }
+  return DEFAULT_STUCK_PROCESSING_TIMEOUT_MINUTES;
+}
+
+export function createDurableHooksProcessor<TSchema extends AnySchema>(
+  fragment: AnyFragnoInstantiatedDatabaseFragment<TSchema>,
+): DurableHooksProcessor | null {
+  const durableHooks = (fragment.$internal as DurableHooksInternal).durableHooks;
+  if (!durableHooks) {
+    return null;
+  }
+
+  const { namespace, internalFragment } = durableHooks;
+  const stuckProcessingTimeoutMinutes = resolveStuckProcessingTimeoutMinutes(
+    durableHooks.stuckProcessingTimeoutMinutes,
+  );
+  const scheduler =
+    durableHooks.scheduler ?? (durableHooks.scheduler = createHookScheduler(durableHooks));
+
+  return {
+    namespace,
+    process: async () => scheduler.schedule(),
+    drain: async () => scheduler.drain(),
+    getNextWakeAt: async () => {
+      const services = internalFragment.services as { getDbNow?: () => Promise<Date> };
+      const now = services.getDbNow ? await services.getDbNow() : new Date();
+      return await internalFragment.inContext(async function () {
+        return await this.handlerTx()
+          .withServiceCalls(
+            () =>
+              [
+                internalFragment.services.hookService.getNextHookWakeAt(
+                  namespace,
+                  stuckProcessingTimeoutMinutes,
+                  now,
+                ),
+              ] as const,
+          )
+          .transform(({ serviceResult: [result] }) => result)
+          .execute();
+      });
+    },
+  };
+}