graphql-schema_comparator 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e193c10ab21868ab4bf6fd6f3159b4d3e4a67525
-  data.tar.gz: 9603fd58643f3a1dabecb23ff543a646657b1f3a
+  metadata.gz: 2bd04f7cdf16f7bc67fb74e219478457b180e022
+  data.tar.gz: eb021f9745da0a4fed5fb2cedfb5a848ca1685b0
 SHA512:
-  metadata.gz: bced670ccc797b2222231e60d930d167e1856d820722c0c4946c45fe2d84c96fcdd50f9e91089a83a82adc9f9dee212aa6636c810a48e57745ece7b7a1d48c50
-  data.tar.gz: ea0916f65eb4de48038077dff40add62c7fa9d5581293d1618c4b045086545b465e13aecfb0c0390f1147496d47bcee7c5ef10c09ec0c5f5cf2f4503bb04bbb8
+  metadata.gz: 7a6d826fd10f0bb42eebcc9546c77d40b32242d5c6888181e5dab77b7c1f9d4ce8d4be192ef750209d98d7230ee81aa0121645f6c1482b6fc1d80e9d5287f02e
+  data.tar.gz: f43508482f55b5b88b1627b5b9d12ce6800512a2386cb66785348f01951d25384d1142d62370dc7d339530d0593998200005ced1a4ae01402a24940676bbc62d

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.5.0 (Dec 2 2017)
+
+## New Features
+
+  - `AbstractChange#criticality` now returns a criticality object which
+  has a level (non_breaking, dangerous, breaking) and a reason
+
+  - Schema::ComparatorResult maintains a list of `#dangerous_changes`
+
+  - New Methods: Change.non_breaking? Change.dangerous?
+
+  - New CLI `schema_comparator` which includes `dangerous_changes`
+
+## Breaking Changes
+
+  - Some changes have been recategorized as dangerous
+  - Some type changes now return breaking or non-breaking depending on the type kind
+
 ## 0.4.0 (Nov 27 2017)
 
 ## Breaking Changes

data/README.md

