@automate.ax/catalog 0.55.0

package/src/index.ts

@@ -0,0 +1,68 @@
+export {
+  airtableService,
+  anthropicService,
+  apolloService,
+  asanaService,
+  brevoService,
+  cerebrasService,
+  cloudflareService,
+  cohereService,
+  deepinfraService,
+  deepseekService,
+  firecrawlService,
+  fireworksService,
+  getIntegrationService,
+  githubService,
+  googleGenaiService,
+  googleService,
+  groqService,
+  huggingfaceService,
+  integrationCatalog,
+  linearService,
+  microsoftService,
+  millionverifierService,
+  mistralService,
+  openaiService,
+  openrouterService,
+  perplexityService,
+  postgresService,
+  resendService,
+  scrapflyService,
+  slackService,
+  tidycalService,
+  togetheraiService,
+  trelloService,
+  vercelAiGatewayService,
+  vercelService,
+  whatsappService,
+  xaiService,
+  type IntegrationServiceId,
+} from "./catalog"
+export {
+  defineIntegrationCatalog,
+  defineIntegrationService,
+  scope,
+  type IntegrationAccountConnectionOption,
+  type IntegrationAccountRequirement,
+  type IntegrationConnectionDefinition,
+  type IntegrationFormField,
+  type IntegrationScopeRequirement,
+  type IntegrationServiceDefinition,
+  type ScopeRequirementGroup,
+  type TriggerDefinition,
+  type TriggerPresentation,
+  type TriggerPresentationContext,
+  type TriggerPresentationDetail,
+} from "./types"
+export {
+  getHttpTriggerEndpoint,
+  getHttpTriggerEndpointKey,
+  getTriggerDefinition,
+  getTriggerName,
+  getTriggerPresentation,
+  triggerCatalog,
+  triggerDefinitions,
+  type HttpTriggerEndpointOptions,
+  type HttpTriggerScope,
+  type TriggerType,
+} from "./triggers"

package/src/triggers/airtable.ts

@@ -0,0 +1,39 @@
+import { airtableService } from "../catalog"
+import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+
+const AIRTABLE_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [
+        {
+          requirements: ["data.records:read", "webhook:manage"],
+          type: "and",
+        },
+      ],
+    },
+  ],
+  serviceId: airtableService.id,
+} as const satisfies IntegrationAccountRequirement
+
+export const airtableTriggerDefinitions = {
+  airtableRecordCreated: {
+    account: AIRTABLE_ACCOUNT,
+    type: "airtable.record.created",
+  },
+  airtableRecordDeleted: {
+    account: AIRTABLE_ACCOUNT,
+    type: "airtable.record.deleted",
+  },
+  airtableRecordMovedIntoView: {
+    account: AIRTABLE_ACCOUNT,
+    type: "airtable.record.movedIntoView",
+  },
+  airtableRecordMovedOutOfView: {
+    account: AIRTABLE_ACCOUNT,
+    type: "airtable.record.movedOutOfView",
+  },
+  airtableRecordUpdated: {
+    account: AIRTABLE_ACCOUNT,
+    type: "airtable.record.updated",
+  },
+} as const satisfies Record<string, TriggerDefinition>

package/src/triggers/asana.ts

@@ -0,0 +1,42 @@
+import { asanaService } from "../catalog"
+import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+
+const ASANA_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [],
+    },
+  ],
+  serviceId: asanaService.id,
+} as const satisfies IntegrationAccountRequirement
+
+export const asanaTriggerDefinitions = {
+  asanaCommentAdded: {
+    account: ASANA_ACCOUNT,
+    type: "asana.comment.added",
+  },
+  asanaEvent: {
+    account: ASANA_ACCOUNT,
+    type: "asana.event",
+  },
+  asanaTaskAdded: {
+    account: ASANA_ACCOUNT,
+    type: "asana.task.added",
+  },
+  asanaTaskChanged: {
+    account: ASANA_ACCOUNT,
+    type: "asana.task.changed",
+  },
+  asanaTaskCompleted: {
+    account: ASANA_ACCOUNT,
+    type: "asana.task.completed",
+  },
+  asanaTaskDeleted: {
+    account: ASANA_ACCOUNT,
+    type: "asana.task.deleted",
+  },
+  asanaTaskRemoved: {
+    account: ASANA_ACCOUNT,
+    type: "asana.task.removed",
+  },
+} as const satisfies Record<string, TriggerDefinition>

package/src/triggers/brevo.ts

