@oomol-lab/open-connector 1.9.0 → 1.9.2

package/src/providers/salesforce/chatter-routes.js

@@ -0,0 +1,140 @@
+export const chatterFeedRoutes = {
+    favorites: {
+        path: "/chatter/feeds/favorites/{userId}/{favoriteId}/feed-elements",
+        communityRequired: false,
+        parameters: ["elementsPerBundle", "page", "pageSize", "recentCommentCount", "sort"],
+    },
+    filter: {
+        path: "/chatter/feeds/filter/{userId}/{keyPrefix}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort", "updatedSince"],
+    },
+    bookmarks: {
+        path: "/chatter/feeds/bookmarks/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort"],
+    },
+    company: {
+        path: "/chatter/feeds/company/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort", "updatedSince"],
+    },
+    "direct-messages": {
+        path: "/chatter/feeds/direct-messages/feed-elements",
+        communityRequired: false,
+        parameters: ["page", "pageSize", "recentCommentCount", "sort"],
+    },
+    draft: {
+        path: "/chatter/feeds/draft/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort"],
+    },
+    files: {
+        path: "/chatter/feeds/files/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort", "updatedSince"],
+    },
+    groups: {
+        path: "/chatter/feeds/groups/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort", "updatedSince"],
+    },
+    isolated: {
+        path: "/chatter/feeds/isolated/feed-elements",
+        communityRequired: false,
+        parameters: ["page", "pageSize", "q", "sort"],
+    },
+    mute: {
+        path: "/chatter/feeds/mute/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort"],
+    },
+    news: {
+        path: "/chatter/feeds/news/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: [
+            "density",
+            "elementsPerBundle",
+            "filter",
+            "page",
+            "pageSize",
+            "q",
+            "recentCommentCount",
+            "sort",
+            "updatedSince",
+        ],
+    },
+    "pending-review": {
+        path: "/chatter/feeds/pending-review/feed-elements",
+        communityRequired: false,
+        parameters: ["page", "pageSize", "q", "sort"],
+    },
+    people: {
+        path: "/chatter/feeds/people/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort", "updatedSince"],
+    },
+    record: {
+        path: "/chatter/feeds/record/{recordId}/feed-elements",
+        communityRequired: false,
+        parameters: [
+            "customFilter",
+            "density",
+            "elementsPerBundle",
+            "filter",
+            "page",
+            "pageSize",
+            "q",
+            "recentCommentCount",
+            "showInternalOnly",
+            "sort",
+            "threadedCommentsCollapsed",
+            "updatedSince",
+        ],
+    },
+    streams: {
+        path: "/chatter/feeds/streams/{streamId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "recentCommentCount", "sort", "updatedSince"],
+    },
+    to: {
+        path: "/chatter/feeds/to/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: ["density", "elementsPerBundle", "page", "pageSize", "q", "recentCommentCount", "sort"],
+    },
+    topics: {
+        path: "/chatter/feeds/topics/{topicId}/feed-elements",
+        communityRequired: false,
+        parameters: ["filter", "page", "pageSize", "sort"],
+    },
+    "user-profile": {
+        path: "/chatter/feeds/user-profile/{userId}/feed-elements",
+        communityRequired: false,
+        parameters: [
+            "density",
+            "elementsPerBundle",
+            "filter",
+            "page",
+            "pageSize",
+            "q",
+            "recentCommentCount",
+            "sort",
+            "threadedCommentsCollapsed",
+        ],
+    },
+    "direct-message-moderation": {
+        path: "/chatter/feeds/direct-message-moderation/feed-elements",
+        communityRequired: true,
+        parameters: ["page", "pageSize", "q", "sort"],
+    },
+    home: {
+        path: "/chatter/feeds/home/feed-elements",
+        communityRequired: true,
+        parameters: ["filter", "page", "pageSize", "q", "sort", "threadedCommentsCollapsed"],
+    },
+    moderation: {
+        path: "/chatter/feeds/moderation/feed-elements",
+        communityRequired: true,
+        parameters: ["page", "pageSize", "q", "sort"],
+    },
+};

package/src/providers/salesforce/context.d.ts

@@ -0,0 +1,16 @@
+import type { OAuthProviderContext } from "../provider-runtime.ts";
+export interface SalesforceContext extends OAuthProviderContext {
+    base: string;
+    version: string;
+    origin: string;
+    request(path: string, method?: string, body?: unknown, extraHeaders?: HeadersInit): Promise<unknown>;
+    object(path: string, method?: string, body?: unknown, extraHeaders?: HeadersInit): Promise<Record<string, unknown>>;
+    items(path: string, method?: string, body?: unknown): Promise<{
+        results: unknown[];
+    }>;
+    response<T>(path: string, init: RequestInit, consume: (response: Response, signal: AbortSignal) => Promise<T>): Promise<T>;
+}
+export declare function createSalesforceContext(context: OAuthProviderContext, data: Record<string, unknown>): SalesforceContext;
+export type SalesforceHandler = (data: Record<string, unknown>, context: SalesforceContext) => Promise<unknown>;
+export declare function segment(value: unknown): string;
+export declare function queryPath(path: string, params: Record<string, unknown>): string;

package/src/providers/salesforce/context.js

@@ -0,0 +1,61 @@
+import { requiredRawString } from "../../core/cast.js";
+import { providerInputError, providerResponseError, requiredInputString, requiredResponseRecord, } from "../provider-runtime.js";
+import { salesforceFileRequestTimeoutMs, salesforceOrigin, salesforceRequest, withSalesforceResponse, } from "./transport.js";
+export function createSalesforceContext(context, data) {
+    const origin = salesforceOrigin(requiredInputString(context.providerSecret?.instanceUrl, "instanceUrl"), "instanceUrl");
+    const version = String(data.apiVersion ?? "66.0");
+    const base = `/services/data/v${version}`;
+    function url(path) {
+        const resolved = new URL(path, origin);
+        if (resolved.origin !== origin || !path.startsWith("/services/"))
+            throw providerInputError("Salesforce path must stay within the connected instance");
+        return resolved;
+    }
+    function initWithAuth(init) {
+        const headers = new Headers(init.headers);
+        headers.set("authorization", `Bearer ${context.accessToken}`);
+        return { ...init, headers };
+    }
+    async function request(path, method = "GET", body, extraHeaders) {
+        const headers = new Headers(extraHeaders);
+        if (body !== undefined)
+            headers.set("content-type", "application/json");
+        return (await salesforceRequest(url(path), initWithAuth({
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+        }), context.fetcher, context.signal)).body;
+    }
+    return {
+        ...context,
+        base,
+        version,
+        origin,
+        request,
+        async object(path, method = "GET", body, extraHeaders) {
+            return requiredResponseRecord(await request(path, method, body, extraHeaders), "Salesforce response");
+        },
+        async items(path, method = "GET", body) {
+            const results = await request(path, method, body);
+            if (!Array.isArray(results))
+                throw providerResponseError("Salesforce results must be an array");
+            return { results };
+        },
+        response(path, init, consume) {
+            return withSalesforceResponse(url(path), initWithAuth(init), context.fetcher, consume, salesforceFileRequestTimeoutMs, context.signal);
+        },
+    };
+}
+export function segment(value) {
+    const raw = requiredRawString(value, "path segment", providerInputError);
+    if (!raw || raw === "." || raw === "..")
+        throw providerInputError("Salesforce path cannot contain dot segments");
+    return encodeURIComponent(raw);
+}
+export function queryPath(path, params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params))
+        if (value !== undefined)
+            search.set(key, Array.isArray(value) ? value.join(",") : String(value));
+    return search.size ? `${path}?${search}` : path;
+}

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

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

package/src/providers/salesforce/executors.js

