graphql-rails-activereflection 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f290ca96c78a7e555293a6c0579c148a98cd3cb7
+  data.tar.gz: e9d4d6c77d65f00195cceac332adc08716b1df04
+SHA512:
+  metadata.gz: c8694fc4b9c0671f1fbf7f5827d9e12a672b676341de78dd4a7fd7eabe5432fa2495e178e882731777edf26dc4c5e1df9e2dd85bc6f61e7dcda242442d9e2fca
+  data.tar.gz: 665656bc9fb5419af9b85571004ad71a304694c5aea3a4629533ebe30059db03b81365bb51e7075c9b0fe78288b101cf13f2ffef125193b963233cadbc7f2253

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# GraphQL::Rails::ActiveReflection
+## CHANGELOG
+
+### Version 0.1.0
+Initial commit. More to come.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Cole Turner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+# GraphQL::Rails::ActiveReflection
+## (graphql-rails-activereflection)
+Reflection over GraphQL for ActiveRecord models and validators
+
+# What is it?
+The purpose of this gem is to enable ActiveRecord reflections on models over GraphQL.
+
+At release, this gem only contains reflections on validators. This is to avoid duplication and doubling up on the front-end for how to validate form inputs.
+
+Eventually I would like to include some React examples and sample container components to apply the validators.
+
+# Installation
+To begin, install the gem by adding it to the `Gemfile`:
+
+```ruby
+  gem 'graphql-rails-activereflection'
+```
+
+You're now ready to expose validators for your GraphQL Fields.  This only works for fields that resolve to ActiveRecord Models.
+
+To expose a field, add the following line:
+
+```ruby
+  implements GraphQL::Rails::ActiveReflection::Model.interface, inherit: true
+```
+
+And that's it! This will add a `_model` field to the object type and enables the following query:
+
+```graphql
+fragment on YourObjectType {
+  _model {
+    attributes {
+      name
+
+      validators {
+        abscence: Boolean
+        prescence: Boolean
+        uniqueness: Boolean
+        with_format: String
+        without_format: String
+        min_length: Integer
+        max_length: Integer
+        inclusion: [String]
+        exclusion: [String]
+      }
+
+      validate(int: Integer, str: String, float: Float, bool: Boolean) {
+        valid: Boolean
+        errors: [String]
+      }
+    }
+  }
+}
+```
+
+Each of the validators corresponds to the standard Rails validators. Almost all validators for an attribute will be returned, **except those that have the `if` or `unless` conditionals.** This is by design and therefore make note that any conditional validations will have to be performed manually.
+
+There is also the `validate(...)` field with arguments for standard scalar types. Any one of the arguments can be provided, but only one. The result will contain a `valid` boolean and a list of `errors` strings returned from the validators.
+
+In the future all of the `validate(...)` should be chained for a single call.
+
+## Direction
+Future plans for this module are to expose any reflections for an ActiveRecord model.
+
+# Needs Help
+If you wish to contribute to this project, any pull request is warmly welcomed.
+
+- [ ] Documentation
+- [ ] Examples
+- [ ] Unit Tests
+- [ ] Merge `validate(...)` calls
+
+# Credits
+- Cole Turner ([@colepatrickturner](https://github.com/colepatrickturner))

data/lib/graphql/rails/active_reflection.rb

@@ -0,0 +1,42 @@
+require 'graphql'
+require 'graphql/rails/active_reflection/model_reflection'
+require 'graphql/rails/active_reflection/attribute_reflection'
+require 'graphql/rails/active_reflection/validation_result'
+require 'graphql/rails/active_reflection/validator_reflection'
+require 'graphql/rails/active_reflection/types'
+
+module GraphQL
+  module Rails
+    module ActiveReflection
+      VERSION = '0.1.0'
+
+      class UnsupportedObject < StandardError; end
+
+      class Model
+        def self.interface
+          @interface ||= GraphQL::InterfaceType.define do
+            name "ActiveReflectionInterface"
+            field('_model', ModelReflectionType, 'Model of attributes for field.')
+          end
+        end
+
+        def self.field(**kwargs, &block)
+          # We have to define it fresh each time because
+          # its name will be modified and its description
+          # _may_ be modified.
+          field = GraphQL::Field.define do
+            type(GraphQL::Rails::ActiveReflection::Model.interface)
+            description('Fetch the content model for the given object.')
+            resolve(ModelReflection)
+          end
+
+          if kwargs.any? || block
+            field = field.redefine(kwargs, &block)
+          end
+
+          field
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/active_reflection/attribute_reflection.rb

@@ -0,0 +1,31 @@
+module GraphQL
+  module Rails
+    module ActiveReflection
+      class AttributeReflection
+        @schema_name = "ActiveReflectionAttribute"
+
+        attr_reader :klass
+        attr_reader :name
+        attr_reader :description
+        attr_reader :validators
+
+        def initialize(field, klass, schema)
+          @klass = klass
+          @name = field.property || field.name
+          @validators = klass.validators.map { |validator|
+            return nil if validator.attributes.exclude? @name
+            return nil if validator.options[:if].present?
+            return nil if validator.options[:unless].present?
+
+            ValidatorReflection.new(validator)
+          }.compact
+          @errors = []
+        end
+
+        class << self
+          attr_accessor :schema_name
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/active_reflection/model_reflection.rb

@@ -0,0 +1,34 @@
+module GraphQL
+  module Rails
+    module ActiveReflection
+      class ModelReflection
+        @schema_name = "ActiveReflectionModel"
+
+        def self.call(obj, args, ctx)
+          raise UnsupportedObject unless obj < ActiveRecord::Base
+          @reflections[obj.class] ||= new(obj.class, ctx.schema)
+        end
+
+        attr_reader :attributes
+
+        def initialize(klass, schema)
+          @klass = klass
+          @type = schema.resolve_type(@klass)
+          @schema = schema
+          @attributes = @type.fields.map { |field|
+            # No reflection if it's not a model attribute
+            property = field.property || field.name
+            return nil unless klass.attribute_names.include? property
+
+            AttributeReflection.new(field, klass, schema)
+          }.compact
+        end
+
+        class << self
+          attr_accessor :schema_name
+        end
+
+      end
+    end
+  end
+end

data/lib/graphql/rails/active_reflection/types.rb

@@ -0,0 +1,4 @@
+require 'graphql/rails/active_reflection/types/model_reflection_type'
+require 'graphql/rails/active_reflection/types/attribute_reflection_type'
+require 'graphql/rails/active_reflection/types/validation_result_type'
+require 'graphql/rails/active_reflection/types/validator_type'

data/lib/graphql/rails/active_reflection/types/attribute_reflection_type.rb

@@ -0,0 +1,36 @@
+module GraphQL
+  module Rails
+    module ActiveReflection
+      module Types
+
+        AttributeReflectionType = ::GraphQL::ObjectType.define do
+          name AttributeReflection.schema_name
+
+          field :name, !types.String
+          field :validators, ValidatorType.to_list_type
+          field :validate, ValidationResultType do
+            argument :int, types.Int
+            argument :str, types.String
+            argument :float, types.Float
+            argument :bool, types.Boolean
+
+            resolve ->(obj, args, _ctx) do
+              values = [args['int'], args['str'], args['float'], args['bool']]
+              raise ArgumentError, "Must specify at least one argument" if values.compact.empty?
+              raise ArgumentError, "Too many arguments, one expected" if values.compact.size > 1
+
+              value = values.compact.first
+
+              model = obj.klass.new
+              model[obj.name] = value
+
+              model.validate!
+              ValidationResult.new(model.valid?, model.errors[obj.name])
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/graphql/rails/active_reflection/types/model_reflection_type.rb

@@ -0,0 +1,12 @@
+module GraphQL
+  module Rails
+    module ActiveReflection
+      module Types
+        ModelReflectionType = ::GraphQL::ObjectType.define do
+          name ModelReflection.schema_name
+          field :attributes, AttributeReflectionType.to_list_type
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/active_reflection/types/validation_result_type.rb

@@ -0,0 +1,14 @@
+module GraphQL
+  module Rails
+    module ActiveReflection
+      module Types
+          ValidationResultType = ::GraphQL::ObjectType.define do
+          name ValidationResult.schema_name
+
+          field :valid, types.Boolean
+          field :errors, types.String.to_list_type
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/active_reflection/types/validator_type.rb

@@ -0,0 +1,77 @@
+module GraphQL
+  module Rails
+    module ActiveReflection
+      module Types
+        ValidatorType = ::GraphQL::ObjectType.define do
+          name ValidatorReflection.schema_name
+          # TODO NumericalityValidator
+
+          field :abscence, types.Boolean do
+            resolve ->(obj, _args, _ctx) do
+              obj < ActiveModel::Validations::AbsenceValidator
+            end
+          end
+
+          field :prescence, types.Boolean do
+            resolve ->(obj, _args, _ctx) do
+              obj < ActiveModel::Validations::PrescenceValidator
+            end
+          end
+
+          field :uniqueness, types.Boolean do
+            resolve ->(obj, _args, _ctx) do
+              obj < ActiveModel::Validations::UniquenessValidator
+            end
+          end
+
+          field :with_format, types.String do
+            resolve ->(obj, _args, _ctx) do
+              return nil unless obj < ActiveModel::Validations::FormatValidator
+              obj.options[:with]
+            end
+          end
+
+          field :without_format, types.String do
+            resolve ->(obj, _args, _ctx) do
+              return nil unless obj < ActiveModel::Validations::FormatValidator
+              obj.options[:without]
+            end
+          end
+
+          field :min_length, types.Int do
+            resolve ->(obj, _args, _ctx) do
+              return nil unless obj < ActiveModel::Validations::LengthValidator
+              obj.options[:minimum]
+            end
+          end
+
+          field :max_length, types.Int do
+            resolve ->(obj, _args, _ctx) do
+              return nil unless obj < ActiveModel::Validations::LengthValidator
+              obj.options[:maximum]
+            end
+          end
+
+          field :inclusion, types.String.to_list_type do
+            resolve ->(obj, _args, _ctx) do
+              return nil unless obj < ActiveModel::Validations::InclusionValidator
+              return nil if obj.options[:in].respond_to? :call
+              obj.options[:in]
+            end
+          end
+
+          field :exclusion, types.String.to_list_type do
+            resolve ->(obj, _args, _ctx) do
+              return nil unless obj < ActiveModel::Validations::ExclusionValidator
+              return nil if obj.options[:in].respond_to? :call
+              obj.options[:in]
+            end
+          end
+
+          # TODO AcceptanceValidator (is this relevant anymore?)
+
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/active_reflection/validation_result.rb

@@ -0,0 +1,21 @@
+module GraphQL
+  module Rails
+    module ActiveReflection
+      class ValidationResult
+        @schema_name = "ActiveReflectionValidation"
+
+        attr_reader :valid
+        attr_reader :errors
+
+        def initialize(valid, errors)
+          @valid = valid
+          @errors = errors
+        end
+
+        class << self
+          attr_accessor :schema_name
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/active_reflection/validator_reflection.rb

@@ -0,0 +1,65 @@
+module GraphQL
+  module Rails
+    module ActiveReflection
+      class ValidatorReflection
+        @schema_name = "ActiveReflectionValidator"
+
+        attr_reader :validator
+
+        def initialize(validator)
+          @validator = validator
+        end
+
+        def abscence
+          @validator < ActiveModel::Validations::AbsenceValidator
+        end
+
+        def prescence
+          resolve ->(obj, _args, _ctx) do
+            @validator < ActiveModel::Validations::PrescenceValidator
+          end
+        end
+
+        def uniqueness
+          @validator < ActiveModel::Validations::UniquenessValidator
+        end
+
+        def with_format
+          return nil unless @validator < ActiveModel::Validations::FormatValidator
+          @validator.options[:with]
+        end
+
+        def without_format
+          return nil unless @validator < ActiveModel::Validations::FormatValidator
+          @validator.options[:without]
+        end
+
+        def min_length
+          return nil unless @validator < ActiveModel::Validations::LengthValidator
+          @validator.options[:minimum]
+        end
+
+        def max_length
+          return nil unless @validator < ActiveModel::Validations::LengthValidator
+          @validator.options[:maximum]
+        end
+
+        def inclusion
+          return nil unless @validator < ActiveModel::Validations::InclusionValidator
+          return nil if @validator.options[:in].respond_to? :call
+          @validator.options[:in]
+        end
+
+        def exclusion
+          return nil unless @validator < ActiveModel::Validations::ExclusionValidator
+          return nil if @validator.options[:in].respond_to? :call
+          @validator.options[:in]
+        end
+
+        class << self
+          attr_accessor :schema_name
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: graphql-rails-activereflection
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Cole Turner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Reflection over GraphQL for ActiveRecord models and validators
+email: turner.cole@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/graphql/rails/active_reflection.rb
+- lib/graphql/rails/active_reflection/attribute_reflection.rb
+- lib/graphql/rails/active_reflection/model_reflection.rb
+- lib/graphql/rails/active_reflection/types.rb
+- lib/graphql/rails/active_reflection/types/attribute_reflection_type.rb
+- lib/graphql/rails/active_reflection/types/model_reflection_type.rb
+- lib/graphql/rails/active_reflection/types/validation_result_type.rb
+- lib/graphql/rails/active_reflection/types/validator_type.rb
+- lib/graphql/rails/active_reflection/validation_result.rb
+- lib/graphql/rails/active_reflection/validator_reflection.rb
+homepage: http://rubygems.org/gems/graphql-rails-activereflection
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Reflection over GraphQL for ActiveRecord validators
+test_files: []