graphqr 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 876e07cf3e0eb24c8d8c71f23b23e18ae3d014bc
-  data.tar.gz: bcd24faba39f7be1b3a07ca3629bf6f680f10c25
+  metadata.gz: b962a2340faac84b6f9369947841074c52c34afa
+  data.tar.gz: 36fdff3a030711d367bd9d585228bf6f40755053
 SHA512:
-  metadata.gz: 51f5c95b0ba53fe528e7e275bf6e00063c4d2cbd6add26bdc16cf41b0f2f2e6f4884e776108e8e4f3a522121ad0419863e50d111f0dadd0ce577d3611c524cf8
-  data.tar.gz: cf5ff9b77895930d9d7bc9d8aa6adb3bdd494c34c6310139055e4ebb57e3403903810a197cd6f0098855dcfad2b0c275ec715bf21ef212569c7b7beeb9290bfa
+  metadata.gz: 5c68aeedd464b35f796312a9be00e7a909f3d99dea883637affde7a6ff349e44483326d5d6f5a5461ba7d5a191b2813f24403eebb7840b80e3b12e7b4d1d3509
+  data.tar.gz: 77739403805caf9a8974f16248a1da4bf392d08044e3a682fccb38e7e29697c1cf22d78fb6fd17a43242c359f8811c0a41739b82063896ffbe5a80d2fa7f3f75

data/README.md

@@ -31,7 +31,7 @@ Or install it yourself as:
 GraphQR uses `pagy` and `pundit` by default and activates both `Authorization` and `Pagination` modules.
 If you'd like to create a specific configuration, create `config/initializers/graphql.rb` with
 
-```
+```ruby
 GraphQR.configure do |config|
   config.use_pagination = true # or false to disable
   config.use_authorization = true # or false to disable
@@ -44,12 +44,20 @@ end
 ## Modules
 
 To use the extensions correctly add
+```ruby
+    field_class GraphQR::Fields::BaseField
 ```
-field_class GraphQR::Fields::BaseField
-```
-
-to your `BaseObject` class. This will add the `paginate` options to your fields and add the necessary extensions according to the modules you activated.
+to your `BaseObject` class. This will add the custom options to your fields and add the necessary extensions according to the modules you activated.
 
+```ruby
+module Types
+  class BaseObject < GraphQL::Schema::Object
+    ...
+    field_class GraphQR::Fields::BaseField
+    ...
+  end
+end
+```
 ### Pagination
 
 The Pagination module consists in a easier way of dealing with pages. Instead of using `cursors` we implemented a more Rails way using `per` and `page`.
@@ -57,16 +65,33 @@ Our implementation is (for now) based on [Pagy](https://github.com/ddnexus/pagy)
 
 To use the Pagination module add
 
-```
+```ruby
+
 extend GraphQR::Pagination
 ```
 
 to any `GraphQL::Schema::Object` you'd like, but we recommend adding it to your `BaseObject` class.
 
+```ruby
+module Types
+  class BaseObject < GraphQL::Schema::Object
+    ...
+    extend GraphQR::Pagination
+    ...
+  end
+end
+```
+
 #### Usage
 