@@ -0,0 +1,64 @@
+import { optionalString } from "../../core/cast.js";
+import { defineOAuthProviderExecutors, defineProviderProxy, providerInputError, providerResponseError, requiredInputString, requiredResponseRecord, } from "../provider-runtime.js";
+import { createSalesforceContext } from "./context.js";
+import { salesforceAnalyticsHandlers } from "./runtime-analytics.js";
+import { salesforceApprovalHandlers } from "./runtime-approvals.js";
+import { salesforceAutomationHandlers } from "./runtime-automation.js";
+import { salesforceBaseHandlers } from "./runtime-base.js";
+import { salesforceBulkHandlers } from "./runtime-bulk.js";
+import { salesforceChatterHandlers } from "./runtime-chatter.js";
+import { salesforceDataHandlers } from "./runtime-data.js";
+import { salesforceFileHandlers } from "./runtime-files.js";
+import { salesforceKnowledgeHandlers } from "./runtime-knowledge.js";
+import { salesforceLeadHandlers } from "./runtime-leads.js";
+import { salesforcePlatformHandlers } from "./runtime-platform.js";
+import { readSalesforceError, salesforceOrigin, salesforceRequest } from "./transport.js";
+export { oauth } from "./oauth.js";
+const handlers = {};
+for (const [name, handler] of Object.entries({
+    ...salesforceApprovalHandlers,
+    ...salesforceChatterHandlers,
+    ...salesforceKnowledgeHandlers,
+    ...salesforceLeadHandlers,
+    ...salesforcePlatformHandlers,
+    ...salesforceBaseHandlers,
+    ...salesforceDataHandlers,
+    ...salesforceAnalyticsHandlers,
+    ...salesforceAutomationHandlers,
+    ...salesforceFileHandlers,
+    ...salesforceBulkHandlers,
+})) {
+    handlers[name] = (input, context) => handler(input, createSalesforceContext(context, input));
+}
+export const executors = defineOAuthProviderExecutors("salesforce", handlers);
+export const proxy = defineProviderProxy({
+    service: "salesforce",
+    async baseUrl(context, service) {
+        const credential = await context.getCredential(service);
+        if (credential?.authType !== "oauth2")
+            throw providerInputError("Salesforce requires OAuth2");
+        return salesforceOrigin(requiredInputString(credential.providerSecret?.instanceUrl, "instanceUrl"), "instanceUrl");
+    },
+    auth: { type: "oauth_bearer" },
+    readError: readSalesforceError,
+});
+export const credentialValidators = {
+    async oauth2(credential, { fetcher, signal }) {
+        const metadata = credential.providerSecret;
+        if (!metadata)
+            throw providerInputError("Salesforce connection metadata is missing");
+        const url = new URL(requiredInputString(metadata?.identityUrl, "identityUrl"));
+        salesforceOrigin(url.origin, "identityUrl");
+        const body = requiredResponseRecord((await salesforceRequest(url, { headers: { authorization: `Bearer ${credential.accessToken}` } }, fetcher, signal)).body, "Salesforce identity");
+        if (body.organization_id !== metadata?.organizationId || body.user_id !== metadata?.userId)
+            throw providerResponseError("Salesforce identity does not match the token response");
+        return {
+            profile: {
+                accountId: `${metadata.organizationId}:${metadata.userId}`,
+                displayName: optionalString(body.display_name) ?? optionalString(body.username),
+            },
+            metadata: { instanceUrl: metadata.instanceUrl },
+            grantedScopes: optionalString(credential.metadata.scope)?.split(" ").filter(Boolean),
+        };
+    },
+};

package/src/providers/salesforce/media.d.ts

@@ -0,0 +1,9 @@
+import type { TransitFileUpload, TransitFileWriter } from "../../core/types.ts";
+import type { SalesforceContext } from "./context.ts";
+export declare function requireSalesforceTransit(context: SalesforceContext): TransitFileWriter;
+export declare function downloadSalesforceSource(fileUrl: string, maximumBytes: number, context: SalesforceContext): Promise<{
+    body: ReadableStream<Uint8Array>;
+    sizeBytes: number;
+    cleanup(): Promise<void>;
+}>;
+export declare function saveSalesforceDownload(context: SalesforceContext, response: Response, name: string, mimeType: string, signal: AbortSignal): Promise<TransitFileUpload>;

package/src/providers/salesforce/media.js

