Salesforce Auth Provider

export SALESFORCE_CLIENT_ID="<your client ID>"
export SALESFORCE_CLIENT_SECRET="<your client secret>"

SALESFORCE_CLIENT_ID="<your client ID>"
SALESFORCE_CLIENT_SECRET="<your client secret>"

auth:
  providers:
    - id: salesforce
      description: "Custom Salesforce provider"
      enabled: true
      type: oauth2
      client_id: ${env:SALESFORCE_CLIENT_ID}
      client_secret: ${env:SALESFORCE_CLIENT_SECRET}
      oauth2:
        authorize_request:
          endpoint: 'https://salesforce-org-subdomain.my.salesforce.com/services/oauth2/authorize'
          params:
            client_id: '{{client_id}}'
            redirect_uri: '{{redirect_uri}}'
            scope: '{{scopes}}'
            response_type: code
        token_request:
          endpoint: 'https://salesforce-org-subdomain.my.salesforce.com/services/oauth2/token'
          params:
            grant_type: authorization_code
            client_id: '{{client_id}}'
            client_secret: '{{client_secret}}'
            redirect_uri: '{{redirect_uri}}'
        refresh_request:
          endpoint: 'https://salesforce-org-subdomain.my.salesforce.com/services/oauth2/token'
          params:
            grant_type: refresh_token
            client_id: '{{client_id}}'
            client_secret: '{{client_secret}}'
            refresh_token: '{{refresh_token}}'
        token_introspection_request:
          enabled: false
          endpoint: 'https://salesforce-org-subdomain.my.salesforce.com/services/oauth2/introspect'
          method: POST
          params:
            token: '{{access_token}}'
          auth_method: 'client_secret_basic'
          request_content_type: application/x-www-form-urlencoded
          response_content_type: application/json
          response_map:
            expires_in: '$.exp'
            scope: '$.scope'
          expiration_format: absolute_unix_timestamp
          triggers:
            on_token_grant: true
            on_token_refresh: true

auth:
  providers:
    - id: salesforce
      description: "Custom Salesforce provider"
      enabled: true
      pkce: true
      ...

pip install arcadepy

import requests
from arcadepy import Arcade
 
client = Arcade(base_url="http://localhost:9099")  # Automatically finds the `ARCADE_API_KEY` env variable

salesforce_provider_id = "salesforce"
salesforce_org_subdomain = "salesforce-org-subdomain"
user_id = "user@example.com"
scopes = ["read_account"]

auth_response = client.auth.start(
    user_id=user_id,
    provider=salesforce_provider_id,
    scopes=scopes,
)
 
if auth_response.status != "completed":
    print("Please complete the authorization challenge in your browser:")
    print(auth_response.url)
 
# Wait for the authorization to complete
auth_response = client.auth.wait_for_completion(auth_response)
 
token = auth_response.context.token
 
if not token:
    raise ValueError("No token found in auth response")

response = requests.post(
    f"https://{salesforce_org_subdomain}.my.salesforce.com/services/data/v63.0/parameterizedSearch",
    headers={"Authorization": f"Bearer {token}"},
    json={
        "q": "acme",
        "sobjects": [
            {"name": "Account", "fields": ["Id", "Name", "Website", "Phone"]},
        ],
        "in": "ALL",
        "overallLimit": 10,
        "offset": 0,
    },
)
 
if not response.ok:
    raise ValueError(
        f"Failed to retrieve Salesforce data: {response.status_code} - {response.text}"
    )

npm install @arcadeai/arcadejs

import { Arcade } from "@arcadeai/arcadejs";
 
const client = new Arcade((baseURL = "http://localhost:9099")); // Automatically finds the `ARCADE_API_KEY` env variable

const salesforceProviderId = "salesforce";
const salesforceOrgSubdomain = "salesforce-org-subdomain";
const userId = "user@example.com";
const scopes = ["read_account"];

let authResponse = await client.auth.start(userId, {
  provider: salesforceProviderId,
  scopes: scopes,
});
 
if (authResponse.status !== "completed") {
  console.log("Please complete the authorization challenge in your browser:");
  console.log(authResponse.url);
}
 
// Wait for the authorization to complete
authResponse = await client.auth.waitForCompletion(authResponse);
 
if (!authResponse.context.token) {
  throw new Error("No token found in auth response");
}
 
const token = authResponse.context.token;
 
if (!token) {
  throw new Error("No token found in auth response");

// Use the Salesforce API
const response = await fetch(
  `https://${salesforceOrgSubdomain}.my.salesforce.com/services/data/v63.0/parameterizedSearch`,
  {
    headers: {
      Authorization: `Bearer ${token}`,
    },
    method: "POST",
    body: JSON.stringify({
      q: "acme",
      sobjects: [
        { name: "Account", fields: ["Id", "Name", "Website", "Phone"] },
      ],
      in: "ALL",
      overallLimit: 10,
      offset: 0,
    }),
  },
);
 
if (!response.ok) {
  throw new Error(
    `HTTP error! status: ${response.status} - ${await response.text()}`,
  );