@oomol-lab/open-connector 1.9.1 → 1.9.3

package/src/triggers/sources/feishu.js

@@ -0,0 +1,85 @@
+import { PermanentIntegrationError } from "../common/integration.js";
+import { SourceIdentityError } from "./definition.js";
+import { feishuSubscriptions } from "./feishu-demands.js";
+import { receiveFeishuEvent, matchesFeishuEvent } from "./feishu-events.js";
+export const feishuApplication = {
+    kind: "feishu",
+    provider: "feishu_app_bot",
+    maximumBodyBytes: 64 * 1024,
+    initialize(input, accountId) {
+        if (input.kind != null && input.kind !== "feishu")
+            throw new SourceIdentityError("Expected a Feishu source.");
+        if (accountId == null || !/^cli_[a-zA-Z0-9]+$/.test(accountId))
+            throw new SourceIdentityError("Connector must provide the verified application identity.");
+        return {
+            identity: accountId,
+            eventTypes: input.eventTypes,
+            config: { manageSubscriptions: input.manageSubscriptions },
+            secrets: { verificationToken: input.verificationToken, encryptKey: input.encryptKey },
+            state: {},
+        };
+    },
+    update(source, input) {
+        const secrets = {
+            verificationToken: input.verificationToken ?? source.secrets.verificationToken,
+            encryptKey: input.encryptKey ?? source.secrets.encryptKey,
+        };
+        const changed = secrets.verificationToken != source.secrets.verificationToken || secrets.encryptKey != source.secrets.encryptKey;
+        return {
+            identity: source.identity,
+            eventTypes: input.eventTypes,
+            config: source.config,
+            secrets,
+            state: changed ? {} : source.state,
+        };
+    },
+    view(source) {
+        return {
+            appId: source.identity,
+            manageSubscriptions: source.config.manageSubscriptions === true,
+            verificationTokenConfigured: true,
+            encryptKeyConfigured: true,
+            verifiedAt: typeof source.state.verifiedAt == "number" ? new Date(source.state.verifiedAt).toISOString() : null,
+        };
+    },
+    ready: (source) => typeof source.state.verifiedAt == "number",
+    async receive(source, bytes, headers, now) {
+        const received = await receiveFeishuEvent(bytes, headers, {
+            appId: source.identity,
+            verificationToken: source.secrets.verificationToken,
+            encryptKey: source.secrets.encryptKey,
+        }, now);
+        if ("challenge" in received)
+            return { response: Response.json(received), state: { ...source.state, verifiedAt: now } };
+        const event = received.event;
+        return {
+            event: {
+                id: event.id,
+                type: event.type,
+                payload: {
+                    event: event.type,
+                    deliveryId: event.id,
+                    appId: event.appId,
+                    tenantKey: event.tenantKey,
+                    occurredAt: event.occurredAt,
+                    body: event.body,
+                },
+            },
+        };
+    },
+    matches(config, event) {
+        return matchesFeishuEvent(config, {
+            type: event.type,
+            body: event.payload.body,
+        });
+    },
+    resources: {
+        triggerId: "feishu_app_bot.on_event",
+        requests(source, provider, config) {
+            const subscriptions = feishuSubscriptions(config, provider);
+            if (subscriptions.length > 0 && source.config.manageSubscriptions !== true)
+                throw new PermanentIntegrationError("This source does not manage resource subscriptions.");
+            return subscriptions;
+        },
+    },
+};

package/src/triggers/sources/fireflies.d.ts

@@ -0,0 +1,3 @@
+import type { CreateEventSource, EventSource, UpdateEventSource } from "./configuration.ts";
+import type { EventSourceDefinition } from "./definition.ts";
+export declare const firefliesAccount: EventSourceDefinition<CreateEventSource, UpdateEventSource, Pick<EventSource, "appId" | "manageSubscriptions" | "verificationTokenConfigured" | "encryptKeyConfigured" | "signingSecretConfigured" | "verifiedAt">>;

package/src/triggers/sources/fireflies.js