@@ -0,0 +1,66 @@
+import { assertPublicHttpUrl, storeResponseInTransit } from "../../core/request.js";
+import { providerFetch, providerInputError, providerResponseError, ProviderRequestError, runProviderRequest, } from "../provider-runtime.js";
+import { salesforceFileRequestTimeoutMs } from "./transport.js";
+export function requireSalesforceTransit(context) {
+    const store = context.transitFiles;
+    if (!store?.createFromStream)
+        throw providerInputError("Salesforce file transfers require a streaming transit file backend (filesystem).");
+    return store;
+}
+export async function downloadSalesforceSource(fileUrl, maximumBytes, context) {
+    const store = requireSalesforceTransit(context);
+    if (!store.response)
+        throw providerInputError("Salesforce uploads require a transit backend with streaming reads.");
+    const url = assertPublicHttpUrl(fileUrl, { fieldName: "fileUrl", createError: providerInputError });
+    if (url.protocol !== "https:")
+        throw providerInputError("fileUrl must use HTTPS");
+    return runProviderRequest({ label: "Salesforce file source", timeoutMs: salesforceFileRequestTimeoutMs, signal: context.signal }, async (signal) => {
+        const response = await providerFetch(url, { signal });
+        if (!response.ok || !response.body) {
+            await response.body?.cancel();
+            throw new ProviderRequestError(response.status, `File source returned HTTP ${response.status}`, undefined, "provider_error");
+        }
+        const file = await storeResponseInTransit(response, store, {
+            name: "source",
+            mimeType: "application/octet-stream",
+            fieldName: "Salesforce file source",
+            createError: (message) => new ProviderRequestError(413, message),
+            maxBytes: maximumBytes,
+            signal,
+        });
+        let body = null;
+        try {
+            if (!file.sizeBytes)
+                throw providerInputError("The file source is empty");
+            const source = await store.response(file.fileId);
+            body = source.body;
+            if (!source.ok || !body)
+                throw providerResponseError("Salesforce transit source could not be read");
+            const sourceBody = body;
+            return {
+                body: sourceBody,
+                sizeBytes: file.sizeBytes,
+                async cleanup() {
+                    await sourceBody.cancel().catch(() => undefined);
+                    await store.delete(file.fileId);
+                },
+            };
+        }
+        catch (error) {
+            await body?.cancel().catch(() => undefined);
+            await store.delete(file.fileId);
+            throw error;
+        }
+    });
+}
+export async function saveSalesforceDownload(context, response, name, mimeType, signal) {
+    const store = requireSalesforceTransit(context);
+    return storeResponseInTransit(response, store, {
+        name,
+        mimeType,
+        signal,
+        maxBytes: 2 * 1024 ** 3,
+        fieldName: "Salesforce file",
+        createError: (message) => new ProviderRequestError(413, message),
+    });
+}

package/src/providers/salesforce/oauth.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderOAuthRuntime } from "../../oauth/oauth-token.ts";
+export declare const oauth: ProviderOAuthRuntime;

package/src/providers/salesforce/oauth.js

