hq-graphql 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be9de36cb5b0f12696e98d85156404d89acdc6d5
-  data.tar.gz: 0e887aabc0d14374ad192e464a8b1e3e4ac4ea8f
+  metadata.gz: b25a73fce273a48a00a185766cae51a9ec2e3150
+  data.tar.gz: 7c325eaef387c340778954fb83dbb3d0ccac9c03
 SHA512:
-  metadata.gz: 7ec2755f98cd6045e93da317edec985a3a148c4baef5a7e30d24c1568020327f455d4a7efb14b117d482c0b51106e69ad67f0db33c6051c8b42d750f951086c8
-  data.tar.gz: aae1f46e971c88db6a4e87d919dc354e0235931041bf485172df0109520892f1e0294a10b99c81943ca71132b92ed1bfd56f76fdda5d2cb0e3b9e9323bc56665
+  metadata.gz: da27072503a7751c1eefa68ebdf6a0fcb77b28a6213fb8fb6a4d7fdec32d9f0bd14dfb585d0196f4d1119cd2d5ecb8d33e54c7c1e902051612e3fb7d9e2ab815
+  data.tar.gz: c5b52d4d4d8af7fe53b1c1aa50ad28b62eb36b66c2f39de2e6b4a51add6505c110b3e7d6182f0efcb302d53ca70c78ccf1d5817206eef413635d033832cc10af

data/README.md