@@ -0,0 +1,68 @@
+import { brevoService } from "../catalog"
+import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+
+const BREVO_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [],
+    },
+  ],
+  serviceId: brevoService.id,
+} as const satisfies IntegrationAccountRequirement
+
+export const brevoTriggerDefinitions = {
+  brevoTransactionalBlocked: {
+    account: BREVO_ACCOUNT,
+    name: "Brevo email blocked",
+    type: "brevo.transactional.blocked",
+  },
+  brevoTransactionalClicked: {
+    account: BREVO_ACCOUNT,
+    name: "Brevo email clicked",
+    type: "brevo.transactional.clicked",
+  },
+  brevoTransactionalDeferred: {
+    account: BREVO_ACCOUNT,
+    name: "Brevo email deferred",
+    type: "brevo.transactional.deferred",
+  },
+  brevoTransactionalDelivered: {
+    account: BREVO_ACCOUNT,
+    name: "Brevo email delivered",
+    type: "brevo.transactional.delivered",
+  },
+  brevoTransactionalEvent: {
+    account: BREVO_ACCOUNT,
+    type: "brevo.transactional.event",
+  },
+  brevoTransactionalHardBounced: {
+    account: BREVO_ACCOUNT,
+    name: "Brevo email hard bounced",
+    type: "brevo.transactional.hardBounced",
+  },
+  brevoTransactionalMarkedAsSpam: {
+    account: BREVO_ACCOUNT,
+    name: "Brevo email marked as spam",
+    type: "brevo.transactional.markedAsSpam",
+  },
+  brevoTransactionalOpened: {
+    account: BREVO_ACCOUNT,
+    name: "Brevo email opened",
+    type: "brevo.transactional.opened",
+  },
+  brevoTransactionalSent: {
+    account: BREVO_ACCOUNT,
+    name: "Brevo email sent",
+    type: "brevo.transactional.sent",
+  },
+  brevoTransactionalSoftBounced: {
+    account: BREVO_ACCOUNT,
+    name: "Brevo email soft bounced",
+    type: "brevo.transactional.softBounced",
+  },
+  brevoTransactionalUnsubscribed: {
+    account: BREVO_ACCOUNT,
+    name: "Brevo email unsubscribed",
+    type: "brevo.transactional.unsubscribed",
+  },
+} as const satisfies Record<string, TriggerDefinition>

package/src/triggers/core.ts

@@ -0,0 +1,93 @@
+import type { TriggerDefinition } from "../types"
+import * as z from "zod/mini"
+
+const CRON_PRESENTATION_CONFIG_SCHEMA = z.object({
+  schedule: z.string(),
+  timeZone: z.prefault(z.string(), "UTC"),
+})
+const HTTP_PRESENTATION_CONFIG_SCHEMA = z.object({
+  scope: z.prefault(z.enum(["trigger", "automation", "project"]), "trigger"),
+})
+const INVOCATION_PRESENTATION_CONFIG_SCHEMA = z.object({
+  entrypoint: z.string(),
+})
+
+export const coreTriggerDefinitions = {
+  automationInvoked: {
+    getDetails: ({ config }) => [
+      {
+        label: "Entrypoint",
+        value: INVOCATION_PRESENTATION_CONFIG_SCHEMA.parse(config).entrypoint,
+      },
+    ],
+    icon: "automation",
+    name: "Invocation",
+    type: "automation.invoked",
+  },
+  cronTick: {
+    getDetails: ({ config }) => {
+      const parsedConfig = CRON_PRESENTATION_CONFIG_SCHEMA.parse(config)
+
+      return [
+        { label: "Schedule", value: parsedConfig.schedule },
+        { label: "Time zone", value: parsedConfig.timeZone },
+      ]
+    },
+    icon: "schedule",
+    name: "Cron schedule",
+    type: "cron.tick",
+  },
+  httpRequest: {
+    getDetails: ({ appOrigin, automationId, config, hookSlot, projectId }) => [
+      {
+        copyable: true,
+        label: "URL",
+        value: getHttpTriggerEndpoint({
+          appOrigin,
+          automationId,
+          hookSlot,
+          projectId,
+          scope: HTTP_PRESENTATION_CONFIG_SCHEMA.parse(config).scope,
+        }),
+      },
+    ],
+    icon: "webhook",
+    name: "HTTP request",
+    type: "http.request",
+  },
+} as const satisfies Record<string, TriggerDefinition>
+
+export type HttpTriggerScope = "trigger" | "automation" | "project"
+
+export interface HttpTriggerEndpointOptions {
+  appOrigin: string
+  automationId: string
+  hookSlot: number
+  projectId: string
+  scope: HttpTriggerScope
+}
+
+/**
+ * Returns the public URL for one deployed HTTP trigger.
+ *
+ * @param options - Public origin and trigger identity.
+ */
+export function getHttpTriggerEndpoint(options: HttpTriggerEndpointOptions) {
+  return new URL(
+    `/x/${getHttpTriggerEndpointKey(options)}/`,
+    options.appOrigin,
+  ).toString()
+}
+
+/**
+ * Returns the durable endpoint identity for one configured HTTP scope.
+ *
+ * @param options - Trigger and owning resource identity.
+ */
+export function getHttpTriggerEndpointKey(
+  options: Omit<HttpTriggerEndpointOptions, "appOrigin">,
+) {
+  if (options.scope === "project") return options.projectId
+  if (options.scope === "automation") return options.automationId
+  return `${options.automationId}:${options.hookSlot}`
+}