@@ -0,0 +1,89 @@
+import { optionalNumber, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
+import { ProviderRequestError, providerResponseError, requiredResponseRecord } from "../provider-runtime.js";
+import { salesforceOrigin, salesforceRequest } from "./transport.js";
+function loginOrigin(config) {
+    return salesforceOrigin(optionalString(config.extra.loginUrl) ?? "https://login.salesforce.com", "loginUrl");
+}
+async function requestToken(input) {
+    const origin = loginOrigin(input.config);
+    const result = await salesforceRequest(new URL("/services/oauth2/token", origin), {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            ...input.parameters,
+            client_id: input.config.clientId,
+            client_secret: input.config.clientSecret,
+        }),
+    }, input.fetcher, input.signal).catch((error) => {
+        if (!(error instanceof ProviderRequestError))
+            throw error;
+        const details = optionalRecord(error.details);
+        // Only Salesforce's explicit expired-refresh-token response warrants reconnecting.
+        const expired = input.parameters.grant_type === "refresh_token" &&
+            details?.errorCode === "invalid_grant" &&
+            details.errorDescription === "expired access/refresh token";
+        throw input.createError(error.message, expired ? { status: error.status, errorCode: "invalid_grant" } : undefined);
+    });
+    const body = requiredResponseRecord(result.body, "Salesforce token response");
+    const instanceUrl = salesforceOrigin(requiredString(body.instance_url, "Salesforce instance_url", providerResponseError), "instance_url");
+    const identityUrl = new URL(requiredString(body.id, "Salesforce identity URL", providerResponseError));
+    salesforceOrigin(identityUrl.origin, "identity URL");
+    const parts = identityUrl.pathname.split("/");
+    if (parts.length !== 4 ||
+        parts[1] !== "id" ||
+        !parts[2] ||
+        !parts[3] ||
+        identityUrl.search ||
+        identityUrl.hash ||
+        identityUrl.username ||
+        identityUrl.password)
+        throw providerResponseError("Salesforce returned an invalid identity URL");
+    const scope = optionalString(body.scope) ?? input.fallbackScopes;
+    if (!scope.split(" ").includes("api"))
+        throw providerResponseError("Salesforce did not grant the required api scope");
+    const expiresIn = optionalNumber(body.expires_in);
+    // Salesforce normally omits expires_in; ten minutes is a local refresh budget, not its session lifetime.
+    const refreshAfterSeconds = expiresIn !== undefined && expiresIn > 0 ? Math.min(expiresIn, 600) : 600;
+    return {
+        accessToken: requiredString(body.access_token, "Salesforce access token", providerResponseError),
+        refreshToken: input.parameters.grant_type === "authorization_code"
+            ? requiredString(body.refresh_token, "Salesforce refresh token; enable refresh_token scope and authorize again", input.createError)
+            : optionalString(body.refresh_token),
+        tokenType: optionalString(body.token_type) ?? "Bearer",
+        expiresAt: new Date(Date.now() + refreshAfterSeconds * 1000).toISOString(),
+        providerSecret: { instanceUrl, identityUrl: identityUrl.toString(), organizationId: parts[2], userId: parts[3] },
+        metadata: { scope },
+    };
+}
+export const oauth = {
+    buildAuthorizationUrl({ authorizationUrl, clientConfig }) {
+        const url = new URL("/services/oauth2/authorize", loginOrigin(clientConfig));
+        url.search = authorizationUrl.search;
+        return url.toString();
+    },
+    exchangeCode(input) {
+        const parameters = {
+            grant_type: "authorization_code",
+            code: input.code,
+            redirect_uri: input.redirectUri,
+            code_verifier: requiredString(input.codeVerifier, "Salesforce PKCE verifier", input.createError),
+        };
+        return requestToken({
+            config: input.clientConfig,
+            parameters,
+            fetcher: input.fetcher,
+            signal: input.signal,
+            fallbackScopes: "api refresh_token",
+            createError: input.createError,
+        });
+    },
+    refreshAccessToken(input) {
+        return requestToken({
+            config: input.clientConfig,
+            parameters: { grant_type: "refresh_token", refresh_token: input.refreshToken },
+            fetcher: input.fetcher,
+            fallbackScopes: optionalString(input.metadata.scope) ?? "api refresh_token",
+            createError: input.createError,
+        });
+    },
+};

package/src/providers/salesforce/runtime-analytics.d.ts

@@ -0,0 +1,2 @@
+import type { SalesforceHandler } from "./context.ts";
+export declare const salesforceAnalyticsHandlers: Record<string, SalesforceHandler>;

package/src/providers/salesforce/runtime-analytics.js

@@ -0,0 +1,60 @@
+import { recordOrEmpty, requiredString } from "../../core/cast.js";
+import { providerResponseError } from "../provider-runtime.js";
+import { queryPath, segment } from "./context.js";
+function reportPath(d, base) {
+    return queryPath(`${base}/analytics/reports/${segment(d.reportId)}`, {
+        includeDetails: d.includeDetails,
+    });
+}
+function dashboardPath(d, base, suffix = "") {
+    return queryPath(`${base}/analytics/dashboards/${segment(d.dashboardId)}${suffix}`, {
+        runningUser: d.runningUser,
+        filter1: d.filter1,
+        filter2: d.filter2,
+        filter3: d.filter3,
+    });
+}
+export const salesforceAnalyticsHandlers = {
+    async list_reports(_d, c) {
+        return c.items(`${c.base}/analytics/reports`);
+    },
+    async describe_report(d, c) {
+        return c.object(`${c.base}/analytics/reports/${segment(d.reportId)}/describe`);
+    },
+    async run_report(d, c) {
+        return c.object(reportPath(d, c.base), d.metadata === undefined ? "GET" : "POST", d.metadata === undefined ? undefined : { reportMetadata: d.metadata });
+    },
+    async submit_report(d, c) {
+        const response = await c.object(queryPath(`${c.base}/analytics/reports/${segment(d.reportId)}/instances`, {
+            includeDetails: d.includeDetails,
+        }), "POST", d.metadata === undefined ? undefined : { reportMetadata: d.metadata });
+        // Submit responses put instance fields at the root; result responses use attributes.
+        const handle = {
+            reportId: d.reportId,
+            instanceId: requiredString(response.id, "report instance ID", providerResponseError),
+            apiVersion: c.version,
+        };
+        return { handle, state: requiredString(response.status, "report state", providerResponseError) };
+    },
+    async get_report_result(d, c) {
+        const handle = recordOrEmpty(d.handle);
+        const report = await c.object(`/services/data/v${segment(handle.apiVersion)}/analytics/reports/${segment(handle.reportId)}/instances/${segment(handle.instanceId)}`);
+        return {
+            handle,
+            state: requiredString(recordOrEmpty(report.attributes).status, "report state", providerResponseError),
+            report,
+        };
+    },
+    async list_dashboards(_d, c) {
+        return c.items(`${c.base}/analytics/dashboards`);
+    },
+    async get_dashboard(d, c) {
+        return c.object(dashboardPath(d, c.base));
+    },
+    async refresh_dashboard(d, c) {
+        return c.object(dashboardPath(d, c.base), "PUT");
+    },
+    async get_dashboard_status(d, c) {
+        return c.object(dashboardPath(d, c.base, "/status"));
+    },
+};