@@ -0,0 +1,100 @@
+import { isJsonObject } from "../common/json.js";
+import { SourceIdentityError } from "./definition.js";
+import { verifySourceHmac } from "./signature.js";
+const events = new Set(["meeting.transcribed", "meeting.summarized"]);
+export const firefliesAccount = {
+    kind: "fireflies",
+    provider: "fireflies",
+    maximumBodyBytes: 64 * 1024,
+    initialize(input, accountId) {
+        if (input.kind !== "fireflies" || !accountId)
+            throw new SourceIdentityError("Connector must provide the verified Fireflies account identity.");
+        if (input.eventTypes.some((event) => !events.has(event)))
+            throw new SourceIdentityError("Unsupported Fireflies event.");
+        return {
+            identity: JSON.stringify([input.teamId, input.connectionId, accountId]),
+            eventTypes: input.eventTypes,
+            config: { appId: accountId, accountId },
+            secrets: { signingSecret: input.signingSecret },
+            state: {},
+        };
+    },
+    update(source, input) {
+        if (input.verificationToken != null || input.encryptKey != null)
+            throw new SourceIdentityError("Fireflies uses the Webhooks V2 Signing Secret.");
+        if (input.eventTypes.some((event) => !events.has(event)))
+            throw new SourceIdentityError("Unsupported Fireflies event.");
+        const signingSecret = input.signingSecret ?? source.secrets.signingSecret;
+        return {
+            ...source,
+            eventTypes: input.eventTypes,
+            secrets: { signingSecret },
+            state: signingSecret === source.secrets.signingSecret ? source.state : {},
+        };
+    },
+    view(source) {
+        return {
+            appId: String(source.config.appId),
+            manageSubscriptions: false,
+            verificationTokenConfigured: false,
+            encryptKeyConfigured: false,
+            signingSecretConfigured: true,
+            verifiedAt: typeof source.state.verifiedAt === "number" ? new Date(source.state.verifiedAt).toISOString() : null,
+        };
+    },
+    ready: (source) => typeof source.state.verifiedAt === "number",
+    async receive(source, bytes, headers, now, execute) {
+        const signature = headers.get("x-hub-signature") ?? "";
+        if (!signature.startsWith("sha256=") ||
+            !(await verifySourceHmac(bytes, signature.slice(7), String(source.secrets.signingSecret))))
+            throw new TypeError("Invalid Fireflies signature.");
+        const payload = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+        if (!isJsonObject(payload) || typeof payload.event !== "string")
+            throw new TypeError("Invalid Fireflies envelope.");
+        if (!events.has(payload.event))
+            return { response: Response.json({}), state: source.state };
+        if (typeof payload.meeting_id !== "string" ||
+            !payload.meeting_id ||
+            payload.meeting_id.length > 256 ||
+            !Number.isSafeInteger(payload.timestamp) ||
+            Number(payload.timestamp) < 0 ||
+            (payload.reprocessed_at != null &&
+                (!Number.isSafeInteger(payload.reprocessed_at) || Number(payload.reprocessed_at) <= 0)))
+            throw new TypeError("Incomplete Fireflies event.");
+        if (execute == null)
+            throw new SourceIdentityError("Fireflies meeting verification is unavailable.");
+        const identity = await execute({ operation: "sourceIdentity", config: { meetingId: payload.meeting_id } });
+        if (!isJsonObject(identity) ||
+            identity.accountId !== source.config.accountId ||
+            identity.meetingId !== payload.meeting_id ||
+            typeof identity.accessible !== "boolean")
+            throw new SourceIdentityError("Fireflies returned an invalid meeting access result.");
+        if (!identity.accessible)
+            return { response: Response.json({}), state: source.state };
+        const version = Number(payload.reprocessed_at ?? 0);
+        const stream = JSON.stringify([payload.event, payload.meeting_id]);
+        const deliveryId = JSON.stringify([payload.event, payload.meeting_id, version]);
+        return {
+            state: { ...source.state, verifiedAt: now },
+            event: {
+                id: deliveryId,
+                type: payload.event,
+                ordering: { key: stream, version },
+                payload: {
+                    event: payload.event,
+                    deliveryId,
+                    accountId: source.config.accountId,
+                    meetingId: payload.meeting_id,
+                    body: {
+                        event: payload.event,
+                        meeting_id: payload.meeting_id,
+                        reprocessed_at: payload.reprocessed_at ?? null,
+                        client_reference_id: typeof payload.client_reference_id === "string" ? payload.client_reference_id : null,
+                    },
+                },
+            },
+        };
+    },
+    matches: (config, event) => Array.isArray(config.eventTypes) && config.eventTypes.includes(event.type),
+    resources: { triggerId: "fireflies.on_meeting_ready", requests: () => [] },
+};

