Function poll_create_token

crates/chat-cli/src/auth/builder_id.rs:530–593

Poll for the create token response

(
    database: &Database,
    device_code: String,
    start_url: Option<String>,
    region: Option<String>,
    telemetry: &crate::telemetry::TelemetryThread,
)

/// Poll for the create token response
pub async fn poll_create_token(
    database: &Database,
    device_code: String,
    start_url: Option<String>,
    region: Option<String>,
    telemetry: &crate::telemetry::TelemetryThread,
) -> PollCreateToken {
    let region = region.clone().map_or(OIDC_BUILDER_ID_REGION, Region::new);
    let client = client(region.clone());

    let DeviceRegistration {
        client_id,
        client_secret,
        scopes,
        ..
    } = match DeviceRegistration::init_device_code_registration(database, &client, &region).await {
        Ok(res) => res,
        Err(err) => {
            return PollCreateToken::Error(err);
        },
    };

    match client
        .create_token()
        .grant_type(DEVICE_GRANT_TYPE)
        .device_code(device_code)
        .client_id(client_id)
        .client_secret(client_secret.0)
        .send()
        .await
    {
        Ok(output) => {
            let token: BuilderIdToken =
                BuilderIdToken::from_output(output, region, start_url, OAuthFlow::DeviceCode, scopes);

            if let Err(err) = token.save(database).await {
                error!(?err, "Failed to store builder id token");
            };

            PollCreateToken::Complete
        },
        Err(SdkError::ServiceError(service_error)) if service_error.err().is_authorization_pending_exception() => {
            PollCreateToken::Pending
        },
        Err(err) => {
            error!(?err, "Failed to poll for builder id token");

            // Send telemetry for device code failure
            let auth_method = match TokenType::from(start_url.as_deref()) {
                TokenType::BuilderId => "BuilderId",
                TokenType::IamIdentityCenter => "IdentityCenter",
            };
            let error_code = match &err {
                SdkError::ServiceError(service_err) => service_err.err().meta().code().map(|s| s.to_string()),
                _ => None,
            };
            telemetry
                .send_auth_failed(auth_method, "DeviceCode", "NewLogin", error_code)