package/src/providers/salesforce/runtime-approvals.d.ts

@@ -0,0 +1,2 @@
+import type { SalesforceHandler } from "./context.ts";
+export declare const salesforceApprovalHandlers: Record<string, SalesforceHandler>;

package/src/providers/salesforce/runtime-approvals.js

@@ -0,0 +1,52 @@
+import { providerInputError, providerResponseError, requiredResponseRecord, requiredInputString, } from "../provider-runtime.js";
+import { queryPath } from "./context.js";
+export const salesforceApprovalHandlers = {
+    async list_approval_processes(d, c) {
+        const response = await c.object(`${c.base}/process/approvals/`);
+        const processes = requiredResponseRecord(response.approvals, "Salesforce approval processes");
+        return {
+            processes: d.objectName === undefined
+                ? processes
+                : Object.fromEntries(Object.entries(processes).filter(([name]) => name === d.objectName)),
+        };
+    },
+    async submit_for_approval(d, c) {
+        return c.items(`${c.base}/process/approvals/`, "POST", {
+            requests: d.requests.map(({ recordId, submitterId, ...rest }) => ({
+                ...rest,
+                actionType: "Submit",
+                contextId: recordId,
+                contextActorId: submitterId,
+            })),
+        });
+    },
+    async review_approval_requests(d, c) {
+        return c.items(`${c.base}/process/approvals/`, "POST", {
+            requests: d.requests.map(({ workItemId, decision, ...rest }) => ({
+                ...rest,
+                actionType: decision === "approve" ? "Approve" : "Reject",
+                contextId: workItemId,
+            })),
+        });
+    },
+    async list_pending_approvals(d, c) {
+        if ((d.scope === "actor") !== (d.actorId !== undefined))
+            throw providerInputError("actorId is required only for actor scope");
+        let actorId = d.actorId;
+        if (d.scope === "mine") {
+            actorId = requiredInputString(c.providerSecret?.userId, "Salesforce user ID");
+            if (!/^[A-Za-z0-9]{15}([A-Za-z0-9]{3})?$/.test(String(actorId)))
+                throw providerResponseError("Salesforce returned an invalid user ID");
+        }
+        const filters = [];
+        if (actorId)
+            filters.push(`ActorId = '${actorId}'`);
+        if (d.recordId)
+            filters.push(`ProcessInstance.TargetObjectId = '${d.recordId}'`);
+        const soql = "SELECT Id, ProcessInstanceId, ProcessInstance.TargetObjectId, ActorId, OriginalActorId, CreatedDate FROM ProcessInstanceWorkitem" +
+            (d.scope === "mineAndGroups" ? " USING SCOPE mine_and_my_groups" : "") +
+            (filters.length ? ` WHERE ${filters.join(" AND ")}` : "") +
+            " ORDER BY CreatedDate DESC, Id DESC";
+        return c.object(queryPath(`${c.base}/query`, { q: soql }));
+    },
+};

package/src/providers/salesforce/runtime-automation.d.ts

