hq-graphql 2.2.0 → 2.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a158f615a83d3743a038f248bc82c04285631e6575f62b5124bbb5767ab6ede9
-  data.tar.gz: 630bea394ce6e073b1f4ee2bd62047fcf46ba433357d1c759b99d7ecf350bfec
+  metadata.gz: deb4969d6bb5453570686309a4c86237970c3d273e8551a5749f8f686efb37be
+  data.tar.gz: ad22b68ed30b65621ff4190eb018e528eccd62180b5539bdde30efcf59c1f061
 SHA512:
-  metadata.gz: b6076f33bc12f04a7e701f2deeb7420fc44792af3e99727029196d24d68280276a15c7c8d70d875de82c3ec48e41afdc13b5578a45fbcff2ddcc0edfa8971628
-  data.tar.gz: c85f1b1af47ddee4f049a431277ca63bb1728ab74738fe8bc1bbc0f7b31f9dedd14f12fb850045f82ff301d83729d3f896628154e0fcaecea17c117dfd6140d5
+  metadata.gz: 7a2a1f0e2f88cdda2142055d40228390a7f7dd45cc5d503b8b5bfb3b49e7053a7ff14d54d240d04750d9d72f888011f04885731f914e09dde4ddfd538536ea5b
+  data.tar.gz: bcf822fdeb159f53a94c79d43204055ce3eff8297c007bd420f9164478a08442678d93a55fcaf943a5ff7f0adf41075bc7f4cebae745b4f523bc61ab21a3233c

data/lib/hq/graphql/comparator.rb

@@ -13,26 +13,32 @@ module HQ
         non_breaking: 2
       }
 
-      class << self
-        def compare(old_schema, new_schema, criticality: :breaking)
-          old_schema.load_types! if old_schema < ::GraphQL::Schema
-          new_schema.load_types! if old_schema < ::GraphQL::Schema
-          level = CRITICALITY[criticality]
-          raise ::ArgumentError, "Invalid criticality. Possible values are #{CRITICALITY.keys.join(", ")}" unless level
+      def self.compare(old_schema, new_schema, criticality: :breaking)
+        level = CRITICALITY[criticality]
+        raise ::ArgumentError, "Invalid criticality. Possible values are #{CRITICALITY.keys.join(", ")}" unless level
+
+        result = ::GraphQL::SchemaComparator.compare(prepare_schema(old_schema), prepare_schema(new_schema))
+        return if result.identical?
+        changes = {}
+        changes[:breaking] = result.breaking_changes
+        if level >= CRITICALITY[:dangerous]
+          changes[:dangerous] = result.dangerous_changes
+        end
+        if level >= CRITICALITY[:non_breaking]
+          changes[:non_breaking] = result.non_breaking_changes
+        end
+        return unless changes.values.flatten.any?
 
-          result = ::GraphQL::SchemaComparator.compare(old_schema, new_schema)
-          return nil if result.identical?
-          changes = {}
-          changes[:breaking] = result.breaking_changes
-          if level >= CRITICALITY[:dangerous]
-            changes[:dangerous] = result.dangerous_changes
-          end
-          if level >= CRITICALITY[:non_breaking]
-            changes[:non_breaking] = result.non_breaking_changes
-          end
-          return nil unless changes.values.flatten.any?
+        changes
+      end
+
+      class << self
+        private
 
-          changes
+        def prepare_schema(schema)
+          schema = ::GraphQL::Schema.from_definition(schema) if schema.is_a?(String)
+          schema.load_types!
+          schema
         end
       end
     end

data/lib/hq/graphql/enum/filter_operation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "hq/graphql/filter_operations"
+
+module HQ
+  module GraphQL
+    module Enum
+      class FilterOperation < ::GraphQL::Schema::Enum
+        ::HQ::GraphQL::FilterOperations::OPERATIONS.each do |filter_operation|
+          value filter_operation.name, value: filter_operation
+        end
+      end
+    end
+  end
+end

data/lib/hq/graphql/ext/schema_extensions.rb

@@ -5,11 +5,11 @@ module HQ
     module Ext
       module SchemaExtensions
         def self.prepended(klass)
-          klass.alias_method :add_type_without_lazyload, :add_type
-          klass.alias_method :add_type, :add_type_with_lazyload
+          klass.alias_method :add_type_and_traverse_without_types, :add_type_and_traverse
+          klass.alias_method :add_type_and_traverse, :add_type_and_traverse_with_types
         end
 
