Automated GraphQL Schema Generation

[danbi2990]

While working on #984, I found it cumbersome to manually generate GraphQL schema file every time a query changed. Automating this process offers several benefits:

• It prevents human error.
• It streamlines the workflow.

It can be implemented as follows.

/// Add CLI parameter to the Args struct
    #[arg(long, value_name = "EXPORT_SCHEMA_PATH")]
    pub export_schema_path: Option<String>,

/// Add following code in the main function (line 174)
    if let Some(export_schema_path) = args.export_schema_path.as_deref() {
        fs::write(export_schema_path, schema.sdl()).context("Failed to write SDL to file")?;
        return Ok(())
    }

We can then specify the schema file path using the CLI argument --export-schema-path ./src/graphql/client/schema/schema.graphql. If we integrate auto-generation into the build process, the schema file can be excluded from version control.

The above implementation is just one option that came to mind; the key concept is to automate schema generation for a smoother workflow. Your feedback and suggestions would be greatly appreciated.

[sehkone]

I couldn't agree more with your suggestion. Any method might suffice as long as it works correctly. One thing we need to consider more seriously is how to run this feature. It could be included as one of Giganto’s command options, which would generate the schema file and then terminate. Any better ideas are welcome.

[danbi2990]

As discussed with Sophie, if we implement it exactly as described in the text, the build will fail when the schema file is missing. This is a current cyclic dependency issue in Giganto, regardless of the automation feature. (A schema file is required to generate a schema file.)

The actions we can take here are:

• Fundamentally remove the cyclic dependency.
• Ignore the absence of a schema file and automate the generation (assuming that a schema is always present).
  • I will create a separate issue and PR to share the code for this approach. The problem of cyclic dependencies still remains and the build will still fail when schema.graphql is missing. However, since this issue already exists in the current setup, it should be considered separately.

Removing the Cyclic Dependency

Conclusion:
The modifications below seem quite complex and likely won’t be resolved by a simple refactoring, so this option is on hold for now.

Details:
The reason a schema is needed during the build is that Giganto acts as a client for clustering. It appears possible to disable the code referencing the schema using Cargo feature flags.
For example, as shown in the code snippet below, modularizing the schema-dependent code and disabling it in the module tree (within graphql.rs) would be the most straightforward solution. However, significant refactoring will be needed to achieve this modularization.

#[cfg(not(feature = "schema-generation"))]
mod client;

Without modularization, every piece of schema-dependent code would require a feature check. Here are some examples:

• Macros in the graphql.rs file:
  Create two versions of the macro under different feature flags.
  • These macros mainly generate GraphQL query resolver code that references code generated from the schema.
  • When generating the schema, you can remove the internal implementation of the resolver by considering only the types.

// The same macro name is used differently based on the feature

#[cfg(not(feature = "schema-generation"))]
macro_rules! paged_events_in_cluster {
    // ... implementation that uses the schema
}

#[cfg(feature="schema-generation")]
macro_rules! paged_events_in_cluster {
    ($($params:expr),*) => {
        Ok(Connection::new(false, false))
    }
}

• For macros such as events_in_cluster in graphql.rs:
  Parameters that depend on the schema—like variables_type and response_data_type—must be removed. Therefore, the macro itself might need to be modified.

• Attributes in the network.rs file: Use cfg_attr

#[derive(SimpleObject, Debug, ConvertGraphQLEdgesNode)]
#[graphql_client_type(names = [conn_raw_events::ConnRawEventsConnRawEventsEdgesNode, network_raw_events::NetworkRawEventsNetworkRawEventsEdgesNodeOnConnRawEvent])]
pub struct ConnRawEvents;

// becomes

#[derive(SimpleObject, Debug)]
#[cfg_attr(not(feature = "schema-generation"),
           derive(ConvertGraphQLEdgesNode),
           graphql_client_type(names = [
            derives::conn_raw_events::DnsRawEventsDnsRawEventsEdgesNode,
            derives::network_raw_events::NetworkRawEventsNetworkRawEventsEdgesNodeOnDnsRawEvent]))]
pub struct ConnRawEvents;

• Attributes in the derives.rs file: Also using cfg_attr

#[derive(GraphQLQuery)]
#[graphql(
    schema_path = "src/graphql/client/schema/schema.graphql",
    query_path = "src/graphql/client/schema/network_raw_events.graphql",
    response_derives = "Clone, PartialEq"
)]

// becomes

#[cfg_attr(not(feature = "schema-generation"),
           derive(GraphQLQuery),
           graphql(
               schema_path = "src/graphql/client/schema/schema.graphql",
               query_path = "src/graphql/client/schema/network_raw_events.graphql",
               response_derives = "Clone, PartialEq"
           )
)]