@oomol-lab/open-connector 1.6.5 → 1.8.0

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

@@ -0,0 +1,74 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const defaultPageSize = 25;
+const eventSchema = s.object({
+    historyId: { type: ["string", "null"] },
+    labelIds: s.array(s.string()),
+    messageId: s.string(),
+    messageTimestamp: s.string(),
+    sender: s.string(),
+    subject: s.string(),
+    threadId: s.string(),
+    to: s.string(),
+}, {
+    additionalProperties: false,
+    required: ["messageId", "threadId", "historyId", "labelIds", "subject", "sender", "to", "messageTimestamp"],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "includeDrafts",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+            description: "Also trigger on draft messages.",
+        },
+        {
+            handle: "includeSpamAndTrash",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+            description: "Also trigger on messages in SPAM and TRASH.",
+        },
+        {
+            handle: "labelNamesOrIds",
+            jsonSchema: s.array(s.string({ minLength: 1 })),
+            nullable: false,
+            description: "Only trigger on messages carrying all of these labels, referenced by name or ID.",
+            value: [],
+        },
+        {
+            handle: "maxMessagesPerPoll",
+            jsonSchema: s.integer({ maximum: 100, minimum: 1 }),
+            nullable: false,
+            value: defaultPageSize,
+        },
+        {
+            handle: "readStatus",
+            jsonSchema: s.stringEnum(["Read", "Unread", "All"]),
+            nullable: false,
+            value: "All",
+        },
+        {
+            handle: "search",
+            jsonSchema: s.string(),
+            nullable: false,
+            description: "Gmail search-syntax query the message must match.",
+            value: "",
+        },
+        {
+            handle: "sender",
+            jsonSchema: s.string(),
+            nullable: false,
+            description: "Only trigger on messages whose sender matches this address or name.",
+            value: "",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Polls the Gmail mailbox and triggers when a new message is received.",
+    displayName: "New Message Received",
+    key: "gmail.on_message_received",
+    name: "on_message_received",
+    outputs: [{ handle: "events", jsonSchema: s.array(eventSchema), nullable: false }],
+    provider: "gmail",
+    type: "poll",
+};

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/google_analytics/executors.js

@@ -1,6 +1,6 @@
 import { compactObject, objectArray, optionalBooleanOrNull, optionalIntegerOrNull, optionalObjectArray, optionalRecord as asOptionalObject, optionalScalarString, optionalString as optionalNonEmptyString, optionalStringOrNull, requiredRecord, } from "../../core/cast.js";
-import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator } from "../google-auth.js";
-import { googleJsonRequest } from "../google-runtime.js";
+import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator, } from "../googledrive/runtime-auth.js";
+import { googleJsonRequest } from "../googledrive/runtime-request.js";
 import { defineProviderProxy, ProviderRequestError } from "../provider-runtime.js";
 import { googleAnalyticsOAuthScopes } from "./scopes.js";
 const service = "google_analytics";

package/src/providers/google_analytics/scopes.js

@@ -1,5 +1,10 @@
+import { googleIdentityScopes } from "../googleads/scopes.js";
 export const googleAnalyticsReadonlyScope = "https://www.googleapis.com/auth/analytics.readonly";
 export const googleAnalyticsEditScope = "https://www.googleapis.com/auth/analytics.edit";
 export const googleAnalyticsReadScopes = [googleAnalyticsReadonlyScope];
 export const googleAnalyticsWriteScopes = [googleAnalyticsEditScope];
-export const googleAnalyticsOAuthScopes = [googleAnalyticsReadonlyScope, googleAnalyticsEditScope];
+export const googleAnalyticsOAuthScopes = [
+    googleAnalyticsReadonlyScope,
+    googleAnalyticsEditScope,
+    ...googleIdentityScopes,
+];

package/src/providers/google_bigquery/executors.js

@@ -1,6 +1,6 @@
 import { booleanString, compactObject, optionalBoolean, optionalInteger as asOptionalInteger, requiredRecord, } from "../../core/cast.js";
-import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator } from "../google-auth.js";
-import { googleJsonRequest, googleRequest } from "../google-runtime.js";
+import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator, } from "../googledrive/runtime-auth.js";
+import { googleJsonRequest, googleRequest } from "../googledrive/runtime-request.js";
 import { defineProviderProxy, ProviderRequestError } from "../provider-runtime.js";
 import { googleBigQueryOAuthScopes } from "./scopes.js";
 const bigQueryApiBaseUrl = "https://bigquery.googleapis.com/bigquery/v2";

package/src/providers/google_bigquery/scopes.js

@@ -1,3 +1,4 @@
+import { googleIdentityScopes } from "../googleads/scopes.js";
 export const bigQueryScope = "https://www.googleapis.com/auth/bigquery";
 export const bigQueryReadOnlyScope = "https://www.googleapis.com/auth/bigquery.readonly";
 export const bigQueryInsertDataScope = "https://www.googleapis.com/auth/bigquery.insertdata";
