@fragno-dev/db 0.2.2 → 0.4.1

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

@@ -0,0 +1,65 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { DurableHooksLogger } from "./durable-hooks-logger";
+import {
+  getDurableHooksNotifierByNamespace,
+  getDurableHooksRuntimeByConfig,
+  getDurableHooksRuntimeByNamespace,
+  getDurableHooksRuntimeByToken,
+  registerDurableHooksRuntime,
+} from "./durable-hooks-runtime";
+import type { HookNotifier, HookProcessorConfig } from "./hooks";
+
+let namespaceCounter = 0;
+const defaultInternalFragment = {} as HookProcessorConfig["internalFragment"];
+
+function createConfig(
+  namespace: string,
+  notifier?: HookNotifier,
+  internalFragment: HookProcessorConfig["internalFragment"] = defaultInternalFragment,
+): HookProcessorConfig {
+  return {
+    namespace,
+    hooks: {},
+    notifier,
+    internalFragment,
+    handlerTx: (() => {
+      throw new Error("handlerTx should not be called in durable-hooks-runtime tests");
+    }) as HookProcessorConfig["handlerTx"],
+  };
+}
+
+describe("durable hooks runtime registry", () => {
+  it("returns the same token when registering the same config twice", () => {
+    const namespace = `runtime-same-config-${namespaceCounter++}`;
+    const config = createConfig(namespace);
+
+    const tokenA = registerDurableHooksRuntime(config);
+    const tokenB = registerDurableHooksRuntime(config);
+
+    expect(tokenA).toBe(tokenB);
+    expect(getDurableHooksRuntimeByToken(tokenA)?.config).toBe(config);
+    expect(getDurableHooksRuntimeByConfig(config)?.token).toBe(tokenA);
+  });
+
+  it("keeps the latest runtime for scoped namespace lookup and warns on duplicates", () => {
+    const warnSpy = vi.spyOn(DurableHooksLogger, "warn").mockImplementation(() => {});
+    const namespace = `runtime-duplicate-${namespaceCounter++}`;
+    const internalFragment = {} as HookProcessorConfig["internalFragment"];
+    const firstConfig = createConfig(namespace, undefined, internalFragment);
+    const notifier: HookNotifier = {
+      notify: vi.fn(),
+    };
+    const secondConfig = createConfig(namespace, notifier, internalFragment);
+
+    const firstToken = registerDurableHooksRuntime(firstConfig);
+    const secondToken = registerDurableHooksRuntime(secondConfig);
+
+    expect(firstToken).not.toBe(secondToken);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(getDurableHooksRuntimeByNamespace(namespace, internalFragment)?.token).toBe(secondToken);
+    expect(getDurableHooksNotifierByNamespace(namespace, internalFragment)).toBe(notifier);
+
+    warnSpy.mockRestore();
+  });
+});

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

@@ -0,0 +1,81 @@
+import { DurableHooksLogger } from "./durable-hooks-logger";
+import type { HookProcessorConfig } from "./hooks";
+
+type DurableHooksRuntimeState = {
+  token: object;
+  config: HookProcessorConfig;
+  dispatcherRegistered: boolean;
+  dispatcherWarningEmitted: boolean;
+};
+
+const runtimeByToken = new WeakMap<object, DurableHooksRuntimeState>();
+const runtimeByConfig = new WeakMap<HookProcessorConfig, DurableHooksRuntimeState>();
+const runtimesByInternalFragment = new WeakMap<
+  HookProcessorConfig["internalFragment"],
+  Map<string, DurableHooksRuntimeState>
+>();
+
+function getNamespaceRuntimeMap(
+  internalFragment: HookProcessorConfig["internalFragment"],
+  createIfMissing = false,
+) {
+  const existing = runtimesByInternalFragment.get(internalFragment);
+  if (existing || !createIfMissing) {
+    return existing;
+  }
+  const created = new Map<string, DurableHooksRuntimeState>();
+  runtimesByInternalFragment.set(internalFragment, created);
+  return created;
+}
+
+export function registerDurableHooksRuntime(config: HookProcessorConfig): object {
+  const existing = runtimeByConfig.get(config);
+  if (existing) {
+    return existing.token;
+  }
+
+  const token = {};
+  const runtime: DurableHooksRuntimeState = {
+    token,
+    config,
+    dispatcherRegistered: false,
+    dispatcherWarningEmitted: false,
+  };
+
+  runtimeByToken.set(token, runtime);
+  runtimeByConfig.set(config, runtime);
+  const runtimeByNamespace = getNamespaceRuntimeMap(config.internalFragment, true);
+  const existingForNamespace = runtimeByNamespace?.get(config.namespace);
+  if (existingForNamespace && existingForNamespace.config !== config) {
+    DurableHooksLogger.warn("Durable hooks runtime already registered for namespace", {
+      namespace: config.namespace,
+    });
+  }
+  runtimeByNamespace?.set(config.namespace, runtime);
+
+  return token;
+}
+
+export function getDurableHooksRuntimeByToken(token: object): DurableHooksRuntimeState | undefined {
+  return runtimeByToken.get(token);
+}
+
+export function getDurableHooksRuntimeByConfig(
+  config: HookProcessorConfig,
+): DurableHooksRuntimeState | undefined {
+  return runtimeByConfig.get(config);
+}
+
+export function getDurableHooksRuntimeByNamespace(
+  namespace: string,
+  internalFragment: HookProcessorConfig["internalFragment"],
+): DurableHooksRuntimeState | undefined {
+  return getNamespaceRuntimeMap(internalFragment)?.get(namespace);
+}
+
+export function getDurableHooksNotifierByNamespace(
+  namespace: string,
+  internalFragment: HookProcessorConfig["internalFragment"],
+) {
+  return getNamespaceRuntimeMap(internalFragment)?.get(namespace)?.config.notifier;
+}