hq-graphql 2.0.7 → 2.1.1

data/lib/hq/graphql/resource.rb

@@ -1,21 +1,26 @@
-# typed: false
 # frozen_string_literal: true
 
-require "hq/graphql/resource/mutation"
+require "hq/graphql/enum/sort_by"
+require "hq/graphql/field_extension/paginated_arguments"
+require "hq/graphql/input_object"
+require "hq/graphql/object"
+require "hq/graphql/resource/auto_mutation"
+require "hq/graphql/scalars"
 
 module HQ
   module GraphQL
     module Resource
-      extend T::Helpers
-
       def self.included(base)
         super
-        ::HQ::GraphQL.types << base
+        ::HQ::GraphQL.resources << base
         base.include Scalars
         base.include ::GraphQL::Types
+        base.extend ClassMethods
       end
 
       module ClassMethods
+        include AutoMutation
+
         attr_writer :graphql_name, :model_name
 
         def scope(context)
@@ -39,7 +44,7 @@ module HQ
         end
 
         def model_name
-          @model_name || name.demodulize
+          @model_name || ::HQ::GraphQL.extract_class(self)
         end
 
         def model_klass
@@ -62,6 +67,10 @@ module HQ
           @query_klass ||= build_graphql_object
         end
 
+        def sort_fields_enum
+          @sort_fields_enum || ::HQ::GraphQL::Enum::SortBy
+        end
+
         protected
 
         def default_scope(&block)
@@ -73,155 +82,25 @@ module HQ
         end
 
         def mutations(create: true, copy: true, update: true, destroy: true)
-          scoped_graphql_name = graphql_name
-          scoped_model_name = model_name
-          scoped_self = self
-
-          if create
-            create_mutation = ::HQ::GraphQL::Resource::Mutation.build(model_name, action: :create, graphql_name: "#{scoped_graphql_name}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_model_name], required: true
-              end
-            end
-
-            mutation_klasses["create_#{scoped_graphql_name.underscore}"] = create_mutation
-          end
-
-          if copy
-            copy_mutation = ::HQ::GraphQL::Resource::Mutation.build(
-              model_name,
-              action: :copy,
-              graphql_name: "#{scoped_graphql_name}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 #{scoped_graphql_name}" }
-                  }
-                end
-              end
-            end
-
-            mutation_klasses["copy_#{scoped_graphql_name.underscore}"] = copy_mutation
-          end
-
-          if update
-            update_mutation = ::HQ::GraphQL::Resource::Mutation.build(
-              model_name,
-              action: :update,
-              graphql_name: "#{scoped_graphql_name}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 #{scoped_graphql_name}" }
-                  }
-                end
-              end
-
-              lazy_load do
-                argument :attributes, ::HQ::GraphQL::Inputs[scoped_model_name], required: true
-              end
-            end
-
-            mutation_klasses["update_#{scoped_graphql_name.underscore}"] = update_mutation
-          end
-
-          if destroy
-            destroy_mutation = ::HQ::GraphQL::Resource::Mutation.build(
-              model_name,
-              action: :destroy,
-              graphql_name: "#{scoped_graphql_name}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 #{scoped_graphql_name}" }
-                  }
-                end
-              end
-            end
-
-            mutation_klasses["destroy_#{scoped_graphql_name.underscore}"] = destroy_mutation
-          end
+          mutation_klasses["create_#{graphql_name.underscore}"] = build_create if create
+          mutation_klasses["copy_#{graphql_name.underscore}"] = build_copy if copy
+          mutation_klasses["update_#{graphql_name.underscore}"] = build_update if update
+          mutation_klasses["destroy_#{graphql_name.underscore}"] = build_destroy if destroy
         end
 
         def query(**options, &block)
           @query_klass = build_graphql_object(**options, &block)
         end
 
+        def sort_fields(*fields)
+          self.sort_fields_enum = fields
+        end
+
         def def_root(field_name, is_array: false, null: true, &block)
-          graphql = self
+          resource = self
           resolver = -> {
             Class.new(::GraphQL::Schema::Resolver) do
-              type = is_array ? [graphql.query_klass] : graphql.query_klass
+              type = is_array ? [resource.query_klass] : resource.query_klass
               type type, null: null
               class_eval(&block) if block
             end
@@ -231,7 +110,7 @@ module HQ
           }
         end
 
-        def root_query(find_one: true, find_all: true, pagination: false, per_page_max: 250)
+        def root_query(find_one: true, find_all: true, pagination: true, limit_max: 250)
           field_name = graphql_name.underscore
           scoped_self = self
 
@@ -250,18 +129,22 @@ module HQ
 
           if find_all
             def_root field_name.pluralize, is_array: true, null: false do
-              argument :page, Integer, required: false
-              argument :per_page, Integer, required: false
+              extension FieldExtension::PaginatedArguments, klass: scoped_self.model_klass if pagination
 
-              define_method(:resolve) do |page: nil, per_page: nil, **_attrs|
+              define_method(:resolve) do |limit: nil, offset: nil, sort_by: nil, sort_order: nil, **_attrs|
                 scope = scoped_self.scope(context).all
 
-                if pagination || page || per_page
-                  page ||= 0
-                  limit = [per_page_max, *per_page].min
-                  scope = scope.limit(limit).offset(page * limit)
+                if pagination || page || limit
+                  offset = [0, *offset].max
+                  limit = [[limit_max, *limit].min, 0].max
+                  scope = scope.limit(limit).offset(offset)
                 end
 
+                sort_by ||= :updated_at
+                sort_order ||= :desc
+                # There should be no risk for SQL injection since an enum is being used for both sort_by and sort_order
+                scope = scope.reorder(sort_by => sort_order)
+
                 scope
               end
             end
@@ -293,9 +176,17 @@ module HQ
             class_eval(&block) if block
           end
         end
-      end
 
-      mixes_in_class_methods(ClassMethods)
+        def sort_fields_enum=(fields)
+          @sort_fields_enum ||= Class.new(::HQ::GraphQL::Enum::SortBy).tap do |c|
+            c.graphql_name "#{graphql_name}Sort"
+          end
+
+          Array(fields).each do |field|
+            @sort_fields_enum.value field.to_s.classify, value: field
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,4 +1,3 @@
-# typed: true
 # frozen_string_literal: true
 
 module HQ
@@ -8,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