horizon-sdk 9.0.0

use chrono::Utc;
use tracing::debug;
use uuid::Uuid;

use crate::postgres::retry::{RetryPolicy, retry};
use crate::types::error::Result;
use crate::types::model::PlatformKind;

use super::PostgresRepository;

impl PostgresRepository {
    /// Delete a platform kind by ID. Returns the number of rows removed.
    pub async fn delete_platform_kind(&self, id: Uuid) -> Result<u64> {
        let result = sqlx::query!("DELETE FROM horizon_public.platform_kind WHERE id = $1", id)
            .execute(&self.pool)
            .await?;
        Ok(result.rows_affected())
    }

    /// Create a new platform kind.
    pub async fn insert_platform_kind(&self, platform_kind: &PlatformKind) -> Result<PlatformKind> {
        let now = Utc::now();
        let org = self.organization_id.or(platform_kind.organization_id);
        Ok(sqlx::query_as!(
            PlatformKind,
            r#"
            INSERT INTO horizon_public.platform_kind
                (id, name, image_url, short_description, long_description,
                 organization_id, modified_datetime)
            VALUES (COALESCE($1, gen_random_uuid()), $2, $3, $4, $5, $6, $7)
            RETURNING id, created_datetime, modified_datetime, name, image_url,
                      short_description, long_description, organization_id
            "#,
            platform_kind.id,
            platform_kind.name,
            platform_kind.image_url,
            platform_kind.short_description,
            platform_kind.long_description,
            org,
            now,
        )
        .fetch_one(&self.pool)
        .await?)
    }

    /// Create a batch of platform kinds in a single multi-row INSERT.
    ///
    /// Per-column slices are passed to `PostgreSQL` `UNNEST(...)` so the
    /// entire batch becomes one SQL statement and one network round-trip.
    /// Missing IDs are filled by `gen_random_uuid()` server-side, and
    /// `modified_datetime` is set to the same `now()` value for every
    /// row.
    ///
    /// Returns the inserted rows in input order. Wraps the statement in
    /// a transaction so a per-row failure rolls back the entire batch.
    #[allow(
        clippy::as_conversions,
        reason = "sqlx::query_as! requires `&Vec<T> as &[T]` ascription to bind a nullable Postgres array; conversion direction is unambiguous (same element type)"
    )]
    pub async fn insert_platform_kind_batch(
        &self,
        platform_kinds: &[PlatformKind],
    ) -> Result<Vec<PlatformKind>> {
        if platform_kinds.is_empty() {
            return Ok(Vec::new());
        }
        let now = Utc::now();
        let ids: Vec<Option<Uuid>> = platform_kinds
            .iter()
            .map(|platform_kind| platform_kind.id)
            .collect();
        let names: Vec<Option<String>> = platform_kinds
            .iter()
            .map(|platform_kind| platform_kind.name.clone())
            .collect();
        let image_urls: Vec<Option<String>> = platform_kinds
            .iter()
            .map(|platform_kind| platform_kind.image_url.clone())
            .collect();
        let short_descriptions: Vec<Option<String>> = platform_kinds
            .iter()
            .map(|platform_kind| platform_kind.short_description.clone())
            .collect();
        let long_descriptions: Vec<Option<String>> = platform_kinds
            .iter()
            .map(|platform_kind| platform_kind.long_description.clone())
            .collect();
        let orgs: Vec<Option<Uuid>> = platform_kinds
            .iter()
            .map(|platform_kind| self.organization_id.or(platform_kind.organization_id))
            .collect();
        let mut tx = self.pool.begin().await?;
        let rows = sqlx::query_as!(
            PlatformKind,
            r#"
            WITH source AS (
                SELECT
                    COALESCE(id, gen_random_uuid()) AS id,
                    name, image_url, short_description, long_description,
                    organization_id, ord
                FROM UNNEST(
                    $1::uuid[], $2::text[], $3::text[], $4::text[], $5::text[], $6::uuid[]
                ) WITH ORDINALITY
                    AS batch(id, name, image_url, short_description, long_description,
                             organization_id, ord)
            ),
            inserted AS (
                INSERT INTO horizon_public.platform_kind
                    (id, name, image_url, short_description, long_description,
                     organization_id, modified_datetime)
                SELECT
                    id, name, image_url, short_description, long_description,
                    organization_id, $7
                FROM source
                RETURNING id, created_datetime, modified_datetime, name, image_url,
                          short_description, long_description, organization_id
            )
            SELECT inserted.id, inserted.created_datetime, inserted.modified_datetime,
                   inserted.name, inserted.image_url, inserted.short_description,
                   inserted.long_description, inserted.organization_id
            FROM inserted
            JOIN source ON source.id = inserted.id
            ORDER BY source.ord
            "#,
            &ids as &[Option<Uuid>],
            &names as &[Option<String>],
            &image_urls as &[Option<String>],
            &short_descriptions as &[Option<String>],
            &long_descriptions as &[Option<String>],
            &orgs as &[Option<Uuid>],
            now,
        )
        .fetch_all(&mut *tx)
        .await?;
        tx.commit().await?;
        debug!(batch_size = rows.len(), "insert_platform_kind_batch");
        Ok(rows)
    }

    /// List all platform kind records. Retried under the default [`RetryPolicy`] on
    /// transient Postgres errors; reads are naturally idempotent.
    pub async fn list_platform_kinds(&self) -> Result<Vec<PlatformKind>> {
        retry(RetryPolicy::default(), || async move {
            Ok(sqlx::query_as!(
                PlatformKind,
                r#"
                SELECT id, created_datetime, modified_datetime, name, image_url,
                       short_description, long_description, organization_id
                FROM horizon_public.platform_kind
                "#,
            )
            .fetch_all(&self.pool)
            .await?)
        })
        .await
    }

    /// Read a platform kind by ID. Retried under the default [`RetryPolicy`] on transient
    /// Postgres errors; reads are naturally idempotent.
    pub async fn read_platform_kind(&self, id: Uuid) -> Result<Option<PlatformKind>> {
        retry(RetryPolicy::default(), || async move {
            Ok(sqlx::query_as!(
                PlatformKind,
                r#"
                SELECT id, created_datetime, modified_datetime, name, image_url,
                       short_description, long_description, organization_id
                FROM horizon_public.platform_kind WHERE id = $1
                "#,
                id,
            )
            .fetch_optional(&self.pool)
            .await?)
        })
        .await
    }
}