@automate.ax/catalog 0.83.3 → 0.85.0

package/dist/triggers/stripe.d.ts

@@ -0,0 +1,262 @@
+export declare const stripeTriggerDefinitions: {
+    readonly stripeChargeDisputeClosed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.charge.dispute.closed";
+    };
+    readonly stripeChargeDisputeCreated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.charge.dispute.created";
+    };
+    readonly stripeCheckoutSessionCompleted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.checkout.session.completed";
+    };
+    readonly stripeCheckoutSessionAsyncPaymentFailed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.checkout.session.asyncPaymentFailed";
+    };
+    readonly stripeCheckoutSessionAsyncPaymentSucceeded: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.checkout.session.asyncPaymentSucceeded";
+    };
+    readonly stripeCheckoutSessionExpired: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.checkout.session.expired";
+    };
+    readonly stripeCustomerCreated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.customer.created";
+    };
+    readonly stripeCustomerDeleted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.customer.deleted";
+    };
+    readonly stripeCustomerSubscriptionCreated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.customer.subscription.created";
+    };
+    readonly stripeCustomerSubscriptionDeleted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.customer.subscription.deleted";
+    };
+    readonly stripeCustomerSubscriptionTrialWillEnd: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.customer.subscription.trialWillEnd";
+    };
+    readonly stripeCustomerSubscriptionUpdated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.customer.subscription.updated";
+    };
+    readonly stripeCustomerUpdated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.customer.updated";
+    };
+    readonly stripeEvent: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.event";
+    };
+    readonly stripeInvoiceFinalized: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.invoice.finalized";
+    };
+    readonly stripeInvoiceOverdue: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.invoice.overdue";
+    };
+    readonly stripeInvoicePaid: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.invoice.paid";
+    };
+    readonly stripeInvoicePaymentFailed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.invoice.paymentFailed";
+    };
+    readonly stripeInvoiceVoided: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.invoice.voided";
+    };
+    readonly stripePaymentIntentCanceled: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.paymentIntent.canceled";
+    };
+    readonly stripePaymentIntentPaymentFailed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.paymentIntent.paymentFailed";
+    };
+    readonly stripePaymentIntentSucceeded: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.paymentIntent.succeeded";
+    };
+    readonly stripePayoutFailed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.payout.failed";
+    };
+    readonly stripePayoutPaid: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.payout.paid";
+    };
+    readonly stripeRefundCreated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.refund.created";
+    };
+    readonly stripeRefundFailed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "api-key";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "stripe";
+        };
+        readonly type: "stripe.refund.failed";
+    };
+};

package/dist/triggers/stripe.js

@@ -0,0 +1,107 @@
+const STRIPE_ACCOUNT = {
+    connectionOptions: [{ connectionMethodId: "api-key", requiredScopes: [] }],
+    serviceId: "stripe",
+};
+export const stripeTriggerDefinitions = {
+    stripeChargeDisputeClosed: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.charge.dispute.closed",
+    },
+    stripeChargeDisputeCreated: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.charge.dispute.created",
+    },
+    stripeCheckoutSessionCompleted: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.checkout.session.completed",
+    },
+    stripeCheckoutSessionAsyncPaymentFailed: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.checkout.session.asyncPaymentFailed",
+    },
+    stripeCheckoutSessionAsyncPaymentSucceeded: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.checkout.session.asyncPaymentSucceeded",
+    },
+    stripeCheckoutSessionExpired: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.checkout.session.expired",
+    },
+    stripeCustomerCreated: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.customer.created",
+    },
+    stripeCustomerDeleted: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.customer.deleted",
+    },
+    stripeCustomerSubscriptionCreated: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.customer.subscription.created",
+    },
+    stripeCustomerSubscriptionDeleted: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.customer.subscription.deleted",
+    },
+    stripeCustomerSubscriptionTrialWillEnd: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.customer.subscription.trialWillEnd",
+    },
+    stripeCustomerSubscriptionUpdated: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.customer.subscription.updated",
+    },
+    stripeCustomerUpdated: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.customer.updated",
+    },
+    stripeEvent: { account: STRIPE_ACCOUNT, type: "stripe.event" },
+    stripeInvoiceFinalized: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.invoice.finalized",
+    },
+    stripeInvoiceOverdue: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.invoice.overdue",
+    },
+    stripeInvoicePaid: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.invoice.paid",
+    },
+    stripeInvoicePaymentFailed: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.invoice.paymentFailed",
+    },
+    stripeInvoiceVoided: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.invoice.voided",
+    },
+    stripePaymentIntentCanceled: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.paymentIntent.canceled",
+    },
+    stripePaymentIntentPaymentFailed: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.paymentIntent.paymentFailed",
+    },
+    stripePaymentIntentSucceeded: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.paymentIntent.succeeded",
+    },
+    stripePayoutFailed: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.payout.failed",
+    },
+    stripePayoutPaid: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.payout.paid",
+    },
+    stripeRefundCreated: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.refund.created",
+    },
+    stripeRefundFailed: {
+        account: STRIPE_ACCOUNT,
+        type: "stripe.refund.failed",
+    },
+};

