jsonapionify 0.11.11 → 0.12.0

data/lib/jsonapionify/api/resource/builders/fields_builder.rb

@@ -14,11 +14,11 @@ module JSONAPIonify::Api
       end
 
       def resource_fields
-        fields[resource_type] || {}
+        fields && fields[resource_type]
       end
 
       def build
-        fields.nil? ? build_default : build_sparce
+        resource_fields.nil? ? build_default : build_sparce
       end
 
     end

data/lib/jsonapionify/api/resource/builders/relationship_builder.rb

@@ -25,13 +25,14 @@ module JSONAPIonify::Api
       private
 
       def build_data
+        rel_resource = resource.relationship(relationship.name)
         case relationship
         when Relationship::Many
           resolution.map do |child|
-            relationship.build_resource_identifier(child)
+            rel_resource.build_resource_identifier(instance: child)
           end
         when Relationship::One
-          relationship.build_resource_identifier resolution
+          rel_resource.build_resource_identifier instance: resolution
         end
       end
 

data/lib/jsonapionify/api/resource/builders/relationships_builder.rb

@@ -3,19 +3,20 @@ module JSONAPIonify::Api
     class RelationshipsBuilder < FieldsBuilder
 
       delegate :relationships, to: :resource, prefix: true
+      delegate :includes, to: :context
 
       private
 
       def build_default
         resource_relationships.each_with_object(Objects::Relationships.new) do |relationship, attrs|
-          unless relationship.hidden_for_action?(action_name)
+          if !relationship.hidden_for_action?(action_name) || includes.keys.include?(relationship.name.to_s)
             attrs[relationship.name] = build_relationship(relationship)
           end
         end
       end
 
       def build_sparce
-        resource_fields.each_with_object(Objects::Relationships.new) do |field, attrs|
+        (resource_fields + includes.keys).each_with_object(Objects::Relationships.new) do |field, attrs|
           field = field.to_sym
           relationship = resource_relationships.find { |rel| rel.name == field }
           attrs[field] = build_relationship(relationship) if relationship

data/lib/jsonapionify/api/resource/caching.rb

@@ -19,10 +19,7 @@ module JSONAPIonify::Api
     end
 
     def cache_key(**options)
-      self.class.cache_key(
-        **options,
-        action_name: action_name
-      )
+      self.class.cache_key(**options, action_name: @__context.action_name)
     end
   end
 end

data/lib/jsonapionify/api/resource/callbacks.rb

@@ -0,0 +1,60 @@
+require 'active_support/concern'
+
+module JSONAPIonify::Api
+  module Resource::Callbacks
+    extend ActiveSupport::Concern
+    using JSONAPIonify::DestructuredProc
+    included do
+
+      def self.define_callbacks(*names)
+        names.each do |name|
+          chains = {
+            main:   "__#{name}_callback_chain",
+            before: "__#{name}_before_callback_chain",
+            after:  "__#{name}_after_callback_chain"
+          }
+          define_method chains[:main] do |*args, &block|
+            block ||= proc {}
+            if send(chains[:before], *args) != false
+              value = begin
+                instance_exec(*args, @__context, &block&.destructure)
+              rescue => e
+                e.backtrace.unshift block.source_location.join(':') + ":in `(callback)`"
+                raise e
+              end
+              value if send(chains[:after], *args) != false
+            end
+          end unless method_defined? chains[:main]
+
+          # Define before and after chains
+          %i{after before}.each do |timing|
+            define_method chains[timing] { |*| } unless method_defined? chains[timing]
+            callback_name = "#{timing}_#{name}"
+            define_singleton_method callback_name do |sym = nil, &outer_block|
+              outer_block = (outer_block || sym).to_proc
+              prev_chain  = instance_method(chains[timing])
+              define_method chains[timing] do |*args, &block|
+                begin
+                  if prev_chain.bind(self).call(*args, @__context, &block&.destructure) != false
+                    instance_exec(*args, @__context, &outer_block&.destructure)
+                  end
+                rescue => e
+                  e.backtrace.unshift outer_block.source_location.join(':') + ":in `(callback) #{callback_name}`"
+                  raise e
+                end
+              end
+            end
+          end
+
+          private(*chains.values)
+
+        end
+      end
+    end
+
+    def run_callbacks(name, *args, &block)
+      send("__#{name}_callback_chain", *args, &block)
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/caller.rb

