Retries, timeouts, and idempotency

import { Photon } from "@photon-ai/api";

const apiKey = process.env.PHOTON_API_KEY;
const organizationId = process.env.PHOTON_ORGANIZATION_ID;
if (!apiKey || !organizationId) {
  throw new Error("Set PHOTON_API_KEY and PHOTON_ORGANIZATION_ID");
}

const photon = new Photon({
  headers: { Authorization: `Bearer ${apiKey}` },
  timeoutMs: 10_000,
  retry: { maxAttempts: 2, maximumRetryAfterMs: 5_000 },
});

const controller = new AbortController();
const result = await photon.organizations.projects.count(
  { path: { organizationId } },
  { signal: controller.signal },
);
console.log(result.count);

import os

from photon_api import Photon
from photon_api.rpc_generated import CountProjectsInput

api_key = os.environ["PHOTON_API_KEY"]
organization_id = os.environ["PHOTON_ORGANIZATION_ID"]

with Photon(
    headers={"Authorization": f"Bearer {api_key}"},
    timeout=10.0,
    max_attempts=2,
    max_retry_after=5.0,
) as photon:
    result = photon.organizations.projects.count(
        CountProjectsInput.model_validate({"path": {"organizationId": organization_id}})
    )
    print(result.count)

use std::time::Duration;

use photon_ai_api::{Credential, PhotonClientBuilder, SecretString};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("PHOTON_API_KEY")?;
    let organization_id = std::env::var("PHOTON_ORGANIZATION_ID")?;

    let credential = Credential::Bearer(SecretString::from(api_key));
    let client = PhotonClientBuilder::new()
        .credential("accountServiceKey", credential)
        .timeout(Duration::from_secs(10))
        .max_attempts(2)
        .maximum_retry_after(Duration::from_secs(5))
        .build()?;

    let result = client
        .count_projects(organization_id, None)
        .await
        .map_err(|error| format!("{error:?}"))?;
    println!("{}", result.inner().count);
    Ok(())
}