package/src/triggers/sources/intercom.d.ts

@@ -0,0 +1,3 @@
+import type { CreateEventSource, EventSource, UpdateEventSource } from "./configuration.ts";
+import type { EventSourceDefinition } from "./definition.ts";
+export declare const intercomApplication: EventSourceDefinition<CreateEventSource, UpdateEventSource, Pick<EventSource, "appId" | "workspaceId" | "manageSubscriptions" | "verificationTokenConfigured" | "encryptKeyConfigured" | "signingSecretConfigured" | "verifiedAt">>;

package/src/triggers/sources/intercom.js

@@ -0,0 +1,86 @@
+import { isJsonObject } from "../common/json.js";
+import { SourceIdentityError } from "./definition.js";
+import { verifySourceHmac } from "./signature.js";
+const events = new Set(["conversation.user.created", "conversation.user.replied", "ticket.created"]);
+export const intercomApplication = {
+    kind: "intercom",
+    provider: "intercom",
+    applicationIngress: true,
+    maximumBodyBytes: 64 * 1024,
+    initialize(input, accountId) {
+        if (input.kind !== "intercom" || accountId == null || !/^[^:]+:[^:]+$/.test(accountId))
+            throw new SourceIdentityError("Connector must provide the verified Intercom workspace and administrator identity.");
+        if (input.eventTypes.some((event) => !events.has(event)))
+            throw new SourceIdentityError("Unsupported Intercom event type.");
+        const workspaceId = accountId.split(":")[0];
+        return {
+            identity: JSON.stringify([input.teamId, input.connectionId, input.appId, accountId]),
+            eventTypes: input.eventTypes,
+            config: { appId: input.appId, workspaceId, accountId },
+            secrets: { signingSecret: input.signingSecret },
+            state: {},
+        };
+    },
+    update(source, input) {
+        if (input.verificationToken != null || input.encryptKey != null)
+            throw new SourceIdentityError("Intercom uses the application Client Secret.");
+        if (input.eventTypes.some((event) => !events.has(event)))
+            throw new SourceIdentityError("Unsupported Intercom event type.");
+        const signingSecret = input.signingSecret ?? source.secrets.signingSecret;
+        return {
+            ...source,
+            eventTypes: input.eventTypes,
+            secrets: { signingSecret },
+            state: signingSecret === source.secrets.signingSecret ? source.state : {},
+        };
+    },
+    view(source) {
+        return {
+            appId: String(source.config.appId),
+            workspaceId: String(source.config.workspaceId),
+            manageSubscriptions: false,
+            verificationTokenConfigured: false,
+            encryptKeyConfigured: false,
+            signingSecretConfigured: true,
+            verifiedAt: typeof source.state.verifiedAt === "number" ? new Date(source.state.verifiedAt).toISOString() : null,
+        };
+    },
+    ready: (source) => typeof source.state.verifiedAt === "number",
+    async receive(source, bytes, headers, now) {
+        const signature = headers.get("x-hub-signature") ?? "";
+        if (!/^sha1=[0-9a-f]{40}$/.test(signature))
+            throw new TypeError("Invalid Intercom signature.");
+        if (!(await verifySourceHmac(bytes, signature.slice(5), String(source.secrets.signingSecret), "SHA-1")))
+            throw new TypeError("Invalid Intercom signature.");
+        const payload = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+        if (!isJsonObject(payload) || payload.type !== "notification_event")
+            throw new TypeError("Invalid Intercom notification.");
+        if (payload.app_id !== source.config.workspaceId)
+            return { response: Response.json({}), state: source.state };
+        if (payload.topic === "ping")
+            return { response: Response.json({}), state: { ...source.state, verifiedAt: now } };
+        if (typeof payload.topic !== "string" || !events.has(payload.topic))
+            return { response: Response.json({}), state: source.state };
+        if (typeof payload.id !== "string" ||
+            !payload.id ||
+            !isJsonObject(payload.data) ||
+            !isJsonObject(payload.data.item) ||
+            typeof payload.data.item.id !== "string")
+            throw new TypeError("Incomplete Intercom notification.");
+        return {
+            event: {
+                id: payload.id,
+                type: payload.topic,
+                payload: {
+                    event: payload.topic,
+                    deliveryId: payload.id,
+                    workspaceId: payload.app_id,
+                    objectId: payload.data.item.id,
+                    body: payload.data.item,
+                },
+            },
+        };
+    },
+    matches: (config, event) => Array.isArray(config.eventTypes) && config.eventTypes.includes(event.type),
+    resources: { triggerId: "intercom.on_conversation_event", requests: () => [] },
+};