@@ -7,20 +7,106 @@ OneHQ GraphQL interface to [Ruby Graphql](https://github.com/rmosolgo/graphql-ru
 
 ## Configuration
 
-You can pass configuration options as a block to `::HQ::GraphQL.configure`.
+### Default Scope
+Define a global default scope.
 
 ```ruby
-# The gem assumes that if your model is called `MyModel`, the corresponding type is `MyModelType`.
-# You can override that convention.
-# Default is: -> (model_class) { "#{model_class.name.demodulize}Type" }
 ::HQ::GraphQL.config do |config|
-  config.model_to_graphql_type = -> (model_class) { "::CustomNameSpace::#{model_class.name}Type" }
+  config.default_scope = ->(scope, context) do
+    scope.where(organization_id: context[:organization_id])
+  end
+end
+```
+
+## GraphQL Resource
+Connect to ActiveRecord to auto generate queries and mutations.
+
+### Queries
+Include `::HQ::GraphQL::Resource` and set `self.model_name` to start using queries.
+Fields will be created for all active record columns. Association fields will be created if the association
+is also a GraphQL Resource.
+
+```ruby
+class AdvisorResource
+  include ::HQ::GraphQL::Resource
+
+  # ActiveRecord Model Name
+  self.model_name = "Advisor"
+end
+```
+
+#### Customize
+```ruby
+class AdvisorResource
+  include ::HQ::GraphQL::Resource
+  self.model_name = "Advisor"
+
+  # Turn off fields for active record associations
+  query attributes: true, associations: false do
+    # Create field for addresses
+    add_association :addresses
+
+    # add a custom field
+    field :custom_field, String, null: false
+
+    def custom_field
+      "Fizz"
+    end
+  end
+end
+```
+
+### Mutations
+Mutations will not be created by default. Add `mutations` to a resource to build mutations for create, update, and destroy.
+
+```ruby
+class AdvisorResource
+  include ::HQ::GraphQL::Resource
+  self.model_name = "Advisor"
+
+  # Builds the following mutations:
+  #   createAdvisor
+  #   updateAdvisor
+  #   destroyAdvisor
+  mutations create: true, update: true, destroy: true
+
+  # Turn off fields for active record associations
+  inputs attributes: true, associations: false do
+    # Create input argument for addresses
+    add_association :addresses
+  end
 end
 ```
 
-## Usage
+### Root Mutations
+Add mutations to your schema
+
+```ruby
+class RootMutation < ::HQ::GraphQL::RootMutation; end
+
+class Schema < ::GraphQL::Schema
+  mutation(RootMutation)
+end
+```
+
+### Root Queries
+Create a root query:
+```ruby
+class AdvisorResource
+  include ::HQ::GraphQL::Resource
+  self.model_name = "Advisor"
+
+  root_query
+end
+
+class RootQuery < ::HQ::GraphQL::RootQuery; end
+
+class Schema < ::GraphQL::Schema
+  mutation(RootQuery)
+end
+```
 
-Create a new ::HQ::GraphQL::Object
+## Create a new ::HQ::GraphQL::Object
 ```ruby
 class AdvisorType < ::HQ::GraphQL::Object
   # Supports graphql-ruby functionality

data/lib/hq/graphql/active_record_extensions.rb

@@ -0,0 +1,125 @@
+module HQ
+  module GraphQL
+    module ActiveRecordExtensions
+      class Error < StandardError
+        MISSING_MODEL_MSG = "Your GraphQL object must be connected to a model: `::HQ::GraphQL::Object.with_model 'User'`".freeze
+        MISSING_ATTR_MSG = "Can't find attr %{model}.%{attr}'`".freeze
+        MISSING_ASSOC_MSG = "Can't find association %{model}.%{assoc}'`".freeze
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        attr_accessor :model_name,
+                    :auto_load_attributes,
+                    :auto_load_associations
+
+        def lazy_load(&block)
+          @lazy_load ||= []
+          @lazy_load << block if block
+          @lazy_load
+        end
+
+        def lazy_load!
+          lazy_load.map(&:call)
+          @lazy_load = []
+        end
+
+        def model_columns
+          model_columns =
+            if auto_load_attributes
+              model_klass.columns
+            else
+              added_attributes.map { |attr| column_from_model(attr) }
+            end
+
+          # validate removed_attributes exist
+          removed_attributes.each { |attr| column_from_model(attr) }
+
+          model_columns.reject { |c| removed_attributes.include?(c.name.to_sym) }
+        end
+
+        def model_associations
+          model_associations =
+            if auto_load_associations
+              model_klass.reflect_on_all_associations
+            else
+              added_associations.map { |association| association_from_model(association) }
+            end
+
+          # validate removed_associations exist
+          removed_associations.each { |association| association_from_model(association) }
+
+          model_associations.reject { |a| removed_associations.include?(a.name.to_sym) }
+        end
+
+        private
+
+        def add_attributes(*attrs)
+          validate_model!
+          added_attributes.concat attrs.map(&:to_sym)
+        end
+        alias_method :add_attribute, :add_attributes
+        alias_method :add_attrs, :add_attributes
+        alias_method :add_attr, :add_attributes
+
+        def remove_attributes(*attrs)
+          validate_model!
+          removed_attributes.concat attrs.map(&:to_sym)
+        end
+        alias_method :remove_attribute, :remove_attributes
+        alias_method :remove_attrs, :remove_attributes
+        alias_method :remove_attr, :remove_attributes
+
+        def add_associations(*associations)
+          validate_model!
+          added_associations.concat associations.map(&:to_sym)
+        end
+        alias_method :add_association, :add_associations
+
+        def remove_associations(*associations)
+          validate_model!
+          removed_associations.concat associations.map(&:to_sym)
+        end
+        alias_method :remove_association, :remove_associations
+
+        def model_klass
+          @model_klass ||= model_name.constantize
+        end
+
+        def column_from_model(attr)
+          model_klass.columns_hash[attr.to_s] || raise(Error, Error::MISSING_ATTR_MSG % { model: model_name, attr: attr })
+        end
+
+        def association_from_model(association)
+          model_klass.reflect_on_association(association) || raise(Error, Error::MISSING_ASSOC_MSG % { model: model_name, assoc: association })
+        end
+
+        def added_attributes
+          @added_attributes ||= []
+        end
+
+        def removed_attributes
+          @removed_attributes ||= []
+        end
+
+        def added_associations
+          @added_associations ||= []
+        end
+
+        def removed_associations
+          @removed_associations ||= []
+        end
+
+        def validate_model!
+          lazy_load do
+            model_name || raise(Error, Error::MISSING_MODEL_MSG)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/hq/graphql/input_extensions.rb

@@ -0,0 +1,56 @@
+module HQ
+  module GraphQL
+    module InputExtensions
+
+      def self.included(base)
+        base.include Scalars
+        base.include ::HQ::GraphQL::ActiveRecordExtensions
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def with_model(model_name, attributes: true, associations: false)
+          self.model_name = model_name
+          self.auto_load_attributes = attributes
+          self.auto_load_associations = associations
+
+          lazy_load do
+            model_columns.each do |column|
+              argument_from_column(column)
+            end
+
+            model_associations.each do |association|
+              argument_from_association association
+            end
+          end
+        end
+
+        private
+
+        def argument_from_association(association)
+          input = ::HQ::GraphQL::Inputs[association.klass]
+          name = association.name
+          name_attributes = "#{name}_attributes"
+          case association.macro
+          when :has_many
+            argument name_attributes, [input], required: false
+          else
+            argument name_attributes, input, required: false
+          end
+
+          if !model_klass.nested_attributes_options.keys.include?(name.to_sym)
+            model_klass.accepts_nested_attributes_for name, allow_destroy: true
+          end
+        rescue ::HQ::GraphQL::Inputs::Error
+          nil
+        end
+
+        def argument_from_column(column)
+          argument column.name, ::HQ::GraphQL::Types.type_from_column(column), required: false
+        end
+
+      end
+    end
+  end
+end

data/lib/hq/graphql/input_object.rb

@@ -0,0 +1,17 @@
+module HQ
+  module GraphQL
+    class InputObject < ::GraphQL::Schema::InputObject
+      include ::HQ::GraphQL::InputExtensions
+
+      def self.to_graphql
+        lazy_load!
+        super
+      end
+
+      def with_indifferent_access
+        to_h.with_indifferent_access
+      end
+
+    end
+  end
+end

data/lib/hq/graphql/inputs.rb

@@ -0,0 +1,32 @@
+module HQ
+  module GraphQL
+    module Inputs
+      class Error < StandardError
+        MISSING_TYPE_MSG = "The GraphQL type for `%{klass}` is missing.".freeze
+      end
+
+      def self.[](key)
+        @inputs ||= Hash.new do |hash, klass|
+          hash[klass] = klass_for(klass)
+        end
+        @inputs[key]
+      end
+
+      # Only being used in testing
+      def self.reset!
+        @inputs = nil
+      end
+
+      class << self
+        private
+
+        def klass_for(klass_or_string)
+          klass = klass_or_string.is_a?(String) ? klass_or_string.constantize : klass_or_string
+          ::HQ::GraphQL.types.detect { |t| t.model_klass == klass }&.input_klass ||
+             raise(Error, Error::MISSING_TYPE_MSG % { klass: klass.name })
+        end
+      end
+
+    end
+  end
+end

data/lib/hq/graphql/mutation.rb

@@ -0,0 +1,13 @@
+module HQ
+  module GraphQL
+    class Mutation < ::GraphQL::Schema::Mutation
+      include ::HQ::GraphQL::InputExtensions
+
+      def self.generate_payload_type
+        lazy_load!
+        super
+      end
+
+    end
+  end
+end

data/lib/hq/graphql/object.rb

@@ -1,58 +1,25 @@
 module HQ
   module GraphQL
     class Object < ::GraphQL::Schema::Object
-      class Error < StandardError
-        MISSING_MODEL_MSG = "Can't perform %{action} without connecting to a model: `::HQ::GraphQL::Object.with_model 'User'`".freeze
-        MISSING_ATTR_MSG = "Can't find attr %{model}.%{attr}'`".freeze
-        MISSING_ASSOC_MSG = "Can't find association %{model}.%{assoc}'`".freeze
-      end
-
-      def self.lazy_load(&block)
-        @lazy_load ||= []
-        @lazy_load << block if block
-        @lazy_load
-      end
+      include Scalars
+      include ::HQ::GraphQL::ActiveRecordExtensions
 
       def self.with_model(model_name, attributes: true, associations: true)
         self.model_name = model_name
+        self.auto_load_attributes = attributes
+        self.auto_load_associations = associations
 
         lazy_load do
-          if attributes
-            model_klass.columns.reject { |c| removed_attrs.include?(c.name.to_sym) }.each do |column|
-              field_from_column column
-            end
+          model_columns.each do |column|
+            field_from_column(column)
           end
 
-          if associations
-            model_klass.reflect_on_all_associations.reject { |a| removed_associations.include?(a.name.to_sym) }.each do |association|
-              field_from_association association
-            end
+          model_associations.each do |association|
+            field_from_association association
           end
         end
       end
 
-      def self.add_attr(attr)
-        lazy_load do
-          validate_model!(:add_attr)
-          field_from_column model_column(attr)
-        end
-      end
-
-      def self.remove_attrs(*attrs)
-        removed_attrs.concat attrs.map(&:to_sym)
-      end
-
-      def self.remove_associations(*associations)
-        removed_associations.concat associations.map(&:to_sym)
-      end
-
-      def self.add_association(association)
-        lazy_load do
-          validate_model!(:add_association)
-          field_from_association model_association(association)
-        end
-      end
-
       def self.to_graphql
         lazy_load!
         super
@@ -61,55 +28,22 @@ module HQ
       class << self
         private
 
-        attr_accessor :model_name
-        attr_writer :removed_attrs, :removed_associations
-
-        def lazy_load!
-          lazy_load.map(&:call)
-          @lazy_load = []
-        end
-
-        def model_klass
-          @model_klass ||= model_name&.constantize
-        end
-
-        def model_column(attr)
-          model_klass.columns_hash[attr.to_s] || raise(Error, Error::MISSING_ATTR_MSG % { model: model_name, attr: attr })
-        end
-
-        def model_association(association)
-          model_klass.reflect_on_association(association) || raise(Error, Error::MISSING_ASSOC_MSG % { model: model_name, assoc: association })
-        end
-
-        def removed_attrs
-          @removed_attrs ||= []
-        end
-
-        def removed_associations
-          @removed_associations ||= []
-        end
-
-        def validate_model!(action)
-          unless model_name
-            raise Error, Error::MISSING_MODEL_MSG % { action: action }
-          end
-        end
-
         def field_from_association(association)
-          name = association.name
           type = ::HQ::GraphQL::Types[association.klass]
+          name = association.name
           case association.macro
           when :has_many
             field name, [type], null: false
           else
             field name, type, null: true
           end
+        rescue ::HQ::GraphQL::Types::Error
+          nil
         end
 
         def field_from_column(column)
           field column.name, ::HQ::GraphQL::Types.type_from_column(column), null: column.null
         end
-
       end
 
     end

data/lib/hq/graphql/resource/mutation.rb

@@ -0,0 +1,32 @@
+module HQ
+  module GraphQL
+    module Resource
+      module Mutation
+
+        def self.build(model_name, graphql_name:, require_primary_key: false, &block)
+          Class.new(::HQ::GraphQL::Mutation) do
+            graphql_name graphql_name
+
+            lazy_load do
+              field :errors, [String], null: false
+              field :resource, ::HQ::GraphQL::Types[model_name], null: true
+            end
+
+            instance_eval(&block)
+
+            if require_primary_key
+              lazy_load do
+                klass = model_name.constantize
+                primary_key = klass.primary_key
+                pk_column = klass.columns.detect { |c| c.name == primary_key.to_s }
+
+                argument primary_key, ::HQ::GraphQL::Types.type_from_column(pk_column), required: true
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end