use async_trait::async_trait;
#[derive(Clone)]
pub struct SlackAppCredentials {
pub app_id: String,
pub client_id: String,
pub client_secret: String,
pub signing_secret: String,
}
impl std::fmt::Debug for SlackAppCredentials {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_struct("SlackAppCredentials")
.field("app_id", &self.app_id)
.field("client_id", &self.client_id)
.field("client_secret", &"<redacted>")
.field("signing_secret", &"<redacted>")
.finish()
}
}
#[derive(Clone, serde::Serialize, serde::Deserialize)]
pub struct ProvisionedSlackApp {
pub app_id: String,
pub client_id: String,
pub client_secret: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub install_state: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub install_state_issued_at: Option<chrono::DateTime<chrono::Utc>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub team_id: Option<String>,
}
impl std::fmt::Debug for ProvisionedSlackApp {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_struct("ProvisionedSlackApp")
.field("app_id", &self.app_id)
.field("client_id", &self.client_id)
.field("client_secret", &"<redacted>")
.field(
"install_state",
&self.install_state.as_ref().map(|_| "<set>"),
)
.field("install_state_issued_at", &self.install_state_issued_at)
.field("team_id", &self.team_id)
.finish()
}
}
#[derive(Debug, thiserror::Error)]
pub enum SlackProvisioningError {
#[error("Slack app provisioning is not configured on this deployment")]
Unavailable,
#[error("This organization has not connected Slack app provisioning")]
OrgNotConnected,
#[error("This organization must reconnect Slack app provisioning")]
ReconnectRequired,
#[error("Choose which connected Slack workspace to use")]
WorkspaceRequired,
#[error("That Slack workspace is not connected to this organization")]
WorkspaceNotConnected,
#[error("Slack rejected the request: {0}")]
Rejected(String),
#[error("Could not reach Slack: {0}")]
Unreachable(String),
}
pub type SlackProvisioningResult<T> = Result<T, SlackProvisioningError>;
#[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct SlackProvisioningConnectionStatus {
pub connected: bool,
pub reconnect_required: bool,
}
#[async_trait]
pub trait SlackAppProvisioner: Send + Sync {
async fn create_app(
&self,
org_id: i64,
team_id: Option<&str>,
manifest_yaml: &str,
) -> SlackProvisioningResult<SlackAppCredentials>;
async fn delete_app(
&self,
org_id: i64,
team_id: Option<&str>,
app_id: &str,
) -> SlackProvisioningResult<()>;
fn deployment_supported(&self) -> bool {
true
}
async fn connection_status(
&self,
org_id: i64,
) -> SlackProvisioningResult<SlackProvisioningConnectionStatus>;
fn name(&self) -> &'static str {
"SlackAppProvisioner"
}
}
#[derive(Debug, Clone, Default)]
pub struct UnavailableSlackAppProvisioner;
#[async_trait]
impl SlackAppProvisioner for UnavailableSlackAppProvisioner {
async fn create_app(
&self,
_org_id: i64,
_team_id: Option<&str>,
_manifest_yaml: &str,
) -> SlackProvisioningResult<SlackAppCredentials> {
Err(SlackProvisioningError::Unavailable)
}
async fn delete_app(
&self,
_org_id: i64,
_team_id: Option<&str>,
_app_id: &str,
) -> SlackProvisioningResult<()> {
Err(SlackProvisioningError::Unavailable)
}
fn deployment_supported(&self) -> bool {
false
}
async fn connection_status(
&self,
_org_id: i64,
) -> SlackProvisioningResult<SlackProvisioningConnectionStatus> {
Ok(SlackProvisioningConnectionStatus::default())
}
fn name(&self) -> &'static str {
"UnavailableSlackAppProvisioner"
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn credentials_debug_redacts_every_secret() {
let rendered = format!(
"{:?}",
SlackAppCredentials {
app_id: "A0123".to_string(),
client_id: "4567.89".to_string(),
client_secret: "client-secret-value".to_string(),
signing_secret: "signing-secret-value".to_string(),
}
);
assert!(rendered.contains("A0123"), "{rendered}");
assert!(rendered.contains("4567.89"), "{rendered}");
assert!(!rendered.contains("client-secret-value"), "{rendered}");
assert!(!rendered.contains("signing-secret-value"), "{rendered}");
}
#[tokio::test]
async fn absent_provisioner_reports_unavailable_rather_than_failing() {
let provisioner = UnavailableSlackAppProvisioner;
assert!(!provisioner.deployment_supported());
assert_eq!(
provisioner.connection_status(1).await.expect("status"),
SlackProvisioningConnectionStatus::default()
);
assert!(matches!(
provisioner.create_app(1, None, "_meta: {}").await,
Err(SlackProvisioningError::Unavailable)
));
}
}