Incrementally build Enum schema changes

Reviewed By: tyao1

Differential Revision: D54547131

fbshipit-source-id: 51619edbdaa3b21cb96be815e7f96a3a6da8f503

Author: evanyeung

compiler/crates/dependency-analyzer/Cargo.toml

@@ -22,6 +22,7 @@ graphql-syntax = { path = "../graphql-syntax" }
 relay-transforms = { path = "../relay-transforms" }
 rustc-hash = "1.1.0"
 schema = { path = "../schema" }
+schema-diff = { path = "../schema-diff" }
 serde = { version = "1.0.185", features = ["derive", "rc"] }
 
 [dev-dependencies]

compiler/crates/dependency-analyzer/src/ir.rs

@@ -15,6 +15,9 @@ use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
 use schema::SDLSchema;
 use schema::Schema;
+use schema_diff::check;
+
+use crate::schema_change_analyzer;
 
 pub type ExecutableDefinitionNameSet = FxHashSet<ExecutableDefinitionName>;
 pub type ExecutableDefinitionNameMap<V> = FxHashMap<ExecutableDefinitionName, V>;
@@ -48,11 +51,16 @@ pub fn get_reachable_ir(
     base_definition_names: ExecutableDefinitionNameSet,
     changed_names: ExecutableDefinitionNameSet,
     schema: &SDLSchema,
+    schema_changes: FxHashSet<check::IncrementalBuildSchemaChange>,
 ) -> Vec<ExecutableDefinition> {
-    if changed_names.is_empty() {
+    if changed_names.is_empty() && schema_changes.is_empty() {
         return vec![];
     }
 
+    let mut all_changed_names: ExecutableDefinitionNameSet =
+        schema_change_analyzer::get_affected_definitions(schema, &definitions, schema_changes);
+    all_changed_names.extend(changed_names);
+
     // For each executable definition, define a `Node` indicating its parents and children
     // Note: There are situations where a name in `changed_names` may not appear
     // in `definitions`, and thus would be missing from `dependency_graph`. This can arise
@@ -64,7 +72,7 @@ pub fn get_reachable_ir(
     let mut visited = Default::default();
     let mut filtered_definitions = Default::default();
 
-    for key in changed_names.into_iter() {
+    for key in all_changed_names.into_iter() {
         if dependency_graph.contains_key(&key) {
             add_related_nodes(
                 &mut visited,

compiler/crates/dependency-analyzer/src/lib.rs

@@ -13,6 +13,7 @@
 mod ast;
 mod ir;
 mod minimized_executable;
+mod schema_change_analyzer;
 
 pub use ast::get_definition_references;
 pub use ast::get_reachable_ast;

compiler/crates/dependency-analyzer/src/schema_change_analyzer.rs

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+use std::collections::HashSet;
+
+use graphql_ir::*;
+use rustc_hash::FxHashSet;
+use schema::SDLSchema;
+use schema::Schema;
+use schema_diff::check::IncrementalBuildSchemaChange;
+
+use crate::ExecutableDefinitionNameSet;
+
+pub fn get_affected_definitions(
+    schema: &SDLSchema,
+    definitions: &[ExecutableDefinition],
+    schema_changes: FxHashSet<IncrementalBuildSchemaChange>,
+) -> ExecutableDefinitionNameSet {
+    SchemaChangeDefinitionFinder::get_definitions(schema, definitions, schema_changes)
+}
+
+struct SchemaChangeDefinitionFinder<'a, 'b> {
+    changed_definitions: ExecutableDefinitionNameSet,
+    current_executable: &'a ExecutableDefinition,
+    schema: &'b SDLSchema,
+    schema_changes: FxHashSet<IncrementalBuildSchemaChange>,
+}
+
+impl SchemaChangeDefinitionFinder<'_, '_> {
+    fn get_definitions(
+        schema: &SDLSchema,
+        definitions: &[ExecutableDefinition],
+        schema_changes: FxHashSet<IncrementalBuildSchemaChange>,
+    ) -> ExecutableDefinitionNameSet {
+        if definitions.is_empty() || schema_changes.is_empty() {
+            return HashSet::default();
+        }
+
+        let mut finder = SchemaChangeDefinitionFinder {
+            changed_definitions: HashSet::default(),
+            current_executable: &definitions[0],
+            schema,
+            schema_changes,
+        };
+        for def in definitions.iter() {
+            finder.current_executable = def;
+            match def {
+                ExecutableDefinition::Operation(operation) => finder.visit_operation(operation),
+                ExecutableDefinition::Fragment(fragment) => finder.visit_fragment(fragment),
+            };
+        }
+        finder.changed_definitions
+    }
+
+    fn get_name_from_executable(&self) -> ExecutableDefinitionName {
+        match self.current_executable {
+            ExecutableDefinition::Operation(node) => {
+                ExecutableDefinitionName::OperationDefinitionName(node.name.item)
+            }
+            ExecutableDefinition::Fragment(node) => {
+                ExecutableDefinitionName::FragmentDefinitionName(node.name.item)
+            }
+        }
+    }
+}
+
+impl Visitor for SchemaChangeDefinitionFinder<'_, '_> {
+    const NAME: &'static str = "DependencyAnalyzerSchemaChangeDefinitionFinder";
+    const VISIT_ARGUMENTS: bool = false;
+    const VISIT_DIRECTIVES: bool = false;
+
+    fn visit_scalar_field(&mut self, field: &ScalarField) {
+        let id = field.definition.item;
+        let type_ = self.schema.field(id).type_.inner();
+        match type_ {
+            schema::definitions::Type::Enum(id) => {
+                let enum_type = self.schema.enum_(id);
+                let key = enum_type.name.item.0;
+                if self
+                    .schema_changes
+                    .contains(&IncrementalBuildSchemaChange::Enum(key))
+                {
+                    self.changed_definitions
+                        .insert(self.get_name_from_executable());
+                }
+            }
+            // We only care about enum fields at the moment. As more changes can be handled,
+            // they should be added here
+            _ => (),
+        }
+    }
+}

compiler/crates/dependency-analyzer/tests/ir/fixtures/schema-and-definitions-change.expected

@@ -0,0 +1,55 @@
+==================================== INPUT ====================================
+# F1, Q2
+query Q1 {
+  me {
+    ...F1
+    ...F2
+  }
+}
+
+fragment F1 on User {
+  userEnum
+}
+
+fragment F2 on User {
+  name
+}
+
+query Q2 {
+  me {
+    ...F2
+    ...F3
+  }
+}
+
+fragment F3 on User {
+  alternate_name
+}
+
+query QUnrelated {
+    me {
+      ...F3
+    }
+}
+
+%extensions%
+# Enum: TestEnum
+
+enum TestEnum {
+    A
+    B
+}
+
+extend type User {
+    userEnum: TestEnum
+}
+==================================== OUTPUT ===================================
+Fragment: F1
+
+Fragment: F2
+
+Fragment: F3
+
+Operation: Q1
+
+Operation: Q2

compiler/crates/dependency-analyzer/tests/ir/fixtures/schema-and-definitions-change.graphql

@@ -0,0 +1,44 @@
+# F1, Q2
+query Q1 {
+  me {
+    ...F1
+    ...F2
+  }
+}
+
+fragment F1 on User {
+  userEnum
+}
+
+fragment F2 on User {
+  name
+}
+
+query Q2 {
+  me {
+    ...F2
+    ...F3
+  }
+}
+
+fragment F3 on User {
+  alternate_name
+}
+
+query QUnrelated {
+    me {
+      ...F3
+    }
+}
+
+%extensions%
+# Enum: TestEnum
+
+enum TestEnum {
+    A
+    B
+}
+
+extend type User {
+    userEnum: TestEnum
+}

compiler/crates/dependency-analyzer/tests/ir/fixtures/schema-enum-change.expected

@@ -0,0 +1,45 @@
+==================================== INPUT ====================================
+#
+query Q1 {
+  me {
+    ...F1
+    ...F2
+  }
+}
+
+fragment F1 on User {
+  userEnum
+}
+
+fragment F2 on User {
+  name
+}
+
+query QUnrelated {
+  me {
+    ...F2
+    ...F3
+  }
+}
+
+fragment F3 on User {
+  alternate_name
+}
+
+%extensions%
+# Enum: TestEnum
+
+enum TestEnum {
+    A
+    B
+}
+
+extend type User {
+    userEnum: TestEnum
+}
+==================================== OUTPUT ===================================
+Fragment: F1
+
+Fragment: F2
+
+Operation: Q1

compiler/crates/dependency-analyzer/tests/ir/fixtures/schema-enum-change.graphql

@@ -0,0 +1,38 @@
+#
+query Q1 {
+  me {
+    ...F1
+    ...F2
+  }
+}
+
+fragment F1 on User {
+  userEnum
+}
+
+fragment F2 on User {
+  name
+}
+
+query QUnrelated {
+  me {
+    ...F2
+    ...F3
+  }
+}
+
+fragment F3 on User {
+  alternate_name
+}
+
+%extensions%
+# Enum: TestEnum
+
+enum TestEnum {
+    A
+    B
+}
+
+extend type User {
+    userEnum: TestEnum
+}