@oomol-lab/open-connector 1.6.5 → 1.8.0

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, ProviderRequestError } from "../provider-runtime.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",
@@ -93,6 +94,13 @@ function graphRequestOptions(input) {
 function isAllowedOutlookMessageNextLinkPath(pathname) {
     const normalizedPath = trimTrailingSlash(pathname);
     const segments = normalizedPath.split("/").filter(Boolean);
+    // Delta continuation links (@odata.nextLink inside a delta round and
+    // @odata.deltaLink) end in a trailing `delta` segment on the two
+    // folder-scoped message-collection shapes. Graph tracks message changes per
+    // folder, so `/v1.0/me/messages/delta` is not admitted.
+    if (segments.length > 4 && segments[segments.length - 1] === "delta") {
+        segments.pop();
+    }
     if (segments[0] !== "v1.0") {
         return false;
     }
@@ -162,12 +170,24 @@ async function listMailFolders(input, { accessToken, fetcher }) {
     };
 }
 async function listMessages(input, { accessToken, fetcher }) {
-    const pathOrUrl = typeof input.nextLink === "string"
+    // A nextLink continues the current page sequence; a deltaLink starts the
+    // next delta round. Both are opaque Graph URLs checked by the allowlist.
+    const followUpLink = typeof input.nextLink === "string"
         ? input.nextLink
-        : typeof input.mailFolderId === "string"
-            ? `me/mailFolders/${encodeURIComponent(input.mailFolderId)}/messages`
-            : "me/messages";
-    const query = typeof input.nextLink === "string"
+        : typeof input.deltaLink === "string"
+            ? input.deltaLink
+            : undefined;
+    const folderPath = typeof input.mailFolderId === "string"
+        ? `me/mailFolders/${encodeURIComponent(input.mailFolderId)}/messages`
+        : undefined;
+    // Graph tracks message changes per folder: there is no mailbox-wide
+    // messages/delta, so a delta listing needs a folder.
+    if (followUpLink === undefined && input.delta === true && folderPath === undefined) {
+        throw providerInputError("mailFolderId is required when delta is true.");
+    }
+    const collectionPath = folderPath ?? "me/messages";
+    const pathOrUrl = followUpLink ?? (input.delta === true ? `${collectionPath}/delta` : collectionPath);
+    const query = followUpLink !== undefined
         ? undefined
         : compactObject({
             $top: typeof input.top === "number" ? String(input.top) : undefined,
@@ -186,9 +206,11 @@ async function listMessages(input, { accessToken, fetcher }) {
         query,
         headers,
     });
+    // Rows stay raw: a delta round reports removals as `{ id, "@removed": {...} }`.
     return {
         messages: Array.isArray(payload.value) ? payload.value : [],
         nextLink: typeof payload["@odata.nextLink"] === "string" ? payload["@odata.nextLink"] : null,
+        deltaLink: typeof payload["@odata.deltaLink"] === "string" ? payload["@odata.deltaLink"] : null,
     };
 }
 async function getMessage(input, { accessToken, fetcher }) {
@@ -413,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/microsoft-graph.js

@@ -1,5 +1,5 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, readProviderErrorTextBody, readProviderJsonBody, runProviderRequest, setSearchParams, } from "../provider-runtime.js";
+import { ProviderRequestError, readProviderErrorTextBody, readProviderJsonBody, runProviderRequest, setSearchParams, withRetryAfterSeconds, } from "../provider-runtime.js";
 const graphBaseUrl = "https://graph.microsoft.com/v1.0/";
 const graphOrigin = "https://graph.microsoft.com";
 /**
@@ -41,10 +41,13 @@ export async function microsoftGraphJson(pathOrUrl, options) {
     }));
 }
 function buildMicrosoftGraphUrl(pathOrUrl, query, allowNextLink) {
-    const normalizedPathOrUrl = pathOrUrl.toLowerCase();
-    const absolute = normalizedPathOrUrl.startsWith("https://") || normalizedPathOrUrl.startsWith("http://");
-    const requiresNextLinkValidation = absolute || pathOrUrl.startsWith("/");
-    const url = absolute ? new URL(pathOrUrl) : new URL(pathOrUrl, graphBaseUrl);
+    // Code passes plain relative paths such as `me/messages`; anything else is a
+    // caller-supplied link that must pass the allowlist. A value with any scheme
+    // is parsed on its own: resolved against the base, `https:me/drive` would
+    // turn into a same-origin path that never reaches the allowlist.
+    const absolute = /^[a-z][a-z\d+.-]*:/i.test(pathOrUrl);
+    const requiresNextLinkValidation = absolute || !/^[a-z\d]/i.test(pathOrUrl);
+    const url = parseMicrosoftGraphUrl(pathOrUrl, absolute ? undefined : graphBaseUrl);
     if (url.origin !== graphOrigin || url.protocol !== "https:") {
         throw new ProviderRequestError(400, "Microsoft Graph URL must target https://graph.microsoft.com");
     }
@@ -54,6 +57,14 @@ function buildMicrosoftGraphUrl(pathOrUrl, query, allowNextLink) {
     setSearchParams(url, query ?? {});
     return url;
 }
+function parseMicrosoftGraphUrl(pathOrUrl, base) {
+    try {
+        return new URL(pathOrUrl, base);
+    }
+    catch {
+        throw new ProviderRequestError(400, "Microsoft Graph URL must target https://graph.microsoft.com");
+    }
+}
 async function microsoftGraphResponseError(response, options) {
     const text = await readProviderErrorTextBody(response, `${options.label} error response`);
     let code = "";
@@ -69,5 +80,5 @@ async function microsoftGraphResponseError(response, options) {
             // Keep the upstream text when it is not JSON.
         }
     }
-    return new ProviderRequestError(response.status, options.refineErrorMessage?.(code, message) ?? message);
+    return new ProviderRequestError(response.status, options.refineErrorMessage?.(code, message) ?? message, withRetryAfterSeconds(response));
 }

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";
+};

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

@@ -0,0 +1,93 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const defaultFolder = "inbox";
+const defaultPageSize = 25;
+const eventSchema = s.object({
+    bodyPreview: s.string(),
+    categories: s.array(s.string()),
+    conversationId: s.string(),
+    from: s.string(),
+    fromName: s.string(),
+    hasAttachments: s.boolean(),
+    importance: s.string(),
+    internetMessageId: s.string(),
+    isDraft: s.boolean(),
+    isRead: s.boolean(),
+    messageId: s.string(),
+    parentFolderId: s.string(),
+    receivedDateTime: s.string(),
+    subject: s.string(),
+    to: s.array(s.string()),
+    webLink: s.string(),
+}, {
+    additionalProperties: false,
+    required: [
+        "messageId",
+        "internetMessageId",
+        "conversationId",
+        "subject",
+        "bodyPreview",
+        "from",
+        "fromName",
+        "to",
+        "receivedDateTime",
+        "hasAttachments",
+        "isRead",
+        "isDraft",
+        "importance",
+        "categories",
+        "parentFolderId",
+        "webLink",
+    ],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "folder",
+            jsonSchema: s.string({ pattern: "^[A-Za-z0-9_=-]*$" }),
+            nullable: false,
+            value: defaultFolder,
+            description: "A well-known mail folder name, folder ID, or an empty string for the whole mailbox.",
+        },
+        { handle: "includeDrafts", jsonSchema: s.boolean(), nullable: false, value: false },
+        {
+            handle: "maxMessagesPerPoll",
+            jsonSchema: s.integer({ maximum: 100, minimum: 1 }),
+            nullable: false,
+            value: defaultPageSize,
+        },
+        {
+            handle: "readStatus",
+            jsonSchema: s.stringEnum(["All", "Read", "Unread"]),
+            nullable: false,
+            value: "All",
+        },
+        {
+            handle: "senderAddress",
+            jsonSchema: s.string(),
+            nullable: false,
+            value: "",
+            description: "Exact sender address, or empty for any sender.",
+        },
+        {
+            handle: "subjectContains",
+            jsonSchema: s.string(),
+            nullable: false,
+            value: "",
+            description: "Case-insensitive subject text.",
+        },
+        {
+            handle: "withAttachmentsOnly",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Polls a Microsoft Outlook mail folder and triggers when a new message arrives.",
+    displayName: "New Message Received",
+    key: "outlook.on_message_received",
+    name: "on_message_received",
+    outputs: [{ handle: "events", jsonSchema: s.array(eventSchema), nullable: false }],
+    provider: "outlook",
+    type: "poll",
+};

package/src/providers/outlook/trigger-on-message-received.js

@@ -0,0 +1,226 @@
+import { eventsPollOutputs, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot } from "./trigger-on-message-received.definition.js";
+const markerPageSize = 100;
+const seedAnchor = "1970-01-01T00:00:00Z";
+const select = "id,internetMessageId,conversationId,subject,bodyPreview,from,toRecipients,receivedDateTime,hasAttachments,isRead,isDraft,importance,categories,parentFolderId,webLink";
+export const outlookMessageReceived = {
+    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 result = await get(context, endpoint(config.folder), {
+            $filter: filter(config, checkpoint.lastReceivedDateTime),
+            $orderby: "receivedDateTime asc",
+            $select: select,
+            $top: config.maxMessagesPerPoll,
+        });
+        success(result, "message list");
+        const rows = messages(result.data);
+        if (rows.length == 0)
+            return { checkpoint: checkpoint, events: [] };
+        const previousMs = Date.parse(checkpoint.lastReceivedDateTime);
+        let watermarkMs = previousMs;
+        let watermark = checkpoint.lastReceivedDateTime;
+        for (const row of rows) {
+            const ms = isoMs(row.receivedDateTime);
+            if (row.receivedDateTime != null && ms != null && ms > watermarkMs) {
+                watermarkMs = ms;
+                watermark = row.receivedDateTime;
+            }
+        }
+        const moved = watermarkMs > previousMs;
+        const processed = new Set(checkpoint.boundaryMessageIds);
+        const full = rows.length >= config.maxMessagesPerPoll;
+        if (full && !moved && rows.every((row) => typeof row.id == "string" && processed.has(row.id))) {
+            throw new PermanentPollError("Outlook cursor is stuck on a full timestamp boundary; increase maxMessagesPerPoll and resume the Trigger.");
+        }
+        const boundary = new Set(moved ? [] : checkpoint.boundaryMessageIds);
+        const events = [];
+        let filtered = 0;
+        for (const row of rows) {
+            if (row.id == null || row.id.length == 0)
+                continue;
+            if (isoMs(row.receivedDateTime) == watermarkMs)
+                boundary.add(row.id);
+            if (processed.has(row.id))
+                continue;
+            if (!matches(row, config)) {
+                filtered += 1;
+                continue;
+            }
+            events.push(event(row, row.id));
+        }
+        const hasMore = full && (moved || events.length > 0);
+        return {
+            checkpoint: { boundaryMessageIds: [...boundary], lastReceivedDateTime: watermark },
+            events,
+            filtered,
+            ...(hasMore ? { hasMore: true } : {}),
+        };
+    },
+};
+function resolveConfig(value) {
+    return {
+        folder: value.folder,
+        includeDrafts: value.includeDrafts,
+        maxMessagesPerPoll: value.maxMessagesPerPoll,
+        readStatus: value.readStatus,
+        senderAddress: value.senderAddress.trim(),
+        subjectContains: value.subjectContains.trim(),
+        withAttachmentsOnly: value.withAttachmentsOnly,
+    };
+}
+async function seed(context, config) {
+    const marker = await get(context, endpoint(config.folder), {
+        $orderby: "receivedDateTime desc",
+        $select: "id,receivedDateTime",
+        $top: markerPageSize,
+    });
+    success(marker, "seed marker fetch");
+    const shape = await get(context, endpoint(config.folder), {
+        $filter: filter(config, seedAnchor),
+        $orderby: "receivedDateTime desc",
+        $top: 1,
+    });
+    success(shape, "seed filter shape check");
+    const newest = newestMessage(messages(marker.data));
+    if (newest == null)
+        return { boundaryMessageIds: [], lastReceivedDateTime: context.now.toISOString() };
+    const boundary = messages(marker.data).filter((row) => isoMs(row.receivedDateTime) == newest.ms);
+    if (boundary.length >= config.maxMessagesPerPoll) {
+        return {
+            boundaryMessageIds: [],
+            lastReceivedDateTime: new Date(newest.ms + 1_000).toISOString(),
+        };
+    }
+    return {
+        boundaryMessageIds: boundary.flatMap((row) => (row.id == null || row.id.length == 0 ? [] : [row.id])),
+        lastReceivedDateTime: newest.iso,
+    };
+}
+function readCheckpoint(value) {
+    const checkpoint = record(value);
+    const watermark = checkpoint?.lastReceivedDateTime;
+    if (typeof watermark != "string" || isoMs(watermark) == null) {
+        throw new PermanentPollError("Outlook checkpoint is invalid; recreate the Trigger.");
+    }
+    const boundary = checkpoint?.boundaryMessageIds;
+    return {
+        boundaryMessageIds: Array.isArray(boundary)
+            ? boundary.filter((id) => typeof id == "string" && id.length > 0)
+            : [],
+        lastReceivedDateTime: watermark,
+    };
+}
+function endpoint(folder) {
+    return folder.length == 0 ? "/me/messages" : `/me/mailFolders/${encodeURIComponent(folder)}/messages`;
+}
+function filter(config, watermark) {
+    const clauses = [`receivedDateTime ge ${watermark}`];
+    if (config.readStatus == "Unread")
+        clauses.push("isRead eq false");
+    if (config.readStatus == "Read")
+        clauses.push("isRead eq true");
+    if (config.withAttachmentsOnly)
+        clauses.push("hasAttachments eq true");
+    if (config.senderAddress.length > 0)
+        clauses.push(`from/emailAddress/address eq '${config.senderAddress.replaceAll("'", "''")}'`);
+    return clauses.join(" and ");
+}
+function matches(message, config) {
+    if (message.isDraft === true && !config.includeDrafts)
+        return false;
+    return (config.subjectContains.length == 0 ||
+        (message.subject ?? "").toLowerCase().includes(config.subjectContains.toLowerCase()));
+}
+function event(message, id) {
+    return {
+        dedupeKey: id,
+        payload: {
+            bodyPreview: message.bodyPreview ?? "",
+            categories: message.categories ?? [],
+            conversationId: message.conversationId ?? "",
+            from: message.from?.emailAddress?.address ?? "",
+            fromName: message.from?.emailAddress?.name ?? "",
+            hasAttachments: message.hasAttachments ?? false,
+            importance: message.importance ?? "",
+            internetMessageId: message.internetMessageId ?? "",
+            isDraft: message.isDraft ?? false,
+            isRead: message.isRead ?? false,
+            messageId: id,
+            parentFolderId: message.parentFolderId ?? "",
+            receivedDateTime: message.receivedDateTime ?? "",
+            subject: message.subject ?? "",
+            to: (message.toRecipients ?? []).flatMap(({ emailAddress }) => emailAddress?.address == null ? [] : [emailAddress.address]),
+            webLink: message.webLink ?? "",
+        },
+    };
+}
+async function get(context, path, query) {
+    try {
+        return await context.connector.execute({ endpoint: path, headers: { Prefer: 'IdType="ImmutableId"' }, method: "GET", query }, context.signal);
+    }
+    catch (cause) {
+        throw new TransientPollError(`Outlook proxy request to ${path} failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    const codes = errorCodes(result.data);
+    if (result.status == 401)
+        throw new PollConnectionError(`Outlook ${operation} rejected the Connection.`);
+    if (result.status == 403 && codes.has("mailboxnotenabledforrestapi")) {
+        throw new PermanentPollError("The Outlook mailbox is not reachable through the Graph mail APIs.");
+    }
+    if (result.status == 403 && (codes.has("accessdenied") || codes.has("erroraccessdenied"))) {
+        throw new PollConnectionError(`Outlook ${operation} rejected the Connection.`);
+    }
+    if (result.status == 404 && (codes.has("erroritemnotfound") || codes.has("itemnotfound"))) {
+        throw new PermanentPollError("The configured Outlook folder does not exist.");
+    }
+    if (result.status == 400 && (codes.has("errorinvalididmalformed") || codes.has("inefficientfilter"))) {
+        throw new PermanentPollError("Outlook rejected the configured folder or filters.");
+    }
+    throw new TransientPollError(`Outlook ${operation} failed with status ${result.status}.`);
+}
+function errorCodes(data) {
+    const codes = new Set();
+    let value = record(data)?.error;
+    for (let depth = 0; depth < 4; depth += 1) {
+        const error = record(value);
+        if (error == null)
+            break;
+        if (typeof error.code == "string" && error.code.length > 0)
+            codes.add(error.code.toLowerCase());
+        value = error.innerError ?? error.innererror;
+    }
+    return codes;
+}
+function messages(data) {
+    const value = record(data)?.value;
+    return Array.isArray(value) ? value : [];
+}
+function newestMessage(rows) {
+    let newest = null;
+    for (const row of rows) {
+        const ms = isoMs(row.receivedDateTime);
+        if (row.receivedDateTime != null && ms != null && (newest == null || ms > newest.ms))
+            newest = { iso: row.receivedDateTime, ms };
+    }
+    return newest;
+}
+function isoMs(value) {
+    if (value == null || value.length == 0)
+        return null;
+    const milliseconds = Date.parse(value);
+    return Number.isNaN(milliseconds) ? null : milliseconds;
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}