package/src/triggers/github.ts

@@ -0,0 +1,142 @@
+import { githubService } from "../catalog"
+import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+
+const GITHUB_ISSUES_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: ["issues:read"],
+    },
+  ],
+  serviceId: githubService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const GITHUB_PULL_REQUESTS_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: ["pull_requests:read"],
+    },
+  ],
+  serviceId: githubService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const GITHUB_CONTENTS_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: ["contents:read"],
+    },
+  ],
+  serviceId: githubService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const GITHUB_ACTIONS_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: ["actions:read"],
+    },
+  ],
+  serviceId: githubService.id,
+} as const satisfies IntegrationAccountRequirement
+
+export const githubTriggerDefinitions = {
+  githubIssueClosed: {
+    account: GITHUB_ISSUES_ACCOUNT,
+    type: "github.issue.closed",
+  },
+  githubIssueEvent: {
+    account: GITHUB_ISSUES_ACCOUNT,
+    type: "github.issue.event",
+  },
+  githubIssueOpened: {
+    account: GITHUB_ISSUES_ACCOUNT,
+    type: "github.issue.opened",
+  },
+  githubIssueReopened: {
+    account: GITHUB_ISSUES_ACCOUNT,
+    type: "github.issue.reopened",
+  },
+  githubPullRequestClosed: {
+    account: GITHUB_PULL_REQUESTS_ACCOUNT,
+    type: "github.pull-request.closed",
+  },
+  githubPullRequestEvent: {
+    account: GITHUB_PULL_REQUESTS_ACCOUNT,
+    type: "github.pull-request.event",
+  },
+  githubPullRequestMerged: {
+    account: GITHUB_PULL_REQUESTS_ACCOUNT,
+    type: "github.pull-request.merged",
+  },
+  githubPullRequestOpened: {
+    account: GITHUB_PULL_REQUESTS_ACCOUNT,
+    type: "github.pull-request.opened",
+  },
+  githubPullRequestReadyForReview: {
+    account: GITHUB_PULL_REQUESTS_ACCOUNT,
+    type: "github.pull-request.ready-for-review",
+  },
+  githubPullRequestReviewApproved: {
+    account: GITHUB_PULL_REQUESTS_ACCOUNT,
+    type: "github.pull-request-review.approved",
+  },
+  githubPullRequestReviewChangesRequested: {
+    account: GITHUB_PULL_REQUESTS_ACCOUNT,
+    name: "GitHub pull request changes requested",
+    type: "github.pull-request-review.changes-requested",
+  },
+  githubPullRequestReviewDismissed: {
+    account: GITHUB_PULL_REQUESTS_ACCOUNT,
+    type: "github.pull-request-review.dismissed",
+  },
+  githubPullRequestReviewEvent: {
+    account: GITHUB_PULL_REQUESTS_ACCOUNT,
+    type: "github.pull-request-review.event",
+  },
+  githubPullRequestReviewSubmitted: {
+    account: GITHUB_PULL_REQUESTS_ACCOUNT,
+    type: "github.pull-request-review.submitted",
+  },
+  githubPullRequestSynchronized: {
+    account: GITHUB_PULL_REQUESTS_ACCOUNT,
+    type: "github.pull-request.synchronized",
+  },
+  githubPush: {
+    account: GITHUB_CONTENTS_ACCOUNT,
+    type: "github.push",
+  },
+  githubReleaseEvent: {
+    account: GITHUB_CONTENTS_ACCOUNT,
+    type: "github.release.event",
+  },
+  githubReleasePublished: {
+    account: GITHUB_CONTENTS_ACCOUNT,
+    type: "github.release.published",
+  },
+  githubWorkflowRunCancelled: {
+    account: GITHUB_ACTIONS_ACCOUNT,
+    type: "github.workflow-run.cancelled",
+  },
+  githubWorkflowRunCompleted: {
+    account: GITHUB_ACTIONS_ACCOUNT,
+    type: "github.workflow-run.completed",
+  },
+  githubWorkflowRunEvent: {
+    account: GITHUB_ACTIONS_ACCOUNT,
+    type: "github.workflow-run.event",
+  },
+  githubWorkflowRunFailed: {
+    account: GITHUB_ACTIONS_ACCOUNT,
+    type: "github.workflow-run.failed",
+  },
+  githubWorkflowRunRequested: {
+    account: GITHUB_ACTIONS_ACCOUNT,
+    type: "github.workflow-run.requested",
+  },
+  githubWorkflowRunStarted: {
+    account: GITHUB_ACTIONS_ACCOUNT,
+    type: "github.workflow-run.started",
+  },
+  githubWorkflowRunSucceeded: {
+    account: GITHUB_ACTIONS_ACCOUNT,
+    type: "github.workflow-run.succeeded",
+  },
+} as const satisfies Record<string, TriggerDefinition>