@@ -1,14 +1,16 @@
 module JSONAPIonify::Api
   module Resource::Caller
+    using JSONAPIonify::DestructuredProc
+
     def call
       do_respond = proc { __respond }
       do_request = proc { __request }
-      response   = @callbacks ? run_callbacks(:request, @__context, &do_request) : do_request.call
+      response   = @callbacks ? run_callbacks(:request, &do_request) : do_request.call
     rescue Errors::RequestError => e
       raise e unless errors.present?
       response = error_response
     rescue Errors::CacheHit
-      JSONAPIonify.logger.info "Cache Hit: #{@cache_options[:key]}"
+      JSONAPIonify.logger.debug "Cache Hit: #{@cache_options[:key]}"
       response = self.class.cache_store.read @cache_options[:key]
     rescue Exception => exception
       response = rescued_response exception, @__context, do_respond
@@ -25,21 +27,20 @@ module JSONAPIonify::Api
     private
 
     def __commit
-      instance_exec(@__context, &action.block)
-      halt if errors.present?
+      instance_exec(@__context, &action.block.destructure)
     end
 
     def __commit_and_respond
       do_respond = proc { __respond }
       do_commit  = proc { __commit }
       halt if errors.present?
-      action.name && @callbacks ? run_callbacks("commit_#{action.name}", @__context, &do_commit) : do_commit.call
-      @callbacks ? run_callbacks(:response, @__context, &do_respond) : do_respond.call
+      action.name && @callbacks ? run_callbacks("commit_#{action.name}", &do_commit) : do_commit.call
+      @callbacks ? run_callbacks(:response, &do_respond) : do_respond.call
     end
 
     def __request
       do_commit_and_respond = proc { __commit_and_respond }
-      action.name && @callbacks ? run_callbacks(action.name, @__context, &do_commit_and_respond) : do_commit_and_respond.call
+      action.name && @callbacks ? run_callbacks(action.name, &do_commit_and_respond) : do_commit_and_respond.call
     end
 
     def __respond(**options)

data/lib/jsonapionify/api/resource/defaults/actions.rb

@@ -3,20 +3,21 @@ module JSONAPIonify::Api
     extend ActiveSupport::Concern
 
     included do
-      context :path_actions, readonly: true, persisted: true do |context|
-        self.class.path_actions(context.request)
+      context :path_actions, readonly: true, persisted: true do |request:|
+        self.class.path_actions(request)
       end
 
-      context :http_allow, readonly: true, persisted: true do |context|
-        context.path_actions.map(&:request_method)
+      context :http_allow, readonly: true, persisted: true do |path_actions:|
+        path_actions.map(&:request_method)
       end
 
-      context(:action_name, persisted: true) {}
+      context(:action_name, persisted: true)
+
       define_action(:options, 'OPTIONS', '*', cacheable: true, callbacks: false) do
         cache 'options-request'
-      end.response(status: 200) do |context|
-        response_headers['Allow'] = context.http_allow.join(', ')
-        requests                  = context.path_actions.each_with_object({}) do |action, h|
+      end.response(status: 200) do |context, request:, http_allow:, path_actions:|
+        response_headers['Allow'] = http_allow.join(', ')
+        requests                  = path_actions.each_with_object({}) do |action, h|
           request_attributes_json = attributes.select do |attr|
             attr.supports_write_for_action? action.name, context
           end.map do |attr|
@@ -26,11 +27,11 @@ module JSONAPIonify::Api
           response_attributes_json = attributes.select do |attr|
             attr.supports_read_for_action? action.name, context
           end.map do |attr|
-            attr.options_json_for_action(action.name, context)
+            attr.options_json_for_action action.name, context
           end
 
-          h['path']      = context.request.path
-          h['url']       = context.request.url
+          h['path']      = request.path
+          h['url']       = request.url
           action_options = h[action.request_method] = {}
 
           if ['GET', 'POST', 'PUT', 'PATCH'].include? action.request_method
@@ -50,7 +51,9 @@ module JSONAPIonify::Api
         ).to_json
       end
 
-      before(:create) { |context| context.instance = context.new_instance }
+      before(:create) do |context|
+        context.instance = context.new_instance
+      end
       read
     end
   end

data/lib/jsonapionify/api/resource/defaults/hooks.rb

