@oomol-lab/open-connector 1.9.0 → 1.9.2

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

@@ -0,0 +1,62 @@
+import { requiredResponseRecord } from "../provider-runtime.js";
+import { queryPath, segment } from "./context.js";
+import { salesforceRequest } from "./transport.js";
+export const salesforceBaseHandlers = {
+    async list_objects(_d, c) {
+        return c.object(`${c.base}/sobjects/`);
+    },
+    async describe_object(d, c) {
+        return c.object(`${c.base}/sobjects/${segment(d.objectName)}/describe`);
+    },
+    async query(d, c) {
+        const headers = new Headers({ authorization: `Bearer ${c.accessToken}` });
+        if (d.batchSize !== undefined)
+            headers.set("Sforce-Query-Options", `batchSize=${d.batchSize}`);
+        return requiredResponseRecord((await salesforceRequest(new URL(queryPath(`${c.base}/${d.includeDeleted ? "queryAll" : "query"}`, { q: d.soql }), c.origin), { headers }, c.fetcher, c.signal)).body, "Salesforce query");
+    },
+    async query_more(d, c) {
+        const headers = new Headers({ authorization: `Bearer ${c.accessToken}` });
+        if (d.batchSize !== undefined)
+            headers.set("Sforce-Query-Options", `batchSize=${d.batchSize}`);
+        return requiredResponseRecord((await salesforceRequest(new URL(String(d.nextRecordsUrl), c.origin), { headers }, c.fetcher, c.signal)).body, "Salesforce query");
+    },
+    async get_record(d, c) {
+        return {
+            record: await c.object(queryPath(`${c.base}/sobjects/${segment(d.objectName)}/${segment(d.recordId)}`, { fields: d.fields })),
+        };
+    },
+    async create_record(d, c) {
+        return c.object(`${c.base}/sobjects/${segment(d.objectName)}`, "POST", d.fields, writeHeaders(d));
+    },
+    async update_record(d, c) {
+        const result = await c.request(`${c.base}/sobjects/${segment(d.objectName)}/${segment(d.recordId)}`, "PATCH", d.fields, writeHeaders(d));
+        return result === undefined
+            ? { success: true, id: d.recordId }
+            : requiredResponseRecord(result, "Salesforce response");
+    },
+    async delete_record(d, c) {
+        const result = await c.request(`${c.base}/sobjects/${segment(d.objectName)}/${segment(d.recordId)}`, "DELETE");
+        return result === undefined
+            ? { success: true, id: d.recordId }
+            : requiredResponseRecord(result, "Salesforce response");
+    },
+    async upsert_record(d, c) {
+        const result = await c.request(queryPath(`${c.base}/sobjects/${segment(d.objectName)}/${segment(d.externalIdField)}/${segment(d.externalId)}`, {
+            updateOnly: d.updateOnly,
+        }), "PATCH", d.fields, writeHeaders(d));
+        return result === undefined
+            ? { success: true, created: false }
+            : requiredResponseRecord(result, "Salesforce response");
+    },
+};
+function writeHeaders(input) {
+    const headers = new Headers();
+    if (input.assignmentRule !== undefined)
+        headers.set("Sforce-Auto-Assign", String(input.assignmentRule));
+    if (input.duplicateRule !== undefined) {
+        const options = Object.entries(input.duplicateRule);
+        if (options.length)
+            headers.set("Sforce-Duplicate-Rule-Header", options.map(([name, value]) => `${name}=${value}`).join("; "));
+    }
+    return headers;
+}

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

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

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

