celerity-runtime-sdk 0.2.0__tar.gz → 0.2.2__tar.gz

{celerity_runtime_sdk-0.2.0 → celerity_runtime_sdk-0.2.2}/Cargo.lock

@@ -971,7 +971,7 @@ dependencies = [
 
 [[package]]
 name = "celerity-python-runtime-sdk"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "async-trait",
  "axum 0.8.8",
@@ -1016,6 +1016,7 @@ dependencies = [
 name = "celerity_blueprint_config_parser"
 version = "0.1.0"
 dependencies = [
+ "celerity_blueprint_lang",
  "celerity_helpers",
  "hashlink",
  "insta",
@@ -1028,6 +1029,19 @@ dependencies = [
  "yaml-rust2",
 ]
 
+[[package]]
+name = "celerity_blueprint_lang"
+version = "0.1.0"
+dependencies = [
+ "hashlink",
+ "insta",
+ "pretty_assertions",
+ "serde",
+ "serde_json",
+ "test-log",
+ "tracing",
+]
+
 [[package]]
 name = "celerity_consumer_azure_events_hub"
 version = "0.1.0"
@@ -1943,6 +1957,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7"
 dependencies = [
  "hashbrown 0.14.5",
+ "serde",
 ]
 
 [[package]]

celerity_runtime_sdk-0.2.2/Cargo.toml

@@ -0,0 +1,5 @@
+[workspace]
+members = ["core", "helpers", "aws-helpers", "blueprint-config-parser", "blueprint-lang", "sdk/python", "consumers/consumer-sqs", "consumers/consumer-kinesis", "consumers/consumer-azure-events-hub", "consumers/consumer-redis", "consumers/consumer-gcloud-pubsub", "consumers/consumer-azure-service-bus", "consumers/consumer-gcloud-tasks", "ws/ws-registry"]
+
+[workspace.package]
+license = "Apache-2.0"

{celerity_runtime_sdk-0.2.0 → celerity_runtime_sdk-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celerity-runtime-sdk
-Version: 0.2.0
+Version: 0.2.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{celerity_runtime_sdk-0.2.0 → celerity_runtime_sdk-0.2.2}/blueprint-config-parser/Cargo.toml

@@ -16,6 +16,9 @@ json-strip-comments = "1.0.4"
 [dependencies.celerity_helpers]
 path = "../helpers"
 
+[dependencies.celerity_blueprint_lang]
+path = "../blueprint-lang"
+
 [dev-dependencies]
 test-log = { version = "0.2.16", features = ["log", "trace"] }
 pretty_assertions = "1.4.0"

{celerity_runtime_sdk-0.2.0 → celerity_runtime_sdk-0.2.2}/blueprint-config-parser/src/blueprint.rs

@@ -151,7 +151,7 @@ impl Default for RuntimeBlueprintResource {
         RuntimeBlueprintResource {
             resource_type: CelerityResourceType::CelerityHandler,
             metadata: BlueprintResourceMetadata {
-                display_name: "".to_string(),
+                display_name: None,
                 annotations: None,
                 labels: None,
             },
@@ -196,10 +196,10 @@ pub enum CelerityResourceType {
 
 /// This holds the metadata
 /// for a resource in the blueprint configuration.
-#[derive(Serialize, Deserialize, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, PartialEq, Default)]
 pub struct BlueprintResourceMetadata {
-    #[serde(rename = "displayName")]
-    pub display_name: String,
+    #[serde(rename = "displayName", skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
     /// Annotations are always stored as string values.
     /// Literal booleans, integers, and floats in YAML/JSONC
     /// are converted to their string representation during parsing.
@@ -211,16 +211,6 @@ pub struct BlueprintResourceMetadata {
     pub labels: Option<HashMap<String, String>>,
 }
 
-impl Default for BlueprintResourceMetadata {
-    fn default() -> Self {
-        BlueprintResourceMetadata {
-            display_name: "".to_string(),
-            annotations: None,
-            labels: None,
-        }
-    }
-}
-
 /// This holds the configuration
 /// for a link selector in the blueprint configuration.
 #[derive(Serialize, Deserialize, Debug, PartialEq, Default)]
@@ -1151,5 +1141,5 @@ pub enum ResolvedMappingNode {
     Scalar(BlueprintScalarValue),
     Mapping(HashMap<String, ResolvedMappingNode>),
     Sequence(Vec<ResolvedMappingNode>),
-    Null,
+    None,
 }

{celerity_runtime_sdk-0.2.0 → celerity_runtime_sdk-0.2.2}/blueprint-config-parser/src/blueprint_with_subs.rs

@@ -50,8 +50,8 @@ impl Default for RuntimeBlueprintResourceWithSubs {
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Default)]
 pub struct BlueprintResourceMetadataWithSubs {
-    #[serde(rename = "displayName")]
-    pub display_name: StringOrSubstitutions,
+    #[serde(rename = "displayName", skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<StringOrSubstitutions>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub annotations: Option<HashMap<String, MappingNode>>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -575,7 +575,7 @@ pub enum MappingNode {
     Sequence(Vec<MappingNode>),
     SubstitutionStr(StringOrSubstitutions),
     #[default]
-    Null,
+    None,
 }
 
 #[derive(Serialize, Debug, PartialEq, Clone, Default)]

{celerity_runtime_sdk-0.2.0 → celerity_runtime_sdk-0.2.2}/blueprint-config-parser/src/lib.rs

@@ -6,6 +6,7 @@ mod parse_helpers;
 mod parse_mapping_node;
 mod parse_substitutions;
 mod parse_yaml;
+mod reshape;
 mod resolve_substitutions;
 mod validate_parsed;
 pub mod workflow_consts;

{celerity_runtime_sdk-0.2.0 → celerity_runtime_sdk-0.2.2}/blueprint-config-parser/src/parse.rs

@@ -48,6 +48,34 @@ impl BlueprintConfig {
         Ok(final_config)
     }
 
+    /// Parses a Runtime-specific Blueprint configuration from blueprint-language
+    /// (`.bp` / `.blueprint`) source and resolves variable substitutions with
+    /// the provided environment variables.
+    pub fn from_blueprint_lang_str(
+        blueprint_lang: &str,
+        env: Box<dyn EnvVars>,
+    ) -> Result<BlueprintConfig, BlueprintParseError> {
+        let blueprint = celerity_blueprint_lang::parse_string_with_options(
+            blueprint_lang,
+            celerity_blueprint_lang::ParseOptions {
+                substitutions: celerity_blueprint_lang::SubstitutionMode::RawText,
+            },
+        )?;
+        let json = crate::reshape::to_jsonc_string(&blueprint)?;
+        Self::from_jsonc_str(&json, env)
+    }
+
+    /// Parses a Runtime-specific Blueprint configuration from a blueprint-language
+    /// (`.bp` / `.blueprint`) file and resolves variable substitutions with the
+    /// provided environment variables.
+    pub fn from_blueprint_lang_file(
+        file_path: &str,
+        env: Box<dyn EnvVars>,
+    ) -> Result<BlueprintConfig, BlueprintParseError> {
+        let doc_str = read_to_string(file_path)?;
+        Self::from_blueprint_lang_str(&doc_str, env)
+    }
+
     /// Parses a Runtime-specific Blueprint
     /// configuration from a YAML string
     /// and resolves variable substitutions with
@@ -93,6 +121,7 @@ pub enum BlueprintParseError {
     UnsupportedResourceType(String),
     UnsupportedWorkflowStateType(String),
     SubstitutionParseError(parse_substitutions::ParseError),
+    BlueprintLangError(celerity_blueprint_lang::Errors),
 }
 
 impl fmt::Display for BlueprintParseError {
@@ -117,6 +146,9 @@ impl fmt::Display for BlueprintParseError {
             BlueprintParseError::SubstitutionParseError(error) => {
                 write!(f, "substitution parse error: {error}")
             }
+            BlueprintParseError::BlueprintLangError(error) => {
+                write!(f, "blueprint language parse error: {error}")
+            }
         }
     }
 }
@@ -156,3 +188,9 @@ impl From<parse_substitutions::ParseError> for BlueprintParseError {
         BlueprintParseError::SubstitutionParseError(error)
     }
 }
+
+impl From<celerity_blueprint_lang::Errors> for BlueprintParseError {
+    fn from(error: celerity_blueprint_lang::Errors) -> Self {
+        BlueprintParseError::BlueprintLangError(error)
+    }
+}

{celerity_runtime_sdk-0.2.0 → celerity_runtime_sdk-0.2.2}/blueprint-config-parser/src/parse_mapping_node.rs

@@ -118,6 +118,6 @@ impl<'de> Visitor<'de> for MappingNodeVisitor {
     }
 
     fn visit_none<E>(self) -> Result<Self::Value, E> {
-        Ok(MappingNode::Null)
+        Ok(MappingNode::None)
     }
 }

{celerity_runtime_sdk-0.2.0 → celerity_runtime_sdk-0.2.2}/blueprint-config-parser/src/parse_substitutions.rs

@@ -183,29 +183,35 @@ where
     E: de::Error,
 {
     let is_close_sub_bracket = ch == '}' && state.in_possible_sub && !state.in_string_literal;
-    if is_close_sub_bracket && state.potential_sub.starts_with("variables") {
-        // We check for the "variables" prefix to avoid parsing unsupported substitutions
-        // and differentiating between errors in parsing a variable reference and trying to
-        // parse a substitution that is not supported (e.g. values.*, datasources.* etc.).
-        // End of a supported substitution, let's parse it.
-        let mut scanner = Scanner::new(&state.potential_sub);
-        let parsed_sub = parse_substitution(&mut scanner).map_err(de::Error::custom)?;
-        state
-            .parsed
-            .push(StringOrSubstitution::SubstitutionValue(parsed_sub));
-        state.potential_sub = "".to_string();
-        state.potential_non_sub_str = "".to_string();
-        state.in_possible_sub = false;
-    } else if is_close_sub_bracket {
-        // End of a substitution, but it's not a supported substitution.
+    if !is_close_sub_bracket {
+        return Ok(CheckCloseSubBracketResult::Not);
+    }
+
+    // The "variables" prefix gates whether we attempt to parse a variable
+    // reference at all: this keeps a malformed reference (e.g. `${variables.-1}`)
+    // surfaced as an error, while a body with an unsupported prefix
+    // (e.g. `${values.x}`) is left as literal text for downstream tooling.
+    if !state.potential_sub.starts_with("variables") {
         return Ok(CheckCloseSubBracketResult::Unsupported);
     }
 
-    Ok(if is_close_sub_bracket {
-        CheckCloseSubBracketResult::Supported
-    } else {
-        CheckCloseSubBracketResult::Not
-    })
+    // A supported substitution must be a variable reference in full. A body
+    // that begins with a valid reference but carries trailing content (an
+    // expression such as `${variables.a && variables.b}`) is not a plain
+    // reference, so it is kept as literal text rather than silently truncated to
+    // the leading reference.
+    match full_variable_reference(&state.potential_sub).map_err(de::Error::custom)? {
+        Some(parsed_sub) => {
+            state
+                .parsed
+                .push(StringOrSubstitution::SubstitutionValue(parsed_sub));
+            state.potential_sub = String::new();
+            state.potential_non_sub_str = String::new();
+            state.in_possible_sub = false;
+            Ok(CheckCloseSubBracketResult::Supported)
+        }
+        None => Ok(CheckCloseSubBracketResult::Unsupported),
+    }
 }
 
 #[derive(Debug)]
@@ -267,6 +273,22 @@ fn parse_substitution(scanner: &mut Scanner) -> Result<Substitution, ParseError>
     substitution(scanner)
 }
 
+/// Parses `body` as a complete variable reference. Returns `Ok(Some(_))` when
+/// the whole body is a valid reference, `Ok(None)` when it begins with a valid
+/// reference but has trailing content (so it is an expression, not a plain
+/// reference), and `Err` when the reference itself is malformed.
+fn full_variable_reference(body: &str) -> Result<Option<Substitution>, ParseError> {
+    let mut scanner = Scanner::new(body);
+    // parse_substitution doesn't support the blueprint language features
+    // such as boolean expressions, so it will only successfully parse a plain variable reference.
+    let parsed = parse_substitution(&mut scanner)?;
+    consume_whitespace(&mut scanner);
+    if scanner.peek().is_some() {
+        return Ok(None);
+    }
+    Ok(Some(parsed))
+}
+
 fn substitution(scanner: &mut Scanner) -> Result<Substitution, ParseError> {
     // Consume any whitespace before the keyword.
     consume_whitespace(scanner);
@@ -552,4 +574,22 @@ mod tests {
             "parse error at position 10, expected identifier start character in the ${..} substitution at line 1 column 39",
         );
     }
+
+    #[test]
+    fn test_keeps_variable_prefixed_expression_as_literal() {
+        // A `${..}` whose body begins with a valid variable reference but is
+        // actually an expression must be preserved verbatim, not silently
+        // truncated to the leading reference (`${variables.a}`).
+        let input = "\"${variables.a && variables.b}\"";
+        let result = serde_json::from_str::<StringOrSubstitutions>(input);
+        assert!(result.is_ok());
+        assert_eq!(
+            result.unwrap(),
+            StringOrSubstitutions {
+                values: vec![StringOrSubstitution::StringValue(
+                    "${variables.a && variables.b}".to_string()
+                )],
+            }
+        )
+    }
 }

{celerity_runtime_sdk-0.2.0 → celerity_runtime_sdk-0.2.2}/blueprint-config-parser/src/parse_yaml.rs

@@ -1579,7 +1579,7 @@ fn validate_resource_metadata(
                 "displayName" => {
                     if let yaml_rust2::Yaml::String(value_str) = value {
                         resource_metadata.display_name =
-                            parse_substitutions::<ParseError>(value_str)?;
+                            Some(parse_substitutions::<ParseError>(value_str)?);
                     } else {
                         Err(BlueprintParseError::YamlFormatError(format!(
                             "expected a string for resource display name, found {value:?}",
@@ -1623,10 +1623,13 @@ fn validate_resource_metadata(
         }
     }
 
-    if is_string_with_substitutions_empty(&resource_metadata.display_name) {
-        Err(BlueprintParseError::YamlFormatError(
-            "expected a display name for resource metadata".to_string(),
-        ))?;
+    // A display name is optional, but a provided one must not be empty.
+    if let Some(display_name) = &resource_metadata.display_name {
+        if is_string_with_substitutions_empty(display_name) {
+            Err(BlueprintParseError::YamlFormatError(
+                "expected a non-empty display name for resource metadata".to_string(),
+            ))?;
+        }
     }
     Ok(resource_metadata)
 }

celerity_runtime_sdk-0.2.2/blueprint-config-parser/src/reshape.rs

@@ -0,0 +1,245 @@
+//! Reshaping `celerity_blueprint_lang::Blueprint` into the narrow
+//! JWCC JSON the runtime's intermediate model deserializes.
+//!
+//! The blueprint must already have had its substitutions flattened to raw
+//! `${..}` text (parsed with `SubstitutionMode::RawText`), so every spec value
+//! is a plain scalar/mapping/sequence and every string-or-substitutions field is
+//! a single literal string.
+//!
+//! Two things force an explicit reshape rather than re-serialising the blueprint
+//! types: the narrow model uses camelCase field names (e.g. `allowedValues`) and
+//! bare scalars (not the canonical `{value, span}` wrapper); and a resource's
+//! `type` key must be emitted before `spec`, because the narrow resource
+//! deserializer reads `spec` using the already-seen `type`. Resource objects are
+//! therefore ordered `Serialize` structs (serde emits struct fields in
+//! declaration order), while order-insensitive parts are built as `Value`s.
+
+use std::collections::BTreeMap;
+
+use celerity_blueprint_lang::mapping::MappingNode;
+use celerity_blueprint_lang::scalar::{Scalar, ScalarValue};
+use celerity_blueprint_lang::schema::{LinkSelector, Metadata, NamedMap, Resource, Variable};
+use celerity_blueprint_lang::substitution::{
+    StringOrSubstitution, StringOrSubstitutions, SubstitutionKind,
+};
+use celerity_blueprint_lang::Blueprint;
+use serde::Serialize;
+use serde_json::{Map, Value};
+
+const CELERITY_RESOURCE_PREFIX: &str = "celerity/";
+
+/// Reshapes a (substitution-flattened) blueprint into a JWCC JSON
+/// string the runtime's `from_jsonc_str` can parse.
+pub(crate) fn to_jsonc_string(blueprint: &Blueprint) -> Result<String, serde_json::Error> {
+    serde_json::to_string(&reshape_blueprint(blueprint))
+}
+
+#[derive(Serialize)]
+struct ReshapedBlueprint {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    version: Option<String>,
+    // `transform` and `resources` are required by the intermediate JWCC model
+    // (their custom deserializers have no default), so they are always emitted.
+    // An empty `transform` becomes `[]`.
+    transform: Vec<String>,
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    variables: BTreeMap<String, Value>,
+    resources: BTreeMap<String, ReshapedResource>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    metadata: Option<Value>,
+}
+
+/// Field order is significant: serde serialises struct fields in declaration
+/// order, so `type` is emitted before `spec` as the narrow resource
+/// deserializer requires.
+#[derive(Serialize)]
+struct ReshapedResource {
+    #[serde(rename = "type")]
+    resource_type: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    metadata: Option<Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    description: Option<String>,
+    #[serde(rename = "linkSelector", skip_serializing_if = "Option::is_none")]
+    link_selector: Option<Value>,
+    spec: Value,
+}
+
+fn reshape_blueprint(blueprint: &Blueprint) -> ReshapedBlueprint {
+    let mut variables = BTreeMap::new();
+    for (name, variable) in &blueprint.variables.values {
+        variables.insert(name.clone(), reshape_variable(variable));
+    }
+
+    // Only `celerity/*` resources are interpreted by the runtime; everything
+    // else (and data sources, includes, exports) is skipped, mirroring the
+    // YAML/JWCC paths.
+    let mut resources = BTreeMap::new();
+    for (name, resource) in &blueprint.resources.values {
+        if resource
+            .res_type
+            .value
+            .starts_with(CELERITY_RESOURCE_PREFIX)
+        {
+            resources.insert(name.clone(), reshape_resource(resource));
+        }
+    }
+
+    ReshapedBlueprint {
+        version: blueprint.version.as_ref().and_then(scalar_string),
+        transform: blueprint
+            .transform
+            .iter()
+            .map(|t| t.value.clone())
+            .collect(),
+        variables,
+        resources,
+        metadata: blueprint.metadata.as_ref().map(mapping_node_to_json),
+    }
+}
+
+fn reshape_resource(resource: &Resource) -> ReshapedResource {
+    ReshapedResource {
+        resource_type: resource.res_type.value.clone(),
+        metadata: resource.metadata.as_ref().map(reshape_metadata),
+        description: resource.description.as_ref().and_then(sos_string),
+        link_selector: resource.link_selector.as_ref().map(reshape_link_selector),
+        spec: mapping_node_to_json(&resource.spec),
+    }
+}
+
+fn reshape_variable(variable: &Variable) -> Value {
+    let mut object = Map::new();
+    object.insert(
+        "type".to_string(),
+        Value::String(variable.var_type.value.as_str().to_string()),
+    );
+    if let Some(description) = &variable.description {
+        object.insert("description".to_string(), scalar_to_json(description));
+    }
+    if let Some(default) = &variable.default {
+        object.insert("default".to_string(), scalar_to_json(default));
+    }
+    if !variable.allowed_values.is_empty() {
+        let values = variable.allowed_values.iter().map(scalar_to_json).collect();
+        object.insert("allowedValues".to_string(), Value::Array(values));
+    }
+    if let Some(secret) = &variable.secret {
+        object.insert("secret".to_string(), scalar_to_json(secret));
+    }
+    Value::Object(object)
+}
+
+fn reshape_metadata(metadata: &Metadata) -> Value {
+    let mut object = Map::new();
+    if let Some(display_name) = metadata.display_name.as_ref().and_then(sos_string) {
+        object.insert("displayName".to_string(), Value::String(display_name));
+    }
+    if let Some(labels) = &metadata.labels {
+        object.insert("labels".to_string(), string_map_to_json(labels));
+    }
+    if let Some(annotations) = &metadata.annotations {
+        object.insert("annotations".to_string(), sos_map_to_json(annotations));
+    }
+    // The canonical `custom` field has no narrow equivalent and is dropped.
+    Value::Object(object)
+}
+
+fn reshape_link_selector(link_selector: &LinkSelector) -> Value {
+    let mut object = Map::new();
+    object.insert(
+        "byLabel".to_string(),
+        string_map_to_json(&link_selector.by_label),
+    );
+    Value::Object(object)
+}
+
+fn mapping_node_to_json(node: &MappingNode) -> Value {
+    match node {
+        MappingNode::Scalar(scalar) => scalar_to_json(scalar),
+        MappingNode::Fields { fields, .. } => Value::Object(
+            fields
+                .iter()
+                .map(|(key, value)| (key.clone(), mapping_node_to_json(value)))
+                .collect(),
+        ),
+        MappingNode::Items { items, .. } => {
+            Value::Array(items.iter().map(mapping_node_to_json).collect())
+        }
+        MappingNode::StringWithSubstitutions(parts) => {
+            Value::String(sos_string(parts).unwrap_or_default())
+        }
+        MappingNode::None => Value::Null,
+    }
+}
+
+fn scalar_to_json(scalar: &Scalar) -> Value {
+    match &scalar.value {
+        ScalarValue::String(value) => Value::String(value.clone()),
+        ScalarValue::Int(value) => Value::Number((*value).into()),
+        ScalarValue::Float(value) => serde_json::Number::from_f64(*value)
+            .map(Value::Number)
+            .unwrap_or(Value::Null),
+        ScalarValue::Bool(value) => Value::Bool(*value),
+    }
+}
+
+fn scalar_string(scalar: &Scalar) -> Option<String> {
+    match &scalar.value {
+        ScalarValue::String(value) => Some(value.clone()),
+        _ => None,
+    }
+}
+
+fn string_map_to_json(map: &NamedMap<String>) -> Value {
+    Value::Object(
+        map.values
+            .iter()
+            .map(|(key, value)| (key.clone(), Value::String(value.clone())))
+            .collect(),
+    )
+}
+
+fn sos_map_to_json(map: &NamedMap<StringOrSubstitutions>) -> Value {
+    Value::Object(
+        map.values
+            .iter()
+            .map(|(key, value)| (key.clone(), sos_to_json(value)))
+            .collect(),
+    )
+}
+
+/// Converts a (flattened) string-or-substitutions value to JSON. A lone scalar
+/// literal becomes a typed JSON scalar (so e.g. a boolean annotation stays a
+/// boolean); anything else becomes a string.
+fn sos_to_json(parts: &StringOrSubstitutions) -> Value {
+    if let [StringOrSubstitution::Substitution(substitution)] = parts.values.as_slice() {
+        if let Some(value) = scalar_kind_to_json(&substitution.kind) {
+            return value;
+        }
+    }
+    Value::String(sos_string(parts).unwrap_or_default())
+}
+
+fn scalar_kind_to_json(kind: &SubstitutionKind) -> Option<Value> {
+    match kind {
+        SubstitutionKind::Int(value) => Some(Value::Number((*value).into())),
+        SubstitutionKind::Float(value) => serde_json::Number::from_f64(*value).map(Value::Number),
+        SubstitutionKind::Bool(value) => Some(Value::Bool(*value)),
+        _ => None,
+    }
+}
+
+/// Joins the literal parts of a (flattened) string-or-substitutions value.
+/// Returns `None` if a structured substitution remains, which should not happen
+/// for a `RawText`-flattened blueprint.
+fn sos_string(parts: &StringOrSubstitutions) -> Option<String> {
+    let mut text = String::new();
+    for part in &parts.values {
+        match part {
+            StringOrSubstitution::String { value, .. } => text.push_str(value),
+            StringOrSubstitution::Substitution(_) => return None,
+        }
+    }
+    Some(text)
+}

{celerity_runtime_sdk-0.2.0 → celerity_runtime_sdk-0.2.2}/blueprint-config-parser/src/resolve_substitutions.rs

@@ -1928,12 +1928,18 @@ fn resolve_resource_metadata(
     env: Box<dyn EnvVars>,
     resource_name: &str,
 ) -> Result<BlueprintResourceMetadata, ResolveError> {
+    let display_name = metadata
+        .display_name
+        .map(|display_name| {
+            resolve_string_or_substitutions_to_string(
+                display_name,
+                env.clone(),
+                &resource_metadata_field_path(resource_name, &["displayName"]),
+            )
+        })
+        .transpose()?;
     Ok(BlueprintResourceMetadata {
-        display_name: resolve_string_or_substitutions_to_string(
-            metadata.display_name,
-            env.clone(),
-            &resource_metadata_field_path(resource_name, &["displayName"]),
-        )?,
+        display_name,
         annotations: resolve_annotations(metadata.annotations, env.clone(), resource_name)?,
         labels: metadata.labels,
     })
@@ -2129,7 +2135,7 @@ fn resolve_mapping_node(
             resolve_scalar_value_from_string_or_substitutions(string_or_substitutions, env, field)
                 .map(ResolvedMappingNode::Scalar)
         }
-        MappingNode::Null => Ok(ResolvedMappingNode::Null),
+        MappingNode::None => Ok(ResolvedMappingNode::None),
     }
 }