graphiform 0.1.2 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d348d5da31c862403a9127ada31cbb135e892c21928ca48b8ccfb5eb2d64d047
-  data.tar.gz: 73db372bee299b12a56e219218d04c4977436f3457379def8d0dd952a5e97aec
+  metadata.gz: 76a4ecba322d7e4c1f2486f621531307b184bf42f52827023ef5f11942b4bcbc
+  data.tar.gz: ed8815feff1a1eaba966dd44b5db53f1739fce88f0d0e9fb7a850dda522d74bc
 SHA512:
-  metadata.gz: b22a9b8d9e6b612406ab06a1d8fc86e8ad9e6305a8f1d222d7dc36a08f72cf95d911445ab5e2c1d852714f565b8d8758b6f3c2b3a1ebb1e62199a11f1a4880cb
-  data.tar.gz: c5766eb8d166b5311189ede79a26e21b5d55155199f24f995a763c9ddcc6540a5973bf360e1f5edb6ed75959085661f597e81946102a04b9022ad2ada48f5a61
+  metadata.gz: 412b372b015026737c993a1990031222c066272c5b9aec2563cd95e1474f5d2637d0a0ede3d3e589982ccb161b4b62d18c8380b117548e33221172689e1a5a41
+  data.tar.gz: b2c489a6c8f250f535657b5324aed7aa341365fa39540908ce2eabb6c403b793f71863cabfa63b6313ce60aab43731c94fc82492f7105e00d162a5eca0e1c96e

data/lib/graphiform/core.rb

@@ -76,8 +76,38 @@ module Graphiform
         unless defined? @base_resolver
           @base_resolver = Helpers.get_const_or_create(demodulized_name, ::Resolvers) do
             Class.new(::Resolvers::BaseResolver) do
-              # Default resolver just returns the object to prevent exceptions
-              define_method :resolve do |**_args|
+              attr_reader :value
+
+              class << self
+                attr_accessor :addon_resolve_blocks
+              end
+
+              def self.addon_resolve(&block)
+                @addon_resolve_blocks ||= []
+                @addon_resolve_blocks << block
+              end
+
+              def resolve(**args)
+                @value = base_resolve(**args)
+
+                if self.class.addon_resolve_blocks.present? && !self.class.addon_resolve_blocks.empty?
+                  self.class.addon_resolve_blocks.each do |addon_resolve_block|
+                    @value = instance_exec(**args, &addon_resolve_block)
+                  end
+                end
+
+                @value
+              end
+
+              def apply_built_ins(where: nil, sort: nil, **)
+                @value = @value.apply_filters(where.to_h) if where.present? && @value.respond_to?(:apply_filters)
+                @value = @value.apply_sorts(sort.to_h) if sort.present? && @value.respond_to?(:apply_sorts)
+
+                @value
+              end
+
+              # Default resolver - meant to be overridden
+              def base_resolve(**)
                 object
               end
             end
@@ -86,7 +116,14 @@ module Graphiform
           local_graphql_filter = graphql_filter
           local_graphql_sort = graphql_sort
 
+          model = self
           @base_resolver.class_eval do
+            unless respond_to?(:model)
+              define_method :model do
+                model
+              end
+            end
+
             argument :where, local_graphql_filter, required: false
             argument :sort, local_graphql_sort, required: false unless local_graphql_sort.arguments.empty?
           end
@@ -97,16 +134,14 @@ module Graphiform
 
       def graphql_query
         Helpers.get_const_or_create(demodulized_name, ::Resolvers::Queries) do
-          model = self
           local_graphql_type = graphql_type
           Class.new(graphql_base_resolver) do
             type local_graphql_type, null: false
 
-            define_method :resolve do |where: nil|
-              val = model.all
-              val = val.apply_filters(where.to_h) if where.present? && val.respond_to?(:apply_filters)
-
-              val.first
+            def base_resolve(**args)
+              @value = model.all
+              apply_built_ins(**args)
+              @value.first
             end
           end
         end