-        def execute(*args, **options)
+        def multiplex(*args, **options)
           load_types!
           super
         end
@@ -30,17 +30,17 @@ module HQ
 
         def load_types!
           ::HQ::GraphQL.load_types!
-          return if @add_type_with_lazyload.blank?
-          while (args, options = @add_type_with_lazyload.shift)
-            add_type_without_lazyload(*args, **options)
+          return if @add_type_and_traverse_with_types.blank?
+          while (args, options = @add_type_and_traverse_with_types.shift)
+            add_type_and_traverse_without_types(*args, **options)
           end
         end
 
         # Defer adding types until first schema execution
-        # https://github.com/rmosolgo/graphql-ruby/blob/792f276444e1dd6004fcafe3820d65fdbbe285f0/lib/graphql/schema.rb#L1888-L1980
-        def add_type_with_lazyload(*args, **options)
-          @add_type_with_lazyload ||= []
-          @add_type_with_lazyload.push([args, options])
+        # https://github.com/rmosolgo/graphql-ruby/blob/345ebb2e3833909963067d81e0e8378717b5bdbf/lib/graphql/schema.rb#L1792
+        def add_type_and_traverse_with_types(*args, **options)
+          @add_type_and_traverse_with_types ||= []
+          @add_type_and_traverse_with_types.push([args, options])
         end
       end
     end

data/lib/hq/graphql/filter_operations.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "hq/graphql/enum/filter_operation"
+
+module HQ
+  module GraphQL
+    module FilterOperations
+      class Operation
+        attr_reader :name, :arel, :check_for_null, :sanitize
+
+        def initialize(name:, arel:, check_for_null: false, sanitize: nil)
+          @name           = name
+          @arel           = arel
+          @check_for_null = check_for_null
+          @sanitize       = sanitize
+        end
+
+        def sanitize_value(value)
+          sanitize ? sanitize.call(value) : value
+        end
+
+        def to_arel(table:, column_name:, value:)
+          sanitized_value = sanitize_value(value)
+
+          if arel.is_a?(Proc)
+            return arel.call(table: table, column_name: column_name, value: sanitized_value)
+          end
+
+          expression = table[column_name].send(arel, sanitized_value)
+
+          if check_for_null
+            expression = expression.or(table[column_name].eq(nil))
+          end
+
+          expression
+        end
+      end
+
+      OPERATIONS = [
+        EQUAL = Operation.new(name: "EQUAL", arel: :eq),
+        NOT_EQUAL = Operation.new(name: "NOT_EQUAL", arel: :not_eq, check_for_null: true),
+        LIKE = Operation.new(name: "LIKE", arel: :matches, sanitize: ->(value) { "%#{ActiveRecord::Base.sanitize_sql_like(value)}%" }),
+        NOT_LIKE = Operation.new(name: "NOT_LIKE", arel: :does_not_match, check_for_null: true, sanitize: ->(value) { "%#{ActiveRecord::Base.sanitize_sql_like(value)}%" }),
+        GREATER_THAN = Operation.new(name: "GREATER_THAN", arel: :gt),
+        LESS_THAN = Operation.new(name: "LESS_THAN", arel: :lt),
+        WITH = Operation.new(
+          name: "WITH",
+          arel: ->(table:, column_name:, value:) do
+            if value.casecmp("t") == 0 || value.casecmp("true") == 0
+              table[column_name].not_eq(nil)
+            else
+              table[column_name].eq(nil)
+            end
+          end
+        )
+      ]
+    end
+  end
+end

