@secondlayer/subgraphs 4.2.1 → 4.3.1

package/dist/src/runtime/emitter.js

@@ -7,7 +7,7 @@ import { lookup as dnsLookup } from "node:dns/promises";
 import {
   getTargetDb
 } from "@secondlayer/shared/db";
-import { getSubscriptionSigningSecret } from "@secondlayer/shared/db/queries/subscriptions";
+import { getWebhookSigningSecret } from "@secondlayer/shared/db/queries/webhooks";
 import { logger as logger2 } from "@secondlayer/shared/logger";
 import { listen, targetListenerUrl } from "@secondlayer/shared/queue/listener";
 import { sql as sql2 } from "kysely";
@@ -161,9 +161,9 @@ function buildBody(outboxRow, sub, signingSecret) {
     case "standard-webhooks":
       return buildStandardWebhooks(outboxRow, signingSecret);
     default:
-      logger.warn("Unknown subscription format, falling back to standard-webhooks", {
+      logger.warn("Unknown webhook format, falling back to standard-webhooks", {
         format: sub.format,
-        subscriptionId: sub.id
+        webhookId: sub.id
       });
       return buildStandardWebhooks(outboxRow, signingSecret);
   }
@@ -189,16 +189,16 @@ async function meterBlocksProcessed(accountId, blocks, subgraphName) {
     return true;
   return hooks.onBlocksProcessed(accountId, blocks, subgraphName);
 }
-async function meterDeliveryAttempt(accountId, subscriptionId) {
+async function meterDeliveryAttempt(accountId, webhookId) {
   if (!accountId)
     return true;
   if (!hooks.onDeliveryAttempt)
     return true;
-  return hooks.onDeliveryAttempt(accountId, subscriptionId);
+  return hooks.onDeliveryAttempt(accountId, webhookId);
 }
 
-// src/runtime/subscription-state.ts
-import { listSubscriptions } from "@secondlayer/shared/db/queries/subscriptions";
+// src/runtime/webhook-state.ts
+import { listWebhooks } from "@secondlayer/shared/db/queries/webhooks";
 import { sql } from "kysely";
 
 // src/runtime/emitter-matcher.ts
@@ -318,7 +318,7 @@ function key(subgraphName, tableName) {
   return `${subgraphName}\x00${tableName}`;
 }
 
-class SubscriptionMatcher {
+class WebhookMatcher {
   byKey = new Map;
   byId = new Map;
   setAll(subs) {
@@ -360,11 +360,11 @@ class SubscriptionMatcher {
   }
 }
 
-// src/runtime/subscription-state.ts
-var matcher = new SubscriptionMatcher;
+// src/runtime/webhook-state.ts
+var matcher = new WebhookMatcher;
 async function refreshMatcher(db) {
   const rows = await sql`
-		SELECT * FROM subscriptions WHERE status = 'active'
+		SELECT * FROM webhooks WHERE status = 'active'
 	`.execute(db);
   matcher.setAll(rows.rows);
   return matcher.size();
@@ -375,8 +375,8 @@ var BATCH_SIZE = 50;
 var LIVE_SHARE = 0.9;
 var BACKOFF_SECONDS = [30, 120, 600, 3600, 21600, 86400, 259200];
 var CIRCUIT_THRESHOLD = 20;
-var MAX_SUBSCRIPTION_TIMEOUT_MS = 300000;
-var LOCK_WINDOW_MS = MAX_SUBSCRIPTION_TIMEOUT_MS + 60000;
+var MAX_WEBHOOK_TIMEOUT_MS = 300000;
+var LOCK_WINDOW_MS = MAX_WEBHOOK_TIMEOUT_MS + 60000;
 function nextDelaySeconds(attempt) {
   return BACKOFF_SECONDS[Math.min(attempt, BACKOFF_SECONDS.length - 1)];
 }
@@ -484,7 +484,7 @@ async function checkEgressAllowed(url) {
   return null;
 }
 var MAX_REDIRECT_HOPS = 3;
-async function postToSubscription(url, body, headers, timeoutMs) {
+async function postToWebhook(url, body, headers, timeoutMs) {
   const start = performance.now();
   let target = url;
   let statusCode = null;
@@ -553,14 +553,14 @@ async function postToSubscription(url, body, headers, timeoutMs) {
     responseHeaders
   };
 }
-var __postToSubscriptionForTest = postToSubscription;
+var __postToWebhookForTest = postToWebhook;
 async function dispatchOne(db, outboxRow, sub) {
-  const { body, headers } = buildForFormat(outboxRow, sub, getSubscriptionSigningSecret(sub));
-  const r = await postToSubscription(sub.url, body, headers, sub.timeout_ms);
+  const { body, headers } = buildForFormat(outboxRow, sub, getWebhookSigningSecret(sub));
+  const r = await postToWebhook(sub.url, body, headers, sub.timeout_ms);
   const attempt = outboxRow.attempt + 1;
-  await db.insertInto("subscription_deliveries").values({
+  await db.insertInto("webhook_deliveries").values({
     outbox_id: outboxRow.id,
-    subscription_id: outboxRow.subscription_id,
+    webhook_id: outboxRow.webhook_id,
     attempt,
     status_code: r.statusCode,
     response_headers: r.responseHeaders,
@@ -580,7 +580,7 @@ function buildTestOutboxRow(sub) {
   const now = new Date;
   return {
     id: randomUUID(),
-    subscription_id: sub.id,
+    webhook_id: sub.id,
     kind: sub.kind,
     subgraph_name: sub.subgraph_name ?? null,
     table_name: sub.table_name ?? null,
@@ -591,7 +591,7 @@ function buildTestOutboxRow(sub) {
     payload: {
       test: true,
       message: "Secondlayer test delivery",
-      subscription_id: sub.id,
+      webhook_id: sub.id,
       sent_at: now.toISOString()
     },
     dedup_key: `test:${sub.id}:${now.getTime()}`,
@@ -608,11 +608,11 @@ function buildTestOutboxRow(sub) {
 }
 async function deliverTestEvent(db, sub) {
   const testRow = buildTestOutboxRow(sub);
-  const { body, headers } = buildForFormat(testRow, sub, getSubscriptionSigningSecret(sub));
-  const r = await postToSubscription(sub.url, body, headers, sub.timeout_ms);
-  const inserted = await db.insertInto("subscription_deliveries").values({
+  const { body, headers } = buildForFormat(testRow, sub, getWebhookSigningSecret(sub));
+  const r = await postToWebhook(sub.url, body, headers, sub.timeout_ms);
+  const inserted = await db.insertInto("webhook_deliveries").values({
     outbox_id: null,
-    subscription_id: sub.id,
+    webhook_id: sub.id,
     attempt: 1,
     status_code: r.statusCode,
     response_headers: r.responseHeaders,
@@ -630,20 +630,20 @@ async function deliverTestEvent(db, sub) {
 }
 async function settleDelivered(db, outboxRow) {
   await db.transaction().execute(async (tx) => {
-    await tx.updateTable("subscription_outbox").set({
+    await tx.updateTable("webhook_outbox").set({
       status: "delivered",
       delivered_at: new Date,
       attempt: outboxRow.attempt + 1,
       locked_by: null,
       locked_until: null
     }).where("id", "=", outboxRow.id).execute();
-    await tx.updateTable("subscriptions").set({
+    await tx.updateTable("webhooks").set({
       last_delivery_at: new Date,
       last_success_at: new Date,
       circuit_failures: 0,
       last_error: null,
       updated_at: new Date
-    }).where("id", "=", outboxRow.subscription_id).execute();
+    }).where("id", "=", outboxRow.webhook_id).execute();
   });
 }
 async function settleFailed(db, outboxRow, sub, errText) {
@@ -651,7 +651,7 @@ async function settleFailed(db, outboxRow, sub, errText) {
   const isDead = attempt >= sub.max_retries;
   const nextAt = isDead ? null : new Date(Date.now() + nextDelaySeconds(outboxRow.attempt) * 1000);
   await db.transaction().execute(async (tx) => {
-    await tx.updateTable("subscription_outbox").set({
+    await tx.updateTable("webhook_outbox").set({
       attempt,
       next_attempt_at: nextAt ?? new Date,
       status: isDead ? "dead" : "pending",
@@ -660,7 +660,7 @@ async function settleFailed(db, outboxRow, sub, errText) {
       locked_until: null
     }).where("id", "=", outboxRow.id).execute();
     const incResult = await sql2`
-			UPDATE subscriptions
+			UPDATE webhooks
 			SET circuit_failures = circuit_failures + 1,
 				last_delivery_at = NOW(),
 				last_error = ${errText.slice(0, 500)},
@@ -671,13 +671,13 @@ async function settleFailed(db, outboxRow, sub, errText) {
     const newFailures = incResult.rows[0]?.circuit_failures ?? sub.circuit_failures + 1;
     const shouldTripCircuit = newFailures >= CIRCUIT_THRESHOLD;
     if (shouldTripCircuit) {
-      await tx.updateTable("subscriptions").set({
+      await tx.updateTable("webhooks").set({
         status: "paused",
         circuit_opened_at: new Date,
         updated_at: new Date
       }).where("id", "=", sub.id).execute();
-      logger2.warn("Subscription circuit tripped — paused after consecutive failures", {
-        subscription: sub.name,
+      logger2.warn("Webhook circuit tripped — paused after consecutive failures", {
+        webhook: sub.name,
         failures: newFailures
       });
     }
@@ -692,7 +692,7 @@ async function claimAndDrain(db, state, emitterId) {
     const replayLimit = BATCH_SIZE - liveLimit;
     const claimed = await db.transaction().execute(async (tx) => {
       const live = await sql2`
-					SELECT * FROM subscription_outbox
+					SELECT * FROM webhook_outbox
 					WHERE status = 'pending'
 						AND next_attempt_at <= NOW()
 						AND is_replay = FALSE
@@ -701,7 +701,7 @@ async function claimAndDrain(db, state, emitterId) {
 					LIMIT ${sql2.lit(liveLimit)}
 				`.execute(tx);
       const replay = await sql2`
-					SELECT * FROM subscription_outbox
+					SELECT * FROM webhook_outbox
 					WHERE status = 'pending'
 						AND next_attempt_at <= NOW()
 						AND is_replay = TRUE
@@ -714,7 +714,7 @@ async function claimAndDrain(db, state, emitterId) {
         return [];
       const now = new Date;
       const lockUntil = new Date(now.getTime() + LOCK_WINDOW_MS);
-      await tx.updateTable("subscription_outbox").set({
+      await tx.updateTable("webhook_outbox").set({
         locked_by: emitterId,
         locked_until: lockUntil,
         next_attempt_at: lockUntil
@@ -725,14 +725,14 @@ async function claimAndDrain(db, state, emitterId) {
       return 0;
     const bySubId = new Map;
     for (const row of claimed) {
-      const arr = bySubId.get(row.subscription_id);
+      const arr = bySubId.get(row.webhook_id);
       if (arr)
         arr.push(row);
       else
-        bySubId.set(row.subscription_id, [row]);
+        bySubId.set(row.webhook_id, [row]);
     }
     const subIds = Array.from(bySubId.keys());
-    const subs = await db.selectFrom("subscriptions").selectAll().where("id", "in", subIds).execute();
+    const subs = await db.selectFrom("webhooks").selectAll().where("id", "in", subIds).execute();
     const subById = new Map(subs.map((s) => [s.id, s]));
     await Promise.all(subIds.map((subId) => drainForSub(db, state, subById.get(subId), bySubId.get(subId))));
     return claimed.length;
@@ -781,15 +781,15 @@ async function drainForSub(db, state, sub, rows) {
 }
 async function runRetention(db) {
   await sql2`
-		DELETE FROM subscription_outbox
+		DELETE FROM webhook_outbox
 		WHERE status = 'delivered' AND delivered_at < NOW() - interval '7 days'
 	`.execute(db);
   await sql2`
-		DELETE FROM subscription_deliveries
+		DELETE FROM webhook_deliveries
 		WHERE dispatched_at < NOW() - interval '30 days'
 	`.execute(db);
   await sql2`
-		DELETE FROM subscription_outbox
+		DELETE FROM webhook_outbox
 		WHERE status = 'dead' AND failed_at < NOW() - interval '90 days'
 	`.execute(db);
 }
@@ -826,14 +826,14 @@ async function startEmitter(opts) {
     throw new Error(`[emitter] matcher refresh failed ${MATCHER_BOOT_ATTEMPTS}×; aborting boot: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
   }
   const listenUrl = targetListenerUrl();
-  const stopNew = await listen("subscriptions:new_outbox", () => {
+  const stopNew = await listen("webhooks:new_outbox", () => {
     if (!state.running)
       return;
     claimAndDrain(db, state, emitterId).catch((err) => logger2.error("[emitter] claim failed", {
       error: err instanceof Error ? err.message : String(err)
     }));
   }, { connectionString: listenUrl });
-  const stopChanged = await listen("subscriptions:changed", () => {
+  const stopChanged = await listen("webhooks:changed", () => {
     if (!state.running)
       return;
     refreshMatcher(db).catch((err) => logger2.error("[emitter] matcher refresh failed", {
@@ -869,11 +869,11 @@ export {
   deliverTestEvent,
   checkEgressAllowed,
   __setDnsLookupForTest,
-  __postToSubscriptionForTest,
-  MAX_SUBSCRIPTION_TIMEOUT_MS,
+  __postToWebhookForTest,
+  MAX_WEBHOOK_TIMEOUT_MS,
   MAX_REDIRECT_HOPS,
   LOCK_WINDOW_MS
 };
 
-//# debugId=DBFC05A3E3ECCD9D64756E2164756E21
+//# debugId=15D49DA18C7A55F864756E2164756E21
 //# sourceMappingURL=emitter.js.map