@effectstream/runtime 0.100.27 → 0.101.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectstream/runtime",
-  "version": "0.100.27",
+  "version": "0.101.0",
   "license": "MIT",
   "homepage": "https://effectstream.github.io/docs/",
   "repository": {
@@ -13,17 +13,17 @@
   },
   "exports": "./src/mod.ts",
   "dependencies": {
-    "@effectstream/concise": "0.100.27",
-    "@effectstream/config": "0.100.27",
-    "@effectstream/coroutine": "0.100.27",
-    "@effectstream/crypto": "0.100.27",
-    "@effectstream/db": "0.100.27",
-    "@effectstream/event-client": "0.100.27",
-    "@effectstream/event-server": "0.100.27",
-    "@effectstream/log": "0.100.27",
-    "@effectstream/sm": "0.100.27",
-    "@effectstream/sync": "0.100.27",
-    "@effectstream/utils": "0.100.27",
+    "@effectstream/concise": "0.101.0",
+    "@effectstream/config": "0.101.0",
+    "@effectstream/coroutine": "0.101.0",
+    "@effectstream/crypto": "0.101.0",
+    "@effectstream/db": "0.101.0",
+    "@effectstream/event-client": "0.101.0",
+    "@effectstream/event-server": "0.101.0",
+    "@effectstream/log": "0.101.0",
+    "@effectstream/sm": "0.101.0",
+    "@effectstream/sync": "0.101.0",
+    "@effectstream/utils": "0.101.0",
     "@fastify/cors": "^11.0.1",
     "@metamask/json-rpc-engine": "^10.0.3",
     "pg": "8.21.0",

package/src/coalesce.ts

@@ -39,9 +39,13 @@ export function* loadEmptyRunBoundaries(
 ): Operation<EmptyRunBoundaries> {
   const [bh] = yield* until(getEarliestScheduledBlockHeight.run(undefined, dbConn));
   const [ts] = yield* until(getEarliestScheduledTimestamp.run(undefined, dbConn));
-  // Ignore scheduled block heights already in the past: a stale unprocessed row
-  // (e.g. from a DB reset) would otherwise permanently suppress coalescing for
-  // all current blocks, since every block number >= the stale height.
+  // getEarliestScheduledBlockHeight now excludes heights at/below the last applied
+  // block in SQL, so this is always an upcoming schedule (or null when none pends).
+  // The `>= fromBlockNumber` check is a belt-and-suspenders guard. BEWARE the old
+  // shape: that query returned the global MIN, and a stale below-head row (e.g. an
+  // input that was already skipped) collapsed the boundary to null *here* — which
+  // disables coalescing's scheduled-input guard entirely, so every later scheduled
+  // input inside an empty run gets coalesced over. One orphan permanently broke it.
   const minScheduledBlockHeight = bh?.min_block_height != null && bh.min_block_height >= fromBlockNumber
     ? bh.min_block_height
     : null;

package/src/config-snapshot.ts

@@ -70,6 +70,23 @@ function extractImmutableConfig(protocol: SyncProtocolWithNetwork): Record<strin
   return { startBlockHeight: sp.startBlockHeight };
 }
 
+/**
+ * Compares a saved snapshot value against the current in-memory value.
+ * Falls back to structural JSON comparison for nested objects (which are
+ * always freshly constructed plain objects with stable key-insertion order
+ * from `extractImmutableConfig`), and to reference/identity comparison for
+ * everything else.
+ */
+function valuesDiffer(saved: unknown, current: unknown): boolean {
+  if (
+    typeof saved === "object" && saved !== null &&
+    typeof current === "object" && current !== null
+  ) {
+    return JSON.stringify(saved) !== JSON.stringify(current);
+  }
+  return saved !== current;
+}
+
 /**
  * Checks the saved config snapshot for each sync protocol against the current config.
  *
@@ -85,7 +102,6 @@ export function* validateAndSnapshotConfig(
   syncInfo: SyncProtocolWithNetwork[],
   dbConn: Client,
 ): Operation<void> {
-  console.log("validateAndSnapshotConfig");
   const useDbStartHeight = getEnv("USE_DB_STARTHEIGHT") !== undefined;
 
   for (const protocol of syncInfo) {
@@ -119,20 +135,9 @@ export function* validateAndSnapshotConfig(
 
     const saved = rows[0].immutable_config as Record<string, unknown>;
     const mismatches: string[] = [];
-    console.log("saved", saved);
     for (const [key, savedValue] of Object.entries(saved)) {
-      console.log("key", key, savedValue, currentImmutable[key]);
-      // if (currentImmutable[key] !== savedValue) {
-      //   mismatches.push(`  ${key}: saved=${JSON.stringify(savedValue)}, current=${JSON.stringify(currentImmutable[key])}`);
-      // }
-      if (typeof savedValue === "object" && savedValue !== null) {
-        for (const [k, v] of Object.entries(savedValue)) {
-          if ((currentImmutable[key] as any)[k] !== v) {
-            mismatches.push(`  ${key}.${k}: saved=${JSON.stringify(v)},\n current=${JSON.stringify((currentImmutable[key] as any)[k])}`);
-          }
-        }
-      } else if (currentImmutable[key] !== savedValue) {
-        mismatches.push(`  ${key}: saved=${JSON.stringify(savedValue)},\n current=${JSON.stringify(currentImmutable[key])}`);
+      if (valuesDiffer(savedValue, currentImmutable[key])) {
+        mismatches.push(`  ${key}: saved=${JSON.stringify(savedValue)}, current=${JSON.stringify(currentImmutable[key])}`);
       }
     }
 

package/src/process-blocks.ts

@@ -260,6 +260,7 @@ export function* processFinalizedBlock(
             blockEvents.push(...inputEvents);
           }
         } catch (err) {
+          if (isTransientPgError(err)) throw err;
           success = false;
           log.remote(
             ComponentNames.EFFECTSTREAM_SYNC,

package/test/config-snapshot.unit.test.ts

@@ -0,0 +1,99 @@
+import { expect, test, mock, beforeEach, afterEach } from "bun:test";
+import { run } from "effection";
+import type { Client } from "pg";
+import { ConfigNetworkType, ConfigSyncProtocolType } from "@effectstream/config";
+import type { SyncProtocolWithNetwork } from "@effectstream/config";
+
+/**
+ * In-memory backing store for the mocked `@effectstream/db` query objects.
+ * `validateAndSnapshotConfig` only touches two queries — `get…Snapshot`
+ * (returns rows) and `upsert…Snapshot` (writes) — so stubbing those two is
+ * sufficient to exercise the comparison loop end-to-end without a real DB.
+ */
+type StoredRow = { networkType: ConfigNetworkType; immutable_config: unknown };
+let store: Record<string, StoredRow | undefined> = {};
+
+mock.module("@effectstream/db", () => ({
+  getSyncProtocolConfigSnapshot: {
+    run: ({ protocolName }: { protocolName: string }) =>
+      Promise.resolve(store[protocolName] ? [store[protocolName]] : []),
+  },
+  upsertSyncProtocolConfigSnapshot: {
+    run: ({
+      protocolName,
+      networkType,
+      immutableConfig,
+    }: {
+      protocolName: string;
+      networkType: ConfigNetworkType;
+      immutableConfig: string;
+    }) => {
+      store[protocolName] = { networkType, immutable_config: JSON.parse(immutableConfig) };
+      return Promise.resolve([]);
+    },
+  },
+}));
+
+const { validateAndSnapshotConfig } = await import("../src/config-snapshot.ts");
+
+const STUB_DB = {} as Client;
+
+function cardanoUtxoRpcProtocol(
+  startChainPoint: unknown,
+): SyncProtocolWithNetwork {
+  return {
+    networkType: ConfigNetworkType.CARDANO,
+    syncProtocolType: ConfigSyncProtocolType.CARDANO_UTXORPC_PARALLEL,
+    syncProtocol: { name: "cardano-utxorpc", startChainPoint },
+    network: {},
+  } as unknown as SyncProtocolWithNetwork;
+}
+
+async function runValidate(
+  protocols: SyncProtocolWithNetwork[],
+): Promise<void> {
+  await run(function* () {
+    yield* validateAndSnapshotConfig(protocols, STUB_DB);
+  });
+}
+
+beforeEach(() => {
+  store = {};
+  delete process.env.USE_DB_STARTHEIGHT;
+});
+
+afterEach(() => {
+  delete process.env.USE_DB_STARTHEIGHT;
+});
+
+test("first run persists the snapshot and succeeds", async () => {
+  const protocol = cardanoUtxoRpcProtocol({ slot: 1, hash: "0xabc" });
+  await expect(runValidate([protocol])).resolves.toBeUndefined();
+  expect(store["cardano-utxorpc"]?.immutable_config).toEqual({
+    startChainPoint: { slot: 1, hash: "0xabc" },
+  });
+});
+
+test("matching nested-object snapshot succeeds on subsequent runs", async () => {
+  // Seed the snapshot from a first run.
+  await runValidate([cardanoUtxoRpcProtocol({ slot: 5, hash: "0xdead" })]);
+
+  // Same shape on restart — must not throw.
+  await expect(
+    runValidate([cardanoUtxoRpcProtocol({ slot: 5, hash: "0xdead" })]),
+  ).resolves.toBeUndefined();
+});
+
+test("reports a clean mismatch (no TypeError) when a saved nested object has no current counterpart", async () => {
+  // Snapshot persisted with a nested startChainPoint object.
+  await runValidate([cardanoUtxoRpcProtocol({ slot: 42, hash: "0xbeef" })]);
+
+  // On restart the current config has lost that field (shape drift / undefined).
+  const drifted = cardanoUtxoRpcProtocol(undefined);
+
+  // The robust comparator must surface this as a clean CRITICAL mismatch
+  // rather than throwing a `TypeError: Cannot read properties of undefined`.
+  await expect(runValidate([drifted])).rejects.toThrow(
+    /\[config-snapshot\] CRITICAL/,
+  );
+});