package/src/triggers/google.ts

@@ -0,0 +1,149 @@
+import { googleService } from "../catalog"
+import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+
+const GMAIL_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [
+        {
+          requirements: [
+            "https://mail.google.com/",
+            "https://www.googleapis.com/auth/gmail.modify",
+            "https://www.googleapis.com/auth/gmail.readonly",
+          ],
+          type: "or",
+        },
+      ],
+    },
+  ],
+  serviceId: googleService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const GOOGLE_CALENDAR_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [
+        {
+          requirements: [
+            "https://www.googleapis.com/auth/calendar",
+            "https://www.googleapis.com/auth/calendar.readonly",
+            "https://www.googleapis.com/auth/calendar.events",
+            "https://www.googleapis.com/auth/calendar.events.readonly",
+            "https://www.googleapis.com/auth/calendar.events.owned",
+          ],
+          type: "or",
+        },
+      ],
+    },
+  ],
+  serviceId: googleService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const GOOGLE_FORMS_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [
+        {
+          requirements: [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.readonly",
+            "https://www.googleapis.com/auth/forms.body",
+            "https://www.googleapis.com/auth/forms.body.readonly",
+          ],
+          type: "or",
+        },
+      ],
+    },
+  ],
+  serviceId: googleService.id,
+} as const satisfies IntegrationAccountRequirement
+
+const GOOGLE_FORM_RESPONSES_ACCOUNT = {
+  connectionOptions: [
+    {
+      requiredScopes: [
+        {
+          requirements: [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/drive.file",
+            "https://www.googleapis.com/auth/drive.readonly",
+            "https://www.googleapis.com/auth/forms.body",
+            "https://www.googleapis.com/auth/forms.body.readonly",
+          ],
+          type: "or",
+        },
+        {
+          requirements: [
+            {
+              requirements: [
+                "https://www.googleapis.com/auth/drive",
+                "https://www.googleapis.com/auth/drive.file",
+                "https://www.googleapis.com/auth/forms.responses.readonly",
+              ],
+              type: "or",
+            },
+            {
+              requirements: [
+                "https://www.googleapis.com/auth/drive",
+                "https://www.googleapis.com/auth/drive.file",
+                "https://www.googleapis.com/auth/drive.readonly",
+                "https://www.googleapis.com/auth/forms.body",
+                "https://www.googleapis.com/auth/forms.body.readonly",
+              ],
+              type: "or",
+            },
+          ],
+          type: "and",
+        },
+      ],
+    },
+  ],
+  serviceId: googleService.id,
+} as const satisfies IntegrationAccountRequirement
+
+export const googleTriggerDefinitions = {
+  gmailLabelAdded: {
+    account: GMAIL_ACCOUNT,
+    type: "gmail.label.added",
+  },
+  gmailLabelRemoved: {
+    account: GMAIL_ACCOUNT,
+    type: "gmail.label.removed",
+  },
+  gmailMessageReceived: {
+    account: GMAIL_ACCOUNT,
+    name: "Gmail email received",
+    type: "gmail.message.received",
+  },
+  gmailMessageSent: {
+    account: GMAIL_ACCOUNT,
+    name: "Gmail email sent",
+    type: "gmail.message.sent",
+  },
+  googleCalendarEventCreated: {
+    account: GOOGLE_CALENDAR_ACCOUNT,
+    name: "Google Calendar event created",
+    type: "googleCalendar.event.created",
+  },
+  googleCalendarEventDeleted: {
+    account: GOOGLE_CALENDAR_ACCOUNT,
+    name: "Google Calendar event deleted",
+    type: "googleCalendar.event.deleted",
+  },
+  googleCalendarEventUpdated: {
+    account: GOOGLE_CALENDAR_ACCOUNT,
+    name: "Google Calendar event updated",
+    type: "googleCalendar.event.updated",
+  },
+  googleFormsFormChanged: {
+    account: GOOGLE_FORMS_ACCOUNT,
+    name: "Google Form changed",
+    type: "googleForms.form.changed",
+  },
+  googleFormsResponseSubmitted: {
+    account: GOOGLE_FORM_RESPONSES_ACCOUNT,
+    name: "Google Form response submitted",
+    type: "googleForms.response.submitted",
+  },
+} as const satisfies Record<string, TriggerDefinition>