@@ -0,0 +1,2 @@
+import type { SalesforceHandler } from "./context.ts";
+export declare const salesforceAutomationHandlers: Record<string, SalesforceHandler>;

package/src/providers/salesforce/runtime-automation.js

@@ -0,0 +1,64 @@
+import { recordOrEmpty } from "../../core/cast.js";
+import { providerInputError } from "../provider-runtime.js";
+import { queryPath, segment } from "./context.js";
+function invocablePath(d, base, detail) {
+    if (d.category === "standard" && d.actionType !== undefined)
+        throw providerInputError("actionType is only valid for custom actions");
+    if (d.category === "custom" && detail && !d.actionType)
+        throw providerInputError("Custom actions require actionType");
+    return `${base}/actions/${segment(d.category)}${d.actionType ? `/${segment(d.actionType)}` : ""}${detail ? `/${segment(d.actionName)}` : ""}`;
+}
+async function sendEmail(d, c) {
+    const email = recordOrEmpty(d.email);
+    const recipients = [email.recipientAddresses, email.ccAddresses, email.bccAddresses].reduce((sum, list) => sum + (Array.isArray(list) ? list.length : 0), email.recipientId ? 1 : 0);
+    if (!recipients || recipients > 150)
+        throw providerInputError("Email requires between 1 and 150 recipients");
+    if (email.senderType === "OrgWideEmailAddress" && !email.senderAddress)
+        throw providerInputError("OrgWideEmailAddress requires senderAddress");
+    if (email.logEmailOnSend && !email.recipientId && !email.relatedRecordId)
+        throw providerInputError("logEmailOnSend requires recipientId or relatedRecordId");
+    return c.items(`${c.base}/actions/standard/emailSimple`, "POST", { inputs: [email] });
+}
+export const salesforceAutomationHandlers = {
+    async list_email_templates(d, c) {
+        const filters = [
+            d.includeInactive ? undefined : "IsActive = true",
+            d.folderId ? `FolderId = '${String(d.folderId)}'` : undefined,
+        ].filter(Boolean);
+        const q = `SELECT Id, Name, DeveloperName, Subject, TemplateType, FolderId, IsActive FROM EmailTemplate${filters.length ? ` WHERE ${filters.join(" AND ")}` : ""} ORDER BY Name LIMIT ${d.limit ?? 200}`;
+        return c.object(queryPath(`${c.base}/query`, { q }));
+    },
+    async get_email_template(d, c) {
+        return {
+            record: await c.object(queryPath(`${c.base}/sobjects/EmailTemplate/${segment(d.templateId)}`, {
+                fields: "Id,Name,DeveloperName,Subject,Body,HtmlValue,TemplateType,FolderId,IsActive",
+            })),
+        };
+    },
+    send_email: sendEmail,
+    send_email_from_template: sendEmail,
+    async list_invocable_actions(d, c) {
+        return { result: await c.request(invocablePath(d, c.base, false)) };
+    },
+    async describe_invocable_action(d, c) {
+        return { result: await c.request(invocablePath(d, c.base, true)) };
+    },
+    async invoke_action(d, c) {
+        return c.items(invocablePath(d, c.base, true), "POST", { inputs: d.inputs });
+    },
+    async list_quick_actions(d, c) {
+        return {
+            result: await c.request(`${c.base}${d.objectName ? `/sobjects/${segment(d.objectName)}` : ""}/quickActions/`),
+        };
+    },
+    async get_quick_action_defaults(d, c) {
+        return {
+            result: await c.request(`${c.base}/sobjects/${segment(d.objectName)}/quickActions/${segment(d.actionName)}/defaultValues/${d.contextId ? segment(d.contextId) : ""}`),
+        };
+    },
+    async execute_quick_action(d, c) {
+        return {
+            result: await c.request(`${c.base}${d.objectName ? `/sobjects/${segment(d.objectName)}` : ""}/quickActions/${segment(d.actionName)}`, "POST", { contextId: d.contextId, record: d.fields }),
+        };
+    },
+};

package/src/providers/salesforce/runtime-base.d.ts

@@ -0,0 +1,2 @@
+import type { SalesforceHandler } from "./context.ts";
+export declare const salesforceBaseHandlers: Record<string, SalesforceHandler>;