hq-graphql 2.0.10 → 2.1.3

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "hq/graphql/inputs"
+require "hq/graphql/mutation"
+require "hq/graphql/types"
+
+module HQ
+  module GraphQL
+    module Resource
+      module AutoMutation
+        def build_create
+          scoped_self = self
+
+          build_mutation(action: :create) do
+            define_method(:resolve) do |**args|
+              resource = scoped_self.new_record(context)
+              resource.assign_attributes(args[:attributes].format_nested_attributes)
+              if resource.save
+                {
+                  resource: resource,
+                  errors: {},
+                }
+              else
+                {
+                  resource: nil,
+                  errors: errors_from_resource(resource)
+                }
+              end
+            end
+
+            lazy_load do
+              argument :attributes, ::HQ::GraphQL::Inputs[scoped_self.model_name], required: true
+            end
+          end
+        end
+
+        def build_update
+          scoped_self = self
+
+          build_mutation(action: :update, require_primary_key: true) do
+            define_method(:resolve) do |**args|
+              resource = scoped_self.find_record(args, context)
+
+              if resource
+                resource.assign_attributes(args[:attributes].format_nested_attributes)
+                if resource.save
+                  {
+                    resource: resource,
+                    errors: {},
+                  }
+                else
+                  {
+                    resource: nil,
+                    errors: errors_from_resource(resource)
+                  }
+                end
+              else
+                {
+                  resource: nil,
+                  errors: { resource: "Unable to find #{self.class.graphql_name}" }
+                }
+              end
+            end
+
+            lazy_load do
+              argument :attributes, ::HQ::GraphQL::Inputs[scoped_self.model_name], required: true
+            end
+          end
+        end
+
+        def build_copy
+          scoped_self = self
+
+          build_mutation(action: :copy, require_primary_key: true, nil_klass: true) do
+            define_method(:resolve) do |**args|
+              resource = scoped_self.find_record(args, context)
+
+              if resource
+                copy = resource.copy
+                if copy.save
+                  {
+                    resource: copy,
+                    errors: {},
+                  }
+                else
+                  {
+                    resource: copy,
+                    errors: errors_from_resource(copy)
+                  }
+                end
+              else
+                {
+                  resource: nil,
+                  errors: { resource: "Unable to find #{self.class.graphql_name}" }
+                }
+              end
+            end
+          end
+        end
+
+        def build_destroy
+          scoped_self = self
+
+          build_mutation(action: :destroy, require_primary_key: true) do
+            define_method(:resolve) do |**attrs|
+              resource = scoped_self.find_record(attrs, context)
+
+              if resource
+                if resource.destroy
+                  {
+                    resource: resource,
+                    errors: {},
+                  }
+                else
+                  {
+                    resource: nil,
+                    errors: errors_from_resource(resource)
+                  }
+                end
+              else
+                {
+                  resource: nil,
+                  errors: { resource: "Unable to find #{self.class.graphql_name}" }
+                }
+              end
+            end
+          end
+        end
+
+        def build_mutation(action:, require_primary_key: false, nil_klass: false, &block)
+          gql_name = "#{graphql_name}#{action.to_s.titleize}"
+          scoped_model_name = model_name
+          Class.new(::HQ::GraphQL::Mutation) do
+            graphql_name gql_name
+
+            define_method(:ready?) do |*args|
+              super(*args) && ::HQ::GraphQL.authorized?(action, scoped_model_name, context)
+            end
+
+            lazy_load do
+              field :errors, ::HQ::GraphQL::Types::Object, null: false
+              field :resource, ::HQ::GraphQL::Types[scoped_model_name, nil_klass], null: true
+            end
+
+            instance_eval(&block)
+
+            if require_primary_key
+              lazy_load do
+                klass = scoped_model_name.constantize
+                primary_key = klass.primary_key
+                argument primary_key, ::GraphQL::Types::ID, required: true
+              end
+            end
+
+            def errors_from_resource(resource)
+              resource.errors.to_h.deep_transform_keys { |k| k.to_s.camelize(:lower) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hq/graphql/root_mutation.rb

@@ -7,7 +7,7 @@ module HQ
         super
         base.class_eval do
           lazy_load do
-            ::HQ::GraphQL.types.each do |type|
+            ::HQ::GraphQL.resources.each do |type|
               type.mutation_klasses.each do |mutation_name, klass|
                 field mutation_name, mutation: klass
               end

data/lib/hq/graphql/types.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "hq/graphql/types/object"
+require "hq/graphql/types/uuid"
+
 module HQ
   module GraphQL
     module Types
@@ -10,7 +13,7 @@ module HQ
       def self.registry
         @registry ||= Hash.new do |hash, options|
           klass, nil_klass = Array(options)
-          hash[klass] = nil_klass ? nil_query_klass(klass) : klass_for(klass)
+          hash[options] = nil_klass ? nil_query_object(klass) : klass_for(klass)
         end
       end
 
@@ -39,6 +42,10 @@ module HQ
             ::GraphQL::Types::Float
           when :boolean
             ::GraphQL::Types::Boolean
+          when :date
+            ::GraphQL::Types::ISO8601Date
+          when :datetime
+            ::GraphQL::Types::ISO8601DateTime
           else
             ::GraphQL::Types::String
           end
@@ -54,26 +61,20 @@ module HQ
       class << self
         private
 
-        def nil_query_klass(klass_or_string)
-          find_klass(klass_or_string, :nil_query_klass)
+        def nil_query_object(klass_or_string)
+          find_klass(klass_or_string, :nil_query_object)
         end
 
         def klass_for(klass_or_string)
-          find_klass(klass_or_string, :query_klass)
+          find_klass(klass_or_string, :query_object)
         end
 
         def find_klass(klass_or_string, method)
           klass = klass_or_string.is_a?(String) ? klass_or_string.constantize : klass_or_string
-          type = find_type(klass)
-          type ||= find_type(klass.base_class)
-          type ||= find_type(klass.superclass)
-
-          raise(Error, Error::MISSING_TYPE_MSG % { klass: klass.name }) if !type
-          type.send(method)
-        end
+          resource = ::HQ::GraphQL.lookup_resource(klass)
 
-        def find_type(klass)
-          ::HQ::GraphQL.resource_lookup(klass) || ::HQ::GraphQL.types.detect { |t| t.model_klass == klass }
+          raise(Error, Error::MISSING_TYPE_MSG % { klass: klass.name }) if !resource
+          resource.send(method)
         end
       end
     end

data/lib/hq/graphql/version.rb

@@ -2,6 +2,6 @@
 
 module HQ
   module GraphQL
-    VERSION = "2.0.10"
+    VERSION = "2.1.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hq-graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.10
+  version: 2.1.3
 platform: ruby
 authors:
 - Danny Jones
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-13 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -247,19 +247,25 @@ files:
 - lib/hq-graphql.rb
 - lib/hq/graphql.rb
 - lib/hq/graphql/active_record_extensions.rb
+- lib/hq/graphql/association_loader.rb
 - lib/hq/graphql/comparator.rb
 - lib/hq/graphql/config.rb
 - lib/hq/graphql/engine.rb
 - lib/hq/graphql/enum.rb
+- lib/hq/graphql/enum/sort_by.rb
+- lib/hq/graphql/enum/sort_order.rb
 - lib/hq/graphql/field.rb
+- 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/input_object.rb
 - lib/hq/graphql/inputs.rb
-- lib/hq/graphql/loaders.rb
-- lib/hq/graphql/loaders/association.rb
 - lib/hq/graphql/mutation.rb
 - lib/hq/graphql/object.rb
+- lib/hq/graphql/object_association.rb
+- lib/hq/graphql/paginated_association_loader.rb
 - lib/hq/graphql/resource.rb
-- lib/hq/graphql/resource/mutation.rb
+- lib/hq/graphql/resource/auto_mutation.rb
 - lib/hq/graphql/root_mutation.rb
 - lib/hq/graphql/root_query.rb
 - lib/hq/graphql/scalars.rb

data/lib/hq/graphql/loaders.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "hq/graphql/loaders/association"

data/lib/hq/graphql/loaders/association.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module HQ
-  module GraphQL
-    module Loaders
-      class Association < ::GraphQL::Batch::Loader
-        def initialize(model, association_name)
-          @model = model
-          @association_name = association_name
-          validate
-        end
-
-        def load(record)
-          raise TypeError, "#{@model} loader can't load association for #{record.class}" unless record.is_a?(@model)
-          return Promise.resolve(read_association(record)) if association_loaded?(record)
-          super
-        end
-
-        # We want to load the associations on all records, even if they have the same id
-        def cache_key(record)
-          record.object_id
-        end
-
-        def perform(records)
-          preload_association(records)
-          records.each { |record| fulfill(record, read_association(record)) }
-        end
-
-        private
-
-        def validate
-          unless @model.reflect_on_association(@association_name)
-            raise ArgumentError, "No association #{@association_name} on #{@model}"
-          end
-        end
-
-        def preload_association(records)
-          ::ActiveRecord::Associations::Preloader.new.preload(records, @association_name)
-        end
-
-        def read_association(record)
-          record.public_send(@association_name)
-        end
-
-        def association_loaded?(record)
-          record.association(@association_name).loaded?
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module HQ
-  module GraphQL
-    module Resource
-      module Mutation
-        def self.build(model_name, action:, graphql_name:, require_primary_key: false, nil_klass: false, &block)
-          Class.new(::HQ::GraphQL::Mutation) do
-            graphql_name graphql_name
-
-            define_method(:ready?) do |*args|
-              super(*args) && ::HQ::GraphQL.authorized?(action, model_name, context)
-            end
-
-            lazy_load do
-              field :errors, ::HQ::GraphQL::Types::Object, null: false
-              field :resource, ::HQ::GraphQL::Types[model_name, nil_klass], null: true
-            end
-
-            instance_eval(&block)
-
-            if require_primary_key
-              lazy_load do
-                klass = model_name.constantize
-                primary_key = klass.primary_key
-                argument primary_key, ::GraphQL::Types::ID, required: true
-              end
-            end
-
-            def errors_from_resource(resource)
-              resource.errors.to_h.deep_transform_keys { |k| k.to_s.camelize(:lower) }
-            end
-          end
-        end
-      end
-    end
-  end
-end