Merge pull request #24 from Virtual-Repetitions/join-team-with-code

bumping to 0.29

Author: scoop1120

Cargo.lock

@@ -1,5 +1,5 @@
 [workspace.package]
-version = "0.28.1"
+version = "0.29.0"
 edition = "2024"
 
 # See https://github.com/mozilla/application-services/blob/main/Cargo.toml for the reasons why we use this structure

Cargo.toml

@@ -179,11 +179,17 @@ pub fn load_subsystem_builders(
 
                     if builder.is_none() {
                         // Then try to load a dynamic builder
-                        subsystem_builders.push(
-                            core_plugin_interface::interface::load_subsystem_builder(
-                                &entry.path(),
-                            )?,
-                        );
+                        match core_plugin_interface::interface::load_subsystem_builder(
+                            &entry.path(),
+                        ) {
+                            Ok(builder) => subsystem_builders.push(builder),
+                            Err(err) => {
+                                eprintln!(
+                                    "Skipping dynamic subsystem builder {:?} due to error: {err}",
+                                    entry.path()
+                                );
+                            }
+                        }
                     };
                 }
             }

crates/builder/src/lib.rs

@@ -84,6 +84,15 @@ impl SubsystemBuilder for PostgresSubsystemBuilder {
                     mapped_params: None,
                 },
             ),
+            (
+                "relationPath",
+                AnnotationSpec {
+                    targets: &[AnnotationTarget::Field],
+                    no_params: false,
+                    single_params: true,
+                    mapped_params: None,
+                },
+            ),
             (
                 "dbtype",
                 AnnotationSpec {

crates/postgres-subsystem/postgres-builder/src/plugin.rs

@@ -758,6 +758,71 @@ fn resolve_composite_type_fields(
             },
         };
 
+        let relation_path = field.annotations.get("relationPath").and_then(|params| {
+            match params {
+                AstAnnotationParams::Single(expr, _) => match expr {
+                    AstExpr::StringLiteral(path, _) => {
+                        let segments: Vec<String> = path
+                            .split('.')
+                            .map(|segment| segment.trim().to_string())
+                            .filter(|segment| !segment.is_empty())
+                            .collect();
+
+                        if segments.is_empty() {
+                            errors.push(Diagnostic {
+                                level: Level::Error,
+                                message: format!(
+                                    "@relationPath for field '{}' must contain at least one segment",
+                                    field.name
+                                ),
+                                code: Some("C000".to_string()),
+                                spans: vec![SpanLabel {
+                                    span: field.span,
+                                    style: SpanStyle::Primary,
+                                    label: None,
+                                }],
+                            });
+                            None
+                        } else {
+                            Some(segments)
+                        }
+                    }
+                    _ => {
+                        errors.push(Diagnostic {
+                            level: Level::Error,
+                            message: format!(
+                                "@relationPath for field '{}' must be a string literal",
+                                field.name
+                            ),
+                            code: Some("C000".to_string()),
+                            spans: vec![SpanLabel {
+                                span: field.span,
+                                style: SpanStyle::Primary,
+                                label: None,
+                            }],
+                        });
+                        None
+                    }
+                },
+                _ => {
+                    errors.push(Diagnostic {
+                        level: Level::Error,
+                        message: format!(
+                            "@relationPath for field '{}' must use the syntax @relationPath(\"segment1.segment2\")",
+                            field.name
+                        ),
+                        code: Some("C000".to_string()),
+                        spans: vec![SpanLabel {
+                            span: field.span,
+                            style: SpanStyle::Primary,
+                            label: None,
+                        }],
+                    });
+                    None
+                }
+            }
+        });
+
         let typ = resolve_field_type(
             &field.typ.to_typ(&typechecked_system.types),
             &typechecked_system.types,
@@ -768,6 +833,23 @@ fn resolve_composite_type_fields(
             .as_ref()
             .map(|v| resolve_field_default_type(v, &typ, errors));
 
+        if relation_path.is_some() && field.annotations.get("computed").is_some() {
+            errors.push(Diagnostic {
+                level: Level::Error,
+                message: format!(
+                    "Field '{}' cannot use both @computed and @relationPath",
+                    field.name
+                ),
+                code: Some("C000".to_string()),
+                spans: vec![SpanLabel {
+                    span: field.span,
+                    style: SpanStyle::Primary,
+                    label: None,
+                }],
+            });
+            continue;
+        }
+
         if let Some(computed_params) = field.annotations.get("computed") {
             let resolved_computed =
                 match parse_computed_field(module_base_path, field, computed_params, errors) {
@@ -791,14 +873,29 @@ fn resolve_composite_type_fields(
                 default_value: None,
                 update_sync: false,
                 readonly: true,
+                relation_path: None,
                 doc_comments: field.doc_comments.clone(),
                 computed: Some(resolved_computed),
                 span: field.span,
             });
             continue;
         }
 
-        let column_info = compute_column_info(ct, field, &typechecked_system.types, table_managed);
+        if relation_path.is_some() {
+            readonly = true;
+        }
+
+        let column_info = if relation_path.is_some() {
+            Ok(ColumnInfo {
+                names: vec![],
+                self_column: false,
+                unique_constraints: vec![],
+                indices: vec![],
+                cardinality: None,
+            })
+        } else {
+            compute_column_info(ct, field, &typechecked_system.types, table_managed)
+        };
 
         let ColumnInfo {
             names: column_names,
@@ -860,6 +957,7 @@ fn resolve_composite_type_fields(
             default_value: field_default,
             update_sync,
             readonly,
+            relation_path,
             doc_comments: field.doc_comments.clone(),
             computed: None,
             span: field.span,

crates/postgres-subsystem/postgres-core-builder/src/resolved_builder.rs

@@ -94,6 +94,8 @@ pub struct ResolvedField {
     pub default_value: Option<ResolvedFieldDefault>,
     pub update_sync: bool,
     pub readonly: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub relation_path: Option<Vec<String>>,
     pub doc_comments: Option<String>,
     pub computed: Option<ResolvedComputedField>,
     #[serde(skip_serializing)]