jsonapionify 0.9.0 → 0.9.1

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

@@ -52,7 +52,11 @@ module JSONAPIonify::Api
 
     def documented_actions_in_order
       indexes = %i{list create read update delete add replace remove}
-      documented_actions.sort_by { |action, _| indexes.index(action.name) || indexes.length }
+      documented_actions.reject do |a, *|
+        ['HEAD', 'OPTIONS'].include? a.request_method
+      end.sort_by do |action, *|
+        indexes.index(action.name) || indexes.length
+      end
     end
 
     def documentation_object(base_url)
@@ -60,7 +64,7 @@ module JSONAPIonify::Api
         name:          type,
         description:   JSONAPIonify::Documentation.render_markdown(@description || ''),
         relationships: relationships.map { |r| r.documentation_object },
-        attributes:    attributes.map(&:documentation_object),
+        attributes:    attributes.sort_by(&:name).map(&:documentation_object),
         actions:       documented_actions_in_order.map do |action, base, args|
           action.documentation_object File.join(base_url, base), *args
         end

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

@@ -3,6 +3,53 @@ module JSONAPIonify::Api
     extend ActiveSupport::Concern
 
     included do
+      context :path_actions, readonly: true, persisted: true do |context|
+        self.class.path_actions(context.request)
+      end
+
+      context :http_allow, readonly: true, persisted: true do |context|
+        context.path_actions.map(&:request_method)
+      end
+
+      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|
+          request_attributes_json = attributes.select do |attr|
+            attr.supports_write_for_action? action.name, context
+          end.map do |attr|
+            attr.options_json_for_action(action.name, context)
+          end
+
+          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)
+          end
+
+          h['path']      = context.request.path
+          h['url']       = context.request.url
+          action_options = h[action.request_method] = {}
+
+          if ['GET', 'POST', 'PUT', 'PATCH'].include? action.request_method
+            action_options[:response_attributes] = response_attributes_json
+            action_options[:relationships]       = self.class.relationships.map(&:options_json)
+          end
+
+          if ['POST', 'PUT', 'PATCH'].include? action.request_method
+            action_options[:request_attributes] = request_attributes_json
+          end
+        end
+        JSONAPIonify.new_object(
+          meta: {
+            type:     self.class.type,
+            requests: requests
+          }
+        ).to_json
+      end
+
       before(:create) { |context| context.instance = context.new_instance }
       read
     end

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

@@ -5,8 +5,11 @@ module JSONAPIonify::Api
     extend ActiveSupport::Concern
 
     included do
-      rescue_from JSONAPIonify::Structure::ValidationError, error: :jsonapi_validation_error
-      rescue_from Oj::ParseError, error: :json_parse_error
+      register_exception 'ActiveRecord::RecordInvalid', error: :invalid_record
+      register_exception 'ActiveRecord::RecordNotUnique', error: :duplicate_record
+      register_exception 'ActiveRecord::RecordNotFound', error: :not_found
+      register_exception JSONAPIonify::Structure::ValidationError, error: :jsonapi_validation_error
+      register_exception Oj::ParseError, error: :json_parse_error
 
       Rack::Utils::SYMBOL_TO_STATUS_CODE.reject { |_, v| v < 400 }.each do |symbol, code|
         message = Rack::Utils::HTTP_STATUS_CODES[code]
@@ -18,74 +21,100 @@ module JSONAPIonify::Api
 
       error :data_missing do
         pointer ''
-        title 'Missing Member'
+        title 'missing Member'
         detail 'missing data member'
         status '422'
       end
 
       error :json_parse_error do
-        title 'Parse Error'
-        detail 'Could not parse JSON object'
+        title 'parse Error'
+        detail 'could not parse json object'
         status '422'
       end
 
       error :field_not_permitted do |type, field|
         parameter "fields[#{type}]"
-        title 'Invalid Field'
+        title 'invalid field'
         detail "type: `#{type}`, does not have field: `#{field}`"
         status '400'
       end
 
+      error :attribute_type_error do |attribute|
+        pointer "data/attributes/#{attribute}"
+        status '500'
+        title "attribute type error"
+      end
+
+      error :attribute_required do |attribute|
+        pointer "data/attributes/#{attribute}"
+        title 'attribute required'
+        detail "attribute required: #{attribute}"
+        status '422'
+      end
+
+      error :attribute_cannot_be_null do |attribute|
+        pointer "data/attributes/#{attribute}"
+        title "attribute cannot be null: #{attribute}"
+        status '500'
+      end
+
       error :attribute_not_permitted do |attribute|
         pointer "data/attributes/#{attribute}"
-        title 'Attribute not permitted'
-        detail "Attribute not permitted: #{attribute}"
+        title 'attribute not permitted'
+        status '422'
+        detail "attribute not permitted: #{attribute}"
       end
 
       error :attributes_missing do
         pointer 'data'
-        title 'Missing Member'
+        title 'missing Member'
         detail 'missing attributes member'
         status '422'
       end
 
       error :include_parameter_invalid do
         parameter 'sort'
-        title 'Include parameter is invalid'
+        title 'include parameter is invalid'
         status '400'
       end
 
       error :parameters_missing do |parameters|