data/lib/hq/graphql/filters.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "hq/graphql/filter_operations"
+require "hq/graphql/util"
+
+module HQ
+  module GraphQL
+    class Filters
+      BOOLEAN_VALUES = ["t", "f", "true", "false"]
+
+      def self.supported?(column)
+        !!Filter.class_from_column(column)
+      end
+
+      attr_reader :filters, :model
+
+      def initialize(filters, model)
+        @filters = Array(filters).map { |filter| Filter.for(filter, table: model.arel_table) }
+        @model = model
+      end
+
+      def validate!
+        filters.each(&:validate)
+        errors = filters.map do |filter|
+          filter.display_error_message
+        end.flatten.uniq
+
+        if errors.any?
+          raise ::GraphQL::ExecutionError, errors.join(", ")
+        end
+      end
+
+      def to_scope
+        filters.reduce(model.all) do |s, filter|
+          s.where(filter.to_arel)
+        end
+      end
+
+      class Filter
+        include ActiveModel::Validations
+        include FilterOperations
+
+        def self.for(filter, **options)
+          class_from_column(filter.field).new(filter, **options)
+        end
+
+        def self.class_from_column(column)
+          case column.type
+          when :boolean
+            BooleanFilter
+          when :date, :datetime
+            DateFilter
+          when :decimal, :integer
+            NumericFilter
+          when :string, :text
+            StringFilter
+          when :uuid
+            UuidFilter
+          end
+        end
+
+        def self.validate_operations(*operations)
+          valid_operations = operations + [WITH]
+          validates :operation, inclusion: {
+            in: valid_operations,
+            message: "only supports the following operations: #{valid_operations.map(&:name).join(", ")}"
+          }
+        end
+
+        def self.validate_value(**options)
+          validates :value, **options, unless: ->(filter) { filter.operation == WITH }
+        end
+
+        validate :validate_boolean_values, if: ->(filter) { filter.operation == WITH }
+
+        attr_reader :table, :column, :operation, :value
+
+        def initialize(filter, table:)
+          @table = table
+          @column = filter.field
+          @operation = filter.operation
+          @value = filter.value
+        end
+
+        def display_error_message
+          return unless errors.any?
+          messages = errors.messages.values.join(", ")
+          "#{column.name.camelize(:lower)} (type: #{column.type}, operation: #{operation.name}, value: \"#{value}\"): #{messages}"
+        end
+
+        def to_arel
+          operation.to_arel(table: table, column_name: column.name, value: value)
+        end
+
+        def validate_boolean_values
+          is_valid = BOOLEAN_VALUES.any? { |v| value.casecmp(v) == 0 }
+          return if is_valid
+          errors.add(:value, "WITH operation only supports boolean values (#{BOOLEAN_VALUES.join(", ")})")
+        end
+      end
+
+      class BooleanFilter < Filter
+        validate_operations
+
+        def to_arel
+          arel = super
+
+          if value.casecmp("f") == 0 || value.casecmp("false") == 0
+            arel = arel.or(table[column.name].eq(false))
+          end
+
+          arel
+        end
+      end
+
+      class DateFilter < Filter
+        validate_operations GREATER_THAN, LESS_THAN
+        validate :validate_iso8601
+
+        def validate_iso8601
+          is_valid = begin
+            DateTime.iso8601(value)
+            true
+          rescue ArgumentError
+            false
+          end
+
+          return if is_valid
+
+          today = Date.today
+          errors.add(:value, "only supports ISO8601 values (\"#{today.iso8601}\", \"#{today.to_datetime.iso8601}\")")
+        end
+      end
+
+      class NumericFilter < Filter
+        validate_operations GREATER_THAN, LESS_THAN, EQUAL, NOT_EQUAL
+        validate_value numericality: { message: "only supports numerical values" }
+      end
+
+      class StringFilter < Filter
+        validate_operations EQUAL, NOT_EQUAL, LIKE, NOT_LIKE
+      end
+
+      class UuidFilter < Filter
+        validate_operations EQUAL, NOT_EQUAL
+        validate_value format: { with: HQ::GraphQL::Util::UUID_FORMAT, message: "only supports UUID values (e.g. 00000000-0000-0000-0000-000000000000)" }
+      end
+    end
+  end
+end

data/lib/hq/graphql/resource.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
+require "hq/graphql/ext/enum_extensions"
 require "hq/graphql/ext/input_object_extensions"
 require "hq/graphql/ext/object_extensions"
+require "hq/graphql/enum/filter_operation"
 require "hq/graphql/enum/sort_by"
 require "hq/graphql/field_extension/paginated_arguments"
+require "hq/graphql/filters"
 require "hq/graphql/resource/auto_mutation"
 require "hq/graphql/scalars"
 
@@ -91,11 +94,50 @@ module HQ
             nil_query_object
           when :Input
             input_klass
+          when :FilterInput
+            filter_input
+          when :FilterFields
+            filter_fields_enum
           else
             super
           end
         end
 
