reactive_graph/client/types/flows/
mod.rs

1use crate::client::error::CommandError;
2use crate::client::error::CommandError::NamespacedTypeNotFound;
3use crate::client::error::CommandError::NoContent;
4use crate::client::error::CommandError::NotCreated;
5use crate::client::error::CommandError::NotFound;
6use crate::client::result::CommandResult;
7use crate::client::types::extension::output_format::ExtensionsOutputFormatWrapper;
8use crate::client::types::flows::args::FlowTypesArgs;
9use crate::client::types::flows::commands::FlowTypesCommands;
10use crate::client::types::flows::output_format::FlowTypesOutputFormatWrapper;
11use crate::client::types::property_type::output_format::PropertyTypesOutputFormatWrapper;
12use reactive_graph_client::ReactiveGraphClient;
13use reactive_graph_graph::EntityInstance;
14use reactive_graph_graph::FlowType;
15use reactive_graph_graph::NamespacedTypeContainer;
16use reactive_graph_graph::NamespacedTypeGetter;
17use std::sync::Arc;
18
19pub(crate) mod args;
20pub(crate) mod commands;
21pub(crate) mod output_format;
22
23pub(crate) async fn flow_types(client: &Arc<ReactiveGraphClient>, flow_type_args: FlowTypesArgs) -> CommandResult {
24    let output_format_wrapper: FlowTypesOutputFormatWrapper = flow_type_args.output_format.clone().into();
25    let Some(command) = flow_type_args.commands else {
26        return Err(CommandError::MissingSubCommand);
27    };
28    match command {
29        FlowTypesCommands::List => match client.types().flows().get_all_flow_types().await {
30            Ok(Some(flow_types)) => output_format_wrapper.collection(flow_types.to_vec()),
31            Ok(None) => Err(NoContent("No flow types found".to_string())),
32            Err(e) => Err(e.into()),
33        },
34        FlowTypesCommands::Get { flow_ty } => match client.types().flows().get_flow_type_by_type(&flow_ty).await {
35            Ok(Some(flow_type)) => output_format_wrapper.single(flow_type),
36            Ok(None) => Err(NamespacedTypeNotFound(flow_ty.namespaced_type())),
37            Err(e) => Err(e.into()),
38        },
39        FlowTypesCommands::ListVariables { flow_ty } => match client.types().flows().get_flow_type_by_type(&flow_ty).await {
40            Ok(Some(flow_type)) => {
41                let output_format_wrapper: PropertyTypesOutputFormatWrapper = flow_type_args.output_format.into();
42                output_format_wrapper.collection(flow_type.variables.to_vec())
43            }
44            Ok(None) => Err(NamespacedTypeNotFound(flow_ty.namespaced_type())),
45            Err(e) => Err(e.into()),
46        },
47        FlowTypesCommands::ListExtensions { flow_ty } => match client.types().flows().get_flow_type_by_type(&flow_ty).await {
48            Ok(Some(flow_type)) => {
49                let output_format_wrapper: ExtensionsOutputFormatWrapper = flow_type_args.output_format.into();
50                output_format_wrapper.collection(flow_type.extensions.to_vec())
51            }
52            Ok(None) => Err(NamespacedTypeNotFound(flow_ty.namespaced_type())),
53            Err(e) => Err(e.into()),
54        },
55        FlowTypesCommands::GetJsonSchema { flow_ty } => match client.types().flows().json_schema_for_flow_type_by_type(&flow_ty).await {
56            Ok(Some(json_schema)) => Ok(json_schema.into()),
57            Ok(None) => Err(NamespacedTypeNotFound(flow_ty.namespaced_type())),
58            Err(e) => Err(e.into()),
59        },
60        FlowTypesCommands::Create(args) => match client
61            .types()
62            .flows()
63            .create_flow_type(
64                FlowType::builder()
65                    .ty(&args.flow_ty)
66                    .description(args.description.unwrap_or_default())
67                    .wrapper_entity_instance(
68                        EntityInstance::builder()
69                            .ty(&args.entity_ty)
70                            .id(args.wrapper_entity_instance_id)
71                            .description(args.wrapper_entity_instance_description.unwrap_or_default())
72                            .build(),
73                    )
74                    .build(),
75            )
76            .await
77        {
78            Ok(Some(flow_type)) => output_format_wrapper.single(flow_type),
79            Ok(None) => Err(NotCreated("Flow type wasn't created".to_string())),
80            Err(e) => Err(e.into()),
81        },
82        FlowTypesCommands::Delete { flow_ty } => match client.types().flows().delete_flow_type(&flow_ty).await {
83            Ok(Some(true)) => Ok(format!("Flow Type {} deleted", flow_ty).into()),
84            Ok(Some(false)) => Ok(format!("Flow Type {} not deleted", flow_ty).into()),
85            Ok(None) => Err(NamespacedTypeNotFound(flow_ty.namespaced_type())),
86            Err(e) => Err(e.into()),
87        },
88        FlowTypesCommands::AddVariable(args) => match client.types().flows().add_variable(&args.flow_ty, &args.variable).await {
89            Ok(Some(flow_type)) => output_format_wrapper.single(flow_type),
90            Ok(None) => Err(NotCreated("Property wasn't created".to_string())),
91            Err(e) => Err(e.into()),
92        },
93        FlowTypesCommands::RemoveVariable(args) => match client.types().flows().remove_variable(&args.flow_ty, args.variable_name.clone()).await {
94            Ok(Some(flow_type)) => output_format_wrapper.single(flow_type),
95            Ok(None) => Err(NamespacedTypeNotFound(args.flow_ty.namespaced_type())),
96            Err(e) => Err(e.into()),
97        },
98        FlowTypesCommands::AddExtension(args) => match client.types().flows().add_extension(&args.flow_ty, &args.extension).await {
99            Ok(Some(flow_type)) => output_format_wrapper.single(flow_type),
100            Ok(None) => Err(NotCreated("Extension wasn't created".to_string())),
101            Err(e) => Err(e.into()),
102        },
103        FlowTypesCommands::RemoveExtension(args) => match client.types().flows().remove_extension(&args).await {
104            Ok(Some(flow_type)) => output_format_wrapper.single(flow_type),
105            Ok(None) => Err(NamespacedTypeNotFound(args.flow_ty.namespaced_type())),
106            Err(e) => Err(e.into()),
107        },
108        FlowTypesCommands::AddEntityInstance(args) => match client.types().flows().add_entity_instance(&args.flow_ty, &args.entity_instance).await {
109            Ok(Some(flow_type)) => output_format_wrapper.single(flow_type),
110            Ok(None) => Err(NotCreated("Entity instance wasn't created".to_string())),
111            Err(e) => Err(e.into()),
112        },
113        FlowTypesCommands::RemoveEntityInstance(args) => match client.types().flows().remove_entity_instance(&args.flow_ty, args.id).await {
114            Ok(Some(flow_type)) => output_format_wrapper.single(flow_type),
115            Ok(None) => Err(NotCreated("Entity instance wasn't removed".to_string())),
116            Err(e) => Err(e.into()),
117        },
118        FlowTypesCommands::UpdateDescription(args) => match client.types().flows().update_description(&args.flow_ty, args.description).await {
119            Ok(Some(flow_type)) => output_format_wrapper.single(flow_type),
120            Ok(None) => Err(NamespacedTypeNotFound(args.flow_ty.namespaced_type())),
121            Err(e) => Err(e.into()),
122        },
123        FlowTypesCommands::JsonSchema => match client.json_schema().types().flows().await {
124            Ok(Some(json_schema)) => Ok(json_schema.into()),
125            Ok(None) => Err(NotFound("JSON Schema not available".to_string())),
126            Err(e) => Err(e.into()),
127        },
128    }
129}