@oomol-lab/open-connector 1.7.0 → 1.8.0

package/src/providers/shopify/trigger-on-shop-event.js

@@ -0,0 +1,165 @@
+import { IntegrationConnectionError, PermanentIntegrationError, TransientIntegrationError, } from "../../triggers/common/integration.js";
+import { sameSecret } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-shop-event.definition.js";
+export const shopifyShopEvent = {
+    initialState: { checkpoint: null, subscription: {} },
+    snapshot,
+    receive(context) {
+        if (!sameSecret(context.query("open_flow_callback"), context.callbackSecret)) {
+            return { body: "", contentType: "text/plain", outcome: "respond", status: 404 };
+        }
+        const topic = context.header("x-shopify-topic")?.trim();
+        if (!topic)
+            return { outcome: "ignored", reason: "Shopify topic header is missing." };
+        if (!configuredTopics(context.config).includes(topic))
+            return { outcome: "ignored", reason: "Shopify topic is not subscribed." };
+        const webhookId = context.header("x-shopify-webhook-id") ?? "";
+        return {
+            dedupeKey: webhookId.length == 0 ? undefined : webhookId,
+            outcome: "event",
+            outputs: {
+                apiVersion: context.header("x-shopify-api-version") ?? "",
+                body: context.payload,
+                eventId: context.header("x-shopify-event-id") ?? "",
+                shopDomain: context.header("x-shopify-shop-domain") ?? "",
+                topic,
+                triggeredAt: context.header("x-shopify-triggered-at") ?? "",
+                webhookId,
+            },
+        };
+    },
+    async reconcile(context) {
+        const state = requireState(context.state);
+        const subscriptions = await list(context);
+        if (subscriptions == null) {
+            if (!context.active)
+                return { outcome: "ready" };
+            throw new PermanentIntegrationError("The Shopify store or webhook resource is unavailable.");
+        }
+        if (!context.active) {
+            for (const id of subscriptions.values())
+                await remove(context, id);
+            await state.saveSubscription({}, later(context.now));
+            return { outcome: "ready" };
+        }
+        const wanted = configuredTopics(context.config);
+        const ids = [];
+        const created = [];
+        try {
+            for (const topic of wanted) {
+                const existing = subscriptions.get(topic);
+                if (existing != null)
+                    ids.push(existing);
+                else {
+                    const subscription = await create(context, topic);
+                    ids.push(subscription.id);
+                    if (subscription.created)
+                        created.push(subscription.id);
+                }
+            }
+        }
+        catch (cause) {
+            await Promise.allSettled(created.map((id) => remove(context, id)));
+            throw cause;
+        }
+        for (const [topic, id] of subscriptions)
+            if (!wanted.includes(topic))
+                await remove(context, id);
+        await state.saveSubscription({ webhookIds: ids }, later(context.now));
+        return { outcome: "ready" };
+    },
+};
+function configuredTopics(value) {
+    return [...new Set(value.topics)];
+}
+async function create(context, topic) {
+    const address = callbackUrl(context);
+    const result = await request(context, "subscription create", {
+        body: { webhook: { address, format: "json", topic } },
+        endpoint: "/webhooks.json",
+        method: "POST",
+    });
+    if (result.status == 422) {
+        const subscriptions = await list(context);
+        const winner = subscriptions?.get(topic);
+        if (winner != null)
+            return { created: false, id: winner };
+    }
+    success(result, "subscription create");
+    const id = normalizeId(record(record(result.data)?.webhook)?.id);
+    if (id == null)
+        throw new TransientIntegrationError("Shopify subscription response is missing its ID.");
+    return { created: true, id };
+}
+async function list(context) {
+    const address = callbackUrl(context);
+    const result = await request(context, "subscription list", {
+        endpoint: "/webhooks.json",
+        method: "GET",
+        query: { address, limit: 250 },
+    });
+    if (result.status == 404)
+        return null;
+    success(result, "subscription list");
+    const raw = record(result.data)?.webhooks;
+    const subscriptions = new Map();
+    if (!Array.isArray(raw))
+        return subscriptions;
+    for (const item of raw) {
+        const value = record(item);
+        const id = normalizeId(value?.id);
+        if (value?.address === address && typeof value.topic == "string" && id != null)
+            subscriptions.set(value.topic, id);
+    }
+    return subscriptions;
+}
+function callbackUrl(context) {
+    const url = new URL(context.endpointUrl);
+    url.searchParams.set("open_flow_callback", context.callbackSecret);
+    return url.href;
+}
+async function remove(context, id) {
+    const result = await request(context, "subscription delete", {
+        endpoint: `/webhooks/${encodeURIComponent(id)}.json`,
+        method: "DELETE",
+    });
+    if (result.status != 404)
+        success(result, "subscription delete");
+}
+async function request(context, operation, value) {
+    try {
+        return await context.connector.execute(value, context.signal);
+    }
+    catch (cause) {
+        if (cause instanceof IntegrationConnectionError)
+            throw cause;
+        throw new TransientIntegrationError(`Shopify ${operation} request failed.`, { cause });
+    }
+}
+function success(result, operation) {
+    if (result.status >= 200 && result.status < 300)
+        return;
+    if (result.status == 401 || result.status == 403)
+        throw new IntegrationConnectionError(`Shopify ${operation} rejected the Connection.`);
+    if ([402, 404, 422, 423, 501].includes(result.status))
+        throw new PermanentIntegrationError(`Shopify ${operation} rejected the subscription.`);
+    throw new TransientIntegrationError(`Shopify ${operation} failed with status ${result.status}.`);
+}
+function normalizeId(value) {
+    if (typeof value == "string")
+        return value.trim().length == 0 ? null : value;
+    return typeof value == "number" && Number.isFinite(value) ? String(value) : null;
+}
+function requireState(value) {
+    if (value == null)
+        throw new PermanentIntegrationError("Shopify Integration state is missing.");
+    return value;
+}
+function later(now) {
+    return new Date(now.getTime() + 30 * 24 * 60 * 60 * 1_000);
+}
+function record(value) {
+    return value != null && typeof value == "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/src/providers/slack/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 proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];

package/src/providers/slack/executors.js

@@ -1,5 +1,6 @@
 import { defineProviderProxy } from "../provider-runtime.js";
 import { defineSlackProviderExecutors, slackActionHandlers, slackApiBaseUrl, slackCredentialValidators, } from "./runtime.js";
+import { slackMessagePosted } from "./trigger-on-message-posted.js";
 const service = "slack";
 export const executors = defineSlackProviderExecutors(service, "user", slackActionHandlers);
 export const proxy = defineProviderProxy({
@@ -9,3 +10,4 @@ export const proxy = defineProviderProxy({
     skipDnsValidation: true,
 });
 export const credentialValidators = slackCredentialValidators;
+export const triggers = [slackMessagePosted];

package/src/providers/slack/trigger-on-message-posted.d.ts

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

package/src/providers/slack/trigger-on-message-posted.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/slack/trigger-on-message-posted.definition.js

@@ -0,0 +1,80 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const defaultPageSize = 15;
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "channelId",
+            jsonSchema: s.string({ pattern: "^[CDG][A-Z0-9]{2,31}$" }),
+            nullable: false,
+            description: "Slack conversation ID to watch, e.g. C0122KQ70S7E.",
+        },
+        {
+            handle: "fromUserIds",
+            jsonSchema: s.array(s.string({ pattern: "^[UW][A-Z0-9]{2,31}$" })),
+            nullable: false,
+            value: [],
+            description: "Only trigger on messages written by these Slack user IDs. Empty means any author.",
+        },
+        {
+            handle: "ignoreUserIds",
+            jsonSchema: s.array(s.string({ pattern: "^[UW][A-Z0-9]{2,31}$" })),
+            nullable: false,
+            value: [],
+            description: "Never trigger on messages written by these Slack user IDs.",
+        },
+        {
+            handle: "includeBotMessages",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+            description: "Also trigger on messages posted by bots and apps.",
+        },
+        {
+            handle: "includeSystemMessages",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+            description: "Also trigger on Slack system notices.",
+        },
+        {
+            handle: "maxMessagesPerPoll",
+            jsonSchema: s.integer({ maximum: 100, minimum: 1 }),
+            nullable: false,
+            value: defaultPageSize,
+            description: "Maximum number of messages processed per poll.",
+        },
+        {
+            handle: "textContains",
+            jsonSchema: s.string(),
+            nullable: false,
+            value: "",
+            description: "Only trigger when message text contains this string, case-insensitively.",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Polls one Slack conversation and triggers when a new message is posted to it.",
+    displayName: "New Channel Message",
+    key: "slack.on_message_posted",
+    name: "on_message_posted",
+    outputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.object({
+                botId: { type: ["string", "null"] },
+                channelId: s.string(),
+                files: s.array(s.object({ id: s.string(), mimetype: s.string(), name: s.string() }, { additionalProperties: false, required: ["id", "name", "mimetype"] })),
+                messageTs: s.string(),
+                subtype: { type: ["string", "null"] },
+                text: s.string(),
+                threadTs: { type: ["string", "null"] },
+                userId: { type: ["string", "null"] },
+            }, {
+                additionalProperties: false,
+                required: ["channelId", "messageTs", "threadTs", "userId", "botId", "subtype", "text", "files"],
+            })),
+            nullable: false,
+        },
+    ],
+    provider: "slack",
+    type: "poll",
+};

package/src/providers/slack/trigger-on-message-posted.js

@@ -0,0 +1,176 @@
+import { HttpRequestError } from "../../server/api/http-utils.js";
+import { eventsPollOutputs, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot } from "./trigger-on-message-posted.definition.js";
+const seedBackoffMs = 60_000;
+const plainSubtypes = new Set(["file_share", "thread_broadcast", "me_message", "bot_message"]);
+const credentialErrors = new Set([
+    "invalid_auth",
+    "not_authed",
+    "token_revoked",
+    "token_expired",
+    "account_inactive",
+    "two_factor_setup_required",
+]);
+const permanentErrors = new Set([
+    "channel_not_found",
+    "not_in_channel",
+    "not_allowed_token_type",
+    "access_denied",
+    "channel_is_limited_access",
+    "ekm_access_denied",
+    "enterprise_is_restricted",
+    "no_permission",
+    "team_access_not_granted",
+    "invalid_ts_oldest",
+    "invalid_ts_latest",
+    "method_deprecated",
+    "deprecated_endpoint",
+    "accesslimited",
+]);
+export const slackMessagePosted = {
+    buildOutputs: eventsPollOutputs,
+    snapshot,
+    async poll(context) {
+        const config = resolveConfig(context.config);
+        if (context.checkpoint === null) {
+            return { checkpoint: { lastTs: await seed(context, config.channelId) }, events: [] };
+        }
+        const checkpoint = readCheckpoint(context.checkpoint);
+        const history = await fetchHistory(context, config, checkpoint);
+        const messages = timedMessages(history);
+        const events = [];
+        let filtered = 0;
+        for (const entry of messages.toReversed()) {
+            if (!matches(entry.message, config)) {
+                filtered += 1;
+                continue;
+            }
+            events.push(event(entry, config.channelId));
+        }
+        return { checkpoint: nextCheckpoint(checkpoint, history, messages), events, filtered };
+    },
+};
+function resolveConfig(value) {
+    return {
+        channelId: value.channelId,
+        fromUserIds: value.fromUserIds,
+        ignoreUserIds: value.ignoreUserIds,
+        includeBotMessages: value.includeBotMessages,
+        includeSystemMessages: value.includeSystemMessages,
+        maxMessagesPerPoll: value.maxMessagesPerPoll,
+        textContains: value.textContains,
+    };
+}
+async function seed(context, channelId) {
+    const result = await slackGet(context, { channel: channelId, limit: 1 });
+    success(result, "baseline history fetch");
+    const ts = result.data.messages?.[0]?.ts;
+    return ts != null && validTs(ts) ? ts : `${Math.floor((context.now.getTime() - seedBackoffMs) / 1000)}.000000`;
+}
+function readCheckpoint(value) {
+    const checkpoint = value;
+    if (typeof checkpoint.lastTs != "string" || checkpoint.lastTs.length == 0) {
+        throw new PermanentPollError("Slack checkpoint lastTs is missing.");
+    }
+    const drainLatest = checkpoint.drainLatest;
+    const pendingHighTs = checkpoint.pendingHighTs;
+    if (drainLatest == null && pendingHighTs == null)
+        return { lastTs: checkpoint.lastTs };
+    if (typeof drainLatest != "string" ||
+        drainLatest.length == 0 ||
+        typeof pendingHighTs != "string" ||
+        pendingHighTs.length == 0) {
+        throw new PermanentPollError("Slack checkpoint drain fields are incomplete.");
+    }
+    return { drainLatest, lastTs: checkpoint.lastTs, pendingHighTs };
+}
+async function fetchHistory(context, config, checkpoint) {
+    const result = await slackGet(context, {
+        channel: config.channelId,
+        inclusive: "false",
+        latest: checkpoint.drainLatest,
+        limit: config.maxMessagesPerPoll,
+        oldest: checkpoint.lastTs,
+    });
+    success(result, "history list");
+    return result.data;
+}
+async function slackGet(context, query) {
+    try {
+        return await context.connector.execute({
+            endpoint: "/conversations.history",
+            method: "GET",
+            query: Object.fromEntries(Object.entries(query).filter((entry) => entry[1] != null)),
+        }, context.signal);
+    }
+    catch (cause) {
+        throw new TransientPollError("Slack proxy request failed.", { cause });
+    }
+}
+function success(result, operation) {
+    const body = result.data != null && typeof result.data === "object" && !Array.isArray(result.data)
+        ? result.data
+        : {};
+    if (result.status >= 200 && result.status < 300 && body.ok === true)
+        return;
+    const code = typeof body.error == "string" ? body.error : "";
+    if (code === "missing_scope")
+        throw new HttpRequestError("scope_missing", "Slack history permission is missing for the selected conversation", 403);
+    if (credentialErrors.has(code))
+        throw new PollConnectionError(`Slack ${operation} rejected with ${code}.`);
+    if (permanentErrors.has(code))
+        throw new PermanentPollError(`Slack ${operation} rejected with ${code}.`);
+    throw new TransientPollError(`Slack ${operation} failed with ${code || `status ${result.status}`}.`);
+}
+function timedMessages(history) {
+    return (history.messages ?? []).flatMap((message) => message.ts != null && validTs(message.ts) ? [{ message, ts: message.ts }] : []);
+}
+function nextCheckpoint(checkpoint, history, messages) {
+    const newestTs = messages[0]?.ts;
+    const oldestTs = messages.at(-1)?.ts;
+    if (history.has_more === true) {
+        if (newestTs == null || oldestTs == null)
+            throw new TransientPollError("Slack history reports has_more without a usable timestamp.");
+        return {
+            drainLatest: oldestTs,
+            lastTs: checkpoint.lastTs,
+            pendingHighTs: checkpoint.pendingHighTs ?? newestTs,
+        };
+    }
+    if (checkpoint.pendingHighTs != null)
+        return { lastTs: checkpoint.pendingHighTs };
+    return { lastTs: newestTs ?? checkpoint.lastTs };
+}
+function matches(message, config) {
+    if (!config.includeBotMessages && (message.bot_id != null || message.subtype == "bot_message"))
+        return false;
+    if (!config.includeSystemMessages && message.subtype != null && !plainSubtypes.has(message.subtype))
+        return false;
+    if (config.fromUserIds.length > 0 && (message.user == null || !config.fromUserIds.includes(message.user)))
+        return false;
+    if (message.user != null && config.ignoreUserIds.includes(message.user))
+        return false;
+    return (config.textContains.length == 0 || (message.text ?? "").toLowerCase().includes(config.textContains.toLowerCase()));
+}
+function event(entry, channelId) {
+    return {
+        dedupeKey: `${channelId}:${entry.ts}`,
+        payload: {
+            botId: entry.message.bot_id ?? null,
+            channelId,
+            files: (entry.message.files ?? []).map((file) => ({
+                id: file.id ?? "",
+                mimetype: file.mimetype ?? "",
+                name: file.name ?? "",
+            })),
+            messageTs: entry.ts,
+            subtype: entry.message.subtype ?? null,
+            text: entry.message.text ?? "",
+            threadTs: entry.message.thread_ts ?? null,
+            userId: entry.message.user ?? null,
+        },
+    };
+}
+function validTs(value) {
+    return /^\d+(?:\.\d+)?$/.test(value) && !Number.isNaN(new Date(Math.round(Number(value) * 1000)).getTime());
+}

package/src/providers/spotify/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean, optionalInteger, optionalString } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerInputError, providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
 export const spotifyApiBaseUrl = "https://api.spotify.com/v1/";
 export const spotifyActionHandlers = {
     get_current_user_profile(_input, deps) {
@@ -131,9 +131,7 @@ export const spotifyActionHandlers = {
             query: {
                 market: optionalString(input.market),
                 limit: stringifyOptionalInteger(input.limit),
-                seed_artists: joinStringArray(input.seedArtists),
-                seed_tracks: joinStringArray(input.seedTracks),
-                seed_genres: joinStringArray(input.seedGenres),
+                ...buildRecommendationSeedQuery(input),
             },
         });
     },
@@ -761,6 +759,19 @@ function buildPagingQuery(input, extraQuery) {
         ...(extraQuery ?? {}),
     };
 }
+// Spotify takes 1 to 5 seed values in any combination of seed_artists, seed_tracks, and seed_genres.
+function buildRecommendationSeedQuery(input) {
+    const query = {
+        seed_artists: joinStringArray(input.seedArtists),
+        seed_tracks: joinStringArray(input.seedTracks),
+        seed_genres: joinStringArray(input.seedGenres),
+    };
+    const seedCount = [input.seedArtists, input.seedTracks, input.seedGenres].reduce((count, seeds) => count + (Array.isArray(seeds) ? seeds.length : 0), 0);
+    if (seedCount < 1 || seedCount > 5) {
+        throw providerInputError(`get_recommendations needs 1 to 5 seeds across seedArtists, seedTracks, and seedGenres; received ${seedCount}`);
+    }
+    return query;
+}
 function buildPlaybackQuery(input) {
     return {
         market: optionalString(input.market),

package/src/providers/stripe/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 { ApiKeyProviderContext } from "../provider-runtime.ts";
 type StripeActionContext = ApiKeyProviderContext;
@@ -7,4 +9,5 @@ export declare const stripeActionHandlers: ProviderActionHandlers<"stripe", Stri
 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/stripe/executors.js

@@ -1,5 +1,6 @@
 import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
 import { ProviderRequestError, defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, requiredResponseRecord, } from "../provider-runtime.js";
+import { stripeEvent } from "./trigger-on-event.js";
 const service = "stripe";
 const stripeApiBaseUrl = "https://api.stripe.com";
 const stripeApiVersion = "2024-06-20";
@@ -289,3 +290,4 @@ function mapStripeError(status, message) {
     }
     return new ProviderRequestError(502, message, status);
 }
+export const triggers = [stripeEvent];

package/src/providers/stripe/trigger-on-event.d.ts

@@ -0,0 +1,2 @@
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+export declare const stripeEvent: IntegrationDefinition;

package/src/providers/stripe/trigger-on-event.definition.d.ts

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

package/src/providers/stripe/trigger-on-event.definition.js

@@ -0,0 +1,43 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "apiVersion",
+            jsonSchema: s.string({ maxLength: 40 }),
+            nullable: false,
+            value: "",
+        },
+        {
+            handle: "events",
+            jsonSchema: s.array(s.string({ maxLength: 120, pattern: "^(\\*|[a-z0-9_]+(?:\\.[a-z0-9_]+)+)$" }), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+            nullable: false,
+        },
+        {
+            handle: "includeConnectedAccounts",
+            jsonSchema: s.boolean(),
+            nullable: false,
+            value: false,
+        },
+    ],
+    definitionVersion: 2,
+    description: "Triggers when selected Stripe events happen on the connected account.",
+    displayName: "Account Event",
+    endpoint: {
+        body: { allowArray: false, allowEmpty: false, formats: ["json"] },
+        methods: ["POST"],
+        successStatus: 202,
+    },
+    key: "stripe.on_event",
+    name: "on_event",
+    outputs: [
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+        { handle: "event", jsonSchema: s.string(), nullable: false },
+        { handle: "eventId", jsonSchema: s.string(), nullable: false },
+        { handle: "livemode", jsonSchema: s.boolean(), nullable: false },
+    ],
+    provider: "stripe",
+    type: "integration",
+};