graphql-active_record 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ddd18445547cbfe82e3526ffbcac6bb8e609ff8a
-  data.tar.gz: 2bace41aa51e44c9c8d3725123f6324557b9aa41
+  metadata.gz: 10caa39790c95eaa28ada47d7f82ca23552c22dc
+  data.tar.gz: bd0c481b90ea4d88c6e033775a86c42924896b66
 SHA512:
-  metadata.gz: b2060751108d72871b669d620a5169069f40581777df3a5c5314dd16329f7b99d8ac229741d3f896f5bbb9cc2528d38f4f05cf542613ffd6f0a816b11f303fac
-  data.tar.gz: b6adb77476fbf746558d22e5629730507568a0dce4fc9f3253de624e3027c12f9f52d6765baa17902a979936082a2c476046b01760fa649b60469d602324a3e0
+  metadata.gz: c6ec6a31f0cc12597eb16481f8e211c17ad0997ae06c8a2b38f5e3caaa082ab4118b5a263172930f6ab0a20a78ec59623b3356abb5987c11f19561c6b8053b60
+  data.tar.gz: 92f9b98456949e083d1eaefc4a2e780185c981ecb8a3ab7487068971de3483de31fb12467ff6ca44cd50cc724760b02fadabf44426bc453ba0b9b66aabe56cb3

data/.gitignore

@@ -7,3 +7,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+
+*.gem

data/README.md

@@ -1,15 +1,13 @@
-# Graphql::Active::Record
+# GraphQL::ActiveRecordExtensions
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/graphql/active/record`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Active Record includes for GraphQL
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'graphql-active-record'
+gem 'graphql-active_record'
 ```
 
 And then execute:
@@ -18,11 +16,18 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install graphql-active-record
+    $ gem install graphql-active_record
 
 ## Usage
 
-TODO: Write usage instructions here
+Use like:
+
+```ruby
+GraphQL::ActiveRecordExtensions::Field.new(type: Type, model: Model)
+
+# using UUID
+GraphQL::ActiveRecordExtensions::Field.new(type: Type, model: Model, use_uuid: true)
+```
 
 ## Development
 
@@ -32,7 +37,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/graphql-active-record.
+Bug reports and pull requests are welcome on GitHub at https://github.com/brettjurgens/graphql-active-record.
 
 
 ## License

data/graphql-active-record.gemspec

@@ -1,11 +1,11 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'graphql/active_record_extension/version'
+require 'graphql/active_record_extensions/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "graphql-active_record"
-  spec.version       = Graphql::ActiveRecordExtension::VERSION
+  spec.version       = GraphQL::ActiveRecordExtensions::VERSION
   spec.authors       = ["Brett Jurgens"]
   spec.email         = ["brett@brettjurgens.com"]
 

data/lib/graphql/active_record_extension.rb

@@ -1,137 +1,5 @@
 require 'active_record'
 require 'graphql'
 