package/src/triggers/sources/jira.d.ts

@@ -0,0 +1,3 @@
+import type { CreateEventSource, EventSource, UpdateEventSource } from "./configuration.ts";
+import type { EventSourceDefinition } from "./definition.ts";
+export declare const jiraProject: EventSourceDefinition<CreateEventSource, UpdateEventSource, Pick<EventSource, "appId" | "projectId" | "projectKey" | "subscriptionStatus" | "lastError" | "manageSubscriptions" | "verificationTokenConfigured" | "encryptKeyConfigured" | "verifiedAt">>;

package/src/triggers/sources/jira.js

@@ -0,0 +1,120 @@
+import { isJsonObject } from "../common/json.js";
+import { SourceIdentityError } from "./definition.js";
+const events = new Set(["jira:issue_created", "jira:issue_updated", "comment_created"]);
+export const jiraProject = {
+    kind: "jira",
+    provider: "jira",
+    maximumBodyBytes: 64 * 1024,
+    initialize(input, accountId) {
+        if (input.kind !== "jira" || !accountId?.startsWith("jira:"))
+            throw new SourceIdentityError("Choose a verified Jira Cloud OAuth connection.");
+        if (input.eventTypes.some((event) => !events.has(event)))
+            throw new SourceIdentityError("Unsupported Jira event.");
+        return {
+            identity: JSON.stringify([input.teamId, input.connectionId, accountId]),
+            eventTypes: input.eventTypes,
+            config: { accountId, project: input.project },
+            secrets: {},
+            state: {},
+        };
+    },
+    async verifyIdentity(source, read) {
+        const identity = await read(source.config);
+        if (!isJsonObject(identity) ||
+            identity.accountId !== source.config.accountId ||
+            typeof identity.cloudId !== "string" ||
+            typeof identity.userId !== "string" ||
+            typeof identity.projectId !== "string" ||
+            !/^\d+$/.test(identity.projectId) ||
+            typeof identity.projectKey !== "string" ||
+            typeof identity.siteUrl !== "string")
+            throw new SourceIdentityError("Jira did not return the selected project and site identity.");
+        if (source.config.projectId != null &&
+            (source.config.cloudId !== identity.cloudId ||
+                source.config.projectId !== identity.projectId ||
+                source.config.userId !== identity.userId))
+            throw new SourceIdentityError("The Jira project, site or user changed. Recreate the event source.");
+        return {
+            ...source,
+            identity: source.config.projectId == null
+                ? JSON.stringify([source.identity, identity.cloudId, identity.projectId, identity.userId])
+                : source.identity,
+            config: { ...source.config, ...identity },
+        };
+    },
+    update(source, input) {
+        if (input.verificationToken != null || input.encryptKey != null || input.signingSecret != null)
+            throw new SourceIdentityError("Jira OAuth callback verification is owned by Connector.");
+        if (input.eventTypes.some((event) => !events.has(event)))
+            throw new SourceIdentityError("Unsupported Jira event.");
+        return { ...source, eventTypes: input.eventTypes };
+    },
+    view(source, now = Date.now()) {
+        const expired = isJsonObject(source.state.resource) &&
+            typeof source.state.resource.expiresAt === "number" &&
+            source.state.resource.expiresAt <= now;
+        const status = expired ? "error" : source.state.resourceStatus;
+        return {
+            appId: String(source.config.cloudId),
+            projectId: String(source.config.projectId),
+            projectKey: String(source.config.projectKey),
+            subscriptionStatus: status === "pending" || status === "ready" || status === "error" ? status : "idle",
+            lastError: expired
+                ? "The Jira webhook expired. Restore Connector access and retry publication."
+                : typeof source.state.lastError === "string"
+                    ? source.state.lastError
+                    : undefined,
+            manageSubscriptions: true,
+            verificationTokenConfigured: false,
+            encryptKeyConfigured: false,
+            verifiedAt: typeof source.state.verifiedAt === "number" ? new Date(source.state.verifiedAt).toISOString() : null,
+        };
+    },
+    expiresAt: (source) => isJsonObject(source.state.resource) && typeof source.state.resource.expiresAt === "number"
+        ? source.state.resource.expiresAt
+        : undefined,
+    ready: (source, now = Date.now()) => source.state.resourceStatus === "ready" &&
+        isJsonObject(source.state.resource) &&
+        typeof source.state.resource.expiresAt === "number" &&
+        source.state.resource.expiresAt > now,
+    async receive(source, bytes, headers, _now, execute) {
+        if (!isJsonObject(source.state.resource) ||
+            typeof source.state.resource.webhookId !== "number" ||
+            source.state.resourceStatus !== "ready")
+            return { response: new Response(null, { status: 503 }), state: source.state };
+        if (execute == null)
+            throw new SourceIdentityError("Jira callback verification is unavailable.");
+        const result = await execute({
+            operation: "sourceReceive",
+            config: { ...source.config, webhookId: source.state.resource.webhookId },
+            headers: {
+                authorization: headers.get("authorization") ?? "",
+                "x-atlassian-webhook-identifier": headers.get("x-atlassian-webhook-identifier") ?? "",
+            },
+            rawBody: new TextDecoder("utf-8", { fatal: true }).decode(bytes),
+        });
+        if (!isJsonObject(result))
+            throw new SourceIdentityError("Invalid Jira verification response.");
+        if (result.outcome === "unauthorized")
+            return { response: new Response(null, { status: 401 }), state: source.state };
+        if (result.outcome === "ignored")
+            return { response: Response.json({}), state: source.state };
+        if (result.outcome !== "event" ||
+            typeof result.id !== "string" ||
+            typeof result.type !== "string" ||
+            !events.has(result.type) ||
+            !isJsonObject(result.payload))
+            throw new SourceIdentityError("Invalid Jira verified event.");
+        return { event: { id: result.id, type: result.type, payload: result.payload } };
+    },
+    matches: (config, event) => Array.isArray(config.eventTypes) && config.eventTypes.includes(event.type),
+    resources: {
+        triggerId: "jira.on_issue_event",
+        managed: true,
+        requests(source, _provider, _config, endpointUrl) {
+            if (!endpointUrl)
+                throw new SourceIdentityError("Jira requires a public callback URL.");
+            return [{ key: "project", config: { projectId: source.config.projectId, endpointUrl } }];
+        },
+    },
+};

