graphiti 1.0.beta.15 → 1.0.beta.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e06792e034635555f5687496aebef2ed8e0eac93
-  data.tar.gz: c3d10077cc25cff01a1adf79059dc3c3b6ee213d
+  metadata.gz: ff5dc08a7d35f114a138a26759c857eb11a226de
+  data.tar.gz: 00d815886fc13aca087ce7b140fc472020cbfd5c
 SHA512:
-  metadata.gz: 4cba835660dc04c71d333703860acd47eb408a463bc1cdb5c4d29d75d0904ee680fddceb6497490fd4c47effaadef6bd65ddb3285984931f999d950073e8a894
-  data.tar.gz: 1d3f3b288997909c4763966ce32dab8cf4998f56a29122c630a3f953741e471d2bb5bcfa56676c710007f2a51eaff1948593d5619270c4f606093fa5ce886052
+  metadata.gz: bff46d68fcb42853a4d9e31e169ce1a06ea6bb84007728f86cc5f3b2901a3b7b5e310c906e5ad147b14161fc215c7158dd56b92b7dd12b810fd9a599c6b7f74a
+  data.tar.gz: f519c2331d8c4e30550bcd5481ff07c03ab9ce020855e6b1c7993f60e94d1a12f4930a39eebb4c1c4615cb7cf588ee4127bb6c820d17d4c67ed552c4b61cf20e

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Venkata Pasupuleti
+Copyright (c) 2018 Lee Richmond
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/graphiti.rb

@@ -27,6 +27,8 @@ require "graphiti/resource/configuration"
 require "graphiti/resource/dsl"
 require "graphiti/resource/interface"
 require "graphiti/resource/polymorphism"
+require "graphiti/resource/documentation"
+require "graphiti/resource/persistence"
 require "graphiti/sideload"
 require "graphiti/sideload/has_many"
 require "graphiti/sideload/belongs_to"
@@ -194,3 +196,5 @@ end
 class Object
   prepend InstanceVariableOverride
 end
+
+ActiveSupport.run_load_hooks(:graphiti, Graphiti)

data/lib/graphiti/adapters/abstract.rb

@@ -41,7 +41,9 @@ module Graphiti
           float: numerical_operators,
           boolean: [:eq],
           date: numerical_operators,
-          datetime: numerical_operators
+          datetime: numerical_operators,
+          hash: [:eq],
+          array: [:eq]
         }
       end
 
@@ -379,75 +381,26 @@ module Graphiti
         end
       end
 
-      # Remove the association without destroying objects
-      #
-      # This is NOT needed in the standard use case. The standard use case would be:
-      #
-      #   def update(attrs)
-      #     # attrs[:the_foreign_key] is nil, so updating the record disassociates
-      #   end
-      #
-      # However, sometimes you need side-effect or elsewise non-standard behavior. Consider
-      # using {{https://github.com/mbleigh/acts-as-taggable-on acts_as_taggable_on}} gem:
-      #
-      #   # Not actually needed, just an example
-      #   def disassociate(parent, child, association_name, association_type)
-      #     parent.tag_list.remove(child.name)
-      #   end
-      #
-      # @example Basic accessor
-      #   def disassociate(parent, child, association_name, association_type)
-      #     if association_type == :has_many
-      #       parent.send(association_name).delete(child)
-      #     else
-      #       child.send(:"#{association_name}=", nil)
-      #     end
-      #   end
-      #
-      # +association_name+ and +association_type+ come from your sideload
-      # configuration:
-      #
-      #   allow_sideload :the_name, type: the_type do
-      #     # ... code.
-      #   end
-      #
-      # @param parent The parent object (via the JSONAPI 'relationships' graph)
-      # @param child The child object (via the JSONAPI 'relationships' graph)
-      # @param association_name The 'relationships' key we are processing
-      # @param association_type The Sideload type (see Sideload#type). Usually :has_many/:belongs_to/etc
       def disassociate(parent, child, association_name, association_type)
         raise 'you must override #disassociate in an adapter subclass'
       end
 
-      # @param [Class] model_class The configured model class (see Resource.model)
-      # @param [Hash] create_params Attributes + id
-      # @return the model instance just created
-      # @see Resource.model
-      # @example ActiveRecord default
-      #   def create(model_class, create_params)
-      #     instance = model_class.new(create_params)
-      #     instance.save
-      #     instance
-      #   end
-      def create(model_class, create_params)
-        raise 'you must override #create in an adapter subclass'
+      def build(model_class)
+        model_class.new
       end
 
-      # @param [Class] model_class The configured model class (see Resource.model)
-      # @param [Hash] update_params Attributes + id
-      # @return the model instance just created
-      # @see Resource.model
-      # @example ActiveRecord default
-      #   def update(model_class, update_params)
-      #     instance = model_class.find(update_params.delete(:id))
-      #     instance.update_attributes(update_params)
-      #     instance
-      #   end
-      def update(model_class, update_params)
-        raise 'you must override #update in an adapter subclass'
+      # TODO respond to and specific error
+      def assign_attributes(model_instance, attributes)
+        attributes.each_pair do |k, v|
+          model_instance.send(:"#{k}=", v)
+        end
+      end
+
+      def save(model_instance)
+        raise 'you must override #save in an adapter subclass'
       end
 
-      def destroy(model)
+      def destroy(model_instance)
         raise 'you must override #destroy in an adapter subclass'
       end
 

data/lib/graphiti/adapters/active_record.rb

@@ -260,6 +260,16 @@ module Graphiti
         model.destroy
         model
       end
+
+      def save(model_instance)
+        model_instance.save
+        model_instance
+      end
+
+      def destroy(model_instance)
+        model_instance.destroy
+        model_instance
+      end
     end
   end
 end

data/lib/graphiti/errors.rb

@@ -16,6 +16,19 @@ The adapter #{@adapter.class} does not implement method '#{@method}', which was
       end
     end
 
+    class AroundCallbackProc < Base
+      def initialize(resource_class, method_name)
+        @resource_class = resource_class
+        @method_name = method_name
+      end
+
+      def message
+        <<-MSG
+#{@resource_class}: Tried to pass block to .#{@method_name}, which only accepts a method name.
+        MSG
+      end
+    end
+
     class UnsupportedOperator < Base
       def initialize(resource, filter_name, supported, operator)
         @resource = resource

data/lib/graphiti/filter_operators.rb

@@ -5,7 +5,7 @@ module Graphiti
 
       def initialize(resource, type_name, opts)
         @procs = {}
-        defaults = resource.adapter.default_operators[type_name] || []
+        defaults = resource.adapter.default_operators[type_name] || [:eq]
         if opts[:only]
           defaults = defaults.select { |op| opts[:only].include?(op) }
         end

data/lib/graphiti/railtie.rb

@@ -13,6 +13,12 @@ module Graphiti
       end
     end
 
+    initializer 'graphti.logger' do
+      config.after_initialize do
+        Graphiti.logger = ::Rails.logger
+      end
+    end
+
     initializer 'graphiti.init' do
       if ::Rails.application.config.eager_load
         config.after_initialize do |app|

data/lib/graphiti/resource.rb

@@ -5,6 +5,8 @@ module Graphiti
     include Configuration
     include Sideloading
     include Links
+    include Documentation
+    include Persistence
 
     attr_reader :context
 
@@ -80,18 +82,6 @@ module Graphiti
       end
     end
 
-    def create(create_params)
-      adapter.create(model, create_params)
-    end
-
-    def update(update_params)
-      adapter.update(model, update_params)
-    end
-
-    def destroy(model)
-      adapter.destroy(model)
-    end
-
     def associate_all(parent, children, association_name, type)
       adapter.associate_all(parent, children, association_name, type)
     end

data/lib/graphiti/resource/configuration.rb

