cgd 0.1.0-alpha.2

Official command-line interface for Coragrid source-linked private-market data infrastructure
Documentation
use crate::client::{
    ApiResponse, CallerResource, CompanyId, CompanyOfficerPage, CompanyPage, CompanyResource,
    CoragridClient, DocumentId, DocumentResource, Envelope, ResolutionResource,
    ResolveCompanyRequest, SearchCompaniesRequest,
};
use crate::error::CgdError;

#[derive(Debug)]
pub enum Effect {
    Search {
        generation: u64,
        request: SearchCompaniesRequest,
    },
    Resolve {
        generation: u64,
        request: ResolveCompanyRequest,
    },
    Company {
        generation: u64,
        company_id: CompanyId,
    },
    Officers {
        generation: u64,
        company_id: CompanyId,
        limit: u16,
    },
    Document {
        generation: u64,
        document_id: DocumentId,
    },
    Caller {
        generation: u64,
    },
}

impl Effect {
    pub fn set_generation(&mut self, value: u64) {
        match self {
            Self::Search { generation, .. }
            | Self::Resolve { generation, .. }
            | Self::Company { generation, .. }
            | Self::Officers { generation, .. }
            | Self::Document { generation, .. }
            | Self::Caller { generation } => *generation = value,
        }
    }

    pub const fn running_label(&self) -> &'static str {
        match self {
            Self::Search { .. } => "searching companies…",
            Self::Resolve { .. } => "resolving company…",
            Self::Company { .. } => "loading canonical company…",
            Self::Officers { .. } => "loading current officers…",
            Self::Document { .. } => "loading document metadata…",
            Self::Caller { .. } => "verifying authentication…",
        }
    }
}

#[derive(Debug)]
pub struct UiFailure {
    pub message: String,
    pub request_id: Option<String>,
}

impl From<CgdError> for UiFailure {
    fn from(error: CgdError) -> Self {
        Self {
            request_id: error.request_id().map(str::to_owned),
            message: error.to_string(),
        }
    }
}

#[derive(Debug)]
pub enum EffectResult {
    Search {
        generation: u64,
        response: Result<ApiResponse<CompanyPage>, UiFailure>,
    },
    Resolve {
        generation: u64,
        response: Result<ApiResponse<Envelope<ResolutionResource>>, UiFailure>,
    },
    Company {
        generation: u64,
        response: Result<ApiResponse<Envelope<CompanyResource>>, UiFailure>,
    },
    Officers {
        generation: u64,
        response: Result<ApiResponse<CompanyOfficerPage>, UiFailure>,
    },
    Document {
        generation: u64,
        response: Result<ApiResponse<Envelope<DocumentResource>>, UiFailure>,
    },
    Caller {
        generation: u64,
        response: Result<ApiResponse<Envelope<CallerResource>>, UiFailure>,
    },
}

impl EffectResult {
    pub const fn generation(&self) -> u64 {
        match self {
            Self::Search { generation, .. }
            | Self::Resolve { generation, .. }
            | Self::Company { generation, .. }
            | Self::Officers { generation, .. }
            | Self::Document { generation, .. }
            | Self::Caller { generation, .. } => *generation,
        }
    }

    pub fn request_id(&self) -> Option<&str> {
        match self {
            Self::Search {
                response: Ok(response),
                ..
            } => response.request_id.as_deref(),
            Self::Resolve {
                response: Ok(response),
                ..
            } => response.request_id.as_deref(),
            Self::Company {
                response: Ok(response),
                ..
            } => response.request_id.as_deref(),
            Self::Officers {
                response: Ok(response),
                ..
            } => response.request_id.as_deref(),
            Self::Document {
                response: Ok(response),
                ..
            } => response.request_id.as_deref(),
            Self::Caller {
                response: Ok(response),
                ..
            } => response.request_id.as_deref(),
            Self::Search {
                response: Err(error),
                ..
            }
            | Self::Resolve {
                response: Err(error),
                ..
            }
            | Self::Company {
                response: Err(error),
                ..
            }
            | Self::Officers {
                response: Err(error),
                ..
            }
            | Self::Document {
                response: Err(error),
                ..
            }
            | Self::Caller {
                response: Err(error),
                ..
            } => error.request_id.as_deref(),
        }
    }
}

pub async fn execute(client: CoragridClient, effect: Effect) -> EffectResult {
    match effect {
        Effect::Search {
            generation,
            request,
        } => EffectResult::Search {
            generation,
            response: client.search(&request).await.map_err(Into::into),
        },
        Effect::Resolve {
            generation,
            request,
        } => EffectResult::Resolve {
            generation,
            response: client.resolve(&request).await.map_err(Into::into),
        },
        Effect::Company {
            generation,
            company_id,
        } => EffectResult::Company {
            generation,
            response: client.get_company(&company_id).await.map_err(Into::into),
        },
        Effect::Officers {
            generation,
            company_id,
            limit,
        } => EffectResult::Officers {
            generation,
            response: client
                .get_company_officers(&company_id, limit)
                .await
                .map_err(Into::into),
        },
        Effect::Document {
            generation,
            document_id,
        } => EffectResult::Document {
            generation,
            response: client
                .get_document_metadata(&document_id)
                .await
                .map_err(Into::into),
        },
        Effect::Caller { generation } => EffectResult::Caller {
            generation,
            response: client.caller().await.map_err(Into::into),
        },
    }
}