@@ -0,0 +1,98 @@
+import { recordOrEmpty, requiredString } from "../../core/cast.js";
+import { providerInputError, providerResponseError, ProviderRequestError } from "../provider-runtime.js";
+import { queryPath, segment } from "./context.js";
+import { downloadSalesforceSource, requireSalesforceTransit, saveSalesforceDownload } from "./media.js";
+function jobResult(job, kind, version) {
+    return {
+        handle: { jobId: requiredString(job.id, "Bulk job ID", providerResponseError), kind, apiVersion: version },
+        state: requiredString(job.state, "Bulk job state", providerResponseError),
+        job,
+    };
+}
+function jobPath(handle) {
+    return `/services/data/v${segment(handle.apiVersion)}/jobs/${segment(handle.kind)}/${segment(handle.jobId)}`;
+}
+async function readJob(d, c) {
+    const handle = recordOrEmpty(d.handle);
+    const job = await c.object(jobPath(handle));
+    return { ...jobResult(job, String(handle.kind), String(handle.apiVersion)), path: jobPath(handle) };
+}
+export const salesforceBulkHandlers = {
+    async submit_bulk_query(d, c) {
+        return jobResult(await c.object(`${c.base}/jobs/query`, "POST", {
+            operation: d.includeDeleted ? "queryAll" : "query",
+            query: d.soql,
+            contentType: "CSV",
+            columnDelimiter: d.columnDelimiter,
+            lineEnding: d.lineEnding,
+        }), "query", c.version);
+    },
+    async get_bulk_query_result(d, c) {
+        const { path, ...output } = await readJob(d, c);
+        if (output.state !== "JobComplete" || d.download === false)
+            return output;
+        requireSalesforceTransit(c);
+        const downloaded = await c.response(queryPath(`${path}/results`, { locator: d.locator, maxRecords: d.maxRecords }), { headers: { accept: "text/csv" } }, async (response, signal) => {
+            const locator = response.headers.get("Sforce-Locator");
+            if (!locator) {
+                await response.body?.cancel();
+                throw providerResponseError("Salesforce query results are missing Sforce-Locator; pagination completeness is unknown");
+            }
+            const count = response.headers.get("Sforce-NumberOfRecords");
+            const result = await saveSalesforceDownload(c, response, `${output.handle.jobId}.csv`, "text/csv", signal);
+            return {
+                result,
+                nextLocator: locator === "null" ? null : locator,
+                numberOfRecords: count !== null && Number.isFinite(Number(count)) ? Number(count) : undefined,
+            };
+        });
+        return { ...output, ...downloaded };
+    },
+    async submit_bulk_ingest(d, c) {
+        if (d.operation === "upsert" && !d.externalIdField)
+            throw providerInputError("Bulk upsert requires externalIdField");
+        const source = await downloadSalesforceSource(String(d.csvUrl), 100_000_000, c);
+        let created;
+        try {
+            created = await c.object(`${c.base}/jobs/ingest`, "POST", {
+                object: d.objectName,
+                operation: d.operation,
+                contentType: "CSV",
+                externalIdFieldName: d.externalIdField,
+                assignmentRuleId: d.assignmentRuleId,
+                columnDelimiter: d.columnDelimiter,
+                lineEnding: d.lineEnding,
+            });
+            const id = requiredString(created.id, "Bulk job ID", providerResponseError);
+            await c.response(`${c.base}/jobs/ingest/${segment(id)}/batches`, {
+                method: "PUT",
+                headers: { "content-type": "text/csv", "content-length": String(source.sizeBytes) },
+                body: source.body,
+            }, async (response) => {
+                await response.body?.cancel();
+            });
+            return jobResult(await c.object(`${c.base}/jobs/ingest/${segment(id)}`, "PATCH", { state: "UploadComplete" }), "ingest", c.version);
+        }
+        catch (error) {
+            if (!created)
+                throw error;
+            throw new ProviderRequestError(error instanceof ProviderRequestError ? error.status : 502, `Salesforce ingest job ${String(created.id)} was created but submission failed. Inspect or cancel this ingest job with API ${c.version} before resubmitting. ${error instanceof Error ? error.message : "Unknown failure"}`, undefined, error instanceof ProviderRequestError ? error.code : "provider_error");
+        }
+        finally {
+            await source.cleanup();
+        }
+    },
+    async get_bulk_ingest_result(d, c) {
+        const { path, ...output } = await readJob(d, c);
+        if (!["JobComplete", "Failed", "Aborted"].includes(output.state) || d.download === false)
+            return output;
+        requireSalesforceTransit(c);
+        const type = String(d.resultType ?? (output.state === "JobComplete" ? "failedResults" : "unprocessedrecords"));
+        const result = await c.response(`${path}/${type}`, { headers: { accept: "text/csv" } }, (response, signal) => saveSalesforceDownload(c, response, `${output.handle.jobId}-${type}.csv`, "text/csv", signal));
+        return { ...output, result };
+    },
+    async cancel_bulk_job(d, c) {
+        const handle = recordOrEmpty(d.handle);
+        return jobResult(await c.object(jobPath(handle), "PATCH", { state: "Aborted" }), String(handle.kind), String(handle.apiVersion));
+    },
+};

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

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

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