@@ -114,36 +149,30 @@ module Graphiform
 
       def graphql_connection_query
         Helpers.get_const_or_create(demodulized_name, ::Resolvers::ConnectionQueries) do
-          model = self
           connection_type = graphql_connection
           Class.new(graphql_base_resolver) do
             type connection_type, null: false
 
-            define_method :resolve do |where: nil, sort: nil|
-              val = model.all
-              val = val.apply_filters(where.to_h) if where.present? && val.respond_to?(:apply_filters)
-              val = val.apply_sorts(sort.to_h) if sort.present? && val.respond_to?(:apply_sorts)
-
-              val
+            def base_resolve(**args)
+              @value = model.all
+              apply_built_ins(**args)
             end
           end
         end
       end
 
-      def graphql_create_resolver(method_name, resolver_type = graphql_type)
+      def graphql_create_resolver(method_name, resolver_type = graphql_type, read_prepare: nil, read_resolve: nil, **)
         Class.new(graphql_base_resolver) do
           type resolver_type, null: false
 
-          define_method :resolve do |where: nil, **args|
-            where_hash = where.to_h
-
-            val = super(**args)
-
-            val = val.public_send(method_name) if val.respond_to? method_name
+          define_method :base_resolve do |**args|
+            @value = object
 
-            return val.apply_filters(where_hash) if val.respond_to? :apply_filters
+            @value = instance_exec(@value, context, &read_resolve) if read_resolve
+            @value = @value.public_send(method_name) if !read_resolve && @value.respond_to?(method_name)
+            @value = instance_exec(@value, context, &read_prepare) if read_prepare
 
-            val
+            apply_built_ins(**args)
           end
         end
       end

data/lib/graphiform/fields.rb

@@ -9,17 +9,18 @@ module Graphiform
     module ClassMethods
       def graphql_readable_field(
         name,
+        as: nil,
         **options
       )
-        column_def = column(name)
-        association_def = association(name)
+        column_def = column(as || name)
+        association_def = association(as || name)
 
-        graphql_add_column_field(name, column_def, **options) if column_def.present?
-        graphql_add_association_field(name, association_def, **options) if association_def.present?
-        graphql_add_method_field(name, **options) unless column_def.present? || association_def.present?
+        graphql_add_column_field(name, column_def, as: as, **options) if column_def.present?
+        graphql_add_association_field(name, association_def, as: as, **options) if association_def.present?
+        graphql_add_method_field(name, as: as, **options) unless column_def.present? || association_def.present?
 
-        graphql_add_scopes_to_filter(name)
-        graphql_field_to_sort(name)
+        graphql_add_scopes_to_filter(name, as || name)
+        graphql_field_to_sort(name, as || name)
       end
 
       def graphql_writable_field(
@@ -31,25 +32,30 @@ module Graphiform
         description: nil,
         default_value: ::GraphQL::Schema::Argument::NO_DEFAULT,
         as: nil,
-        **_options
+        **
       )
         name = name.to_sym
-        argument_name = graphql_resolve_argument_name(name)
-        argument_type = graphql_resolve_argument_type(name, type)
+        has_nested_attributes_method = instance_methods.include?("#{as || name}_attributes=".to_sym)
 
-        return Helpers.logger.warn "Graphiform: Missing `type` for argument #{name}" if argument_type.nil?
+        argument_name = has_nested_attributes_method ? "#{name}_attributes".to_sym : name
+        argument_type = graphql_resolve_argument_type(as || name, type)
+        as = has_nested_attributes_method ? "#{as}_attributes".to_sym : as.to_sym if as
+
+        return Helpers.logger.warn "Graphiform: Missing `type` for argument `#{name}` in model `#{self.name}`" if argument_type.nil?
 
         prepare = write_prepare || prepare
 
         graphql_input.class_eval do
