Enable delete_connection API endpoint

Removing an AttributePrototypeArgument will now cause the
AttributeValue(s) that use that Prototype to automatically be updated to
reflect the new function inputs.

Author: jhelwig

lib/dal/src/attribute/prototype/argument.rs

@@ -3,6 +3,8 @@
 //! value. It defines source of the value for the function argument in the
 //! context of the prototype.
 
+use std::collections::HashSet;
+
 use serde::{Deserialize, Serialize};
 use telemetry::prelude::*;
 use thiserror::Error;
@@ -22,8 +24,8 @@ use crate::{
         },
         WorkspaceSnapshotError,
     },
-    AttributePrototype, AttributePrototypeId, ComponentId, DalContext, OutputSocketId, PropId,
-    Timestamp, TransactionsError,
+    AttributePrototype, AttributePrototypeId, AttributeValue, ComponentId, DalContext,
+    OutputSocketId, PropId, Timestamp, TransactionsError,
 };
 
 use self::{
@@ -45,6 +47,8 @@ pk!(AttributePrototypeArgumentId);
 pub enum AttributePrototypeArgumentError {
     #[error("attribute prototype error: {0}")]
     AttributePrototype(#[from] AttributePrototypeError),
+    #[error("attribute value error: {0}")]
+    AttributeValue(String),
     #[error("change set error: {0}")]
     ChangeSet(#[from] ChangeSetPointerError),
     #[error("edge weight error: {0}")]
@@ -59,8 +63,12 @@ pub enum AttributePrototypeArgumentError {
     LayerDb(#[from] si_layer_cache::LayerDbError),
     #[error("attribute prototype argument {0} has no func argument")]
     MissingFuncArgument(AttributePrototypeArgumentId),
+    #[error("attribute prototype argument {0} has no value source")]
+    MissingSource(AttributePrototypeArgumentId),
     #[error("node weight error: {0}")]
     NodeWeight(#[from] NodeWeightError),
+    #[error("no targets for prototype argument: {0}")]
+    NoTargets(AttributePrototypeArgumentId),
     #[error("serde json error: {0}")]
     Serde(#[from] serde_json::Error),
     #[error("transactions error: {0}")]
@@ -525,9 +533,37 @@ impl AttributePrototypeArgument {
         ctx: &DalContext,
         apa_id: AttributePrototypeArgumentId,
     ) -> AttributePrototypeArgumentResult<()> {
+        let apa = Self::get_by_id(ctx, apa_id).await?;
+        let prototype_id = apa.prototype_id(ctx).await?;
+        // Find all of the "destination" attribute values.
+        let mut avs_to_update = AttributePrototype::attribute_value_ids(ctx, prototype_id).await?;
+        // If the argument has targets, then we only care about AVs that are for the same
+        // destination component.
+        if let Some(targets) = apa.targets() {
+            let mut av_ids_to_keep = HashSet::new();
+            for av_id in &avs_to_update {
+                let component_id = AttributeValue::component_id(ctx, *av_id)
+                    .await
+                    .map_err(|e| AttributePrototypeArgumentError::AttributeValue(e.to_string()))?;
+                if component_id == targets.destination_component_id {
+                    av_ids_to_keep.insert(*av_id);
+                }
+            }
+            avs_to_update.retain(|av_id| av_ids_to_keep.contains(av_id));
+        }
+
+        // Remove the argument
         ctx.workspace_snapshot()?
             .remove_node_by_id(ctx.change_set_pointer()?, apa_id)
             .await?;
+        // Update the destination attribute values
+        for av_id_to_update in &avs_to_update {
+            AttributeValue::update_from_prototype_function(ctx, *av_id_to_update)
+                .await
+                .map_err(|e| AttributePrototypeArgumentError::AttributeValue(e.to_string()))?;
+        }
+        // Enqueue a dependent values update with the destination attribute values
+        ctx.enqueue_dependent_values_update(avs_to_update).await?;
 
         Ok(())
     }

lib/dal/tests/integration_test/connection.rs

@@ -1,3 +1,4 @@
+use dal::attribute::prototype::argument::AttributePrototypeArgument;
 use dal::diagram::Diagram;
 use dal::{
     AttributeValue, Component, DalContext, InputSocket, OutputSocket, Schema, SchemaVariant,
@@ -217,3 +218,197 @@ async fn connect_to_one_destination_with_multiple_candidates_of_same_schema_vari
     assert_eq!(edge.from_component_id, source.id());
     assert_eq!(edge.to_component_id, destination.id());
 }
+
+#[test]
+async fn remove_connection(ctx: &mut DalContext) {
+    // Get the source schema variant id.
+    let docker_image_schema = Schema::find_by_name(ctx, "Docker Image")
+        .await
+        .expect("could not perform find by name")
+        .expect("no schema found");
+    let mut docker_image_schema_variants =
+        SchemaVariant::list_for_schema(ctx, docker_image_schema.id())
+            .await
+            .expect("could not list schema variants for schema");
+    let docker_image_schema_variant = docker_image_schema_variants
+        .pop()
+        .expect("schema variants are empty");
+    let docker_image_schema_variant_id = docker_image_schema_variant.id();
+
+    // Get the destination schema variant id.
+    let butane_schema = Schema::find_by_name(ctx, "Butane")
+        .await
+        .expect("could not perform find by name")
+        .expect("no schema found");
+    let mut butane_schema_variants = SchemaVariant::list_for_schema(ctx, butane_schema.id())
+        .await
+        .expect("could not list schema variants for schema");
+    let butane_schema_variant = butane_schema_variants
+        .pop()
+        .expect("schema variants are empty");
+    let butane_schema_variant_id = butane_schema_variant.id();
+
+    // Find the sockets we want to use.
+    let output_socket =
+        OutputSocket::find_with_name(ctx, "Container Image", docker_image_schema_variant_id)
+            .await
+            .expect("could not perform find output socket")
+            .expect("output socket not found");
+    let input_socket =
+        InputSocket::find_with_name(ctx, "Container Image", butane_schema_variant_id)
+            .await
+            .expect("could not perform find input socket")
+            .expect("input socket not found");
+
+    // Create a component for both the source and the destination
+    let oysters_component =
+        Component::new(ctx, "oysters in my pocket", docker_image_schema_variant_id)
+            .await
+            .expect("could not create component");
+
+    ctx.blocking_commit()
+        .await
+        .expect("blocking commit after component creation");
+
+    ctx.update_snapshot_to_visibility()
+        .await
+        .expect("update_snapshot_to_visibility");
+
+    // Create a second component for a second source
+    let lunch_component =
+        Component::new(ctx, "were saving for lunch", docker_image_schema_variant_id)
+            .await
+            .expect("could not create component");
+
+    ctx.blocking_commit()
+        .await
+        .expect("blocking commit after component 2 creation");
+
+    ctx.update_snapshot_to_visibility()
+        .await
+        .expect("update_snapshot_to_visibility");
+
+    let royel_component = Component::new(ctx, "royel otis", butane_schema_variant_id)
+        .await
+        .expect("could not create component");
+
+    ctx.blocking_commit()
+        .await
+        .expect("blocking commit after butane component creation");
+
+    ctx.update_snapshot_to_visibility()
+        .await
+        .expect("update_snapshot_to_visibility");
+
+    // Connect the components!
+    let inter_component_attribute_prototype_argument_id = Component::connect(
+        ctx,
+        oysters_component.id(),
+        output_socket.id(),
+        royel_component.id(),
+        input_socket.id(),
+    )
+    .await
+    .expect("could not connect components");
+
+    ctx.blocking_commit().await.expect("blocking commit failed");
+
+    ctx.update_snapshot_to_visibility()
+        .await
+        .expect("update_snapshot_to_visibility");
+
+    // Connect component 2
+    let _inter_component_attribute_prototype_argument_id = Component::connect(
+        ctx,
+        lunch_component.id(),
+        output_socket.id(),
+        royel_component.id(),
+        input_socket.id(),
+    )
+    .await
+    .expect("could not connect components");
+
+    ctx.blocking_commit().await.expect("blocking commit failed");
+
+    ctx.update_snapshot_to_visibility()
+        .await
+        .expect("update_snapshot_to_visibility");
+
+    //dbg!(royel_component.incoming_connections(ctx).await.expect("ok"));
+
+    let units_value_id = royel_component
+        .attribute_values_for_prop(ctx, &["root", "domain", "systemd", "units"])
+        .await
+        .expect("able to get values for units")
+        .first()
+        .copied()
+        .expect("has a value");
+
+    let materialized_view = AttributeValue::get_by_id(ctx, units_value_id)
+        .await
+        .expect("value exists")
+        .materialized_view(ctx)
+        .await
+        .expect("able to get units materialized_view")
+        .expect("units has a materialized_view");
+
+    dbg!(lunch_component
+        .materialized_view(ctx)
+        .await
+        .expect("get docker image materialized_view"));
+
+    assert!(matches!(materialized_view, serde_json::Value::Array(_)));
+
+    if let serde_json::Value::Array(units_array) = materialized_view {
+        assert_eq!(2, units_array.len())
+    }
+
+    // Assemble the diagram and check the edges.
+    let diagram = Diagram::assemble(ctx)
+        .await
+        .expect("could not assemble the diagram");
+    assert_eq!(2, diagram.edges.len());
+
+    // Disconnect Component 1
+    AttributePrototypeArgument::remove(ctx, inter_component_attribute_prototype_argument_id)
+        .await
+        .expect("Unable to remove inter component attribute prototype argument");
+
+    ctx.blocking_commit().await.expect("blocking commit failed");
+    ctx.update_snapshot_to_visibility()
+        .await
+        .expect("Unable to update snapshot to visibility");
+
+    let units_value_id = royel_component
+        .attribute_values_for_prop(ctx, &["root", "domain", "systemd", "units"])
+        .await
+        .expect("able to get values for units")
+        .first()
+        .copied()
+        .expect("has a value");
+
+    let materialized_view = AttributeValue::get_by_id(ctx, units_value_id)
+        .await
+        .expect("value exists")
+        .materialized_view(ctx)
+        .await
+        .expect("able to get units materialized_view")
+        .expect("units has a materialized_view");
+
+    dbg!(lunch_component
+        .materialized_view(ctx)
+        .await
+        .expect("get docker image materialized_view"));
+
+    assert!(matches!(materialized_view, serde_json::Value::Array(_)));
+
+    if let serde_json::Value::Array(units_array) = materialized_view {
+        assert_eq!(1, units_array.len())
+    }
+
+    // Assemble the diagram and check the edges.
+    let diagram = Diagram::assemble(ctx)
+        .await
+        .expect("could not assemble the diagram");
+    assert_eq!(1, diagram.edges.len());
+}

lib/sdf-server/src/server/service/diagram.rs

@@ -3,9 +3,12 @@ use axum::response::{IntoResponse, Response};
 use axum::routing::{get, post};
 use axum::Json;
 use axum::Router;
+use dal::attribute::prototype::argument::AttributePrototypeArgumentError;
 use dal::attribute::prototype::AttributePrototypeError;
+use dal::attribute::value::AttributeValueError;
 use dal::component::ComponentError;
 use dal::socket::input::InputSocketError;
+use dal::socket::output::OutputSocketError;
 use dal::workspace_snapshot::WorkspaceSnapshotError;
 use dal::WsEventError;
 use dal::{
@@ -25,7 +28,7 @@ pub mod set_component_position;
 
 // mod connect_component_to_frame;
 pub mod delete_component;
-//pub mod delete_connection;
+pub mod delete_connection;
 // pub mod paste_component;
 pub mod remove_delete_intent;
 // pub mod restore_connection;
@@ -37,8 +40,12 @@ pub enum DiagramError {
     Action(#[from] ActionError),
     #[error("action: {0}")]
     ActionPrototype(#[from] ActionPrototypeError),
-    #[error("prototype error: {0}")]
+    #[error("attribute prototype error: {0}")]
     AttributePrototype(#[from] AttributePrototypeError),
+    #[error("attribute prototype argument error: {0}")]
+    AttributePrototypeArgument(#[from] AttributePrototypeArgumentError),
+    #[error("attribute value error: {0}")]
+    AttributeValue(#[from] AttributeValueError),
     #[error("changeset error: {0}")]
     ChangeSet(#[from] ChangeSetPointerError),
     #[error("change set not found")]
@@ -73,6 +80,8 @@ pub enum DiagramError {
     Nats(#[from] si_data_nats::NatsError),
     #[error("not authorized")]
     NotAuthorized,
+    #[error("output socket error: {0}")]
+    OutputSocket(#[from] OutputSocketError),
     #[error("paste failed")]
     PasteError,
     #[error(transparent)]
@@ -112,10 +121,10 @@ impl IntoResponse for DiagramError {
 
 pub fn routes() -> Router<AppState> {
     Router::new()
-        // .route(
-        //     "/delete_connection",
-        //     post(delete_connection::delete_connection),
-        // )
+        .route(
+            "/delete_connection",
+            post(delete_connection::delete_connection),
+        )
         // .route(
         //     "/restore_connection",
         //     post(restore_connection::restore_connection),