@oomol-lab/open-connector 1.7.0 → 1.9.0

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

@@ -0,0 +1,232 @@
+import { eventsPollOutputs, maximumPollEventsPerPage, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot } from "./trigger-on-message-received.definition.js";
+export const gmailMessageReceived = {
+    buildOutputs: eventsPollOutputs,
+    snapshot,
+    async poll(context) {
+        const config = resolveConfig(context.config);
+        if (context.checkpoint === null)
+            return { checkpoint: { historyId: await profileHistoryId(context) }, events: [] };
+        const checkpoint = readCheckpoint(context.checkpoint);
+        const labels = await labelIds(context, config.labelNamesOrIds);
+        const budget = Math.min(config.maxMessagesPerPoll, maximumPollEventsPerPage);
+        const { candidates, lastPage } = await listMessages(context, checkpoint, labels, budget);
+        const offset = checkpoint.messageOffset ?? 0;
+        const end = Math.min(offset + budget, candidates.length);
+        // History pages count records, so consume all messages before advancing the page token.
+        const next = end < candidates.length
+            ? {
+                checkpoint: { historyId: checkpoint.historyId, pageToken: checkpoint.pageToken, messageOffset: end },
+                hasMore: true,
+            }
+            : nextCheckpoint(checkpoint.historyId, lastPage);
+        const events = [];
+        let filtered = 0;
+        for (const candidate of candidates.slice(offset, end)) {
+            const message = await messageMetadata(context, candidate.id);
+            if (message == null)
+                continue;
+            if (!(await matches(context, message, config, labels))) {
+                filtered += 1;
+                continue;
+            }
+            events.push(event(message));
+        }
+        return {
+            checkpoint: next.checkpoint,
+            events,
+            filtered,
+            ...(next.hasMore ? { hasMore: true } : {}),
+        };
+    },
+};
+function resolveConfig(value) {
+    return {
+        includeDrafts: value.includeDrafts,
+        includeSpamAndTrash: value.includeSpamAndTrash,
+        labelNamesOrIds: value.labelNamesOrIds,
+        maxMessagesPerPoll: value.maxMessagesPerPoll,
+        readStatus: value.readStatus,
+        search: value.search.trim(),
+        sender: value.sender.trim(),
+    };
+}
+async function profileHistoryId(context) {
+    const result = await get(context, "/users/me/profile");
+    success(result, "profile fetch");
+    const historyId = record(result.data)?.historyId;
+    if (typeof historyId != "string" || historyId.length == 0)
+        throw new TransientPollError("Gmail profile historyId is missing.");
+    return historyId;
+}
+function readCheckpoint(value) {
+    const checkpoint = record(value);
+    if (typeof checkpoint?.historyId != "string" || checkpoint.historyId.length == 0) {
+        throw new PermanentPollError("Gmail checkpoint historyId is missing; recreate the Trigger.");
+    }
+    if (checkpoint.messageOffset !== undefined &&
+        (!Number.isInteger(checkpoint.messageOffset) || checkpoint.messageOffset < 0)) {
+        throw new PermanentPollError("Gmail checkpoint messageOffset is invalid; recreate the Trigger.");
+    }
+    return {
+        historyId: checkpoint.historyId,
+        ...(typeof checkpoint.pageToken == "string" ? { pageToken: checkpoint.pageToken } : {}),
+        messageOffset: checkpoint.messageOffset,
+    };
+}
+async function labelIds(context, configured) {
+    if (configured.length == 0)
+        return [];
+    const result = await get(context, "/users/me/labels");
+    success(result, "labels list");
+    const labels = record(result.data)?.labels;
+    const byId = new Set();
+    const byName = new Map();
+    if (Array.isArray(labels)) {
+        for (const value of labels) {
+            const label = record(value);
+            if (typeof label?.id != "string" || label.id.length == 0)
+                continue;
+            byId.add(label.id);
+            if (typeof label.name == "string" && label.name.length > 0)
+                byName.set(label.name.toLowerCase(), label.id);
+        }
+    }
+    return [
+        ...new Set(configured.map((value) => {
+            const id = byId.has(value) ? value : byName.get(value.toLowerCase());
+            if (id == null)
+                throw new PermanentPollError(`Gmail label "${value}" does not exist.`);
+            return id;
+        })),
+    ];
+}
+async function listMessages(context, checkpoint, labels, maxMessages) {
+    const candidates = new Map();
+    const result = await get(context, "/users/me/history", {
+        historyTypes: "messageAdded",
+        labelId: labels[0],
+        maxResults: maxMessages,
+        pageToken: checkpoint.pageToken,
+        startHistoryId: checkpoint.historyId,
+    });
+    if (result.status == 404)
+        throw new PermanentPollError("Gmail history checkpoint expired; recreate the Trigger.");
+    success(result, "history list");
+    const lastPage = (record(result.data) ?? {});
+    for (const history of lastPage.history ?? []) {
+        for (const added of history.messagesAdded ?? []) {
+            const id = added.message?.id;
+            if (id != null && id.length > 0 && !candidates.has(id))
+                candidates.set(id, { id });
+        }
+    }
+    return { candidates: [...candidates.values()], lastPage };
+}
+function nextCheckpoint(historyId, page) {
+    if (page.nextPageToken)
+        return { checkpoint: { historyId, pageToken: page.nextPageToken }, hasMore: true };
+    if (!page.historyId)
+        throw new TransientPollError("Gmail history response historyId is missing.");
+    return { checkpoint: { historyId: page.historyId }, hasMore: false };
+}
+async function messageMetadata(context, id) {
+    const result = await get(context, `/users/me/messages/${encodeURIComponent(id)}`, {
+        format: "metadata",
+    });
+    if (result.status == 404)
+        return null;
+    success(result, "message metadata fetch");
+    return record(result.data) ?? null;
+}
+async function matches(context, message, config, requiredLabels) {
+    const labels = message.labelIds ?? [];
+    if (labels.includes("SENT") && !labels.includes("INBOX"))
+        return false;
+    if (!config.includeSpamAndTrash && (labels.includes("SPAM") || labels.includes("TRASH")))
+        return false;
+    if (!config.includeDrafts && labels.includes("DRAFT"))
+        return false;
+    if (config.readStatus == "Unread" && !labels.includes("UNREAD"))
+        return false;
+    if (config.readStatus == "Read" && labels.includes("UNREAD"))
+        return false;
+    if (!requiredLabels.every((label) => labels.includes(label)))
+        return false;
+    const query = searchQuery(config);
+    return query.length == 0 || (await matchesQuery(context, message, query, config.includeSpamAndTrash));
+}
+function searchQuery(config) {
+    const query = config.search.length == 0 ? [] : [config.search];
+    const sender = config.sender.replaceAll('"', "").trim();
+    if (sender.length > 0)
+        query.push(`from:${/\s/.test(sender) ? `"${sender}"` : sender}`);
+    return query.join(" ");
+}
+async function matchesQuery(context, message, query, includeSpamAndTrash) {
+    const messageId = header(message.payload?.headers ?? [], "Message-ID")
+        .replace(/^</, "")
+        .replace(/>$/, "");
+    if (messageId.length == 0)
+        return false;
+    const result = await get(context, "/users/me/messages", {
+        includeSpamTrash: includeSpamAndTrash ? "true" : undefined,
+        q: `${query} rfc822msgid:${messageId}`,
+    });
+    success(result, "query match");
+    const messages = record(result.data)?.messages;
+    return Array.isArray(messages) && messages.some((value) => record(value)?.id === message.id);
+}
+function event(message) {
+    const headers = message.payload?.headers ?? [];
+    return {
+        dedupeKey: message.id,
+        payload: {
+            historyId: message.historyId ?? null,
+            labelIds: message.labelIds ?? [],
+            messageId: message.id,
+            messageTimestamp: timestamp(message.internalDate, header(headers, "Date")),
+            sender: header(headers, "From"),
+            subject: header(headers, "Subject"),
+            threadId: message.threadId ?? "",
+            to: header(headers, "To"),
+        },
+    };
+}
+async function get(context, endpoint, query = {}) {
+    try {
+        return await context.connector.execute({
+            endpoint,
+            method: "GET",
+            query: Object.fromEntries(Object.entries(query).filter((entry) => entry[1] != null)),
+        }, context.signal);
+    }
+    catch (cause) {
+        throw new TransientPollError(`Gmail proxy request to ${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(`Gmail ${operation} rejected the Connection.`);
+    throw new TransientPollError(`Gmail ${operation} failed with status ${result.status}.`);
+}
+function header(headers, name) {
+    return headers.find((value) => value.name.toLowerCase() == name.toLowerCase())?.value ?? "";
+}
+function timestamp(internalDate, fallback) {
+    const epoch = internalDate == null ? Number.NaN : Number(internalDate);
+    if (Number.isFinite(epoch)) {
+        const date = new Date(epoch);
+        if (!Number.isNaN(date.getTime()))
+            return date.toISOString();
+    }
+    const parsed = Date.parse(fallback);
+    return Number.isNaN(parsed) ? "" : new Date(parsed).toISOString();
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

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

@@ -1,7 +1,7 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { ProviderFetch } from "../provider-runtime.ts";
-export declare const googleAdsApiBaseUrl = "https://googleads.googleapis.com/v22";
+export declare const googleAdsApiBaseUrl = "https://googleads.googleapis.com/v25";
 interface GoogleAdsRuntimeContext {
     accessToken: string;
     customerId?: string;

package/src/providers/googleads/executors.js

@@ -3,7 +3,7 @@ import { compactObject, objectArray, optionalBoolean, optionalRecord, optionalSc
 import { googleJsonRequest, googleRequest } from "../googledrive/runtime-request.js";
 import { defineProviderExecutors, defineProviderProxy, ProviderRequestError, requireOAuthCredential, requiredInputString, } from "../provider-runtime.js";
 import { googleAdsScope } from "./scopes.js";
-export const googleAdsApiBaseUrl = "https://googleads.googleapis.com/v22";
+export const googleAdsApiBaseUrl = "https://googleads.googleapis.com/v25";
 const service = "googleads";
 const customerMatchUserListType = "CUSTOMER_MATCH_USER_LIST";
 const googleUserInfoUrl = "https://openidconnect.googleapis.com/v1/userinfo";
@@ -116,8 +116,8 @@ async function getCampaignById(input, context) {
             "campaign.status,",
             "campaign.advertising_channel_type,",
             "campaign.advertising_channel_sub_type,",
-            "campaign.start_date,",
-            "campaign.end_date",
+            "campaign.start_date_time,",
+            "campaign.end_date_time",
             "FROM campaign",
             `WHERE campaign.id = ${campaignId}`,
             "LIMIT 1",
@@ -139,8 +139,8 @@ async function getCampaignByName(input, context) {
             "campaign.status,",
             "campaign.advertising_channel_type,",
             "campaign.advertising_channel_sub_type,",
-            "campaign.start_date,",
-            "campaign.end_date",
+            "campaign.start_date_time,",
+            "campaign.end_date_time",
             "FROM campaign",
             `WHERE campaign.name = ${JSON.stringify(requireNonEmptyString(input.name, "name"))}`,
             "ORDER BY campaign.id",
@@ -380,8 +380,8 @@ function normalizeCampaign(row) {
         status: optionalString(campaign.status),
         advertisingChannelType: optionalString(campaign.advertisingChannelType),
         advertisingChannelSubType: optionalString(campaign.advertisingChannelSubType),
-        startDate: optionalString(campaign.startDate),
-        endDate: optionalString(campaign.endDate),
+        startDateTime: optionalString(campaign.startDateTime),
+        endDateTime: optionalString(campaign.endDateTime),
     });
 }
 function normalizeCustomerList(row) {
@@ -469,8 +469,8 @@ function normalizeCampaignMutationData(value, mode) {
             : {}),
         name: mode === "create" ? requireNonEmptyString(value.name, "create.name") : optionalString(value.name),
         status: normalizeOptionalEnumValue(value.status, "status", campaignStatusAliases),
-        startDate: optionalString(value.startDate),
-        endDate: optionalString(value.endDate),
+        startDateTime: optionalString(value.startDateTime),
+        endDateTime: optionalString(value.endDateTime),
         manualCpc: optionalRecord(value.manualCpc),
         campaignBudget: mode === "create"
             ? requireNonEmptyString(value.campaignBudget, "create.campaignBudget")

package/src/providers/googlecalendar/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 GooglecalendarRuntimeDeps = OAuthProviderContext;
@@ -7,4 +9,5 @@ export declare const googlecalendarActionHandlers: ProviderActionHandlers<"googl
 export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/googlecalendar/executors.js

@@ -4,6 +4,7 @@ import { combineProviderActionHandlers, defineProviderProxy, ProviderRequestErro
 import { googlecalendarEventActionHandlers } from "./runtime-events.js";
 import { googlecalendarApiBaseUrl, googlecalendarJsonRequest, googlecalendarRequest, resolveCalendarId, resolveRuleId, resolveSettingId, } from "./runtime-shared.js";
 import { googlecalendarOAuthScopes } from "./scopes.js";
+import { googleCalendarEventChanged } from "./trigger-on-event-changed.js";
 function asObject(value) {
     return requiredRecord(value, "object input", (message) => new ProviderRequestError(400, message));
 }
@@ -566,3 +567,4 @@ function asRecord(value) {
     }
     return value;
 }
+export const triggers = [googleCalendarEventChanged];

package/src/providers/googlecalendar/scopes.d.ts

@@ -12,3 +12,14 @@ export declare const googlecalendarSettingsReadScopes: string[];
 export declare const googlecalendarAclReadScopes: string[];
 export declare const googlecalendarAclWriteScopes: string[];
 export declare const googlecalendarOAuthScopes: string[];
+/**
+ * Scopes a client config may request beyond {@link googlecalendarOAuthScopes}; none joins a consent
+ * unless named. `calendar.calendarlist.readonly` and `calendar.events.freebusy` are Google's
+ * non-sensitive scopes for `calendarList.list`/`calendarList.get` and `freeBusy.query`, so a host
+ * that writes events and lists calendars can leave the sensitive `calendar.readonly` out of its
+ * consent. The full `calendar` scope is available for deployments that need full calendar access
+ * and explicitly select it. Choose the minimum access needed for the application's features;
+ * fewer scope strings do not imply narrower access or less verification. The service-account mint
+ * list stays {@link googlecalendarOAuthScopes}: a domain-wide-delegation grant names those exact scopes.
+ */
+export declare const googlecalendarOptionalScopes: string[];

package/src/providers/googlecalendar/scopes.js

@@ -25,3 +25,21 @@ export const googlecalendarOAuthScopes = [
     googleCalendarAclsReadonlyScope,
     ...googleIdentityScopes,
 ];
+const googleCalendarScope = "https://www.googleapis.com/auth/calendar";
+const googleCalendarCalendarListReadonlyScope = "https://www.googleapis.com/auth/calendar.calendarlist.readonly";
+const googleCalendarEventsFreeBusyScope = "https://www.googleapis.com/auth/calendar.events.freebusy";
+/**
+ * Scopes a client config may request beyond {@link googlecalendarOAuthScopes}; none joins a consent
+ * unless named. `calendar.calendarlist.readonly` and `calendar.events.freebusy` are Google's
+ * non-sensitive scopes for `calendarList.list`/`calendarList.get` and `freeBusy.query`, so a host
+ * that writes events and lists calendars can leave the sensitive `calendar.readonly` out of its
+ * consent. The full `calendar` scope is available for deployments that need full calendar access
+ * and explicitly select it. Choose the minimum access needed for the application's features;
+ * fewer scope strings do not imply narrower access or less verification. The service-account mint
+ * list stays {@link googlecalendarOAuthScopes}: a domain-wide-delegation grant names those exact scopes.
+ */
+export const googlecalendarOptionalScopes = [
+    googleCalendarCalendarListReadonlyScope,
+    googleCalendarEventsFreeBusyScope,
+    googleCalendarScope,
+];

package/src/providers/googlecalendar/trigger-on-event-changed.d.ts

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

package/src/providers/googlecalendar/trigger-on-event-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/googlecalendar/trigger-on-event-changed.definition.js

@@ -0,0 +1,74 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const changes = ["created", "updated", "cancelled"];
+const eventSchema = s.object({
+    attendeeEmails: s.array(s.string()),
+    calendarId: s.string(),
+    changeType: s.stringEnum(changes),
+    created: { type: ["string", "null"] },
+    creatorEmail: { type: ["string", "null"] },
+    description: { type: ["string", "null"] },
+    end: { type: ["object", "null"] },
+    eventId: s.string(),
+    eventType: { type: ["string", "null"] },
+    htmlLink: { type: ["string", "null"] },
+    isAllDay: s.boolean(),
+    location: { type: ["string", "null"] },
+    organizerEmail: { type: ["string", "null"] },
+    recurringEventId: { type: ["string", "null"] },
+    start: { type: ["object", "null"] },
+    status: s.string(),
+    summary: { type: ["string", "null"] },
+    updated: { type: ["string", "null"] },
+}, {
+    additionalProperties: false,
+    required: [
+        "changeType",
+        "calendarId",
+        "eventId",
+        "status",
+        "summary",
+        "description",
+        "location",
+        "htmlLink",
+        "start",
+        "end",
+        "isAllDay",
+        "organizerEmail",
+        "creatorEmail",
+        "attendeeEmails",
+        "recurringEventId",
+        "eventType",
+        "created",
+        "updated",
+    ],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "calendarId",
+            jsonSchema: s.string({ maxLength: 1024, minLength: 1 }),
+            nullable: false,
+        },
+        {
+            handle: "changes",
+            jsonSchema: s.array(s.stringEnum(changes), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+            value: changes,
+        },
+        { handle: "matchTerm", jsonSchema: s.string(), nullable: false, value: "" },
+        {
+            handle: "maxEventsPerPoll",
+            jsonSchema: s.integer({ maximum: 500, minimum: 1 }),
+            nullable: false,
+            value: 100,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Polls a Google Calendar and triggers when an event is created, updated or cancelled.",
+    displayName: "Event Changed",
+    key: "googlecalendar.on_event_changed",
+    name: "on_event_changed",
+    outputs: [{ handle: "events", jsonSchema: s.array(eventSchema), nullable: false }],
+    provider: "googlecalendar",
+    type: "poll",
+};

package/src/providers/googlecalendar/trigger-on-event-changed.js

@@ -0,0 +1,233 @@
+import { eventsPollOutputs, maximumPollEventsPerPage, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot } from "./trigger-on-event-changed.definition.js";
+const quotaReasons = new Set(["rateLimitExceeded", "userRateLimitExceeded", "quotaExceeded", "usageLimits"]);
+export const googleCalendarEventChanged = {
+    buildOutputs: eventsPollOutputs,
+    snapshot,
+    async poll(context) {
+        const config = resolveConfig(context.config);
+        if (context.checkpoint === null)
+            return seed(context, config, context.now.toISOString());
+        const checkpoint = readCheckpoint(context.checkpoint);
+        if (checkpoint.calendarId !== config.calendarId)
+            return seed(context, config, context.now.toISOString());
+        if ("seedTimeMin" in checkpoint)
+            return seed(context, config, checkpoint.seedTimeMin, checkpoint.pageToken);
+        return incremental(context, config, checkpoint);
+    },
+};
+function resolveConfig(value) {
+    return {
+        calendarId: value.calendarId,
+        changes: new Set(value.changes),
+        matchTerm: value.matchTerm.trim(),
+        maxEventsPerPoll: value.maxEventsPerPoll,
+    };
+}
+function readCheckpoint(value) {
+    const checkpoint = record(value);
+    const pageToken = typeof checkpoint?.pageToken == "string" ? checkpoint.pageToken : undefined;
+    const calendarId = typeof checkpoint?.calendarId == "string" ? checkpoint.calendarId : undefined;
+    if (typeof checkpoint?.syncToken == "string" && checkpoint.syncToken.length > 0) {
+        return {
+            calendarId,
+            ...(pageToken == null ? {} : { pageToken }),
+            syncToken: checkpoint.syncToken,
+        };
+    }
+    if (typeof checkpoint?.seedTimeMin == "string" && checkpoint.seedTimeMin.length > 0) {
+        return {
+            calendarId,
+            ...(pageToken == null ? {} : { pageToken }),
+            seedTimeMin: checkpoint.seedTimeMin,
+        };
+    }
+    throw new PermanentPollError("Google Calendar checkpoint is invalid; recreate the Trigger.");
+}
+async function seed(context, config, timeMin, startPageToken) {
+    let pageToken = startPageToken;
+    for (let page = 0; page < 2; page += 1) {
+        const result = await list(context, config.calendarId, {
+            maxResults: 2_500,
+            pageToken,
+            showDeleted: "true",
+            singleEvents: "false",
+            timeMin,
+        });
+        if (pageToken != null && stalePage(result))
+            return { checkpoint: { calendarId: config.calendarId, seedTimeMin: timeMin }, events: [] };
+        success(context, result, "seed full sync");
+        const parsed = (record(result.data) ?? {});
+        if (parsed.nextSyncToken)
+            return {
+                checkpoint: { calendarId: config.calendarId, syncToken: parsed.nextSyncToken },
+                events: [],
+            };
+        if (!parsed.nextPageToken)
+            throw new TransientPollError("Google Calendar seed response has no continuation token.");
+        pageToken = parsed.nextPageToken;
+    }
+    return {
+        checkpoint: {
+            calendarId: config.calendarId,
+            ...(pageToken == null ? {} : { pageToken }),
+            seedTimeMin: timeMin,
+        },
+        events: [],
+        hasMore: true,
+    };
+}
+async function incremental(context, config, checkpoint) {
+    const events = [];
+    let filtered = 0;
+    const result = await list(context, config.calendarId, {
+        maxResults: Math.min(config.maxEventsPerPoll, maximumPollEventsPerPage),
+        pageToken: checkpoint.pageToken,
+        showDeleted: "true",
+        singleEvents: "false",
+        syncToken: checkpoint.syncToken,
+    });
+    if (checkpoint.pageToken != null && stalePage(result)) {
+        return {
+            checkpoint: { calendarId: config.calendarId, syncToken: checkpoint.syncToken },
+            events,
+            filtered,
+        };
+    }
+    success(context, result, "incremental sync");
+    const parsed = (record(result.data) ?? {});
+    for (const item of parsed.items ?? []) {
+        if (item.id == null || item.id.length == 0)
+            continue;
+        const change = classify(item);
+        if (!config.changes.has(change) || !matches(item, config.matchTerm)) {
+            filtered += 1;
+            continue;
+        }
+        events.push(event(item, item.id, change, config.calendarId));
+    }
+    if (parsed.nextSyncToken) {
+        return {
+            checkpoint: { calendarId: config.calendarId, syncToken: parsed.nextSyncToken },
+            events,
+            filtered,
+        };
+    }
+    if (!parsed.nextPageToken)
+        throw new TransientPollError("Google Calendar sync response has no continuation token.");
+    return {
+        checkpoint: {
+            calendarId: config.calendarId,
+            pageToken: parsed.nextPageToken,
+            syncToken: checkpoint.syncToken,
+        },
+        events,
+        filtered,
+        hasMore: true,
+    };
+}
+function classify(value) {
+    if (value.status == "cancelled")
+        return "cancelled";
+    const created = epochSecond(value.created);
+    const updated = epochSecond(value.updated);
+    return created != null && created == updated ? "created" : "updated";
+}
+function matches(value, term) {
+    if (term.length == 0)
+        return true;
+    const needle = term.toLowerCase();
+    return [value.summary, value.description, value.location, ...(value.attendees ?? []).map(({ email }) => email)].some((candidate) => typeof candidate == "string" && candidate.toLowerCase().includes(needle));
+}
+function event(item, eventId, change, calendarId) {
+    return {
+        dedupeKey: `${eventId}:${item.updated ?? item.etag ?? ""}`,
+        payload: {
+            attendeeEmails: (item.attendees ?? []).flatMap(({ email }) => email == null || email.length == 0 ? [] : [email]),
+            calendarId,
+            changeType: change,
+            created: iso(item.created),
+            creatorEmail: item.creator?.email ?? null,
+            description: item.description ?? null,
+            end: item.end ?? null,
+            eventId,
+            eventType: item.eventType ?? null,
+            htmlLink: item.htmlLink ?? null,
+            isAllDay: item.start?.date != null,
+            location: item.location ?? null,
+            organizerEmail: item.organizer?.email ?? null,
+            recurringEventId: item.recurringEventId ?? null,
+            start: item.start ?? null,
+            status: item.status ?? "",
+            summary: item.summary ?? null,
+            updated: iso(item.updated),
+        },
+    };
+}
+async function list(context, calendarId, query) {
+    const endpoint = `/calendars/${encodeURIComponent(calendarId)}/events`;
+    try {
+        return await context.connector.execute({
+            endpoint,
+            method: "GET",
+            query: Object.fromEntries(Object.entries(query).filter((entry) => entry[1] != null)),
+        }, context.signal);
+    }
+    catch (cause) {
+        throw new TransientPollError(`Google Calendar proxy request to ${endpoint} failed.`, { cause });
+    }
+}
+function success(context, result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    if (result.status == 410 || (result.status == 400 && fullSyncRequired(result.data))) {
+        throw new PermanentPollError("Google Calendar sync token expired; recreate the Trigger.");
+    }
+    if (result.status == 400 || (result.status == 404 && context.checkpoint === null)) {
+        throw new PermanentPollError(`Google Calendar ${operation} rejected the configuration.`);
+    }
+    if (result.status == 401)
+        throw new PollConnectionError(`Google Calendar ${operation} rejected the Connection.`);
+    if (result.status == 403) {
+        if (reasons(result.data).some((reason) => quotaReasons.has(reason))) {
+            throw new TransientPollError(`Google Calendar ${operation} was rate limited.`);
+        }
+        throw new PollConnectionError(`Google Calendar ${operation} rejected the Connection.`);
+    }
+    throw new TransientPollError(`Google Calendar ${operation} failed with status ${result.status}.`);
+}
+function stalePage(result) {
+    return result.status == 400 && !fullSyncRequired(result.data);
+}
+function reasons(data) {
+    const errors = record(record(data)?.error)?.errors;
+    if (!Array.isArray(errors))
+        return [];
+    return errors.flatMap((value) => {
+        const reason = record(value)?.reason;
+        return typeof reason == "string" ? [reason] : [];
+    });
+}
+function fullSyncRequired(data) {
+    if (reasons(data).includes("fullSyncRequired"))
+        return true;
+    const message = record(record(data)?.error)?.message;
+    return typeof message == "string" && message.includes("fullSyncRequired");
+}
+function iso(value) {
+    if (value == null || value.length == 0)
+        return null;
+    const milliseconds = Date.parse(value);
+    return Number.isNaN(milliseconds) ? null : new Date(milliseconds).toISOString();
+}
+function epochSecond(value) {
+    if (value == null || value.length == 0)
+        return null;
+    const milliseconds = Date.parse(value);
+    return Number.isNaN(milliseconds) ? null : Math.floor(milliseconds / 1_000);
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}