jsonapionify 0.9.0 → 0.9.1

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

@@ -3,10 +3,10 @@ module JSONAPIonify::Api
 
     def scope(&block)
       define_singleton_method(:current_scope) do
-        Object.new.instance_eval(&block)
+        instance_exec(OpenStruct.new, &block)
       end
-      context :scope do
-        self.class.current_scope
+      context :scope do |context|
+        instance_exec(context, &block)
       end
     end
 
@@ -16,7 +16,7 @@ module JSONAPIonify::Api
       define_singleton_method(:find_instance) do |id|
         instance_exec(current_scope, id, OpenStruct.new, &block)
       end
-      context :instance do |context|
+      context :instance, persisted: true do |context|
         instance_exec(context.scope, context.id, context, &block)
       end
     end
@@ -31,7 +31,7 @@ module JSONAPIonify::Api
       define_singleton_method(:build_instance) do
         Object.new.instance_exec(current_scope, &block)
       end
-      context :new_instance do |context|
+      context :new_instance, persisted: true, readonly: true do |context|
         Object.new.instance_exec(context.scope, context, &block)
       end
     end

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

@@ -10,28 +10,32 @@ module JSONAPIonify::Api
         delegate :sort_fields_from_sort_string, to: :class
 
         # Define Contexts
-        context :sorted_collection do |context|
-          _, block = sorting_strategies.to_a.reverse.to_h.find do |mod, _|
-            Object.const_defined?(mod, false) && context.collection.class <= Object.const_get(mod, false)
+        context :sorted_collection, readonly: true do |context|
+          if context.root_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)
+            end
+            context.reset(:sort_params)
+            instance_exec(context.collection, context.sort_params, context, &block)
+          else
+            context.collection
           end
-          context.reset(:sort_params)
-          instance_exec(context.collection, context.sort_params, context, &block)
         end
 
-        context(:sort_params, readonly: true) do |context|
+        context(:sort_params, readonly: true, persisted: true) do |context|
           sort_fields_from_sort_string(context.params['sort']).tap do |fields|
             should_error = false
             fields.each do |field|
               unless self.class.field_valid?(field.name) || field.name == id_attribute
                 should_error = true
-                type = self.class.type
+                type         = self.class.type
                 error :sort_parameter_invalid do
                   detail "resource `#{type}` does not have field: #{field.name}"
                 end
                 next
               end
             end
-            raise Errors::RequestError if should_error
+            halt if should_error
           end
         end
 
@@ -47,9 +51,6 @@ module JSONAPIonify::Api
           collection.reorder(fields.to_hash).order(self.class.id_attribute)
         end
 
-        # Configure the default sort
-        default_sort 'id'
-
       end
     end
 

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

@@ -11,4 +11,4 @@ module JSONAPIonify::Api
       end
     end
   end
-end
+end

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

@@ -1,12 +1,27 @@
+require 'unstrict_proc'
+
 module JSONAPIonify::Api
   module Resource::ErrorHandling
     extend ActiveSupport::Concern
+    using UnstrictProc
 
     included do
       include ActiveSupport::Rescuable
-      context(:errors, readonly: true) do
+      context(:errors, readonly: true, persisted: true) do
         ErrorsObject.new
       end
+      register_exception Exception, error: :internal_server_error do |exception|
+        if JSONAPIonify.verbose_errors
+          detail exception.message
+          meta[:error_class] = exception.class.name
+        end
+      end
+      register_exception Errors::RequestError, error: :internal_server_error do |exception|
+        if JSONAPIonify.verbose_errors
+          detail exception.message
+          meta[:error_class] = exception.class.name
+        end
+      end
     end
 
     module ClassMethods
@@ -15,11 +30,12 @@ module JSONAPIonify::Api
         self.error_definitions = self.error_definitions.merge name.to_sym => block
       end
 
-      def rescue_from(*klasses, error:, &block)
-        super(*klasses) do |exception|
+      def register_exception(*klasses, error:, &block)
+        block ||= proc {}
+        rescue_from(*klasses) do |exception, context|
           errors.evaluate(
             error_block:   lookup_error(error),
-            runtime_block: block || proc {},
+            runtime_block: proc { instance_exec exception, context, &block },
             backtrace:     exception.backtrace
           )
         end
@@ -37,6 +53,35 @@ module JSONAPIonify::Api
           @error_definitions
         end
       end
+
+      def sorted_rescue_handlers
+        handlers           = self.rescue_handlers.dup
+        # logic to find invalid order
+        out_of_order_class = lambda do |klasses|
+          klass_index  = nil
+          parent_index = nil
+          sort_class   = klasses.find do |klass|
+            klass_index  = klasses.find_index { |k| k == klass }
+            parent_index = klasses[0..klass_index].find_index { |k| k < klass }
+          end
+          sort_class ? [klass_index, parent_index] : nil
+        end
+
+        # Map handler classes
+        klasses            = handlers.map do |klass_name, _|
+          klass = self.class.const_get(klass_name) rescue nil
+          klass ||= klass_name.constantize rescue nil
+          klass
+        end
+
+        # Loop until things are ordered
+        while (result = out_of_order_class[klasses])
+          klass_index, parent_index = result
+          handler                   = klasses.delete_at klass_index
+          handlers                  = [*handlers[0..parent_index-1], handler, *handlers[parent_index..-1]]
+        end
+        handlers.reverse
+      end
     end
 
     def error(name, *args, &block)
@@ -49,7 +94,7 @@ module JSONAPIonify::Api
 
     def error_now(name, *args, &block)
       error(name, *args, &block)
-      raise Errors::RequestError
+      halt
     end
 
     def set_errors(collection)
@@ -60,6 +105,12 @@ module JSONAPIonify::Api
       errors.meta
     end
 
+    def halt
+      error = Errors::RequestError.new
+      error.set_backtrace caller
+      raise error
+    end
+
     private
 
     def lookup_error(name)
@@ -68,22 +119,43 @@ module JSONAPIonify::Api
       end
     end
 
-    def rescued_response(exception)
-      rescue_with_handler(exception) || begin
-        run_callbacks(:exception, exception)
-        errors.evaluate(
-          error_block:   lookup_error(:internal_server_error),
-          runtime_block: proc {
-            unless ENV['RACK_ENV'] == 'production'
-              detail exception.message
-              meta[:error_class] = exception.class.name
-            end
-          },
-          backtrace:     exception.backtrace
-        )
+    def handler_for_rescue(exception)
+      _, rescuer = self.class.sorted_rescue_handlers.find do |klass_name, _|
+        klass = self.class.const_get(klass_name) rescue nil
+        klass ||= klass_name.constantize rescue nil
+        exception.is_a?(klass) if klass
+      end
+
+      case rescuer
+      when Symbol
+        method(rescuer)
+      when Proc
+        rescuer
+      end
+    end
+
+    def invoke_rescue_handler(handler, exception, context, respond_proc)
+      status, headers, body =
+        instance_exec exception, context, respond_proc, &handler.unstrict
+      if status.is_a?(Fixnum) && headers.is_a?(Hash) && body.respond_to?(:each)
+        [status, headers, body]
+      else
+        error_response
+      end
+    end
+
+    # Tries to rescue the exception by looking up and calling a registered handler.
+    def rescue_with_handler(exception, context, respond_proc)
+      if (handler = handler_for_rescue(exception))
+        invoke_rescue_handler(handler, exception, context, respond_proc)
       end
-    ensure
-      return error_response
+    end
+
+    def rescued_response(exception, context, respond_proc)
+      rescue_with_handler(exception, context, respond_proc)
+    rescue Exception => ex
+      handler = handler_for_rescue(Exception.new)
+      invoke_rescue_handler(handler, ex, context, respond_proc)
     end
 
     def error_response

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

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

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

@@ -1,9 +1,97 @@
+require 'concurrent'
+
 module JSONAPIonify::Api
   module Resource::Includer
     extend ActiveSupport::Concern
 
     included do
-      param :include
+      before :list, :create, :read, :update do |context|
+        supports_includes = context.root_request? && context.includes.present?
+        is_active_record  = defined?(ActiveRecord) && context.scope.respond_to?(:<) && 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|
+              fetch_included(context, owner: instance)
+            end.reduce(:+)
+          append_included(context, included)
+        end
+      end
+
+      after :commit_create, :commit_read, :commit_update do |context|
+        if context.includes.present?
+          included = fetch_included(
+            context, owner: context.instance
+          )
+          append_included(context, included)
+        end
+      end
+
+      context :root_request?, readonly: true do
+        true
+      end
+
+      context :includes do |context|
+        Resource::Includer.includes_to_hashes context.params['include']
+      end
+    end
+
+    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
+      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)
+        else
+          error :relationship_not_includable, res.rel.name
+        end
+      end.uniq
+    end
+
+    def self.includes_to_hashes(path)
+      path.to_s.split(',').each_with_object({}) do |path, obj|
+        rel, *sub_path = path.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

data/lib/jsonapionify/api/resource.rb

@@ -15,31 +15,78 @@ module JSONAPIonify::Api
     include Builders
     include Defaults
 
+    delegate :type, :attributes, :relationships, to: :class
+
     def self.inherited(subclass)
       super(subclass)
       subclass.class_eval do
-        context(:api, readonly: true) { self.class.api }
-        context(:resource, readonly: true) { self }
+        context(:api, readonly: true, persisted: true) { self.class.api }
+        context(:resource, readonly: true, persisted: true) { self }
       end
     end
 
+    def self.cache_key(**options)
+      api.cache_key(
+        **options,
+        resource: name
+      )
+    end
+
     def self.example_id_generator(&block)
-      define_singleton_method :generate_id, &block
+      index = 0
+      define_singleton_method(:generate_id) do
+        instance_exec index += 1, &block
+      end
+      context :example_id do
+        self.class.generate_id
+      end
     end
 
-    def self.example_instance(index=1)
-      id = generate_id(index)
+    def self.example_instance_for_action(action, context)
+      id = generate_id
       OpenStruct.new.tap do |instance|
-        instance.send "#{id_attribute}=", (id).to_s
-        attributes.select(&:read?).each do |attribute|
-          instance.send "#{attribute.name}=", attribute.example(id, index)
+        instance.send "#{id_attribute}=", id.to_s
+        actionable_attributes = attributes.select do |attr|
+          attr.supports_read_for_action?(action, context)
+        end
+        actionable_attributes.each do |attribute|
+          instance.send "#{attribute.name}=", attribute.example(id)
         end
       end
     end
 
     example_id_generator { |val| val }
 
+    attr_reader :errors, :action, :response_headers
+
+    def initialize(
+      request:,
+      context_definitions: self.class.context_definitions,
+      commit: true,
+      callbacks: true,
+      context_overrides: {},
+      cacheable: true,
+      action: nil
+    )
+      context_overrides[:action_name] = action.name if action
+      @__context                      = ContextDelegate.new(
+        request,
+        self,
+        context_definitions,
+        context_overrides
+      )
+      @errors                         = @__context.errors
+      @action                         = action
+      @response_headers               = @__context.response_headers
+      @callbacks                      = action ? callbacks : false
+      @cache_options                  = {}
+      extend Caller if commit && action
+      extend Exec unless action
+      extend Caching if cacheable
+    end
+
     def action_name
+      action&.name
     end
 
   end

data/lib/jsonapionify/api/response.rb

@@ -1,12 +1,20 @@
 module JSONAPIonify::Api
   class Response
-    attr_reader :action, :accept, :response_block, :status
+    attr_reader :action, :accept, :response_block, :status,
+                :matcher, :content_type
 
-    def initialize(action, accept: nil, status: nil, &block)
+    def initialize(action, accept: 'application/vnd.api+json', content_type: nil, status: nil, match: nil, cacheable: true, &block)
       @action         = action
       @response_block = block || proc {}
-      @accept         = accept || 'application/vnd.api+json'
+      @accept         = accept unless match
+      @content_type   = content_type || (@accept == '*/*' ? nil : @accept)
+      @matcher        = match || proc {}
       @status         = status || 200
+      @cacheable      = cacheable
+    end
+
+    def cacheable
+      action.cacheable && @cacheable
     end
 
     def ==(other)
@@ -16,12 +24,6 @@ module JSONAPIonify::Api
         end
     end
 
-    def accept?(request)
-      request.accept.any? do |accept|
-        @accept == accept || accept == '*/*' || self.accept == '*/*'
-      end
-    end
-
     def documentation_object
       OpenStruct.new(
         accept:       accept,
@@ -30,18 +32,45 @@ module JSONAPIonify::Api
       )
     end
 
-    def call(instance, context)
+    def call(instance, context, status: nil)
+      status   ||= self.status
       response = self
       instance.instance_eval do
         body = instance_exec(context, &response.response_block)
         Rack::Response.new.tap do |rack_response|
-          rack_response.status = response.status
-          response_headers.each { |k, v| rack_response.headers[k.split('-').map(&:capitalize).join('-')] = v }
-          rack_response.headers['Content-Type'] = response.accept unless response.accept == '*/*'
-          rack_response.write(body) unless body.nil?
+          rack_response.status = status
+          response_headers.each do |k, v|
+            rack_response.headers[k.split('-').map(&:capitalize).join('-')] = v
+          end
+          rack_response.headers['Content-Type'] =
+            case response.content_type
+            when nil
+              raise(Errors::MissingContentType, 'missing content type')
+            when Proc
+              response.content_type.call(context)
+            else
+              response.content_type
+            end
+          if body.respond_to?(:each)
+            rack_response.body = body
+          elsif !body.nil?
+            rack_response.write(body)
+          end
         end.finish
       end
     end
 
+    def accept_with_header?(context)
+      context.request.accept.any? do |accept|
+        self.accept == accept ||
+          (self.accept == '*/*' && !context.request.extension) ||
+          (accept == '*/*' && !context.request.extension)
+      end
+    end
+
+    def accept_with_matcher?(context)
+      !!matcher.call(context)
+    end
+
   end
 end

data/lib/jsonapionify/api/server/media_type.rb

