@oomol-lab/open-connector 1.7.0 → 1.8.0

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

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

@@ -1,4 +1,7 @@
 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 executors: ProviderExecutors;
 export declare const credentialValidators: CredentialValidators;
 export declare const proxy: ProviderProxyExecutor;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];

package/src/providers/googledrive/executors.js

@@ -7,6 +7,8 @@ import { createComment, createPermission, createReply, deleteComment, deletePerm
 import { googleJsonRequest, googleRequest } from "./runtime-request.js";
 import { asObject, asOptionalObject, asOptionalInteger, asStringArray, asStringRecord, compactObject, compactUnknownObject, optionalBoolean, optionalNestedString, optionalString, parseSizeBytes, pickOptionalBoolean, pickOptionalInteger, pickOptionalString, resolveFileId, resolveRequiredString, resolveSupportsAllDrives, } from "./runtime-shared.js";
 import { googledriveOAuthScopes } from "./scopes.js";
+import { googleDriveChanges, googleDriveChangeListener } from "./trigger-changes.js";
+import { googleDriveFileChange } from "./trigger-on-file-change.js";
 const service = "googledrive";
 const driveApiBaseUrl = "https://www.googleapis.com/drive/v3";
 const driveUploadApiBaseUrl = "https://www.googleapis.com/upload/drive/v3";
@@ -863,3 +865,8 @@ export const proxy = defineProviderProxy({
     auth: googleBearerProxyAuth(googledriveOAuthScopes),
     allowedEndpoint: providerProxyEndpointPrefixes("/drive/v3", "/upload/drive/v3"),
 });
+export const triggers = [
+    googleDriveChanges,
+    googleDriveChangeListener,
+    googleDriveFileChange,
+];

package/src/providers/googledrive/trigger-changes.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { ConnectorProxy } from "../../triggers/common/proxy.ts";
+import type { JsonValue } from "../../triggers/common/types.ts";
+interface ReadContext {
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connector: ConnectorProxy;
+    readonly signal?: AbortSignal;
+}
+export declare const googleDriveChanges: IntegrationDefinition;
+export declare function googleDriveStartPageToken(context: ReadContext): Promise<string>;
+export declare const googleDriveChangeListener: IntegrationDefinition;
+export {};

package/src/providers/googledrive/trigger-changes.definition.d.ts

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

package/src/providers/googledrive/trigger-changes.definition.js

@@ -0,0 +1,101 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const defaultPageSize = 100;
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "driveId",
+            jsonSchema: s.string({ maxLength: 256, minLength: 1 }),
+            nullable: true,
+            description: "Optional shared drive ID. Omit it to monitor the connected account.",
+        },
+        {
+            handle: "includeCorpusRemovals",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+            description: "Include the accessible file resource when an item leaves the change corpus.",
+        },
+        {
+            handle: "includeItemsFromAllDrives",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: true,
+            description: "Include items from My Drive and shared drives.",
+        },
+        {
+            handle: "includeRemoved",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: true,
+            description: "Include changes caused by deletion or loss of access.",
+        },
+        {
+            handle: "pageSize",
+            jsonSchema: s.integer({ maximum: 100, minimum: 1 }),
+            nullable: false,
+            value: defaultPageSize,
+            description: "Maximum changes included in one Flow Run.",
+        },
+        {
+            handle: "restrictToMyDrive",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+            description: "Restrict changes to the My Drive hierarchy.",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Uses a Google Drive changes.watch channel and triggers when Drive changes are available.",
+    displayName: "Changes Detected",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: true, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 204,
+    },
+    key: "googledrive.changes_detected",
+    name: "changes_detected",
+    outputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.object({
+                changeId: s.string(),
+                changeType: { type: ["string", "null"] },
+                driveId: { type: ["string", "null"] },
+                file: { type: ["object", "null"] },
+                fileId: { type: ["string", "null"] },
+                notification: s.object({
+                    changedTypes: s.array(s.string()),
+                    messageNumber: { type: ["string", "null"] },
+                    resourceState: s.string(),
+                    resourceUri: { type: ["string", "null"] },
+                }, {
+                    additionalProperties: false,
+                    required: ["resourceState", "changedTypes", "messageNumber", "resourceUri"],
+                }),
+                removed: s.boolean(),
+                time: { type: ["string", "null"] },
+            }, {
+                additionalProperties: false,
+                required: ["changeId", "changeType", "removed", "time", "fileId", "driveId", "file", "notification"],
+            })),
+            nullable: false,
+        },
+    ],
+    provider: "googledrive",
+    type: "integration",
+};
+export const additionalSnapshot0 = {
+    ...snapshot,
+    configInputs: snapshot.configInputs,
+    key: "googledrive.watch_changes",
+    name: "watch_changes",
+    displayName: "Watch Changes",
+    description: "Monitors Drive changes using notifications and periodic scans of the same change stream.",
+    outputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array({ type: "object" }),
+            nullable: false,
+        },
+    ],
+};