package/dist/triggers/webflow.d.ts

@@ -0,0 +1,63 @@
+import type { IntegrationAccountRequirement } from "../types.js";
+export declare const webflowTriggerDefinitions: {
+    readonly webflowCollectionItemChanged: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.collectionItem.changed";
+    };
+    readonly webflowCollectionItemCreated: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.collectionItem.created";
+    };
+    readonly webflowCollectionItemDeleted: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.collectionItem.deleted";
+    };
+    readonly webflowCollectionItemPublished: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.collectionItem.published";
+    };
+    readonly webflowCollectionItemUnpublished: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.collectionItem.unpublished";
+    };
+    readonly webflowCommentCreated: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.comment.created";
+    };
+    readonly webflowEvent: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.event";
+    };
+    readonly webflowFormSubmitted: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.form.submitted";
+    };
+    readonly webflowInventoryChanged: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.inventory.changed";
+    };
+    readonly webflowOrderChanged: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.order.changed";
+    };
+    readonly webflowOrderCreated: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.order.created";
+    };
+    readonly webflowPageCreated: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.page.created";
+    };
+    readonly webflowPageDeleted: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.page.deleted";
+    };
+    readonly webflowPageMetadataUpdated: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.page.metadataUpdated";
+    };
+    readonly webflowSitePublished: {
+        readonly account: IntegrationAccountRequirement<"webflow">;
+        readonly type: "webflow.site.published";
+    };
+};

package/dist/triggers/webflow.js

@@ -0,0 +1,86 @@
+const WEBFLOW_SITE_READ_ACCOUNT = webflowAccount(["sites:read"]);
+export const webflowTriggerDefinitions = {
+    webflowCollectionItemChanged: {
+        account: webflowAccount(["cms:read"]),
+        type: "webflow.collectionItem.changed",
+    },
+    webflowCollectionItemCreated: {
+        account: webflowAccount(["cms:read"]),
+        type: "webflow.collectionItem.created",
+    },
+    webflowCollectionItemDeleted: {
+        account: webflowAccount(["cms:read"]),
+        type: "webflow.collectionItem.deleted",
+    },
+    webflowCollectionItemPublished: {
+        account: webflowAccount(["cms:read"]),
+        type: "webflow.collectionItem.published",
+    },
+    webflowCollectionItemUnpublished: {
+        account: webflowAccount(["cms:read"]),
+        type: "webflow.collectionItem.unpublished",
+    },
+    webflowCommentCreated: {
+        account: webflowAccount(["comments:read"]),
+        type: "webflow.comment.created",
+    },
+    webflowEvent: {
+        account: webflowAccount([
+            "cms:read",
+            "comments:read",
+            "ecommerce:read",
+            "forms:read",
+            "pages:read",
+            "sites:read",
+        ]),
+        type: "webflow.event",
+    },
+    webflowFormSubmitted: {
+        account: webflowAccount(["forms:read"]),
+        type: "webflow.form.submitted",
+    },
+    webflowInventoryChanged: {
+        account: webflowAccount(["ecommerce:read"]),
+        type: "webflow.inventory.changed",
+    },
+    webflowOrderChanged: {
+        account: webflowAccount(["ecommerce:read"]),
+        type: "webflow.order.changed",
+    },
+    webflowOrderCreated: {
+        account: webflowAccount(["ecommerce:read"]),
+        type: "webflow.order.created",
+    },
+    webflowPageCreated: {
+        account: webflowAccount(["pages:read"]),
+        type: "webflow.page.created",
+    },
+    webflowPageDeleted: {
+        account: webflowAccount(["pages:read"]),
+        type: "webflow.page.deleted",
+    },
+    webflowPageMetadataUpdated: {
+        account: webflowAccount(["pages:read"]),
+        type: "webflow.page.metadataUpdated",
+    },
+    webflowSitePublished: {
+        account: WEBFLOW_SITE_READ_ACCOUNT,
+        type: "webflow.site.published",
+    },
+};
+/**
+ * Requires webhook management plus the scopes needed for delivered events.
+ *
+ * @param eventScopes - Read scopes required by the selected provider events.
+ */
+function webflowAccount(eventScopes) {
+    return {
+        connectionOptions: [
+            {
+                connectionMethodId: "oauth",
+                requiredScopes: ["sites:write", ...eventScopes],
+            },
+        ],
+        serviceId: "webflow",
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automate.ax/catalog",
-  "version": "0.83.3",
+  "version": "0.85.0",
   "description": "Shared integration service and trigger definitions for Automate.ax.",
   "license": "MIT",
   "repository": {
@@ -36,8 +36,10 @@
       "./triggers/name": "./src/triggers/name.ts",
       "./triggers/resend": "./src/triggers/resend.ts",
       "./triggers/slack": "./src/triggers/slack.ts",
+      "./triggers/stripe": "./src/triggers/stripe.ts",
       "./triggers/trello": "./src/triggers/trello.ts",
       "./triggers/vercel": "./src/triggers/vercel.ts",
+      "./triggers/webflow": "./src/triggers/webflow.ts",
       "./triggers/whatsapp": "./src/triggers/whatsapp.ts"
     },
     "cjs": false,
@@ -46,7 +48,7 @@
     }
   },
   "devDependencies": {
-    "@internal/config": "0.1.0",
+    "@internal/config": "0.2.0",
     "@types/bun": "latest",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@zachsents/oxlint-config": "^0.4.1",
@@ -167,6 +169,11 @@
       "types": "./dist/triggers/slack.d.ts",
       "default": "./dist/triggers/slack.js"
     },
+    "./triggers/stripe": {
+      "bun": "./src/triggers/stripe.ts",
+      "types": "./dist/triggers/stripe.d.ts",
+      "default": "./dist/triggers/stripe.js"
+    },
     "./triggers/trello": {
       "bun": "./src/triggers/trello.ts",
       "types": "./dist/triggers/trello.d.ts",
@@ -177,6 +184,11 @@
       "types": "./dist/triggers/vercel.d.ts",
       "default": "./dist/triggers/vercel.js"
     },
