More code review fixed

Author: zaychenko-sergei

docs/internal/resources-framework.md

@@ -333,7 +333,7 @@ Generic, `R`-parameterized contracts in `use_cases/`: `ApplyResourceUseCase<R>`
 ```rust
 pub struct ResourceManifest {
     #[serde(rename = "$schema")]
-    pub schema: String,                      // required — canonical schema URL
+    pub schema: ResourceSchemaId,            // required — canonical schema URL
     pub headers: ResourceManifestHeaders,
     pub spec: serde_json::Value,             // desired state; kind-specific shape
 }

src/adapter/graphql/src/queries/resources/models.rs

@@ -56,8 +56,8 @@ pub struct ResourceAccountSelectorInput {
 }
 
 impl ResourceAccountSelectorInput {
-    pub fn into_manifest_account(self) -> kamu_resources::ResourceManifestAccount {
-        kamu_resources::ResourceManifestAccount {
+    pub fn into_manifest_account(self) -> kamu_resources::ResourceAccountRef {
+        kamu_resources::ResourceAccountRef {
             id: self.by_id.map(Into::into),
             name: self.by_name.map(|name| name.to_string()),
         }

src/app/cli/src/commands/apply_command.rs

@@ -726,7 +726,7 @@ impl ApplyPrinter<'_> {
             "{}: {} -> {}/{}",
             style,
             source,
-            kamu_resources::ResourceSchema::display_name(&result.resource.schema),
+            kamu_resources::ResourceSchemaId::display_name(&result.resource.schema),
             result.resource.headers.name
         )
     }

src/app/cli/src/error.rs

@@ -461,14 +461,16 @@ impl From<ResourceLookupProblem> for ResourceLookupCliError {
         match problem {
             ResourceLookupProblem::IDNotFound(err) => Self::IDNotFound(err.0),
             ResourceLookupProblem::NameNotFound(err) => Self::NameNotFound {
-                kind: kamu_resources::ResourceSchema::display_name(&err.kind).to_string(),
+                kind: kamu_resources::ResourceSchemaId::display_name(&err.kind).to_string(),
                 name: err.name,
             },
             ResourceLookupProblem::SchemaMismatch(err) => Self::SchemaMismatch {
                 id: err.id,
-                expected_schema: kamu_resources::ResourceSchema::display_name(&err.expected_schema)
-                    .to_string(),
-                actual_schema: kamu_resources::ResourceSchema::display_name(&err.actual_schema)
+                expected_schema: kamu_resources::ResourceSchemaId::display_name(
+                    &err.expected_schema,
+                )
+                .to_string(),
+                actual_schema: kamu_resources::ResourceSchemaId::display_name(&err.actual_schema)
                     .to_string(),
             },
         }

src/domain/resources/domain/src/manifests/resource_manifest.rs

@@ -13,15 +13,15 @@ use serde::de::{MapAccess, SeqAccess, Visitor};
 use serde::ser::SerializeMap;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-use crate::{ResourceID, ResourceName};
+use crate::{ResourceID, ResourceName, ResourceSchemaId};
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct ResourceManifest {
     #[serde(rename = "$schema")]
-    pub schema: String,
+    pub schema: ResourceSchemaId,
     pub headers: ResourceManifestHeaders,
     pub spec: serde_json::Value,
 }
@@ -32,7 +32,7 @@ pub struct ResourceManifest {
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct ResourceManifestHeaders {
     pub id: Option<ResourceID>,
-    pub account: Option<ResourceManifestAccount>,
+    pub account: Option<ResourceAccountRef>,
     pub name: ResourceName,
     pub description: Option<String>,
     #[serde(
@@ -53,7 +53,7 @@ pub struct ResourceManifestHeaders {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub struct ResourceManifestAccount {
+pub struct ResourceAccountRef {
     pub name: Option<String>,
     pub id: Option<odf::AccountID>,
 }

src/domain/resources/domain/src/values/mod.rs

@@ -12,13 +12,13 @@ mod resource_headers;
 mod resource_headers_input;
 mod resource_id;
 mod resource_phase;
-mod resource_schema;
+mod resource_schema_id;
 mod resource_warning;
 
 pub use resource_condition::*;
 pub use resource_headers::*;
 pub use resource_headers_input::*;
 pub use resource_id::*;
 pub use resource_phase::*;
-pub use resource_schema::*;
+pub use resource_schema_id::*;
 pub use resource_warning::*;

…ces/domain/src/values/resource_schema.rs …/domain/src/values/resource_schema_id.rssrc/domain/resources/domain/src/values/resource_schema.rs renamed to src/domain/resources/domain/src/values/resource_schema_id.rs src/domain/resources/domain/src/values/resource_schema.rs renamed to src/domain/resources/domain/src/values/resource_schema_id.rs

@@ -15,15 +15,15 @@ use url::Url;
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ResourceSchema {
+pub struct ResourceSchemaId {
     schema: String,
     base: String,
     context: String,
     version: String,
     name: String,
 }
 
-impl ResourceSchema {
+impl ResourceSchemaId {
     pub fn parse(schema: &str) -> Result<Self, ParseResourceSchemaError> {
         if schema.trim() != schema || schema.is_empty() {
             return Err(ParseResourceSchemaError::new(schema));
@@ -104,21 +104,21 @@ impl ResourceSchema {
     }
 }
 
-impl std::fmt::Display for ResourceSchema {
+impl std::fmt::Display for ResourceSchemaId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(&self.schema)
     }
 }
 
-impl FromStr for ResourceSchema {
+impl FromStr for ResourceSchemaId {
     type Err = ParseResourceSchemaError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         Self::parse(s)
     }
 }
 
-impl Serialize for ResourceSchema {
+impl Serialize for ResourceSchemaId {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -127,7 +127,7 @@ impl Serialize for ResourceSchema {
     }
 }
 
-impl<'de> Deserialize<'de> for ResourceSchema {
+impl<'de> Deserialize<'de> for ResourceSchemaId {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
@@ -147,9 +147,10 @@ mod tests {
 
     #[test]
     fn parses_schema_with_path_base() {
-        let schema =
-            ResourceSchema::parse("https://opendatafabric.org/schemas/config/v1alpha1/VariableSet")
-                .unwrap();
+        let schema = ResourceSchemaId::parse(
+            "https://opendatafabric.org/schemas/config/v1alpha1/VariableSet",
+        )
+        .unwrap();
 
         assert_eq!(
             schema.as_str(),
@@ -166,7 +167,7 @@ mod tests {
     #[test]
     fn parses_schema_with_host_only_base() {
         let schema =
-            ResourceSchema::parse("https://schemas.partner.org/billing/v1/Invoice").unwrap();
+            ResourceSchemaId::parse("https://schemas.partner.org/billing/v1/Invoice").unwrap();
 
         assert_eq!(
             schema.as_str(),
@@ -195,7 +196,7 @@ mod tests {
             "https://schemas.partner.org/billing//v1/Invoice",
         ] {
             assert!(
-                ResourceSchema::parse(invalid_schema).is_err(),
+                ResourceSchemaId::parse(invalid_schema).is_err(),
                 "schema should be rejected: {invalid_schema}"
             );
         }

src/domain/resources/facade-tests/tests/contract/account_scoping.rs

@@ -8,7 +8,7 @@
 // by the Apache License, Version 2.0.
 
 use database_common::PaginationOpts;
-use kamu_resources::{ResourceID, ResourceManifestAccount};
+use kamu_resources::{ResourceAccountRef, ResourceID};
 use kamu_resources_facade::{
     ApplyManifestError,
     ApplyManifestRequest,
@@ -59,7 +59,7 @@ async fn create_with_account_selector(
     h: &impl FacadeContractHarness,
     facade_account: TestAccount,
     name: &str,
-    selector: ResourceManifestAccount,
+    selector: ResourceAccountRef,
 ) -> ResourceID {
     apply_manifest_and_get_id(
         h,
@@ -69,10 +69,7 @@ async fn create_with_account_selector(
     .await
 }
 
-fn variable_set_manifest_json_with_account(
-    name: &str,
-    account: &ResourceManifestAccount,
-) -> String {
+fn variable_set_manifest_json_with_account(name: &str, account: &ResourceAccountRef) -> String {
     let mut account_fields = Vec::new();
     if let Some(n) = &account.name {
         account_fields.push(format!(r#""name": "{n}""#));
@@ -98,42 +95,42 @@ fn variable_set_manifest_json_with_account(
     )
 }
 
-fn account_by_name(name: &odf::AccountName) -> ResourceManifestAccount {
-    ResourceManifestAccount {
+fn account_by_name(name: &odf::AccountName) -> ResourceAccountRef {
+    ResourceAccountRef {
         name: Some(name.to_string()),
         id: None,
     }
 }
 
-fn account_by_id(id: odf::AccountID) -> ResourceManifestAccount {
-    ResourceManifestAccount {
+fn account_by_id(id: odf::AccountID) -> ResourceAccountRef {
+    ResourceAccountRef {
         name: None,
         id: Some(id),
     }
 }
 
-fn account_by_name_and_id(name: &odf::AccountName, id: odf::AccountID) -> ResourceManifestAccount {
-    ResourceManifestAccount {
+fn account_by_name_and_id(name: &odf::AccountName, id: odf::AccountID) -> ResourceAccountRef {
+    ResourceAccountRef {
         name: Some(name.to_string()),
         id: Some(id),
     }
 }
 
-fn unknown_account_by_name() -> ResourceManifestAccount {
-    ResourceManifestAccount {
+fn unknown_account_by_name() -> ResourceAccountRef {
+    ResourceAccountRef {
         name: Some("unknown-resource-contract-account".to_string()),
         id: None,
     }
 }
 
-fn unknown_account_by_id() -> ResourceManifestAccount {
-    ResourceManifestAccount {
+fn unknown_account_by_id() -> ResourceAccountRef {
+    ResourceAccountRef {
         name: None,
         id: Some(odf::AccountID::new_generated_ed25519().1),
     }
 }
 
-fn selector_by_name(name: &str, account: Option<ResourceManifestAccount>) -> ResourceSelector {
+fn selector_by_name(name: &str, account: Option<ResourceAccountRef>) -> ResourceSelector {
     ResourceSelector {
         account,
         kind: VARIABLE_SET_KIND.to_string(),
@@ -143,7 +140,7 @@ fn selector_by_name(name: &str, account: Option<ResourceManifestAccount>) -> Res
 
 fn batch_selector_by_name(
     name: &str,
-    account: Option<ResourceManifestAccount>,
+    account: Option<ResourceAccountRef>,
 ) -> ResourceBatchSelector {
     ResourceBatchSelector {
         account,

src/domain/resources/facade-tests/tests/contract/batch_ops.rs

@@ -7,7 +7,7 @@
 // the Business Source License, use of this software will be governed
 // by the Apache License, Version 2.0.
 
-use kamu_resources::{ApplyResourceOutcome, ResourceManifestAccount};
+use kamu_resources::{ApplyResourceOutcome, ResourceAccountRef};
 use kamu_resources_facade::{
     ApplyManifestRequest,
     BatchResourceError,
@@ -241,7 +241,7 @@ pub async fn test_get_many_empty_refs_validates_bad_account(h: &impl FacadeContr
     let result = facade
         .get_many(
             ResourceBatchSelector {
-                account: Some(ResourceManifestAccount {
+                account: Some(ResourceAccountRef {
                     name: Some("unknown-resource-contract-account".to_string()),
                     id: None,
                 }),
@@ -270,7 +270,7 @@ contract_test!(
 pub async fn test_batch_empty_refs_validation_is_consistent(h: &impl FacadeContractHarness) {
     let facade = h.facade_for(TestAccount::Alice);
     let bad_kind = "NoSuchResourceKindXYZ";
-    let bad_account = Some(ResourceManifestAccount {
+    let bad_account = Some(ResourceAccountRef {
         name: Some("unknown-resource-contract-account".to_string()),
         id: None,
     });

src/domain/resources/facade-tests/tests/contract/error_taxonomy.rs

@@ -16,7 +16,7 @@
 //! account-accepting API (not demoted to internal errors).
 
 use database_common::PaginationOpts;
-use kamu_resources::{ApplyResourceOutcome, ResourceManifestAccount};
+use kamu_resources::{ApplyResourceOutcome, ResourceAccountRef};
 use kamu_resources_facade::{
     ApplyManifestError,
     ApplyManifestRequest,
@@ -343,7 +343,7 @@ contract_test!(bad_account_taxonomy, super::test_bad_account_taxonomy);
 pub async fn test_bad_account_taxonomy(h: &impl FacadeContractHarness) {
     let facade = h.facade_for(TestAccount::Alice);
 
-    let unknown_account = ResourceManifestAccount {
+    let unknown_account = ResourceAccountRef {
         name: Some("unknown-resource-contract-account".to_string()),
         id: None,
     };