-          argument \
+          argument(
             argument_name,
             argument_type,
             required: required,
             prepare: prepare,
             description: description,
             default_value: default_value,
-            as: as
+            as: as,
+            method_access: false
+          )
         end
       end
 
@@ -84,15 +90,9 @@ module Graphiform
 
       private
 
-      def graphql_resolve_argument_name(name)
-        attributes_name = "#{name}_attributes"
-
-        return attributes_name.to_sym if instance_methods.include?("#{attributes_name}=".to_sym)
-
-        name
-      end
-
       def graphql_resolve_argument_type(name, type)
+        type = graphql_create_enum(name) if type.blank? && enum_attribute?(name)
+
         return Helpers.graphql_type(type) if type.present?
 
         column_def = column(name)
@@ -107,12 +107,12 @@ module Graphiform
         has_many ? [association_def.klass.graphql_input] : association_def.klass.graphql_input
       end
 
-      def graphql_add_scopes_to_filter(name)
-        added_scopes = auto_scopes_by_attribute(name)
+      def graphql_add_scopes_to_filter(name, as)
+        added_scopes = auto_scopes_by_attribute(as)
 
         return if added_scopes.empty?
 
-        association_def = association(name)
+        association_def = association(as)
 
         if association_def.present?
           return unless Helpers.association_arguments_valid?(association_def, :graphql_filter)
@@ -128,19 +128,18 @@ module Graphiform
             enum = graphql_create_enum(name)
             scope_argument_type = scope_argument_type.is_a?(Array) ? [enum] : enum
           end
-          add_scope_def_to_filter(added_scope, scope_argument_type)
+          add_scope_def_to_filter(name, added_scope, scope_argument_type)
         end
       end
 
-      def add_scope_def_to_filter(scope_def, argument_type)
+      def add_scope_def_to_filter(name, scope_def, argument_type)
         return unless argument_type
 
         argument_type = Helpers.graphql_type(argument_type)
-        camelized_attribute = scope_def.attribute.to_s.camelize(:lower)
+        argument_attribute = name
         argument_prefix = scope_def.prefix
-        argument_suffix = scope_def.suffix
-        argument_suffix = argument_suffix == '_is' ? '' : argument_suffix
-        argument_name = "#{argument_prefix}#{camelized_attribute}#{argument_suffix}"
+        argument_suffix = scope_def.suffix == '_is' ? '' : scope_def.suffix
+        argument_name = "#{argument_prefix}#{argument_attribute}#{argument_suffix}".underscore
         scope_name = scope_def.name
 
         graphql_filter.class_eval do
@@ -148,15 +147,15 @@ module Graphiform
             argument_name,
             argument_type,
             required: false,
-            camelize: false,
-            as: scope_name
+            as: scope_name,
+            method_access: false
           )
         end
       end
 
-      def graphql_field_to_sort(name)
-        column_def = column(name)
-        association_def = association(name)
+      def graphql_field_to_sort(name, as)
+        column_def = column(as || name)
+        association_def = association(as || name)
 
         type = ::Enums::Sort if column_def.present?
         type = association_def.klass.graphql_sort if Helpers.association_arguments_valid?(association_def, :graphql_sort)
@@ -169,7 +168,9 @@ module Graphiform
           argument(
             name,
             type,
-            required: false
+            required: false,
+            as: as,
+            method_access: false
           )
         end
       end
@@ -181,18 +182,21 @@ module Graphiform
         description: nil,
         deprecation_reason: nil,
         method: nil,
+        as: nil,
         read_prepare: nil,
-        **_options
+        read_resolve: nil,
+        **
       )
+        type = Helpers.graphql_type(type)
+        is_resolver = Helpers.resolver?(type)
+
         field_name = field_name.to_sym
         field_options = {
           description: description,
           deprecation_reason: deprecation_reason,
-          method: method,
+          method: is_resolver ? nil : method || as,
         }
 