package/src/triggers/sources/operation.d.ts

@@ -0,0 +1,42 @@
+import type { IntegrationDefinition } from "../common/integration.ts";
+import type { ConnectorProxy } from "../common/proxy.ts";
+import type { JsonValue } from "../common/types.ts";
+import type { SourceConfiguration } from "./definition.ts";
+import { z } from "zod";
+export declare const sourceOperationSchema: z.ZodType<SourceOperation>;
+export type SourceOperation = {
+    readonly action: "initialize";
+    readonly input: Readonly<Record<string, JsonValue>>;
+} | {
+    readonly action: "update";
+    readonly source: SourceConfiguration;
+    readonly input: Readonly<Record<string, JsonValue>>;
+} | {
+    readonly action: "inspect";
+    readonly source: SourceConfiguration;
+} | {
+    readonly action: "prepare";
+    readonly source: SourceConfiguration;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly endpointUrl?: string;
+} | {
+    readonly action: "receive";
+    readonly source: SourceConfiguration;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly rawBody: string;
+    readonly consumers: readonly {
+        readonly id: string;
+        readonly config: Readonly<Record<string, JsonValue>>;
+    }[];
+};
+export declare function sourceMetadata(definition: IntegrationDefinition): {
+    kind: string;
+    provider: string;
+    triggerId: string;
+    maximumBodyBytes: number;
+    applicationIngress: boolean;
+    managed: boolean;
+    createSchema: Record<string, unknown>;
+    updateSchema: Record<string, unknown>;
+} | undefined;
+export declare function executeSourceOperation(definition: IntegrationDefinition, request: SourceOperation, connector: ConnectorProxy, signal: AbortSignal, now?: number): Promise<unknown>;

