@secondlayer/subgraphs 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/src/runtime/processor.js

@@ -1503,7 +1503,7 @@ import {
   listSubgraphs as listSubgraphs2,
   updateSubgraphStatus as updateSubgraphStatus2
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger8 } from "@secondlayer/shared/logger";
+import { logger as logger9 } from "@secondlayer/shared/logger";
 import { listen as listen2 } from "@secondlayer/shared/queue/listener";
 
 // src/runtime/emitter.ts
@@ -1513,10 +1513,98 @@ import {
 import {
   getSubscriptionSigningSecret
 } from "@secondlayer/shared/db/queries/subscriptions";
-import { logger as logger7 } from "@secondlayer/shared/logger";
+import { logger as logger8 } from "@secondlayer/shared/logger";
 import { listen } from "@secondlayer/shared/queue/listener";
 import { sql as sql4 } from "kysely";
 
+// src/runtime/formats/index.ts
+import { logger as logger7 } from "@secondlayer/shared/logger";
+
+// src/runtime/formats/cloudevents.ts
+function buildCloudEvents(outboxRow, _sub) {
+  const event = {
+    specversion: "1.0",
+    type: outboxRow.event_type,
+    source: `secondlayer:${outboxRow.subgraph_name}`,
+    id: outboxRow.id,
+    time: new Date(outboxRow.created_at).toISOString(),
+    datacontenttype: "application/json",
+    data: outboxRow.payload
+  };
+  return {
+    body: JSON.stringify(event),
+    headers: {
+      "content-type": "application/cloudevents+json; charset=utf-8"
+    }
+  };
+}
+
+// src/runtime/formats/cloudflare.ts
+import { decryptSecret } from "@secondlayer/shared/crypto/secrets";
+function resolveBearer(sub) {
+  const cfg = sub.auth_config;
+  if (cfg.tokenEnc) {
+    try {
+      return decryptSecret(Buffer.from(cfg.tokenEnc, "base64"));
+    } catch {
+      return null;
+    }
+  }
+  return cfg.token ?? null;
+}
+function buildCloudflare(outboxRow, sub) {
+  const body = JSON.stringify({
+    params: {
+      ...outboxRow.payload,
+      _type: outboxRow.event_type,
+      _outboxId: outboxRow.id
+    }
+  });
+  const headers = {
+    "content-type": "application/json"
+  };
+  const token = resolveBearer(sub);
+  if (token)
+    headers.authorization = `Bearer ${token}`;
+  return { body, headers };
+}
+
+// src/runtime/formats/inngest.ts
+var INNGEST_VERSION = "2026-04-23.v1";
+function buildInngest(outboxRow) {
+  const event = {
+    name: outboxRow.event_type,
+    data: outboxRow.payload,
+    id: outboxRow.id,
+    ts: new Date(outboxRow.created_at).getTime(),
+    v: INNGEST_VERSION
+  };
+  return {
+    body: JSON.stringify([event]),
+    headers: {
+      "content-type": "application/json"
+    }
+  };
+}
+
+// src/runtime/formats/raw.ts
+function buildRaw(outboxRow, sub) {
+  const cfg = sub.auth_config;
+  const headers = {
+    "content-type": cfg.contentType ?? "application/json",
+    ...cfg.headers ?? {}
+  };
+  if (cfg.authType === "bearer" && cfg.token) {
+    headers.authorization = `Bearer ${cfg.token}`;
+  } else if (cfg.authType === "basic" && cfg.basicAuth) {
+    headers.authorization = `Basic ${cfg.basicAuth}`;
+  }
+  return {
+    body: JSON.stringify(outboxRow.payload),
+    headers
+  };
+}
+
 // src/runtime/formats/standard-webhooks.ts
 import { sign } from "@secondlayer/shared/crypto/standard-webhooks";
 function buildStandardWebhooks(outboxRow, signingSecret) {
@@ -1539,15 +1627,69 @@ function buildStandardWebhooks(outboxRow, signingSecret) {
   };
 }
 
+// src/runtime/formats/trigger.ts
+import { decryptSecret as decryptSecret2 } from "@secondlayer/shared/crypto/secrets";
+function resolveBearer2(sub) {
+  const cfg = sub.auth_config;
+  if (cfg.tokenEnc) {
+    try {
+      return decryptSecret2(Buffer.from(cfg.tokenEnc, "base64"));
+    } catch {
+      return null;
+    }
+  }
+  return cfg.token ?? null;
+}
+function buildTrigger(outboxRow, sub) {
+  const body = JSON.stringify({
+    payload: outboxRow.payload,
+    options: {
+      idempotencyKey: outboxRow.id
+    }
+  });
+  const headers = {
+    "content-type": "application/json"
+  };
+  const token = resolveBearer2(sub);
+  if (token)
+    headers.authorization = `Bearer ${token}`;
+  return { body, headers };
+}
+
+// src/runtime/formats/index.ts
+function buildForFormat(outboxRow, sub, signingSecret) {
+  switch (sub.format) {
+    case "inngest":
+      return buildInngest(outboxRow);
+    case "trigger":
+      return buildTrigger(outboxRow, sub);
+    case "cloudflare":
+      return buildCloudflare(outboxRow, sub);
+    case "cloudevents":
+      return buildCloudEvents(outboxRow, sub);
+    case "raw":
+      return buildRaw(outboxRow, sub);
+    case "standard-webhooks":
+      return buildStandardWebhooks(outboxRow, signingSecret);
+    default:
+      logger7.warn("Unknown subscription format, falling back to standard-webhooks", {
+        format: sub.format,
+        subscriptionId: sub.id
+      });
+      return buildStandardWebhooks(outboxRow, signingSecret);
+  }
+}
+
 // src/runtime/emitter.ts
 var BATCH_SIZE = 50;
+var LIVE_SHARE = 0.9;
 var BACKOFF_SECONDS = [30, 120, 600, 3600, 21600, 86400, 259200];
 var CIRCUIT_THRESHOLD = 20;
 function nextDelaySeconds(attempt) {
   return BACKOFF_SECONDS[Math.min(attempt, BACKOFF_SECONDS.length - 1)];
 }
 async function dispatchOne(db, outboxRow, sub) {
-  const { body, headers } = buildStandardWebhooks(outboxRow, getSubscriptionSigningSecret(sub));
+  const { body, headers } = buildForFormat(outboxRow, sub, getSubscriptionSigningSecret(sub));
   const start = performance.now();
   let statusCode = null;
   let error = null;
@@ -1625,7 +1767,7 @@ async function settleFailed(db, outboxRow, sub, errText) {
       updated_at: new Date
     }).where("id", "=", outboxRow.subscription_id).execute();
     if (shouldTripCircuit) {
-      logger7.warn("Subscription circuit tripped — paused after consecutive failures", {
+      logger8.warn("Subscription circuit tripped — paused after consecutive failures", {
         subscription: sub.name,
         failures: newFailures
       });
@@ -1637,20 +1779,34 @@ async function claimAndDrain(db, state, emitterId) {
     return 0;
   state.claimInFlight = true;
   try {
+    const liveLimit = Math.max(1, Math.round(BATCH_SIZE * LIVE_SHARE));
+    const replayLimit = BATCH_SIZE - liveLimit;
     const claimed = await db.transaction().execute(async (tx) => {
-      const rows = await sql4`
+      const live = await sql4`
+					SELECT * FROM subscription_outbox
+					WHERE status = 'pending'
+						AND next_attempt_at <= NOW()
+						AND is_replay = FALSE
+					ORDER BY next_attempt_at ASC
+					FOR UPDATE SKIP LOCKED
+					LIMIT ${sql4.lit(liveLimit)}
+				`.execute(tx);
+      const replay = await sql4`
 					SELECT * FROM subscription_outbox
-					WHERE status = 'pending' AND next_attempt_at <= NOW()
+					WHERE status = 'pending'
+						AND next_attempt_at <= NOW()
+						AND is_replay = TRUE
 					ORDER BY next_attempt_at ASC
 					FOR UPDATE SKIP LOCKED
-					LIMIT ${sql4.lit(BATCH_SIZE)}
+					LIMIT ${sql4.lit(replayLimit)}
 				`.execute(tx);
-      if (rows.rows.length === 0)
+      const combined = [...live.rows, ...replay.rows];
+      if (combined.length === 0)
         return [];
       const now = new Date;
       const lockUntil = new Date(now.getTime() + 60000);
-      await tx.updateTable("subscription_outbox").set({ locked_by: emitterId, locked_until: lockUntil }).where("id", "in", rows.rows.map((r) => r.id)).execute();
-      return rows.rows;
+      await tx.updateTable("subscription_outbox").set({ locked_by: emitterId, locked_until: lockUntil }).where("id", "in", combined.map((r) => r.id)).execute();
+      return combined;
     });
     if (claimed.length === 0)
       return 0;
@@ -1695,7 +1851,7 @@ async function drainForSub(db, state, sub, rows) {
             await settleFailed(db, row, sub, err);
           }
         } catch (err) {
-          logger7.error("Emitter dispatch crashed", {
+          logger8.error("Emitter dispatch crashed", {
             outboxId: row.id,
             error: err instanceof Error ? err.message : String(err)
           });
@@ -1732,30 +1888,30 @@ async function startEmitter(opts) {
   };
   const pollIntervalMs = opts?.pollIntervalMs ?? 120000;
   const retentionIntervalMs = opts?.retentionIntervalMs ?? 60 * 60000;
-  logger7.info("[emitter] started", { id: emitterId });
+  logger8.info("[emitter] started", { id: emitterId });
   await refreshMatcher(db).catch((err) => {
-    logger7.error("[emitter] initial matcher refresh failed", {
+    logger8.error("[emitter] initial matcher refresh failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   });
   const stopNew = await listen("subscriptions:new_outbox", () => {
     if (!state.running)
       return;
-    claimAndDrain(db, state, emitterId).catch((err) => logger7.error("[emitter] claim failed", {
+    claimAndDrain(db, state, emitterId).catch((err) => logger8.error("[emitter] claim failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   });
   const stopChanged = await listen("subscriptions:changed", () => {
     if (!state.running)
       return;
-    refreshMatcher(db).catch((err) => logger7.error("[emitter] matcher refresh failed", {
+    refreshMatcher(db).catch((err) => logger8.error("[emitter] matcher refresh failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   });
   const poll = setInterval(() => {
     if (!state.running)
       return;
-    claimAndDrain(db, state, emitterId).catch((err) => logger7.error("[emitter] poll claim failed", {
+    claimAndDrain(db, state, emitterId).catch((err) => logger8.error("[emitter] poll claim failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   }, pollIntervalMs);
@@ -1763,7 +1919,7 @@ async function startEmitter(opts) {
   const retention = setInterval(() => {
     if (!state.running)
       return;
-    runRetention(db).catch((err) => logger7.error("[emitter] retention failed", {
+    runRetention(db).catch((err) => logger8.error("[emitter] retention failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   }, retentionIntervalMs);
@@ -1773,7 +1929,7 @@ async function startEmitter(opts) {
     clearInterval(retention);
     await stopNew();
     await stopChanged();
-    logger7.info("[emitter] stopped", { id: emitterId });
+    logger8.info("[emitter] stopped", { id: emitterId });
   };
 }
 
@@ -1811,7 +1967,7 @@ async function loadSubgraphDefinition(sg) {
   knownVersions.set(sg.name, sg.version);
   definitionCache.set(sg.name, def);
   if (prevVersion && prevVersion !== sg.version) {
-    logger8.info("Subgraph handler reloaded", {
+    logger9.info("Subgraph handler reloaded", {
       subgraph: sg.name,
       from: prevVersion,
       to: sg.version
@@ -1831,7 +1987,7 @@ function cleanupCaches(active) {
 async function startSubgraphProcessor(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_CONCURRENCY;
   let running = true;
-  logger8.info("Starting subgraph processor", { concurrency });
+  logger9.info("Starting subgraph processor", { concurrency });
   const targetDb = getTargetDb5();
   const activeSubgraphs = (await listSubgraphs2(targetDb)).filter((v) => v.status === "active");
   for (const sg of activeSubgraphs) {
@@ -1843,7 +1999,7 @@ async function startSubgraphProcessor(opts) {
       if (isHandlerNotFoundError(err)) {
         await updateSubgraphStatus2(targetDb, sg.name, "error");
       }
-      logger8.error("Subgraph catch-up failed on startup", {
+      logger9.error("Subgraph catch-up failed on startup", {
         subgraph: sg.name,
         error: msg
       });
@@ -1864,7 +2020,7 @@ async function startSubgraphProcessor(opts) {
         if (isHandlerNotFoundError(err)) {
           await updateSubgraphStatus2(db, sg.name, "error");
         }
-        logger8.error("Subgraph processing failed", {
+        logger9.error("Subgraph processing failed", {
           subgraph: sg.name,
           error: msg
         });
@@ -1881,7 +2037,7 @@ async function startSubgraphProcessor(opts) {
         await handleSubgraphReorg(blockHeight, loadSubgraphDefinition);
       }
     } catch (err) {
-      logger8.error("Subgraph reorg handling failed", {
+      logger9.error("Subgraph reorg handling failed", {
         error: getErrorMessage3(err)
       });
     }
@@ -1897,7 +2053,7 @@ async function startSubgraphProcessor(opts) {
         const def = await loadSubgraphDefinition(sg);
         await catchUpSubgraph(def, sg.name);
       } catch (err) {
-        logger8.error("Subgraph poll processing failed", {
+        logger9.error("Subgraph poll processing failed", {
           subgraph: sg.name,
           error: getErrorMessage3(err)
         });
@@ -1905,19 +2061,19 @@ async function startSubgraphProcessor(opts) {
     }
   }, POLL_INTERVAL_MS);
   const stopEmitter = await startEmitter();
-  logger8.info("Subgraph processor ready");
+  logger9.info("Subgraph processor ready");
   return async () => {
     running = false;
     clearInterval(pollInterval);
     await stopListening();
     await stopReorgListening();
     await stopEmitter();
-    logger8.info("Subgraph processor stopped");
+    logger9.info("Subgraph processor stopped");
   };
 }
 export {
   startSubgraphProcessor
 };
 
-//# debugId=F55D6BAE765B37EA64756E2164756E21
+//# debugId=273D92EC37433C7164756E2164756E21
 //# sourceMappingURL=processor.js.map