Struct SalesforceCredentials 

pub struct SalesforceCredentials { /* private fields */ }

Standard Salesforce credentials implementation.

Sensitive fields (access_token, refresh_token) are redacted in Debug output to prevent accidental exposure in logs.

Implementations

impl SalesforceCredentials

pub fn new( instance_url: impl Into<String>, access_token: impl Into<String>, api_version: impl Into<String>, ) -> SalesforceCredentials

Create new credentials with the given values.

pub fn with_refresh_token( self, refresh_token: impl Into<String>, ) -> SalesforceCredentials

Create credentials with a refresh token.

pub fn refresh_token(&self) -> Option<&str>

Get the refresh token if available.

Examples found in repository

examples/basic_auth.rs (line 53)

async fn example_from_env() -> Result<(), Box<dyn std::error::Error>> {
    println!("Example 1: Load from Environment Variables");
    println!("-------------------------------------------");

    match SalesforceCredentials::from_env() {
        Ok(creds) => {
            println!("✓ Loaded credentials from environment");
            println!("  Instance URL: {}", creds.instance_url());
            println!("  API Version: {}", creds.api_version());
            println!("  Has Refresh Token: {}", creds.refresh_token().is_some());
        }
        Err(e) => {
            println!("✗ Failed to load from environment: {}", e);
            println!("  Tip: Set SF_INSTANCE_URL and SF_ACCESS_TOKEN");
        }
    }

    println!();
    Ok(())
}

pub fn set_access_token(&mut self, token: impl Into<String>)

Set a new access token (e.g., after refresh).

pub fn from_env() -> Result<SalesforceCredentials, Error>

Load credentials from environment variables.

Required environment variables:

• SF_INSTANCE_URL or SALESFORCE_INSTANCE_URL
• SF_ACCESS_TOKEN or SALESFORCE_ACCESS_TOKEN

Optional:

• SF_API_VERSION or SALESFORCE_API_VERSION (default: “62.0”)
• SF_REFRESH_TOKEN or SALESFORCE_REFRESH_TOKEN

Examples found in repository

examples/basic_auth.rs (line 48)

async fn example_from_env() -> Result<(), Box<dyn std::error::Error>> {
    println!("Example 1: Load from Environment Variables");
    println!("-------------------------------------------");

    match SalesforceCredentials::from_env() {
        Ok(creds) => {
            println!("✓ Loaded credentials from environment");
            println!("  Instance URL: {}", creds.instance_url());
            println!("  API Version: {}", creds.api_version());
            println!("  Has Refresh Token: {}", creds.refresh_token().is_some());
        }
        Err(e) => {
            println!("✗ Failed to load from environment: {}", e);
            println!("  Tip: Set SF_INSTANCE_URL and SF_ACCESS_TOKEN");
        }
    }

    println!();
    Ok(())
}

examples/bulk_operations.rs (line 290)

async fn get_credentials() -> Result<SalesforceCredentials, Box<dyn std::error::Error>> {
    if let Ok(creds) = SalesforceCredentials::from_sfdx_alias("default").await {
        println!("✓ Using credentials from Salesforce CLI\n");
        return Ok(creds);
    }

    match SalesforceCredentials::from_env() {
        Ok(creds) => {
            println!("✓ Using credentials from environment variables\n");
            Ok(creds)
        }
        Err(e) => {
            eprintln!("✗ Failed to load credentials: {}", e);
            eprintln!("\nPlease either:");
            eprintln!("  1. Authenticate with Salesforce CLI: sf org login web");
            eprintln!("  2. Set environment variables: SF_INSTANCE_URL, SF_ACCESS_TOKEN");
            Err(e.into())
        }
    }
}

examples/error_handling.rs (line 318)

async fn get_credentials() -> Result<SalesforceCredentials, Box<dyn std::error::Error>> {
    if let Ok(creds) = SalesforceCredentials::from_sfdx_alias("default").await {
        println!("✓ Using credentials from Salesforce CLI\n");
        return Ok(creds);
    }

    match SalesforceCredentials::from_env() {
        Ok(creds) => {
            println!("✓ Using credentials from environment variables\n");
            Ok(creds)
        }
        Err(e) => {
            eprintln!("✗ Failed to load credentials: {}", e);
            eprintln!("\nPlease either:");
            eprintln!("  1. Authenticate with Salesforce CLI: sf org login web");
            eprintln!("  2. Set environment variables: SF_INSTANCE_URL, SF_ACCESS_TOKEN");
            Err(e.into())
        }
    }
}

examples/queries.rs (line 432)

async fn get_credentials() -> Result<SalesforceCredentials, Box<dyn std::error::Error>> {
    if let Ok(creds) = SalesforceCredentials::from_sfdx_alias("default").await {
        println!("✓ Using credentials from Salesforce CLI\n");
        return Ok(creds);
    }

    match SalesforceCredentials::from_env() {
        Ok(creds) => {
            println!("✓ Using credentials from environment variables\n");
            Ok(creds)
        }
        Err(e) => {
            eprintln!("✗ Failed to load credentials: {}", e);
            eprintln!("\nPlease either:");
            eprintln!("  1. Authenticate with Salesforce CLI: sf org login web");
            eprintln!("  2. Set environment variables: SF_INSTANCE_URL, SF_ACCESS_TOKEN");
            Err(e.into())
        }
    }
}

