devoyage-subgraph 0.0.15

Subgraph is a CLI that instantly generates a GraphQL API around Mongo, SQL, and HTTP APIs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use async_graphql::dynamic::FieldValue;
use bson::Document;
use log::debug;

use crate::{
    cli_args::CliArgs,
    configuration::subgraph::{
        data_sources::ServiceDataSourceConfig, entities::ServiceEntityConfig, SubGraphConfig,
    },
    graphql::schema::create_auth_service::TokenData,
    resolver_type::ResolverType,
};

pub mod http;
pub mod mongo;
pub mod sql;

#[derive(Debug, Clone)]
pub enum DataSource {
    Mongo(mongo::MongoDataSource),
    HTTP(http::HttpDataSource),
    SQL(sql::SqlDataSource),
}

#[derive(Debug, Clone)]
pub struct DataSources {
    sources: Vec<DataSource>,
}

pub struct TotalCount(i64);

impl DataSources {
    /// Initialize Data Sources
    pub async fn init(
        service_data_source_configs: Vec<ServiceDataSourceConfig>,
        args: &CliArgs,
        subgraph_config: &SubGraphConfig,
    ) -> DataSources {
        debug!("Initializing Data Sources");
        let mut data_sources = vec![];
        for service_data_source_config in service_data_source_configs {
            match service_data_source_config {
                ServiceDataSourceConfig::Mongo(conf) => {
                    data_sources.push(mongo::MongoDataSource::init(&conf).await);
                }
                ServiceDataSourceConfig::HTTP(conf) => {
                    data_sources.push(http::HttpDataSource::init(&conf).await);
                }
                ServiceDataSourceConfig::SQL(conf) => {
                    data_sources
                        .push(sql::SqlDataSource::init(&conf, args, subgraph_config.clone()).await);
                }
            };
        }

        DataSources {
            sources: data_sources,
        }
    }

    /// Provide entity and all data sources to get the data source for the entity.
    pub fn get_entity_data_soruce<'a>(
        data_sources: &'a DataSources,
        entity: &ServiceEntityConfig,
    ) -> &'a DataSource {
        debug!("Getting Data Source for Entity");
        if entity.data_source.is_some() {
            let data_source = match entity.data_source.as_ref().unwrap().from.as_ref() {
                Some(ds_name) => {
                    let data_source = data_sources
                        .sources
                        .iter()
                        .find(|data_source| match data_source {
                            DataSource::Mongo(ds) => &ds.config.name == ds_name,
                            DataSource::HTTP(ds) => &ds.config.name == ds_name,
                            DataSource::SQL(ds) => &ds.config.name == ds_name,
                        })
                        .unwrap(); //TODO: Unwrap here needs error handling
                    data_source
                }
                _ => panic!("Data source specified for entity but not found."),
            };
            data_source
        } else {
            data_sources.sources.first().unwrap()
        }
    }

    pub fn get_data_source_by_name(data_soruces: &DataSources, name: &str) -> DataSource {
        debug!("Getting Data Source by Name");
        let data_source = data_soruces
            .sources
            .iter()
            .find(|data_source| match data_source {
                DataSource::Mongo(ds) => &ds.config.name == name,
                DataSource::HTTP(ds) => &ds.config.name == name,
                DataSource::SQL(ds) => &ds.config.name == name,
            })
            .unwrap();
        data_source.clone()
    }

    /// Execute a data source operation.
    pub async fn execute<'a>(
        data_sources: &DataSources,
        input: Document,
        entity: ServiceEntityConfig,
        resolver_type: ResolverType,
        subgraph_config: &SubGraphConfig,
        token_data: &Option<TokenData>,
        has_selection_set: bool,
    ) -> Result<Option<FieldValue<'a>>, async_graphql::Error> {
        debug!("Executing Datasource Operation");

        let cloned_entity = entity.clone();

        let data_source = DataSources::get_entity_data_soruce(data_sources, &entity);

        match data_source {
            DataSource::Mongo(_ds) => Ok(mongo::MongoDataSource::execute_operation(
                data_source,
                input,
                cloned_entity,
                resolver_type,
                subgraph_config,
            )
            .await?),
            DataSource::HTTP(_ds) => Ok(http::HttpDataSource::execute_operation(
                data_source,
                input,
                cloned_entity,
                resolver_type,
                subgraph_config,
            )
            .await?),
            DataSource::SQL(_ds) => Ok(sql::SqlDataSource::execute_operation(
                data_source,
                input,
                cloned_entity,
                resolver_type,
                subgraph_config,
                token_data,
                has_selection_set,
            )
            .await?),
        }
    }
}