-require "graphql/active_record_extension/version"
-
-##
-# This class allows GraphQL to translate ActiveRecord objects into
-# GraphQL objects easily and does an auto-include to make it
-# somewhat more efficient (hopefully)
-class GraphQL::ActiveRecordExtension < ::GraphQL::Field
-  def initialize(model:, type:, use_uuid: false)
-    @model = model
-    @use_uuid = use_uuid
-
-    self.type = type
-    self.description = "Find a #{model.name} by ID"
-    self.arguments = {
-      id: GraphQL::Argument.define do
-        type !GraphQL::ID_TYPE
-        description "Id for record"
-      end
-    }
-  end
-
-  ##
-  # override of GraphQL::Field.resolve
-  # basically just provides the final object (in this case an AR model)
-  # can check RDoc for graphql-ruby gem
-  #
-  # @param object not used
-  # @param arguments List[GraphQL::Argument] List of Arguments for the field (i.e. id, uuid, etc.)
-  # @param ctx [GraphQL::Context] the context of the GraphQL query
-  #
-  # @return eager-loaded ActiveRecord model
-  def resolve(object, arguments, ctx)
-    includes = map_includes(@model, ctx.ast_node.selections, ctx)
-
-    model_with_includes = @model.includes(*includes)
-    if @use_uuid
-      model_with_includes.find_by_uuid(arguments['id'])
-    else
-      model_with_includes.find(arguments['id'])
-    end
-
-    rescue ActiveRecord::ConfigurationError => e
-      @model.find(arguments['id'])
-  end
-
-  private
-  ##
-  # generates an array for use in AR::QueryMethods.includes
-  # allows for nested includes as well
-  # supports fragments
-  #
-  # @param model [ActiveRecord::Base] an ActiveRecord model
-  # @param selections [GraphQL::Selection] selections on the current model
-  # @param ctx [GraphQL::Context] the context of the GraphQL query. Used to map fragments to models
-  #
-  # @return Array of tables to include in the query
-  def map_includes(model, selections, ctx)
-    selections.map do |selection|
-
-      table_name, node = handle_fragments(selection, ctx)
-
-      if node.present? && node.selections.present?
-        singular = table_name.singularize.to_sym
-        plural   = table_name.pluralize.to_sym
-
-        # make sure that the next model is an ActiveRecord model
-        next_model = singular.to_s.classify.safe_constantize
-
-        if next_model.blank? || !(next_model < ActiveRecord::Base)
-          next_model = model
-        end
-
-        nested = map_includes(next_model, node.selections, ctx)
-
-        final_type =  if model.reflections[singular].present?
-                        # this is for has_one relationships
-                        singular
-
-                      elsif model.reflections[plural].present?
-                        # this is for has_many relationships
-                        plural
-
-                      else
-                        # this is for non-AR models (i.e. Product)
-                        # so they use the correct parent
-                        # TODO Try to get possible_types and include those
-                        nil
-                      end
-
-        if nested.present?
-          if final_type
-            # flatten is used for cases like Interfaces
-            # i.e. Customer -> Product -> Loan
-            # Product isn't an AR type
-            { final_type => nested.flatten }
-          else
-            nested.compact
-          end
-
-        else
-          final_type
-        end
-      else
-        nil
-      end
-    end.compact
-  end
-
-  ##
-  # method to handle fragments in GQL Query
-  # works by finding the fragment reference in the context
-  #
-  # @param node [GraphQL::Language::Nodes::*] current node
-  # @param ctx [GraphQL::Context] GQL Context used to map fragment to node
-  #
-  # @return [String, GraphQL::Language::Nodes::*] tuple of node name and node
-  def handle_fragments(node, ctx)
-    if node.class == GraphQL::Language::Nodes::FragmentSpread
-      fragment = ctx.query.fragments[node.name]
-      [fragment.type.underscore, fragment]
-    elsif node.class == GraphQL::Language::Nodes::InlineFragment
-      ##
-      # avoid auto-including things in InlineFragments
-      # If using an interface, not all fields are guaranteed to
-      # exist in all of the implementing types, but at this point,
-      # we can't tell if it will, because we don't know what type
-      # we are dealing with.
-      ##
-      [nil, nil]
-    else
-      [node.name, node]
-    end
-  end
-end
+require "graphql/active_record_extensions/version"
+require "graphql/active_record_extensions/field"

data/lib/graphql/active_record_extensions/field.rb

