jsonapionify 0.9.0 → 0.9.1

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

@@ -9,82 +9,109 @@ module JSONAPIonify::Api
       klass.class_eval do
         extend JSONAPIonify::InheritedAttributes
         include JSONAPIonify::Callbacks
-        define_callbacks :request, :list, :create, :read, :update, :delete,
-                         :show, :add, :remove, :replace, :exception
+        define_callbacks(
+          :request, :exception, :response,
+          :list, :commit_list,
+          :create, :commit_create,
+          :read, :commit_read,
+          :update, :commit_update,
+          :delete, :commit_delete,
+          :show, :commit_show,
+          :add, :commit_add,
+          :remove, :commit_remove,
+          :replace, :commit_replace
+        )
         inherited_array_attribute :action_definitions
       end
     end
 
-    def list(**options, &block)
+    def list(content_type: nil, only_associated: false, callbacks: true, &block)
+      options = {
+        content_type:    content_type,
+        only_associated: only_associated,
+        callbacks:       callbacks,
+        cacheable:       true
+      }
       define_action(:list, 'GET', **options, &block).tap do |action|
         action.response status: 200 do |context|
+          builder                        = context.respond_to?(:builder) ? context.builder : nil
           context.response_object[:data] = build_collection(
-            context.request,
+            context,
             context.response_collection,
-            fields: context.fields
+            fields:          context.fields,
+            include_cursors: (context.links.keys & [:first, :last, :next, :prev]).present?,
+            &builder
           )
           context.response_object.to_json
         end
       end
     end
 
-    def index(**options, &block)
-      warn 'the `index` action will soon be deprecated, use `list` instead!'
-      list(**options, &block)
-    end
-
-    def create(**options, &block)
+    def create(content_type: nil, only_associated: false, callbacks: true, &block)
+      options = {
+        content_type:    content_type,
+        only_associated: only_associated,
+        callbacks:       callbacks,
+        cacheable:       false,
+        example_input:   :resource
+      }
       define_action(:create, 'POST', **options, &block).tap do |action|
         action.response status: 201 do |context|
-          context.response_object[:data] = build_resource(context.request, context.instance, fields: context.fields)
-          response_headers['Location']   = build_url(context.request, context.instance)
+          builder                        = context.respond_to?(:builder) ? context.builder : nil
+          context.response_object[:data] = build_resource(context, context.instance, fields: context.fields, &builder)
+          response_headers['Location']   = build_url(context, context.instance)
           context.response_object.to_json
         end
       end
     end
 
-    def read(**options, &block)
+    def read(content_type: nil, only_associated: false, callbacks: true, &block)
+      options = {
+        content_type:    content_type,
+        only_associated: only_associated,
+        callbacks:       callbacks,
+        cacheable:       true
+      }
       define_action(:read, 'GET', '/:id', **options, &block).tap do |action|
         action.response status: 200 do |context|
-          context.response_object[:data] = build_resource(context.request, context.instance, fields: context.fields)
+          builder                        = context.respond_to?(:builder) ? context.builder : nil
+          context.response_object[:data] = build_resource(context, context.instance, fields: context.fields, &builder)
           context.response_object.to_json
         end
       end
     end
 
-    def update(**options, &block)
+    def update(content_type: nil, only_associated: false, callbacks: true, &block)
+      options = {
+        content_type:    content_type,
+        only_associated: only_associated,
+        callbacks:       callbacks,
+        cacheable:       false,
+        example_input:   :resource
+      }
       define_action(:update, 'PATCH', '/:id', **options, &block).tap do |action|
         action.response status: 200 do |context|
-          context.response_object[:data] = build_resource(context.request, context.instance, fields: context.fields)
+          builder                        = context.respond_to?(:builder) ? context.builder : nil
+          context.response_object[:data] = build_resource(context, context.instance, fields: context.fields, &builder)
           context.response_object.to_json
         end
       end
     end
 
-    def delete(**options, &block)
+    def delete(content_type: nil, only_associated: false, callbacks: true, &block)
+      options = {
+        content_type:    content_type,
+        only_associated: only_associated,
+        callbacks:       callbacks,
+        cacheable:       false
+      }
       define_action(:delete, 'DELETE', '/:id', **options, &block).tap do |action|
         action.response status: 204
       end
     end
 
     def process(request)
