@secondlayer/shared 11.4.3 → 11.5.0

package/dist/src/index.js

@@ -778,9 +778,9 @@ var TABLE_TO_DB = {
   play_provisions: "target",
   account_spend_caps: "target",
   processed_stripe_events: "target",
-  subscriptions: "target",
-  subscription_outbox: "target",
-  subscription_deliveries: "target",
+  webhooks: "target",
+  webhook_outbox: "target",
+  webhook_deliveries: "target",
   trigger_evaluator_state: "target",
   subgraphs: "target",
   subgraph_operations: "target",
@@ -1118,9 +1118,9 @@ var DeploySubgraphRequestSchema = z2.object({
   dryRun: z2.boolean().optional()
 });
 
-// src/schemas/subscriptions.ts
+// src/schemas/webhooks.ts
 import { z as z3 } from "zod";
-var SUBSCRIPTION_FORMATS = [
+var WEBHOOK_FORMATS = [
   "standard-webhooks",
   "inngest",
   "trigger",
@@ -1128,14 +1128,14 @@ var SUBSCRIPTION_FORMATS = [
   "cloudevents",
   "raw"
 ];
-var SUBSCRIPTION_RUNTIMES = [
+var WEBHOOK_RUNTIMES = [
   "inngest",
   "trigger",
   "cloudflare",
   "node"
 ];
-var SUBSCRIPTION_STATUSES = ["active", "paused", "error"];
-var SUBSCRIPTION_FILTER_OPERATORS = [
+var WEBHOOK_STATUSES = ["active", "paused", "error"];
+var WEBHOOK_FILTER_OPERATORS = [
   "eq",
   "neq",
   "gt",
@@ -1147,26 +1147,23 @@ var SUBSCRIPTION_FILTER_OPERATORS = [
 var webhookUrl = z3.string().trim().min(1).refine((value) => value.startsWith("http://") || value.startsWith("https://"), "must be an http(s) URL");
 var name = z3.string().trim().min(1).max(128);
 var resourceName = z3.string().trim().min(1).max(128);
-var SubscriptionStatusSchema = z3.enum(SUBSCRIPTION_STATUSES);
-var SubscriptionFormatSchema = z3.enum(SUBSCRIPTION_FORMATS);
-var SubscriptionRuntimeSchema = z3.enum(SUBSCRIPTION_RUNTIMES);
-var SubscriptionFilterPrimitiveSchema = z3.union([z3.string(), z3.number().finite(), z3.boolean()]);
-var SubscriptionFilterOperatorSchema = z3.union([
-  z3.object({ eq: SubscriptionFilterPrimitiveSchema }).strict(),
-  z3.object({ neq: SubscriptionFilterPrimitiveSchema }).strict(),
+var WebhookStatusSchema = z3.enum(WEBHOOK_STATUSES);
+var WebhookFormatSchema = z3.enum(WEBHOOK_FORMATS);
+var WebhookRuntimeSchema = z3.enum(WEBHOOK_RUNTIMES);
+var WebhookFilterPrimitiveSchema = z3.union([z3.string(), z3.number().finite(), z3.boolean()]);
+var WebhookFilterOperatorSchema = z3.union([
+  z3.object({ eq: WebhookFilterPrimitiveSchema }).strict(),
+  z3.object({ neq: WebhookFilterPrimitiveSchema }).strict(),
   z3.object({ gt: z3.union([z3.string(), z3.number().finite()]) }).strict(),
   z3.object({ gte: z3.union([z3.string(), z3.number().finite()]) }).strict(),
   z3.object({ lt: z3.union([z3.string(), z3.number().finite()]) }).strict(),
   z3.object({ lte: z3.union([z3.string(), z3.number().finite()]) }).strict(),
   z3.object({
-    in: z3.array(SubscriptionFilterPrimitiveSchema).min(1)
+    in: z3.array(WebhookFilterPrimitiveSchema).min(1)
   }).strict()
 ]);
-var SubscriptionFilterClauseSchema = z3.union([
-  SubscriptionFilterPrimitiveSchema,
-  SubscriptionFilterOperatorSchema
-]);
-var SubscriptionFilterSchema = z3.record(z3.string().min(1), SubscriptionFilterClauseSchema);
+var WebhookFilterClauseSchema = z3.union([WebhookFilterPrimitiveSchema, WebhookFilterOperatorSchema]);
+var WebhookFilterSchema = z3.record(z3.string().min(1), WebhookFilterClauseSchema);
 var CHAIN_TRIGGER_TYPES = [
   "stx_transfer",
   "stx_mint",
@@ -1311,15 +1308,15 @@ var CHAIN_TRIGGER_FIELDS = Object.fromEntries(ChainTriggerSchema._zod.def.option
   const type = shape.type._zod.def.values[0];
   return [type, Object.keys(shape).filter((k) => k !== "type")];
 }));
-var CreateSubscriptionRequestSchema = z3.object({
+var CreateWebhookRequestSchema = z3.object({
   name,
   subgraphName: resourceName.optional(),
   tableName: resourceName.optional(),
-  filter: SubscriptionFilterSchema.optional(),
+  filter: WebhookFilterSchema.optional(),
   triggers: ChainTriggersSchema.optional(),
   url: webhookUrl,
-  format: SubscriptionFormatSchema.default("standard-webhooks"),
-  runtime: SubscriptionRuntimeSchema.nullable().optional(),
+  format: WebhookFormatSchema.default("standard-webhooks"),
+  runtime: WebhookRuntimeSchema.nullable().optional(),
   authConfig: z3.record(z3.string(), z3.unknown()).optional(),
   maxRetries: z3.number().int().min(0).max(100).optional(),
   timeoutMs: z3.number().int().min(100).max(300000).optional(),
@@ -1333,17 +1330,17 @@ var CreateSubscriptionRequestSchema = z3.object({
     return true;
   return v.subgraphName !== undefined && v.tableName !== undefined;
 }, {
-  message: "provide either { subgraphName, tableName } for a subgraph subscription OR { triggers } for a chain subscription — not both"
+  message: "provide either { subgraphName, tableName } for a subgraph webhook OR { triggers } for a chain webhook — not both"
 }).refine((v) => v.filter === undefined || v.triggers === undefined, {
-  message: "`filter` applies to subgraph subscriptions; chain subscriptions use `triggers`",
+  message: "`filter` applies to subgraph webhooks; chain webhooks use `triggers`",
   path: ["filter"]
 });
-var UpdateSubscriptionRequestSchema = z3.object({
+var UpdateWebhookRequestSchema = z3.object({
   name: name.optional(),
   url: webhookUrl.optional(),
-  filter: SubscriptionFilterSchema.optional(),
-  format: SubscriptionFormatSchema.optional(),
-  runtime: SubscriptionRuntimeSchema.nullable().optional(),
+  filter: WebhookFilterSchema.optional(),
+  format: WebhookFormatSchema.optional(),
+  runtime: WebhookRuntimeSchema.nullable().optional(),
   authConfig: z3.record(z3.string(), z3.unknown()).optional(),
   maxRetries: z3.number().int().min(0).max(100).optional(),
   timeoutMs: z3.number().int().min(100).max(300000).optional(),
@@ -1351,7 +1348,7 @@ var UpdateSubscriptionRequestSchema = z3.object({
 }).refine((value) => Object.keys(value).length > 0, {
   message: "At least one field must be provided"
 });
-var ReplaySubscriptionRequestSchema = z3.object({
+var ReplayWebhookRequestSchema = z3.object({
   fromBlock: z3.number().int().nonnegative(),
   toBlock: z3.number().int().nonnegative(),
   force: z3.string().trim().min(1).max(64).optional()
@@ -1445,7 +1442,7 @@ var COMPARISON_COLUMN_TYPES = new Set(["uint", "int", "timestamp"]);
 function formatIssuePath(path) {
   return path.length > 0 ? `${path.map(String).join(".")}: ` : "";
 }
-function formatSubscriptionSchemaErrors(error) {
+function formatWebhookSchemaErrors(error) {
   return error.issues.map((issue) => `${formatIssuePath(issue.path)}${issue.message}`);
 }
 function operatorForClause(clause) {
@@ -1454,7 +1451,7 @@ function operatorForClause(clause) {
   }
   return Object.keys(clause)[0] ?? "eq";
 }
-function validateSubscriptionFilterForTable(input) {
+function validateWebhookFilterForTable(input) {
   const errors = [];
   const table = input.tables[input.tableName];
   if (!table) {
@@ -1464,9 +1461,9 @@ function validateSubscriptionFilterForTable(input) {
   }
   if (input.filter === undefined)
     return errors;
-  const parsed = SubscriptionFilterSchema.safeParse(input.filter);
+  const parsed = WebhookFilterSchema.safeParse(input.filter);
   if (!parsed.success) {
-    return formatSubscriptionSchemaErrors(parsed.error);
+    return formatWebhookSchemaErrors(parsed.error);
   }
   for (const [field, clause] of Object.entries(parsed.data)) {
     const column = table.columns[field];
@@ -1476,7 +1473,7 @@ function validateSubscriptionFilterForTable(input) {
     }
     const columnType = typeof column.type === "string" ? column.type.toLowerCase() : "";
     if (!SCALAR_COLUMN_TYPES.has(columnType)) {
-      errors.push(`Filter field "${field}" has unsupported type "${columnType || "unknown"}"; subscription filters require scalar columns.`);
+      errors.push(`Filter field "${field}" has unsupported type "${columnType || "unknown"}"; webhook filters require scalar columns.`);
       continue;
     }
     const operator = operatorForClause(clause);
@@ -2078,7 +2075,7 @@ function blockEndCursor(height) {
   };
 }
 export {
-  validateSubscriptionFilterForTable,
+  validateWebhookFilterForTable,
   sql2 as sql,
   setMigrationRole,
   parseJsonb,
@@ -2104,7 +2101,7 @@ export {
   generateSubgraphOpenApi,
   generateSubgraphMarkdown,
   generateSubgraphAgentSchema,
-  formatSubscriptionSchemaErrors,
+  formatWebhookSchemaErrors,
   finalizedBurnHeight,
   encodeStreamsCursor,
   exports_ed25519 as ed25519,
@@ -2115,30 +2112,30 @@ export {
   blockEndCursor,
   assertDbSplit,
   applicationDatabaseUrl,
+  WebhookStatusSchema,
+  WebhookRuntimeSchema,
+  WebhookFormatSchema,
+  WebhookFilterSchema,
+  WebhookFilterPrimitiveSchema,
+  WebhookFilterOperatorSchema,
+  WebhookFilterClauseSchema,
+  WEBHOOK_STATUSES,
+  WEBHOOK_RUNTIMES,
+  WEBHOOK_FORMATS,
+  WEBHOOK_FILTER_OPERATORS,
   VersionConflictError,
   ValidationError,
-  UpdateSubscriptionRequestSchema,
+  UpdateWebhookRequestSchema,
   TenantSuspendedError,
   TABLE_TO_DB,
-  SubscriptionStatusSchema,
-  SubscriptionRuntimeSchema,
-  SubscriptionFormatSchema,
-  SubscriptionFilterSchema,
-  SubscriptionFilterPrimitiveSchema,
-  SubscriptionFilterOperatorSchema,
-  SubscriptionFilterClauseSchema,
   SecondLayerError,
-  SUBSCRIPTION_STATUSES,
-  SUBSCRIPTION_RUNTIMES,
-  SUBSCRIPTION_FORMATS,
-  SUBSCRIPTION_FILTER_OPERATORS,
   STREAMS_TO_DB_EVENT_TYPES,
   STREAMS_EVENT_TYPES,
   STREAMS_DB_EVENT_TYPES,
   SOURCE_READ_TYPES,
   SOURCE_READ_PKS,
   SOURCE_READ_COLUMNS,
-  ReplaySubscriptionRequestSchema,
+  ReplayWebhookRequestSchema,
   RateLimitError,
   PaymentRequiredError,
   NotFoundError,
@@ -2151,7 +2148,7 @@ export {
   DEFAULT_BTC_CONFIRMATIONS,
   DECODED_EVENT_TYPES2 as DECODED_EVENT_TYPES,
   DB_TO_STREAMS_EVENT_TYPE,
-  CreateSubscriptionRequestSchema,
+  CreateWebhookRequestSchema,
   CODE_TO_STATUS,
   CHAIN_TRIGGER_TYPES,
   CHAIN_TRIGGER_FIELDS,
@@ -2159,5 +2156,5 @@ export {
   AuthenticationError
 };
 
-//# debugId=8C0A8E0ACCA81ACC64756E2164756E21
+//# debugId=D3AB339890A27E2964756E2164756E21
 //# sourceMappingURL=index.js.map