horizon-sdk 9.0.0

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

use crate::types::error::{HorizonError, PostgresError, Result};
use crate::types::model::OntologyClass;

use super::PostgresRepository;

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

    /// Create an ontology class.
    pub async fn insert_ontology_class(
        &self,
        ontology_class: &OntologyClass,
    ) -> Result<OntologyClass> {
        let now = Utc::now();
        let org = self.organization_id.or(ontology_class.organization_id);
        Ok(sqlx::query_as!(
            OntologyClass,
            r#"
            INSERT INTO horizon_public.ontology_class
                (id, ontology_id, parent_id, name, description,
                 "order", organization_id, relationship_type, modified_datetime)
            VALUES (COALESCE($1, gen_random_uuid()), $2, $3, $4, $5, $6, $7, $8, $9)
            RETURNING id, created_datetime, modified_datetime, ontology_id,
                      parent_id, name, description, "order",
                      organization_id, relationship_type
            "#,
            ontology_class.id,
            ontology_class.ontology_id,
            ontology_class.parent_id,
            ontology_class.name,
            ontology_class.description,
            ontology_class.order,
            org,
            ontology_class.relationship_type,
            now,
        )
        .fetch_one(&self.pool)
        .await?)
    }

    /// Create a batch of ontology classes 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_ontology_class_batch(
        &self,
        ontology_classes: &[OntologyClass],
    ) -> Result<Vec<OntologyClass>> {
        if ontology_classes.is_empty() {
            return Ok(Vec::new());
        }
        let now = Utc::now();
        let ids: Vec<Option<Uuid>> = ontology_classes
            .iter()
            .map(|ontology_class| ontology_class.id)
            .collect();
        let ontology_ids: Vec<Uuid> = ontology_classes
            .iter()
            .map(|ontology_class| ontology_class.ontology_id)
            .collect();
        let parent_ids: Vec<Option<Uuid>> = ontology_classes
            .iter()
            .map(|ontology_class| ontology_class.parent_id)
            .collect();
        let names: Vec<Option<String>> = ontology_classes
            .iter()
            .map(|ontology_class| ontology_class.name.clone())
            .collect();
        let descriptions: Vec<Option<String>> = ontology_classes
            .iter()
            .map(|ontology_class| ontology_class.description.clone())
            .collect();
        let orders: Vec<Option<i32>> = ontology_classes
            .iter()
            .map(|ontology_class| ontology_class.order)
            .collect();
        let orgs: Vec<Option<Uuid>> = ontology_classes
            .iter()
            .map(|ontology_class| self.organization_id.or(ontology_class.organization_id))
            .collect();
        let relationship_types: Vec<Option<String>> = ontology_classes
            .iter()
            .map(|ontology_class| ontology_class.relationship_type.clone())
            .collect();
        let mut tx = self.pool.begin().await?;
        let rows = sqlx::query_as!(
            OntologyClass,
            r#"
            WITH source AS (
                SELECT
                    COALESCE(id, gen_random_uuid()) AS id,
                    ontology_id, parent_id, name, description,
                    "order", organization_id, relationship_type, ord
                FROM UNNEST(
                    $1::uuid[], $2::uuid[], $3::uuid[], $4::text[], $5::text[],
                    $6::integer[], $7::uuid[], $8::text[]
                ) WITH ORDINALITY
                    AS batch(id, ontology_id, parent_id, name, description,
                             "order", organization_id, relationship_type, ord)
            ),
            inserted AS (
                INSERT INTO horizon_public.ontology_class
                    (id, ontology_id, parent_id, name, description,
                     "order", organization_id, relationship_type, modified_datetime)
                SELECT
                    id, ontology_id, parent_id, name, description,
                    "order", organization_id, relationship_type, $9
                FROM source
                RETURNING id, created_datetime, modified_datetime, ontology_id,
                          parent_id, name, description, "order",
                          organization_id, relationship_type
            )
            SELECT inserted.id, inserted.created_datetime, inserted.modified_datetime,
                   inserted.ontology_id, inserted.parent_id, inserted.name,
                   inserted.description, inserted."order", inserted.organization_id,
                   inserted.relationship_type
            FROM inserted
            JOIN source ON source.id = inserted.id
            ORDER BY source.ord
            "#,
            &ids as &[Option<Uuid>],
            &ontology_ids as &[Uuid],
            &parent_ids as &[Option<Uuid>],
            &names as &[Option<String>],
            &descriptions as &[Option<String>],
            &orders as &[Option<i32>],
            &orgs as &[Option<Uuid>],
            &relationship_types as &[Option<String>],
            now,
        )
        .fetch_all(&mut *tx)
        .await?;
        tx.commit().await?;
        debug!(batch_size = rows.len(), "insert_ontology_class_batch");
        Ok(rows)
    }

    /// List all ontology class records.
    pub async fn list_ontology_classes(&self) -> Result<Vec<OntologyClass>> {
        Ok(sqlx::query_as!(
            OntologyClass,
            r#"
            SELECT id, created_datetime, modified_datetime, ontology_id,
                   parent_id, name, description, "order",
                   organization_id, relationship_type
            FROM horizon_public.ontology_class
            "#,
        )
        .fetch_all(&self.pool)
        .await?)
    }

    /// Read an ontology class by ID.
    pub async fn read_ontology_class(&self, id: Uuid) -> Result<Option<OntologyClass>> {
        Ok(sqlx::query_as!(
            OntologyClass,
            r#"
            SELECT id, created_datetime, modified_datetime, ontology_id,
                   parent_id, name, description, "order",
                   organization_id, relationship_type
            FROM horizon_public.ontology_class WHERE id = $1
            "#,
            id,
        )
        .fetch_optional(&self.pool)
        .await?)
    }

    /// Update an existing ontology class by ID.
    ///
    /// Returns `HorizonError::Postgres(PostgresError::NotFound)` if no row
    /// with the given ID exists. Matches Python `BaseRepository.update()`
    /// semantics.
    pub async fn update_ontology_class(
        &self,
        ontology_class: &OntologyClass,
    ) -> Result<OntologyClass> {
        let now = Utc::now();
        let org = self.organization_id.or(ontology_class.organization_id);
        let result = sqlx::query_as!(
            OntologyClass,
            r#"
            UPDATE horizon_public.ontology_class
            SET
                ontology_id = $2,
                parent_id = $3,
                name = $4,
                description = $5,
                "order" = $6,
                organization_id = $7,
                relationship_type = $8,
                modified_datetime = $9
            WHERE id = $1
            RETURNING id, created_datetime, modified_datetime, ontology_id,
                      parent_id, name, description, "order",
                      organization_id, relationship_type
            "#,
            ontology_class.id,
            ontology_class.ontology_id,
            ontology_class.parent_id,
            ontology_class.name,
            ontology_class.description,
            ontology_class.order,
            org,
            ontology_class.relationship_type,
            now,
        )
        .fetch_optional(&self.pool)
        .await?;

        result.ok_or_else(|| {
            HorizonError::Postgres(PostgresError::NotFound {
                entity: "ontology_class".to_owned(),
                id: ontology_class.id.into(),
            })
        })
    }

    /// Insert an ontology class or update it if a row with the same ID
    /// already exists. Sets `modified_datetime` to now and falls back to the
    /// repository's `organization_id` when the model does not provide one.
    pub async fn upsert_ontology_class(
        &self,
        ontology_class: &OntologyClass,
    ) -> Result<OntologyClass> {
        let now = Utc::now();
        let org = self.organization_id.or(ontology_class.organization_id);
        Ok(sqlx::query_as!(
            OntologyClass,
            r#"
            INSERT INTO horizon_public.ontology_class
                (id, ontology_id, parent_id, name, description,
                 "order", organization_id, relationship_type, modified_datetime)
            VALUES (COALESCE($1, gen_random_uuid()), $2, $3, $4, $5, $6, $7, $8, $9)
            ON CONFLICT (id) DO UPDATE SET
                ontology_id = EXCLUDED.ontology_id, parent_id = EXCLUDED.parent_id,
                name = EXCLUDED.name, description = EXCLUDED.description,
                "order" = EXCLUDED."order", organization_id = EXCLUDED.organization_id,
                relationship_type = EXCLUDED.relationship_type,
                modified_datetime = EXCLUDED.modified_datetime
            RETURNING id, created_datetime, modified_datetime, ontology_id,
                      parent_id, name, description, "order",
                      organization_id, relationship_type
            "#,
            ontology_class.id,
            ontology_class.ontology_id,
            ontology_class.parent_id,
            ontology_class.name,
            ontology_class.description,
            ontology_class.order,
            org,
            ontology_class.relationship_type,
            now,
        )
        .fetch_one(&self.pool)
        .await?)
    }
}