package/src/triggers/sources/operation.js

@@ -0,0 +1,146 @@
+import { z } from "zod";
+import { IntegrationConnectionError, PermanentIntegrationError } from "../common/integration.js";
+import { createEventSourceSchema, updateEventSourceSchema, sourceCreateSchema } from "./configuration-schema.js";
+const jsonObject = z.record(z.string(), z.json());
+const configuration = z.object({
+    identity: z.string().min(1),
+    eventTypes: z.array(z.string()),
+    config: jsonObject,
+    secrets: jsonObject,
+    state: jsonObject,
+});
+export const sourceOperationSchema = z.discriminatedUnion("action", [
+    z.strictObject({ action: z.literal("initialize"), input: jsonObject }),
+    z.strictObject({ action: z.literal("update"), source: configuration, input: jsonObject }),
+    z.strictObject({ action: z.literal("inspect"), source: configuration }),
+    z.strictObject({
+        action: z.literal("prepare"),
+        source: configuration,
+        config: jsonObject,
+        endpointUrl: z.string().optional(),
+    }),
+    z.strictObject({
+        action: z.literal("receive"),
+        source: configuration,
+        headers: z
+            .record(z.string(), z.string().max(8192))
+            .refine((headers) => new Set(Object.keys(headers).map((name) => name.toLowerCase())).size === Object.keys(headers).length, "Duplicate webhook header."),
+        rawBody: z
+            .string()
+            .max(90000)
+            .regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/),
+        consumers: z.array(z.object({ id: z.string(), config: jsonObject })).max(10000),
+    }),
+]);
+export function sourceMetadata(definition) {
+    const source = definition.source;
+    if (source == null)
+        return undefined;
+    return {
+        createSchema: z.toJSONSchema(sourceCreateSchema(source.kind)),
+        updateSchema: z.toJSONSchema(updateEventSourceSchema),
+        kind: source.kind,
+        provider: source.provider,
+        triggerId: source.resources.triggerId,
+        maximumBodyBytes: source.maximumBodyBytes,
+        applicationIngress: source.applicationIngress === true,
+        managed: source.resources.managed === true,
+    };
+}
+export async function executeSourceOperation(definition, request, connector, signal, now = Date.now()) {
+    const source = definition.source;
+    if (source == null)
+        throw new PermanentIntegrationError("This Trigger has no shared event source protocol.");
+    const execute = async (operation) => {
+        const context = { config: operation.config, connector, now: new Date(now), signal };
+        if (operation.operation === "sourceIdentity") {
+            if (definition.sourceIdentity == null)
+                throw new PermanentIntegrationError("Source identity verification is unavailable.");
+            return definition.sourceIdentity(context);
+        }
+        if (definition.sourceReceive == null)
+            throw new PermanentIntegrationError("Source callback verification is unavailable.");
+        return definition.sourceReceive({ ...context, headers: operation.headers, rawBody: operation.rawBody });
+    };
+    const project = (configuration) => ({
+        ...configuration,
+        state: {
+            ...configuration.state,
+            projection: JSON.parse(JSON.stringify({
+                view: source.view(configuration, now),
+                ready: source.ready(configuration, now),
+                expiresAt: source.expiresAt?.(configuration),
+            })),
+        },
+    });
+    switch (request.action) {
+        case "initialize": {
+            const parsed = createEventSourceSchema.safeParse(request.input);
+            if (!parsed.success)
+                throw new PermanentIntegrationError("Invalid event source configuration.");
+            const input = parsed.data;
+            let configuration = source.initialize(input, connector.providerAccountId);
+            if (source.verifyIdentity != null)
+                configuration = await source.verifyIdentity(configuration, (config) => execute({ operation: "sourceIdentity", config }));
+            return { source: project(configuration) };
+        }
+        case "update": {
+            const parsed = updateEventSourceSchema.safeParse(request.input);
+            if (!parsed.success)
+                throw new PermanentIntegrationError("Invalid event source update.");
+            return { source: project(source.update(request.source, parsed.data)) };
+        }
+        case "inspect":
+            return { source: project(request.source) };
+        case "prepare": {
+            if (connector.providerAccountId !== (request.source.config.accountId ?? request.source.identity))
+                throw new IntegrationConnectionError("The source Connection requires reauthorization.");
+            if (source.verifyIdentity != null)
+                await source.verifyIdentity(request.source, (config) => execute({ operation: "sourceIdentity", config }));
+            if (!source.resources.managed && !source.ready(request.source, now))
+                throw new PermanentIntegrationError("Verify the event source before publishing.");
+            if (!Array.isArray(request.config.eventTypes) ||
+                !request.config.eventTypes.every((type) => typeof type === "string" && request.source.eventTypes.includes(type)))
+                throw new PermanentIntegrationError("Configure the requested events on the event source first.");
+            return {
+                source: project(request.source),
+                subscriptions: source.resources.requests(request.source, source.provider, request.config, request.endpointUrl),
+            };
+        }
+        case "receive": {
+            const bytes = Uint8Array.from(atob(request.rawBody), (value) => value.charCodeAt(0));
+            if (bytes.byteLength > source.maximumBodyBytes)
+                return { response: { status: 413, body: "", headers: {} } };
+            let result;
+            try {
+                result = await source.receive(request.source, bytes, new Headers(request.headers), now, execute);
+            }
+            catch (error) {
+                signal.throwIfAborted();
+                if (!(error instanceof TypeError || error instanceof SyntaxError || error instanceof DOMException))
+                    throw error;
+                return { response: { status: 401, body: "", headers: {} } };
+            }
+            signal.throwIfAborted();
+            const configuration = project({ ...request.source, state: result.state ?? request.source.state });
+            if ("response" in result)
+                return {
+                    source: configuration,
+                    response: {
+                        status: result.response.status,
+                        body: await result.response.text(),
+                        headers: Object.fromEntries(result.response.headers),
+                    },
+                };
+            return {
+                source: configuration,
+                event: {
+                    ...result.event,
+                    matches: request.consumers
+                        .filter((consumer) => source.matches(consumer.config, result.event))
+                        .map((consumer) => consumer.id),
+                },
+            };
+        }
+    }
+}

package/src/triggers/sources/sentry.d.ts

@@ -0,0 +1,3 @@
+import type { CreateEventSource, EventSource, UpdateEventSource } from "./configuration.ts";
+import type { EventSourceDefinition } from "./definition.ts";
+export declare const sentryApplication: EventSourceDefinition<CreateEventSource, UpdateEventSource, Pick<EventSource, "appId" | "installationId" | "organizationId" | "manageSubscriptions" | "verificationTokenConfigured" | "encryptKeyConfigured" | "signingSecretConfigured" | "verifiedAt">>;