store card as enum

Author: mschuwalow

golem-common/src/base_model/card/types.rs

@@ -63,6 +63,7 @@ pub struct Card {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "full", derive(desert_rust::BinaryCodec))]
 pub struct PolymorphicCard {
     pub card_id: CardId,
     pub parent_ids: Vec<CardId>,
@@ -75,6 +76,57 @@ pub struct PolymorphicCard {
     pub system_card: bool,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "full", derive(desert_rust::BinaryCodec))]
+pub enum StoredCard {
+    Concrete(Card),
+    Polymorphic(PolymorphicCard),
+}
+
+impl StoredCard {
+    pub fn card_id(&self) -> CardId {
+        match self {
+            Self::Concrete(card) => card.card_id,
+            Self::Polymorphic(card) => card.card_id,
+        }
+    }
+
+    pub fn parent_ids(&self) -> &[CardId] {
+        match self {
+            Self::Concrete(card) => &card.parent_ids,
+            Self::Polymorphic(card) => &card.parent_ids,
+        }
+    }
+
+    pub fn expires_at(&self) -> Option<DateTime<Utc>> {
+        match self {
+            Self::Concrete(card) => card.expires_at,
+            Self::Polymorphic(card) => card.expires_at,
+        }
+    }
+
+    pub fn system_card(&self) -> bool {
+        match self {
+            Self::Concrete(card) => card.system_card,
+            Self::Polymorphic(card) => card.system_card,
+        }
+    }
+
+    pub fn into_concrete(self) -> Result<Card, Self> {
+        match self {
+            Self::Concrete(card) => Ok(card),
+            other => Err(other),
+        }
+    }
+
+    pub fn into_polymorphic(self) -> Result<PolymorphicCard, Self> {
+        match self {
+            Self::Polymorphic(card) => Ok(card),
+            other => Err(other),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct PolymorphicManifestCard {
     pub card_id: CardId,

golem-registry-service/src/repo/card.rs

@@ -120,16 +120,16 @@ impl DbCardRepo<PostgresPool> {
     async fn insert_parent_links(
         tx: &mut PoolLabelledTransaction<PostgresPool>,
         card_id: Uuid,
-        parent_ids: &[Uuid],
+        parent_ids: &[CardId],
     ) -> Result<(), CardRepoError> {
         for parent_id in parent_ids {
             tx.execute(
                 sqlx::query("INSERT INTO card_parents (card_id, parent_id) VALUES ($1, $2)")
                     .bind(card_id)
-                    .bind(parent_id),
+                    .bind(parent_id.0),
             )
             .await
-            .to_error_on_foreign_key_violation(CardRepoError::ParentNotFound(*parent_id))?;
+            .to_error_on_foreign_key_violation(CardRepoError::ParentNotFound(parent_id.0))?;
         }
 
         Ok(())
@@ -248,7 +248,7 @@ impl DbCardRepo<PostgresPool> {
         tx: &mut PoolLabelledTransaction<PostgresPool>,
         record: CardRecord,
     ) -> Result<CardRecord, CardRepoError> {
-        Self::lock_parent_cards_for_create(tx, record.data.value().parent_ids.as_slice()).await?;
+        Self::lock_parent_cards_for_create(tx, record.data.value().parent_ids()).await?;
 
         let inserted: CardRecord = tx
             .fetch_one_as(
@@ -267,12 +267,7 @@ impl DbCardRepo<PostgresPool> {
             )
             .await?;
 
-        Self::insert_parent_links(
-            tx,
-            inserted.card_id,
-            inserted.data.value().parent_ids.as_slice(),
-        )
-        .await?;
+        Self::insert_parent_links(tx, inserted.card_id, inserted.data.value().parent_ids()).await?;
 
         Ok(inserted)
     }
@@ -281,18 +276,18 @@ impl DbCardRepo<PostgresPool> {
 impl DbCardRepo<PostgresPool> {
     async fn lock_parent_cards_for_create(
         tx: &mut PoolLabelledTransaction<PostgresPool>,
-        parent_ids: &[Uuid],
+        parent_ids: &[CardId],
     ) -> Result<(), CardRepoError> {
         for parent_id in parent_ids {
             let row = tx
                 .fetch_optional(
                     sqlx::query("SELECT card_id FROM cards WHERE card_id = $1 FOR UPDATE")
-                        .bind(*parent_id),
+                        .bind(parent_id.0),
                 )
                 .await?;
 
             if row.is_none() {
-                return Err(CardRepoError::ParentNotFound(*parent_id));
+                return Err(CardRepoError::ParentNotFound(parent_id.0));
             }
         }
 
@@ -303,7 +298,7 @@ impl DbCardRepo<PostgresPool> {
 impl DbCardRepo<SqlitePool> {
     async fn lock_parent_cards_for_create(
         _tx: &mut PoolLabelledTransaction<SqlitePool>,
-        _parent_ids: &[Uuid],
+        _parent_ids: &[CardId],
     ) -> RepoResult<()> {
         // SQLite serializes write transactions, so there is no separate row-locking
         // primitive to use here. Missing parents are rejected by the card_parents FK.

golem-registry-service/src/repo/model/card.rs

@@ -12,10 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use anyhow::anyhow;
 use chrono::{DateTime, Utc};
 use golem_common::error_forwarding;
 use golem_common::model::card::{
     Card, CardId, CardManagedBy, PermissionPattern, PolymorphicCard, PolymorphicPermissionPattern,
+    StoredCard,
 };
 use golem_service_base::repo::{Blob, RepoError, SqlDateTime};
 use sqlx::FromRow;
@@ -37,15 +39,13 @@ error_forwarding!(CardRepoError, RepoError);
 
 #[derive(Debug, Clone, PartialEq, Eq, desert_rust::BinaryCodec)]
 pub struct CardDataRecord {
-    pub parent_ids: Vec<Uuid>,
-    pub lower_positive: Vec<PermissionPattern>,
-    pub lower_negative: Vec<PermissionPattern>,
-    pub upper_positive: Vec<PermissionPattern>,
-    pub upper_negative: Vec<PermissionPattern>,
-    pub polymorphic_lower_positive: Vec<PolymorphicPermissionPattern>,
-    pub polymorphic_lower_negative: Vec<PolymorphicPermissionPattern>,
-    pub polymorphic_upper_positive: Vec<PolymorphicPermissionPattern>,
-    pub polymorphic_upper_negative: Vec<PolymorphicPermissionPattern>,
+    pub card: StoredCard,
+}
+
+impl CardDataRecord {
+    pub fn parent_ids(&self) -> &[CardId] {
+        self.card.parent_ids()
+    }
 }
 
 #[derive(FromRow, Debug, Clone, PartialEq)]
@@ -62,19 +62,10 @@ impl TryFrom<CardRecord> for Card {
     type Error = RepoError;
 
     fn try_from(value: CardRecord) -> Result<Self, Self::Error> {
-        let data = value.data.into_value();
-
-        Ok(Card {
-            card_id: CardId(value.card_id),
-            parent_ids: data.parent_ids.into_iter().map(CardId).collect(),
-            lower_positive: data.lower_positive,
-            lower_negative: data.lower_negative,
-            upper_positive: data.upper_positive,
-            upper_negative: data.upper_negative,
-            created_at: value.created_at.into(),
-            expires_at: value.expires_at.map(Into::into),
-            system_card: value.system_card,
-            managed_by: value.managed_by.map(Blob::into_value),
+        value.try_into_stored_card()?.into_concrete().map_err(|_| {
+            RepoError::InternalError(anyhow!(
+                "Cannot convert polymorphic card record to concrete card"
+            ))
         })
     }
 }
@@ -83,19 +74,22 @@ impl TryFrom<CardRecord> for PolymorphicCard {
     type Error = RepoError;
 
     fn try_from(value: CardRecord) -> Result<Self, Self::Error> {
-        let data = value.data.into_value();
-
-        Ok(PolymorphicCard {
-            card_id: CardId(value.card_id),
-            parent_ids: data.parent_ids.into_iter().map(CardId).collect(),
-            lower_positive: data.polymorphic_lower_positive,
-            lower_negative: data.polymorphic_lower_negative,
-            upper_positive: data.polymorphic_upper_positive,
-            upper_negative: data.polymorphic_upper_negative,
-            created_at: value.created_at.into(),
-            expires_at: value.expires_at.map(Into::into),
-            system_card: value.system_card,
-        })
+        value
+            .try_into_stored_card()?
+            .into_polymorphic()
+            .map_err(|_| {
+                RepoError::InternalError(anyhow!(
+                    "Cannot convert concrete card record to polymorphic card"
+                ))
+            })
+    }
+}
+
+impl TryFrom<CardRecord> for StoredCard {
+    type Error = RepoError;
+
+    fn try_from(value: CardRecord) -> Result<Self, Self::Error> {
+        value.try_into_stored_card()
     }
 }
 
@@ -111,23 +105,27 @@ impl CardRecord {
         system_card: bool,
         managed_by: Option<CardManagedBy>,
     ) -> Self {
+        let card = Card {
+            card_id,
+            parent_ids,
+            lower_positive,
+            lower_negative,
+            upper_positive,
+            upper_negative,
+            created_at: Utc::now(),
+            expires_at,
+            system_card,
+            managed_by,
+        };
         Self {
-            card_id: card_id.0,
+            card_id: card.card_id.0,
             data: Blob::new(CardDataRecord {
-                parent_ids: parent_ids.into_iter().map(|id| id.0).collect(),
-                lower_positive,
-                lower_negative,
-                upper_positive,
-                upper_negative,
-                polymorphic_lower_positive: Vec::new(),
-                polymorphic_lower_negative: Vec::new(),
-                polymorphic_upper_positive: Vec::new(),
-                polymorphic_upper_negative: Vec::new(),
+                card: StoredCard::Concrete(card.clone()),
             }),
-            created_at: SqlDateTime::now(),
-            expires_at: expires_at.map(Into::into),
-            system_card,
-            managed_by: managed_by.map(Blob::new),
+            created_at: card.created_at.into(),
+            expires_at: card.expires_at.map(Into::into),
+            system_card: card.system_card,
+            managed_by: card.managed_by.map(Blob::new),
         }
     }
 
@@ -142,25 +140,48 @@ impl CardRecord {
         system_card: bool,
         managed_by: Option<CardManagedBy>,
     ) -> Self {
+        let card = PolymorphicCard {
+            card_id,
+            parent_ids,
+            lower_positive,
+            lower_negative,
+            upper_positive,
+            upper_negative,
+            created_at: Utc::now(),
+            expires_at,
+            system_card,
+        };
         Self {
-            card_id: card_id.0,
+            card_id: card.card_id.0,
             data: Blob::new(CardDataRecord {
-                parent_ids: parent_ids.into_iter().map(|id| id.0).collect(),
-                lower_positive: Vec::new(),
-                lower_negative: Vec::new(),
-                upper_positive: Vec::new(),
-                upper_negative: Vec::new(),
-                polymorphic_lower_positive: lower_positive,
-                polymorphic_lower_negative: lower_negative,
-                polymorphic_upper_positive: upper_positive,
-                polymorphic_upper_negative: upper_negative,
+                card: StoredCard::Polymorphic(card.clone()),
             }),
-            created_at: SqlDateTime::now(),
-            expires_at: expires_at.map(Into::into),
-            system_card,
+            created_at: card.created_at.into(),
+            expires_at: card.expires_at.map(Into::into),
+            system_card: card.system_card,
             managed_by: managed_by.map(Blob::new),
         }
     }
+
+    fn try_into_stored_card(self) -> Result<StoredCard, RepoError> {
+        let mut card = self.data.into_value().card;
+        match &mut card {
+            StoredCard::Concrete(card) => {
+                card.card_id = CardId(self.card_id);
+                card.created_at = self.created_at.into();
+                card.expires_at = self.expires_at.map(Into::into);
+                card.system_card = self.system_card;
+                card.managed_by = self.managed_by.map(Blob::into_value);
+            }
+            StoredCard::Polymorphic(card) => {
+                card.card_id = CardId(self.card_id);
+                card.created_at = self.created_at.into();
+                card.expires_at = self.expires_at.map(Into::into);
+                card.system_card = self.system_card;
+            }
+        }
+        Ok(card)
+    }
 }
 
 #[cfg(test)]