@@ -0,0 +1,78 @@
+import { recordOrEmpty } from "../../core/cast.js";
+import { providerInputError } from "../provider-runtime.js";
+import { chatterFeedRoutes } from "./chatter-routes.js";
+import { queryPath, segment } from "./context.js";
+function chatterBase(d, c) {
+    return c.base + (d.communityId === undefined ? "" : `/connect/communities/${segment(d.communityId)}`);
+}
+function elementPath(d, c) {
+    return `${chatterBase(d, c)}/chatter/feed-elements/${segment(d.feedElementId)}`;
+}
+export const salesforceChatterHandlers = {
+    async list_chatter_feed_elements(d, c) {
+        const route = chatterFeedRoutes[d.feedType];
+        if (route.communityRequired && d.communityId === undefined)
+            throw providerInputError("communityId is required for this feed");
+        let path = route.path;
+        for (const name of ["userId", "recordId", "topicId", "streamId", "favoriteId", "keyPrefix"]) {
+            const inputName = ["favoriteId", "keyPrefix"].includes(name) ? name : "subjectId";
+            if (path.includes(`{${name}}`)) {
+                if (d[inputName] === undefined)
+                    throw providerInputError(`${inputName} is required for ${d.feedType}`);
+                path = path.replace(`{${name}}`, segment(d[inputName]));
+            }
+        }
+        if (!route.path.includes("{") && d.subjectId !== undefined)
+            throw providerInputError("This feed does not accept subjectId");
+        if (d.favoriteId !== undefined && d.feedType !== "favorites")
+            throw providerInputError("favoriteId requires favorites feed");
+        if (d.keyPrefix !== undefined && d.feedType !== "filter")
+            throw providerInputError("keyPrefix requires filter feed");
+        const { apiVersion: _version, feedType: _type, subjectId: _subject, communityId: _community, favoriteId: _favorite, keyPrefix: _prefix, ...params } = d;
+        for (const name of Object.keys(params))
+            if (!route.parameters.includes(name))
+                throw providerInputError(`${name} is not supported by ${d.feedType} feed`);
+        return c.object(queryPath(chatterBase(d, c) + path, params));
+    },
+    async get_chatter_feed_element(d, c) {
+        return {
+            element: await c.object(queryPath(elementPath(d, c), {
+                commentSort: d.commentSort,
+                elementsPerBundle: d.elementsPerBundle,
+                recentCommentCount: d.recentCommentCount,
+                threadedCommentsCollapsed: d.threadedCommentsCollapsed,
+            })),
+        };
+    },
+    async list_chatter_comments(d, c) {
+        return c.object(queryPath(`${elementPath(d, c)}/capabilities/comments/items`, {
+            page: d.page,
+            pageSize: d.pageSize,
+            sort: d.sort,
+            threadedCommentsCollapsed: d.threadedCommentsCollapsed,
+        }));
+    },
+    async create_chatter_comment(d, c) {
+        return {
+            comment: await c.object(`${elementPath(d, c)}/capabilities/comments/items`, "POST", {
+                body: d.body,
+                capabilities: d.capabilities,
+                threadParentId: d.threadParentId,
+            }),
+        };
+    },
+    async create_chatter_feed_element(d, c) {
+        const capabilities = recordOrEmpty(d.capabilities);
+        if (d.body === undefined && !capabilities.files && !capabilities.link && !capabilities.feedEntityShare)
+            throw providerInputError("Provide body or a file, link or feed sharing capability");
+        return {
+            element: await c.object(`${chatterBase(d, c)}/chatter/feed-elements`, "POST", {
+                feedElementType: "FeedItem",
+                subjectId: d.subjectId,
+                body: d.body,
+                capabilities: d.capabilities,
+                visibility: d.visibility,
+            }),
+        };
+    },
+};

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

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

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