@@ -169,7 +169,8 @@ module Graphiti
               before_commit: {},
               attributes: {},
               extra_attributes: {},
-              sideloads: {}
+              sideloads: {},
+              callbacks: {}
             }
         end
 

data/lib/graphiti/resource/documentation.rb

@@ -0,0 +1,55 @@
+module Graphiti
+  class Resource
+    module Documentation
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def description=(val)
+          @description = val
+        end
+
+        def description
+          return @description if @description.present?
+
+          if defined?(::I18n)
+            desc = ::I18n.t :description,
+              scope: i18n_resource_scope,
+              default: nil
+            desc ||= ::I18n.t :description,
+              scope: i18n_type_scope,
+              default: nil
+          end
+        end
+
+        # @api private
+        def attribute_description(attr_name)
+          desc = all_attributes[attr_name][:description]
+          return desc if desc.present?
+
+          if defined?(::I18n)
+            desc = ::I18n.t :description,
+              scope: [*i18n_type_scope, :attributes, attr_name],
+              default: nil
+            desc ||= ::I18n.t :description,
+              scope: [*i18n_resource_scope, :attributes, attr_name],
+              default: nil
+          end
+        end
+
+        private
+
+        def underscored_resource_name
+          self.name.gsub(/Resource$/, '').underscore
+        end
+
+        def i18n_resource_scope
+          [:graphiti, :resources, underscored_resource_name]
+        end
+
+        def i18n_type_scope
+          [:graphiti, :types, type]
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/resource/persistence.rb

@@ -0,0 +1,182 @@
+module Graphiti
+  class Resource
+    module Persistence
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def before_attributes(method = nil, only: [:create, :update], &blk)
+          add_callback(:attributes, :before, method, only, &blk)
+        end
+
+        def after_attributes(method = nil, only: [:create, :update], &blk)
+          add_callback(:attributes, :after, method, only, &blk)
+        end
+
+        def before_save(method = nil, only: [:create, :update], &blk)
+          add_callback(:save, :before, method, only, &blk)
+        end
+
+        def after_save(method = nil, only: [:create, :update], &blk)
+          add_callback(:save, :after, method, only, &blk)
+        end
+
+        def before_destroy(method = nil, &blk)
+          add_callback(:destroy, :before, method, [:destroy], &blk)
+        end
+
+        def after_destroy(method = nil, &blk)
+          add_callback(:destroy, :after, method, [:destroy], &blk)
+        end
+
+        def around_attributes(method = nil, only: [:create, :update], &blk)
+          if blk
+            raise Errors::AroundCallbackProc.new(self, 'around_attributes')
+          else
+            add_callback(:attributes, :around, method, only, &blk)
+          end
+        end
+
+        def around_save(method = nil, only: [:create, :update], &blk)
+          if blk
+            raise Errors::AroundCallbackProc.new(self, 'around_save')
+          else
+            add_callback(:save, :around, method, only, &blk)
+          end
+        end
+
+        def around_destroy(method = nil, &blk)
+          if blk
+            raise Errors::AroundCallbackProc.new(self, 'around_destroy')
+          else
+            add_callback(:destroy, :around, method, [:destroy], &blk)
+          end
+        end
+
+        private
+
+        def add_callback(kind, lifecycle, method = nil, only, &blk)
+          config[:callbacks][kind] ||= {}
+          config[:callbacks][kind][lifecycle] ||= []
+          config[:callbacks][kind][lifecycle] << { callback: (method || blk), only: only }
+        end
+      end
+
+      def create(create_params)
+        model_instance = nil
+
+        run_callbacks :attributes, :create, create_params do |params|
+          model_instance = build(model)
+          assign_attributes(model_instance, params)
+          model_instance
+        end
+
+        run_callbacks :save, :create, model_instance do
+          model_instance = save(model_instance)
+        end
+
+        model_instance
+      end
+
+      def update(update_params)
+        model_instance = nil
+        id = update_params.delete(:id)
+
+        run_callbacks :attributes, :update, update_params do |params|
+          model_instance = self.class._find(params.merge(id: id)).data
+          assign_attributes(model_instance, params)
+          model_instance
+        end
+
+        run_callbacks :save, :update, model_instance do
+          model_instance = save(model_instance)
+        end
+
+        model_instance
+      end
+
+      def destroy(id)
+        model_instance = self.class._find(id: id).data
+        run_callbacks :destroy, :destroy, model_instance do
+          adapter.destroy(model_instance)
+        end
+        model_instance
+      end
+
+      def build(model)
+        adapter.build(model)
+      end
+
+      def assign_attributes(model_instance, update_params)
+        adapter.assign_attributes(model_instance, update_params)
+      end
+
+      def save(model_instance)
+        adapter.save(model_instance)
+      end
+
+      private
+
+      def run_callbacks(kind, action, *args)
+        fire_around_callbacks(kind, action, *args) do |*yieldargs|
+          fire_callbacks(kind, :before, action, *yieldargs)
+          result = yield(*yieldargs)
+          fire_callbacks(kind, :after, action, result)
+          result
+        end
+      end
+
+      def fire_callbacks(kind, lifecycle, action, *args)
+        if callbacks = self.class.config[:callbacks][kind]
+          callbacks = callbacks[lifecycle] || []
+          callbacks.each do |config|
+            callback = config[:callback]
+            next unless config[:only].include?(action)
+
+            if callback.respond_to?(:call)
+              instance_exec(*args, &callback)
+            else
+              send(callback, *args)
+            end
+          end
+        end
+      end
+
+      def fire_around_callbacks(kind, action, *args, &blk)
+        callbacks = self.class.config[:callbacks][kind].try(:[], :around) || []
+        callbacks = callbacks.select { |cb| cb[:only].include?(action) }
+        if callbacks.length.zero?
+          yield(*args)
+        else
+          prc = around_callback_proc(callbacks, 0, *args, &blk)
+          instance_exec(*args, &prc)
+        end
+      end
+
+      # The tricky thing here is we need to yield to the next around callback
+      # until there are no more callbacks, then we want to call the original block
+      # Also keep in mind each callback needs to yield to the next
+      def around_callback_proc(callbacks, index, *args, &blk)
+        method_name = callbacks[index][:callback]
+
+        if callbacks[index + 1]
+          proc do
+            r = nil
+            send(method_name, *args) do |r2|
+              wrapped = around_callback_proc(callbacks, index+1, r2, &blk)
+              r = instance_exec(r2, &wrapped)
+            end
+            r
+          end
+        else
+          proc do |result|
+            r = nil
+            send(callbacks[index][:callback], result) do |r2|
+              r = instance_exec(r2, &blk)
+            end
+            r
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/resource_proxy.rb

@@ -95,9 +95,8 @@ module Graphiti
     end
 
     def destroy
-      record = data
       validator = @resource.transaction do
-        model = @resource.destroy(record)
+        model = @resource.destroy(@query.filters[:id])
         model.instance_variable_set(:@__serializer_klass, @resource.serializer)
         validator = ::Graphiti::Util::ValidationResponse.new \
           model, @payload

data/lib/graphiti/schema.rb

@@ -83,6 +83,7 @@ module Graphiti
         config = {
           name: r.name,
           type: r.type.to_s,
+          description: r.description,
           attributes: attributes(r),
           extra_attributes: extra_attributes(r),
           sorts: sorts(r),
@@ -116,7 +117,8 @@ module Graphiti
             attrs[name] = {
               type:       config[:type].to_s,
               readable:   flag(config[:readable]),
-              writable:   flag(config[:writable])
+              writable:   flag(config[:writable]),
+              description: resource.attribute_description(name),
             }
           end
         end
@@ -128,7 +130,8 @@ module Graphiti
         resource.extra_attributes.each_pair do |name, config|
           attrs[name] = {
             type:     config[:type].to_s,
-            readable: flag(config[:readable])
+            readable: flag(config[:readable]),
+            description: resource.attribute_description(name),
           }
         end
       end

data/lib/graphiti/scoping/filter.rb

@@ -1,32 +1,7 @@
 module Graphiti
-  # Apply filtering logic to the scope
-  #
-  # If the user requests to filter a field that has not been allowlisted,
-  # a +Graphiti::Errors::BadFilter+ error will be raised.
-  #
-  #   allow_filter :title # :title now allowlisted
-  #
-  # If the user requests a filter field that has been allowlisted, but
-  # does not pass the associated `+:if+ clause, +BadFilter+ will be raised.
-  #
-  #   allow_filter :title, if: :admin?
-  #
-  # This will also honor filter aliases.
-  #
-  #   # GET /posts?filter[headline]=foo will filter on title
-  #   allow_filter :title, aliases: [:headline]
-  #
-  # @see Adapters::Abstract#filter
-  # @see Adapters::ActiveRecord#filter
-  # @see Resource.allow_filter
   class Scoping::Filter < Scoping::Base
     include Scoping::Filterable
 
-    # Apply the filtering logic.
-    #
-    # Loop and parse all requested filters, taking into account guards and
-    # aliases. If valid, call either the default or custom filtering logic.
-    # @return the scope we are chaining/modifying
     def apply
       if missing_required_filters.any?
         raise Errors::RequiredFilter.new(resource, missing_required_filters)
@@ -47,8 +22,6 @@ module Graphiti
     private
 
     def filter_scope(filter, operator, value)
-      operator = operator.to_s.gsub('!', 'not_').to_sym
-
       if custom_scope = filter.values[0][:operators][operator]
         custom_scope.call(@scope, value, resource.context)
       else
@@ -73,6 +46,7 @@ module Graphiti
       filter_param.each_pair do |param_name, param_value|
         filter = find_filter!(param_name)
         value, operator = normalize_param(filter, param_value)
+        operator = operator.to_s.gsub('!', 'not_').to_sym
         validate_operator(filter, operator)
         value  = parse_string_value(filter.values[0], value) if value.is_a?(String)
         validate_singular(resource, filter, value)
@@ -98,7 +72,9 @@ module Graphiti
     end
 
     def normalize_param(filter, param_value)
-      param_value = { eq: param_value } unless param_value.is_a?(Hash)
+      unless param_value.is_a?(Hash) && param_value.present?
+        param_value = { eq: param_value }
+      end
       value = param_value.values.first
       operator = param_value.keys.first
 

data/lib/graphiti/util/persistence.rb

@@ -149,8 +149,7 @@ class Graphiti::Util::Persistence
   def persist_object(method, attributes)
     case method
       when :destroy
-        model = @resource.class._find(attributes.slice(:id)).data
-        call_resource_method(:destroy, model, @caller_model)
+        call_resource_method(:destroy, attributes[:id], @caller_model)
       when :update, nil, :disassociate
         call_resource_method(:update, attributes, @caller_model)
       else

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.0.beta.15"
+  VERSION = "1.0.beta.16"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.0.beta.15
+  version: 1.0.beta.16
 platform: ruby
 authors:
 - Lee Richmond
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-02 00:00:00.000000000 Z
+date: 2018-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable
@@ -280,9 +280,11 @@ files:
 - lib/graphiti/renderer.rb
 - lib/graphiti/resource.rb
 - lib/graphiti/resource/configuration.rb
+- lib/graphiti/resource/documentation.rb
 - lib/graphiti/resource/dsl.rb
 - lib/graphiti/resource/interface.rb
 - lib/graphiti/resource/links.rb
+- lib/graphiti/resource/persistence.rb
 - lib/graphiti/resource/polymorphism.rb
 - lib/graphiti/resource/sideloading.rb
 - lib/graphiti/resource_proxy.rb