@automate.ax/catalog 0.55.0

package/src/triggers/index.ts

@@ -0,0 +1,128 @@
+import { airtableTriggerDefinitions } from "./airtable"
+import { asanaTriggerDefinitions } from "./asana"
+import { brevoTriggerDefinitions } from "./brevo"
+import { coreTriggerDefinitions } from "./core"
+import { githubTriggerDefinitions } from "./github"
+import { googleTriggerDefinitions } from "./google"
+import { linearTriggerDefinitions } from "./linear"
+import { microsoftTriggerDefinitions } from "./microsoft"
+import { resendTriggerDefinitions } from "./resend"
+import { slackTriggerDefinitions } from "./slack"
+import { trelloTriggerDefinitions } from "./trello"
+import { vercelTriggerDefinitions } from "./vercel"
+import { whatsappTriggerDefinitions } from "./whatsapp"
+import { getIntegrationService } from "../catalog"
+import type {
+  TriggerDefinition,
+  TriggerPresentation,
+  TriggerPresentationContext,
+} from "../types"
+
+export {
+  getHttpTriggerEndpoint,
+  getHttpTriggerEndpointKey,
+  type HttpTriggerEndpointOptions,
+  type HttpTriggerScope,
+} from "./core"
+
+/** Plain shared definitions for every public trigger type. */
+export const triggerDefinitions = {
+  ...airtableTriggerDefinitions,
+  ...asanaTriggerDefinitions,
+  ...brevoTriggerDefinitions,
+  ...coreTriggerDefinitions,
+  ...githubTriggerDefinitions,
+  ...googleTriggerDefinitions,
+  ...linearTriggerDefinitions,
+  ...microsoftTriggerDefinitions,
+  ...resendTriggerDefinitions,
+  ...slackTriggerDefinitions,
+  ...trelloTriggerDefinitions,
+  ...vercelTriggerDefinitions,
+  ...whatsappTriggerDefinitions,
+} as const satisfies Record<string, TriggerDefinition>
+
+/** Trigger definitions with inferred display names materialized. */
+export const triggerCatalog = Object.values(triggerDefinitions).map(
+  (definition) => ({
+    ...definition,
+    name:
+      ("name" in definition ? definition.name : undefined) ??
+      inferTriggerName(definition),
+  }),
+)
+
+export type TriggerType = (typeof triggerCatalog)[number]["type"]
+
+/**
+ * Looks up one known trigger by its stable event type.
+ *
+ * @param type - Stable public event type.
+ */
+export function getTriggerDefinition(
+  type: string,
+): (TriggerDefinition & { name: string }) | undefined {
+  return triggerCatalog.find((trigger) => trigger.type === type)
+}
+
+/**
+ * Resolves the display name for a stable event type.
+ *
+ * Known trigger types use their catalog name. Unknown types fall back to the
+ * same sentence-case convention used by catalog definitions.
+ *
+ * @param type - Stable event type to name.
+ */
+export function getTriggerName(type: string) {
+  return getTriggerDefinition(type)?.name ?? sentenceCase(type)
+}
+
+/**
+ * Describes one configured trigger using its shared client-safe definition.
+ *
+ * @param context - Trigger identity, configuration, and public application
+ *   origin.
+ */
+export function getTriggerPresentation(
+  context: TriggerPresentationContext & { eventType: string },
+): TriggerPresentation {
+  const definition = getTriggerDefinition(context.eventType)
+
+  return {
+    details: definition?.getDetails?.(context) ?? [],
+    name: definition?.name ?? getTriggerName(context.eventType),
+    type: context.eventType,
+  }
+}
+
+/**
+ * Infers presentation copy from a trigger's stable event type.
+ *
+ * @param definition - Trigger definition to name.
+ */
+function inferTriggerName(definition: TriggerDefinition) {
+  const [namespace = definition.type] = definition.type.split(".")
+  const inferredName = sentenceCase(definition.type)
+  const service =
+    definition.account?.serviceId.toLowerCase() === namespace.toLowerCase()
+      ? getIntegrationService(definition.account.serviceId)
+      : undefined
+
+  return service
+    ? inferredName.replace(sentenceCase(namespace), service.name)
+    : inferredName
+}
+
+/**
+ * Converts a stable identifier to a sentence-cased display name.
+ *
+ * @param value - Stable identifier to format.
+ */
+function sentenceCase(value: string) {
+  const words = value
+    .replaceAll(/([a-z\d])([A-Z])/g, "$1 $2")
+    .replaceAll(/[._-]+/g, " ")
+    .toLowerCase()
+
+  return words.charAt(0).toUpperCase() + words.slice(1)
+}

package/src/triggers/linear.ts

@@ -0,0 +1,62 @@
+import { linearService } from "../catalog"
+import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+
+const LINEAR_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: ["read"],
+    },
+  ],
+  serviceId: linearService.id,
+} as const satisfies IntegrationAccountRequirement
+
+export const linearTriggerDefinitions = {
+  linearCommentCreated: {
+    account: LINEAR_ACCOUNT,
+    type: "linear.comment.created",
+  },
+  linearCommentEvent: {
+    account: LINEAR_ACCOUNT,
+    type: "linear.comment.event",
+  },
+  linearCommentRemoved: {
+    account: LINEAR_ACCOUNT,
+    type: "linear.comment.removed",
+  },
+  linearCommentUpdated: {
+    account: LINEAR_ACCOUNT,
+    type: "linear.comment.updated",
+  },
+  linearIssueCreated: {
+    account: LINEAR_ACCOUNT,
+    type: "linear.issue.created",
+  },
+  linearIssueEvent: {
+    account: LINEAR_ACCOUNT,
+    type: "linear.issue.event",
+  },
+  linearIssueRemoved: {
+    account: LINEAR_ACCOUNT,
+    type: "linear.issue.removed",
+  },
+  linearIssueUpdated: {
+    account: LINEAR_ACCOUNT,
+    type: "linear.issue.updated",
+  },
+  linearProjectCreated: {
+    account: LINEAR_ACCOUNT,
+    type: "linear.project.created",
+  },
+  linearProjectEvent: {
+    account: LINEAR_ACCOUNT,
+    type: "linear.project.event",
+  },
+  linearProjectRemoved: {
+    account: LINEAR_ACCOUNT,
+    type: "linear.project.removed",
+  },
+  linearProjectUpdated: {
+    account: LINEAR_ACCOUNT,
+    type: "linear.project.updated",
+  },
+} as const satisfies Record<string, TriggerDefinition>

package/src/triggers/microsoft.ts

@@ -0,0 +1,65 @@
+import { microsoftService } from "../catalog"
+import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+
+const OUTLOOK_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [
+        {
+          requirements: ["Mail.ReadWrite", "Mail.Read"],
+          type: "or",
+        },
+      ],
+    },
+  ],
+  serviceId: microsoftService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const TEAMS_CHANNEL_MESSAGE_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [
+        {
+          requirements: [
+            "ChannelMessage.Read.All",
+            "Team.ReadBasic.All",
+            "Channel.ReadBasic.All",
+          ],
+          type: "and",
+        },
+      ],
+    },
+  ],
+  serviceId: microsoftService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const TEAMS_CHAT_MESSAGE_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [
+        {
+          requirements: ["Chat.ReadWrite", "Chat.Read"],
+          type: "or",
+        },
+      ],
+    },
+  ],
+  serviceId: microsoftService.id,
+} as const satisfies IntegrationAccountRequirement
+
+export const microsoftTriggerDefinitions = {
+  outlookEmailReceived: {
+    account: OUTLOOK_ACCOUNT,
+    type: "outlook.email.received",
+  },
+  teamsChannelMessagePosted: {
+    account: TEAMS_CHANNEL_MESSAGE_ACCOUNT,
+    name: "Microsoft Teams channel message posted",
+    type: "teams.channel.message.posted",
+  },
+  teamsChatMessagePosted: {
+    account: TEAMS_CHAT_MESSAGE_ACCOUNT,
+    name: "Microsoft Teams chat message posted",
+    type: "teams.chat.message.posted",
+  },
+} as const satisfies Record<string, TriggerDefinition>

package/src/triggers/resend.ts

@@ -0,0 +1,62 @@
+import { resendService } from "../catalog"
+import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+
+const RESEND_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [],
+    },
+  ],
+  serviceId: resendService.id,
+} as const satisfies IntegrationAccountRequirement
+
+export const resendTriggerDefinitions = {
+  resendEmailBounced: {
+    account: RESEND_ACCOUNT,
+    type: "resend.email.bounced",
+  },
+  resendEmailClicked: {
+    account: RESEND_ACCOUNT,
+    type: "resend.email.clicked",
+  },
+  resendEmailComplained: {
+    account: RESEND_ACCOUNT,
+    type: "resend.email.complained",
+  },
+  resendEmailDelivered: {
+    account: RESEND_ACCOUNT,
+    type: "resend.email.delivered",
+  },
+  resendEmailDeliveryDelayed: {
+    account: RESEND_ACCOUNT,
+    type: "resend.email.deliveryDelayed",
+  },
+  resendEmailEvent: {
+    account: RESEND_ACCOUNT,
+    type: "resend.email.event",
+  },
+  resendEmailFailed: {
+    account: RESEND_ACCOUNT,
+    type: "resend.email.failed",
+  },
+  resendEmailOpened: {
+    account: RESEND_ACCOUNT,
+    type: "resend.email.opened",
+  },
+  resendEmailReceived: {
+    account: RESEND_ACCOUNT,
+    type: "resend.email.received",
+  },
+  resendEmailScheduled: {
+    account: RESEND_ACCOUNT,
+    type: "resend.email.scheduled",
+  },
+  resendEmailSent: {
+    account: RESEND_ACCOUNT,
+    type: "resend.email.sent",
+  },
+  resendEmailSuppressed: {
+    account: RESEND_ACCOUNT,
+    type: "resend.email.suppressed",
+  },
+} as const satisfies Record<string, TriggerDefinition>

package/src/triggers/slack.ts

@@ -0,0 +1,58 @@
+import { slackService } from "../catalog"
+import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+
+const SLACK_APP_MENTION_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: ["app_mentions:read"],
+    },
+  ],
+  serviceId: slackService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const SLACK_MESSAGE_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [
+        {
+          requirements: [
+            "channels:history",
+            "groups:history",
+            "im:history",
+            "mpim:history",
+          ],
+          type: "and",
+        },
+      ],
+    },
+  ],
+  serviceId: slackService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const SLACK_REACTION_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: ["reactions:read"],
+    },
+  ],
+  serviceId: slackService.id,
+} as const satisfies IntegrationAccountRequirement
+
+export const slackTriggerDefinitions = {
+  slackAppMentioned: {
+    account: SLACK_APP_MENTION_ACCOUNT,
+    type: "slack.app.mentioned",
+  },
+  slackMessagePosted: {
+    account: SLACK_MESSAGE_ACCOUNT,
+    type: "slack.message.posted",
+  },
+  slackReactionAdded: {
+    account: SLACK_REACTION_ACCOUNT,
+    type: "slack.reaction.added",
+  },
+  slackReactionRemoved: {
+    account: SLACK_REACTION_ACCOUNT,
+    type: "slack.reaction.removed",
+  },
+} as const satisfies Record<string, TriggerDefinition>

package/src/triggers/trello.ts

@@ -0,0 +1,38 @@
+import { trelloService } from "../catalog"
+import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+
+const TRELLO_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [],
+    },
+  ],
+  serviceId: trelloService.id,
+} as const satisfies IntegrationAccountRequirement
+
+export const trelloTriggerDefinitions = {
+  trelloBoardEvent: {
+    account: TRELLO_ACCOUNT,
+    type: "trello.board.event",
+  },
+  trelloCardArchived: {
+    account: TRELLO_ACCOUNT,
+    type: "trello.card.archived",
+  },
+  trelloCardCommented: {
+    account: TRELLO_ACCOUNT,
+    type: "trello.card.commented",
+  },
+  trelloCardCreated: {
+    account: TRELLO_ACCOUNT,
+    type: "trello.card.created",
+  },
+  trelloCardMoved: {
+    account: TRELLO_ACCOUNT,
+    type: "trello.card.moved",
+  },
+  trelloCardUpdated: {
+    account: TRELLO_ACCOUNT,
+    type: "trello.card.updated",
+  },
+} as const satisfies Record<string, TriggerDefinition>

package/src/triggers/vercel.ts

@@ -0,0 +1,170 @@
+import { vercelService } from "../catalog"
+import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+
+const VERCEL_DEPLOYMENT_ACCOUNT = {
+  connectionOptions: [
+    {
+      connectionId: "oauth",
+      requiredScopes: ["deployment:read"],
+    },
+  ],
+  serviceId: vercelService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const VERCEL_INTEGRATION_CONFIGURATION_ACCOUNT = {
+  connectionOptions: [
+    {
+      connectionId: "oauth",
+      requiredScopes: [],
+    },
+  ],
+  serviceId: vercelService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const VERCEL_PROJECT_ACCOUNT = {
+  connectionOptions: [
+    {
+      connectionId: "oauth",
+      requiredScopes: ["project:read"],
+    },
+  ],
+  serviceId: vercelService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const VERCEL_PROJECT_DOMAIN_ACCOUNT = {
+  connectionOptions: [
+    {
+      connectionId: "oauth",
+      requiredScopes: ["domain:read"],
+    },
+  ],
+  serviceId: vercelService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const VERCEL_PROJECT_ENVIRONMENT_VARIABLE_ACCOUNT = {
+  connectionOptions: [
+    {
+      connectionId: "oauth",
+      requiredScopes: ["global-project-env-vars:read"],
+    },
+  ],
+  serviceId: vercelService.id,
+} as const satisfies IntegrationAccountRequirement
+
+export const vercelTriggerDefinitions = {
+  vercelDeployment: {
+    account: VERCEL_DEPLOYMENT_ACCOUNT,
+    name: "Vercel deployment event",
+    type: "vercel.deployment",
+  },
+  vercelDeploymentCanceled: {
+    account: VERCEL_DEPLOYMENT_ACCOUNT,
+    type: "vercel.deployment.canceled",
+  },
+  vercelDeploymentCreated: {
+    account: VERCEL_DEPLOYMENT_ACCOUNT,
+    type: "vercel.deployment.created",
+  },
+  vercelDeploymentFailed: {
+    account: VERCEL_DEPLOYMENT_ACCOUNT,
+    type: "vercel.deployment.failed",
+  },
+  vercelDeploymentPromoted: {
+    account: VERCEL_DEPLOYMENT_ACCOUNT,
+    type: "vercel.deployment.promoted",
+  },
+  vercelDeploymentReady: {
+    account: VERCEL_DEPLOYMENT_ACCOUNT,
+    type: "vercel.deployment.ready",
+  },
+  vercelDeploymentSucceeded: {
+    account: VERCEL_DEPLOYMENT_ACCOUNT,
+    type: "vercel.deployment.succeeded",
+  },
+  vercelIntegrationConfiguration: {
+    account: VERCEL_INTEGRATION_CONFIGURATION_ACCOUNT,
+    name: "Vercel integration configuration event",
+    type: "vercel.integration-configuration",
+  },
+  vercelIntegrationConfigurationPermissionUpgraded: {
+    account: VERCEL_INTEGRATION_CONFIGURATION_ACCOUNT,
+    name: "Vercel integration permission upgraded",
+    type: "vercel.integration-configuration.permissionUpgraded",
+  },
+  vercelIntegrationConfigurationRemoved: {
+    account: VERCEL_INTEGRATION_CONFIGURATION_ACCOUNT,
+    type: "vercel.integration-configuration.removed",
+  },
+  vercelIntegrationConfigurationScopeChangeConfirmed: {
+    account: VERCEL_INTEGRATION_CONFIGURATION_ACCOUNT,
+    name: "Vercel integration scope change confirmed",
+    type: "vercel.integration-configuration.scopeChangeConfirmed",
+  },
+  vercelIntegrationConfigurationTransferred: {
+    account: VERCEL_INTEGRATION_CONFIGURATION_ACCOUNT,
+    type: "vercel.integration-configuration.transferred",
+  },
+  vercelProject: {
+    account: VERCEL_PROJECT_ACCOUNT,
+    name: "Vercel project event",
+    type: "vercel.project",
+  },
+  vercelProjectCreated: {
+    account: VERCEL_PROJECT_ACCOUNT,
+    type: "vercel.project.created",
+  },
+  vercelProjectDomain: {
+    account: VERCEL_PROJECT_DOMAIN_ACCOUNT,
+    name: "Vercel project domain event",
+    type: "vercel.project-domain",
+  },
+  vercelProjectDomainCreated: {
+    account: VERCEL_PROJECT_DOMAIN_ACCOUNT,
+    type: "vercel.project-domain.created",
+  },
+  vercelProjectDomainDeleted: {
+    account: VERCEL_PROJECT_DOMAIN_ACCOUNT,
+    type: "vercel.project-domain.deleted",
+  },
+  vercelProjectDomainMoved: {
+    account: VERCEL_PROJECT_DOMAIN_ACCOUNT,
+    type: "vercel.project-domain.moved",
+  },
+  vercelProjectDomainUnverified: {
+    account: VERCEL_PROJECT_DOMAIN_ACCOUNT,
+    type: "vercel.project-domain.unverified",
+  },
+  vercelProjectDomainUpdated: {
+    account: VERCEL_PROJECT_DOMAIN_ACCOUNT,
+    type: "vercel.project-domain.updated",
+  },
+  vercelProjectDomainVerified: {
+    account: VERCEL_PROJECT_DOMAIN_ACCOUNT,
+    type: "vercel.project-domain.verified",
+  },
+  vercelProjectEnvironmentVariable: {
+    account: VERCEL_PROJECT_ENVIRONMENT_VARIABLE_ACCOUNT,
+    name: "Vercel project environment variable event",
+    type: "vercel.project-environment-variable",
+  },
+  vercelProjectEnvironmentVariableCreated: {
+    account: VERCEL_PROJECT_ENVIRONMENT_VARIABLE_ACCOUNT,
+    type: "vercel.project-environment-variable.created",
+  },
+  vercelProjectEnvironmentVariableDeleted: {
+    account: VERCEL_PROJECT_ENVIRONMENT_VARIABLE_ACCOUNT,
+    type: "vercel.project-environment-variable.deleted",
+  },
+  vercelProjectEnvironmentVariableUpdated: {
+    account: VERCEL_PROJECT_ENVIRONMENT_VARIABLE_ACCOUNT,
+    type: "vercel.project-environment-variable.updated",
+  },
+  vercelProjectRemoved: {
+    account: VERCEL_PROJECT_ACCOUNT,
+    type: "vercel.project.removed",
+  },
+  vercelProjectRenamed: {
+    account: VERCEL_PROJECT_ACCOUNT,
+    type: "vercel.project.renamed",
+  },
+} as const satisfies Record<string, TriggerDefinition>

package/src/triggers/whatsapp.ts

@@ -0,0 +1,42 @@
+import { whatsappService } from "../catalog"
+import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+
+const WHATSAPP_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: ["whatsapp_business_messaging"],
+    },
+  ],
+  serviceId: whatsappService.id,
+} as const satisfies IntegrationAccountRequirement
+
+export const whatsappTriggerDefinitions = {
+  whatsappMessageDelivered: {
+    account: WHATSAPP_ACCOUNT,
+    type: "whatsapp.message.delivered",
+  },
+  whatsappMessageFailed: {
+    account: WHATSAPP_ACCOUNT,
+    type: "whatsapp.message.failed",
+  },
+  whatsappMessagePlayed: {
+    account: WHATSAPP_ACCOUNT,
+    type: "whatsapp.message.played",
+  },
+  whatsappMessageRead: {
+    account: WHATSAPP_ACCOUNT,
+    type: "whatsapp.message.read",
+  },
+  whatsappMessageReceived: {
+    account: WHATSAPP_ACCOUNT,
+    type: "whatsapp.message.received",
+  },
+  whatsappMessageSent: {
+    account: WHATSAPP_ACCOUNT,
+    type: "whatsapp.message.sent",
+  },
+  whatsappMessageStatusEvent: {
+    account: WHATSAPP_ACCOUNT,
+    type: "whatsapp.message.statusEvent",
+  },
+} as const satisfies Record<string, TriggerDefinition>