graphql-schema_comparator 0.1.0

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

@@ -0,0 +1,44 @@
+module GraphQL
+  module SchemaComparator
+    module Diff
+      class Argument
+        def initialize(type, field, old_arg, new_arg)
+          @type = type
+          @field = field
+
+          @old_arg = old_arg
+          @new_arg = new_arg
+        end
+
+        def diff
+          changes = []
+
+          if old_arg.description != new_arg.description
+            changes << Changes::FieldArgumentDescriptionChanged.new(type, field, old_arg, new_arg)
+          end
+
+          if old_arg.default_value != new_arg.default_value
+            changes << Changes::FieldArgumentDefaultChanged.new(type, field, old_arg, new_arg)
+          end
+
+          if old_arg.type != new_arg.type
+            changes << Changes::FieldArgumentTypeChanged.new(type, field, old_arg, new_arg)
+          end
+
+          # TODO directives
+
+          changes
+        end
+
+        private
+
+        attr_reader(
+          :type,
+          :field,
+          :new_arg,
+          :old_arg
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module GraphQL
+  module SchemaComparator
+    module Diff
+      class Enum
+        def initialize(old_type, new_type)
+          @old_type = old_type
+          @new_type = new_type
+
+          @old_values = old_type.values
+          @new_values = new_type.values
+        end
+
+        def diff
+          changes = []
+
+          changes += removed_values.map { |value| Changes::EnumValueRemoved.new(old_type, value) }
+          changes += added_values.map { |value| Changes::EnumValueAdded.new(new_type, value) }
+
+          each_common_value do |old_value, new_value|
+            # TODO: Add Directive Stuff
+
+            if old_value.description != new_value.description
+              changes += Changes::EnumValueDescriptionChanged.new(old_value, new_value)
+            end
+
+            if old_value.deprecation_reason != new_value.deprecation_reason
+              changes += Changes::EnumValueDeprecated.new(old_value, new_value)
+            end
+          end
+
+          changes
+        end
+
+        private
+
+        attr_reader :old_type, :new_type, :old_values, :new_values
+
+        def each_common_value(&block)
+          intersection = old_values.keys & new_values.keys
+          intersection.each do |common_value|
+            old_value = old_type.values[common_value]
+            new_value = new_type.values[common_value]
+
+            block.call(old_value, new_value)
+          end
+        end
+
+        def removed_values
+          (old_values.keys - new_values.keys).map { |removed| old_type.values[removed] }
+        end
+
+        def added_values
+          (new_values.keys - old_values.keys).map { |added| new_type.values[added] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module GraphQL
+  module SchemaComparator
+    module Diff
+      class Field
+        def initialize(old_type, new_type, old_field, new_field)
+          @old_type = old_type
+          @new_type = new_type
+
+          @old_field = old_field
+          @new_field = new_field
+
+          @old_arguments = old_field.arguments
+          @new_arguments = new_field.arguments
+        end
+
+        def diff
+          changes = []
+
+          if old_field.description != new_field.description
+            changes << Changes::FieldDescriptionChanged.new(new_type, old_field, new_field)
+          end
+
+          if old_field.deprecation_reason != new_field.deprecation_reason
+            changes << Changes::FieldDeprecationChanged.new(new_type, old_field, new_field)
+          end
+
+          if old_field.type != new_field.type
+            changes << Changes::FieldTypeChanged.new(new_type, old_field, new_field)
+          end
+
+          changes += arg_removals
+
+          changes += arg_additions
+
+          each_common_argument do |old_arg, new_arg|
+            changes += Diff::Argument.new(new_type, new_field, old_arg, new_arg).diff
+          end
+
+          # TODO: directives
+
+          changes
+        end
+
+        private
+
+        attr_reader(
+          :old_type,
+          :new_type,
+          :new_field,
+          :old_field,
+          :old_arguments,
+          :new_arguments
+        )
+
+        def arg_removals
+          removed = old_arguments.values.select { |arg| !new_arguments[arg.name] }
+          removed.map { |arg| Changes::FieldArgumentRemoved.new(new_type, old_field, arg) }
+        end
+
+        def arg_additions
+          removed = new_arguments.values.select { |arg| !old_arguments[arg.name] }
+          removed.map { |arg| Changes::FieldArgumentAdded.new(new_type, new_field, arg) }
+        end
+
+        def each_common_argument(&block)
+          intersection = old_arguments.keys & new_arguments.keys
+          intersection.each do |common_arg|
+            old_arg = old_field.arguments[common_arg]
+            new_arg = new_field.arguments[common_arg]
+
+            block.call(old_arg, new_arg)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module GraphQL
+  module SchemaComparator
+    module Diff
+      class InputField
+        def initialize(old_type, new_type, old_field, new_field)
+          @old_type = old_type
+          @new_type = new_type
+
+          @old_field = old_field
+          @new_field = new_field
+        end
+
+        def diff
+          changes = []
+
+          if old_field.description != new_field.description
+            changes << Changes::InputFieldDescriptionChanged.new(old_type, old_field, new_field)
+          end
+
+          if old_field.default_value != new_field.default_value
+            changes << Changes::InputFieldDefaultChanged.new(old_type, old_field, new_field)
+          end
+
+          if old_field.type != new_field.type
+            changes << Changes::InputFieldTypeChanged.new(old_type, old_field, new_field)
+          end
+
+          # TODO: directives
+
+          changes
+        end
+
+        private
+
+        attr_reader :old_type, :new_type, :new_field, :old_field
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module GraphQL
+  module SchemaComparator
+    module Diff
+      class InputObject
+        def initialize(old_type, new_type)
+          @old_type = old_type
+          @new_type = new_type
+
+          @old_fields = old_type.arguments
+          @new_fields = new_type.arguments
+        end
+
+        def diff
+          changes = []
+
+          changes += removed_fields.map { |field| Changes::InputFieldRemoved.new(old_type, field) }
+          changes += added_fields.map { |field| Changes::InputFieldAdded.new(new_type, field) }
+
+          each_common_field do |old_field, new_field|
+            # TODO: Add Directive Stuff
+            changes += InputField.new(old_type, new_type, old_field, new_field).diff
+          end
+
+          changes
+        end
+
+        private
+
+        attr_reader :old_type, :new_type, :old_fields, :new_fields
+
+        def each_common_field(&block)
+          intersection = old_fields.keys & new_fields.keys
+          intersection.each do |common_field|
+            old_field = old_type.arguments[common_field]
+            new_field = new_type.arguments[common_field]
+
+            block.call(old_field, new_field)
+          end
+        end
+
+        def removed_fields
+          old_fields.values.select { |field| !new_fields[field.name] }
+        end
+
+        def added_fields
+          new_fields.values.select { |field| !old_fields[field.name] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module GraphQL
+  module SchemaComparator
+    module Diff
+      class Interface
+        def initialize(old_iface, new_iface)
+          @old_iface = old_iface
+          @new_iface = new_iface
+
+          @old_fields = old_iface.fields
+          @new_fields = new_iface.fields
+        end
+
+        def diff
+          changes = []
+          changes += field_removals
+          changes += field_additions
+
+          each_common_field do |old_field, new_field|
+            changes += Diff::Field.new(old_iface, new_iface, old_field, new_field).diff
+          end
+
+          changes
+        end
+
+        private
+
+        attr_reader :old_iface, :new_iface, :old_fields, :new_fields
+
+        def field_removals
+          removed = old_fields.values.select { |field| !new_fields[field.name] }
+          removed.map { |field| Changes::FieldRemoved.new(old_iface, field) }
+        end
+
+        def field_additions
+          added = new_fields.values.select { |field| !old_fields[field.name] }
+          added.map { |field| Changes::FieldAdded.new(new_iface, field) }
+        end
+
+        def each_common_field(&block)
+          intersection = old_fields.keys & new_fields.keys
+          intersection.each do |common_field|
+            old_field = old_iface.fields[common_field]
+            new_field = new_iface.fields[common_field]
+
+            block.call(old_field, new_field)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module GraphQL
+  module SchemaComparator
+    module Diff
+      class ObjectType
+        def initialize(old_type, new_type)
+          @old_type = old_type
+          @new_type = new_type
+
+          @old_fields = old_type.fields
+          @new_fields = new_type.fields
+
+          @old_interfaces = old_type.interfaces
+          @new_interfaces = new_type.interfaces
+        end
+
+        def diff
+          changes = []
+
+          changes += interface_additions
+          changes += interface_removals
+          changes += field_removals
+          changes += field_additions
+
+          each_common_field do |old_field, new_field|
+            changes += Diff::Field.new(old_type, new_type, old_field, new_field).diff
+          end
+
+          changes
+        end
+
+        private
+
+        attr_reader(
+          :old_type,
+          :new_type,
+          :old_fields,
+          :new_fields,
+          :old_interfaces,
+          :new_interfaces
+        )
+
+        def interface_removals
+          removed = old_interfaces.select { |iface| !new_interfaces.include?(iface) }
+          removed.map { |iface| Changes::ObjectTypeInterfaceRemoved.new(iface, old_type) }
+        end
+
+        def interface_additions
+          added = new_interfaces.select { |iface| !old_interfaces.include?(iface) }
+          added.map { |iface| Changes::ObjectTypeInterfaceAdded.new(iface, new_type) }
+        end
+
+        def field_removals
+          removed = old_fields.values.select { |field| !new_fields[field.name] }
+          removed.map { |field| Changes::FieldRemoved.new(old_type, field) }
+        end
+
+        def field_additions
+          added = new_fields.values.select { |field| !old_fields[field.name] }
+          added.map { |field| Changes::FieldAdded.new(new_type, field) }
+        end
+
+        def each_common_field(&block)
+          intersection = old_fields.keys & new_fields.keys
+          intersection.each do |common_field|
+            old_field = old_type.fields[common_field]
+            new_field = new_type.fields[common_field]
+
+            block.call(old_field, new_field)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+require "graphql/schema_comparator/diff/enum"
+require "graphql/schema_comparator/diff/union"
+require "graphql/schema_comparator/diff/input_object"
+require "graphql/schema_comparator/diff/input_field"
+require "graphql/schema_comparator/diff/object_type"
+require "graphql/schema_comparator/diff/interface"
+require "graphql/schema_comparator/diff/field"
+require "graphql/schema_comparator/diff/argument"
+
+module GraphQL
+  module SchemaComparator
+    module Diff
+      class Schema
+        def initialize(old_schema, new_schema)
+          @old_schema = old_schema
+          @new_schema = new_schema
+
+          @old_types = old_schema.types
+          @new_types = new_schema.types
+        end
+
+        def diff
+          changes = []
+
+          # Removed and Added Types
+          changes += removed_types.map { |type| Changes::TypeRemoved.new(type) }
+          changes += added_types.map { |type| Changes::TypeAdded.new(type) }
+
+          # Type Diff for common types
+          each_common_type do |old_type, new_type|
+            changes += changes_in_type(old_type, new_type)
+          end
+
+          # Diff Schemas
+          changes += changes_in_schema
+
+          # Diff Directives
+          changes += changes_in_directives
+
+          changes
+        end
+
+        def changes_in_type(old_type, new_type)
+          changes = []
+
+          if old_type.kind != new_type.kind
+            changes << Changes::TypeKindChanged.new(old_type, new_type)
+          else
+            case old_type
+            when GraphQL::EnumType
+              changes += Diff::Enum.new(old_type, new_type).diff
+            when GraphQL::UnionType
+              changes += Diff::Union.new(old_type, new_type).diff
+            when GraphQL::InputObjectType
+              changes += Diff::InputObject.new(old_type, new_type).diff
+            when GraphQL::ObjectType
+              changes += Diff::ObjectType.new(old_type, new_type).diff
+            when GraphQL::InterfaceType
+              changes += Diff::Interface.new(old_type, new_type).diff
+            end
+          end
+
+          if old_type.description != new_type.description
+            changes << Changes::TypeDescriptionChanged.new(old_type, new_type)
+          end
+
+          changes
+        end
+
+        def changes_in_schema
+          changes = []
+
+          if old_schema.query != new_schema.query
+            changes << Changes::SchemaQueryTypeChanged.new(old_schema, new_schema)
+          end
+
+          if old_schema.mutation != new_schema.mutation
+            changes << Changes::SchemaMutationTypeChanged.new(old_schema, new_schema)
+          end
+
+          if old_schema.subscription != new_schema.subscription
+            changes << Changes::SchemaSubscriptionTypeChanged.new(old_schema, new_schema)
+          end
+
+          changes
+        end
+
+        def changes_in_directives
+          # TODO
+          []
+        end
+
+        private
+
+        def each_common_type(&block)
+          intersection = old_types.keys & new_types.keys
+          intersection.each do |common_type_name|
+            old_type = old_schema.types[common_type_name]
+            new_type = new_schema.types[common_type_name]
+
+            block.call(old_type, new_type)
+          end
+        end
+
+        def removed_types
+          (old_types.keys - new_types.keys).map { |type_name| old_schema.types[type_name] }
+        end
+
+        def added_types
+          (new_types.keys - old_types.keys).map { |type_name| new_schema.types[type_name] }
+        end
+
+        attr_reader :old_schema, :new_schema, :old_types, :new_types
+      end
+    end
+  end
+end