@secondlayer/subgraphs 4.2.0 → 4.3.0

package/dist/src/service.js

@@ -2701,7 +2701,7 @@ function stableStringify(obj) {
     return acc;
   }, {}));
 }
-async function emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, blockHeight) {
+async function emitWebhookOutbox(tx, subgraphName, manifest, matcher, blockHeight) {
   if (!isEmitOutboxEnabled()) {
     if (!loggedKillSwitch) {
       logger6.warn("SECONDLAYER_EMIT_OUTBOX=false — outbox emission bypassed");
@@ -2720,7 +2720,7 @@ async function emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block
     const eventType = `${subgraphName}.${write.table}.${OP_VERB[write.op]}`;
     for (const s of subs) {
       rows.push({
-        subscription_id: s.id,
+        webhook_id: s.id,
         subgraph_name: subgraphName,
         table_name: write.table,
         block_height: blockHeight,
@@ -2734,7 +2734,7 @@ async function emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block
   }
   if (rows.length === 0)
     return 0;
-  await tx.insertInto("subscription_outbox").values(rows).onConflict((oc) => oc.columns(["subscription_id", "dedup_key"]).doNothing()).execute();
+  await tx.insertInto("webhook_outbox").values(rows).onConflict((oc) => oc.columns(["webhook_id", "dedup_key"]).doNothing()).execute();
   return rows.length;
 }
 
@@ -3047,8 +3047,8 @@ async function answerRead(hostCtx, msg) {
   }
 }
 
-// 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 as sql3 } from "kysely";
 
 // src/runtime/emitter-matcher.ts
@@ -3168,7 +3168,7 @@ function key(subgraphName, tableName) {
   return `${subgraphName}\x00${tableName}`;
 }
 
-class SubscriptionMatcher {
+class WebhookMatcher {
   byKey = new Map;
   byId = new Map;
   setAll(subs) {
@@ -3210,11 +3210,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 sql3`
-		SELECT * FROM subscriptions WHERE status = 'active'
+		SELECT * FROM webhooks WHERE status = 'active'
 	`.execute(db);
   matcher.setAll(rows.rows);
   return matcher.size();
@@ -3504,7 +3504,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
         const manifest = await ctx.flush();
         flushedWrites = manifest.count > 0;
         if (manifest.count > 0) {
-          await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
+          await emitWebhookOutbox(tx, subgraphName, manifest, matcher, block.height);
         }
         flushMs = performance.now() - flushStart;
       }
@@ -4638,8 +4638,8 @@ async function reorgOneSubgraph(sg, schema, blockHeight, loadSubgraphDef) {
   for (const [tableName, rows] of Object.entries(revertedByTable)) {
     if (rows.length === 0)
       continue;
-    await targetDb.insertInto("subscription_outbox").columns([
-      "subscription_id",
+    await targetDb.insertInto("webhook_outbox").columns([
+      "webhook_id",
       "subgraph_name",
       "table_name",
       "block_height",
@@ -4648,8 +4648,8 @@ async function reorgOneSubgraph(sg, schema, blockHeight, loadSubgraphDef) {
       "dedup_key",
       "row_pk",
       "status"
-    ]).expression((eb) => eb.selectFrom("subscriptions").select((eb2) => [
-      "id as subscription_id",
+    ]).expression((eb) => eb.selectFrom("webhooks").select((eb2) => [
+      "id as webhook_id",
       eb2.val(sg.name).as("subgraph_name"),
       eb2.val(tableName).as("table_name"),
       eb2.val(blockHeight).as("block_height"),
@@ -4667,8 +4667,8 @@ async function reorgOneSubgraph(sg, schema, blockHeight, loadSubgraphDef) {
         reorgRoot: blockHeight
       }).as("row_pk"),
       eb2.val("pending").as("status")
-    ]).where("subgraph_name", "=", sg.name).where("table_name", "=", tableName).where("status", "=", "active")).onConflict((oc) => oc.columns(["subscription_id", "dedup_key"]).doNothing()).execute().catch((err) => {
-      logger12.error("Failed to emit revert event for subscriptions", {
+    ]).where("subgraph_name", "=", sg.name).where("table_name", "=", tableName).where("status", "=", "active")).onConflict((oc) => oc.columns(["webhook_id", "dedup_key"]).doNothing()).execute().catch((err) => {
+      logger12.error("Failed to emit revert event for webhooks", {
         event: "reorg_revert_emit_dropped",
         subgraph: sg.name,
         table: tableName,
@@ -4720,6 +4720,26 @@ import {
   targetListenerUrl as targetListenerUrl2
 } from "@secondlayer/shared/queue/listener";
 
+// src/runtime/hosted-meter.ts
+var hooks = {};
+function setHostedMeterHooks(next) {
+  hooks = next;
+}
+async function meterBlocksProcessed(accountId, blocks, subgraphName) {
+  if (!accountId || blocks <= 0)
+    return true;
+  if (!hooks.onBlocksProcessed)
+    return true;
+  return hooks.onBlocksProcessed(accountId, blocks, subgraphName);
+}
+async function meterDeliveryAttempt(accountId, webhookId) {
+  if (!accountId)
+    return true;
+  if (!hooks.onDeliveryAttempt)
+    return true;
+  return hooks.onDeliveryAttempt(accountId, webhookId);
+}
+
 // src/runtime/streams-reorg-poll.ts
 import { getErrorMessage as getErrorMessage5 } from "@secondlayer/shared";
 import {
@@ -4795,7 +4815,8 @@ async function catchUpAll(subgraphs, db, concurrency) {
         break;
       try {
         const def = await loadSubgraphDefinition(sg);
-        await catchUpSubgraph(def, sg.name);
+        const processed = await catchUpSubgraph(def, sg.name);
+        await meterBlocksProcessed(sg.account_id, processed, sg.name);
       } catch (err) {
         const msg = getErrorMessage6(err);
         if (isHandlerNotFoundError(err)) {
@@ -4893,38 +4914,45 @@ async function runSubgraphOperation(operation, signal) {
   const subgraph = await db.selectFrom("subgraphs").selectAll().where("id", "=", operation.subgraph_id).executeTakeFirst();
   if (!subgraph)
     throw new Error(`Subgraph not found: ${operation.subgraph_id}`);
+  if (subgraph.status === "paused")
+    return 0;
   const def = await loadSubgraphDefinition(subgraph);
   const schemaName = subgraph.schema_name ?? pgSchemaName2(subgraph.name);
+  let processed = 0;
   if (operation.kind === "backfill") {
     if (operation.from_block == null || operation.to_block == null) {
       throw new Error("Backfill operation is missing from_block or to_block");
     }
     const resumeFrom = operation.cursor_block != null ? Math.max(Number(operation.from_block), Number(operation.cursor_block) + 1) : Number(operation.from_block);
-    const result2 = await backfillSubgraph(def, {
+    const result = await backfillSubgraph(def, {
       fromBlock: resumeFrom,
       toBlock: Number(operation.to_block),
       schemaName,
       operationId: operation.id,
       signal
     });
-    return result2.processed;
-  }
-  const hasResumeMetadata = subgraph.status === "reindexing" && subgraph.reindex_from_block != null && subgraph.reindex_to_block != null;
-  if (hasResumeMetadata) {
-    const result2 = await resumeReindex(def, {
-      schemaName,
-      operationId: operation.id,
-      signal
-    });
-    return result2.processed;
+    processed = result.processed;
+  } else {
+    const hasResumeMetadata = subgraph.status === "reindexing" && subgraph.reindex_from_block != null && subgraph.reindex_to_block != null;
+    if (hasResumeMetadata) {
+      const result = await resumeReindex(def, {
+        schemaName,
+        operationId: operation.id,
+        signal
+      });
+      processed = result.processed;
+    } else {
+      const result = await reindexSubgraph(def, {
+        startBlockFloor: operation.from_block == null ? undefined : Number(operation.from_block),
+        schemaName,
+        operationId: operation.id,
+        signal
+      });
+      processed = result.processed;
+    }
   }
-  const result = await reindexSubgraph(def, {
-    startBlockFloor: operation.from_block == null ? undefined : Number(operation.from_block),
-    schemaName,
-    operationId: operation.id,
-    signal
-  });
-  return result.processed;
+  await meterBlocksProcessed(subgraph.account_id, processed, subgraph.name);
+  return processed;
 }
 async function startSubgraphOperationRunner(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_OPERATION_CONCURRENCY;
@@ -5130,6 +5158,7 @@ async function startSubgraphProcessor(opts) {
 // src/service.ts
 import { assertDbSplit, getDb } from "@secondlayer/shared/db";
 import { logger as logger15 } from "@secondlayer/shared/logger";
+import { isPlatformMode } from "@secondlayer/shared/mode";
 import { sql as sql7 } from "kysely";
 var HEARTBEAT_INTERVAL_MS2 = 30000;
 var SERVICE_NAME = "subgraph-processor";
@@ -5143,6 +5172,20 @@ async function writeHeartbeat() {
   }
 }
 assertDbSplit();
+if (isPlatformMode()) {
+  try {
+    const spec = "@secondlayer/platform/hosted-meters";
+    const mod = await import(spec);
+    setHostedMeterHooks({
+      onBlocksProcessed: mod.onBlocksProcessed,
+      onDeliveryAttempt: mod.onDeliveryAttempt
+    });
+  } catch (err) {
+    logger15.warn("hosted meters not installed; indexing unmetered", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
 var processor = await startSubgraphProcessor({
   concurrency: Number.parseInt(process.env.SUBGRAPH_CONCURRENCY ?? "5")
 });
@@ -5157,5 +5200,5 @@ var shutdown = async () => {
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 
-//# debugId=DF841AAE92C1E98664756E2164756E21
+//# debugId=075E602303939FCE64756E2164756E21
 //# sourceMappingURL=service.js.map