@@ -3,66 +3,19 @@ module JSONAPIonify::Api
     extend ActiveSupport::Concern
 
     included do
-      before :commit_create, :commit_update do |context|
-        # Assign the attributes
-        context.request_attributes.each do |key, value|
-          context.instance.send "#{key}=", value
-        end
-
-        # Assign the relationships
-        context.request_relationships.each do |key, value|
-          context.instance.send "#{key}=", value
-        end
-
-      end
-
-      after :commit_create, :commit_update do |context|
-        try_commit(context.instance)
-      end
-
-      after :commit_delete do |context|
-        if defined?(ActiveRecord) && context.instance.is_a?(ActiveRecord::Base)
-          context.instance.destroy
-        end
-      end
-
-      before :commit_add do |context|
-        context.scope.concat context.request_instances
-      end
-
-      before :commit_remove do |context|
-        context.request_instances.each { |instance| context.scope.delete(instance) }
-      end
-
-      before :commit_replace do |context|
-        case self.class.rel
-        when Relationship::One
-          context.owner.send "#{self.class.rel.name}=", context.request_instance
-          try_commit(context.owner)
-        when Relationship::Many
-          instances_to_add    = context.request_instances - context.scope
-          instances_to_delete = context.scope - context.request_instances
-          instances_to_delete.each { |instance| context.scope.delete(instance) }
-          context.scope.append instances_to_add
-        end
-      end
-    end
-
-    def try_commit(instance)
-      if defined?(ActiveRecord) && instance.is_a?(ActiveRecord::Base)
-        commit_active_record(instance)
-      end
-    end
-
-    def commit_active_record(instance)
-      instance.save
-      if instance.errors.present?
-        instance.errors.messages.each do |attr, messages|
-          messages.each do |message|
-            error :invalid_attribute, attr, message
+      after :commit_update, :commit_create do |instance:|
+        if defined?(ActiveRecord) && instance.is_a?(ActiveRecord::Base)
+          # Collect Errors
+          if instance.errors.present?
+            instance.errors.messages.each do |attr, messages|
+              messages.each do |message|
+                error :invalid_attribute, attr, message
+              end
+            end
           end
         end
       end
     end
+
   end
 end

data/lib/jsonapionify/api/resource/defaults/options.rb

@@ -11,7 +11,7 @@ module JSONAPIonify::Api
     included do
       id :id
       scope { self.type.classify.constantize }
-      collection do |scope, context|
+      collection do |scope|
         Resource::Defaults::Options.scope_is_active_record?(scope) ? scope.all : scope
       end
 
@@ -25,13 +25,8 @@ module JSONAPIonify::Api
         scope.new
       end
 
-      before do |context|
-        context.request_headers # pull request_headers so they verify
-      end
-
-      before do |context|
-        context.params # pull params so they verify
-      end
+      # Invoke validating contexts
+      before { |request_headers:| }
 
     end
   end

data/lib/jsonapionify/api/resource/defaults/params.rb

@@ -3,8 +3,6 @@ module JSONAPIonify::Api
     extend ActiveSupport::Concern
 
     included do
-      param :'include-relationships'
-
       # Configure the default sort
       default_sort 'id'
     end

data/lib/jsonapionify/api/resource/defaults/request_contexts.rb

@@ -3,37 +3,35 @@ module JSONAPIonify::Api
     extend ActiveSupport::Concern
 
     included do
-
-      context(:request_body, readonly: true, persisted: true) do |context|
-        context.request.body.read
+      context(:request_body, readonly: true, persisted: true) do |request:|
+        request.body.read
       end
 
-      context(:request_object, readonly: true, persisted: true) do |context|
-        JSONAPIonify.parse(context.request_body).as(:client).tap do |input|
+      context(:request_object, readonly: true, persisted: true) do |context, request_body:|
+        JSONAPIonify.parse(request_body).as(:client).tap do |input|
           error_now(:request_object_invalid, context, input) unless input.validate
         end
       end
 
-      context(:id, readonly: true, persisted: true) do |context|
-        context.request.env['jsonapionify.id']
+      context(:id, readonly: true, persisted: true) do |request:|
+        request.env['jsonapionify.id']
       end
 
-      context(:request_id, readonly: true, persisted: true) do |context|
-        context.request_data[:id]
+      context(:request_id, readonly: true, persisted: true) do |request_data:|
+        request_data[:id]
       end
 