examples/rest_crud.rs (line 303)

async fn get_credentials() -> Result<SalesforceCredentials, Box<dyn std::error::Error>> {
    // Try SFDX first
    if let Ok(creds) = SalesforceCredentials::from_sfdx_alias("default").await {
        println!("✓ Using credentials from Salesforce CLI\n");
        return Ok(creds);
    }

    // Fall back to environment variables
    match SalesforceCredentials::from_env() {
        Ok(creds) => {
            println!("✓ Using credentials from environment variables\n");
            Ok(creds)
        }
        Err(e) => {
            eprintln!("✗ Failed to load credentials: {}", e);
            eprintln!("\nPlease either:");
            eprintln!("  1. Authenticate with Salesforce CLI: sf org login web");
            eprintln!("  2. Set environment variables: SF_INSTANCE_URL, SF_ACCESS_TOKEN");
            Err(e.into())
        }
    }
}

pub async fn from_sfdx_alias( alias_or_username: &str, ) -> Result<SalesforceCredentials, Error>

Load credentials from SFDX CLI using an org alias or username.

Requires the sf CLI to be installed and the org to be authenticated.

Examples found in repository

examples/bulk_operations.rs (line 285)

async fn get_credentials() -> Result<SalesforceCredentials, Box<dyn std::error::Error>> {
    if let Ok(creds) = SalesforceCredentials::from_sfdx_alias("default").await {
        println!("✓ Using credentials from Salesforce CLI\n");
        return Ok(creds);
    }

    match SalesforceCredentials::from_env() {
        Ok(creds) => {
            println!("✓ Using credentials from environment variables\n");
            Ok(creds)
        }
        Err(e) => {
            eprintln!("✗ Failed to load credentials: {}", e);
            eprintln!("\nPlease either:");
            eprintln!("  1. Authenticate with Salesforce CLI: sf org login web");
            eprintln!("  2. Set environment variables: SF_INSTANCE_URL, SF_ACCESS_TOKEN");
            Err(e.into())
        }
    }
}

examples/error_handling.rs (line 313)

async fn get_credentials() -> Result<SalesforceCredentials, Box<dyn std::error::Error>> {
    if let Ok(creds) = SalesforceCredentials::from_sfdx_alias("default").await {
        println!("✓ Using credentials from Salesforce CLI\n");
        return Ok(creds);
    }

    match SalesforceCredentials::from_env() {
        Ok(creds) => {
            println!("✓ Using credentials from environment variables\n");
            Ok(creds)
        }
        Err(e) => {
            eprintln!("✗ Failed to load credentials: {}", e);
            eprintln!("\nPlease either:");
            eprintln!("  1. Authenticate with Salesforce CLI: sf org login web");
            eprintln!("  2. Set environment variables: SF_INSTANCE_URL, SF_ACCESS_TOKEN");
            Err(e.into())
        }
    }
}

examples/queries.rs (line 427)

async fn get_credentials() -> Result<SalesforceCredentials, Box<dyn std::error::Error>> {
    if let Ok(creds) = SalesforceCredentials::from_sfdx_alias("default").await {
        println!("✓ Using credentials from Salesforce CLI\n");
        return Ok(creds);
    }

    match SalesforceCredentials::from_env() {
        Ok(creds) => {
            println!("✓ Using credentials from environment variables\n");
            Ok(creds)
        }
        Err(e) => {
            eprintln!("✗ Failed to load credentials: {}", e);
            eprintln!("\nPlease either:");
            eprintln!("  1. Authenticate with Salesforce CLI: sf org login web");
            eprintln!("  2. Set environment variables: SF_INSTANCE_URL, SF_ACCESS_TOKEN");
            Err(e.into())
        }
    }
}

examples/basic_auth.rs (line 73)

async fn example_from_sfdx() -> Result<(), Box<dyn std::error::Error>> {
    println!("Example 2: Load from Salesforce CLI");
    println!("------------------------------------");

    // Try to load from default org
    match SalesforceCredentials::from_sfdx_alias("default").await {
        Ok(creds) => {
            println!("✓ Loaded credentials from SFDX CLI");
            println!("  Instance URL: {}", creds.instance_url());
            println!("  API Version: {}", creds.api_version());
        }
        Err(e) => {
            println!("✗ Failed to load from SFDX: {}", e);
            println!("  Tip: Run 'sf org login web' or 'sf org login jwt'");
            println!("  Or specify an alias: SalesforceCredentials::from_sfdx_alias(\"my-org\")");
        }
    }

    println!();
    Ok(())
}

examples/rest_crud.rs (line 297)