@@ -3,7 +3,7 @@
 [![Build Status](https://travis-ci.org/xuorig/graphql-schema_comparator.svg?branch=master)](https://travis-ci.org/xuorig/graphql-schema_comparator)
 
 `GraphQL::SchemaComparator` is a GraphQL Schema comparator. What does that mean? `GraphQL::SchemaComparator` takes
-two GraphQL schemas and outputs a list of changes that happened between the two versions. This is useful for many things:
+two GraphQL schemas and outputs a list of changes between versions. This is useful for many things:
 
   - Breaking Change detection
   - Applying custom rules to schema changes
@@ -28,26 +28,40 @@ Or install it yourself as:
 ## CLI
 
 `GraphQL::SchemaComparator` comes with a handy CLI to help compare two schemas using
-the commandline.
+the command line.
 
 After a `gem install graphql-schema_comparator`, use the CLI this way:
 
 ```
 Commands:
-  graphql-schema compare OLD_SCHEMA NEW_SCHEMA  # Compares OLD_SCHEMA with NEW_SCHEMA and returns a list of changes
-  graphql-schema help [COMMAND]                 # Describe available commands or one specific command
+  schema_comparator compare OLD_SCHEMA NEW_SCHEMA  # Compares OLD_SCHEMA with NEW_SCHEMA and returns a list of changes
+  schema_comparator help [COMMAND]                 # Describe available commands or one specific command
 ```
 
 Where OLD_SCHEMA and NEW_SCHEMA can be a string containing a schema IDL or a filename where that IDL is located.
 
 ### Example
 
-![comparator result](http://i.imgur.com/FnItukM.png)
+```
+$ ./bin/schema_comparator compare "type Query { a: A } type A { a: String } enum B { A_VALUE }" "type Query { a: A } type A { b: String } enum B { A_VALUE ANOTHER_VALUE }"
+⏳  Checking for changes...
+🎉  Done! Result:
+
+Detected the following changes between schemas:
+
+🛑  Field `a` was removed from object type `A`
+⚠️  Enum value `ANOTHER_VALUE` was added to enum `B`
+✅  Field `b` was added to object type `A`
+```
 
 ## Usage
 
 `GraphQL::SchemaComparator`, provides a simple api for Ruby applications to use.
 
+## Docs
+
+http://www.rubydoc.info/github/xuorig/graphql-schema_comparator/master/GraphQL/SchemaComparator
+
 ### GraphQL::SchemaComparator.compare
 
 The compare method takes two arguments, `old_schema` and `new_schema`, the two schemas to compare.
@@ -61,31 +75,22 @@ access information on the changes between the two schemas.
  - `result.identical?` returns true if the two schemas were identical
  - `result.breaking_changes` returns the list of breaking changes found between schemas.
  - `result.non_breaking_changes` returns the list of non-breaking changes found between schemas.
+ - `result.dangerous_changes` returns the list of dangerous changes found between schemas.
 - `result.changes` returns the full list of change objects.
 
 ### Change Objects
 
-Change objects are considered any objects that respond to `message` and `breaking` and they
-are all namespaced under the `Changes` module.
+`GraphQL::SchemaComparator` returns a list of change objects. These change objects
+all inherit from `Changes::AbstractChange`
 
 Possible changes are all found in [changes.rb](lib/graphql/schema_comparator/changes.rb).
 
-## TODO
-
-  - [ ] Handle changes in schema directives
-  - [ ] Test each differ
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/xuorig/graphql-schema_comparator. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+### Change Criticality
 
+Each change object has a ``#criticality` method which returns a `Changes::Criticality` object.
+This objects defines how dangerous a change is to a schema.
 
-## License
+The different levels of criticality (non_breaking, dangerous, breaking) are explained here:
+https://github.com/xuorig/graphql-schema_comparator/blob/master/lib/graphql/schema_comparator/changes/criticality.rb#L6-L19
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/bin/graphql-schema

@@ -8,6 +8,8 @@ class GraphQLSchema < Thor
   desc "compare OLD_SCHEMA NEW_SCHEMA", "Compares OLD_SCHEMA with NEW_SCHEMA and returns a list of changes"
 
   def compare(old_schema, new_schema)
+    say "[Warning] graphql-schema is deprecated. Please use `schema_comparator` instead", :yellow
+
     parsed_old = parse_schema(old_schema)
     parsed_new = parse_schema(new_schema)
 

data/bin/schema_comparator

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "thor"
+require "graphql/schema_comparator"
+
+class GraphQLSchema < Thor
+  desc "compare OLD_SCHEMA NEW_SCHEMA", "Compares OLD_SCHEMA with NEW_SCHEMA and returns a list of changes"
+
+  def compare(old_schema, new_schema)
+    parsed_old = parse_schema(old_schema)
+    parsed_new = parse_schema(new_schema)
+
+    say "⏳  Checking for changes..."
+    result = GraphQL::SchemaComparator.compare(parsed_old, parsed_new)
+
+    say "🎉  Done! Result:"
+    say "\n"
+
+    if result.identical?
+      say "✅  Schemas are identical"
+    else
+      print_changes(result)
+    end
+  end
+
+  private
+
+  def print_changes(result)
+    say "Detected the following changes between schemas:"
+    say "\n"
+
+    result.changes.each do |change|
+      if change.breaking?
+        say "🛑  #{change.message}", :red
+      elsif change.dangerous?
+        say "⚠️  #{change.message}", :yellow
+      else
+        say "✅  #{change.message}", :green
+      end
+    end
+  end
+
+  def parse_schema(schema)
+    if File.file?(schema)
+      File.read(schema)
+    elsif schema.is_a?(String)
+      schema
+    else
+      raise ArgumentError, "Invalid argument #{schema}. Must be an IDL string or file containing the schema IDL."
+    end
+  end
+end
+
+GraphQLSchema.start(ARGV)

data/graphql-schema_comparator.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
     f.match(%r{^(test|spec|features)/})
   end
   spec.bindir        = "bin"
-  spec.executables   = ["graphql-schema"]
+  spec.executables   = ["graphql-schema", "schema_comparator"]
   spec.require_paths = ["lib"]
 
   spec.add_dependency "graphql", "~> 1.6"

data/lib/graphql/schema_comparator.rb

@@ -1,9 +1,10 @@
 require "graphql"
 
 require "graphql/schema_comparator/version"
-require "graphql/schema_comparator/changes"
 require "graphql/schema_comparator/result"
 
+require 'graphql/schema_comparator/changes'
+
 require "graphql/schema_comparator/diff/schema"
 require "graphql/schema_comparator/diff/argument"
 require "graphql/schema_comparator/diff/directive"
@@ -18,6 +19,11 @@ require "graphql/schema_comparator/diff/union"
 
 module GraphQL
   module SchemaComparator
+    # Compares and returns changes for two versions of a schema
+    #
+    # @param old_schema [GraphQL::Schema, String]
+    # @param new_schema [GraphQL::Schema, String]
+    # @return [GraphQL::SchemaComparator::Result] the result of the comparison
     def self.compare(old_schema, new_schema)
       parsed_old = parse_schema(old_schema)
       parsed_new = parse_schema(new_schema)

data/lib/graphql/schema_comparator/changes.rb

@@ -1,41 +1,46 @@
+require 'graphql/schema_comparator/changes/criticality'
+require 'graphql/schema_comparator/changes/safe_type_change'
+
 module GraphQL
   module SchemaComparator
     module Changes
-      module SafeTypeChange
-        def safe_change?(old_type, new_type)
-          if !old_type.kind.wraps? && !new_type.kind.wraps?
-            old_type == new_type
-          elsif old_type.kind.list? && new_type.kind.list?
-            safe_change?(old_type.of_type, new_type.of_type)
-          elsif old_type.kind.non_null?
-            of_type = new_type.kind.non_null? ? new_type.of_type : new_type
-            safe_change?(old_type.of_type, of_type)
-          else
-            false
-          end
-        end
-      end
-
+      # Base class for change objects
       class AbstractChange
+        # A message describing the change that happened between the two version
+        # @return [String] The change message
         def message
           raise NotImplementedError
         end
 
+      # @return [Boolean] If the change is breaking or not
         def breaking?
+          criticality.breaking?
+        end
+
+        # @return [Boolean] If the change is dangerous or not
+        def dangerous?
+          criticality.dangerous?
+        end
+
+        # @return [Boolean] If the change is non breaking
+        def non_breaking?
+          criticality.non_breaking?
+        end
+
+        # @return [GraphQL::SchemaComparator::Changes::Criticality] The criticality of this change
+        def criticality
           raise NotImplementedError
         end
       end
 
+      # Mostly breaking changes
+
       class TypeRemoved < AbstractChange
-        attr_reader :removed_type
+        attr_reader :removed_type, :criticality
 
         def initialize(removed_type)
           @removed_type = removed_type
-          @breaking = true
-        end
-
-        def breaking?
-          !!@breaking
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
@@ -44,296 +49,499 @@ module GraphQL
       end
 
       class DirectiveRemoved < AbstractChange
-        attr_reader :directive
+        attr_reader :directive, :criticality
 
         def initialize(directive)
           @directive = directive
-          @breaking = true
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
           "`#{directive.name}` was removed"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class TypeKindChanged < AbstractChange
-        attr_reader :old_type, :new_type
+        attr_reader :old_type, :new_type, :criticality
 
         def initialize(old_type, new_type)
           @old_type = old_type
           @new_type = new_type
-          @breaking = true
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
           "`#{old_type.name}` kind changed from `#{old_type.kind}` to `#{new_type.kind}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class EnumValueRemoved < AbstractChange
-        attr_reader :enum_value, :enum_type
+        attr_reader :enum_value, :enum_type, :criticality
 
         def initialize(enum_type, enum_value)
           @enum_value = enum_value
           @enum_type = enum_type
-          @breaking = true
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
           "Enum value `#{enum_value.name}` was removed from enum `#{enum_type.name}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class UnionMemberRemoved < AbstractChange
-        attr_reader :union_type, :union_member
+        attr_reader :union_type, :union_member, :criticality
 
         def initialize(union_type, union_member)
           @union_member = union_member
           @union_type = union_type
-          @breaking = true
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
           "Union member `#{union_member.name}` was removed from Union type `#{union_type.name}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class InputFieldRemoved < AbstractChange
-        attr_reader :input_object_type, :field
+        attr_reader :input_object_type, :field, :criticality
 
         def initialize(input_object_type, field)
           @input_object_type = input_object_type
           @field = field
-          @breaking = true
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
           "Input field `#{field.name}` was removed from input object type `#{input_object_type.name}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class FieldArgumentRemoved < AbstractChange
-        attr_reader :object_type, :field, :argument
+        attr_reader :object_type, :field, :argument, :criticality
 
         def initialize(object_type, field, argument)
           @object_type = object_type
           @field = field
           @argument = argument
-          @breaking = true
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
           "Argument `#{argument.name}: #{argument.type}` was removed from field `#{object_type.name}.#{field.name}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class DirectiveArgumentRemoved < AbstractChange
-        attr_reader :directive, :argument
+        attr_reader :directive, :argument, :criticality
 
         def initialize(directive, argument)
           @directive = directive
           @argument = argument
-          @breaking = true
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
           "Argument `#{argument.name}` was removed from directive `#{directive.name}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class SchemaQueryTypeChanged < AbstractChange
-        attr_reader :old_schema, :new_schema
+        attr_reader :old_schema, :new_schema, :criticality
 
         def initialize(old_schema, new_schema)
           @old_schema = old_schema
           @new_schema = new_schema
-          @breaking = true
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
           "Schema query root has changed from `#{old_schema.query.name}` to `#{new_schema.query.name}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class FieldRemoved < AbstractChange
-        attr_reader :object_type, :field
+        attr_reader :object_type, :field, :criticality
 
         def initialize(object_type, field)
           @object_type = object_type
           @field = field
-          @breaking = true
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
           "Field `#{field.name}` was removed from object type `#{object_type.name}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class DirectiveLocationRemoved < AbstractChange
-        attr_reader :directive, :location
+        attr_reader :directive, :location, :criticality
 
         def initialize(directive, location)
           @directive = directive
           @location = location
-          @breaking = true
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
           "Location `#{location}` was removed from directive `#{directive.name}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class ObjectTypeInterfaceRemoved < AbstractChange
-        attr_reader :interface, :object_type
+        attr_reader :interface, :object_type, :criticality
 
         def initialize(interface, object_type)
           @interface = interface
           @object_type = object_type
-          @breaking = true
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
           "`#{object_type.name}` object type no longer implements `#{interface.name}` interface"
         end
+      end
 
-        def breaking?
-          !!@breaking
+      class FieldTypeChanged < AbstractChange
+        include SafeTypeChange
+
+        attr_reader :type, :old_field, :new_field
+
+        def initialize(type, old_field, new_field)
+          @type = type
+          @old_field = old_field
+          @new_field = new_field
+        end
+
+        def message
+          "Field `#{type}.#{old_field.name}` changed type from `#{old_field.type}` to `#{new_field.type}`"
+        end
+
+        def criticality
+          if safe_change_for_field?(old_field.type, new_field.type)
+            Changes::Criticality.non_breaking
+          else
+            Changes::Criticality.breaking
+          end
         end
       end
 
-      class TypeAdded < AbstractChange
-        attr_reader :type
+      class InputFieldTypeChanged < AbstractChange
+        include SafeTypeChange
 
-        def initialize(type)
-          @type = type
-          @breaking = false
+        attr_reader :input_type, :old_input_field, :new_input_field, :criticality
+
+        def initialize(input_type, old_input_field, new_input_field)
+          if safe_change_for_input_value?(old_input_field.type, new_input_field.type)
+            @criticality = Changes::Criticality.non_breaking(
+              reason: "Changing an input field from non-null to null is considered non-breaking"
+            )
+          else
+            @criticality = Changes::Criticality.breaking
+          end
+
+          @input_type = input_type
+          @old_input_field = old_input_field
+          @new_input_field = new_input_field
         end
 
         def message
-          "Type `#{type.name}` was added"
+          "Input field `#{input_type}.#{old_input_field.name}` changed type from `#{old_input_field.type}` to `#{new_input_field.type}`"
         end
+      end
 
-        def breaking?
-          !!@breaking
+      class FieldArgumentTypeChanged < AbstractChange
+        include SafeTypeChange
+
+        attr_reader :type, :field, :old_argument, :new_argument, :criticality
+
+        def initialize(type, field, old_argument, new_argument)
+          if safe_change_for_input_value?(old_argument.type, new_argument.type)
+            @criticality = Changes::Criticality.non_breaking(
+              reason: "Changing an input field from non-null to null is considered non-breaking"
+            )
+          else
+            @criticality = Changes::Criticality.breaking
+          end
+
+          @type = type
+          @field = field
+          @old_argument = old_argument
+          @new_argument = new_argument
+        end
+
+        def message
+          "Type for argument `#{new_argument.name}` on field `#{type.name}.#{field.name}` changed"\
+            " from `#{old_argument.type}` to `#{new_argument.type}`"
         end
       end
 
-      class DirectiveAdded < AbstractChange
-        attr_reader :directive
+      class DirectiveArgumentTypeChanged < AbstractChange
+        include SafeTypeChange
+
+        attr_reader :directive, :old_argument, :new_argument, :criticality
+
+        def initialize(directive, old_argument, new_argument)
+          if safe_change_for_input_value?(old_argument.type, new_argument.type)
+            @criticality = Changes::Criticality.non_breaking(
+              reason: "Changing an input field from non-null to null is considered non-breaking"
+            )
+          else
+            @criticality = Changes::Criticality.breaking
+          end
 
-        def initialize(directive)
           @directive = directive
-          @breaking = false
+          @old_argument = old_argument
+          @new_argument = new_argument
         end
 
         def message
-          "Directive `#{directive.name}` was added"
+          "Type for argument `#{new_argument.name}` on directive `#{directive.name}` changed"\
+            " from `#{old_argument.type}` to `#{new_argument.type}`"
         end
+      end
 
-        def breaking?
-          !!@breaking
+      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
       end
 
-      class TypeDescriptionChanged < AbstractChange
-        attr_reader :old_type, :new_type
+      class SchemaSubscriptionTypeChanged < AbstractChange
+        attr_reader :old_schema, :new_schema, :criticality
 
-        def initialize(old_type, new_type)
-          @old_type = old_type
-          @new_type = new_type
-          @breaking = false
+        def initialize(old_schema, new_schema)
+          @old_schema = old_schema
+          @new_schema = new_schema
+          @criticality = Changes::Criticality.breaking
         end
 
         def message
-          "Description `#{old_type.description}` on type `#{old_type.name}` has changed to `#{new_type.description}`"
+          "Schema subscription type has changed from `#{old_schema.subscription}` to `#{new_schema.subscription}`"
         end
+      end
 
-        def breaking?
-          !!@breaking
+      # Dangerous Changes
+
+      class FieldArgumentDefaultChanged < AbstractChange
+        attr_reader :type, :field, :old_argument, :new_argument, :criticality
+
+        def initialize(type, field, old_argument, new_argument)
+          @type = type
+          @field = field
+          @old_argument = old_argument
+          @new_argument = new_argument
+          @criticality = Changes::Criticality.dangerous(
+            reason: "Changing the default value for an argument may change the runtime " \
+              "behaviour of a field if it was never provided."
+          )
+        end
+
+        def message
+          "Default value for argument `#{new_argument.name}` on field `#{type.name}.#{field.name}` changed"\
+            " from `#{old_argument.default_value}` to `#{new_argument.default_value}`"
+        end
+      end
+
+      class InputFieldDefaultChanged < AbstractChange
+        attr_reader :input_type, :old_field, :new_field, :criticality
+
+        def initialize(input_type, old_field, new_field)
+          @criticality = Changes::Criticality.dangerous(
+            reason: "Changing the default value for an argument may change the runtime " \
+              "behaviour of a field if it was never provided."
+          )
+          @input_type = input_type
+          @old_field = old_field
+          @new_field = new_field
+        end
+
+        def message
+          "Input field `#{input_type.name}.#{old_field.name}` default changed"\
+            " from `#{old_field.default_value}` to `#{new_field.default_value}`"
+        end
+      end
+
+      class DirectiveArgumentDefaultChanged < AbstractChange
+        attr_reader :directive, :old_argument, :new_argument, :criticality
+
+        def initialize(directive, old_argument, new_argument)
+          @criticality = Changes::Criticality.dangerous(
+            reason: "Changing the default value for an argument may change the runtime " \
+              "behaviour of a field if it was never provided."
+          )
+          @directive = directive
+          @old_argument = old_argument
+          @new_argument = new_argument
+        end
+
+        def message
+          "Default value for argument `#{new_argument.name}` on directive `#{directive.name}` changed"\
+            " from `#{old_argument.default_value}` to `#{new_argument.default_value}`"
         end
       end
 
       class EnumValueAdded < AbstractChange
-        attr_reader :enum_type, :enum_value
+        attr_reader :enum_type, :enum_value, :criticality
 
         def initialize(enum_type, enum_value)
           @enum_type = enum_type
           @enum_value = enum_value
-          @breaking = false
+          @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."
+          )
+        end
+
+        def message
+          "Enum value `#{enum_value.name}` was added to enum `#{enum_type.name}`"
+        end
+      end
+
+      class UnionMemberAdded < AbstractChange
+        attr_reader :union_type, :union_member, :criticality
+
+        def initialize(union_type, union_member)
+          @union_member = union_member
+          @union_type = union_type
+          @criticality = Changes::Criticality.dangerous(
+            reason: "Adding a possible type to Unions may break existing clients " \
+              "that were not programming defensively against a new possible type."
+          )
+        end
+
+        def message
+          "Union member `#{union_member.name}` was added to Union type `#{union_type.name}`"
+        end
+      end
+
+      class ObjectTypeInterfaceAdded < AbstractChange
+        attr_reader :interface, :object_type, :criticality
+
+        def initialize(interface, object_type)
+          @criticality = Changes::Criticality.dangerous(
+            reason: "Adding an interface to an object type may break existing clients " \
+              "that were not programming defensively against a new possible type."
+          )
+          @interface = interface
+          @object_type = object_type
+        end
+
+        def message
+          "`#{object_type.name}` object implements `#{interface.name}` interface"
+        end
+      end
+
+      # Mostly Non-Breaking Changes
+
+      class InputFieldAdded < AbstractChange
+        attr_reader :input_object_type, :field, :criticality
+
+        def initialize(input_object_type, field)
+          @criticality = if field.type.non_null?
+            Changes::Criticality.breaking
+          else
+            Changes::Criticality.non_breaking
+          end
+
+          @input_object_type = input_object_type
+          @field = field
+        end
+
+        def message
+          "Input field `#{field.name}` was added to input object type `#{input_object_type.name}`"
+        end
+      end
+
+      class FieldArgumentAdded < AbstractChange
+        attr_reader :type, :field, :argument, :criticality
+
+        def initialize(type, field, argument)
+          @criticality = if argument.type.non_null?
+            Changes::Criticality.breaking
+          else
+            Changes::Criticality.non_breaking
+          end
+
+          @type = type
+          @field = field
+          @argument = argument
+        end
+
+        def message
+          "Argument `#{argument.name}: #{argument.type}` added to field `#{type.name}.#{field.name}`"
+        end
+      end
+
+      class TypeAdded < AbstractChange
+        attr_reader :type, :criticality
+
+        def initialize(type)
+          @type = type
+          @criticality = Changes::Criticality.non_breaking
+        end
+
+        def message
+          "Type `#{type.name}` was added"
+        end
+      end
+
+      class DirectiveAdded < AbstractChange
+        attr_reader :directive, :criticality
+
+        def initialize(directive)
+          @directive = directive
+          @criticality = Changes::Criticality.non_breaking
+        end
+
+        def message
+          "Directive `#{directive.name}` was added"
+        end
+      end
+
+      class TypeDescriptionChanged < AbstractChange
+        attr_reader :old_type, :new_type, :criticality
+
+        def initialize(old_type, new_type)
+          @old_type = old_type
+          @new_type = new_type
+          @criticality = Changes::Criticality.non_breaking
         end
 
         def message
-          "Enum value `#{enum_value.name}` was added to enum `#{enum_type.name}`"
-        end
-
-        def breaking?
-          !!@breaking
+          "Description `#{old_type.description}` on type `#{old_type.name}` has changed to `#{new_type.description}`"
         end
       end
 
       class EnumValueDescriptionChanged < AbstractChange
-        attr_reader :enum, :old_enum_value, :new_enum_value
+        attr_reader :enum, :old_enum_value, :new_enum_value, :criticality
 
         def initialize(enum, old_enum_value, new_enum_value)
           @enum = enum
           @old_enum_value = old_enum_value
           @new_enum_value = new_enum_value
+          @criticality = Changes::Criticality.non_breaking
         end
 
         def message
           "Description for enum value `#{enum.name}.#{new_enum_value.name}` changed from " \
             "`#{old_enum_value.description}` to `#{new_enum_value.description}`"
         end
-
-        def breaking?
-          false
-        end
       end
 
       class EnumValueDeprecated < AbstractChange
-        attr_reader :enum, :old_enum_value, :new_enum_value
+        attr_reader :enum, :old_enum_value, :new_enum_value, :criticality
 
         def initialize(enum, old_enum_value, new_enum_value)
+          @criticality = Changes::Criticality.non_breaking
           @enum = enum
           @old_enum_value = old_enum_value
           @new_enum_value = new_enum_value
@@ -348,263 +556,131 @@ module GraphQL
               " `#{new_enum_value.deprecation_reason}`"
           end
         end
-
-        def breaking?
-          false
-        end
-      end
-
-      class UnionMemberAdded < AbstractChange
-        attr_reader :union_type, :union_member
-
-        def initialize(union_type, union_member)
-          @union_member = union_member
-          @union_type = union_type
-          @breaking = false
-        end
-
-        def message
-          "Union member `#{union_member.name}` was added to Union type `#{union_type.name}`"
-        end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class InputFieldDescriptionChanged < AbstractChange
-        attr_reader :input_type, :old_field, :new_field
+        attr_reader :input_type, :old_field, :new_field, :criticality
 
         def initialize(input_type, old_field, new_field)
+          @criticality = Changes::Criticality.non_breaking
           @input_type = input_type
           @old_field = old_field
           @new_field = new_field
-          @breaking = false
         end
 
         def message
           "Input field `#{input_type.name}.#{old_field.name}` description changed"\
             " from `#{old_field.description}` to `#{new_field.description}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class DirectiveDescriptionChanged < AbstractChange
-        attr_reader :old_directive, :new_directive
+        attr_reader :old_directive, :new_directive, :criticality
 
         def initialize(old_directive, new_directive)
+          @criticality = Changes::Criticality.non_breaking
           @old_directive = old_directive
           @new_directive = new_directive
-          @breaking = false
         end
 
         def message
           "Directive `#{new_directive.name}` description changed"\
             " from `#{old_directive.description}` to `#{new_directive.description}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class FieldDescriptionChanged < AbstractChange
-        attr_reader :type, :old_field, :new_field
+        attr_reader :type, :old_field, :new_field, :criticality
 
         def initialize(type, old_field, new_field)
+          @criticality = Changes::Criticality.non_breaking
           @type = type
           @old_field = old_field
           @new_field = new_field
-          @breaking = false
         end
 
         def message
           "Field `#{type.name}.#{old_field.name}` description changed"\
             " from `#{old_field.description}` to `#{new_field.description}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class FieldArgumentDescriptionChanged < AbstractChange
-        attr_reader :type, :field, :old_argument, :new_argument
+        attr_reader :type, :field, :old_argument, :new_argument, :criticality
 
         def initialize(type, field, old_argument, new_argument)
+          @criticality = Changes::Criticality.non_breaking
           @type = type
           @field = field
           @old_argument = old_argument
           @new_argument = new_argument
-          @breaking = false
         end
 
         def message
           "Description for argument `#{new_argument.name}` on field `#{type.name}.#{field.name}` changed"\
             " from `#{old_argument.description}` to `#{new_argument.description}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class DirectiveArgumentDescriptionChanged < AbstractChange
-        attr_reader :directive, :old_argument, :new_argument
+        attr_reader :directive, :old_argument, :new_argument, :criticality
 
         def initialize(directive, old_argument, new_argument)
+          @criticality = Changes::Criticality.non_breaking
           @directive = directive
           @old_argument = old_argument
           @new_argument = new_argument
-          @breaking = false
         end
 
         def message
           "Description for argument `#{new_argument.name}` on directive `#{directive.name}` changed"\
             " from `#{old_argument.description}` to `#{new_argument.description}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class FieldDeprecationChanged < AbstractChange
-        attr_reader :type, :old_field, :new_field
+        attr_reader :type, :old_field, :new_field, :criticality
 
         def initialize(type, old_field, new_field)
+          @criticality = Changes::Criticality.non_breaking
           @type = type
           @old_field = old_field
           @new_field = new_field
-          @breaking = false
         end
 
         def message
           "Deprecation reason on field `#{type.name}.#{new_field.name}` has changed "\
             "from `#{old_field.deprecation_reason}` to `#{new_field.deprecation_reason}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
-      end
-
-      class InputFieldDefaultChanged < AbstractChange
-        attr_reader :input_type, :old_field, :new_field
-
-        def initialize(input_type, old_field, new_field)
-          @input_type = input_type
-          @old_field = old_field
-          @new_field = new_field
-          @breaking = false
-        end
-
-        def message
-          "Input field `#{input_type.name}.#{old_field.name}` default changed"\
-            " from `#{old_field.default_value}` to `#{new_field.default_value}`"
-        end
-
-        def breaking?
-          !!@breaking
-        end
-      end
-
-      class FieldArgumentDefaultChanged < AbstractChange
-        attr_reader :type, :field, :old_argument, :new_argument
-
-        def initialize(type, field, old_argument, new_argument)
-          @type = type
-          @field = field
-          @old_argument = old_argument
-          @new_argument = new_argument
-          @breaking = false
-        end
-
-        def message
-          "Default value for argument `#{new_argument.name}` on field `#{type.name}.#{field.name}` changed"\
-            " from `#{old_argument.default_value}` to `#{new_argument.default_value}`"
-        end
-
-        def breaking?
-          !!@breaking
-        end
-      end
-
-      class DirectiveArgumentDefaultChanged < AbstractChange
-        attr_reader :directive, :old_argument, :new_argument
-
-        def initialize(directive, old_argument, new_argument)
-          @directive = directive
-          @old_argument = old_argument
-          @new_argument = new_argument
-          @breaking = false
-        end
-
-        def message
-          "Default value for argument `#{new_argument.name}` on directive `#{directive.name}` changed"\
-            " from `#{old_argument.default_value}` to `#{new_argument.default_value}`"
-        end
-
-        def breaking?
-          !!@breaking
-        end
-      end
-
-      class ObjectTypeInterfaceAdded < AbstractChange
-        attr_reader :interface, :object_type
-
-        def initialize(interface, object_type)
-          @interface = interface
-          @object_type = object_type
-          @breaking = false
-        end
-
-        def message
-          "`#{object_type.name}` object implements `#{interface.name}` interface"
-        end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       class FieldAdded < AbstractChange
-        attr_reader :object_type, :field
+        attr_reader :object_type, :field, :criticality
 
         def initialize(object_type, field)
+          @criticality = Changes::Criticality.non_breaking
           @object_type = object_type
           @field = field
-          @breaking = false
         end
 
         def message
           "Field `#{field.name}` was added to object type `#{object_type.name}`"
         end
 
-        def breaking?
-          !!@breaking
-        end
       end
 
       class DirectiveLocationAdded < AbstractChange
-        attr_reader :directive, :location
+        attr_reader :directive, :location, :criticality
 
         def initialize(directive, location)
+          @criticality = Changes::Criticality.non_breaking
           @directive = directive
           @location = location
-          @breaking = false
         end
 
         def message
           "Location `#{location}` was added to directive `#{directive.name}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
       end
 
       # TODO
@@ -751,177 +827,22 @@ module GraphQL
         end
       end
 
-      class InputFieldAdded < AbstractChange
-        attr_reader :input_object_type, :field
-
-        def initialize(input_object_type, field)
-          @input_object_type = input_object_type
-          @field = field
-          @breaking = field.type.kind.non_null? ? true : false
-        end
-
-        def message
-          "Input field `#{field.name}` was added to input object type `#{input_object_type.name}`"
-        end
-
-        def breaking?
-          !!@breaking
-        end
-      end
-
-      class FieldArgumentAdded < AbstractChange
-        attr_reader :type, :field, :argument
-
-        def initialize(type, field, argument)
-          @type = type
-          @field = field
-          @argument = argument
-          # TODO: should at least have a warning that it may still be breaking
-          @breaking = argument.type.kind.non_null? ? true : false
-        end
-
-        def message
-          "Argument `#{argument.name}: #{argument.type}` added to field `#{type.name}.#{field.name}`"
-        end
-
-        def breaking?
-          !!@breaking
-        end
-      end
-
       class DirectiveArgumentAdded < AbstractChange
-        attr_reader :directive, :argument
+        attr_reader :directive, :argument, :criticality
 
         def initialize(directive, argument)
+          @criticality = if argument.type.non_null?
+            Changes::Criticality.breaking
+          else
+            Changes::Criticality.non_breaking
+          end
           @directive = directive
           @argument = argument
-          @breaking = false
         end
 
         def message
           "Argument `#{argument.name}` was added to directive `#{directive.name}`"
         end
-
-        def breaking?
-          !!@breaking
-        end
-      end
-
-      class InputFieldTypeChanged < AbstractChange
-        include SafeTypeChange
-
-        attr_reader :input_type, :old_input_field, :new_input_field
-
-        def initialize(input_type, old_input_field, new_input_field)
-          @input_type = input_type
-          @old_input_field = old_input_field
-          @new_input_field = new_input_field
-          @breaking = !safe_change?(old_input_field.type, new_input_field.type)
-        end
-
-        def message
-          "Input field `#{input_type}.#{old_input_field.name}` changed type from #{old_input_field.type} to #{new_input_field.type}"
-        end
-
-        def breaking?
-          !!@breaking
-        end
-      end
-
-      class FieldArgumentTypeChanged < AbstractChange
-        include SafeTypeChange
-
-        attr_reader :type, :field, :old_argument, :new_argument
-
-        def initialize(type, field, old_argument, new_argument)
-          @type = type
-          @field = field
-          @old_argument = old_argument
-          @new_argument = new_argument
-          @breaking = !safe_change?(old_argument.type, new_argument.type)
-        end
-
-        def message
-          "Type for argument `#{new_argument.name}` on field `#{type.name}.#{field.name}` changed"\
-            " from `#{old_argument.type}` to `#{new_argument.type}`"
-        end
-
-        def breaking?
-          !!@breaking
-        end
-      end
-
-      class DirectiveArgumentTypeChanged < AbstractChange
-        attr_reader :directive, :old_argument, :new_argument
-
-        def initialize(directive, old_argument, new_argument)
-          @directive = directive
-          @old_argument = old_argument
-          @new_argument = new_argument
-          @breaking = false
-        end
-
-        def message
-          "Type for argument `#{new_argument.name}` on directive `#{directive.name}` changed"\
-            " from `#{old_argument.type}` to `#{new_argument.type}`"
-        end
-
-        def breaking?
-          !!@breaking
-        end
-      end
-
-      class FieldTypeChanged < AbstractChange
-        attr_reader :type, :old_field, :new_field
-
-        def initialize(type, old_field, new_field)
-          @type = type
-          @old_field = old_field
-          @new_field = new_field
-          @breaking = true
-        end
-
-        def message
-          "Field `#{type}.#{old_field.name}` changed type from `#{old_field.type}` to `#{new_field.type}`"
-        end
-
-        def breaking?
-          !!@breaking
-        end
-      end
-
-      class SchemaMutationTypeChanged < AbstractChange
-        attr_reader :old_schema, :new_schema
-
-        def initialize(old_schema, new_schema)
-          @old_schema = old_schema
-          @new_schema = new_schema
-          @breaking = true
-        end
-
-        def message
-          "Schema mutation root has changed from `#{old_schema.mutation}` to `#{new_schema.mutation}`"
-        end
-
-        def breaking?
-          !!@breaking
-        end
-      end
-
-      class SchemaSubscriptionTypeChanged < AbstractChange
-        def initialize(old_schema, new_schema)
-          @old_schema = old_schema
-          @new_schema = new_schema
-          @breaking = true
-        end
-
-        def message
-          "Schema subscription type has changed from `#{old_schema.subscription}` to `#{new_schema.subscription}`"
-        end
-
-        def breaking?
-          !!@breaking
-        end
       end
     end
   end