-      path_actions = self.path_actions(request)
-      if request.options? && path_actions.present?
-        allow    = [*path_actions.map(&:request_method), 'OPTIONS']
-        requests = allow.each_with_object({}) do |method, h|
-          h[method] = options_for_method(method)
-        end
-        Action.dummy do
-          response_headers['Allow'] = allow.join(', ')
-        end.response(status: 200, accept: 'application/vnd.api+json') do
-          JSONAPIonify.new_object(
-            meta: {
-              type: self.class.type,
-              requests: requests
-            }
-          ).to_json
-        end.call(self, request)
-      elsif (action = find_supported_action(request))
+      if (action = find_supported_action(request))
         action.call(self, request)
       elsif (rel = find_supported_relationship(request))
         relationship(rel.name).process(request)
@@ -93,24 +120,18 @@ module JSONAPIonify::Api
       end
     end
 
-    def options_for_method(method)
-      case method
-      when 'GET'
-        { attributes: attributes.select(&:read).map(&:options_json) }
-      when 'POST', 'PUT', 'PATCH'
-        { attributes: attributes.select(&:write).map(&:options_json) }
-      else
-        {}
+    def after(*action_names, &block)
+      return after_request &block if action_names.blank?
+      action_names.each do |action_name|
+        send("after_#{action_name}", &block)
       end
     end
 
-    def before(action_name = nil, &block)
-      if action_name == :index
-        warn 'the `index` action will soon be deprecated, use `list` instead!'
-        action_name = :list
+    def before(*action_names, &block)
+      return before_request &block if action_names.blank?
+      action_names.each do |action_name|
+        send("before_#{action_name}", &block)
       end
-      return before_request &block if action_name == nil
-      send("before_#{action_name}", &block)
     end
 
     def define_action(name, *args, **options, &block)
@@ -150,22 +171,27 @@ module JSONAPIonify::Api
 
     def find_supported_relationship(request)
       relationship_definitions.find do |rel|
-        relationship(rel.name).path_actions(request).present?
+        relationship = self.relationship(rel.name)
+        relationship != self && relationship.path_actions(request).present?
       end
     end
 
     def remove_action(*names)
-      if names.include? :index
-        warn 'the `index` action will soon be deprecated, use `list` instead!'
-        names << :list
-      end
       action_definitions.delete_if do |action_definition|
         names.include? action_definition.name
       end
     end
 
+    def call_action(name, request, **context_overrides)
+      action(name).call(self, request, **context_overrides)
+    end
+
+    def action(name)
+      actions.find { |action| action.name == name }
+    end
+
     def actions
-      return if action_definitions.blank?
+      return [] if action_definitions.blank?
       action_definitions.select do |action|
         action.only_associated == false ||
           (respond_to?(:rel) && action.only_associated == true)

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

@@ -9,19 +9,31 @@ module JSONAPIonify::Api
         delegate :id_attribute, :attributes, to: :class
 
         context(:fields, readonly: true) do |context|
-          should_error = false
-          fields       = (context.request.params['fields'] || {}).each_with_object(self.class.api.fields) do |(type, fields), field_map|
+          should_error      = false
+          input_fields      = context.request.params['fields'] || {}
+          actionable_fields = self.class.fields_for_action(context.action_name, context)
+          input_fields.each_with_object(
+            actionable_fields
+          ) do |(type, fields), field_map|
             type_sym            = type.to_sym
+            field_symbols       = fields.to_s.split(',').map(&:to_sym)
             field_map[type_sym] =
-              fields.to_s.split(',').map(&:to_sym).each_with_object([]) do |field, field_list|
-                attribute = self.class.api.resource(type_sym).attributes.find do |attribute|
-                  attribute.read? && attribute.name == field
+              field_symbols.each_with_object([]) do |field, field_list|
+                type_attributes = self.class.api.resource(type_sym).attributes
+                attribute       = type_attributes.find do |attribute|
+                  attribute.name == field &&
+                    attribute.supports_read_for_action?(context.action_name, context)
+                end
+                if attribute
+                  field_list << attribute.name
+                else
+                  error(:field_not_permitted, type, field)
+                  should_error = true
                 end
-                attribute ? field_list << attribute.name : error(:field_not_permitted, type, field) && (should_error = true)
               end
+          end.tap do
+            halt if should_error
           end
-          raise Errors::RequestError if should_error
-          fields
         end
       end
     end
@@ -32,20 +44,44 @@ module JSONAPIonify::Api
       end
     end
 
-    def attribute(name, type, description = '', **options)
-      Attribute.new(name, type, description, **options).tap do |new_attribute|
+    def attribute(name, type, description = '', **options, &block)
+      Attribute.new(
+        name, type, description, **options, &block
+      ).tap do |new_attribute|
         attributes.delete(new_attribute)
         attributes << new_attribute
       end
     end
 
+    def remove_attribute(name)
+      attributes.delete_if { |attr| attr.name == name.to_sym }
+    end
+
     def fields
       attributes.select(&:read?).map(&:name)
     end
 
+    def builder(&block)
+      context :builder, readonly: true, persisted: true do |context|
+        proc do |resource, instance|
+          block.call resource, instance, context
+        end
+      end
+    end
+
     def field_valid?(name)
       fields.include? name.to_sym
     end
 
+    def fields_for_action(action, context)
+      api.fields.each_with_object({}) do |(type, attrs), fields|
+        fields[type] = attrs.select do |attr|
+          api.resource(type).attributes.find do |type_attr|
+            type_attr.name == attr
+          end.supports_read_for_action? action, context
+        end
+      end
+    end
+
   end
 end

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

@@ -8,8 +8,12 @@ module JSONAPIonify::Api
       end
     end
 
-    def context(name, readonly: false, &block)
-      self.context_definitions[name.to_sym] = Context.new(block, readonly)
+    def context(name, **opts, &block)
+      self.context_definitions[name.to_sym] = Context.new(
+        **opts,
+        existing_context: self.context_definitions[name.to_sym],
+        &block
+      )
     end
 
   end

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

@@ -6,7 +6,7 @@ module JSONAPIonify::Api
     end
 
     def authentication(&block)
-      context :authentication, readonly: true do |context|
+      context :authentication, readonly: true, persisted: true do |context|
         OpenStruct.new.tap do |authentication_object|
           if instance_exec(context.request, authentication_object, &block) == false
             error_now :forbidden

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

@@ -12,7 +12,7 @@ module JSONAPIonify::Api
         define_method method do |**options|
           @links[method] = URI.parse(@url).tap do |uri|
             page_params = { page: options }.deep_stringify_keys
-            uri.query   = @params.deep_merge(page_params).to_param
+            uri.query   = @params.merge(page_params).to_param
           end.to_s
         end
       end
@@ -35,22 +35,14 @@ module JSONAPIonify::Api
           slice =
             if (params['before'] && params['first']) || (params['after'] && params['last'])
               error :forbidden do
-                message 'Illegal combination of parameters'
+                detail 'Illegal combination of parameters'
               end
             elsif (after = params['after'])
               key_values = parse_and_validate_cursor(:after, after, context)
-              array_select_past_cursor(
-                collection,
-                context.sort_params,
-                key_values
-              ).first(size)
+              array_select_past_cursor(collection, context.sort_params, key_values).first(size)
             elsif (before = params['before'])
               key_values = parse_and_validate_cursor(:before, before, context)
-              array_select_past_cursor(
-                collection,
-                context.sort_params.reverse,
-                key_values
-              ).last(size)
+              array_select_past_cursor(collection, context.sort_params.invert, key_values).last(size)
             elsif params['last']
               collection.last(size)
             else
@@ -59,8 +51,8 @@ module JSONAPIonify::Api
 
           links.first first: size
           links.last last: size
-          links.prev before: build_cursor_from_instance(context.request, slice.first), last: size unless slice.first == collection.first
-          links.next after: build_cursor_from_instance(context.request, slice.last), first: size unless slice.last == collection.last
+          links.prev before: build_cursor_from_instance(context.request, slice.first), last: size unless !slice.first || slice.first == collection.first
+          links.next after: build_cursor_from_instance(context.request, slice.last), first: size unless !slice.last || slice.last == collection.last
 
           slice
         end
@@ -71,22 +63,15 @@ module JSONAPIonify::Api
           slice =
             if (params['before'] && params['first']) || (params['after'] && params['last'])
               error :forbidden do
-                message 'Illegal combination of parameters'
+                detail 'Illegal combination of parameters'
               end
             elsif (after = params['after'])
               key_values = parse_and_validate_cursor(:after, after, context)
-              arel_select_past_cursor(
-                collection,
-                context.sort_params,
-                key_values
-              ).limit(size)
+              arel_select_past_cursor(collection, context.sort_params, key_values).limit(size)
             elsif (before = params['before'])
               key_values = parse_and_validate_cursor(:before, before, context)
-              ids        = arel_select_past_cursor(
-                collection,
-                context.sort_params.reverse,
-                key_values
-              ).reverse_order.limit(size).pluck(:id)
+              ids        = arel_select_past_cursor(collection, context.sort_params.invert, key_values)
+                             .reverse_order.limit(size).pluck(id_attribute)
               collection.where(id_attribute => ids)
             elsif params['last']
               ids = collection.reverse_order.limit(size).pluck(id_attribute)
@@ -97,8 +82,8 @@ module JSONAPIonify::Api
 
           links.first first: size
           links.last last: size
-          links.prev before: build_cursor_from_instance(context.request, slice.first), last: size unless slice.first == collection.first
-          links.next after: build_cursor_from_instance(context.request, slice.last), first: size unless slice.last == collection.last
+          links.prev before: build_cursor_from_instance(context.request, slice.first), last: size unless !slice.first || slice.first == collection.first
+          links.next after: build_cursor_from_instance(context.request, slice.last), first: size unless !slice.last || slice.last == collection.last
 
           slice
         end
@@ -114,26 +99,30 @@ module JSONAPIonify::Api
       param :page, :before, actions: %i{list}
       param :page, :first, actions: %i{list}
       param :page, :last, actions: %i{list}
-      context :paginated_collection do |context|
-        collection = context.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)
-        end
+      context :paginated_collection, readonly: true do |context|
+        if context.root_request?
+          collection = context.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)
+          end
 
-        links_delegate = PaginationLinksDelegate.new(
-          context.request.url,
-          self.class.sticky_params(context.params),
-          context.links
-        )
-
-        instance_exec(
-          collection,
-          context.request.params['page'] || {},
-          links_delegate,
-          per,
-          context,
-          &block
-        )
+          links_delegate = PaginationLinksDelegate.new(
+            context.request.url,
+            context.params,
+            context.links
+          )
+
+          instance_exec(
+            collection,
+            context.request.params['page'] || {},
+            links_delegate,
+            per,
+            context,
+            &block
+          )
+        else
+          context.collection
+        end
       end
     end
 
@@ -166,18 +155,20 @@ module JSONAPIonify::Api
       end
 
       def arel_select_past_cursor(collection, sort_params, key_values)
-        subselect = sort_params.length.times.map do |i|
+        subquery = sort_params.length.times.map do |i|
           set                             = sort_params[0..i]
           *contains_fields, outside_field = set
           contains_fields.reduce(collection.reorder(nil)) do |relation, field|
-            relation.where <<-SQL.strip, value: key_values[field.name.to_s]
-              "#{field.name}" #{field.contains_operator} :value
-            SQL
-          end.where(<<-SQL.strip, key_values[outside_field.name.to_s]).to_sql
-            "#{outside_field.name}" #{outside_field.outside_operator} ?
-          SQL
-        end.join(' UNION ')
-        collection.from("(#{subselect}) AS #{collection.table_name}")
+            relation.where(
+              collection.arel_table[field.name].send(field.contains_arel, key_values[field.name.to_s])
+            )
+          end.where(
+            collection.arel_table[outside_field.name].send(outside_field.outside_arel, key_values[outside_field.name.to_s])
+          )
+        end.map { |rel| "( #{rel.to_sql} )" }.join(' UNION ')
+        collection.from("(#{subquery}) AS #{collection.table_name}").tap(&:first)
+      rescue ActiveRecord::StatementInvalid
+        collection.where(id: collection.find_by_sql(subquery).map(&:id))
       end
 
       def parse_and_validate_cursor(param, cursor, context)
@@ -199,7 +190,7 @@ module JSONAPIonify::Api
             detail 'The cursor sort does not match the request sort'
           end
         end
-        raise Errors::RequestError if should_error
+        halt if should_error
 
         options['a']
       end

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

@@ -6,7 +6,7 @@ module JSONAPIonify::Api
         extend JSONAPIonify::InheritedAttributes
         inherited_hash_attribute :param_definitions
 
-        context(:params, readonly: true) do |context|
+        context(:params, readonly: true, persisted: true) do |context|
           should_error = false
 
           params = self.class.param_definitions.select do |_, v|
@@ -27,18 +27,23 @@ module JSONAPIonify::Api
             reserved = ParamOptions.reserved?(k)
             allowed  = params.keys.include? keypath
             valid    = ParamOptions.valid?(k) || v.is_a?(Hash)
-            unless reserved || (allowed && valid)
+            unless reserved || (allowed && valid) || !context.root_request?
               should_error = true
               error :parameter_invalid, ParamOptions.keypath_to_string(*keypath)
             end
-          end
+          end unless context.request.options?
 
           # Check for requirement
-          if (missing_params = ParamOptions.missing_parameters(context.request.params, required_params.values.map(&:keypath))).present?
+          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
 
-          raise Errors::RequestError if should_error
+          halt if should_error
 
           # Return the params
           context.request.params
