@oomol-lab/open-connector 1.9.1 → 1.9.3

package/src/providers/pinboard/executors.js

@@ -1,8 +1,7 @@
 import { compactObject, optionalRawString, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, requiredInputString, } from "../provider-runtime.js";
+import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, isAbortLikeError, providerUserAgent, ProviderRequestError, requiredInputString, providerInputError, defaultProviderRequestTimeoutMs, } from "../provider-runtime.js";
 const service = "pinboard";
 const pinboardApiBaseUrl = "https://api.pinboard.in/v1";
-const requestTimeoutMs = 30_000;
 const pinboardActionHandlers = {
     async get_last_update(_input, context) {
         const payload = await requestPinboardJson({ path: "/posts/update" }, context, "execute");
@@ -101,7 +100,7 @@ async function requestPinboardJson(input, context, phase) {
             url.searchParams.set(key, value);
         }
     }
-    const timeout = createProviderTimeout(context.signal, requestTimeoutMs);
+    const timeout = createProviderTimeout(context.signal);
     try {
         const response = await context.fetcher(url, {
             method: "GET",
@@ -122,7 +121,7 @@ async function requestPinboardJson(input, context, phase) {
             throw error;
         }
         if (timeout.didTimeout() || isAbortLikeError(error)) {
-            throw new ProviderRequestError(504, `Pinboard request timed out after ${requestTimeoutMs / 1000} seconds`);
+            throw new ProviderRequestError(504, `Pinboard request timed out after ${defaultProviderRequestTimeoutMs / 1000} seconds`);
         }
         throw new ProviderRequestError(502, error instanceof Error ? `Pinboard request failed: ${error.message}` : "Pinboard request failed", error);
     }
@@ -148,7 +147,7 @@ function createPinboardError(status, statusText, payload, phase) {
         return new ProviderRequestError(phase === "validate" ? 400 : status, message);
     }
     if (status === 400 || status === 404) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(status || 502, message);
 }
@@ -212,7 +211,7 @@ function readResultOutput(payload) {
         throw new ProviderRequestError(502, "Pinboard result response is missing result code");
     }
     if (resultCode !== "done") {
-        throw new ProviderRequestError(400, resultCode);
+        throw providerInputError(resultCode);
     }
     return { resultCode };
 }

package/src/providers/pinpoint/runtime.js

@@ -1,5 +1,5 @@
 import { optionalInteger, optionalRecord, optionalString } from "../../core/cast.js";
-import { createProviderTimeout, ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { createProviderTimeout, ProviderRequestError, providerUserAgent, providerInputError, } from "../provider-runtime.js";
 export async function validatePinpointCredential(input, fetcher) {
     const apiKey = requireString(input.apiKey, "apiKey");
     const apiBaseUrl = normalizePinpointApiBaseUrl(input.subdomain);
@@ -152,7 +152,7 @@ function createPinpointError(status, payload, phase) {
     if (status === 429)
         return new ProviderRequestError(429, message);
     if (400 <= status && status < 500)
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     return new ProviderRequestError(status || 502, message);
 }
 function extractPinpointError(payload) {

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

package/src/providers/pipedrive/trigger-on-crm-event.js

@@ -0,0 +1,101 @@
+import { PermanentIntegrationError, TransientIntegrationError } from "../../triggers/common/integration.js";
+import { isJsonObject } from "../../triggers/common/json.js";
+import { reconcileManagedWebhook, webhookRequest } from "../../triggers/managed-webhook.js";
+import { sameSecret } from "../../triggers/signature.js";
+import { basicAuthorizationHeader } from "../provider-runtime.js";
+import { snapshot } from "./trigger-on-crm-event.definition.js";
+export const pipedriveCrmEvent = {
+    snapshot,
+    initialState: { checkpoint: null, subscription: {} },
+    async reconcile(context) {
+        const current = await webhookRequest(context, { endpoint: "/v1/users/me", method: "GET" });
+        if (!isJsonObject(current.data) ||
+            current.data.success !== true ||
+            !isJsonObject(current.data.data) ||
+            !["string", "number"].includes(typeof current.data.data.company_id))
+            throw new TransientIntegrationError("Pipedrive returned no account identity.");
+        const companyId = String(current.data.data.company_id);
+        const event = String(context.config.eventType);
+        const entity = event == "person.created" ? "person" : "deal";
+        const action = event.endsWith(".created") ? "create" : "change";
+        const result = await reconcileManagedWebhook(context, {
+            async find() {
+                const response = await webhookRequest(context, { endpoint: "/v1/webhooks", method: "GET" });
+                if (!isJsonObject(response.data) || response.data.success !== true || !Array.isArray(response.data.data))
+                    throw new TransientIntegrationError("Pipedrive returned an invalid webhook list.");
+                const found = [];
+                for (const item of response.data.data) {
+                    if (!isJsonObject(item) || typeof item.subscription_url != "string")
+                        throw new TransientIntegrationError("Pipedrive returned an invalid webhook.");
+                    if (item.subscription_url != context.endpointUrl)
+                        continue;
+                    if (!["number", "string"].includes(typeof item.id) ||
+                        item.event_object != entity ||
+                        item.event_action != action ||
+                        item.version != "2.0")
+                        throw new PermanentIntegrationError("Pipedrive webhook event settings differ from this subscription.");
+                    found.push({ id: String(item.id), secret: context.callbackSecret });
+                }
+                return found;
+            },
+            async create() {
+                const response = await webhookRequest(context, {
+                    endpoint: "/v1/webhooks",
+                    method: "POST",
+                    body: {
+                        subscription_url: context.endpointUrl,
+                        event_action: action,
+                        event_object: entity,
+                        version: "2.0",
+                        http_auth_user: "oomol",
+                        http_auth_password: context.callbackSecret,
+                    },
+                });
+                if (!isJsonObject(response.data) ||
+                    response.data.success !== true ||
+                    !isJsonObject(response.data.data) ||
+                    !["number", "string"].includes(typeof response.data.data.id))
+                    throw new TransientIntegrationError("Pipedrive webhook creation returned no identity.");
+                return { id: String(response.data.data.id), secret: context.callbackSecret };
+            },
+            async remove(id) {
+                await webhookRequest(context, { endpoint: `/v1/webhooks/${encodeURIComponent(id)}`, method: "DELETE" });
+            },
+        });
+        if (context.active)
+            await context.state.saveSubscription({ ...context.state.subscription, companyId }, new Date(context.now.getTime() + 86_400_000));
+        return result;
+    },
+    receive(context) {
+        const expected = basicAuthorizationHeader(`oomol:${context.callbackSecret}`);
+        if (!sameSecret(context.header("authorization"), expected))
+            return { outcome: "respond", status: 401, body: "", contentType: "text/plain" };
+        const companyId = context.state?.subscription.companyId;
+        if (typeof companyId != "string")
+            return { outcome: "respond", status: 503, body: "", contentType: "text/plain" };
+        const body = context.payload;
+        if (!isJsonObject(body) || !isJsonObject(body.meta) || !isJsonObject(body.data))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        const meta = body.meta;
+        if (meta.version != "2.0" ||
+            String(meta.company_id) != companyId ||
+            String(meta.webhook_id) != context.state?.subscription.hookId)
+            return { outcome: "ignored", reason: "Pipedrive subscription or company does not match." };
+        const event = String(context.config.eventType);
+        if (meta.entity != (event == "person.created" ? "person" : "deal") ||
+            meta.action != (event.endsWith(".created") ? "create" : "change"))
+            return { outcome: "ignored", reason: "Pipedrive event does not match." };
+        if (!event.endsWith(".created")) {
+            const field = event == "deal.stage_changed" ? "stage_id" : "status";
+            if (!isJsonObject(body.previous) || !(field in body.previous) || body.previous[field] === body.data[field])
+                return { outcome: "ignored", reason: "The selected deal field did not change." };
+        }
+        if (typeof meta.id != "string" || !meta.id || !["number", "string"].includes(typeof meta.entity_id))
+            return { outcome: "respond", status: 400, body: "", contentType: "text/plain" };
+        return {
+            outcome: "event",
+            dedupeKey: meta.id,
+            outputs: { event, deliveryId: meta.id, objectId: String(meta.entity_id), body },
+        };
+    },
+};

package/src/providers/placid/runtime.js

@@ -1,6 +1,6 @@
 import { optionalInteger, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
 import { compactObject } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError } from "../provider-runtime.js";
 export const placidApiBaseUrl = "https://api.placid.app";
 const templatesPath = "/api/rest/templates";
 const imagesPath = "/api/rest/images";
@@ -147,13 +147,13 @@ function createPlacidError(status, payload, phase) {
         optionalString(record?.detail) ??
         `placid request failed with status ${status}`;
     if (status === 401 && phase === "validate") {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (status === 401 && phase === "execute") {
         return new ProviderRequestError(401, message);
     }
     if (status === 400 || status === 404 || status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(status === 429 ? 429 : status >= 500 ? 502 : status, message);
 }

package/src/providers/plain/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord, optionalString, requiredRecord, requiredString } from "../../core/cast.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const plainApiUrl = "https://core-api.uk.plain.com/graphql/v1";
 const customerSelection = `
   id
@@ -246,9 +246,9 @@ function createPlainGraphqlError(errors, phase) {
         code === "BAD_USER_INPUT" ||
         code === "GRAPHQL_VALIDATION_FAILED" ||
         code === "GRAPHQL_PARSE_FAILED") {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }
 function mapPlainMutationError(error) {
     const message = readString(error.message, "plain mutation error message");
@@ -258,9 +258,9 @@ function mapPlainMutationError(error) {
         return new ProviderRequestError(401, message);
     }
     if (type === "INTERNAL" || code === "internal") {
-        return new ProviderRequestError(502, message);
+        return providerResponseError(message);
     }
-    return new ProviderRequestError(400, message);
+    return providerInputError(message);
 }
 function buildUpsertCustomerInput(input) {
     const identifier = requiredRecord(input.identifier, "identifier");

package/src/providers/planetscale/runtime.js

@@ -1,5 +1,5 @@
 import { optionalRecord, optionalString, compactObject } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError } from "../provider-runtime.js";
 export const planetScaleApiBaseUrl = "https://api.planetscale.com/v1/";
 function requireApiKey(input) {
     const value = optionalString(input.apiKey);
@@ -193,7 +193,7 @@ function createPlanetScaleError(status, payload) {
         return new ProviderRequestError(status, message);
     }
     if (status == 400 || status == 404 || status == 409 || status == 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(status >= 500 ? status : 502, message);
 }

package/src/providers/planhat/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, objectArray, optionalRawString, optionalRecord, optionalString, requiredString, } from "../../core/cast.js";
-import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, readProviderTextBody, } from "../provider-runtime.js";
+import { createProviderTimeout, defineApiKeyProviderExecutors, defineProviderProxy, providerUserAgent, ProviderRequestError, readProviderTextBody, providerInputError, providerResponseError, } from "../provider-runtime.js";
 const service = "planhat";
 const apiBaseUrl = "https://api.planhat.com";
 const maxResponseBytes = 10 * 1024 * 1024;
@@ -241,17 +241,17 @@ function pickQuery(input, keys) {
 function readObject(value, message) {
     const record = optionalRecord(value);
     if (!record) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return record;
 }
 function readArray(value, message) {
-    return objectArray(value, message, () => new ProviderRequestError(502, message));
+    return objectArray(value, message, () => providerResponseError(message));
 }
 function requiredProviderString(value, message) {
     const text = optionalRawString(value);
     if (!text?.trim()) {
-        throw new ProviderRequestError(502, message);
+        throw providerResponseError(message);
     }
     return text;
 }
@@ -276,13 +276,13 @@ function createPlanhatError(status, statusText, payload, phase) {
         return new ProviderRequestError(429, message);
     }
     if (phase === "validate" && (status === 401 || status === 403)) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     if (phase === "execute" && (status === 401 || status === 403)) {
         return new ProviderRequestError(401, message);
     }
     if (status === 400 || status === 404 || status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(status >= 500 || status < 400 ? 502 : status, message);
 }

package/src/providers/plausible_analytics/runtime.js

@@ -1,6 +1,6 @@
 import { compactObject, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
 import { assertPublicHttpUrl } from "../../core/request.js";
-import { providerUserAgent, ProviderRequestError } from "../provider-runtime.js";
+import { providerUserAgent, ProviderRequestError, providerInputError } from "../provider-runtime.js";
 export const plausibleDefaultBaseUrl = "https://plausible.io";
 const statsPath = "/api/v2/query";
 const eventsPath = "/api/event";
@@ -127,7 +127,7 @@ function createPlausibleError(status, payload, phase, notFoundAsInvalidInput = f
         return new ProviderRequestError(429, message);
     }
     if ((status === 404 && notFoundAsInvalidInput) || status === 400 || status === 422) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
     return new ProviderRequestError(status >= 500 ? 502 : status, message);
 }
@@ -159,7 +159,7 @@ export function normalizePlausibleBaseUrl(value) {
     }
     const url = assertPublicHttpUrl(value, {
         fieldName: "baseUrl",
-        createError: (message) => new ProviderRequestError(400, message),
+        createError: providerInputError,
     });
     if (url.protocol !== "https:") {
         throw new ProviderRequestError(400, "Base URL must use https");

package/src/providers/ploid/actions.d.ts

@@ -0,0 +1,16 @@
+import type { ActionDefinition, JsonSchema } from "../../core/types.ts";
+export interface PloidEndpoint {
+    name: string;
+    method: string;
+    path: string;
+    pathKeys: string[];
+    queryKeys: string[];
+    operationType: ActionDefinition["operationType"];
+    description: string;
+    inputSchema: JsonSchema;
+    outputSchema: JsonSchema;
+}
+declare const ploidEndpoints: PloidEndpoint[];
+export declare const ploidEndpointByName: Map<string, (typeof ploidEndpoints)[number]>;
+export declare const ploidActions: ActionDefinition[];
+export {};

package/src/providers/ploid/actions.js

@@ -0,0 +1,23 @@
+import { defineProviderAction } from "../../core/provider-definition.js";
+import definitions from "./endpoints.json" with { type: "json" };
+const actionLifecycles = {
+    start_dataset: { startActionId: "ploid.start_dataset", statusActionId: "ploid.get_dataset" },
+};
+const actionFollowUps = {
+    sync_people_search: ["ploid.get_set"],
+    get_person: ["ploid.get_person_run"],
+    create_dataset: ["ploid.get_dataset"],
+    start_dataset: ["ploid.get_dataset"],
+};
+const ploidEndpoints = definitions;
+export const ploidEndpointByName = new Map(ploidEndpoints.map((endpoint) => [endpoint.name, endpoint]));
+export const ploidActions = ploidEndpoints.map((endpoint) => defineProviderAction("ploid", {
+    name: endpoint.name,
+    description: endpoint.description,
+    operationType: endpoint.operationType,
+    requiredScopes: [],
+    inputSchema: endpoint.inputSchema,
+    outputSchema: endpoint.outputSchema,
+    asyncLifecycle: actionLifecycles[endpoint.name],
+    followUpActions: actionFollowUps[endpoint.name],
+}));