-      context(:request_attributes, readonly: true, persisted: true) do |context|
+      context(:request_attributes, readonly: true, persisted: true) do |context, request:, action_name:, id:, request_data:|
         should_error = false
 
-        request_attributes =
-          context.request_data.fetch(:attributes) do
-            error_now :attributes_missing
-          end
+        request_attributes = request_data.fetch(:attributes) do
+          error_now :attributes_missing
+        end
 
         # Check for required attributes
         self.attributes.each do |attr|
           next unless attr.required_for_action?(action_name, context)
-          if attr.read? || context.id
+          if attr.read? || id
             example_id = self.build_id(instance: context.instance)
             next unless attr.resolve(
               context.instance, context, example_id: example_id
@@ -64,10 +62,9 @@ module JSONAPIonify::Api
         end
       end
 
-      context(:request_relationships, readonly: true, persisted: true) do |context|
-        data = context.request_data
-        if data[:relationships]
-          data[:relationships].each_with_object({}) do |(name, rel), obj|
+      context(:request_relationships, readonly: true, persisted: true) do |request_data:|
+        if request_data[:relationships]
+          request_data[:relationships].each_with_object({}) do |(name, rel), obj|
             pointer = "data/relationships/#{name}/data"
             case rel[:data]
             when JSONAPIonify::Structure::Collections::Base
@@ -81,22 +78,20 @@ module JSONAPIonify::Api
         end
       end
 
-      context(:request_instances, readonly: true, persisted: true) do |context|
-        data = context.request_data
-        (data ? find_instances(data, pointer: '/data') : [])
+      context(:request_instances, readonly: true, persisted: true) do |request_data:|
+        (request_data ? find_instances(request_data, pointer: '/data') : [])
       end
 
-      context(:request_instance, readonly: true, persisted: true) do |context|
-        find_instance(context.request_data, pointer: 'data')
+      context(:request_instance, readonly: true, persisted: true) do |request_data:|
+        find_instance(request_data, pointer: 'data')
       end
 
-      context(:request_resource, readonly: true, persisted: true) do |context|
-        item = context.request_data
-        find_resource item, pointer: 'data'
+      context(:request_resource, readonly: true, persisted: true) do |request_data:|
+        find_resource request_data, pointer: 'data'
       end
 
-      context(:request_data, readonly: true, persisted: true) do |context|
-        context.request_object.fetch(:data) {
+      context(:request_data, readonly: true, persisted: true) do |request_object:|
+        request_object.fetch(:data) {
           error_now(:data_missing)
         }
       end

data/lib/jsonapionify/api/resource/defaults/response_contexts.rb

@@ -3,32 +3,25 @@ module JSONAPIonify::Api
     extend ActiveSupport::Concern
 
     included do
-      context(:invalidate_cache?, readonly: true, persisted: true) { |c| c.includes.present? }
+      context(:invalidate_cache?, readonly: true, persisted: true) do |includes:|
+        includes.present?
+      end
 
       # Response Objects
-      context(:links, readonly: true, persisted: true) do |context|
-        context.response_object[:links]
+      context(:links, readonly: true, persisted: true) do |response_object:|
+        response_object[:links]
       end
 
-      context(:meta, readonly: true, persisted: true) do |context|
-        JSONAPIonify::Structure::Helpers::MetaDelegate.new context.response_object
+      context(:meta, readonly: true, persisted: true) do |response_object:|
+        JSONAPIonify::Structure::Helpers::MetaDelegate.new response_object
       end
 
-      context(:response_object, readonly: true, persisted: true) do |context|
-        JSONAPIonify.parse(links: { self: context.request.url })
+      context(:response_object, readonly: true, persisted: true) do |request:|
+        JSONAPIonify.parse(links: { self: request.url })
       end
 
-      context(:response_collection, readonly: true) do |context|
-        if context.root_request?
-          collections = %i{
-            paginated_collection
-            sorted_collection
-            collection
-          }
-          context.public_send collections.find { |c| context.respond_to? c }
-        else
-          context.collection
-        end
+      context(:response_collection, readonly: true) do |collection:, nested_request: false, paginated_collection: nil, sorted_collection: nil|
+        nested_request ? collection : paginated_collection || sorted_collection || collection
       end
 
     end