+        def filter_input
+          @filter_input ||= begin
+            scoped_self = self
+
+            input_class = Class.new(::GraphQL::Schema::InputObject) do
+              graphql_name "#{scoped_self.graphql_name}FilterInput"
+
+              argument :field, scoped_self.filter_fields_enum, required: true
+              argument :operation, Enum::FilterOperation, required: true
+              argument :value, String, required: true
+            end
+
+            const_set(:FilterInput, input_class)
+          end
+        end
+
+        def filter_fields_enum
+          @filter_fields_enum ||= begin
+            scoped_self = self
+
+            enum_class = Class.new(::GraphQL::Schema::Enum) do
+              graphql_name "#{scoped_self.graphql_name}FilterFields"
+
+              lazy_load do
+                scoped_self.model_klass.columns.sort_by(&:name).each do |column|
+                  next unless HQ::GraphQL::Filters.supported?(column)
+                  value column.name.camelize(:lower), value: column
+                end
+              end
+            end
+
+            const_set(:FilterFields, enum_class)
+          end
+        end
+
         protected
 
         def default_scope(&block)
@@ -167,9 +209,13 @@ module HQ
           if find_all
             def_root field_name.pluralize, is_array: true, null: false do
               extension FieldExtension::PaginatedArguments, klass: scoped_self.model_klass if pagination
+              argument :filters, [scoped_self.filter_input], required: false
+
+              define_method(:resolve) do |filters: nil, limit: nil, offset: nil, sort_by: nil, sort_order: nil, **_attrs|
+                filters_scope = ::HQ::GraphQL::Filters.new(filters, scoped_self.model_klass)
+                filters_scope.validate!
 
-              define_method(:resolve) do |limit: nil, offset: nil, sort_by: nil, sort_order: nil, **_attrs|
-                scope = scoped_self.scope(context).all
+                scope = scoped_self.scope(context).all.merge(filters_scope.to_scope)
 
                 if pagination || page || limit
                   offset = [0, *offset].max

data/lib/hq/graphql/types/uuid.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "hq/graphql/util"
+
 module HQ
   module GraphQL
     module Types
@@ -18,16 +20,12 @@ module HQ
           private
 
           def validate_and_return_uuid(value)
-            if validate_uuid(value)
+            if ::HQ::GraphQL::Util.validate_uuid(value)
               value
             else
               raise ::GraphQL::CoercionError, "#{value.inspect} is not a valid UUID"
             end
           end
-
-          def validate_uuid(value)
-            !!value.to_s.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/)
-          end
         end
       end
     end

data/lib/hq/graphql/util.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module HQ
+  module GraphQL
+    module Util
+      UUID_FORMAT = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/
+
+      def self.validate_uuid(value)
+        !value || !!value.to_s.match(UUID_FORMAT)
+      end
+    end
+  end
+end

data/lib/hq/graphql/version.rb

@@ -2,6 +2,6 @@
 
 module HQ
   module GraphQL
-    VERSION = "2.2.0"
+    VERSION = "2.2.4"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hq-graphql
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.4
 platform: ruby
 authors:
 - Danny Jones
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-01 00:00:00.000000000 Z
+date: 2021-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -236,6 +236,7 @@ files:
 - lib/hq/graphql/comparator.rb
 - lib/hq/graphql/config.rb
 - lib/hq/graphql/engine.rb
+- lib/hq/graphql/enum/filter_operation.rb
 - lib/hq/graphql/enum/sort_by.rb
 - lib/hq/graphql/enum/sort_order.rb
 - lib/hq/graphql/ext.rb
@@ -249,6 +250,8 @@ files:
 - lib/hq/graphql/field_extension/association_loader_extension.rb
 - lib/hq/graphql/field_extension/paginated_arguments.rb
 - lib/hq/graphql/field_extension/paginated_loader.rb
+- lib/hq/graphql/filter_operations.rb
+- lib/hq/graphql/filters.rb
 - lib/hq/graphql/inputs.rb
 - lib/hq/graphql/object_association.rb
 - lib/hq/graphql/paginated_association_loader.rb
@@ -260,6 +263,7 @@ files:
 - lib/hq/graphql/scalars.rb
 - lib/hq/graphql/types.rb
 - lib/hq/graphql/types/uuid.rb
+- lib/hq/graphql/util.rb
 - lib/hq/graphql/version.rb
 homepage: https://github.com/OneHQ/hq-graphql
 licenses: