jsonapionify 0.11.11 → 0.12.0

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

@@ -3,35 +3,52 @@ require 'active_support/core_ext/array/wrap'
 
 module JSONAPIonify::Api
   module Resource::Definitions::Actions
+    using JSONAPIonify::DestructuredProc
     ActionNotFound = Class.new StandardError
 
-    INSTANCE_RESPONSE = proc do |context|
-      builder                        =
-        context.respond_to?(:builder) ? context.builder : nil
-      context.response_object[:data] =
-        build_resource(
-          context: context,
-          instance: context.instance,
-          &builder
-        )
-      context.response_object.to_json
+    DEFAULT_SAVE_COMMIT = proc do |instance:, request_attributes:, request_relationships:|
+      # Assign the attributes
+      request_attributes.each do |key, value|
+        instance.send "#{key}=", value
+      end
+
+      # Assign the relationships
+      request_relationships.each do |key, value|
+        instance.send "#{key}=", value
+      end
+
+      # Save the instance
+      instance.save if instance.respond_to? :save
+    end
+
+    DEFAULT_DELETE_COMMIT = proc do |instance:|
+      instance.respond_to?(:destroy) ? instance.destroy : instance.respond_to?(:delete) ? instance.delete : nil
     end
 
-    COLLECTION_RESPONSE = proc do |context|
-      builder                        = context.respond_to?(:builder) ? context.builder : nil
-      context.response_object[:data] = build_resource_collection(
+    INSTANCE_RESPONSE = proc do |context, instance:, response_object:, builder: nil|
+      response_object[:data] = build_resource(context: context, instance: instance, &builder)
+      response_object.to_json
+    end
+
+    CREATE_RESPONSE = proc do |context, instance:, response_object:, builder: nil, response_headers:|
+      instance_exec(context, instance: instance, response_object: response_object, builder: builder, &INSTANCE_RESPONSE).tap do
+        response_headers['Location'] = response_object[:data][:links][:self]
+      end
+    end
+
+    COLLECTION_RESPONSE = proc do |context, response_collection:, links:, response_object:, builder: nil, nested_request: false|
+      response_object[:data] = build_resource_collection(
         context: context,
-        collection: context.response_collection,
-        include_cursors: (context.links.keys & [:first, :last, :next, :prev]).present?,
+        collection: response_collection,
+        include_cursors: (links.keys & [:first, :last, :next, :prev]).present?,
         &builder
       )
-      context.response_object.to_json
+      response_object.to_json unless nested_request
     end
 
     def self.extended(klass)
       klass.class_eval do
         extend JSONAPIonify::InheritedAttributes
-        include JSONAPIonify::Callbacks
         define_callbacks(
           :request,
           :exception,
@@ -57,12 +74,9 @@ module JSONAPIonify::Api
     end
 
     def create(**options, &block)
+      block ||= DEFAULT_SAVE_COMMIT
       define_action(:create, 'POST', '', **options, cacheable: false, example_input: :resource, &block).tap do |action|
-        action.response(status: 201) do |context|
-          instance_exec(context, &INSTANCE_RESPONSE).tap do
-            response_headers['Location'] = context.response_object[:data][:links][:self]
-          end
-        end
+        action.response(status: 201, &CREATE_RESPONSE)
       end
     end
 
@@ -73,12 +87,14 @@ module JSONAPIonify::Api
     end
 
     def update(**options, &block)
+      block ||= DEFAULT_SAVE_COMMIT
       define_action(:update, 'PATCH', '/:id', **options, cacheable: false, example_input: :resource, &block).tap do |action|
         action.response(status: 200, &INSTANCE_RESPONSE)
       end
     end
 
     def delete(**options, &block)
+      block ||= DEFAULT_DELETE_COMMIT
       define_action(:delete, 'DELETE', '/:id', **options, cacheable: false, &block).tap do |action|
         action.response(status: 204)
       end

data/lib/jsonapionify/api/resource/definitions/attributes.rb

@@ -8,8 +8,8 @@ module JSONAPIonify::Api
         inherited_array_attribute :attributes
         delegate :id_attribute, :attributes, to: :class
 
-        context(:fields, readonly: true) do |context|
-          context.params['fields']&.map do |type, fields|
+        context(:fields, readonly: true) do |params:|
+          params['fields']&.map do |type, fields|
             [type, fields.split(',')]
           end&.to_h
         end

data/lib/jsonapionify/api/resource/definitions/helpers.rb

@@ -20,7 +20,7 @@ module JSONAPIonify::Api
     end
 
     def on_exception(&block)
-      before_exception &block
+      before_exception(&block)
     end
 
   end

data/lib/jsonapionify/api/resource/definitions/includes.rb

@@ -0,0 +1,16 @@
+module JSONAPIonify::Api
+  module Resource::Definitions::Includes
+
+    def self.extended(klass)
+      klass.class_eval do
+        extend JSONAPIonify::InheritedAttributes
+        inherited_hash_attribute :include_definitions
+      end
+    end
+
+    def includable(relationship, &block)
+      include_definitions[relationship.to_sym] = block
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/definitions/pagination.rb

@@ -99,29 +99,25 @@ module JSONAPIonify::Api
       param :page, :before, actions: %i{list}
       param :page, :first, actions: %i{list}
       param :page, :last, actions: %i{list}
-      context :paginated_collection, readonly: true do |context|
-        if context.root_request?
-          collection = context.sorted_collection
+      context :paginated_collection, readonly: true do |context, nested_request: false, sorted_collection:, collection:, request:, params:, links:|
+        if !nested_request
+          collection = sorted_collection
           _, block   = pagination_strategies.to_a.reverse.to_h.find do |mod, _|
-            Object.const_defined?(mod, false) && context.collection.class <= Object.const_get(mod, false)
+            Object.const_defined?(mod, false) && collection.class <= Object.const_get(mod, false)
           end
 
-          links_delegate = PaginationLinksDelegate.new(
-            context.request.url,
-            context.params,
-            context.links
-          )
+          links_delegate = PaginationLinksDelegate.new(request.url, params, links)
 
           instance_exec(
             collection,
-            context.request.params['page'] || {},
+            request.params['page'] || {},
             links_delegate,
             per,
             context,
             &block
           )
         else
-          context.collection
+          collection
         end
       end
     end

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

@@ -6,47 +6,40 @@ module JSONAPIonify::Api
         extend JSONAPIonify::InheritedAttributes
         inherited_hash_attribute :param_definitions
 
-        context(:params, readonly: true, persisted: true) do |context|
-          should_error = false
-
-          params = self.class.param_definitions.select do |_, v|
+        context(:params, readonly: true, persisted: true) do |request:, action_name:|
+          defined_params = self.class.param_definitions.select do |_, v|
             v.actions.blank? || v.actions.include?(action_name)
           end
+          param_defaults = defined_params.values.select(&:has_default?).map(&:default)
+          [*param_defaults, request.params].reduce(:deep_merge)
+        end
 
-          context.request.params.replace(
-            [*params.values.select(&:has_default?).map(&:default), context.request.params].reduce(:deep_merge)
-          )
+        # Validate params before request
+        before do |params:, action_name:, request:, nested_request: false|
+          defined_params = self.class.param_definitions.select do |_, v|
+            v.actions.blank? || v.actions.include?(action_name)
+          end
 
-          required_params = params.select do |_, v|
+          required_params = defined_params.select do |_, v|
             v.required
           end
 
           # Check for validity
-          context.request.params.each do |k, v|
+          params.each do |k, v|
             keypath  = ParamOptions.hash_to_keypaths(k => v)[0]
             reserved = ParamOptions.reserved?(k)
-            allowed  = params.keys.include? keypath
+            allowed  = defined_params.keys.include? keypath
             valid    = ParamOptions.valid?(k) || v.is_a?(Hash)
-            unless reserved || (allowed && valid) || !context.root_request?
-              should_error = true
+            unless reserved || (allowed && valid) || nested_request
               error :parameter_invalid, ParamOptions.keypath_to_string(*keypath)
             end
-          end unless context.request.options?
+          end unless request.options?
 
           # Check for requirement
-          missing_params =
-            ParamOptions.missing_parameters(
-              context.request.params,
-              required_params.values.map(&:keypath)
-            )
-          if context.root_request? && missing_params.present?
-            error :parameters_missing, missing_params
-          end
-
-          halt if should_error
-
-          # Return the params
-          context.request.params
+          missing_params = ParamOptions.missing_parameters(
+            request.params, required_params.values.map(&:keypath)
+          )
+          error :parameters_missing, missing_params if !nested_request && missing_params.present?
         end
 
       end

data/lib/jsonapionify/api/resource/definitions/relationships.rb

@@ -8,7 +8,7 @@ module JSONAPIonify::Api
       end
     end
 
-    def relates_to_many(name, count_attribute: false, count_hidden: false, **opts, &block)
+    def relates_to_many(name, count_attribute: false, count_hidden: :list, **opts, &block)
       define_relationship(name, Relationship::Many, **opts, &block).tap do
         define_relationship_counter(
           name,
@@ -23,8 +23,8 @@ module JSONAPIonify::Api
       define_relationship(name, Relationship::One, **opts, &block)
     end
 
-    def define_relationship_counter(rel_name, name, hidden = false)
-      attribute name.to_sym, types.Integer, "The number of #{rel_name}.", hidden: hidden, write: false do |_, instance, context|
+    def define_relationship_counter(rel_name, name, hidden)
+      attribute name.to_sym, types.Integer, "The number of #{rel_name}.", hidden: hidden do |_, instance, context|
         rel          = context.resource.class.relationship(rel_name)
         rel_context  = rel.new(
           request:           context.request,

data/lib/jsonapionify/api/resource/definitions/request_headers.rb

@@ -6,28 +6,26 @@ module JSONAPIonify::Api
         extend JSONAPIonify::InheritedAttributes
         inherited_hash_attribute :request_header_definitions
 
-        context(:request_headers, persisted: true, readonly: true) do |context|
-          should_error     = false
+        # Define context
+        context(:request_headers, persisted: true, readonly: true) do |request:|
+          request.headers
+        end
 
-          # Check for validity
-          headers          = self.class.request_header_definitions.select do |_, v|
+        # Validate headers before request
+        before do |request_headers:, action_name:, nested_request: false|
+          # Gather Definitions
+          defined_headers = self.class.request_header_definitions.select do |_, v|
             v.actions.blank? || v.actions.include?(action_name)
           end
-          required_headers = headers.select do |_, v|
-            v.required
-          end
 
-          missing_keys =
-            required_headers.keys.map(&:downcase) -
-              context.request.headers.keys.map(&:downcase)
-          if context.root_request? && missing_keys.present?
-            should_error = true
-            error :headers_missing, missing_keys
+          # Gather required Headers
+          required_headers = defined_headers.select do |_, v|
+            v.required
           end
 
-          halt if should_error
-
-          context.request.headers
+          # Gather Missing Keys
+          missing_keys = required_headers.keys.map(&:downcase) - request_headers.keys.map(&:downcase)
+          error :headers_missing, missing_keys if !nested_request && missing_keys.present?
         end
       end
     end

data/lib/jsonapionify/api/resource/definitions/response_headers.rb

@@ -1,5 +1,6 @@
 module JSONAPIonify::Api
   module Resource::Definitions::ResponseHeaders
+    using JSONAPIonify::DestructuredProc
 
     def self.extended(klass)
       klass.class_eval do
@@ -8,7 +9,7 @@ module JSONAPIonify::Api
 
         context(:response_headers, persisted: true) do |context|
           self.class.response_header_definitions.each_with_object({}) do |(name, block), headers|
-            headers[name.to_s] = instance_exec(context, &block)
+            headers[name.to_s] = instance_exec(context, &block.destructure)
           end
         end
       end

data/lib/jsonapionify/api/resource/definitions/scopes.rb

@@ -16,14 +16,25 @@ module JSONAPIonify::Api
       define_singleton_method(:find_instance) do |id|
         instance_exec(current_scope, id, OpenStruct.new, &block)
       end
-      context :instance, persisted: true do |context|
-        instance_exec(context.scope, context.id, context, &block)
+      context :instance, persisted: true do |context, scope:, id:|
+        instance_exec(scope, id, context, &block)
       end
     end
 
     def collection(&block)
-      context :collection do |context|
-        Object.new.instance_exec(context.scope, context, &block)
+      context :collection do |context, scope:, includes:|
+        collection = Object.new.instance_exec(scope, context, &block)
+
+        # Compute includes manipulations
+        self.class.include_definitions.select do |relationship, _|
+          includes.keys.include? relationship.to_s
+        end.reduce(collection) do |lv, (name, include_block)|
+          lv.instance_exec(lv, includes[name.to_s], &include_block)
+        end
+
+        # TODO: Compute field manipulations
+
+        # TODO: Compute param manipulations
       end
     end
 
@@ -31,8 +42,8 @@ module JSONAPIonify::Api
       define_singleton_method(:build_instance) do
         Object.new.instance_exec(current_scope, &block)
       end
-      context :new_instance, persisted: true, readonly: true do |context|
-        Object.new.instance_exec(context.scope, context, &block)
+      context :new_instance, persisted: true, readonly: true do |context, scope:|
+        Object.new.instance_exec(scope, context, &block)
       end
     end
   end

data/lib/jsonapionify/api/resource/definitions/sorting.rb

@@ -3,6 +3,7 @@ require 'set'
 module JSONAPIonify::Api
   module Resource::Definitions::Sorting
     using JSONAPIonify::DeepSortCollection
+    using JSONAPIonify::DestructuredProc
 
     def self.extended(klass)
       klass.class_eval do
@@ -10,20 +11,20 @@ module JSONAPIonify::Api
         delegate :sort_fields_from_sort_string, to: :class
 
         # Define Contexts
-        context :sorted_collection, readonly: true do |context|
-          if context.root_request?
+        context :sorted_collection, readonly: true do |context, collection:, sort_params:, nested_request: false|
+          if !nested_request
             _, block = sorting_strategies.to_a.reverse.to_h.find do |mod, _|
-              Object.const_defined?(mod, false) && context.collection.class <= Object.const_get(mod, false)
+              Object.const_defined?(mod, false) && collection.class <= Object.const_get(mod, false)
             end
             context.reset(:sort_params)
-            instance_exec(context.collection, context.sort_params, context, &block)
+            instance_exec(collection, sort_params, context, &block.destructure)
           else
-            context.collection
+            collection
           end
         end
 
-        context(:sort_params, readonly: true, persisted: true) do |context|
-          sort_fields_from_sort_string(context.params['sort'])
+        context(:sort_params, readonly: true, persisted: true) do |params:|
+          sort_fields_from_sort_string(params['sort'])
         end
 
         define_sorting_strategy('Object') do |collection|

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

@@ -41,7 +41,7 @@ module JSONAPIonify::Api
             )
           }
           if callbacks
-            run_callbacks :exception, exception, context, &evaluate
+            run_callbacks :exception, exception, &evaluate
           else
             evaluate.call
           end
@@ -95,7 +95,8 @@ module JSONAPIonify::Api
       errors.evaluate(
         *args,
         error_block:   lookup_error(name),
-        runtime_block: block
+        runtime_block: block,
+        backtrace: caller
       )
     end
 

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

@@ -1,11 +1,13 @@
 module JSONAPIonify::Api
   module Resource::Exec
+    using JSONAPIonify::DestructuredProc
+
     def halt
       # Don't Halt
     end
 
     def exec(&block)
-      instance_exec @__context, &block
+      instance_exec @__context, &block.destructure
     end
   end
 end

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

@@ -2,26 +2,16 @@ require 'concurrent'
 
 module JSONAPIonify::Api
   module Resource::Includer
+    include JSONAPIonify::Structure
     extend ActiveSupport::Concern
 
     included do
-      before :list, :create, :read, :update do |context|
-        supports_includes = context.root_request? && context.includes.present?
-        is_active_record  = defined?(ActiveRecord) && context.scope.is_a?(Class) && context.scope < ActiveRecord::Base
-        if supports_includes && is_active_record
-          valid_includes = context.includes.select do |k, v|
-            context.scope._reflect_on_association(k)
-          end.to_h
-          context.scope  = context.scope.includes valid_includes
-        end
-      end
-
       after :commit_list do |context|
         if context.includes.present?
           included =
-            Concurrent::Array.new(context.response_collection).map do |instance|
+            context.response_collection.map do |instance|
               fetch_included(context, owner: instance)
-            end.reduce(:+)
+            end.reduce(:|)
           append_included(context, included)
         end
       end
@@ -35,10 +25,6 @@ module JSONAPIonify::Api
         end
       end
 
-      context :root_request?, readonly: true do
-        true
-      end
-
       context :includes do |context|
         Resource::Includer.includes_to_hashes context.params['include']
       end
@@ -46,53 +32,36 @@ module JSONAPIonify::Api
 
     def append_included(context, included)
       if included.present?
-        context.response_object[:included] = included
-        context.response_object[:included].tap(&:uniq!).reject! do |r|
-          Array.wrap(context.response_object[:included]).include?(r) ||
-            Array.wrap(context.response_object[:data]).include?(r)
-        end
+        context.response_object[:included] |= included
       end
     end
 
     def fetch_included(context, **overrides)
-      collection = JSONAPIonify::Structure::Collections::IncludedResources.new
-      context.includes.each_with_object(collection) do |(name, _),|
-        res = self.class.relationship(name)
-        if res.rel.includable?
-          overrides = overrides.merge includes:      context.includes[name],
-                                      errors:        context.errors,
-                                      root_request?: false
-          *, body   =
-            case res.rel
-            when Relationship::One
-              res.call_action(:read, context.request, **overrides)
-            when Relationship::Many
-              res.call_action(:list, context.request, **overrides)
-            end
-          collection.concat expand_body(body)
+      context.includes.reduce(Collections::IncludedResources.new) do |lv, (name, _)|
+        if self.class.include_definitions.keys.include?(name.to_sym)
+          response_object = JSONAPIonify.new_object
+          res = self.class.relationship(name)
+          overrides = overrides.merge includes:         context.includes[name],
+                                      errors:           context.errors,
+                                      root_request?:    false,
+                                      action_name:      context.action_name,
+                                      response_object:  response_object
+          action_name = res.rel.is_a?(Relationship::One) ? :read : :list
+          res.call_action(action_name, context.request, context_overrides: overrides)
+          lv | (Array.wrap(response_object[:data]).compact + response_object[:included])
         else
           error :relationship_not_includable, res.rel.name
+          lv
         end
-      end.uniq
+      end
     end
 
     def self.includes_to_hashes(path)
-      path.to_s.split(',').each_with_object({}) do |path, obj|
-        rel, *sub_path = path.split('.')
+      path.to_s.split(',').each_with_object({}) do |p, obj|
+        rel, *sub_path = p.split('.')
         obj[rel]       = includes_to_hashes(sub_path.join('.'))
       end
     end
 
-    def expand_body(body)
-      case body
-      when Rack::BodyProxy
-        json = JSONAPIonify.parse(body.body.join)
-        Array.wrap(json[:data]) + (json[:included] || [])
-      when Array
-        json = JSONAPIonify.parse(body.join)
-        Array.wrap(json[:data]) + (json[:included] || [])
-      end
-    end
-
   end
 end