-        title 'Missing required parameters'
+        title 'missing required parameters'
         detail "missing: #{parameters.to_sentence}"
         status '400'
       end
 
       error :parameter_invalid do |param|
         parameter param
-        title 'Parameter Invalid'
+        title 'parameter Invalid'
         detail "parameter invalid: #{param}"
         status '400'
       end
 
       error :headers_missing do |headers|
-        title 'Missing required headers'
+        title 'missing required headers'
         detail "missing: #{headers.to_sentence}"
         status '400'
       end
 
       error :sort_parameter_invalid do
         parameter 'sort'
-        title 'Sort parameter is invalid'
+        title 'sort parameter is invalid'
         status '400'
       end
 
       error :page_parameter_invalid do |*paths|
         parameter ParamOptions.keypath_to_string(*paths)
-        title 'Page parameter invalid'
+        title 'page parameter invalid'
         status '400'
       end
 
+      error :relationship_not_includable do |name|
+        parameter 'include'
+        title "relationship not includable: #{name}"
+        status '406'
+      end
+
       error :request_object_invalid do |context, request_object|
         context.errors.set request_object.errors.as_collection
       end
@@ -94,6 +123,23 @@ module JSONAPIonify::Api
         title 'Invalid Resource'
         status '404'
       end
+
+      error :duplicate_record do
+        title 'Duplicate Record'
+        status "409"
+      end
+
+      error :invalid_attribute do |attr, message|
+        title attr.present? ? 'Invalid Attribute' : 'Invalid Record'
+        detail [attr, message].reject(&:empty?).join(' ')
+        pointer "data/attributes/#{attr}" if attr.present?
+        status "422"
+      end
+
+      error :invalid_record do
+        title 'Invalid Record'
+        status "422"
+      end
     end
   end
 end

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

@@ -0,0 +1,68 @@
+module JSONAPIonify::Api
+  module Resource::Defaults::Hooks
+    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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,40 +3,28 @@ module JSONAPIonify::Api
     extend ActiveSupport::Concern
     included do
       id :id
-      scope { raise NotImplementedError, 'scope not implemented' }
-      collection { raise NotImplementedError, 'collection not implemented' }
-      instance { raise NotImplementedError, 'instance not implemented' }
-      new_instance { raise NotImplementedError, 'new instance not implemented' }
-
-      context :scope_defined? do |context|
-        begin
-          !!context.scope
-        rescue NotImplementedError
-          false
-        end
-      end
-
-      context :collection_defined? do |context|
-        begin
-          !!context.collection
-        rescue NotImplementedError
-          false
+      scope { self.type.classify.constantize }
+      collection do |scope|
+        if defined?(ActiveRecord) && scope < ActiveRecord::Base && scope.is_a?(Class)
+          scope.all
+        else
+          scope
         end
       end
 
-      context :instance_defined? do |context|
-        begin
-          !!context.instance
-        rescue NotImplementedError
-          false
+      instance do |scope, key|
+        if defined?(ActiveRecord) && scope < ActiveRecord::Base
+          scope.find_by! id_attribute => key
+        else
+          raise NotImplementedError, 'instance not implemented'
         end
       end
 
-      context :new_instance_defined? do |context|
-        begin
-          !!context.new_instance
-        rescue NotImplementedError
-          false
+      new_instance do |scope|
+        if defined?(ActiveRecord) && scope < ActiveRecord::Base
+          scope.new
+        else
+          raise NotImplementedError, 'scope not implemented'
         end
       end
 

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

@@ -4,6 +4,9 @@ module JSONAPIonify::Api
 
     included do
       param :'include-relationships'
+
+      # Configure the default sort
+      default_sort 'id'
     end
   end
 end

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

@@ -3,74 +3,122 @@ module JSONAPIonify::Api
     extend ActiveSupport::Concern
 
     included do
-      context(:request_body, readonly: true) do |context|
+
+      context(:request_body, readonly: true, persisted: true) do |context|
         context.request.body.read
       end
 
-      context(:request_object, readonly: true) do |context|
+      context(:request_object, readonly: true, persisted: true) do |context|
         JSONAPIonify.parse(context.request_body).as(:client).tap do |input|
           error_now(:request_object_invalid, context, input) unless input.validate
         end
       end
 
-      context(:id, readonly: true) do |context|
+      context(:id, readonly: true, persisted: true) do |context|
         context.request.env['jsonapionify.id']
       end
 
-      context(:request_attributes, readonly: true) do |context|
-        request_object = context.request_object
+      context(:request_id, readonly: true, persisted: true) do |context|
+        context.request_data[:id]
+      end
+
+      context(:request_attributes, readonly: true, persisted: true) do |context|
+        should_error = false
 
-        # Validate Request Object
-        request_object.validate
-        error_now(:request_object_invalid, context, request_object) if request_object.errors.present?
+        request_attributes =
+          context.request_data.fetch(:attributes) do
+            error_now :attributes_missing
+          end
 
-        request_attributes = context.request_data.fetch(:attributes) do
-          error_now :attributes_missing
+        # Check for required attributes
+        self.attributes.each do |attr|
+          next unless attr.required_for_action?(action_name, context)
+          if attr.read? || context.id
+            example_id = self.build_id(context.instance)
+            next unless attr.resolve(
+              context.instance, context, example_id: example_id
+            ).nil?
+          end
+          unless request_attributes.has_key?(attr.name)
+            error :attribute_required, attr.name
+            should_error = true
+          end
         end
-        request_attributes.tap do |attributes|
-          # Check Permitted Attributes
-          writable_attributes = context.request_resource.attributes.select(&:write?)
-          if (extra_attributes = attributes.keys - writable_attributes.map(&:name)).present?
-            extra_attributes.each { |attr| error :attribute_not_permitted, attr }
-            raise Errors::RequestError
+
+        request_attributes.each_with_object({}) do |(attr, v), attributes|
+          resource_attribute = self.attributes.find { |a| a.name == attr }
+          is_actionable      = !!resource_attribute&.supports_write_for_action?(action_name, context)
+          unless is_actionable
+            error :attribute_not_permitted, attr
+            should_error = true
           end
-        end.to_hash
-      end
 
-      context(:request_instances, readonly: true) do |context|
-        should_error = false
-        data         = context.request_data
-        instances    = data.map.each_with_index do |item, i|
           begin
-            find_instance item, pointer: "data/#{i}"
-          rescue Errors::RequestError
+            attributes[attr] = resource_attribute.type.load(v)
+          rescue JSONAPIonify::Types::LoadError
+            error :attribute_type_error, attr
             should_error = true
           end
+        end.tap do
+          halt if should_error
         end
-        raise Errors::RequestError if should_error
-        instances
       end
 
-      context(:request_instance, readonly: true) do |context|
+      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|
+            pointer = "data/relationships/#{name}/data"
+            case rel[:data]
+            when JSONAPIonify::Structure::Collections::Base
+              obj[name] = find_instances(rel[:data], pointer: pointer)
+            when JSONAPIonify::Structure::Objects::Base
+              obj[name] = find_instance(rel[:data], pointer: pointer)
+            end
+          end
+        else
+          {}
+        end
+      end
+
+      context(:request_instances, readonly: true, persisted: true) do |context|
+        data = context.request_data
+        (data ? find_instances(data, pointer: '/data') : [])
+      end
+
+      context(:request_instance, readonly: true, persisted: true) do |context|
         find_instance(context.request_data, pointer: 'data')
       end
 
-      context(:request_resource, readonly: true) do |context|
+      context(:request_resource, readonly: true, persisted: true) do |context|
         item = context.request_data
         find_resource item, pointer: 'data'
       end
 
-      context(:request_data) do |context|
+      context(:request_data, readonly: true, persisted: true) do |context|
         context.request_object.fetch(:data) {
           error_now(:data_missing)
         }
       end
 
-      context(:authentication, readonly: true) do
+      context(:authentication, readonly: true, persisted: true) do
         OpenStruct.new
       end
     end
 
+    def find_instances(items, pointer:)
+      should_error = false
+      instances    = items.map.each_with_index do |item, i|
+        begin
+          find_instance item, pointer: "#{pointer}/#{i}"
+        rescue Errors::RequestError
+          should_error = true
+        end
+      end
+      halt if should_error
+      instances
+    end
+
     def find_instance(item, pointer:)
       should_error = false
       resource     = find_resource(item, pointer: pointer)
@@ -81,7 +129,7 @@ module JSONAPIonify::Api
           self.detail "could not find resource: `#{item[:type]}` with id: #{item[:id]}"
         end
       end
-      raise Errors::RequestError if should_error
+      halt if should_error
       instance
     end
 
@@ -94,7 +142,7 @@ module JSONAPIonify::Api
           self.detail "could not find resource: `#{item[:type]}`"
         end
       end
-      raise Errors::RequestError if should_error
+      halt if should_error
       resource
     end
 

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

@@ -3,27 +3,34 @@ module JSONAPIonify::Api
     extend ActiveSupport::Concern
 
     included do
+      before(:response) { |context| context.clear }
+
+      context(:invalidate_cache?, readonly: true, persisted: true) { |c| c.includes.present? }
 
       # Response Objects
-      context(:links, readonly: true) do |context|
+      context(:links, readonly: true, persisted: true) do |context|
         context.response_object[:links]
       end
 
-      context(:meta, readonly: true) do |context|
+      context(:meta, readonly: true, persisted: true) do |context|
         JSONAPIonify::Structure::Helpers::MetaDelegate.new context.response_object
       end
 
-      context(:response_object) do |context|
+      context(:response_object, readonly: true, persisted: true) do |context|
         JSONAPIonify.parse(links: { self: context.request.url })
       end
 
-      context(:response_collection) do |context|
-        collections = %i{
+      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 }
+          context.public_send collections.find { |c| context.respond_to? c }
+        else
+          context.collection
+        end
       end
 
     end

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

@@ -7,4 +7,4 @@ module JSONAPIonify::Api
       constants(false).each { |const| klass.include const_get const, false }
     end
   end
-end
+end