graphql-schema_comparator 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ec082ccd9621ae89f5a9ed29c027cbff4a785a3bac913bd5000b3e1a914f43d
-  data.tar.gz: f6924765894399193664e370a2464327c20e1ed0c9f35d252699893c75706736
+  metadata.gz: 9a21994b860741a5060b7600e7473348c0bf0445ecca50ea68966762448a967f
+  data.tar.gz: b4197e9f75dac972f474fd578fab78588b54f77ade6d36b126ad57a3f702b85c
 SHA512:
-  metadata.gz: 326440a4c85adbadc3c0fafb262653e88226a55cec0a1d336a750270925a334bdfbcbfeec62e36dfa5f08d4179e8a2304622fc0e34520695de1c67ee20833a0c
-  data.tar.gz: '069cf716049a9746cb88825734d968112ed512312c12d69da39a6d019f1257d9c74357cae5d7756bdfc5c9f8bea2f2ab8ec0bfbe21664b2e7e1e7c24d046b37e'
+  metadata.gz: 0b637ed11e3ba28902bd61f9e082cb0ac20f0be6868450b70e6e04df56b0019cbdba4a869d750e4dcaee4af454da799ae05512d2299300cbab3497d5d09d8392
+  data.tar.gz: 276c28e5588937b25361937ae594ff678981f71ac84f8f370ebada3e917e8f22f44a54c8dfb32cb9cfa8bf4e58b467dc42de6eb8ef22f864446b50c23f668a1e

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.2.0 (October 18 2023)
+
+### Bug Fix
+
+  - More selective detection of breaking/dangerous enum value changes (#54)
+  - Improve schema root operation type changes (#55)
+
+## 1.1.2 (September 15 2022)
+
+### Bug Fix
+
+  - Fix field argument removed message (#51)
+  - Fix safe type change comparison (#53)
+
 ## 1.1.1 (January 7 2022)
 
 ### Bug Fix

data/lib/graphql/schema_comparator/changes/safe_type_change.rb

@@ -4,7 +4,7 @@ module GraphQL
       module SafeTypeChange
         def safe_change_for_field?(old_type, new_type)
           if !old_type.kind.wraps? && !new_type.kind.wraps?
-            old_type == new_type
+            old_type.graphql_name == new_type.graphql_name
           elsif new_type.kind.non_null?
             of_type = old_type.kind.non_null? ? old_type.of_type : old_type
             safe_change_for_field?(of_type, new_type.of_type)
@@ -18,7 +18,7 @@ module GraphQL
 
         def safe_change_for_input_value?(old_type, new_type)
           if !old_type.kind.wraps? && !new_type.kind.wraps?
-            old_type == new_type
+            old_type.graphql_name == new_type.graphql_name
           elsif old_type.kind.list? && new_type.kind.list?
             safe_change_for_input_value?(old_type.of_type, new_type.of_type)
           elsif old_type.kind.non_null?

data/lib/graphql/schema_comparator/changes.rb

@@ -99,12 +99,18 @@ module GraphQL
       class EnumValueRemoved < AbstractChange
         attr_reader :enum_value, :enum_type, :criticality
 
-        def initialize(enum_type, enum_value)
+        def initialize(enum_type, enum_value, usage)
           @enum_value = enum_value
           @enum_type = enum_type
-          @criticality = Changes::Criticality.breaking(
-            reason: "Removing an enum value will cause existing queries that use this enum value to error."
-          )
+          @criticality = if usage.input?
+                           Changes::Criticality.breaking(
+                             reason: "Removing an enum value will cause existing queries that use this enum value to error."
+                           )
+                         else
+                           Changes::Criticality.non_breaking(
+                             reason: "Removing an enum value for enums used only in outputs is non-breaking."
+                           )
+                         end
         end
 
         def message
@@ -169,7 +175,7 @@ module GraphQL
         end
 
         def message
-          "Argument `#{argument.graphql_name}: #{argument.type.graphql_name}` was removed from field `#{object_type.graphql_name}.#{field.graphql_name}`"
+          "Argument `#{argument.graphql_name}: #{argument.type.to_type_signature}` was removed from field `#{object_type.graphql_name}.#{field.graphql_name}`"
         end
 
         def path
@@ -195,21 +201,93 @@ module GraphQL
         end
       end
 
-      class SchemaQueryTypeChanged < AbstractChange
-        attr_reader :old_schema, :new_schema, :criticality
+      class RootOperationTypeAdded < AbstractChange
+        attr_reader :new_schema, :operation_type, :criticality
+
+        def initialize(new_schema:, operation_type:)
+          @new_schema = new_schema
+          @operation_type = operation_type
+          @criticality = Changes::Criticality.non_breaking(
+            reason: "Adding a schema #{operation_type} root is considered non-breaking."
+          )
+        end
+
+        def message
+          "Schema #{operation_type} root `#{operation_type_name}` was added"
+        end
+
+        def path
+          operation_type_name
+        end
+
+        def operation_type_name
+          case operation_type
+            when :query
+              new_schema.query.graphql_name
+            when :mutation
+              new_schema.mutation.graphql_name
+            when :subscription
+              new_schema.subscription.graphql_name
+          end
+        end
+      end
+
+      class RootOperationTypeChanged < AbstractChange
+        attr_reader :old_schema, :new_schema, :operation_type, :criticality
 
-        def initialize(old_schema, new_schema)
+        def initialize(old_schema:, new_schema:, operation_type:)
           @old_schema = old_schema
           @new_schema = new_schema
+          @operation_type = operation_type
           @criticality = Changes::Criticality.breaking
         end
 
         def message
-          "Schema query root has changed from `#{old_schema.query.graphql_name}` to `#{new_schema.query.graphql_name}`"
+          "Schema #{operation_type} root has changed from `#{operation_type_name(old_schema)}` to `#{operation_type_name(new_schema)}`"
         end
 
         def path
-          # TODO
+          operation_type_name(old_schema)
+        end
+
+        def operation_type_name(schema)
+          case operation_type
+            when :query
+              schema.query.graphql_name
+            when :mutation
+              schema.mutation.graphql_name
+            when :subscription
+              schema.subscription.graphql_name
+          end
+        end
+      end
+
+      class RootOperationTypeRemoved < AbstractChange
+        attr_reader :old_schema, :operation_type, :criticality
+
+        def initialize(old_schema:, operation_type:)
+          @old_schema = old_schema
+          @operation_type = operation_type
+          @criticality = Changes::Criticality.breaking
+        end
+
+        def message
+          "Schema #{operation_type} root `#{operation_type_name}` was removed"
+        end
+
+        def path
+          operation_type_name
+        end
+
+        def operation_type_name
+          case operation_type
+            when :query
+              old_schema.query.graphql_name
+            when :mutation
+              old_schema.mutation.graphql_name
+            when :subscription
+              old_schema.subscription.graphql_name
+          end
         end
       end
 
@@ -398,42 +476,6 @@ module GraphQL
         end
       end
 
-      class SchemaMutationTypeChanged < AbstractChange
-        attr_reader :old_schema, :new_schema, :criticality
-
-        def initialize(old_schema, new_schema)
-          @old_schema = old_schema
-          @new_schema = new_schema
-          @criticality = Changes::Criticality.breaking
-        end
-
-        def message
-          "Schema mutation root has changed from `#{old_schema.mutation}` to `#{new_schema.mutation}`"
-        end
-
-        def path
-          # TODO
-        end
-      end
-
-      class SchemaSubscriptionTypeChanged < AbstractChange
-        attr_reader :old_schema, :new_schema, :criticality
-
-        def initialize(old_schema, new_schema)
-          @old_schema = old_schema
-          @new_schema = new_schema
-          @criticality = Changes::Criticality.breaking
-        end
-
-        def message
-          "Schema subscription type has changed from `#{old_schema.subscription}` to `#{new_schema.subscription}`"
-        end
-
-        def path
-          # TODO
-        end
-      end
-
       # Dangerous Changes
 
       class FieldArgumentDefaultChanged < AbstractChange
@@ -451,11 +493,11 @@ module GraphQL
         end
 
         def message
-          if old_argument.default_value.nil? || old_argument.default_value == :__no_default__
-            "Default value `#{new_argument.default_value}` was added to argument `#{new_argument.graphql_name}` on field `#{field.path}`"
-          else
+          if old_argument.default_value?
             "Default value for argument `#{new_argument.graphql_name}` on field `#{field.path}` changed"\
               " from `#{old_argument.default_value}` to `#{new_argument.default_value}`"
+          else
+            "Default value `#{new_argument.default_value}` was added to argument `#{new_argument.graphql_name}` on field `#{field.path}`"
           end
         end
 
@@ -501,8 +543,12 @@ module GraphQL
         end
 
         def message
-          "Default value for argument `#{new_argument.graphql_name}` on directive `#{directive.graphql_name}` changed"\
-            " from `#{old_argument.default_value}` to `#{new_argument.default_value}`"
+          if old_argument.default_value?
+            "Default value for argument `#{new_argument.graphql_name}` on directive `#{directive.graphql_name}` changed"\
+              " from `#{old_argument.default_value}` to `#{new_argument.default_value}`"
+          else
+            "Default value `#{new_argument.default_value}` was added to argument `#{new_argument.graphql_name}` on directive `#{directive.graphql_name}`"
+          end
         end
 
         def path
@@ -513,13 +559,19 @@ module GraphQL
       class EnumValueAdded < AbstractChange
         attr_reader :enum_type, :enum_value, :criticality
 
-        def initialize(enum_type, enum_value)
+        def initialize(enum_type, enum_value, usage)
           @enum_type = enum_type
           @enum_value = enum_value
-          @criticality = Changes::Criticality.dangerous(
-            reason: "Adding an enum value may break existing clients that were not " \
-              "programming defensively against an added case when querying an enum."
-          )
+          @criticality = if usage.output?
+                           Changes::Criticality.dangerous(
+                             reason: "Adding an enum value may break existing clients that were not " \
+                              "programmed defensively against an added case when querying an enum."
+                           )
+                         else
+                           Changes::Criticality.non_breaking(
+                             reason: "Adding an enum value for enums used only in inputs is non-breaking."
+                           )
+                         end
         end
 
         def message

data/lib/graphql/schema_comparator/diff/enum.rb

@@ -2,19 +2,21 @@ module GraphQL
   module SchemaComparator
     module Diff
       class Enum
-        def initialize(old_enum, new_enum)
+        def initialize(old_enum, new_enum, usage)
           @old_enum = old_enum
           @new_enum = new_enum
 
           @old_values = old_enum.values
           @new_values = new_enum.values
+
+          @usage = usage
         end
 
         def diff
           changes = []
 
-          changes += removed_values.map { |value| Changes::EnumValueRemoved.new(old_enum, value) }
-          changes += added_values.map { |value| Changes::EnumValueAdded.new(new_enum, value) }
+          changes += removed_values.map { |value| Changes::EnumValueRemoved.new(old_enum, value, usage) }
+          changes += added_values.map { |value| Changes::EnumValueAdded.new(new_enum, value, usage) }
 
           each_common_value do |old_value, new_value|
             # TODO: Add Directive Stuff
@@ -33,7 +35,7 @@ module GraphQL
 
         private
 
-        attr_reader :old_enum, :new_enum, :old_values, :new_values
+        attr_reader :old_enum, :new_enum, :old_values, :new_values, :usage
 
         def each_common_value(&block)
           intersection = old_values.keys & new_values.keys

data/lib/graphql/schema_comparator/diff/schema.rb

@@ -42,7 +42,7 @@ module GraphQL
           else
             case old_type.kind.name
             when "ENUM"
-              changes += Diff::Enum.new(old_type, new_type).diff
+              changes += Diff::Enum.new(old_type, new_type, enum_usage(new_type)).diff
             when "UNION"
               changes += Diff::Union.new(old_type, new_type).diff
             when "INPUT_OBJECT"
@@ -65,15 +65,33 @@ module GraphQL
           changes = []
 
           if old_schema.query&.graphql_name != new_schema.query&.graphql_name
-            changes << Changes::SchemaQueryTypeChanged.new(old_schema, new_schema)
+            if old_schema.query.nil?
+              changes << Changes::RootOperationTypeAdded.new(new_schema: new_schema, operation_type: :query)
+            elsif new_schema.query.nil?
+              changes << Changes::RootOperationTypeRemoved.new(old_schema: old_schema, operation_type: :query)
+            else
+              changes << Changes::RootOperationTypeChanged.new(old_schema: old_schema, new_schema: new_schema, operation_type: :query)
+            end
           end
 
           if old_schema.mutation&.graphql_name != new_schema.mutation&.graphql_name
-            changes << Changes::SchemaMutationTypeChanged.new(old_schema, new_schema)
+            if old_schema.mutation.nil?
+              changes << Changes::RootOperationTypeAdded.new(new_schema: new_schema, operation_type: :mutation)
+            elsif new_schema.mutation.nil?
+              changes << Changes::RootOperationTypeRemoved.new(old_schema: old_schema, operation_type: :mutation)
+            else
+              changes << Changes::RootOperationTypeChanged.new(old_schema: old_schema, new_schema: new_schema, operation_type: :mutation)
+            end
           end
 
           if old_schema.subscription&.graphql_name != new_schema.subscription&.graphql_name
-            changes << Changes::SchemaSubscriptionTypeChanged.new(old_schema, new_schema)
+            if old_schema.subscription.nil?
+              changes << Changes::RootOperationTypeAdded.new(new_schema: new_schema, operation_type: :subscription)
+            elsif new_schema.subscription.nil?
+              changes << Changes::RootOperationTypeRemoved.new(old_schema: old_schema, operation_type: :subscription)
+            else
+              changes << Changes::RootOperationTypeChanged.new(old_schema: old_schema, new_schema: new_schema, operation_type: :subscription)
+            end
           end
 
           changes
@@ -94,6 +112,12 @@ module GraphQL
 
         private
 
+        def enum_usage(new_enum)
+          input_usage = new_schema.references_to(new_enum).any? { |member| member.is_a?(GraphQL::Schema::Argument) }
+          output_usage = new_schema.references_to(new_enum).any? { |member| member.is_a?(GraphQL::Schema::Field) }
+          EnumUsage.new(input: input_usage, output: output_usage)
+        end
+
         def each_common_type(&block)
           intersection = old_types.keys & new_types.keys
           intersection.each do |common_type_name|

data/lib/graphql/schema_comparator/enum_usage.rb

@@ -0,0 +1,18 @@
+module GraphQL
+  module SchemaComparator
+    class EnumUsage
+      def initialize(input:, output:)
+        @input = input
+        @output = output
+      end
+
+      def input?
+        @input
+      end
+
+      def output?
+        @output
+      end
+    end
+  end
+end

data/lib/graphql/schema_comparator/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module SchemaComparator
-    VERSION = "1.1.1"
+    VERSION = "1.2.0"
   end
 end

data/lib/graphql/schema_comparator.rb

@@ -4,6 +4,7 @@ require "graphql/schema_comparator/version"
 require "graphql/schema_comparator/result"
 
 require 'graphql/schema_comparator/changes'
+require 'graphql/schema_comparator/enum_usage'
 
 require "graphql/schema_comparator/diff/schema"
 require "graphql/schema_comparator/diff/argument"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-schema_comparator
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Marc-Andre Giroux
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-07 00:00:00.000000000 Z
+date: 2023-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -147,6 +147,7 @@ files:
 - lib/graphql/schema_comparator/diff/object_type.rb
 - lib/graphql/schema_comparator/diff/schema.rb
 - lib/graphql/schema_comparator/diff/union.rb
+- lib/graphql/schema_comparator/enum_usage.rb
 - lib/graphql/schema_comparator/result.rb
 - lib/graphql/schema_comparator/version.rb
 - schema.graphql
@@ -158,7 +159,7 @@ metadata:
   changelog_uri: https://github.com/xuorig/graphql-schema_comparator/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/xuorig/graphql-schema_comparator
   bug_tracker_uri: https://github.com/xuorig/graphql-schema_comparator/issues
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -173,8 +174,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: Compare GraphQL schemas and get the changes that happened.
 test_files: []