@oomol-lab/open-connector 1.9.1 → 1.9.3

package/src/triggers/request.d.ts

@@ -1,8 +1,12 @@
 import type { JsonValue } from "./common/types.ts";
+import type { SourceOperation } from "./sources/operation.ts";
 interface ConfigRequest {
     config: Readonly<Record<string, JsonValue>>;
 }
-export type TriggerRequest = (ConfigRequest & {
+export type TriggerRequest = {
+    operation: "source";
+    request: SourceOperation;
+} | (ConfigRequest & {
     operation: "options";
     field: string;
 }) | (ConfigRequest & {

package/src/triggers/request.js

@@ -1,9 +1,11 @@
 import { z } from "zod";
 import { HttpRequestError } from "../server/api/http-utils.js";
+import { sourceOperationSchema } from "./sources/operation.js";
 const config = z.record(z.string(), z.json());
 const subscriptionId = z.string().min(1).max(128);
 const requestKey = z.string().min(1).max(512);
 const requestSchema = z.discriminatedUnion("operation", [
+    z.strictObject({ operation: z.literal("source"), request: sourceOperationSchema }),
     z.strictObject({ operation: z.literal("options"), config, field: z.string().min(1).max(128) }),
     z.strictObject({ operation: z.literal("read"), config, checkpoint: z.json() }),
     z.strictObject({

package/src/triggers/resources.d.ts

@@ -1,12 +1,18 @@
 import type { IntegrationReconcileResult, ResourceDefinition } from "./common/integration.ts";
 import type { ConnectorProxy } from "./common/proxy.ts";
+import type { JsonValue } from "./common/types.ts";
 import type { TriggerRequest } from "./request.ts";
 import type { TriggerSubscription, TriggerStore } from "./store.ts";
 import type { SubscriptionOwner } from "./subscriptions.ts";
+interface ResourceSubscriptionResult extends IntegrationReconcileResult {
+    readonly subscription?: Readonly<Record<string, JsonValue>>;
+    readonly reconcileAt?: number;
+}
 export declare function executeResourceSubscription(store: TriggerStore, definition: ResourceDefinition, owner: SubscriptionOwner, input: Extract<TriggerRequest, {
     operation: "resource";
-}>, proxy: ConnectorProxy, signal: AbortSignal): Promise<IntegrationReconcileResult>;
+}>, proxy: ConnectorProxy, signal: AbortSignal): Promise<ResourceSubscriptionResult>;
 export declare function executeResourceSubscriptionOperation(store: TriggerStore, definition: ResourceDefinition, consumer: TriggerSubscription, saveConsumer: () => Promise<void>, input: Extract<TriggerRequest, {
     operation: "resource";
-}>, proxy: ConnectorProxy, signal: AbortSignal): Promise<IntegrationReconcileResult>;
+}>, proxy: ConnectorProxy, signal: AbortSignal): Promise<ResourceSubscriptionResult>;
 export declare function abandonResourceSubscription(store: TriggerStore, definition: ResourceDefinition, consumer: TriggerSubscription, signal: AbortSignal): Promise<void>;
+export {};

package/src/triggers/resources.js

@@ -52,6 +52,35 @@ export async function executeResourceSubscriptionOperation(store, definition, co
         consumer.status = "deleting";
         await saveConsumer();
     }
+    if ("reconcile" in definition) {
+        const result = await definition.reconcile({
+            active: input.active,
+            config: input.config,
+            connector: proxy,
+            signal,
+            now: new Date(),
+            endpointUrl: typeof input.config.endpointUrl === "string" ? input.config.endpointUrl : "",
+            callbackSecret: "",
+            idempotencyKey: member,
+            state: {
+                checkpoint: consumer.checkpoint,
+                subscription: consumer.subscription,
+                saveCheckpoint: async (checkpoint) => {
+                    consumer.checkpoint = checkpoint;
+                    await saveConsumer();
+                },
+                saveSubscription: async (subscription, reconcileAt) => {
+                    consumer.subscription = subscription;
+                    consumer.reconcileAt = reconcileAt.getTime();
+                    await saveConsumer();
+                },
+            },
+        });
+        if (!input.active && result.outcome === "ready")
+            consumer.status = "deleted";
+        await saveConsumer();
+        return { ...result, subscription: consumer.subscription, reconcileAt: consumer.reconcileAt };
+    }
     for (const resource of definition.subscriptions(input.config)) {
         const shared = { ...owner, tokenId: "shared-resource" };
         const id = await resourceSubscriptionId(owner, resource.key);
@@ -106,6 +135,8 @@ export async function executeResourceSubscriptionOperation(store, definition, co
     return { outcome: "ready" };
 }
 export async function abandonResourceSubscription(store, definition, consumer, signal) {
+    if ("reconcile" in definition)
+        return;
     for (const resource of definition.subscriptions(consumer.config)) {
         const id = await resourceSubscriptionId(consumer, resource.key);
         if (!(await store.getFlowTrigger(id)))

package/src/triggers/signature.d.ts

@@ -1,4 +1,4 @@
-export declare function bytes(value: string): Uint8Array;
+export declare function bytes(value: string): Uint8Array<ArrayBuffer>;
 export declare function sameSecret(candidate: string | undefined, expected: string): boolean;
-export declare function verifyBase64Hmac(secret: string, parts: readonly Uint8Array[], signature: string | undefined): Promise<boolean>;
-export declare function verifyHexHmac(secret: string, parts: readonly Uint8Array[], signature: string | undefined): Promise<boolean>;
+export declare function verifyBase64Hmac(secret: string | Uint8Array, parts: readonly Uint8Array[], signature: string | undefined): Promise<boolean>;
+export declare function verifyHexHmac(secret: string | Uint8Array, parts: readonly Uint8Array[], signature: string | undefined, hash?: string): Promise<boolean>;

package/src/triggers/signature.js

@@ -9,14 +9,12 @@ export async function verifyBase64Hmac(secret, parts, signature) {
     const candidate = signature == null ? undefined : base64(signature);
     return candidate != null && sameBytes(candidate, await hmac(secret, parts));
 }
-export async function verifyHexHmac(secret, parts, signature) {
+export async function verifyHexHmac(secret, parts, signature, hash = "SHA-256") {
     const candidate = signature == null ? undefined : hex(signature);
-    return candidate != null && sameBytes(candidate, await hmac(secret, parts));
+    return candidate != null && sameBytes(candidate, await hmac(secret, parts, hash));
 }
-async function hmac(secret, parts) {
-    const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { hash: "SHA-256", name: "HMAC" }, false, [
-        "sign",
-    ]);
+async function hmac(secret, parts, hash = "SHA-256") {
+    const key = await crypto.subtle.importKey("raw", typeof secret == "string" ? encoder.encode(secret) : secret, { hash, name: "HMAC" }, false, ["sign"]);
     const size = parts.reduce((total, part) => total + part.byteLength, 0);
     const source = new Uint8Array(size);
     let offset = 0;

package/src/triggers/sources/configuration-schema.d.ts

@@ -0,0 +1,5 @@
+import type { CreateEventSource, UpdateEventSource } from "./configuration.ts";
+import { z } from "zod";
+export declare const updateEventSourceSchema: z.ZodType<UpdateEventSource>;
+export declare const createEventSourceSchema: z.ZodType<CreateEventSource>;
+export declare function sourceCreateSchema(kind: string): z.ZodType<CreateEventSource>;

package/src/triggers/sources/configuration-schema.js

@@ -0,0 +1,118 @@
+import { z } from "zod";
+const id = z.string().min(1).max(256);
+const eventType = z.string().regex(/^[a-z][a-z0-9_.:]{0,127}$/);
+const name = z.string().trim().min(1).max(128);
+const secret = z.string().min(1).max(256);
+const createFeishuEventSourceSchema = z.strictObject({
+    kind: z.literal("feishu").optional(),
+    version: z.literal(1),
+    name,
+    connectionId: id,
+    teamId: id.nullable(),
+    verificationToken: secret,
+    encryptKey: secret,
+    eventTypes: z
+        .array(eventType)
+        .min(1)
+        .max(200)
+        .refine((values) => new Set(values).size == values.length),
+    manageSubscriptions: z.boolean(),
+});
+const createSchema = z.union([
+    createFeishuEventSourceSchema,
+    z.strictObject({
+        kind: z.literal("jira"),
+        version: z.literal(1),
+        name,
+        connectionId: id,
+        teamId: id.nullable(),
+        project: id,
+        eventTypes: z
+            .array(z.enum(["jira:issue_created", "jira:issue_updated", "comment_created"]))
+            .min(1)
+            .max(3)
+            .refine((values) => new Set(values).size === values.length),
+    }),
+    z.strictObject({
+        kind: z.literal("fireflies"),
+        version: z.literal(1),
+        name,
+        connectionId: id,
+        teamId: id.nullable(),
+        signingSecret: secret,
+        eventTypes: z
+            .array(z.enum(["meeting.transcribed", "meeting.summarized"]))
+            .min(1)
+            .max(2)
+            .refine((values) => new Set(values).size === values.length),
+    }),
+    z.strictObject({
+        kind: z.literal("zoom"),
+        version: z.literal(1),
+        name,
+        connectionId: id,
+        teamId: id.nullable(),
+        appId: id,
+        signingSecret: secret,
+        eventTypes: z.array(z.literal("recording.completed")).length(1),
+    }),
+    z.strictObject({
+        kind: z.literal("sentry"),
+        version: z.literal(1),
+        name,
+        connectionId: id,
+        teamId: id.nullable(),
+        appId: id,
+        installationId: id,
+        organizationId: id,
+        signingSecret: secret,
+        eventTypes: z.array(z.literal("issue.alert")).length(1),
+    }),
+    z.strictObject({
+        kind: z.literal("intercom"),
+        version: z.literal(1),
+        name,
+        connectionId: id,
+        teamId: id.nullable(),
+        appId: id,
+        signingSecret: secret,
+        eventTypes: z
+            .array(z.enum(["conversation.user.created", "conversation.user.replied", "ticket.created"]))
+            .min(1)
+            .max(3)
+            .refine((values) => new Set(values).size === values.length),
+    }),
+    z.strictObject({
+        kind: z.literal("slack"),
+        version: z.literal(1),
+        name,
+        connectionId: id,
+        teamId: id.nullable(),
+        appId: z.string().regex(/^A[A-Z0-9]+$/),
+        workspaceId: z.string().regex(/^T[A-Z0-9]+$/),
+        signingSecret: secret,
+        eventTypes: z
+            .array(z.enum(["app_mention", "message.im"]))
+            .min(1)
+            .max(2)
+            .refine((values) => new Set(values).size === values.length),
+    }),
+]);
+export const updateEventSourceSchema = z.strictObject({
+    version: z.literal(1),
+    expectedRevision: z.int().positive(),
+    name,
+    enabled: z.boolean(),
+    eventTypes: z
+        .array(eventType)
+        .min(1)
+        .max(200)
+        .refine((values) => new Set(values).size == values.length),
+    verificationToken: secret.optional(),
+    signingSecret: secret.optional(),
+    encryptKey: secret.optional(),
+});
+export const createEventSourceSchema = createSchema;
+export function sourceCreateSchema(kind) {
+    return createSchema.options.find((schema) => schema.shape.kind.safeParse(kind).success);
+}

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

@@ -0,0 +1,115 @@
+export interface CreateFeishuEventSource {
+    readonly kind?: "feishu";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly verificationToken: string;
+    readonly encryptKey: string;
+    readonly eventTypes: string[];
+    readonly manageSubscriptions: boolean;
+}
+export interface CreateSlackEventSource {
+    readonly kind: "slack";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly appId: string;
+    readonly workspaceId: string;
+    readonly signingSecret: string;
+    readonly eventTypes: string[];
+}
+export interface CreateIntercomEventSource {
+    readonly kind: "intercom";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly appId: string;
+    readonly signingSecret: string;
+    readonly eventTypes: string[];
+}
+export interface CreateSentryEventSource {
+    readonly kind: "sentry";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly appId: string;
+    readonly installationId: string;
+    readonly organizationId: string;
+    readonly signingSecret: string;
+    readonly eventTypes: string[];
+}
+export interface CreateZoomEventSource {
+    readonly kind: "zoom";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly appId: string;
+    readonly signingSecret: string;
+    readonly eventTypes: string[];
+}
+export interface CreateFirefliesEventSource {
+    readonly kind: "fireflies";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly signingSecret: string;
+    readonly eventTypes: string[];
+}
+export interface CreateJiraEventSource {
+    readonly kind: "jira";
+    readonly version: 1;
+    readonly name: string;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly project: string;
+    readonly eventTypes: string[];
+}
+export type CreateEventSource = CreateFeishuEventSource | CreateSlackEventSource | CreateIntercomEventSource | CreateSentryEventSource | CreateZoomEventSource | CreateFirefliesEventSource | CreateJiraEventSource;
+export interface UpdateEventSource {
+    readonly signingSecret?: string;
+    readonly version: 1;
+    readonly expectedRevision: number;
+    readonly name: string;
+    readonly enabled: boolean;
+    readonly eventTypes: string[];
+    readonly verificationToken?: string;
+    readonly encryptKey?: string;
+}
+export interface EventSource {
+    readonly version: 1;
+    readonly sourceId: string;
+    readonly revision: number;
+    readonly name: string;
+    readonly provider: "feishu" | "feishu_app_bot" | "slackbot" | "intercom" | "sentry" | "zoom" | "fireflies" | "jira";
+    readonly appId: string;
+    readonly workspaceId?: string;
+    readonly installationId?: string;
+    readonly organizationId?: string;
+    readonly projectId?: string;
+    readonly projectKey?: string;
+    readonly subscriptionStatus?: "idle" | "pending" | "ready" | "error";
+    readonly lastError?: string;
+    readonly signingSecretConfigured?: boolean;
+    readonly connectionId: string;
+    readonly teamId: string | null;
+    readonly enabled: boolean;
+    readonly eventTypes: string[];
+    readonly manageSubscriptions: boolean;
+    readonly verificationTokenConfigured: boolean;
+    readonly encryptKeyConfigured: boolean;
+    readonly endpointUrl: string | null;
+    readonly verifiedAt: string | null;
+    readonly lastReceivedAt: string | null;
+    readonly updatedAt: string;
+    readonly consumers: {
+        flowId: string;
+        flowName: string;
+        triggerNodeId: string;
+    }[];
+}

package/src/triggers/sources/configuration.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,61 @@
+import { PermanentIntegrationError } from "../common/integration.ts";
+type TriggerOperationRequest = {
+    operation: "sourceIdentity";
+    config: Readonly<Record<string, JsonValue>>;
+} | {
+    operation: "sourceReceive";
+    config: Readonly<Record<string, JsonValue>>;
+    headers: Readonly<Record<string, string>>;
+    rawBody: string;
+};
+import type { JsonValue } from "../common/types.ts";
+export interface SourceConfiguration {
+    readonly identity: string;
+    readonly eventTypes: string[];
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly secrets: Readonly<Record<string, JsonValue>>;
+    readonly state: Readonly<Record<string, JsonValue>>;
+}
+export interface SourceEvent {
+    readonly ordering?: {
+        readonly key: string;
+        readonly version: number;
+    };
+    readonly id: string;
+    readonly type: string;
+    readonly payload: Readonly<Record<string, JsonValue>>;
+}
+export interface SourceSubscription {
+    readonly key: string;
+    readonly config: Readonly<Record<string, JsonValue>>;
+}
+export interface EventSourceDefinition<Create, Update, View> {
+    readonly kind: string;
+    readonly provider: string;
+    readonly maximumBodyBytes: number;
+    readonly expiresAt?: (source: SourceConfiguration) => number | undefined;
+    readonly applicationIngress?: boolean;
+    readonly initialize: (input: Create, accountId: string | undefined) => SourceConfiguration;
+    readonly verifyIdentity?: (source: SourceConfiguration, read: (config: Readonly<Record<string, JsonValue>>) => Promise<unknown>) => Promise<SourceConfiguration>;
+    readonly update: (source: SourceConfiguration, input: Update) => SourceConfiguration;
+    readonly view: (source: SourceConfiguration, now?: number) => View;
+    readonly ready: (source: SourceConfiguration, now?: number) => boolean;
+    readonly receive: (source: SourceConfiguration, bytes: Uint8Array, headers: Headers, now: number, execute?: (request: Extract<TriggerOperationRequest, {
+        operation: "sourceIdentity" | "sourceReceive";
+    }>) => Promise<unknown>) => Promise<{
+        readonly response: Response;
+        readonly state: SourceConfiguration["state"];
+    } | {
+        readonly event: SourceEvent;
+        readonly state?: SourceConfiguration["state"];
+    }>;
+    readonly matches: (config: Readonly<Record<string, JsonValue>>, event: SourceEvent) => boolean;
+    readonly resources: {
+        readonly managed?: boolean;
+        readonly triggerId: string;
+        readonly requests: (source: SourceConfiguration, provider: string, config: Readonly<Record<string, JsonValue>>, endpointUrl?: string) => readonly SourceSubscription[];
+    };
+}
+export declare class SourceIdentityError extends PermanentIntegrationError {
+}
+export {};

package/src/triggers/sources/definition.js

@@ -0,0 +1,3 @@
+import { PermanentIntegrationError } from "../common/integration.js";
+export class SourceIdentityError extends PermanentIntegrationError {
+}

package/src/triggers/sources/feishu-demands.d.ts

@@ -0,0 +1,6 @@
+import type { JsonValue } from "../common/types.ts";
+export interface FeishuSubscription {
+    readonly key: string;
+    readonly config: Readonly<Record<string, JsonValue>>;
+}
+export declare function feishuSubscriptions(config: Readonly<Record<string, JsonValue>>, provider: string): readonly FeishuSubscription[];

package/src/triggers/sources/feishu-demands.js

@@ -0,0 +1,24 @@
+import { feishuResourceKind } from "../../providers/feishu_app_bot/trigger-config.js";
+import { PermanentIntegrationError } from "../common/integration.js";
+import { isJsonObject } from "../common/json.js";
+export function feishuSubscriptions(config, provider) {
+    if (config.resource == null)
+        return [];
+    if (!isJsonObject(config.resource))
+        throw new PermanentIntegrationError("Invalid Feishu resource.");
+    const { kind, id, documentType } = config.resource;
+    if (typeof id != "string" || id.length == 0 || kind != feishuResourceKind(config.eventTypes))
+        throw new PermanentIntegrationError("Invalid resource subscription.");
+    if (kind == "document") {
+        if (typeof documentType != "string" ||
+            !["doc", "docx", "sheet", "bitable", "file", "folder", "slides"].includes(documentType))
+            throw new PermanentIntegrationError("A supported document type is required.");
+        return config.eventTypes.map((eventType) => ({
+            key: JSON.stringify(["document", documentType, id, eventType]),
+            config: { ...config, eventTypes: [eventType] },
+        }));
+    }
+    if (kind == "calendar" || (kind == "approval" && provider == "feishu_app_bot"))
+        return [{ key: JSON.stringify([kind, id]), config }];
+    throw new PermanentIntegrationError("Unsupported Feishu resource subscription.");
+}

package/src/triggers/sources/feishu-events.d.ts

@@ -0,0 +1,19 @@
+import type { JsonValue } from "../common/types.ts";
+export interface FeishuEvent {
+    readonly id: string;
+    readonly type: string;
+    readonly appId: string;
+    readonly tenantKey: string;
+    readonly occurredAt: string | null;
+    readonly body: Readonly<Record<string, JsonValue>>;
+}
+export declare function receiveFeishuEvent(rawBody: Uint8Array, headers: Headers, source: {
+    readonly appId: string;
+    readonly verificationToken: string;
+    readonly encryptKey: string;
+}, now: number): Promise<{
+    readonly challenge: string;
+} | {
+    readonly event: FeishuEvent;
+}>;
+export declare function matchesFeishuEvent(config: Readonly<Record<string, JsonValue>>, event: Pick<FeishuEvent, "type" | "body">): boolean;

package/src/triggers/sources/feishu-events.js

@@ -0,0 +1,108 @@
+import { isJsonObject } from "../common/json.js";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: true });
+export async function receiveFeishuEvent(rawBody, headers, source, now) {
+    const envelope = JSON.parse(decoder.decode(rawBody));
+    if (!isJsonObject(envelope) ||
+        typeof envelope.encrypt != "string" ||
+        !/^[A-Za-z0-9+/]+={0,2}$/.test(envelope.encrypt)) {
+        throw new TypeError("An encrypted Feishu envelope is required.");
+    }
+    const bytes = Uint8Array.from(atob(envelope.encrypt), (character) => character.charCodeAt(0));
+    if (bytes.length < 32 || bytes.length % 16 != 0)
+        throw new TypeError("Invalid encrypted Feishu envelope.");
+    const key = await crypto.subtle.importKey("raw", await crypto.subtle.digest("SHA-256", encoder.encode(source.encryptKey)), "AES-CBC", false, ["decrypt"]);
+    const value = JSON.parse(decoder.decode(await crypto.subtle.decrypt({ name: "AES-CBC", iv: bytes.slice(0, 16) }, key, bytes.slice(16))));
+    if (!isJsonObject(value))
+        throw new TypeError("Invalid Feishu event.");
+    const header = isJsonObject(value.header) ? value.header : undefined;
+    if (!sameSecret(header?.token ?? value.token, source.verificationToken))
+        throw new TypeError("Invalid Feishu verification token.");
+    if (value.type == "url_verification") {
+        if (typeof value.challenge != "string" || value.challenge.length == 0 || value.challenge.length > 1024)
+            throw new TypeError("Invalid challenge.");
+        return { challenge: value.challenge };
+    }
+    const timestamp = headers.get("x-lark-request-timestamp") ?? "";
+    const nonce = headers.get("x-lark-request-nonce") ?? "";
+    const signature = headers.get("x-lark-signature") ?? "";
+    if (!/^\d{10}$/.test(timestamp) ||
+        Math.abs(now - Number(timestamp) * 1000) > 86_400_000 ||
+        nonce.length == 0 ||
+        nonce.length > 256) {
+        throw new TypeError("Invalid Feishu request identity.");
+    }
+    const prefix = encoder.encode(timestamp + nonce + source.encryptKey);
+    const signed = new Uint8Array(prefix.length + rawBody.length);
+    signed.set(prefix);
+    signed.set(rawBody, prefix.length);
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", signed));
+    const hex = Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    if (!sameSecret(signature, hex))
+        throw new TypeError("Invalid Feishu signature.");
+    const body = value.event;
+    if (!isJsonObject(body))
+        throw new TypeError("Missing Feishu event body.");
+    if (value.schema != null && value.schema != "2.0")
+        throw new TypeError("Unsupported Feishu event schema.");
+    const type = header?.event_type ?? body.type;
+    const appId = header?.app_id ?? body.app_id ?? value.app_id;
+    const tenantKey = header?.tenant_key ?? body.tenant_key ?? value.tenant_key;
+    let id = header?.event_id ?? value.uuid;
+    if (type == "im.message.receive_v1" && isJsonObject(body.message))
+        id = body.message.message_id;
+    if (typeof id != "string" ||
+        id.length == 0 ||
+        id.length > 256 ||
+        typeof type != "string" ||
+        !/^[a-z][a-z0-9_.]{0,127}$/.test(type)) {
+        throw new TypeError("Missing Feishu event identity.");
+    }
+    if (appId != source.appId)
+        throw new TypeError("Feishu event source does not match.");
+    if (typeof tenantKey != "string" || tenantKey.length == 0 || tenantKey.length > 256)
+        throw new TypeError("Invalid Feishu event tenant.");
+    if (type == "card.action.trigger" || type == "app_ticket")
+        throw new TypeError("This callback is not an asynchronous business event.");
+    const { token: _token, ...business } = body;
+    const occurredAt = header?.create_time ?? value.ts;
+    return {
+        event: {
+            id: `${type}:${id}`,
+            type,
+            appId: source.appId,
+            tenantKey,
+            occurredAt: typeof occurredAt == "string" ? occurredAt : null,
+            body: business,
+        },
+    };
+}
+function sameSecret(value, expected) {
+    if (typeof value != "string" || value.length != expected.length)
+        return false;
+    let difference = 0;
+    for (let index = 0; index < expected.length; index += 1)
+        difference |= value.charCodeAt(index) ^ expected.charCodeAt(index);
+    return difference == 0;
+}
+export function matchesFeishuEvent(config, event) {
+    if (!Array.isArray(config.eventTypes) || !config.eventTypes.includes(event.type))
+        return false;
+    const chatIds = config.chatIds;
+    if (Array.isArray(chatIds) && chatIds.length > 0) {
+        const chatId = isJsonObject(event.body.message) ? event.body.message.chat_id : event.body.chat_id;
+        if (typeof chatId != "string" || !chatIds.includes(chatId))
+            return false;
+    }
+    const resource = config.resource;
+    if (isJsonObject(resource)) {
+        const id = resource.kind == "document"
+            ? event.body.file_token
+            : resource.kind == "calendar"
+                ? event.body.calendar_id
+                : event.body.approval_code;
+        if (id != resource.id)
+            return false;
+    }
+    return true;
+}

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

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