@@ -58,22 +63,13 @@ module JSONAPIonify::Api
           definition.keypath == keypath
         end
         next {} unless definition
-        value      = definition.extract_value(params)
+        value = definition.extract_value(params)
         if definition.default_value?(value)
           {}
         else
           definition.with_value(value)
         end
       end.reduce(:deep_merge)
-
-      # sticky_param_definitions = param_definitions.values.select(&:sticky)
-      # params.each_with_object do |k, v|
-      #   definition = sticky_param_definitions.find do |definition|
-      #     definition.keypath == ParamOptions.hash_to_keypaths(k => v)[0]
-      #   end
-      #   binding.pry
-      #   definition && !definition.default_value?(v)
-      # end
     end
 
   end

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

@@ -8,18 +8,54 @@ module JSONAPIonify::Api
       end
     end
 
-    def relates_to_many(name, resource: nil, &block)
-      define_relationship(name, Relationship::Many, resource: resource, &block)
+    def relates_to_many(name, count_attribute: false, include_count: true, **opts, &block)
+      define_relationship(name, Relationship::Many, **opts, &block).tap do
+        define_relationship_counter(
+          name,
+          count_attribute === true ? "#{name.to_s.singularize}_count" : count_attribute.to_s,
+          include: include_count
+        ) if count_attribute
+      end
+    end
+
+    def relates_to_one(name, **opts, &block)
+      opts[:resource] ||= name.to_s.pluralize.to_sym
+      define_relationship(name, Relationship::One, **opts, &block)
     end
 
-    def relates_to_one(name, resource: nil, &block)
-      define_relationship(name, Relationship::One, resource: resource, &block)
+    def define_relationship_counter(rel_name, name, include: true)
+      before :response do |context|
+        if (context.scope.is_a?(ActiveRecord::Relation) || context.scope.is_a?(ActiveRecord::Base)) && context.scope._reflect_on_association(rel_name)
+          context.scope = context.scope.includes(rel_name)
+        end if context.fields[type&.to_sym].include? name.to_sym
+      end if include
+      attribute name.to_sym, types.Integer, "The number of #{rel_name}.", write: false do |_, instance, context|
+        rel          = context.resource.class.relationship(rel_name)
+        blank_fields = context.fields.map { |k, _| [k, {}] }.to_h
+        rel_context  = rel.new(
+          request:           context.request,
+          context_overrides: {
+            owner:  instance,
+            fields: blank_fields,
+            params: {}
+          }
+        ).exec { |c| c }
+        count        = rel_context.collection.uniq.count
+        case count
+        when Hash
+          count.values.reduce(:+)
+        when Fixnum
+          count
+        else
+          error :internal_server_error
+        end
+      end
     end
 
-    def define_relationship(name, klass, resource: nil, &block)
+    def define_relationship(name, klass, **opts, &block)
       const_name = name.to_s.camelcase + 'Relationship'
       remove_const(const_name) if const_defined? const_name
-      klass.new(self, name, resource: resource, &block).tap do |new_relationship|
+      klass.new(self, name, **opts, &block).tap do |new_relationship|
         relationship_definitions.delete new_relationship
         relationship_definitions << new_relationship
       end
@@ -34,7 +70,7 @@ module JSONAPIonify::Api
       const_name = name.to_s.camelcase + 'Relationship'
       return const_get(const_name, false) if const_defined? const_name
       relationship_definition = relationship_definitions.find { |rel| rel.name == name }
-      raise Errors::RelationshipNotDefined, "Relationship not defined: #{name}" unless relationship_definition
+      raise Errors::RelationshipNotFound, "Relationship not found: #{name}" unless relationship_definition
       const_set const_name, relationship_definition.resource_class
     end
 

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

@@ -6,7 +6,7 @@ module JSONAPIonify::Api
         extend JSONAPIonify::InheritedAttributes
         inherited_hash_attribute :request_header_definitions
 
-        context(:request_headers) do |context|
+        context(:request_headers, persisted: true, readonly: true) do |context|
           should_error     = false
 
           # Check for validity
@@ -17,12 +17,15 @@ module JSONAPIonify::Api
             v.required
           end
 
-          if (missing_keys = required_headers.keys.map(&:downcase) - context.request.headers.keys.map(&:downcase)).present?
+          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
           end
 
-          raise Errors::RequestError if should_error
+          halt if should_error
 
           context.request.headers
         end

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

@@ -6,7 +6,7 @@ module JSONAPIonify::Api
         extend JSONAPIonify::InheritedAttributes
         inherited_hash_attribute :response_header_definitions
 
-        context(:response_headers) do |context|
+        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)
           end