@oomol-lab/open-connector 1.7.0 → 1.8.0

package/src/providers/notion/trigger-on-database-page-event.js

@@ -0,0 +1,293 @@
+import { eventsPollOutputs, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot } from "./trigger-on-database-page-event.definition.js";
+export const notionDatabasePageEvent = {
+    buildOutputs: eventsPollOutputs,
+    snapshot,
+    async poll(context) {
+        const config = resolveConfig(context.config);
+        if (context.checkpoint === null)
+            return seed(context, config);
+        const stored = readCheckpoint(context.checkpoint);
+        if (stored.target !== target(config))
+            return seed(context, config);
+        return drain(context, config, alignField(stored, cursorField(config.events)));
+    },
+};
+function resolveConfig(value) {
+    return {
+        dataSourceId: value.dataSourceId,
+        databaseId: value.databaseId,
+        events: [...new Set(value.events)],
+        includeProperties: value.includeProperties,
+        maxItemsPerPoll: value.maxItemsPerPoll,
+    };
+}
+async function seed(context, config) {
+    const dataSourceId = await resolveDataSource(context, config);
+    const field = cursorField(config.events);
+    const result = await request(context, {
+        body: { page_size: 1, sorts: [{ direction: "ascending", timestamp: field }] },
+        endpoint: `/data_sources/${encodeURIComponent(dataSourceId)}/query`,
+        method: "POST",
+    });
+    success(result, "seed probe query");
+    return {
+        checkpoint: {
+            cursorField: field,
+            dataSourceId,
+            since: new Date(Math.ceil(context.now.getTime() / 60_000) * 60_000).toISOString(),
+            target: target(config),
+        },
+        events: [],
+    };
+}
+async function resolveDataSource(context, config) {
+    const result = await request(context, {
+        endpoint: `/databases/${encodeURIComponent(config.databaseId)}`,
+        method: "GET",
+    });
+    success(result, "database resolve");
+    const raw = record(result.data)?.data_sources;
+    const candidates = Array.isArray(raw)
+        ? raw.flatMap((value) => {
+            const id = record(value)?.id;
+            return typeof id == "string" && id.length > 0 ? [id] : [];
+        })
+        : [];
+    if (config.dataSourceId.length > 0) {
+        const wanted = normalizeId(config.dataSourceId);
+        const match = candidates.find((id) => normalizeId(id) == wanted);
+        if (match == null)
+            throw new PermanentPollError("The Notion data source does not belong to the configured database.");
+        return match;
+    }
+    if (candidates.length == 1)
+        return candidates[0];
+    if (candidates.length == 0)
+        throw new PermanentPollError("The Notion database has no data sources.");
+    throw new PermanentPollError("The Notion database has multiple data sources; configure dataSourceId.");
+}
+function readCheckpoint(value) {
+    const checkpoint = record(value);
+    const field = checkpoint?.cursorField;
+    if (typeof checkpoint?.dataSourceId != "string" ||
+        checkpoint.dataSourceId.length == 0 ||
+        (field !== "created_time" && field !== "last_edited_time") ||
+        typeof checkpoint.since != "string" ||
+        checkpoint.since.length == 0) {
+        throw new PermanentPollError("Notion checkpoint is invalid; recreate the Trigger.");
+    }
+    return {
+        cursorField: field,
+        dataSourceId: checkpoint.dataSourceId,
+        since: checkpoint.since,
+        target: typeof checkpoint.target == "string" ? checkpoint.target : "",
+        ...(typeof checkpoint.startCursor == "string" && checkpoint.startCursor.length > 0
+            ? { startCursor: checkpoint.startCursor }
+            : {}),
+        ...(checkpoint.sinceExclusive === true ? { sinceExclusive: true } : {}),
+        ...(checkpoint.sinceOnly === true ? { sinceOnly: true } : {}),
+    };
+}
+function cursorField(events) {
+    return events.length == 1 && events[0] == "page_added" ? "created_time" : "last_edited_time";
+}
+function alignField(checkpoint, field) {
+    return checkpoint.cursorField == field
+        ? checkpoint
+        : {
+            cursorField: field,
+            dataSourceId: checkpoint.dataSourceId,
+            since: checkpoint.since,
+            target: checkpoint.target,
+        };
+}
+async function drain(context, config, checkpoint) {
+    const events = [];
+    let filtered = 0;
+    let consumed = 0;
+    let newest = null;
+    let startCursor = checkpoint.startCursor;
+    let ending = null;
+    for (let attempt = 0; attempt < 5; attempt += 1) {
+        const result = await request(context, {
+            body: queryBody(checkpoint, config.maxItemsPerPoll - consumed, startCursor),
+            endpoint: `/data_sources/${encodeURIComponent(checkpoint.dataSourceId)}/query`,
+            method: "POST",
+        });
+        if (result.status == 400 && startCursor != null) {
+            ending = "restarted";
+            break;
+        }
+        success(result, "data source query");
+        const page = (record(result.data) ?? {});
+        for (const row of page.results ?? []) {
+            consumed += 1;
+            const timestamp = checkpoint.cursorField == "created_time" ? row.created_time : row.last_edited_time;
+            if (timestamp != null && timestamp.length > 0)
+                newest = later(newest, timestamp);
+            const kind = classify(row);
+            if (!config.events.includes(kind))
+                filtered += 1;
+            else
+                events.push(event(row, kind, config, checkpoint));
+        }
+        if (page.request_status?.type == "incomplete") {
+            ending = "truncated";
+            break;
+        }
+        if (page.has_more !== true || typeof page.next_cursor != "string" || page.next_cursor.length == 0) {
+            ending = "complete";
+            break;
+        }
+        startCursor = page.next_cursor;
+        if (consumed >= config.maxItemsPerPoll) {
+            ending = { nextCursor: page.next_cursor };
+            break;
+        }
+    }
+    if (ending == null)
+        ending = { nextCursor: startCursor };
+    const base = {
+        cursorField: checkpoint.cursorField,
+        dataSourceId: checkpoint.dataSourceId,
+        target: checkpoint.target,
+    };
+    const next = typeof ending == "object"
+        ? {
+            ...base,
+            since: checkpoint.since,
+            startCursor: ending.nextCursor,
+            ...modifiers(checkpoint),
+        }
+        : { ...base, ...advance(checkpoint, ending, newest, context.now) };
+    return {
+        checkpoint: next,
+        events,
+        filtered,
+        ...(ending == "complete" ? {} : { hasMore: true }),
+    };
+}
+function advance(checkpoint, ending, newest, now) {
+    const pinned = { since: checkpoint.since, ...modifiers(checkpoint) };
+    const closed = Date.parse(checkpoint.since) + 60_000 <= now.getTime();
+    const escaped = closed ? { since: checkpoint.since, sinceExclusive: true } : pinned;
+    if (newest != null && after(newest, checkpoint.since))
+        return { since: newest };
+    if (ending == "restarted")
+        return pinned;
+    if (ending == "complete")
+        return checkpoint.sinceOnly === true || newest != null ? escaped : pinned;
+    if (newest == null)
+        return pinned;
+    return checkpoint.sinceOnly === true ? escaped : { since: checkpoint.since, sinceOnly: true };
+}
+function modifiers(checkpoint) {
+    return {
+        ...(checkpoint.sinceExclusive === true ? { sinceExclusive: true } : {}),
+        ...(checkpoint.sinceOnly === true ? { sinceOnly: true } : {}),
+    };
+}
+function queryBody(checkpoint, budget, startCursor) {
+    const field = checkpoint.cursorField;
+    const filter = checkpoint.sinceOnly === true
+        ? {
+            and: [
+                { [field]: { on_or_after: checkpoint.since }, timestamp: field },
+                { [field]: { on_or_before: checkpoint.since }, timestamp: field },
+            ],
+        }
+        : {
+            [field]: {
+                [checkpoint.sinceExclusive === true ? "after" : "on_or_after"]: checkpoint.since,
+            },
+            timestamp: field,
+        };
+    return {
+        filter,
+        page_size: Math.min(100, budget),
+        sorts: [{ direction: "ascending", timestamp: field }],
+        ...(startCursor == null ? {} : { start_cursor: startCursor }),
+    };
+}
+function classify(page) {
+    return instant(page.created_time) === instant(page.last_edited_time) ? "page_added" : "page_updated";
+}
+function event(page, kind, config, checkpoint) {
+    return {
+        dedupeKey: kind == "page_added"
+            ? `added:${page.id}`
+            : `updated:${page.id}:${instant(page.last_edited_time) ?? page.last_edited_time ?? ""}`,
+        payload: {
+            createdBy: { id: page.created_by?.id ?? "" },
+            createdTime: page.created_time ?? "",
+            dataSourceId: checkpoint.dataSourceId,
+            databaseId: canonicalId(config.databaseId),
+            event: kind,
+            lastEditedBy: { id: page.last_edited_by?.id ?? "" },
+            lastEditedTime: page.last_edited_time ?? "",
+            pageId: page.id,
+            ...(config.includeProperties ? { properties: page.properties ?? {} } : {}),
+            title: title(page.properties ?? {}),
+            url: page.url ?? "",
+        },
+    };
+}
+function title(properties) {
+    for (const value of Object.values(properties)) {
+        const property = record(value);
+        if (property?.type !== "title" || !Array.isArray(property.title))
+            continue;
+        return property.title
+            .map((part) => (typeof record(part)?.plain_text == "string" ? record(part).plain_text : ""))
+            .join("");
+    }
+    return "";
+}
+async function request(context, value) {
+    try {
+        return await context.connector.execute(value, context.signal);
+    }
+    catch (cause) {
+        throw new TransientPollError(`Notion proxy request to ${value.endpoint} failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    if (result.status == 401 || result.status == 403)
+        throw new PollConnectionError(`Notion ${operation} rejected the Connection.`);
+    if (result.status == 404)
+        throw new PermanentPollError("The Notion target was not found or is not shared with the Connection.");
+    if (result.status == 400)
+        throw new PermanentPollError(`Notion ${operation} rejected the configuration.`);
+    throw new TransientPollError(`Notion ${operation} failed with status ${result.status}.`);
+}
+function target(config) {
+    return `${config.databaseId}|${config.dataSourceId}`;
+}
+function normalizeId(value) {
+    return value.replaceAll("-", "").toLowerCase();
+}
+function canonicalId(value) {
+    const hex = normalizeId(value);
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function later(current, candidate) {
+    const timestamp = Date.parse(candidate);
+    return Number.isNaN(timestamp) || (current != null && timestamp < Date.parse(current)) ? current : candidate;
+}
+function after(left, right) {
+    return !Number.isNaN(Date.parse(left)) && !Number.isNaN(Date.parse(right)) && Date.parse(left) > Date.parse(right);
+}
+function instant(value) {
+    if (value == null || value.length == 0)
+        return null;
+    const milliseconds = Date.parse(value);
+    return Number.isNaN(milliseconds) ? null : new Date(milliseconds).toISOString();
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/src/providers/one_drive/executors.d.ts

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { OAuthProviderContext } from "../provider-runtime.ts";
 type OneDriveRuntimeDeps = OAuthProviderContext;
@@ -23,4 +25,5 @@ export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
 export declare function oneDriveJsonRequest<T>(pathOrUrl: string, input: OneDriveRequestInput): Promise<T>;
 export declare function assertOneDriveResponse(response: Response): Promise<void>;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/one_drive/executors.js

@@ -2,6 +2,7 @@ import { Buffer } from "node:buffer";
 import { compactObject, requiredRecord } from "../../core/cast.js";
 import { readBoundedResponseBytes } from "../../core/request.js";
 import { defineOAuthProviderExecutors, defineProviderProxy, ProviderRequestError, readTransitFileInput, } from "../provider-runtime.js";
+import { oneDriveItemChanged } from "./trigger-on-item-changed.js";
 const graphBaseUrl = "https://graph.microsoft.com/v1.0";
 const graphOrigin = new URL(graphBaseUrl).origin;
 const oneDriveUploadChunkSizeBytes = 10 * 1024 * 1024;
@@ -1194,3 +1195,4 @@ function toArrayBuffer(bytes) {
     }
     return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
 }
+export const triggers = [oneDriveItemChanged];

package/src/providers/one_drive/trigger-on-item-changed.d.ts

@@ -0,0 +1,2 @@
+import type { PollDefinition } from "../../triggers/common/poll.ts";
+export declare const oneDriveItemChanged: PollDefinition;

package/src/providers/one_drive/trigger-on-item-changed.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "poll";
+};

package/src/providers/one_drive/trigger-on-item-changed.definition.js

@@ -0,0 +1,63 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const eventSchema = s.object({
+    changeType: s.stringEnum(["created", "updated", "deleted"]),
+    createdDateTime: { type: ["string", "null"] },
+    driveId: { type: ["string", "null"] },
+    eTag: { type: ["string", "null"] },
+    itemId: s.string(),
+    itemType: s.stringEnum(["file", "folder"]),
+    lastModifiedDateTime: { type: ["string", "null"] },
+    mimeType: { type: ["string", "null"] },
+    name: s.string(),
+    parentFolderId: { type: ["string", "null"] },
+    size: { type: ["number", "null"] },
+    webUrl: s.string(),
+}, {
+    additionalProperties: false,
+    required: [
+        "itemId",
+        "name",
+        "changeType",
+        "itemType",
+        "size",
+        "mimeType",
+        "webUrl",
+        "parentFolderId",
+        "driveId",
+        "createdDateTime",
+        "lastModifiedDateTime",
+        "eTag",
+    ],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.stringEnum(["created", "updated", "deleted"]), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+            value: ["created", "updated"],
+        },
+        { handle: "itemId", jsonSchema: s.string(), nullable: false, value: "" },
+        {
+            handle: "itemTypes",
+            jsonSchema: s.array(s.stringEnum(["file", "folder"]), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+            value: ["file"],
+        },
+        {
+            handle: "maxItemsPerPoll",
+            jsonSchema: s.integer({ maximum: 200, minimum: 1 }),
+            nullable: false,
+            value: 50,
+        },
+        { handle: "parentFolderId", jsonSchema: s.string(), nullable: false, value: "" },
+    ],
+    definitionVersion: 2,
+    description: "Polls the OneDrive change feed and triggers when a file or folder is created, updated or deleted.",
+    displayName: "File or Folder Changed",
+    key: "one_drive.on_item_changed",
+    name: "on_item_changed",
+    outputs: [{ handle: "events", jsonSchema: s.array(eventSchema), nullable: false }],
+    provider: "one_drive",
+    type: "poll",
+};

package/src/providers/one_drive/trigger-on-item-changed.js

@@ -0,0 +1,214 @@
+import { canonicalJsonBytes, digestBytes } from "../../triggers/common/encoding.js";
+import { eventsPollOutputs, maximumPollEventsPerPage, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot } from "./trigger-on-item-changed.definition.js";
+export const oneDriveItemChanged = {
+    buildOutputs: eventsPollOutputs,
+    snapshot,
+    async poll(context) {
+        const config = resolveConfig(context.config);
+        if (context.checkpoint === null)
+            return { checkpoint: (await seed(context, config)), events: [] };
+        const checkpoint = readCheckpoint(context.checkpoint);
+        const { items, next } = await changedItems(context, checkpoint, config.maxItemsPerPoll);
+        const events = [];
+        let filtered = 0;
+        for (const [id, item] of items) {
+            const result = await evaluate(id, item, config, checkpoint);
+            if (result == "structural")
+                continue;
+            if (result == "filtered")
+                filtered += 1;
+            else
+                events.push(result);
+        }
+        return {
+            checkpoint: next.checkpoint,
+            events,
+            filtered,
+            ...(next.hasMore ? { hasMore: true } : {}),
+        };
+    },
+};
+function resolveConfig(value) {
+    return {
+        events: value.events,
+        itemId: value.itemId.trim(),
+        itemTypes: value.itemTypes,
+        maxItemsPerPoll: value.maxItemsPerPoll,
+        parentFolderId: value.parentFolderId.trim(),
+    };
+}
+async function seed(context, config) {
+    const result = await get(context, "/me/drive/root/delta", { token: "latest" });
+    if (result.status == 404)
+        throw new PermanentPollError("OneDrive is not provisioned for this account.");
+    success(result, "delta seeding");
+    const link = record(result.data)?.["@odata.deltaLink"];
+    const token = link == null ? null : parseToken(link);
+    if (token == null)
+        throw new TransientPollError("OneDrive delta seeding response has no delta token.");
+    await validateItem(context, "parentFolderId", config.parentFolderId);
+    await validateItem(context, "itemId", config.itemId);
+    return { deltaToken: token, lastPolledAt: context.now.toISOString() };
+}
+async function validateItem(context, field, id) {
+    if (id.length == 0)
+        return;
+    const result = await get(context, `/me/drive/items/${encodeURIComponent(id)}`, {});
+    if (result.status == 400 || result.status == 404)
+        throw new PermanentPollError(`OneDrive ${field} does not identify an item in this drive.`);
+    success(result, `${field} validation`);
+}
+function readCheckpoint(value) {
+    const checkpoint = record(value);
+    if (typeof checkpoint?.deltaToken != "string" ||
+        checkpoint.deltaToken.length == 0 ||
+        typeof checkpoint.lastPolledAt != "string" ||
+        Number.isNaN(Date.parse(checkpoint.lastPolledAt))) {
+        throw new PermanentPollError("OneDrive checkpoint is invalid; recreate the Trigger.");
+    }
+    return {
+        deltaToken: checkpoint.deltaToken,
+        lastPolledAt: checkpoint.lastPolledAt,
+        ...(typeof checkpoint.pageToken == "string" && checkpoint.pageToken.length > 0
+            ? { pageToken: checkpoint.pageToken }
+            : {}),
+    };
+}
+async function changedItems(context, checkpoint, pageSize) {
+    const items = new Map();
+    const result = await get(context, "/me/drive/root/delta", {
+        $top: Math.min(pageSize, maximumPollEventsPerPage),
+        token: checkpoint.pageToken ?? checkpoint.deltaToken,
+    });
+    deltaSuccess(result);
+    const parsed = (record(result.data) ?? {});
+    for (const item of parsed.value ?? [])
+        if (item.id != null && item.id.length > 0)
+            items.set(item.id, item);
+    if (parsed["@odata.deltaLink"]) {
+        return {
+            items,
+            next: {
+                checkpoint: {
+                    deltaToken: requireToken(parsed["@odata.deltaLink"]),
+                    lastPolledAt: context.now.toISOString(),
+                },
+                hasMore: false,
+            },
+        };
+    }
+    if (!parsed["@odata.nextLink"])
+        throw new TransientPollError("OneDrive delta response has no continuation link.");
+    return {
+        items,
+        next: {
+            checkpoint: {
+                deltaToken: checkpoint.deltaToken,
+                lastPolledAt: checkpoint.lastPolledAt,
+                pageToken: requireToken(parsed["@odata.nextLink"]),
+            },
+            hasMore: true,
+        },
+    };
+}
+async function evaluate(id, item, config, checkpoint) {
+    if (item.root != null)
+        return "structural";
+    const itemType = type(item);
+    if (itemType == null)
+        return "structural";
+    const change = item.deleted != null
+        ? "deleted"
+        : createdAfter(item.createdDateTime, new Date(checkpoint.lastPolledAt))
+            ? "created"
+            : "updated";
+    if (!config.events.includes(change) || !config.itemTypes.includes(itemType))
+        return "filtered";
+    if (config.parentFolderId.length > 0 && item.parentReference?.id !== config.parentFolderId)
+        return "filtered";
+    if (config.itemId.length > 0 && id !== config.itemId)
+        return "filtered";
+    return await event(id, item, change, itemType, checkpoint.deltaToken);
+}
+function type(item) {
+    if (item.file != null)
+        return "file";
+    if (item.folder != null)
+        return "folder";
+    return item.deleted != null ? "file" : null;
+}
+async function event(id, item, change, itemType, deltaToken) {
+    // 同一轮分页共用删除事件标识，后续 delta 周期必须使用新标识。
+    return {
+        dedupeKey: item.deleted != null
+            ? await digestBytes(canonicalJsonBytes(["one-drive-deleted", deltaToken, id]))
+            : `${id}:${item.eTag ?? item.lastModifiedDateTime}`,
+        payload: {
+            changeType: change,
+            createdDateTime: item.createdDateTime ?? item.fileSystemInfo?.createdDateTime ?? null,
+            driveId: item.parentReference?.driveId ?? null,
+            eTag: item.eTag ?? null,
+            itemId: id,
+            itemType,
+            lastModifiedDateTime: item.lastModifiedDateTime ?? item.fileSystemInfo?.lastModifiedDateTime ?? null,
+            mimeType: item.file?.mimeType ?? null,
+            name: item.name ?? "",
+            parentFolderId: item.parentReference?.id ?? null,
+            size: item.size ?? null,
+            webUrl: item.webUrl ?? "",
+        },
+    };
+}
+async function get(context, endpoint, query) {
+    try {
+        return await context.connector.execute({ endpoint, method: "GET", query }, context.signal);
+    }
+    catch (cause) {
+        throw new TransientPollError(`OneDrive proxy request to ${endpoint} failed.`, { cause });
+    }
+}
+function deltaSuccess(result) {
+    if (result.status == 410)
+        throw new PermanentPollError("OneDrive delta token expired; recreate the Trigger.");
+    if (result.status == 404)
+        throw new PermanentPollError("OneDrive is not provisioned for this account.");
+    if (result.status == 400)
+        throw new PermanentPollError("OneDrive rejected the delta token; recreate the Trigger.");
+    success(result, "delta list");
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    if (result.status == 401 || result.status == 403)
+        throw new PollConnectionError(`OneDrive ${operation} rejected the Connection.`);
+    throw new TransientPollError(`OneDrive ${operation} failed with status ${result.status}.`);
+}
+function requireToken(link) {
+    const token = parseToken(link);
+    if (token == null)
+        throw new TransientPollError("OneDrive delta link has no token.");
+    return token;
+}
+function parseToken(link) {
+    const raw = /[?&]token=([^&#]+)/.exec(link)?.[1] ?? /\(token='([^']+)'\)/.exec(link)?.[1];
+    if (raw == null)
+        return null;
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+function createdAfter(value, boundary) {
+    if (value == null || value.length == 0)
+        return false;
+    const date = new Date(value);
+    return !Number.isNaN(date.getTime()) && date >= boundary;
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/src/providers/outlook/executors.d.ts

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 export declare const proxy: ProviderProxyExecutor;
 interface OutlookRequestInput {
     accessToken: string;
@@ -13,4 +15,5 @@ interface OutlookRequestInput {
 export declare const executors: ProviderExecutors;
 export declare const credentialValidators: CredentialValidators;
 export declare function outlookJsonRequest<T>(pathOrUrl: string, input: OutlookRequestInput): Promise<T>;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/outlook/executors.js

@@ -1,6 +1,7 @@
 import { compactObject, requiredRecord } from "../../core/cast.js";
 import { defineOAuthProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, } from "../provider-runtime.js";
 import { microsoftGraphJson, microsoftGraphRequest } from "./microsoft-graph.js";
+import { outlookMessageReceived } from "./trigger-on-message-received.js";
 const outlookGraphBaseUrl = "https://graph.microsoft.com/v1.0";
 export const proxy = defineProviderProxy({
     service: "outlook",
@@ -434,3 +435,4 @@ function requiredString(value, field) {
 function asObject(value) {
     return requiredRecord(value, "object input", (message) => new ProviderRequestError(400, message));
 }
+export const triggers = [outlookMessageReceived];

package/src/providers/outlook/trigger-on-message-received.d.ts

@@ -0,0 +1,2 @@
+import type { PollDefinition } from "../../triggers/common/poll.ts";
+export declare const outlookMessageReceived: PollDefinition;

package/src/providers/outlook/trigger-on-message-received.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "poll";
+};