General spelling improvements to the code

As prompted by a trade-off made in #7210 (comment)

Author: abernix

.config/mise/config.toml

@@ -12,3 +12,4 @@ rust = "1.85.0"
 "cargo:graphql_client_cli" = "0.14.0"
 "cargo:cargo-llvm-cov" = "0.6.10"
 "cargo:cargo-fuzz" = "0.12.0"
+"cargo:typos-cli" = "1.31.1"

DEVELOPMENT.md

@@ -106,7 +106,7 @@ cargo build --profile release-dhat --features dhat-heap
 
 This will create a router in `./target/release-dhat`, which can be run with:
 ```shell
-cargo run --profile release-dhat --feautures dhat-heap -- -s ./apollo-router/testing_schema.graphql -c router.yaml
+cargo run --profile release-dhat --features dhat-heap -- -s ./apollo-router/testing_schema.graphql -c router.yaml
 ```
 
 When you run your binary, on termination you will get `dhat-heap.json` and/or `dhat-ad-hoc.json` files which can

RELEASE_CHECKLIST.md

@@ -283,7 +283,7 @@ Start following the steps below to start a release PR.  The process is **not ful
     git push --set-upstream "${APOLLO_ROUTER_RELEASE_GIT_ORIGIN}" "prep-${APOLLO_ROUTER_RELEASE_VERSION}"
     ```
 
-15. Programatically create a small temporary file called `this_release.md` with the changelog details of _precisely this release_ from the `CHANGELOG.md`:
+15. Programmatically create a small temporary file called `this_release.md` with the changelog details of _precisely this release_ from the `CHANGELOG.md`:
 
     > Note: This file could totally be created by the `xtask` if we merely decide convention for it and whether we want it checked in or not.  It will be used again later in process and, in theory, by CI.  Definitely not suggesting this should live on as regex.
 

apollo-federation/src/link/link_spec_definition.rs

@@ -156,7 +156,7 @@ impl LinkSpecDefinition {
         //   (in practice, our own code can actually handle this as it does not strongly rely on
         //   that "it should be the first" rule, but that would set a bad example).
         // 2. earlier versions (pre-#1875) were always putting that directive on the definition,
-        //   and we wanted to avoid suprising users by changing that for not reason.
+        //   and we wanted to avoid surprising users by changing that for not reason.
         //
         // So instead, we put the directive on the schema definition unless some extensions exists
         // but no definition does (that is, no non-extension elements are populated).

apollo-federation/src/operation/mod.rs

@@ -77,7 +77,7 @@ static NEXT_ID: atomic::AtomicUsize = atomic::AtomicUsize::new(1);
 ///
 /// NOTE: This ID does not ensure that IDs are unique because its internal counter resets on
 /// startup. It currently implements `Serialize` for debugging purposes. It should not implement
-/// `Deserialize`, and, more specfically, it should not be used for caching until uniqueness is
+/// `Deserialize`, and, more specifically, it should not be used for caching until uniqueness is
 /// provided (i.e. the inner type is a `Uuid` or the like).
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, serde::Serialize)]
 pub(crate) struct SelectionId(usize);
@@ -1324,7 +1324,7 @@ impl SelectionSet {
     /// so we can efficiently generate query plans. In order to prevent the query planner from spending time
     /// exploring those useless __typename options, we "remove" the unnecessary __typename selections from the
     /// operation. Since we need to ensure that the __typename field will still need to be queried, we "tag"
-    /// one of the "sibling" selections (using "attachement") to remember that __typename needs to be added
+    /// one of the "sibling" selections (using "attachment") to remember that __typename needs to be added
     /// back eventually. The core query planning algorithm will ignore that tag, and because __typename has been
     /// otherwise removed, we'll save any related work. As we build the final query plan, we'll check back for
     /// those "tags" and add back the __typename selections. As this only happen after the query planning
@@ -1698,7 +1698,7 @@ impl SelectionSet {
     ///
     /// The final selections are optional. If `path` ends on a leaf field, then no followup
     /// selections would make sense.
-    /// When final selections are provided, unecessary fragments will be automatically removed
+    /// When final selections are provided, unnecessary fragments will be automatically removed
     /// at the junction between the path and those final selections.
     ///
     /// For instance, suppose that we have:
@@ -2144,12 +2144,12 @@ fn compute_aliases_for_non_merging_fields(
                         };
                     }
                 } else {
-                    // We need to alias the new occurence.
+                    // We need to alias the new occurrence.
                     let alias = gen_alias_name(response_name, &seen_response_names);
 
                     // Given how we generate aliases, it's is very unlikely that the generated alias will conflict with any of the other response name
                     // at the level, but it's theoretically possible. By adding the alias to the seen names, we ensure that in the remote change that
-                    // this ever happen, we'll avoid the conflict by giving another alias to the followup occurence.
+                    // this ever happen, we'll avoid the conflict by giving another alias to the followup occurrence.
                     let selections = match field.selection_set.as_ref() {
                         Some(s) => {
                             let mut p = path.clone();

apollo-federation/src/query_graph/graph_path.rs

@@ -257,7 +257,7 @@ pub(crate) struct SubgraphEnteringEdgeInfo {
 ///
 /// NOTE: This ID does not ensure that IDs are unique because its internal counter resets on
 /// startup. It currently implements `Serialize` for debugging purposes. It should not implement
-/// `Deserialize`, and, more specfically, it should not be used for caching until uniqueness is
+/// `Deserialize`, and, more specifically, it should not be used for caching until uniqueness is
 /// provided (i.e. the inner type is a `Uuid` or the like).
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, serde::Serialize)]
 pub(crate) struct OverrideId(usize);

apollo-federation/src/query_plan/fetch_dependency_graph.rs

@@ -822,7 +822,7 @@ impl FetchDependencyGraph {
         // 1. is for the same subgraph
         // 2. has the same merge_at
         // 3. is for the same entity type (we don't reuse nodes for different entities just yet,
-        //    as this can create unecessary dependencies that gets in the way of some optimizations;
+        //    as this can create unnecessary dependencies that gets in the way of some optimizations;
         //    the final optimizations in `reduceAndOptimize` will however later merge nodes
         //    on the same subgraph and mergeAt when possible).
         // 4. is not part of our conditions or our conditions ancestors
@@ -940,7 +940,7 @@ impl FetchDependencyGraph {
             return true;
         }
 
-        // No risk of inifite loop as the graph is acyclic:
+        // No risk of infinite loop as the graph is acyclic:
         let mut to_check = haystack.clone();
         while let Some(next) = to_check.pop() {
             for parent in self.parents_of(next) {
@@ -3851,7 +3851,7 @@ fn compute_nodes_for_op_path_element<'a>(
         // If the operation contains other directives or a non-trivial type condition,
         // we need to preserve it and so we add operation.
         // Otherwise, we just skip it as a minor optimization (it makes the subgraph query
-        // slighly smaller and on complex queries, it might also deduplicate similar selections).
+        // slightly smaller and on complex queries, it might also deduplicate similar selections).
         return Ok(ComputeNodesStackItem {
             tree: &child.tree,
             node_id: stack_item.node_id,

apollo-federation/src/query_plan/fetch_dependency_graph_processor.rs

@@ -302,7 +302,7 @@ impl FetchDependencyGraphProcessor<Option<PlanNode>, DeferredDeferBlock>
                 // Note that currently `ConditionNode` only works for variables
                 // (`ConditionNode.condition` is expected to be a variable name and nothing else).
                 // We could change that, but really, why have a trivial `ConditionNode`
-                // when we can optimise things righ away.
+                // when we can optimise things right away.
                 condition.then_some(value)
             }
             Conditions::Variables(variables) => {

apollo-federation/src/query_plan/generate.rs

@@ -125,7 +125,7 @@ where
     // all plans are guaranteed to be more costly than `initial` anyway.
     // Note that save for `initial`,
     // we always compute `partialCost` as the pros of exiting some branches early are large enough
-    // that it outweight computing some costs unecessarily from time to time.
+    // that it outweigh computing some costs unnecessarily from time to time.
     let mut stack = VecDeque::new();
     stack.push_back(Partial {
         partial_plan: initial,

apollo-federation/src/query_plan/query_planner.rs

@@ -630,7 +630,7 @@ fn compute_root_serial_dependency_graph(
             // PORT_NOTE: It is unclear if they correct thing to do here is get the next ID, use
             // the current ID that is inside the fetch dep graph's ID generator, or to use the
             // starting ID. Because this method ensure uniqueness between IDs, this approach was
-            // taken; however, it could be the case that this causes unforseen issues.
+            // taken; however, it could be the case that this causes unforeseen issues.
             digest.push(std::mem::replace(
                 &mut fetch_dependency_graph,
                 new_dep_graph,

apollo-federation/src/query_plan/query_planning_traversal.rs

@@ -640,7 +640,7 @@ impl<'a: 'b, 'b> QueryPlanningTraversal<'a, 'b> {
         // To guarantee that the selection is fully local from the provided vertex/type, we must have:
         // - no edge crossing subgraphs from that vertex.
         // - the type must be compositeType (mostly just ensuring the selection make sense).
-        // - everything in the selection must be avaiable in the type (which `rebaseOn` essentially validates).
+        // - everything in the selection must be available in the type (which `rebaseOn` essentially validates).
         // - the selection must not "type-cast" into any abstract type that has inconsistent runtimes acrosse subgraphs. The reason for the
         //   later condition is that `selection` is originally a supergraph selection, but that we're looking to apply "as-is" to a subgraph.
         //   But suppose it has a `... on I` where `I` is an interface. Then it's possible that `I` includes "more" types in the supergraph
@@ -913,11 +913,11 @@ impl<'a: 'b, 'b> QueryPlanningTraversal<'a, 'b> {
     }
 
     /// Look at how many plans we'd have to generate and if it's "too much"
-    /// reduce it to something manageable by arbitrarilly throwing out options.
+    /// reduce it to something manageable by arbitrarily throwing out options.
     /// This effectively means that when a query has too many options,
     /// we give up on always finding the "best" query plan in favor of an "ok" query plan.
     ///
-    /// TODO: currently, when we need to reduce options, we do so somewhat arbitrarilly.
+    /// TODO: currently, when we need to reduce options, we do so somewhat arbitrarily.
     /// More precisely, we reduce the branches with the most options first
     /// and then drop the last option of the branch,
     /// repeating until we have a reasonable number of plans to consider.
@@ -1338,7 +1338,7 @@ fn test_prune_and_reorder_first_branch() {
         assert_eq!(branches, expected)
     }
     // Either the first branch had strictly more options than the second,
-    // so it is still at its correct potition after removing one option…
+    // so it is still at its correct position after removing one option…
     assert(
         &["abcdE", "fgh", "ijk", "lmn", "op"],
         &["abcd", "fgh", "ijk", "lmn", "op"],

apollo-federation/src/query_plan/serializable_document.rs

@@ -11,7 +11,7 @@ use serde::Serialize;
 ///
 /// The relevant schema is required to parse from string but not available during deserialization,
 /// so this contains a dual (either or both) “string” or “parsed” representation.
-/// Accessing the latter is fallible, and requires an explicit initilization step to provide the schema.
+/// Accessing the latter is fallible, and requires an explicit initialization step to provide the schema.
 #[derive(Clone)]
 pub struct SerializableDocument {
     serialized: String,

apollo-federation/src/schema/argument_composition_strategies.rs

@@ -140,7 +140,7 @@ impl ArgumentComposition for MaxArgumentCompositionStrategy {
         self.validator.is_type_supported(schema, ty)
     }
 
-    // TODO: check if this neeeds to be an Result<Value> to avoid the panic!()
+    // TODO: check if this needs to be an Result<Value> to avoid the panic!()
     // https://apollographql.atlassian.net/browse/FED-170
     fn merge_values(&self, values: &[Value]) -> Value {
         values
@@ -180,7 +180,7 @@ impl ArgumentComposition for MinArgumentCompositionStrategy {
         self.validator.is_type_supported(schema, ty)
     }
 
-    // TODO: check if this neeeds to be an Result<Value> to avoid the panic!()
+    // TODO: check if this needs to be an Result<Value> to avoid the panic!()
     // https://apollographql.atlassian.net/browse/FED-170
     fn merge_values(&self, values: &[Value]) -> Value {
         values
@@ -220,7 +220,7 @@ impl ArgumentComposition for SumArgumentCompositionStrategy {
         self.validator.is_type_supported(schema, ty)
     }
 
-    // TODO: check if this neeeds to be an Result<Value> to avoid the panic!()
+    // TODO: check if this needs to be an Result<Value> to avoid the panic!()
     // https://apollographql.atlassian.net/browse/FED-170
     fn merge_values(&self, values: &[Value]) -> Value {
         values
@@ -247,7 +247,7 @@ impl ArgumentComposition for IntersectionArgumentCompositionStrategy {
         support_any_non_null_array(ty)
     }
 
-    // TODO: check if this neeeds to be an Result<Value> to avoid the panic!()
+    // TODO: check if this needs to be an Result<Value> to avoid the panic!()
     // https://apollographql.atlassian.net/browse/FED-170
     fn merge_values(&self, values: &[Value]) -> Value {
         // Each item in `values` must be a Value::List(...).
@@ -280,7 +280,7 @@ impl ArgumentComposition for UnionArgumentCompositionStrategy {
         support_any_non_null_array(ty)
     }
 
-    // TODO: check if this neeeds to be an Result<Value> to avoid the panic!()
+    // TODO: check if this needs to be an Result<Value> to avoid the panic!()
     // https://apollographql.atlassian.net/browse/FED-170
     fn merge_values(&self, values: &[Value]) -> Value {
         // Each item in `values` must be a Value::List(...).

apollo-federation/src/schema/mod.rs

@@ -675,7 +675,7 @@ impl ValidFederationSchema {
     ) -> Result<Name, FederationError> {
         // Currently, the types used to define the federation operations, that is _Any, _Entity and _Service,
         // are not considered part of the federation spec, and are instead hardcoded to the names above.
-        // The reason being that there is no way to maintain backward compatbility with fed2 if we were to add
+        // The reason being that there is no way to maintain backward compatibility with fed2 if we were to add
         // those to the federation spec without requiring users to add those types to their @link `import`,
         // and that wouldn't be a good user experience (because most users don't really know what those types
         // are/do). And so we special case it.

apollo-federation/src/schema/subgraph_metadata.rs

@@ -181,7 +181,7 @@ impl SubgraphMetadata {
         federation_spec_definition: &'static FederationSpecDefinition,
     ) -> Result<IndexSet<FieldDefinitionPosition>, FederationError> {
         let mut shareable_fields = IndexSet::default();
-        // @shareable is only avalaible on fed2 schemas, but the schema upgrader call this on fed1 schemas as a shortcut to
+        // @shareable is only available on fed2 schemas, but the schema upgrader call this on fed1 schemas as a shortcut to
         // identify key fields (because if we know nothing is marked @shareable, then the only fields that are shareable
         // by default are key fields).
         let Some(shareable_directive_name) =

apollo-federation/src/sources/connect/expand/mod.rs

@@ -48,7 +48,7 @@ pub enum ExpansionResult {
 /// with standard query planning concepts while still enforcing connector-specific rules. To do so,
 /// each connector is separated into its own unique subgraph with relevant GraphQL directives to enforce
 /// field dependencies and response structures. This allows for satisfiability and validation to piggy-back
-/// off of existing functionality in a reproducable way.
+/// off of existing functionality in a reproducible way.
 pub fn expand_connectors(
     supergraph_str: &str,
     api_schema_options: &ApiSchemaOptions,

apollo-federation/src/sources/connect/json_selection/README.md

@@ -48,7 +48,7 @@ improvements, we should adhere to the following principles:
 2. It must be possible to statically determine the output shape (object
    properties, array types, and nested value shapes) produced by a
    `JSONSelection` string. JSON data encountered at runtime may be inherently
-   dynamic and unpredicatable, but we must be able to validate the output shape
+   dynamic and unpredictable, but we must be able to validate the output shape
    matches the GraphQL schema. Because we can assume all input data is some kind
    of JSON, for types whose shape cannot be statically determined, the GraphQL
    `JSON` scalar type can be used as an "any" type, though this should be

apollo-federation/src/sources/connect/json_selection/location.rs

@@ -157,7 +157,7 @@ pub(crate) mod strip_ranges {
     use super::WithRange;
 
     /// Including location information in the AST introduces unnecessary
-    /// varation in many tests. StripLoc is a test-only trait allowing
+    /// variation in many tests. StripLoc is a test-only trait allowing
     /// participating AST nodes to remove their own and their descendants'
     /// location information, thereby normalizing the AST for assert_eq!
     /// comparisons.

apollo-federation/src/subgraph/spec.rs

@@ -436,7 +436,7 @@ impl FederationSpecDefinitions {
         }
     }
 
-    // The directive is named `@fromContex`. This is confusing for clippy, as
+    // The directive is named `@fromContext`. This is confusing for clippy, as
     // `from` is a conventional prefix used in conversion methods, which do not
     // take `self` as an argument. This function does **not** perform
     // conversion, but extracts `@fromContext` directive definition.

apollo-federation/src/supergraph/mod.rs

@@ -2455,7 +2455,7 @@ mod tests {
                             d: String
                         }
 
-         * This tests is similar to the other test with unions, but because its members are enties, the
+         * This tests is similar to the other test with unions, but because its members are entries, the
          * members themself with have a join__owner, and that means the removal will hit a different
          * code path (technically, the union A will be "removed" directly by `extractSubgraphsFromSupergraph`
          * instead of being removed indirectly through the removal of its members).