feat(dal, sdf): Getting all the functions associated with a schema variant

stack72 · stack72 · commit 423189fcf029 · 2024-03-28T20:27:58.000Z
diff --git a/lib/dal/src/func.rs b/lib/dal/src/func.rs
@@ -4,7 +4,7 @@ use si_events::ContentHash;
 use std::collections::HashMap;
 use std::string::FromUtf8Error;
 use std::sync::Arc;
-use strum::IntoEnumIterator;
+use strum::{AsRefStr, Display, IntoEnumIterator};
 use telemetry::prelude::*;
 use thiserror::Error;
 use ulid::Ulid;
@@ -48,6 +48,8 @@ pub enum FuncError {
     Transactions(#[from] TransactionsError),
     #[error("could not acquire lock: {0}")]
     TryLock(#[from] tokio::sync::TryLockError),
+    #[error("unable to determine the function type")]
+    UnknownFunctionType,
     #[error("utf8 error: {0}")]
     Utf8(#[from] FromUtf8Error),
     #[error("workspace snapshot error: {0}")]
@@ -76,6 +78,7 @@ impl From<Func> for FuncContentV1 {
             hidden: value.hidden,
             builtin: value.builtin,
             backend_response_type: value.backend_response_type,
+            backend_kind: value.backend_kind,
             handler: value.handler,
             code_base64: value.code_base64,
             code_blake3: value.code_blake3,
@@ -96,6 +99,22 @@ pub fn is_intrinsic(name: &str) -> bool {
 
 pk!(FuncId);
 
+/// Describes what kind of [`Func`] this is.
+#[remain::sorted]
+#[derive(AsRefStr, Deserialize, Display, Serialize, Debug, Eq, PartialEq, Clone, Copy, Hash)]
+#[serde(rename_all = "camelCase")]
+#[strum(serialize_all = "camelCase")]
+pub enum FuncKind {
+    Action,
+    Attribute,
+    Authentication,
+    CodeGeneration,
+    Intrinsic,
+    Qualification,
+    SchemaVariantDefinition,
+    Unknown,
+}
+
 /// A `Func` is the declaration of the existence of a function. It has a name,
 /// and corresponds to a given function backend (and its associated return types).
 ///
@@ -132,7 +151,7 @@ impl Func {
             link: content.link,
             hidden: content.hidden,
             builtin: content.builtin,
-            backend_kind: node_weight.backend_kind(),
+            backend_kind: content.backend_kind,
             backend_response_type: content.backend_response_type,
             handler: content.handler,
             code_base64: content.code_base64,
@@ -143,7 +162,7 @@ impl Func {
     #[allow(clippy::too_many_arguments)]
     pub async fn new(
         ctx: &DalContext,
-        name: impl Into<String>,
+        name: impl Into<String> + Clone,
         display_name: Option<impl Into<String>>,
         description: Option<impl Into<String>>,
         link: Option<impl Into<String>>,
@@ -169,6 +188,7 @@ impl Func {
             hidden,
             builtin,
             backend_response_type,
+            backend_kind,
             handler: handler.map(Into::into),
             code_base64,
             code_blake3,
@@ -185,9 +205,14 @@ impl Func {
             )
             .await?;
 
+        let func_kind =
+            Self::determine_func_kind(name.clone().into(), backend_kind, backend_response_type)
+                .await?;
+
         let change_set = ctx.change_set_pointer()?;
         let id = change_set.generate_ulid()?;
-        let node_weight = NodeWeight::new_func(change_set, id, name.into(), backend_kind, hash)?;
+        let node_weight =
+            NodeWeight::new_func(change_set, id, name.clone().into(), func_kind, hash)?;
 
         let workspace_snapshot = ctx.workspace_snapshot()?;
         workspace_snapshot.add_node(node_weight.clone()).await?;
@@ -208,6 +233,45 @@ impl Func {
         Ok(Self::assemble(&func_node_weight, &content))
     }
 
+    pub async fn determine_func_kind(
+        func_name: String,
+        func_backend_kind: FuncBackendKind,
+        func_backend_response_type: FuncBackendResponseType,
+    ) -> FuncResult<FuncKind> {
+        match func_backend_kind {
+            FuncBackendKind::JsAttribute => {
+                return match func_backend_response_type {
+                    FuncBackendResponseType::CodeGeneration => Ok(FuncKind::CodeGeneration),
+                    FuncBackendResponseType::Qualification => Ok(FuncKind::Qualification),
+                    FuncBackendResponseType::SchemaVariantDefinition => {
+                        dbg!("THIS IS FUCKED!");
+                        Ok(FuncKind::SchemaVariantDefinition)
+                    }
+                    _ => Ok(FuncKind::Attribute),
+                }
+            }
+            FuncBackendKind::JsAction => return Ok(FuncKind::Action),
+            FuncBackendKind::JsAuthentication => return Ok(FuncKind::Authentication),
+            FuncBackendKind::JsSchemaVariantDefinition => {
+                return Ok(FuncKind::SchemaVariantDefinition)
+            }
+            FuncBackendKind::Array
+            | FuncBackendKind::Boolean
+            | FuncBackendKind::Diff
+            | FuncBackendKind::Identity
+            | FuncBackendKind::Integer
+            | FuncBackendKind::Map
+            | FuncBackendKind::Object
+            | FuncBackendKind::String
+            | FuncBackendKind::Unset
+            | FuncBackendKind::Validation => return Ok(FuncKind::Intrinsic),
+            _ => {
+                dbg!(&func_name, &func_backend_kind, &func_backend_response_type);
+                Err(FuncError::UnknownFunctionType)
+            }
+        }
+    }
+
     pub fn metadata_view(&self) -> FuncMetadataView {
         FuncMetadataView {
             display_name: self
@@ -334,17 +398,13 @@ impl Func {
 
         let workspace_snapshot = ctx.workspace_snapshot()?;
 
-        // If both either the name or backend_kind have changed, *and* parts of the FuncContent
+        // If the name HAS changed, *and* parts of the FuncContent
         // have changed, this ends up updating the node for the function twice. This could be
         // optimized to do it only once.
-        if func.name.as_str() != node_weight.name()
-            || func.backend_kind != node_weight.backend_kind()
-        {
+        if func.name.as_str() != node_weight.name() {
             let original_node_index = workspace_snapshot.get_node_index_by_id(func.id).await?;
 
-            node_weight
-                .set_name(func.name.as_str())
-                .set_backend_kind(func.backend_kind);
+            node_weight.set_name(func.name.as_str());
 
             workspace_snapshot
                 .add_node(NodeWeight::Func(
diff --git a/lib/dal/src/layer_db_types/content_types.rs b/lib/dal/src/layer_db_types/content_types.rs
@@ -7,8 +7,8 @@ use crate::{
     func::argument::FuncArgumentKind, key_pair::KeyPairPk, prop::WidgetOptions,
     property_editor::schema::WidgetKind, secret::SecretPk,
     socket::connection_annotation::ConnectionAnnotation, ActionCompletionStatus, ActionKind,
-    ActionPrototypeId, ComponentId, ComponentType, FuncBackendResponseType, FuncId, PropId,
-    PropKind, SocketArity, SocketKind, Timestamp, UserPk,
+    ActionPrototypeId, ComponentId, ComponentType, FuncBackendKind, FuncBackendResponseType,
+    FuncId, PropId, PropKind, SocketArity, SocketKind, Timestamp, UserPk,
 };
 
 /// This type gathers up all the kinds of things we will store in the
@@ -219,6 +219,7 @@ pub struct FuncContentV1 {
     pub hidden: bool,
     pub builtin: bool,
     pub backend_response_type: FuncBackendResponseType,
+    pub backend_kind: FuncBackendKind,
     pub handler: Option<String>,
     pub code_base64: Option<String>,
     /// A hash of the code above
diff --git a/lib/dal/src/schema/variant.rs b/lib/dal/src/schema/variant.rs
@@ -1,7 +1,7 @@
 //! This module contains [`SchemaVariant`](crate::SchemaVariant), which is t/he "class" of a
 //! [`Component`](crate::Component).
 
-use petgraph::{Direction, Incoming};
+use petgraph::{Direction, Incoming, Outgoing};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use si_events::ContentHash;
@@ -20,7 +20,7 @@ use crate::attribute::prototype::AttributePrototypeError;
 use crate::change_set_pointer::ChangeSetPointerError;
 use crate::func::argument::{FuncArgument, FuncArgumentError};
 use crate::func::intrinsics::IntrinsicFunc;
-use crate::func::FuncError;
+use crate::func::{FuncError, FuncKind};
 use crate::layer_db_types::{
     InputSocketContent, OutputSocketContent, SchemaVariantContent,
     SchemaVariantContentDiscriminants, SchemaVariantContentV1,
@@ -41,16 +41,14 @@ use crate::workspace_snapshot::WorkspaceSnapshotError;
 use crate::{
     pk,
     schema::variant::leaves::{LeafInput, LeafInputLocation, LeafKind},
-    AttributePrototype, AttributePrototypeId, ComponentId, ComponentType, DalContext, Func,
-    FuncBackendKind, FuncId, InputSocket, OutputSocket, OutputSocketId, Prop, PropId, PropKind,
-    Schema, SchemaError, SchemaId, SocketArity, Timestamp, TransactionsError,
+    ActionPrototype, ActionPrototypeError, AttributePrototype, AttributePrototypeId, ComponentId,
+    ComponentType, DalContext, Func, FuncId, InputSocket, OutputSocket, OutputSocketId, Prop,
+    PropId, PropKind, Schema, SchemaError, SchemaId, SocketArity, Timestamp, TransactionsError,
 };
 use crate::{FuncBackendResponseType, InputSocketId};
 
 use self::root_prop::RootPropChild;
 
-// use self::leaves::{LeafInput, LeafInputLocation, LeafKind};
-
 pub mod definition;
 pub mod leaves;
 pub mod root_prop;
@@ -64,6 +62,8 @@ pub const SCHEMA_VARIANT_VERSION: SchemaVariantContentDiscriminants =
 #[remain::sorted]
 #[derive(Error, Debug)]
 pub enum SchemaVariantError {
+    #[error("action prototype error: {0}")]
+    ActionPrototype(String),
     #[error("attribute prototype error: {0}")]
     AttributePrototype(#[from] AttributePrototypeError),
     #[error("attribute argument prototype error: {0}")]
@@ -305,7 +305,7 @@ impl SchemaVariant {
                 .await?;
 
             let func_node_weight = node_weight.get_func_node_weight()?;
-            if func_node_weight.backend_kind() == FuncBackendKind::JsSchemaVariantDefinition {
+            if func_node_weight.func_kind() == FuncKind::SchemaVariantDefinition {
                 return Ok(Some(func_node_weight.id().into()));
             }
         }
@@ -1040,39 +1040,81 @@ impl SchemaVariant {
         ctx: &DalContext,
         schema_variant_id: SchemaVariantId,
     ) -> SchemaVariantResult<Vec<Func>> {
+        let workspace_snapshot = ctx.workspace_snapshot()?;
         let mut all_funcs = vec![];
-        // auth funcs
-        for func_id in Self::list_auth_func_ids_for_schema_variant(ctx, schema_variant_id).await? {
-            let func = Func::get_by_id(ctx, func_id).await?;
-            all_funcs.push(func);
-        }
-        // attribute funcs
-        for func_id in
-            Self::list_attribute_func_ids_for_schema_variant(ctx, schema_variant_id).await?
-        {
-            let func = Func::get_by_id(ctx, func_id).await?;
-            all_funcs.push(func);
-        }
-        // qualification funcs
-        for func_id in
-            Self::list_qualification_func_ids_for_schema_variant(ctx, schema_variant_id).await?
-        {
-            let func = Func::get_by_id(ctx, func_id).await?;
-            all_funcs.push(func);
+
+        let sv = Self::get_by_id(ctx, schema_variant_id).await?;
+
+        let prop_list = sv.dump_props_as_list(ctx).await?;
+        for prop_path in prop_list {
+            let prop_id = Prop::find_prop_id_by_path(ctx, schema_variant_id, &prop_path).await?;
+            // Let's get the Attribute funcs now
+            if let Some(ap_id) = AttributePrototype::find_for_prop(ctx, prop_id, &None).await? {
+                let func_id = AttributePrototype::func_id(ctx, ap_id).await?;
+
+                let node_weight = workspace_snapshot
+                    .get_node_weight_by_id(func_id)
+                    .await?
+                    .get_func_node_weight()?;
+
+                match node_weight.func_kind() {
+                    FuncKind::Attribute => {
+                        let func = Func::get_by_id(ctx, func_id).await?;
+                        all_funcs.push(func);
+                    }
+
+                    _ => {}
+                }
+            }
+
+            // Now let's get all of the outgoing edges for the Prop
+            for (edge_weight, _source, _target) in
+                workspace_snapshot.edges_directed(prop_id, Outgoing).await?
+            {
+                if let EdgeWeightKind::Prototype(Some(key)) = edge_weight.kind() {
+                    if let Some(func_id) = Func::find_by_name(ctx, key).await? {
+                        let func = Func::get_by_id(ctx, func_id).await?;
+                        all_funcs.push(func);
+                    }
+                }
+            }
         }
-        // action funcs
-        for func_id in Self::list_action_func_ids_for_schema_variant(ctx, schema_variant_id).await?
-        {
-            let func = Func::get_by_id(ctx, func_id).await?;
-            all_funcs.push(func);
+
+        // Let's get all of the Authentication funcs
+        let auth_func_ids =
+            Self::list_auth_func_ids_for_schema_variant(ctx, schema_variant_id).await?;
+        for auth_func_id in auth_func_ids {
+            let auth_func = Func::get_by_id(ctx, auth_func_id).await?;
+            // We may not need this - the list_auth_func_ids_for_schema_variant returns multiple
+            // of the same type
+            if !all_funcs.contains(&auth_func) {
+                all_funcs.push(auth_func);
+            }
         }
-        //code gen
-        for func_id in
-            Self::list_code_gen_func_ids_for_schema_variant(ctx, schema_variant_id).await?
-        {
-            let func = Func::get_by_id(ctx, func_id).await?;
+
+        let action_prototype_nodes = workspace_snapshot
+            .outgoing_targets_for_edge_weight_kind(
+                schema_variant_id,
+                EdgeWeightKindDiscriminants::ActionPrototype,
+            )
+            .await?;
+        for action_prototype_node in action_prototype_nodes {
+            let weight = workspace_snapshot
+                .get_node_weight(action_prototype_node)
+                .await?;
+            let ap = ActionPrototype::get_by_id(ctx, weight.id().into())
+                .await
+                .map_err(|e| SchemaVariantError::ActionPrototype(e.to_string()))?;
+            let func = Func::get_by_id(
+                ctx,
+                ap.func_id(ctx)
+                    .await
+                    .map_err(|e| SchemaVariantError::ActionPrototype(e.to_string()))?,
+            )
+            .await?;
             all_funcs.push(func);
         }
+
         Ok(all_funcs)
     }
 
diff --git a/lib/dal/src/workspace_snapshot/graph/tests/rebase.rs b/lib/dal/src/workspace_snapshot/graph/tests/rebase.rs
@@ -5,12 +5,12 @@ mod test {
     use si_events::ContentHash;
 
     use crate::change_set_pointer::ChangeSetPointer;
+    use crate::func::FuncKind;
     use crate::workspace_snapshot::content_address::ContentAddress;
     use crate::workspace_snapshot::edge_weight::{EdgeWeight, EdgeWeightKind};
     use crate::workspace_snapshot::node_weight::category_node_weight::CategoryNodeKind;
     use crate::workspace_snapshot::node_weight::NodeWeight;
     use crate::workspace_snapshot::node_weight::{ContentNodeWeight, FuncNodeWeight};
-    use crate::FuncBackendKind;
     use crate::WorkspaceSnapshotGraph;
 
     #[test]
@@ -59,7 +59,7 @@ mod test {
             func_id,
             ContentAddress::Func(ContentHash::from("foo")),
             "foo".to_string(),
-            FuncBackendKind::String,
+            FuncKind::Intrinsic,
         )
         .expect("could not create func node weight");
         let func_node_index = onto
diff --git a/lib/dal/src/workspace_snapshot/node_weight.rs b/lib/dal/src/workspace_snapshot/node_weight.rs
@@ -7,7 +7,6 @@ use ulid::Ulid;
 
 use crate::func::execution::FuncExecutionPk;
 use crate::workspace_snapshot::vector_clock::VectorClockId;
-use crate::FuncBackendKind;
 use crate::{
     change_set_pointer::{ChangeSetPointer, ChangeSetPointerError},
     workspace_snapshot::{
@@ -17,6 +16,7 @@ use crate::{
     PropKind,
 };
 
+use crate::func::FuncKind;
 pub use attribute_prototype_argument_node_weight::ArgumentTargets;
 pub use attribute_prototype_argument_node_weight::AttributePrototypeArgumentNodeWeight;
 pub use attribute_value_node_weight::AttributeValueNodeWeight;
@@ -576,15 +576,15 @@ impl NodeWeight {
         change_set: &ChangeSetPointer,
         func_id: Ulid,
         name: impl AsRef<str>,
-        backend_kind: FuncBackendKind,
+        func_kind: FuncKind,
         content_hash: ContentHash,
     ) -> NodeWeightResult<Self> {
         Ok(NodeWeight::Func(FuncNodeWeight::new(
             change_set,
             func_id,
             ContentAddress::Func(content_hash),
             name.as_ref().to_string(),
-            backend_kind,
+            func_kind,
         )?))
     }
 
diff --git a/lib/dal/src/workspace_snapshot/node_weight/func_node_weight.rs b/lib/dal/src/workspace_snapshot/node_weight/func_node_weight.rs
diff --git a/lib/sdf-server/src/server/service/variant_definition/get_variant_def.rs b/lib/sdf-server/src/server/service/variant_definition/get_variant_def.rs