@@ -14,4 +15,5 @@ export const googleBigQueryOAuthScopes = [
     bigQueryInsertDataScope,
     devStorageReadOnlyScope,
     devStorageReadWriteScope,
+    ...googleIdentityScopes,
 ];

package/src/providers/google_search_console/executors.js

@@ -1,6 +1,6 @@
 import { compactObject, optionalNumber, optionalRecord as asOptionalObject, optionalString as asOptionalString, pickOptionalInteger, pickOptionalString as pickNonEmptyString, } from "../../core/cast.js";
-import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator } from "../google-auth.js";
-import { googleJsonRequest, googleRequest } from "../google-runtime.js";
+import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator, } from "../googledrive/runtime-auth.js";
+import { googleJsonRequest, googleRequest } from "../googledrive/runtime-request.js";
 import { defineProviderProxy, ProviderRequestError } from "../provider-runtime.js";
 import { googleSearchConsoleOAuthScopes } from "./scopes.js";
 const service = "google_search_console";

package/src/providers/google_search_console/scopes.js

@@ -1,3 +1,4 @@
+import { googleIdentityScopes } from "../googleads/scopes.js";
 export const googleSearchConsoleReadonlyScope = "https://www.googleapis.com/auth/webmasters.readonly";
 export const googleSearchConsoleFullScope = "https://www.googleapis.com/auth/webmasters";
 export const googleSearchConsoleReadScopes = [googleSearchConsoleReadonlyScope];
@@ -5,4 +6,5 @@ export const googleSearchConsoleWriteScopes = [googleSearchConsoleFullScope];
 export const googleSearchConsoleOAuthScopes = [
     googleSearchConsoleReadonlyScope,
     googleSearchConsoleFullScope,
+    ...googleIdentityScopes,
 ];

package/src/providers/googleads/executors.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { compactObject, objectArray, optionalBoolean, optionalRecord, optionalScalarString, optionalString, } from "../../core/cast.js";
-import { googleJsonRequest, googleRequest } from "../google-runtime.js";
+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";

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

@@ -1,5 +1,3 @@
 export declare const googleAdsScope = "https://www.googleapis.com/auth/adwords";
-export declare const googleOpenIdScope = "openid";
-export declare const googleEmailScope = "email";
-export declare const googleProfileScope = "profile";
+export declare const googleIdentityScopes: string[];
 export declare const googleAdsOAuthScopes: string[];

package/src/providers/googleads/scopes.js

@@ -1,5 +1,3 @@
 export const googleAdsScope = "https://www.googleapis.com/auth/adwords";
-export const googleOpenIdScope = "openid";
-export const googleEmailScope = "email";
-export const googleProfileScope = "profile";
-export const googleAdsOAuthScopes = [googleAdsScope, googleOpenIdScope, googleEmailScope, googleProfileScope];
+export const googleIdentityScopes = ["openid", "email", "profile"];
+export const googleAdsOAuthScopes = [googleAdsScope, ...googleIdentityScopes];

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

@@ -1,9 +1,10 @@
 import { compactObject, optionalString, pickOptionalBoolean, pickOptionalInteger, pickOptionalString, requiredRecord, } from "../../core/cast.js";
-import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator } from "../google-auth.js";
+import { defineGoogleProviderExecutors, googleBearerProxyAuth, googleServiceAccountValidator, } from "../googledrive/runtime-auth.js";
 import { combineProviderActionHandlers, defineProviderProxy, ProviderRequestError } from "../provider-runtime.js";
 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/runtime-shared.js

@@ -1,5 +1,5 @@
 import { optionalRecord, optionalString as asOptionalString, pickOptionalString } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, withRetryAfterSeconds } from "../provider-runtime.js";
 export const googlecalendarApiBaseUrl = "https://www.googleapis.com/calendar/v3";
 const service = "googlecalendar";
 const googleDefaultRequestTimeoutMs = 30_000;
@@ -142,7 +142,7 @@ async function assertGoogleResponse(response) {
         return;
     }
     const { message, details } = await extractGoogleError(response);
-    throw new ProviderRequestError(response.status, message, details);
+    throw new ProviderRequestError(response.status, message, withRetryAfterSeconds(response, details));
 }
 async function extractGoogleError(response) {
     const rawText = await response.text().catch(() => "");

package/src/providers/googlecalendar/scopes.js

@@ -1,3 +1,4 @@
+import { googleIdentityScopes } from "../googleads/scopes.js";
 export const googleCalendarReadonlyScope = "https://www.googleapis.com/auth/calendar.readonly";
 export const googleCalendarEventsScope = "https://www.googleapis.com/auth/calendar.events";
 export const googleCalendarCalendarsScope = "https://www.googleapis.com/auth/calendar.calendars";
@@ -22,4 +23,5 @@ export const googlecalendarOAuthScopes = [
     googleCalendarSettingsReadonlyScope,
     googleCalendarAclsScope,
     googleCalendarAclsReadonlyScope,
+    ...googleIdentityScopes,
 ];

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