-        type = Helpers.graphql_type(type)
-
         if Helpers.resolver?(type)
           field_options[:resolver] = type
         else
@@ -203,19 +207,40 @@ module Graphiform
         graphql_type.class_eval do
           added_field = field(field_name, **field_options)
 
-          define_method(added_field.method_sym, -> { read_prepare.call(object.public_send(added_field.method_sym)) }) if read_prepare
+          if read_prepare || read_resolve
+            define_method(
+              added_field.method_sym,
+              lambda do
+                value = read_resolve ? instance_exec(object, context, &read_resolve) : object.public_send(added_field.method_sym)
+                instance_exec(value, context, &read_prepare) if read_prepare
+              end
+            )
+          end
         end
       end
 
-      def graphql_add_column_field(field_name, column_def, type: nil, null: nil, **options)
-        type = :string if type.blank? && enum_attribute?(field_name)
+      def graphql_add_column_field(field_name, column_def, type: nil, null: nil, as: nil, **options)
+        is_enum = type.blank? && enum_attribute?(as || field_name)
+        if is_enum
+          enum = graphql_create_enum(as || field_name)
+          type = enum
+        end
         type ||= column_def.type
         null = column_def.null if null.nil?
 
-        graphql_add_field_to_type(field_name, type, null, **options)
+        graphql_add_field_to_type(field_name, type, null, as: as, **options)
       end
 
-      def graphql_add_association_field(field_name, association_def, type: nil, null: nil, **options)
+      def graphql_add_association_field(
+        field_name,
+        association_def,
+        type: nil,
+        null: nil,
+        include_connection: true,
+        read_prepare: nil,
+        read_resolve: nil,
+        **options
+      )
         unless association_def.klass.respond_to?(:graphql_type)
           return Helpers.logger.warn(
             "Graphiform: `#{name}` trying to add association `#{field_name}` - `#{association_def.klass.name}` does not include Graphiform"
@@ -231,22 +256,46 @@ module Graphiform
         has_many = association_def.macro == :has_many
         klass = association_def.klass
 
-        if has_many
+        if include_connection && has_many
           graphql_add_field_to_type(
             "#{field_name}_connection",
-            klass.graphql_create_resolver(association_def.name, graphql_connection),
+            klass.graphql_create_resolver(
+              association_def.name,
+              klass.graphql_connection,
+              read_prepare: read_prepare,
+              read_resolve: read_resolve
+            ),
             false,
             **options
           )
         end
 
-        type = has_many ? klass.graphql_create_resolver(association_def.name, [klass.graphql_type]) : klass.graphql_type if type.nil?
+        if type.nil?
+          type = (
+            if has_many
+              klass.graphql_create_resolver(
+                association_def.name,
+                [klass.graphql_type],
+                read_prepare: read_prepare,
+                read_resolve: read_resolve
+              )
+            else
+              klass.graphql_type
+            end
+          )
+
+          if has_many
+            read_prepare = nil
+            read_resolve = nil
+          end
+        end
+
         null = association_def.macro != :has_many if null.nil?
 
-        graphql_add_field_to_type(field_name, type, null, **options)
+        graphql_add_field_to_type(field_name, type, null, read_prepare: read_prepare, read_resolve: read_resolve, **options)
       end
 
-      def graphql_add_method_field(field_name, type:, null: true, **options)
+      def graphql_add_method_field(field_name, type: nil, null: true, **options)
         return Helpers.logger.warn "Graphiform: Missing `type` for field `#{field_name}` in model `#{name}`" if type.nil?
 
         graphql_add_field_to_type(field_name, type, null, **options)

data/lib/graphiform/version.rb

@@ -1,3 +1,3 @@
 module Graphiform
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.2.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiform
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.2
 platform: ruby
 authors:
 - jayce.pulsipher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-18 00:00:00.000000000 Z
+date: 2020-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.2
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement