graphiform 0.1.3 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6bde49d1fc203265aee73785f6ff23308b5d2098259dd7bbc762dc0a8c16322
-  data.tar.gz: 061af2e25afdf9dad9fdedab5847212e3b7005c36290dfcbccdc73b085dd1588
+  metadata.gz: e55cfe2745a2343ff704c8fa0d6daaf8fde9a24c0d91e78fd938d0c143f74f6e
+  data.tar.gz: f4245107d1b61418d0a2e1995f845a42d56f8e45a33efa6cfd57f039795c587a
 SHA512:
-  metadata.gz: 0df7c307f8fbaa68fa1a33ee60d9c364603dbd911cb3726fc20073cf1bb9decaf1809387f5048fa080cd4abb6908f51fd744c769cbbb5f8c1e88db7fe631a7a7
-  data.tar.gz: df1bc69c8e412ae66be318d65c5574fef2cf1d5d2371a98ddd1293a6ceea9e7b4ac6e3bcd794b1660e8c7a6e7fbe26aa97737b723e5f4d3d5b22ad256e42e8ee
+  metadata.gz: 8e09ad27673bd942cf6a761a090451f4dab2ebe7a09dfc509fba0311ca412b2ddbdb39cd83dddc237a19fbe2c001b227244ffac601c9301e41d18468f55bd5bd
+  data.tar.gz: beb387c2994ec3e01c16441e358e6e49c3cb14c6b47e3a5ee2ec103fce48b7c55b57350bb3d21e11b021bd6210852af51f9c135ccb9dd7074395cdd8b1e5b4fb

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,37 +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, read_prepare: nil, **_options)
+      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
-            val = instance_exec(val, context, &read_prepare) if read_prepare
+          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)
+
+        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}" if argument_type.nil?
+        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,14 +90,6 @@ 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)
 
@@ -109,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)
@@ -130,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
@@ -150,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)
@@ -171,7 +168,9 @@ module Graphiform
           argument(
             name,
             type,
-            required: false
+            required: false,
+            as: as,
+            method_access: false
           )
         end
       end
@@ -183,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
@@ -205,28 +207,42 @@ module Graphiform
         graphql_type.class_eval do
           added_field = field(field_name, **field_options)
 
-          if read_prepare
+          if read_prepare || read_resolve
             define_method(
               added_field.method_sym,
-              -> { instance_exec(object.public_send(added_field.method_sym), context, &read_prepare) }
+              lambda do
+                value = read_resolve ? instance_exec(object, context, &read_resolve) : object.public_send(added_field.method_sym)
+                value = instance_exec(value, context, &read_prepare) if read_prepare
+
+                value
+              end
             )
           end
         end
       end
 
-      def graphql_add_column_field(field_name, column_def, type: nil, null: nil, **options)
-        is_enum = 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(field_name)
+          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, include_connection: true, read_prepare: 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"
@@ -245,23 +261,43 @@ module Graphiform
         if include_connection && has_many
           graphql_add_field_to_type(
             "#{field_name}_connection",
-            klass.graphql_create_resolver(association_def.name, klass.graphql_connection, read_prepare: read_prepare),
+            klass.graphql_create_resolver(
+              association_def.name,
+              klass.graphql_connection,
+              read_prepare: read_prepare,
+              read_resolve: read_resolve
+            ),
             false,
             **options
           )
         end
 
         if type.nil?
-          type = has_many ? klass.graphql_create_resolver(association_def.name, [klass.graphql_type], read_prepare: read_prepare) : klass.graphql_type
-          read_prepare = nil if has_many
+          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, read_prepare: read_prepare, **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.3'.freeze
+  VERSION = '0.2.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiform
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.3
 platform: ruby
 authors:
 - jayce.pulsipher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-19 00:00:00.000000000 Z
+date: 2020-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord