@oomol-lab/open-connector 1.9.0 → 1.9.2

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

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const credentialValidators: CredentialValidators;
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/orbit/executors.js

@@ -0,0 +1,106 @@
+import { optionalRecord, optionalString, looseArray } from "../../core/cast.js";
+import { downloadUploadSource, requiredResponseRecord, isAbortLikeError, runProviderRequest, ProviderRequestError, providerInputError, providerResponseError, defineApiKeyProviderExecutors, defineProviderProxy, } from "../provider-runtime.js";
+import { orbitActions } from "./actions.js";
+import { orbitRoutes } from "./routes.js";
+const baseUrl = "https://api.orbitsearch.com";
+async function request(apiKey, name, input, fetcher, parentSignal) {
+    const route = orbitRoutes[name];
+    let path = route.path;
+    const data = { ...input };
+    for (const field of route.pathFields) {
+        path = path.replace(`{${field}}`, encodeURIComponent(String(data[field])));
+        delete data[field];
+    }
+    const url = new URL(path, baseUrl);
+    for (const field of route.queryFields) {
+        if (data[field] !== undefined)
+            url.searchParams.set(field, String(data[field]));
+        delete data[field];
+    }
+    const idempotencyKey = optionalString(data.idempotencyKey);
+    delete data.idempotencyKey;
+    let body = route.body ? JSON.stringify(data) : undefined;
+    if (name === "detect_faces") {
+        const file = await downloadUploadSource({
+            url: String(data.imageUrl),
+            fieldName: "imageUrl",
+            fetcher,
+            maximumBytes: 25 * 1024 * 1024,
+            signal: parentSignal,
+        });
+        const mime = file.contentType?.split(";")[0]?.trim().toLowerCase();
+        if (!mime || !["image/jpeg", "image/png", "image/webp"].includes(mime))
+            throw providerInputError("imageUrl must return a JPG, PNG or WebP image");
+        const form = new FormData();
+        form.append("image", new Blob([new Uint8Array(file.bytes)], { type: mime }), `image.${mime === "image/jpeg" ? "jpg" : mime.split("/")[1]}`);
+        body = form;
+    }
+    return runProviderRequest({ label: "Orbit", signal: parentSignal }, async (signal) => {
+        const headers = new Headers({ authorization: `Bearer ${apiKey}`, accept: "application/json" });
+        if (body !== undefined && !(body instanceof FormData))
+            headers.set("content-type", "application/json");
+        if (idempotencyKey !== undefined)
+            headers.set("Idempotency-Key", idempotencyKey);
+        const response = await fetcher(url, { method: route.method, headers, body, signal });
+        const payload = await response.json().catch((error) => {
+            if (isAbortLikeError(error))
+                throw error;
+            return undefined;
+        });
+        if (!response.ok) {
+            const error = optionalRecord(optionalRecord(payload)?.error);
+            const code = optionalString(error?.code);
+            const message = optionalString(error?.message);
+            const detail = [code, message].filter(Boolean).join(": ");
+            throw new ProviderRequestError(response.status, `Orbit request failed (${response.status})${detail ? `: ${detail}` : ""}`, undefined, code === "invalid_api_key"
+                ? "authorization_failed"
+                : code === "missing_api_key_scope"
+                    ? "authorization_failed"
+                    : "provider_error");
+        }
+        return requiredResponseRecord(payload, "Orbit response");
+    });
+}
+async function execute(actionName, values, context) {
+    const { apiKey, fetcher } = context;
+    const data = values;
+    if (actionName === "get_batch_enrichment") {
+        const results = [];
+        for (const requestId of data.request_ids) {
+            results.push(await request(apiKey, "get_enrichment", { request_id: requestId }, fetcher, context.signal));
+        }
+        const status = results.some((result) => result.status !== "completed" && result.status !== "failed")
+            ? "running"
+            : results.some((result) => result.status === "failed")
+                ? "completed_with_errors"
+                : "completed";
+        return { status, results };
+    }
+    const result = await request(apiKey, actionName, data, fetcher, context.signal);
+    if (actionName === "batch_enrich") {
+        const children = looseArray(result.results);
+        const requestIds = children.map((child) => optionalString(optionalRecord(child)?.request_id));
+        if (!children.length || requestIds.some((id) => !id))
+            throw providerResponseError("Orbit batch response is missing child request IDs");
+        return { ...result, request_ids: requestIds };
+    }
+    return result;
+}
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request(input.apiKey, "quote_population", {
+            population: { kind: "company", id: "1441", name: "Google" },
+            profile_depth: "partial",
+        }, fetcher, signal);
+        return { profile: { displayName: "Orbit API Key" }, grantedScopes: [], metadata: { apiBaseUrl: baseUrl } };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("orbit", Object.fromEntries(orbitActions.map((action) => [action.name, (values, context) => execute(action.name, values, context)])));
+export const proxy = defineProviderProxy({
+    service: "orbit",
+    baseUrl: baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});

