feat(graphql_analyze): noAnonymousOperations

Disallow operations without name, since GraphQL clients usually use
operations' name to cache.

crates/biome_diagnostics_categories/src/categories.rs

@@ -133,6 +133,7 @@ define_categories! {
  "lint/correctness/useValidForDirection": "https://biomejs.dev/linter/rules/use-valid-for-direction",
  "lint/correctness/useYield": "https://biomejs.dev/linter/rules/use-yield",
  "lint/nursery/colorNoInvalidHex": "https://biomejs.dev/linter/rules/color-no-invalid-hex",
+ "lint/nursery/noAnonymousOperations": "https://biomejs.dev/linter/rules/no-anonymous-operations",
  "lint/nursery/noColorInvalidHex": "https://biomejs.dev/linter/rules/no-color-invalid-hex",
  "lint/nursery/noCommonJs": "https://biomejs.dev/linter/rules/no-common-js",
  "lint/nursery/noConsole": "https://biomejs.dev/linter/rules/no-console",

crates/biome_graphql_analyze/Cargo.toml

@@ -16,6 +16,7 @@ biome_console = { workspace = true }
 biome_deserialize = { workspace = true }
 biome_deserialize_macros = { workspace = true }
 biome_diagnostics = { workspace = true }
+biome_graphql_factory = { workspace = true }
 biome_graphql_syntax = { workspace = true }
 biome_rowan = { workspace = true }
 biome_string_case = { workspace = true }

crates/biome_graphql_analyze/src/lib.rs

@@ -7,14 +7,16 @@ pub use crate::registry::visit_registry;
 use crate::suppression_action::GraphqlSuppressionAction;
 use biome_analyze::{
  AnalysisFilter, AnalyzerOptions, AnalyzerSignal, ControlFlow, LanguageRoot, MatchQueryParams,
- MetadataRegistry, RuleRegistry, SuppressionKind,
+ MetadataRegistry, RuleAction, RuleRegistry, SuppressionKind,
 };
 use biome_diagnostics::{category, Error};
 use biome_graphql_syntax::GraphqlLanguage;
 use biome_suppression::{parse_suppression_comment, SuppressionDiagnostic};
 use std::ops::Deref;
 use std::sync::LazyLock;
 
+pub(crate) type GraphqlRuleAction = RuleAction<GraphqlLanguage>;
+
 pub static METADATA: LazyLock<MetadataRegistry> = LazyLock::new(|| {
  let mut metadata = MetadataRegistry::default();
  visit_registry(&mut metadata);

crates/biome_graphql_analyze/src/lint/nursery.rs

@@ -2,13 +2,15 @@
 
 use biome_analyze::declare_lint_group;
 
+pub mod no_anonymous_operations;
 pub mod no_duplicated_fields;
 pub mod use_deprecated_reason;
 
 declare_lint_group! {
  pub Nursery {
  name : "nursery" ,
  rules : [
+ self :: no_anonymous_operations :: NoAnonymousOperations ,
  self :: no_duplicated_fields :: NoDuplicatedFields ,
  self :: use_deprecated_reason :: UseDeprecatedReason ,
  ]

crates/biome_graphql_analyze/src/lint/nursery/no_anonymous_operations.rs

@@ -0,0 +1,120 @@
+use biome_analyze::{
+ context::RuleContext, declare_lint_rule, ActionCategory, Ast, FixKind, Rule, RuleDiagnostic,
+ RuleSource, RuleSourceKind,
+};
+use biome_console::markup;
+use biome_graphql_factory::make;
+use biome_graphql_syntax::GraphqlOperationDefinition;
+use biome_rowan::{AstNode, AstNodeExt, BatchMutationExt};
+use biome_string_case::Case;
+
+use crate::GraphqlRuleAction;
+
+declare_lint_rule! {
+ /// Require specifying name for GraphQL operations.
+ ///
+ /// This is useful since most GraphQL client libraries are using the operation name for caching purposes..
+ ///
+ /// ## Examples
+ ///
+ /// ### Invalid
+ ///
+ /// ```graphql,expect_diagnostic
+ /// query {}
+ /// ```
+ ///
+ /// ### Valid
+ ///
+ /// ```graphql
+ /// query Human {
+ /// name
+ /// }
+ /// ```
+ ///
+ pub NoAnonymousOperations {
+ version: "next",
+ name: "noAnonymousOperations",
+ language: "graphql",
+ sources: &[RuleSource::EslintGraphql("no-anonymous-operations")],
+ source_kind: RuleSourceKind::SameLogic,
+ recommended: true,
+ fix_kind: FixKind::Unsafe,
+ }
+}
+
+impl Rule for NoAnonymousOperations {
+ type Query = Ast<GraphqlOperationDefinition>;
+ type State = NoAnonymousOperationsState;
+ type Signals = Option<Self::State>;
+ type Options = ();
+
+ fn run(ctx: &RuleContext<Self>) -> Option<Self::State> {
+ let node = ctx.query();
+ let operation_type = node.ty().ok()?.text();
+ if node.name().is_some() {
+ None
+ } else {
+ Some(NoAnonymousOperationsState {
+ operation_type: operation_type.clone(),
+ suggested_name: get_suggested_name(node, operation_type),
+ })
+ }
+ }
+
+ fn diagnostic(ctx: &RuleContext<Self>, state: &Self::State) -> Option<RuleDiagnostic> {
+ let node = ctx.query();
+
+ Some(
+ RuleDiagnostic::new(
+ rule_category!(),
+ node.range(),
+ markup! {
+ "Anonymous GraphQL operations are forbidden. Make sure to name your " {state.operation_type}"!"
+ },
+ )
+ .note(markup! {
+ "Rename this "{state.operation_type}" to "{state.suggested_name}"."
+ }),
+ )
+ }
+
+ fn action(ctx: &RuleContext<Self>, state: &Self::State) -> Option<GraphqlRuleAction> {
+ let mut mutation = ctx.root().begin();
+ let node = ctx.query().clone();
+ let new_name = make::graphql_name_binding(make::ident(&state.suggested_name));
+ let new_node = node.clone().detach().with_name(Some(new_name));
+ mutation.replace_node(node, new_node);
+
+ Some(GraphqlRuleAction::new(
+ ActionCategory::QuickFix,
+ ctx.metadata().applicability(),
+ markup! {
+ "Rename this "{state.operation_type}" to "{state.suggested_name}"."
+ },
+ mutation,
+ ))
+ }
+}
+
+fn get_suggested_name(operation: &GraphqlOperationDefinition, operation_type: String) -> String {
+ let suggested_name = get_suggested_name_base_on_content(operation).unwrap_or(operation_type);
+ Case::Pascal.convert(&suggested_name)
+}
+
+fn get_suggested_name_base_on_content(operation: &GraphqlOperationDefinition) -> Option<String> {
+ let selection_set = operation.selection_set().ok()?;
+ let first_field = selection_set
+ .selections()
+ .into_iter()
+ .find_map(|selection| selection.as_graphql_field().cloned())?;
+
+ first_field
+ .alias()
+ .map(|alias| alias.text())
+ .or(first_field.name().ok().map(|name| name.text()))
+}
+
+pub struct NoAnonymousOperationsState {
+ operation_type: String,
+ suggested_name: String,
+}

crates/biome_graphql_analyze/tests/specs/nursery/noAnonymousOperations/invalid.graphql

@@ -0,0 +1,3 @@
+query { human }
+mutation { ...Type }
+subscription {}

crates/biome_graphql_analyze/tests/specs/nursery/noAnonymousOperations/invalid.graphql.snap

@@ -0,0 +1,71 @@
+---
+source: crates/biome_graphql_analyze/tests/spec_tests.rs
+expression: invalid.graphql
+---
+# Input
+```graphql
+query { human }
+mutation { ...Type }
+subscription {}
+
+```
+
+# Diagnostics
+```
+invalid.graphql:1:1 lint/nursery/noAnonymousOperations FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ ! Anonymous GraphQL operations are forbidden. Make sure to name your query!
+ 
+ > 1 │ query { human }
+ │ ^^^^^^^^^^^^^^^
+ 2 │ mutation { ...Type }
+ 3 │ subscription {}
+ 
+ i Rename this query to Human.
+ 
+ i Unsafe fix: Rename this query to Human.
+ 
+ 1 │ query·Human{·human·}
+ │ +++++ 
+
+```
+
+```
+invalid.graphql:2:1 lint/nursery/noAnonymousOperations FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ ! Anonymous GraphQL operations are forbidden. Make sure to name your mutation!
+ 
+ 1 │ query { human }
+ > 2 │ mutation { ...Type }
+ │ ^^^^^^^^^^^^^^^^^^^^
+ 3 │ subscription {}
+ 4 │ 
+ 
+ i Rename this mutation to Mutation.
+ 
+ i Unsafe fix: Rename this mutation to Mutation.
+ 
+ 2 │ mutation·Mutation{·...Type·}
+ │ ++++++++ 
+
+```
+
+```
+invalid.graphql:3:1 lint/nursery/noAnonymousOperations FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ ! Anonymous GraphQL operations are forbidden. Make sure to name your subscription!
+ 
+ 1 │ query { human }
+ 2 │ mutation { ...Type }
+ > 3 │ subscription {}
+ │ ^^^^^^^^^^^^^^^
+ 4 │ 
+ 
+ i Rename this subscription to Subscription.
+ 
+ i Unsafe fix: Rename this subscription to Subscription.
+ 
+ 3 │ subscription·Subscription{}
+ │ ++++++++++++ 
+
+```

crates/biome_graphql_analyze/tests/specs/nursery/noAnonymousOperations/valid.graphql

@@ -0,0 +1,4 @@
+/* should not generate diagnostics */
+query myQuery { a }
+mutation doSomething { a }
+subscription myData { a }

crates/biome_graphql_analyze/tests/specs/nursery/noAnonymousOperations/valid.graphql.snap

@@ -0,0 +1,12 @@
+---
+source: crates/biome_graphql_analyze/tests/spec_tests.rs
+expression: valid.graphql
+---
+# Input
+```graphql
+/* should not generate diagnostics */
+query myQuery { a }
+mutation doSomething { a }
+subscription myData { a }
+
+```

crates/biome_graphql_factory/src/lib.rs

@@ -2,6 +2,7 @@ use biome_graphql_syntax::GraphqlLanguage;
 use biome_rowan::TreeBuilder;
 
 mod generated;
+pub mod make;
 pub use crate::generated::GraphqlSyntaxFactory;
 
 // Re-exported for tests

crates/biome_graphql_factory/src/make.rs

@@ -0,0 +1,7 @@
+pub use crate::generated::node_factory::*;
+use biome_graphql_syntax::{GraphqlSyntaxKind, GraphqlSyntaxToken};
+
+/// Create a new literal name token with no attached trivia
+pub fn ident(text: &str) -> GraphqlSyntaxToken {
+ GraphqlSyntaxToken::new_detached(GraphqlSyntaxKind::IDENT, text, [], [])
+}