reactive_graph/client/types/flows/
mod.rs1use 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}