package/src/providers/orbit/routes.d.ts

@@ -0,0 +1,9 @@
+interface OrbitRoute {
+    path: string;
+    method: string;
+    pathFields: string[];
+    queryFields: string[];
+    body: boolean;
+}
+export declare const orbitRoutes: Record<string, OrbitRoute>;
+export {};

package/src/providers/orbit/routes.js

@@ -0,0 +1,170 @@
+export const orbitRoutes = {
+    search: {
+        path: "/v3/search",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    get_search: {
+        path: "/v3/search/{search_id}",
+        method: "GET",
+        pathFields: ["search_id"],
+        queryFields: [],
+        body: false,
+    },
+    quote_population: {
+        path: "/v3/search/populations/quote",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    search_population: {
+        path: "/v3/search/populations",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    batch_enrich: {
+        path: "/v3/enrich",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    read_profile: {
+        path: "/v3/enrich/{profile_id}",
+        method: "GET",
+        pathFields: ["profile_id"],
+        queryFields: ["format"],
+        body: false,
+    },
+    enrich_profile: {
+        path: "/v3/enrich/{profile_id}",
+        method: "POST",
+        pathFields: ["profile_id"],
+        queryFields: [],
+        body: true,
+    },
+    get_enrichment: {
+        path: "/v3/enrich/requests/{request_id}",
+        method: "GET",
+        pathFields: ["request_id"],
+        queryFields: [],
+        body: false,
+    },
+    create_watcher: {
+        path: "/v3/watchers",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    list_watchers: {
+        path: "/v3/watchers",
+        method: "GET",
+        pathFields: [],
+        queryFields: [],
+        body: false,
+    },
+    get_watcher: {
+        path: "/v3/watchers/{watcher_id}",
+        method: "GET",
+        pathFields: ["watcher_id"],
+        queryFields: [],
+        body: false,
+    },
+    update_watcher: {
+        path: "/v3/watchers/{watcher_id}",
+        method: "PATCH",
+        pathFields: ["watcher_id"],
+        queryFields: [],
+        body: true,
+    },
+    delete_watcher: {
+        path: "/v3/watchers/{watcher_id}",
+        method: "DELETE",
+        pathFields: ["watcher_id"],
+        queryFields: [],
+        body: false,
+    },
+    list_watcher_runs: {
+        path: "/v3/watchers/{watcher_id}/runs",
+        method: "GET",
+        pathFields: ["watcher_id"],
+        queryFields: ["limit"],
+        body: false,
+    },
+    create_webhook: {
+        path: "/v3/webhooks",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    list_webhooks: {
+        path: "/v3/webhooks",
+        method: "GET",
+        pathFields: [],
+        queryFields: [],
+        body: false,
+    },
+    delete_webhook: {
+        path: "/v3/webhooks/{webhook_id}",
+        method: "DELETE",
+        pathFields: ["webhook_id"],
+        queryFields: [],
+        body: false,
+    },
+    test_webhook: {
+        path: "/v3/webhooks/{webhook_id}/test",
+        method: "POST",
+        pathFields: ["webhook_id"],
+        queryFields: [],
+        body: true,
+    },
+    detect_faces: {
+        path: "/v3/faces/detect",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    search_face_index: {
+        path: "/v3/faces/index-search",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    bulk_search: {
+        path: "/v3/search/bulk",
+        method: "POST",
+        pathFields: [],
+        queryFields: [],
+        body: true,
+    },
+    get_bulk_search: {
+        path: "/v3/search/bulk/{job_id}",
+        method: "GET",
+        pathFields: ["job_id"],
+        queryFields: [],
+        body: false,
+    },
+    get_bulk_results: {
+        path: "/v3/search/bulk/{job_id}/results",
+        method: "GET",
+        pathFields: ["job_id"],
+        queryFields: ["offset"],
+        body: false,
+    },
+    cancel_bulk_search: {
+        path: "/v3/search/bulk/{job_id}/cancel",
+        method: "POST",
+        pathFields: ["job_id"],
+        queryFields: [],
+        body: false,
+    },
+};

package/src/providers/outlook/executors.js

@@ -1,5 +1,5 @@
-import { compactObject, optionalString, requiredRecord } from "../../core/cast.js";
-import { defineOAuthProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, } from "../provider-runtime.js";
+import { compactObject, optionalString, requiredBoolean, requiredRecord } from "../../core/cast.js";
+import { defineOAuthProviderExecutors, defineProviderProxy, providerInputError, requiredInputString, ProviderRequestError, } from "../provider-runtime.js";
 import { microsoftGraphJson, microsoftGraphRequest } from "./microsoft-graph.js";
 import { outlookMessageReceived } from "./trigger-on-message-received.js";
 const outlookGraphBaseUrl = "https://graph.microsoft.com/v1.0";
@@ -22,6 +22,30 @@ const outlookActionHandlers = {
     get_message(input, deps) {
         return getMessage(input, deps);
     },
+    move_message(input, deps) {
+        return moveMessage(input, requiredInputString(input.destinationId, "destinationId"), deps);
+    },
+    archive_message(input, deps) {
+        return moveMessage(input, "archive", deps);
+    },
+    async delete_message(input, { accessToken, fetcher, signal }) {
+        await outlookRequest(`me/messages/${encodeURIComponent(requiredInputString(input.messageId, "messageId"))}`, {
+            accessToken,
+            fetcher,
+            signal,
+            method: "DELETE",
+        });
+        return { success: true };
+    },
+    set_message_read(input, { accessToken, fetcher, signal }) {
+        return outlookJsonRequest(`me/messages/${encodeURIComponent(requiredInputString(input.messageId, "messageId"))}`, {
+            accessToken,
+            fetcher,
+            signal,
+            method: "PATCH",
+            body: { isRead: requiredBoolean(input.isRead, "isRead", providerInputError) },
+        });
+    },
     create_draft(input, deps) {
         return createDraft(input, deps);
     },
@@ -229,6 +253,15 @@ async function getMessage(input, { accessToken, fetcher }) {
         headers,
     });
 }
+async function moveMessage(input, destinationId, { accessToken, fetcher, signal }) {
+    return outlookJsonRequest(`me/messages/${encodeURIComponent(requiredInputString(input.messageId, "messageId"))}/move`, {
+        accessToken,
+        fetcher,
+        signal,
+        method: "POST",
+        body: { destinationId },
+    });
+}
 async function createDraft(input, { accessToken, fetcher }) {
     return outlookJsonRequest("me/messages", {
         accessToken,

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

@@ -1,5 +1,7 @@
 import type { CredentialValidators, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 import { executors } from "./runtime.ts";
 export { executors };
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/pandadoc/executors.js

@@ -1,5 +1,6 @@
 import { defineProviderProxy } from "../provider-runtime.js";
 import { executors, pandadocApiBaseUrl, validatePandadocCredential } from "./runtime.js";
+import { pandadocDocumentEvent } from "./trigger-on-document-event.js";
 export { executors };
 const service = "pandadoc";
 export const proxy = defineProviderProxy({
@@ -15,3 +16,4 @@ export const credentialValidators = {
         return validatePandadocCredential({ apiKey: input.apiKey, ...input.values }, fetcher);
     },
 };
+export const triggers = [pandadocDocumentEvent];

package/src/providers/pandadoc/trigger-on-document-event.d.ts

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

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

@@ -0,0 +1,33 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const snapshot = {
+    key: "pandadoc.on_document_event",
+    provider: "pandadoc",
+    name: "on_document_event",
+    displayName: "Document Status Changed",
+    description: "Receives document status changes in the connected workspace, optionally only when the entire document is completed.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: { methods: ["POST"], body: { formats: ["json"], allowArray: true, allowEmpty: false }, successStatus: 200 },
+    configInputs: [
+        {
+            handle: "completedOnly",
+            jsonSchema: { type: "boolean", title: "Completed documents only" },
+            nullable: false,
+            value: true,
+        },
+    ],
+    outputs: [
+        {
+            handle: "events",
+            nullable: false,
+            jsonSchema: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: { event: s.string(), data: { type: "object" } },
+                    required: ["event", "data"],
+                },
+            },
+        },
+    ],
+};

package/src/providers/pandadoc/trigger-on-document-event.js

@@ -0,0 +1,96 @@
+import { TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { bytes, verifyHexHmac } from "../../triggers/signature.js";
+import { snapshot } from "./trigger-on-document-event.definition.js";
+function webhook(value) {
+    if (!isJsonObject(value) ||
+        typeof value.uuid != "string" ||
+        !value.uuid ||
+        typeof value.shared_key != "string" ||
+        !value.shared_key)
+        throw new TransientIntegrationError("PandaDoc returned an invalid webhook identity or shared key.");
+    return { id: value.uuid, secret: value.shared_key };
+}
+export const pandadocDocumentEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const endpoint = "/public/v1/webhook-subscriptions";
+        return reconcileManagedWebhook(context, {
+            async find() {
+                const found = [];
+                const result = await webhookRequest(context, { endpoint, method: "GET" });
+                if (!isJsonObject(result.data) || !Array.isArray(result.data.items))
+                    throw new TransientIntegrationError("PandaDoc returned an invalid webhook list.");
+                for (const item of result.data.items) {
+                    if (!isJsonObject(item) || typeof item.url != "string")
+                        throw new TransientIntegrationError("PandaDoc returned an invalid webhook.");
+                    if (item.url == context.endpointUrl)
+                        found.push(webhook(item));
+                }
+                return found;
+            },
+            async create() {
+                const result = await webhookRequest(context, {
+                    endpoint,
+                    method: "POST",
+                    body: {
+                        name: "OOMOL document status",
+                        url: context.endpointUrl,
+                        active: true,
+                        triggers: ["document_state_changed"],
+                        payload: ["metadata"],
+                    },
+                });
+                return webhook(result.data);
+            },
+            async align(id) {
+                await webhookRequest(context, {
+                    endpoint: `${endpoint}/${encodeURIComponent(id)}`,
+                    method: "PATCH",
+                    body: { url: context.endpointUrl, active: true, triggers: ["document_state_changed"], payload: ["metadata"] },
+                });
+            },
+            async remove(id) {
+                await webhookRequest(context, { endpoint: `${endpoint}/${encodeURIComponent(id)}`, method: "DELETE" });
+            },
+        });
+    },
+    async receive(context) {
+        const secret = context.state?.subscription.secret;
+        if (typeof secret != "string")
+            return { outcome: "respond", status: 503, body: "", contentType: "text/plain" };
+        if (!(await verifyHexHmac(secret, [context.rawBody], context.query("signature"))))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        if (!Array.isArray(context.payload))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        const events = [];
+        const identities = [];
+        for (const item of context.payload) {
+            if (!isJsonObject(item) || item.event != "document_state_changed")
+                continue;
+            const data = item.data;
+            if (!isJsonObject(data) ||
+                typeof data.id != "string" ||
+                !data.id ||
+                typeof data.status != "string" ||
+                typeof data.date_modified != "string" ||
+                !data.date_modified)
+                return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+            if (context.config.completedOnly === true && data.status != "document.completed")
+                continue;
+            events.push(item);
+            identities.push(JSON.stringify([data.id, data.status, data.date_modified]));
+        }
+        if (!events.length)
+            return { outcome: "ignored", reason: "No matching document status changes." };
+        // Derive deduplication identity from the signed body, not an unsigned delivery header.
+        const digest = await crypto.subtle.digest("SHA-256", bytes(JSON.stringify(identities.sort())));
+        return {
+            outcome: "event",
+            dedupeKey: Array.from(new Uint8Array(digest), (value) => value.toString(16).padStart(2, "0")).join(""),
+            outputs: { events },
+        };
+    },
+};

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

@@ -1,5 +1,7 @@
 import type { CredentialValidators, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
 import { executors } from "./runtime.ts";
 export { executors };
 export declare const credentialValidators: CredentialValidators;
 export declare const proxy: ProviderProxyExecutor;
+export declare const triggers: readonly IntegrationDefinition[];

package/src/providers/pipedrive/executors.js

@@ -1,5 +1,6 @@
 import { defineProviderProxy } from "../provider-runtime.js";
 import { executors, validatePipedriveCredential } from "./runtime.js";
+import { pipedriveCrmEvent } from "./trigger-on-crm-event.js";
 export { executors };
 const service = "pipedrive";
 const apiOrigin = "https://api.pipedrive.com";
@@ -13,3 +14,4 @@ export const proxy = defineProviderProxy({
     baseUrl: apiOrigin,
     auth: { type: "api_key_header", name: "x-api-token" },
 });
+export const triggers = [pipedriveCrmEvent];

package/src/providers/pipedrive/trigger-on-crm-event.d.ts

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

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

@@ -0,0 +1,30 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const events = ["deal.created", "deal.stage_changed", "deal.status_changed", "person.created"];
+export const snapshot = {
+    key: "pipedrive.on_crm_event",
+    provider: "pipedrive",
+    name: "on_crm_event",
+    displayName: "Deal or Contact Event",
+    description: "Receives new deals or contacts, or actual changes to a deal stage or status using Pipedrive Webhooks v2.",
+    definitionVersion: 2,
+    type: "integration",
+    endpoint: {
+        methods: ["POST"],
+        body: { formats: ["json"], allowArray: false, allowEmpty: false },
+        successStatus: 200,
+    },
+    configInputs: [
+        {
+            handle: "eventType",
+            jsonSchema: { type: "string", enum: events, title: "Event" },
+            nullable: false,
+            value: "deal.created",
+        },
+    ],
+    outputs: [
+        { handle: "event", jsonSchema: { type: "string", enum: events }, nullable: false },
+        { handle: "deliveryId", jsonSchema: s.string(), nullable: false },
+        { handle: "objectId", jsonSchema: s.string(), nullable: false },
+        { handle: "body", jsonSchema: { type: "object" }, nullable: false },
+    ],
+};