+    "./triggers/webflow": {
+      "bun": "./src/triggers/webflow.ts",
+      "types": "./dist/triggers/webflow.d.ts",
+      "default": "./dist/triggers/webflow.js"
+    },
     "./triggers/whatsapp": {
       "bun": "./src/triggers/whatsapp.ts",
       "types": "./dist/triggers/whatsapp.d.ts",

package/src/catalog.ts

@@ -361,6 +361,23 @@ export const slackService = defineIntegrationService({
   name: "Slack",
 })
 
+export const stripeService = defineApiKeyService({
+  connectionNotice: {
+    action: {
+      href: "https://docs.stripe.com/keys#limit-access",
+      label: "Review permissions",
+    },
+    description:
+      "Restricted keys need read access to Account for connection checks. Managed triggers also need write access to Webhook Endpoints.",
+    title: "Stripe restricted-key permissions",
+  },
+  credentialUrl: "https://dashboard.stripe.com/apikeys",
+  description: "Connect a Stripe account with a secret or restricted API key.",
+  id: "stripe",
+  name: "Stripe",
+  placeholder: "sk_test_... or rk_test_...",
+})
+
 export const tidycalService = defineIntegrationService({
   connectionMethods: [{ id: "oauth", name: "OAuth", type: "redirect" }],
   description: "Connect a TidyCal account.",
@@ -421,6 +438,13 @@ export const whatsappService = defineIntegrationService({
   name: "WhatsApp",
 })
 
+export const webflowService = defineIntegrationService({
+  connectionMethods: [{ id: "oauth", name: "OAuth", type: "redirect" }],
+  description: "Connect Webflow sites and workspaces.",
+  id: "webflow",
+  name: "Webflow",
+})
+
 export const xaiService = defineApiKeyService({
   description: "Connect an xAI API key.",
   id: "xai",
@@ -460,11 +484,13 @@ export const integrationCatalog = defineIntegrationCatalog([
   resendService,
   scrapflyService,
   slackService,
+  stripeService,
   tidycalService,
   togetheraiService,
   trelloService,
   vercelAiGatewayService,
   vercelService,
+  webflowService,
   whatsappService,
   xaiService,
 ])
@@ -482,7 +508,8 @@ export function getIntegrationService(
   return integrationCatalog.find((service) => service.id === id)
 }
 
-interface ApiKeyServiceDefinition {
+interface ApiKeyServiceDefinition
+  extends Pick<IntegrationServiceDefinition, "connectionNotice"> {
   credentialUrl?: string
   description: string
   icon?: string
@@ -515,6 +542,9 @@ function defineApiKeyService<const TId extends string>(
         type: "form",
       },
     ],
+    ...(service.connectionNotice
+      ? { connectionNotice: service.connectionNotice }
+      : {}),
     description: service.description,
     ...(service.icon ? { icon: service.icon } : {}),
     id: service.id,

package/src/index.ts

@@ -32,11 +32,13 @@ export {
   resendService,
   scrapflyService,
   slackService,
+  stripeService,
   tidycalService,
   togetheraiService,
   trelloService,
   vercelAiGatewayService,
   vercelService,
+  webflowService,
   whatsappService,
   xaiService,
   type IntegrationServiceId,

package/src/triggers/index.ts

@@ -9,8 +9,10 @@ import { linearTriggerDefinitions } from "./linear"
 import { microsoftTriggerDefinitions } from "./microsoft"
 import { resendTriggerDefinitions } from "./resend"
 import { slackTriggerDefinitions } from "./slack"
+import { stripeTriggerDefinitions } from "./stripe"
 import { trelloTriggerDefinitions } from "./trello"
 import { vercelTriggerDefinitions } from "./vercel"
+import { webflowTriggerDefinitions } from "./webflow"
 import { whatsappTriggerDefinitions } from "./whatsapp"
 import { sentenceCase } from "./name"
 import { getIntegrationService } from "../catalog"
@@ -52,8 +54,10 @@ export const triggerDefinitions = {
   ...microsoftTriggerDefinitions,
   ...resendTriggerDefinitions,
   ...slackTriggerDefinitions,
+  ...stripeTriggerDefinitions,
   ...trelloTriggerDefinitions,
   ...vercelTriggerDefinitions,
+  ...webflowTriggerDefinitions,
   ...whatsappTriggerDefinitions,
 } as const satisfies Record<string, TriggerDefinition>