flux-releaser/crates/flux-releaser/src/services/release_manager.rs

use serde::Serialize;

use crate::services::archive::{Archive, ArchiveFile};
use crate::services::artifacts_db::{AddCommitArtifact, GetLatestArtifact};
use crate::services::file_store::FileStore;

use super::artifacts_db::ArtifactsDB;
use super::domain_events::DomainEvents;
use super::git::SharedGit;

use self::models::*;

pub struct ReleaseManager {
    file_store: FileStore,
    domain_events: DomainEvents,
    artifacts_db: ArtifactsDB,
    git: SharedGit,
}

impl ReleaseManager {
    pub fn new(
        file_store: FileStore,
        domain_events: DomainEvents,
        artifacts_db: ArtifactsDB,
        git: SharedGit,
    ) -> Self {
        Self {
            file_store,
            domain_events,
            artifacts_db,
            git,
        }
    }

    pub async fn upload_artifact(
        &self,
        request: UploadArtifact,
    ) -> anyhow::Result<UploadArtifactID> {
        let upload_id = uuid::Uuid::now_v7();

        self.file_store
            .upload_temp(upload_id.into(), request.file_path)
            .await?;

        Ok(upload_id.into())
    }

    pub async fn commit_artifact(&self, request: CommitArtifact) -> anyhow::Result<ArtifactID> {
        tracing::debug!("committing artifact: {:?}", request);
        let artifact_id = ArtifactID::new();

        let artifact = self.file_store.get_temp(request.upload_id).await?;

        self.file_store
            .upload_file(artifact_id.clone(), artifact)
            .await?;

        self.domain_events
            .publish_event(&serde_json::to_string(&CommittedArtifactEvent {
                artifact_id: artifact_id.to_string(),
            })?)
            .await?;

        self.artifacts_db
            .commit_artifact(AddCommitArtifact {
                app: request.app,
                branch: request.branch,
                artifact_id: artifact_id.clone().into(),
            })
            .await?;

        Ok(artifact_id)
    }

    pub async fn release(&self, release_req: Release) -> anyhow::Result<()> {
        tracing::debug!(
            app = release_req.app,
            branch = release_req.branch,
            "releasing latest commit"
        );

        let latest_artifact = self
            .artifacts_db
            .get_latest_artifact(GetLatestArtifact {
                app: release_req.app.clone(),
                branch: release_req.branch.clone(),
            })
            .await?;

        tracing::trace!("found latest artifact: {:?}", latest_artifact);

        let artifact = self
            .file_store
            .get_archive(latest_artifact.artifact_id.into())
            .await?;

        tracing::trace!("placed artifact in: {}", artifact.display());

        self.domain_events
            .publish_event(&serde_json::to_string(&PublishedArtifactEvent {
                artifact_id: latest_artifact.artifact_id.to_string(),
                app: release_req.app.clone(),
                branch: release_req.branch.clone(),
            })?)
            .await?;

        let artifact_contents = tokio::fs::read(artifact).await?;
        let env = if release_req.branch == "main" {
            // FIXME: select prod instead
            "prod"
            //"dev"
        } else {
            "dev"
        };
        self.git
            .publish(
                &ArchiveFile::from(artifact_contents),
                &release_req.app,
                env,
                env,
            )
            .await?;

        Ok(())
    }
}

#[derive(Serialize)]
pub struct CommittedArtifactEvent {
    artifact_id: String,
}

#[derive(Serialize)]
pub struct PublishedArtifactEvent {
    app: String,
    branch: String,
    artifact_id: String,
}

pub mod extensions;
pub mod models;