-```
-field :users, UserType.pagination_type, paginate: true
+```ruby
+module Types
+  class QueryType < Types::BaseObject
+    graphql_name 'Query'
+
+    field :users, UserType.pagination_type, paginate: true
+  end
+end
 ```
 
 A `pagination_type` adds the `per` and `page` arguments and adds a `page_info` field to the response.
@@ -86,13 +111,23 @@ users(per: 10, page: 1) {
 The Authorization module in some wrappers around a `PolicyProvider` (only Pundit for now). And allows some basic behaviors.
 Everything on this module depends on a `policy_provider` passed to the GraphQL context. You can add it like this:
 
-```
-context = {
-  policy_provider: GraphQR::Policies::PunditProvider.new(policy_context: pundit_user)
+```ruby
+class GraphqlController < ApplicationController
+
+  def execute
+    context = {
+      your_context,
+      policy_provider: policy_provider
+    }
+    result = YourSchema.execute(query, variables: variables, context: context, operation_name: operation_name)
+    render json: result.to_json
+  rescue StandardError => e
+    raise e unless Rails.env.development?
+
+    handle_error_in_development(e)
+  end
   ...
-}
-
-Schema.execute(query, variables: variables, context: context, operation_name: operation_name)
+end
 ```
 
 #### Authorized
@@ -101,11 +136,21 @@ This module adds a check on the object policy before resolving it. It always sea
 It works by extending the `authorized?` method.
 
 To add this behavior, add
-```
+```ruby
 extend GraphQR::Authorized
 ```
 to any `GraphQL::Schema::Object` you'd like, but we recommend adding it to your `BaseObject` class.
 
+```ruby
+module Types
+  class BaseObject < GraphQL::Schema::Object
+    ...
+    extend GraphQR::Authorized
+    ...
+  end
+end
+```
+
 Example:
 
 ```
@@ -125,11 +170,21 @@ If any policy returns falsy, the object is returned as `null`.
 This module adds the PolicyProvider scope to the fields that represent an `ActiveRecord::Relation`. It works by implementing the `self.scope_items` method.
 
 To add this behavior, add
-```
+```ruby
 extend GraphQR::ScopeItems
 ```
 to any `GraphQL::Schema::Object` you'd like, but we recommend adding it to your `BaseObject` class.
 
+```ruby
+module Types
+  class BaseObject < GraphQL::Schema::Object
+    ...
+    extend GraphQR::ScopeItems
+    ...
+  end
+end
+```
+
 Example:
 
 ```
@@ -146,14 +201,22 @@ This module is a wrapper around the PolicyProvider authorization.
 It adds the `authorize_graphql` method, similar to Pundit's `authorize`, but it returns an `GraphQL::ExecutionError` instead of a `Pundit::NotAuthorizedError`
 
 To add this behavior, add
-```
-include GraphQR::AuthorizeGraphQL
+```ruby
+include GraphQR::Policies::AuthorizeGraphQL
 ```
 where you want to use this methos, but we recommend adding it to your `Mutations` and `Resolvers` classes.
 
+```ruby
+class BaseResolver < GraphQL::Schema::Resolver
+  ...
+  include GraphQR::Policies::AuthorizeGraphQL
+  ...
+end
+```
+
 Example:
 
-```
+```ruby
 authorize_graphql User, :index?
 ```
 
@@ -167,14 +230,22 @@ This modules is based on the [has_scope](https://github.com/plataformatec/has_sc
 It provides an `apply_scopes` method that can search for model scopes and use them on a collection
 
 To add this method, add
-```
+```ruby
 include GraphQR::ApplyScopes
 ```
 where you'd like to use it, but we recommend adding it to your `Resolvers`.
 
+```ruby
+class BaseResolver < GraphQL::Schema::Resolver
+  ...
+  include GraphQR::ApplyScopes
+  ...
+end
+```
+
 Example:
 
-```
+```ruby
 apply_scopes(User, { order_by_name: true, with_id: [1,2,3] })
 ```
 
@@ -184,11 +255,21 @@ This module adds the `query_field` helper.
 It adds an easy way of creating simple fields with resolvers.
 
 To add this method, add
-```
+```ruby
 extend GraphQR::QueryField
 ```
 to your `BaseObject`.
 
+```ruby
+module Types
+  class BaseObject < GraphQL::Schema::Object
+    ...
+    extend GraphQR::QueryField
+    ...
+  end
+end
+```
+
 Read more about its use in the [documentation](https://qulturerocks.github.io/graphqr/GraphQR/QueryField.html)
 
 

data/lib/graphqr.rb

@@ -57,6 +57,9 @@ require 'graphqr/apply_scopes'
 require 'graphqr/authorized'
 require 'graphqr/pagination'
 require 'graphqr/permitted_fields_extension'
+require 'graphqr/base_resolver'
+require 'graphqr/base_resolvers'
 require 'graphqr/query_field'
+require 'graphqr/relation_fields'
 require 'graphqr/scope_items'
 require 'graphqr/version'

data/lib/graphqr/base_resolver.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module GraphQR
+  ##
+  # @TODO doc
+  class BaseResolver < GraphQL::Schema::Resolver
+    ##
+    # @TODO doc
+    include GraphQR::ApplyScopes
+    include GraphQR::Policies::AuthorizeGraphQL
+  end
+end

data/lib/graphqr/base_resolvers.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module GraphQR
+  ##
+  # @TODO doc
+  module BaseResolvers
+    ##
+    # @TODO doc
+    def base_collection_resolver(type_class, scope_class)
+      Class.new(GraphQR::BaseResolver) do
+        type type_class.pagination_type, null: false
+
+        argument :filter, scope_class, required: false if scope_class.present?
+
+        def resolve(filter: {})
+          authorize_graphql unscoped_collection, :index?
+
+          collection = apply_scopes(unscoped_collection, filter)
+          context[:policy_provider].authorized_records(records: collection)
+        end
+
+        def unscoped_collection
+          raise NotImplementedError
+        end
+      end
+    end
+
+    def base_resource_resolver(type_class)
+      Class.new(GraphQR::BaseResolver) do
+        type type_class, null: false
+
+        def resolve
+          context[:policy_provider].allowed?(action: :show?, record: record)
+
+          record
+        end
+
+        def record
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/graphqr/query_field.rb

@@ -6,9 +6,9 @@ module GraphQR
   # A helper to create simple queries faster and easier
   #
   # To use this extension, add `extend Graphql::QueryField` on your `QueryType`
+  #
   module QueryField
-    # rubocop:disable Metrics/ParameterLists
-
+    include BaseResolvers
     ##
     # The `query_field` method is a helper to create fields and resolver without effort.
     #
@@ -41,13 +41,15 @@ module GraphQR
     #
     # Single fields have the required `id` argument to find the exact record searched.
     # Its resolver will look for the `show?` method on the model Policy.
+    #
+    # rubocop:disable Metrics/ParameterLists
     def query_field(field_name, active_record_class, type_class:, scope_class: nil, **kwargs, &block)
       is_collection = active_record_class.is_a? Array
       if is_collection
         active_record_class = active_record_class.first
-        resolver = collection(active_record_class, type_class, scope_class)
+        resolver = collection_resolver(active_record_class, type_class, scope_class)
       else
-        resolver = resource(active_record_class, type_class)
+        resolver = resource_resolver(active_record_class, type_class)
       end
 
       field(field_name, paginate: is_collection, resolver: resolver, **kwargs, &block)
@@ -56,39 +58,26 @@ module GraphQR
 
     private
 
-    def collection(active_record_class, type_class, scope_class)
-      Class.new(::BaseResolver) do
-        class_attribute :active_record_class
-        self.active_record_class = active_record_class
-
-        type type_class.pagination_type, null: false
-
-        argument :filter, scope_class, required: false
-
-        def resolve(filter: {})
-          authorize_graphql active_record_class, :index?
-
-          collection = apply_scopes(active_record_class, filter)
-          context[:policy_provider].authorized_records(records: collection)
-        end
-      end
+    def collection_resolver(active_record_class, type_class, scope_class)
+      resolver = base_collection_resolver(type_class, scope_class)
+      resolver.define_method(:unscoped_collection) { @unscoped_collection ||= active_record_class }
+      resolver
     end
 
-    def resource(active_record_class, type_class)
-      Class.new(::BaseResolver) do
+    def resource_resolver(active_record_class, type_class)
+      Class.new(base_resource_resolver(type_class)) do
         class_attribute :active_record_class
         self.active_record_class = active_record_class
 
-        type type_class, null: false
-
         argument :id, 'ID', required: true
 
         def resolve(id:)
-          record = self.class.active_record_class.find(id)
-
-          context[:policy_provider].allowed?(action: :show?, record: record)
+          @id = id
+          super()
+        end
 
-          record
+        def record
+          @record ||= active_record_class.find(@id)
         end
       end
     end

data/lib/graphqr/relation_fields.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module GraphQR
+  ##
+  # @TODO doc
+  module RelationFields
+    ##
+    # @TODO doc
+    # rubocop:disable Naming/PredicateName
+    include GraphQR::BaseResolvers
+
+    def has_many(field_name, type_class, scope_class: nil, **kwargs, &block)
+      type_class = type_class.first
+
+      resolver = has_many_resolver(field_name, type_class, scope_class)
+
+      field(field_name, paginate: true, resolver: resolver, **kwargs, &block)
+    end
+
+    def has_one(field_name, type_class, **kwargs, &block)
+      resolver = has_one_resolver(field_name, type_class)
+
+      field(field_name, resolver: resolver, **kwargs, &block)
+    end
+
+    private
+
+    def has_many_resolver(collection_name, type_class, scope_class)
+      resolver = base_collection_resolver(type_class, scope_class)
+      resolver.define_method(:unscoped_collection) { @unscoped_collection ||= object.send(collection_name) }
+      resolver
+    end
+
+    def has_one_resolver(resource_name, type_class)
+      resolver = base_resource_resolver(type_class)
+      resolver.define_method(:record) { @record ||= object.send(resource_name) }
+      resolver
+    end
+    # rubocop:enable Naming/PredicateName
+  end
+end

data/lib/graphqr/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GraphQR
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphqr
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Manuel Puyol
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-29 00:00:00.000000000 Z
+date: 2019-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -144,6 +144,8 @@ files:
 - lib/graphqr.rb
 - lib/graphqr/apply_scopes.rb
 - lib/graphqr/authorized.rb
+- lib/graphqr/base_resolver.rb
+- lib/graphqr/base_resolvers.rb
 - lib/graphqr/configuration.rb
 - lib/graphqr/fields/base_field.rb
 - lib/graphqr/hooks.rb
@@ -155,6 +157,7 @@ files:
 - lib/graphqr/policies/authorize_graphql.rb
 - lib/graphqr/policies/pundit_provider.rb
 - lib/graphqr/query_field.rb
+- lib/graphqr/relation_fields.rb
 - lib/graphqr/scope_items.rb
 - lib/graphqr/version.rb
 - spec/graphqr_spec.rb