reactive_graph/client/types/components/
mod.rs

1use std::sync::Arc;
2
3use crate::client::error::CommandError;
4use crate::client::error::CommandError::NoContent;
5use crate::client::error::CommandError::NotCreated;
6use crate::client::error::CommandError::NotFound;
7use crate::client::result::CommandResult;
8use crate::client::types::components::args::ComponentsArgs;
9use crate::client::types::components::commands::ComponentsCommands;
10use crate::client::types::components::output_format::ComponentsOutputFormatWrapper;
11use crate::client::types::extension::output_format::ExtensionsOutputFormatWrapper;
12use crate::client::types::property_type::output_format::PropertyTypesOutputFormatWrapper;
13use reactive_graph_client::ReactiveGraphClient;
14use reactive_graph_graph::Component;
15use reactive_graph_graph::NamespacedTypeContainer;
16use reactive_graph_graph::NamespacedTypeGetter;
17
18pub(crate) mod args;
19pub(crate) mod commands;
20pub(crate) mod output_format;
21
22pub(crate) async fn components(client: &Arc<ReactiveGraphClient>, component_args: ComponentsArgs) -> CommandResult {
23    let output_format_wrapper: ComponentsOutputFormatWrapper = component_args.output_format.clone().into();
24    let Some(command) = component_args.commands else {
25        return Err(CommandError::MissingSubCommand);
26    };
27    match command {
28        ComponentsCommands::List => match client.types().components().get_all_components().await {
29            Ok(Some(components)) => output_format_wrapper.collection(components.to_vec()),
30            Ok(None) => Err(NoContent("No components found".to_string())),
31            Err(e) => Err(e.into()),
32        },
33        ComponentsCommands::Get { component_ty } => match client.types().components().get_component_by_type(&component_ty).await {
34            Ok(Some(component)) => output_format_wrapper.single(component),
35            Ok(None) => Err(CommandError::NamespacedTypeNotFound(component_ty.namespaced_type())),
36            Err(e) => Err(e.into()),
37        },
38        ComponentsCommands::ListProperties { component_ty } => match client.types().components().get_component_by_type(&component_ty).await {
39            Ok(Some(component)) => {
40                let output_format_wrapper: PropertyTypesOutputFormatWrapper = component_args.output_format.into();
41                output_format_wrapper.collection(component.properties.to_vec())
42            }
43            Ok(None) => Err(CommandError::NamespacedTypeNotFound(component_ty.namespaced_type())),
44            Err(e) => Err(e.into()),
45        },
46        ComponentsCommands::ListExtensions { component_ty } => match client.types().components().get_component_by_type(&component_ty).await {
47            Ok(Some(component)) => {
48                let output_format_wrapper: ExtensionsOutputFormatWrapper = component_args.output_format.into();
49                output_format_wrapper.collection(component.extensions.to_vec())
50            }
51            Ok(None) => Err(CommandError::NamespacedTypeNotFound(component_ty.namespaced_type())),
52            Err(e) => Err(e.into()),
53        },
54        ComponentsCommands::GetJsonSchema { component_ty } => match client.types().components().json_schema_for_component_by_type(&component_ty).await {
55            Ok(Some(json_schema)) => Ok(json_schema.into()),
56            Ok(None) => Err(CommandError::NamespacedTypeNotFound(component_ty.namespaced_type())),
57            Err(e) => Err(e.into()),
58        },
59        ComponentsCommands::Create(args) => match client
60            .types()
61            .components()
62            .create_component(
63                Component::builder()
64                    .ty(args.component_ty)
65                    .description(args.description.unwrap_or_default())
66                    .build(),
67            )
68            .await
69        {
70            Ok(Some(component)) => output_format_wrapper.single(component),
71            Ok(None) => Err(NotCreated("Component wasn't created".to_string())),
72            Err(e) => Err(e.into()),
73        },
74        ComponentsCommands::Delete { component_ty } => match client.types().components().delete_component(&component_ty).await {
75            Ok(Some(true)) => Ok(format!("Component {} deleted", component_ty).into()),
76            Ok(Some(false)) => Ok(format!("Component {} not deleted", component_ty).into()),
77            Ok(None) => Err(CommandError::NamespacedTypeNotFound(component_ty.namespaced_type())),
78            Err(e) => Err(e.into()),
79        },
80        ComponentsCommands::AddProperty(args) => match client.types().components().add_property(args.component_ty, &args.property_type).await {
81            Ok(Some(component)) => output_format_wrapper.single(component),
82            Ok(None) => Err(NotCreated("Property wasn't created".to_string())),
83            Err(e) => Err(e.into()),
84        },
85        ComponentsCommands::RemoveProperty(args) => match client
86            .types()
87            .components()
88            .remove_property(&args.component_ty, args.property_name.clone())
89            .await
90        {
91            Ok(Some(component)) => output_format_wrapper.single(component),
92            Ok(None) => Err(NotFound(format!("Component {} not found", args.component_ty))),
93            Err(e) => Err(e.into()),
94        },
95        ComponentsCommands::AddExtension(args) => match client.types().components().add_extension(args.component_ty, &args.extension).await {
96            Ok(Some(component)) => output_format_wrapper.single(component),
97            Ok(None) => Err(NotCreated("Extension wasn't created".to_string())),
98            Err(e) => Err(e.into()),
99        },
100        ComponentsCommands::RemoveExtension(args) => match client.types().components().remove_extension(&args).await {
101            Ok(Some(component)) => output_format_wrapper.single(component),
102            Ok(None) => Err(CommandError::NamespacedTypeNotFound(args.component_ty.namespaced_type())),
103            Err(e) => Err(e.into()),
104        },
105        ComponentsCommands::UpdateDescription(args) => match client.types().components().update_description(&args.component_ty, args.description).await {
106            Ok(Some(component)) => output_format_wrapper.single(component),
107            Ok(None) => Err(CommandError::NamespacedTypeNotFound(args.component_ty.namespaced_type())),
108            Err(e) => Err(e.into()),
109        },
110        ComponentsCommands::JsonSchema => match client.json_schema().types().components().await {
111            Ok(Some(json_schema)) => Ok(json_schema.into()),
112            Ok(None) => Err(NotFound("JSON Schema not available".to_string())),
113            Err(e) => Err(e.into()),
114        },
115    }
116}