@@ -0,0 +1,136 @@
+##
+# This class allows GraphQL to translate ActiveRecord objects into
+# GraphQL objects easily and does an auto-include to make it
+# somewhat more efficient (hopefully)
+module GraphQL
+  module ActiveRecordExtensions
+    class Field < ::GraphQL::Field
+      def initialize(model:, type:, use_uuid: false)
+        @model = model
+        @use_uuid = use_uuid
+
+        self.type = type
+        self.description = "Find a #{model.name} by ID"
+        self.arguments = {
+          id: GraphQL::Argument.define do
+            type !GraphQL::ID_TYPE
+            description "Id for record"
+          end
+        }
+      end
+
+      ##
+      # override of GraphQL::Field.resolve
+      # basically just provides the final object (in this case an AR model)
+      # can check RDoc for graphql-ruby gem
+      #
+      # @param object not used
+      # @param arguments List[GraphQL::Argument] List of Arguments for the field (i.e. id, uuid, etc.)
+      # @param ctx [GraphQL::Context] the context of the GraphQL query
+      #
+      # @return eager-loaded ActiveRecord model
+      def resolve(object, arguments, ctx)
+        includes = map_includes(@model, ctx.ast_node.selections, ctx)
+
+        model_with_includes = @model.includes(*includes)
+        if @use_uuid
+          model_with_includes.find_by_uuid(arguments['id'])
+        else
+          model_with_includes.find(arguments['id'])
+        end
+
+        rescue ActiveRecord::ConfigurationError => e
+          @model.find(arguments['id'])
+      end
+
+      private
+      ##
+      # generates an array for use in AR::QueryMethods.includes
+      # allows for nested includes as well
+      # supports fragments
+      #
+      # @param model [ActiveRecord::Base] an ActiveRecord model
+      # @param selections [GraphQL::Selection] selections on the current model
+      # @param ctx [GraphQL::Context] the context of the GraphQL query. Used to map fragments to models
+      #
+      # @return Array of tables to include in the query
+      def map_includes(model, selections, ctx)
+        selections.map do |selection|
+
+          table_name, node = handle_fragments(selection, ctx)
+
+          if node.present? && node.selections.present?
+            singular = table_name.singularize.to_sym
+            plural   = table_name.pluralize.to_sym
+
+            # make sure that the next model is an ActiveRecord model
+            next_model = singular.to_s.classify.safe_constantize
+
+            if next_model.blank? || !(next_model < ActiveRecord::Base)
+              next_model = model
+            end
+
+            nested = map_includes(next_model, node.selections, ctx)
+
+            final_type =  if model.reflections[singular].present?
+                            # this is for has_one relationships
+                            singular
+
+                          elsif model.reflections[plural].present?
+                            # this is for has_many relationships
+                            plural
+
+                          else
+                            # this is for non-AR models (i.e. Product)
+                            # so they use the correct parent
+                            # TODO Try to get possible_types and include those
+                            nil
+                          end
+
+            if nested.present?
+              if final_type
+                # flatten is used for cases like Interfaces
+                # i.e. Customer -> Product -> Loan
+                # Product isn't an AR type
+                { final_type => nested.flatten }
+              else
+                nested.compact
+              end
+
+            else
+              final_type
+            end
+          else
+            nil
+          end
+        end.compact
+      end
+
+      ##
+      # method to handle fragments in GQL Query
+      # works by finding the fragment reference in the context
+      #
+      # @param node [GraphQL::Language::Nodes::*] current node
+      # @param ctx [GraphQL::Context] GQL Context used to map fragment to node
+      #
+      # @return [String, GraphQL::Language::Nodes::*] tuple of node name and node
+      def handle_fragments(node, ctx)
+        if node.class == GraphQL::Language::Nodes::FragmentSpread
+          fragment = ctx.query.fragments[node.name]
+          [fragment.type.underscore, fragment]
+        elsif node.class == GraphQL::Language::Nodes::InlineFragment
+          ##
+          # avoid auto-including things in InlineFragments
+          # If using an interface, not all fields are guaranteed to
+          # exist in all of the implementing types, but at this point,
+          # we can't tell if it will, because we don't know what type
+          # we are dealing with.
+          ##
+          [nil, nil]
+        else
+          [node.name, node]
+        end
+      end
+    end
+  end
+end

data/lib/graphql/active_record_extensions/version.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  module ActiveRecordExtensions
+    VERSION = "0.3.0"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql-active_record
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Brett Jurgens
@@ -96,12 +96,9 @@ files:
 - bin/console
 - bin/setup
 - graphql-active-record.gemspec
-- graphql-active_record-0.1.1.gem
-- graphql-active_record-0.1.2.gem
-- graphql-active_record-0.1.3.gem
-- graphql-active_record-0.1.4.gem
 - lib/graphql/active_record_extension.rb
-- lib/graphql/active_record_extension/version.rb
+- lib/graphql/active_record_extensions/field.rb
+- lib/graphql/active_record_extensions/version.rb
 homepage: http://github.com/brettjurgens/graphql-active-record
 licenses:
 - MIT

data/lib/graphql/active_record_extension/version.rb

@@ -1,5 +0,0 @@
-module Graphql
-  module ActiveRecordExtension
-    VERSION = "0.2.0"
-  end
-end