@@ -0,0 +1,36 @@
+module JSONAPIonify::Api
+  class Server::MediaType
+    SPLIT_PATTERN = %r{\s*[;,]\s*}
+
+    class << self
+      # The media type (type/subtype) portion of the CONTENT_TYPE header
+      # without any media type parameters. e.g., when CONTENT_TYPE is
+      # "text/plain;charset=utf-8", the media-type is "text/plain".
+      #
+      # For more information on the use of media types in HTTP, see:
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
+      def type(content_type)
+        return nil unless content_type
+        content_type.split(SPLIT_PATTERN, 2).first.downcase
+      end
+
+      # The media type parameters provided in CONTENT_TYPE as a Hash, or
+      # an empty Hash if no CONTENT_TYPE or media-type parameters were
+      # provided.  e.g., when the CONTENT_TYPE is "text/plain;charset=utf-8",
+      # this method responds with the following Hash:
+      #   { 'charset' => 'utf-8' }
+      def params(content_type)
+        return {} if content_type.nil?
+        Hash[*content_type.split(SPLIT_PATTERN)[1..-1].
+          collect { |s| s.split('=', 2) }.
+          map { |k, v| [k.downcase, strip_doublequotes(v)] }.flatten]
+      end
+
+      private
+
+      def strip_doublequotes(str)
+        (str[0] == ?" && str[-1] == ?") ? str[1..-2] : str
+      end
+    end
+  end
+end

data/lib/jsonapionify/api/server/request.rb

@@ -1,6 +1,7 @@
 require 'rack/request'
 require 'rack/utils'
 require 'rack/mock'
+require 'mime-types'
 
 module JSONAPIonify::Api
   class Server::Request < Rack::Request
@@ -15,7 +16,7 @@ module JSONAPIonify::Api
       end.each_with_object({}) do |(name, value), hash|
         hash[name[5..-1].gsub('_', '-').downcase] = value
       end
-      env_headers['content-type'] = content_type
+      env_headers['content-type'] = content_type if content_type
       Rack::Utils::HeaderHash.new(env_headers)
     end
 
@@ -44,23 +45,36 @@ module JSONAPIonify::Api
       body.rewind
     end
 
+    def extension
+      ext = File.extname(path)
+      return nil unless ext
+      ext = ext[0] == '.' ? ext[1..-1] : ext
+      ext.to_s.empty? ? nil : ext
+    end
+
     def content_type
       super.try(:split, ';').try(:first)
     end
 
-    def accept
-      accepts = (headers['accept'] || '*/*').split(',')
-      accepts.to_a.sort_by! do |accept|
-        _, *media_type_params = accept.split(';')
-        rqf                   = media_type_params.find { |mtp| mtp.start_with? 'q=' }
-        -(rqf ? rqf[2..-1].to_f : 1.0)
-      end.map do |accept|
-        mime, *media_type_params = accept.split(';')
-        media_type_params.reject! { |mtp| mtp.start_with? 'q=' }
-        [mime, *media_type_params].join(';')
+    def accept_params
+      @accept_params ||= begin
+        ext_mime = MIME::Types.type_for(path)[0]&.content_type
+        accepts  = (headers['accept'] || ext_mime || '*/*').split(',')
+        types    = [ext_mime].compact | accepts
+        types.each_with_object({}) do |type, list|
+          list[Server::MediaType.type(type)] = Server::MediaType.params(type)
+        end
       end
     end
 
+    def jsonapi_params
+      accept_params['application/vnd.api+json'] || {}
+    end
+
+    def accept
+      @accept ||= accept_params.keys
+    end
+
     def authorizations
       parts = headers['authorization'].to_s.split(' ')
       parts.length == 2 ? Rack::Utils::HeaderHash.new([parts].to_h) : {}

data/lib/jsonapionify/api/server.rb

@@ -23,17 +23,21 @@ module JSONAPIonify::Api
         @api     = api
         @request = Request.new(env)
         request.path_info.split('/').tap(&:shift).tap do |parts|
+          parts[-1]                                                 = File.basename(parts[-1], File.extname(parts[-1])) if parts[-1]
           @resource, @id, @relationship, @relationship_name, *@more = parts
-          request.env['jsonapionify.resource_name']                 = @resource if @resource
-          request.env['jsonapionify.resource']                      = resource if @resource
-          request.env['jsonapionify.id']                            = @id if @id
         end
       end
 
       def response
+        request.env['jsonapionify.resource_name'] = @resource if @resource
+        request.env['jsonapionify.resource']      = resource if @resource
+        request.env['jsonapionify.id']            = @id if @id
         @resource ? resource.process(request) : api_index
       rescue Errors::ResourceNotFound
-        api.http_error(:not_found, request)
+        resource = @resource
+        api.http_error(:not_found, request) do
+          detail "Resource not found: #{resource}"
+        end
       end
 
       private