async fn get_credentials() -> Result<SalesforceCredentials, Box<dyn std::error::Error>> {
    // Try SFDX first
    if let Ok(creds) = SalesforceCredentials::from_sfdx_alias("default").await {
        println!("✓ Using credentials from Salesforce CLI\n");
        return Ok(creds);
    }

    // Fall back to environment variables
    match SalesforceCredentials::from_env() {
        Ok(creds) => {
            println!("✓ Using credentials from environment variables\n");
            Ok(creds)
        }
        Err(e) => {
            eprintln!("✗ Failed to load credentials: {}", e);
            eprintln!("\nPlease either:");
            eprintln!("  1. Authenticate with Salesforce CLI: sf org login web");
            eprintln!("  2. Set environment variables: SF_INSTANCE_URL, SF_ACCESS_TOKEN");
            Err(e.into())
        }
    }
}

pub async fn from_sfdx_auth_url( auth_url: &str, ) -> Result<SalesforceCredentials, Error>

Load credentials from an SFDX auth URL.

The SFDX auth URL format is:

• force://<client_id>:<client_secret>:<refresh_token>@<instance_url>
• force://<client_id>::<refresh_token>@<instance_url> (empty client_secret)
• force://<client_id>:<client_secret>:<refresh_token>:<username>@<instance_url> (with username)

The client_secret can be empty (indicated by ::) for the default Salesforce CLI connected app. The username field is optional.

This method will parse the auth URL and use the refresh token to obtain an access token from Salesforce.

Example

let auth_url = std::env::var("SF_AUTH_URL")?;
let creds = SalesforceCredentials::from_sfdx_auth_url(&auth_url).await?;

Examples found in repository

examples/test_sf_auth_url.rs (line 13)

async fn main() {
    let auth_url = std::env::var("SF_AUTH_URL").expect("SF_AUTH_URL must be set");

    println!("Testing SF_AUTH_URL authentication...");

    match SalesforceCredentials::from_sfdx_auth_url(&auth_url).await {
        Ok(creds) => {
            println!("✓ Successfully authenticated!");
            println!("Instance URL: {}", creds.instance_url());
            println!("API Version: {}", creds.api_version());
            println!("Access token length: {}", creds.access_token().len());
        }
        Err(e) => {
            eprintln!("✗ Authentication failed: {:?}", e);
            eprintln!("\nError details: {}", e);
            std::process::exit(1);
        }
    }
}

pub fn with_api_version( self, version: impl Into<String>, ) -> SalesforceCredentials

Change the API version.

pub fn rest_api_url(&self) -> String

Get the base REST API URL for this org.

Examples found in repository

examples/basic_auth.rs (line 129)

async fn example_oauth_refresh() -> Result<(), Box<dyn std::error::Error>> {
    println!("Example 3: OAuth 2.0 Refresh Token");
    println!("-----------------------------------");

    // Configuration from environment or hardcoded for example
    let consumer_key =
        std::env::var("SF_CONSUMER_KEY").unwrap_or_else(|_| "your_consumer_key".to_string());
    let consumer_secret = std::env::var("SF_CONSUMER_SECRET").ok();
    let refresh_token =
        std::env::var("SF_REFRESH_TOKEN").unwrap_or_else(|_| "your_refresh_token".to_string());

    if consumer_key == "your_consumer_key" {
        println!("✗ OAuth not configured");
        println!("  Tip: Set SF_CONSUMER_KEY and SF_REFRESH_TOKEN");
        println!();
        return Ok(());
    }

    let mut config = OAuthConfig::new(consumer_key);
    if let Some(secret) = consumer_secret {
        config = config.with_secret(secret);
    }

    let oauth = OAuthClient::new(config);

    match oauth
        .refresh_token(&refresh_token, "https://login.salesforce.com")
        .await
    {
        Ok(token_response) => {
            println!("✓ Successfully refreshed access token");
            println!("  Instance URL: {}", token_response.instance_url);
            println!("  Token Type: {:?}", token_response.token_type);

            // Convert to credentials
            let creds = token_response.to_credentials("62.0");
            println!("  API URL: {}", creds.rest_api_url());
        }
        Err(e) => {
            println!("✗ Failed to refresh token: {}", e);
        }
    }

    println!();
    Ok(())
}

pub fn tooling_api_url(&self) -> String

Get the Tooling API URL for this org.

pub fn metadata_api_url(&self) -> String

Get the Metadata API URL for this org.

pub fn bulk_api_url(&self) -> String

Get the Bulk API 2.0 URL for this org.

Trait Implementations

impl Clone for SalesforceCredentials

fn clone(&self) -> SalesforceCredentials

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Credentials for SalesforceCredentials

fn instance_url(&self) -> &str

Get the Salesforce instance URL.

fn access_token(&self) -> &str

Get the access token.

fn api_version(&self) -> &str

Get the API version (e.g., “62.0”).

fn is_valid(&self) -> bool

Returns true if the credentials appear to be valid (non-empty).

impl Debug for SalesforceCredentials

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.