@@ -0,0 +1,207 @@
+import { recordOrEmpty } from "../../core/cast.js";
+import { providerInputError } from "../provider-runtime.js";
+import { requiredResponseRecord } from "../provider-runtime.js";
+import { queryPath, segment } from "./context.js";
+import { salesforceRequest, salesforceOrigin } from "./transport.js";
+function rejectReservedFields(fields) {
+    if (Object.keys(fields).some((key) => ["attributes", "id"].includes(key.toLowerCase())))
+        throw providerInputError("Use recordId and objectName instead of fields.Id or fields.attributes");
+}
+function validateComposite(requests, graph) {
+    const references = new Set();
+    let collectionQueries = 0;
+    for (const request of requests) {
+        if (Object.keys(recordOrEmpty(request.httpHeaders)).some((header) => ["accept", "authorization", "content-type"].includes(header.toLowerCase())))
+            throw providerInputError("Composite subrequests inherit Accept, Authorization and Content-Type; do not override them");
+        const ref = String(request.referenceId);
+        if (references.has(ref))
+            throw providerInputError("Composite reference IDs must be unique");
+        references.add(ref);
+        const path = String(request.url);
+        const resourcePath = path.split("?")[0];
+        const parts = resourcePath.split("/");
+        if (!path.startsWith("/services/data/v") ||
+            parts.length < 5 ||
+            path.includes("\\") ||
+            path.includes("#") ||
+            parts.slice(4).some((part) => {
+                try {
+                    const decoded = decodeURIComponent(part);
+                    return decoded === "." || decoded === "..";
+                }
+                catch {
+                    return true;
+                }
+            }))
+            throw providerInputError("Invalid composite resource URL");
+        const resource = parts[4]?.split("?")[0];
+        const collection = resource === "composite" && parts[5]?.split("?")[0] === "sobjects";
+        if (resource !== "sobjects" && (graph || (!collection && resource !== "query" && resource !== "queryAll")))
+            throw providerInputError("Resource is not supported by Salesforce Composite");
+        if (collection || resource === "query" || resource === "queryAll")
+            collectionQueries++;
+    }
+    if (!graph && collectionQueries > 5)
+        throw providerInputError("Composite allows at most five queries or collections");
+}
+function validateTree(records, rootType) {
+    let count = 0;
+    const types = new Set();
+    const refs = new Set();
+    function visit(nodes, depth, root) {
+        if (depth > 5)
+            throw providerInputError("Record trees support at most five levels");
+        for (const node of nodes) {
+            const record = recordOrEmpty(node);
+            const attrs = recordOrEmpty(record.attributes);
+            if (typeof attrs.type !== "string" ||
+                typeof attrs.referenceId !== "string" ||
+                !attrs.referenceId ||
+                (root && attrs.type !== rootType))
+                throw providerInputError("Tree records require attributes.type and referenceId; root type must match objectName");
+            if (refs.has(attrs.referenceId))
+                throw providerInputError("Tree reference IDs must be unique");
+            refs.add(attrs.referenceId);
+            types.add(attrs.type);
+            count++;
+            if (count > 200 || types.size > 5)
+                throw providerInputError("Record trees allow 200 records and five object types");
+            for (const value of Object.values(record)) {
+                const nested = recordOrEmpty(value);
+                if (Array.isArray(nested.records))
+                    visit(nested.records, depth + 1, false);
+            }
+        }
+    }
+    visit(records, 1, true);
+}
+export const salesforceDataHandlers = {
+    async search_records(d, c) {
+        return c.object(queryPath(`${c.base}/search`, { q: d.sosl }));
+    },
+    async parameterized_search(d, c) {
+        return c.object(`${c.base}/parameterizedSearch`, "POST", d.request);
+    },
+    async get_record_by_external_id(d, c) {
+        return {
+            record: await c.object(queryPath(`${c.base}/sobjects/${segment(d.objectName)}/${segment(d.externalIdField)}/${segment(d.externalId)}`, { fields: d.fields })),
+        };
+    },
+    async get_related_records(d, c) {
+        return {
+            result: await c.request(queryPath(`${c.base}/sobjects/${segment(d.objectName)}/${segment(d.recordId)}/${d.relationships.map(segment).join("/")}`, { fields: d.fields })),
+        };
+    },
+    async list_updated_records(d, c) {
+        validateWindow(d);
+        return c.object(queryPath(`${c.base}/sobjects/${segment(d.objectName)}/updated/`, {
+            start: d.start,
+            end: d.end,
+        }));
+    },
+    async list_deleted_records(d, c) {
+        validateWindow(d);
+        return c.object(queryPath(`${c.base}/sobjects/${segment(d.objectName)}/deleted/`, {
+            start: d.start,
+            end: d.end,
+        }));
+    },
+    async get_record_counts(d, c) {
+        return c.object(queryPath(`${c.base}/limits/recordCount`, { sObjects: d.objectNames }));
+    },
+    async get_records(d, c) {
+        return c.items(`${c.base}/composite/sobjects/${segment(d.objectName)}`, "POST", {
+            recordIds: d.recordIds,
+            fieldNames: d.fields,
+        });
+    },
+    async create_records(d, c) {
+        return collectionWrite(d, c, false);
+    },
+    async update_records(d, c) {
+        return collectionWrite(d, c, true);
+    },
+    async upsert_records(d, c) {
+        const records = d.records.map((fields) => {
+            rejectReservedFields(fields);
+            if (!Object.hasOwn(fields, String(d.externalIdField)))
+                throw providerInputError("Each upsert record must contain the external ID field");
+            return { ...fields, attributes: { type: d.objectName } };
+        });
+        return c.items(`${c.base}/composite/sobjects/${segment(d.objectName)}/${segment(d.externalIdField)}`, "PATCH", {
+            records,
+            allOrNone: d.allOrNone,
+        });
+    },
+    async delete_records(d, c) {
+        return c.items(queryPath(`${c.base}/composite/sobjects`, { ids: d.recordIds, allOrNone: d.allOrNone }), "DELETE");
+    },
+    async create_record_tree(d, c) {
+        validateTree(d.records, String(d.objectName));
+        return c.object(`${c.base}/composite/tree/${segment(d.objectName)}`, "POST", {
+            records: d.records,
+        });
+    },
+    async execute_composite(d, c) {
+        validateComposite(d.requests, false);
+        return c.object(`${c.base}/composite`, "POST", {
+            compositeRequest: d.requests,
+            allOrNone: d.allOrNone,
+            collateSubrequests: d.collateSubrequests,
+        });
+    },
+    async execute_composite_graph(d, c) {
+        const graphs = d.graphs;
+        if (new Set(graphs.map((g) => g.graphId)).size !== graphs.length ||
+            graphs.reduce((sum, g) => sum + g.compositeRequest.length, 0) > 500)
+            throw providerInputError("Graphs require unique IDs and at most 500 total subrequests");
+        for (const graph of graphs)
+            validateComposite(graph.compositeRequest, true);
+        return c.object(`${c.base}/composite/graph`, "POST", { graphs });
+    },
+    async list_list_views(d, c) {
+        return c.object(`${c.base}/sobjects/${segment(d.objectName)}/listviews`);
+    },
+    async describe_list_view(d, c) {
+        return c.object(`${c.base}/sobjects/${segment(d.objectName)}/listviews/${segment(d.listViewId)}/describe`);
+    },
+    async get_list_view_records(d, c) {
+        return c.object(queryPath(`${c.base}/sobjects/${segment(d.objectName)}/listviews/${segment(d.listViewId)}/results`, {
+            limit: d.limit,
+            offset: d.offset,
+        }));
+    },
+    async get_picklist_values(d, c) {
+        return c.object(`${c.base}/ui-api/object-info/${segment(d.objectName)}/picklist-values/${segment(d.recordTypeId)}`);
+    },
+    async get_current_user(_d, c) {
+        const url = new URL(String(c.providerSecret?.identityUrl));
+        salesforceOrigin(url.origin, "identityUrl");
+        return {
+            user: requiredResponseRecord((await salesforceRequest(url, { headers: { authorization: `Bearer ${c.accessToken}` } }, c.fetcher, c.signal))
+                .body, "Salesforce identity"),
+        };
+    },
+    async get_org_limits(_d, c) {
+        return { limits: await c.object(`${c.base}/limits`) };
+    },
+};
+function validateWindow(d) {
+    if (Date.parse(String(d.start)) >= Date.parse(String(d.end)))
+        throw providerInputError("start must precede end");
+}
+async function collectionWrite(d, c, update) {
+    const records = d.records.map((entry) => {
+        const fields = recordOrEmpty(entry.fields);
+        rejectReservedFields(fields);
+        return {
+            ...fields,
+            attributes: { type: entry.objectName },
+            Id: update ? entry.recordId : undefined,
+        };
+    });
+    return c.items(`${c.base}/composite/sobjects`, update ? "PATCH" : "POST", {
+        records,
+        allOrNone: d.allOrNone,
+    });
+}

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

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

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

@@ -0,0 +1,108 @@
+import { recordOrEmpty, optionalString, requiredString } from "../../core/cast.js";
+import { providerInputError, providerResponseError, requiredResponseRecord } from "../provider-runtime.js";
+import { queryPath, segment } from "./context.js";
+import { downloadSalesforceSource, requireSalesforceTransit, saveSalesforceDownload } from "./media.js";
+export const salesforceFileHandlers = {
+    async upload_file(d, c) {
+        const filename = String(d.filename);
+        if (["\r", "\n", "\0", '"', "\\", "/"].some((char) => filename.includes(char)) ||
+            filename === "." ||
+            filename === "..")
+            throw providerInputError("filename must be a plain file name without header control characters");
+        const metadata = recordOrEmpty(d.metadata);
+        if (Object.keys(metadata).some((key) => ["versiondata", "id", "attributes"].includes(key.toLowerCase())))
+            throw providerInputError("metadata cannot include VersionData, Id or attributes");
+        const source = await downloadSalesforceSource(String(d.fileUrl), 2 * 1024 ** 3, c);
+        const boundary = `salesforce-${Array.from(crypto.getRandomValues(new Uint8Array(16)), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+        const encoder = new TextEncoder();
+        const prefix = encoder.encode(`--${boundary}\r\nContent-Disposition: form-data; name="entity_content"\r\nContent-Type: application/json\r\n\r\n${JSON.stringify({ Title: filename, PathOnClient: filename, ...metadata })}\r\n--${boundary}\r\nContent-Disposition: form-data; name="VersionData"; filename="${filename}"\r\nContent-Type: application/octet-stream\r\n\r\n`);
+        const suffix = encoder.encode(`\r\n--${boundary}--\r\n`);
+        const reader = source.body.getReader();
+        let started = false;
+        const body = new ReadableStream({
+            async pull(controller) {
+                if (!started) {
+                    started = true;
+                    controller.enqueue(prefix);
+                    return;
+                }
+                const chunk = await reader.read();
+                if (chunk.done) {
+                    controller.enqueue(suffix);
+                    controller.close();
+                    reader.releaseLock();
+                }
+                else
+                    controller.enqueue(chunk.value);
+            },
+            async cancel(reason) {
+                await reader.cancel(reason);
+                reader.releaseLock();
+            },
+        });
+        try {
+            return await c.response(`${c.base}/sobjects/ContentVersion`, {
+                method: "POST",
+                headers: {
+                    "content-type": `multipart/form-data; boundary=${boundary}`,
+                    "content-length": String(prefix.byteLength + source.sizeBytes + suffix.byteLength),
+                },
+                body,
+            }, async (response) => requiredResponseRecord(await response.json(), "ContentVersion result"));
+        }
+        finally {
+            await reader.cancel().catch(() => undefined);
+            reader.releaseLock();
+            await source.cleanup();
+        }
+    },
+    async get_file(d, c) {
+        return { record: await c.object(`${c.base}/sobjects/ContentDocument/${segment(d.fileId)}`) };
+    },
+    async download_file(d, c) {
+        requireSalesforceTransit(c);
+        const document = await c.object(queryPath(`${c.base}/sobjects/ContentDocument/${segment(d.fileId)}`, {
+            fields: "Id,Title,LatestPublishedVersionId,FileExtension",
+        }));
+        const versionId = d.versionId ?? requiredString(document.LatestPublishedVersionId, "latest file version ID", providerResponseError);
+        if (d.versionId) {
+            const version = await c.object(queryPath(`${c.base}/sobjects/ContentVersion/${segment(versionId)}`, { fields: "ContentDocumentId" }));
+            if (!sameSalesforceId(String(version.ContentDocumentId), String(d.fileId)))
+                throw providerInputError("versionId does not belong to fileId");
+        }
+        const extension = optionalString(document.FileExtension);
+        const name = `${optionalString(document.Title) ?? String(d.fileId)}${extension ? `.${extension}` : ""}`;
+        return c.response(`${c.base}/sobjects/ContentVersion/${segment(versionId)}/VersionData`, { method: "GET", headers: { accept: "application/octet-stream" } }, (response, signal) => saveSalesforceDownload(c, response, name, response.headers.get("content-type") ?? "application/octet-stream", signal));
+    },
+    async list_record_files(d, c) {
+        return c.object(queryPath(`${c.base}/query`, {
+            q: `SELECT Id, ContentDocumentId, LinkedEntityId, ShareType, Visibility, ContentDocument.Title, ContentDocument.LatestPublishedVersionId FROM ContentDocumentLink WHERE LinkedEntityId = '${d.recordId}'`,
+        }));
+    },
+    async list_file_shares(d, c) {
+        return c.object(queryPath(`${c.base}/query`, {
+            q: `SELECT Id, ContentDocumentId, LinkedEntityId, ShareType, Visibility FROM ContentDocumentLink WHERE ContentDocumentId = '${d.fileId}'`,
+        }));
+    },
+    async link_file(d, c) {
+        return c.object(`${c.base}/sobjects/ContentDocumentLink`, "POST", {
+            ContentDocumentId: d.fileId,
+            LinkedEntityId: d.recordId,
+            ShareType: d.shareType ?? "V",
+            Visibility: d.visibility,
+        });
+    },
+    async unlink_file(d, c) {
+        await c.request(`${c.base}/sobjects/ContentDocumentLink/${segment(d.linkId)}`, "DELETE");
+        return { success: true };
+    },
+    async delete_file(d, c) {
+        await c.request(`${c.base}/sobjects/ContentDocument/${segment(d.fileId)}`, "DELETE");
+        return { success: true };
+    },
+};
+function sameSalesforceId(left, right) {
+    return left.length === 18 && right.length === 18
+        ? left.toLowerCase() === right.toLowerCase()
+        : left.slice(0, 15) === right.slice(0, 15);
+}

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

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

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

@@ -0,0 +1,34 @@
+import { recordOrEmpty } from "../../core/cast.js";
+import { providerInputError } from "../provider-runtime.js";
+import { queryPath, segment } from "./context.js";
+export const salesforceKnowledgeHandlers = {
+    async list_knowledge_articles(d, c) {
+        if (d.queryMethod && !Object.keys(recordOrEmpty(d.categories)).length)
+            throw providerInputError("queryMethod requires categories");
+        if (d.order && !d.sort)
+            throw providerInputError("order requires sort");
+        if (d.sort === "ViewScore" && (d.searchText || d.pageNumber !== undefined))
+            throw providerInputError("ViewScore does not support searchText or pageNumber");
+        return c.object(queryPath(`${c.base}/support/knowledgeArticles`, {
+            q: d.searchText,
+            channel: d.channel,
+            categories: d.categories === undefined ? undefined : JSON.stringify(d.categories),
+            queryMethod: d.queryMethod,
+            sort: d.sort,
+            order: d.order,
+            pageSize: d.pageSize,
+            pageNumber: d.pageNumber,
+        }), "GET", undefined, { "Accept-Language": String(d.language) });
+    },
+    async get_knowledge_article(d, c) {
+        if ((d.articleId !== undefined) === (d.urlName !== undefined))
+            throw providerInputError("Provide exactly one of articleId or urlName");
+        return {
+            article: await c.object(queryPath(`${c.base}/support/knowledgeArticles/${segment(d.articleId ?? d.urlName)}`, {
+                channel: d.channel,
+                isUrlName: d.urlName === undefined ? undefined : true,
+                updateViewStat: d.updateViewStat ?? false,
+            }), "GET", undefined, { "Accept-Language": String(d.language) }),
+        };
+    },
+};

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

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