jsonapi-realizer 4.4.0 → 5.0.0

data/lib/jsonapi/realizer/context.rb

@@ -0,0 +1,8 @@
+module JSONAPI
+  module Realizer
+    module Context
+      extend(ActiveSupport::Concern)
+      include(ActiveModel::Model)
+    end
+  end
+end

data/lib/jsonapi/realizer/controller.rb

@@ -0,0 +1,55 @@
+module JSONAPI
+  module Realizer
+    module Controller
+      private def reject_missing_content_type_header
+        return if request.body.size.zero?
+        return if request.headers.property?("Content-Type")
+
+        raise(JSONAPI::Realizer.configuration.default_missing_content_type_exception)
+      end
+
+      private def reject_invalid_content_type_header
+        reject_missing_content_type_header
+
+        return if request.headers.fetch("Content-Type").include?(JSONAPI::MEDIA_TYPE)
+
+        raise(JSONAPI::Realizer.configuration.default_invalid_content_type_exception)
+      end
+
+      private def reject_missing_root_property
+        return if request.parameters.key?("body")
+        return if request.paremters.key?("errors")
+        return if request.paremters.key?("meta")
+
+        raise(Error::MissingRootProperty)
+      end
+
+      private def reject_invalid_root_property
+        reject_missing_root_property
+
+        return unless request.parameters.key?("data") && (request.parameters.fetch("data").is_a?(Hash) || request.parameters.fetch("data").is_a?(Array))
+        return unless request.parameters.key?("errors") && request.parameters.fetch("errors").is_a?(Array)
+
+        raise(Error::InvalidRootProperty)
+      end
+
+      private def reject_missing_type_property
+        reject_invalid_root_property
+
+        return if request.parameters.fetch("data").is_a?(Hash) && request.parameters.fetch("data").key?("type")
+        return if request.parameters.fetch("data").is_a?(Array) && request.parameters.fetch("data").all? { |data| data.key?("type") }
+
+        raise(Error::MissingDataTypeProperty)
+      end
+
+      private def reject_invalid_type_property
+        reject_missing_type_property
+
+        return if request.parameters.fetch("data").is_a?(Hash) && request.parameters.fetch("data").fetch("type").is_a?(String) && request.parameters.fetch("data").fetch("type").present?
+        return if request.parameters.fetch("data").is_a?(Array) && request.parameters.fetch("data").map {|data| data.fetch("type")}.all? {|type| type.is_a?(String) && type.present? }
+
+        raise(Error::InvalidDataTypeProperty)
+      end
+    end
+  end
+end

data/lib/jsonapi/realizer/error.rb

@@ -1,15 +1,16 @@
 module JSONAPI
   module Realizer
     class Error < StandardError
-      require_relative "error/include_without_data_property"
-      require_relative "error/invalid_accept_header"
-      require_relative "error/invalid_content_type_header"
-      require_relative "error/malformed_data_root_property"
-      require_relative "error/missing_accept_header"
-      require_relative "error/missing_content_type_header"
-      require_relative "error/missing_root_property"
-      require_relative "error/missing_type_resource_property"
-      require_relative "error/duplicate_registration"
+      include(ActiveModel::Model)
+
+      require_relative("error/invalid_content_type_header")
+      require_relative("error/missing_content_type_header")
+      require_relative("error/invalid_root_property")
+      require_relative("error/missing_root_property")
+      require_relative("error/missing_data_type_property")
+      require_relative("error/include_without_data_property")
+      require_relative("error/resource_attribute_not_found")
+      require_relative("error/resource_relationship_not_found")
     end
   end
 end

data/lib/jsonapi/realizer/error/invalid_content_type_header.rb

@@ -2,7 +2,12 @@ module JSONAPI
   module Realizer
     class Error
       class InvalidContentTypeHeader < Error
+        attr_accessor(:given)
+        attr_accessor(:wanted)
 
+        def message
+          "HTTP Content-Type Header recieved is #{given}, but expected #{wanted}"
+        end
       end
     end
   end

data/lib/jsonapi/realizer/error/invalid_data_type_property.rb

@@ -0,0 +1,13 @@
+module JSONAPI
+  module Realizer
+    class Error
+      class InvalidDataTypeProperty < Error
+        attr_accessor(:given)
+
+        def message
+          "root.data property was #{given}, which is not an Hash, Array, or nil"
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/realizer/error/invalid_root_property.rb

@@ -0,0 +1,13 @@
+module JSONAPI
+  module Realizer
+    class Error
+      class InvalidRootProperty < Error
+        attr_accessor(:given)
+
+        def message
+          "root property was #{given}, which is not an Hash"
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/realizer/error/{duplicate_registration.rb → missing_data_type_property.rb}

@@ -1,7 +1,7 @@
 module JSONAPI
   module Realizer
     class Error
-      class DuplicateRegistration < Error
+      class MissingDataTypeProperty < Error
 
       end
     end

data/lib/jsonapi/realizer/error/resource_attribute_not_found.rb

@@ -0,0 +1,14 @@
+module JSONAPI
+  module Realizer
+    class Error
+      class ResourceAttributeNotFound < Error
+        attr_accessor(:name)
+        attr_accessor(:realizer)
+
+        def message
+          "#{realizer} doesn't define the attribute #{name}"
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/realizer/error/resource_relationship_not_found.rb

@@ -0,0 +1,14 @@
+module JSONAPI
+  module Realizer
+    class Error
+      class ResourceRelationshipNotFound < Error
+        attr_accessor(:name)
+        attr_accessor(:realizer)
+
+        def message
+          "#{realizer} doesn't define the relationship #{name}"
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/realizer/resource.rb

@@ -1,127 +1,332 @@
 module JSONAPI
   module Realizer
     module Resource
-      extend ActiveSupport::Concern
+      require_relative("resource/configuration")
+      require_relative("resource/attribute")
+      require_relative("resource/relation")
 
-      attr_reader :model
+      extend(ActiveSupport::Concern)
+      include(ActiveModel::Model)
 
-      def self.register(resource_class:, model_class:, adapter:, type:)
-        @mapping ||= Set.new
-        raise JSONAPI::Realizer::Error::DuplicateRegistration if @mapping.any? { |realizer| realizer.type == type }
-        @mapping << OpenStruct.new({
-          resource_class: resource_class,
-          model_class: model_class,
-          adapter: adapter,
-          type: type.dasherize,
-          attributes: OpenStruct.new({}),
-          relationships: OpenStruct.new({})
-         })
+      MIXIN_HOOK = ->(*) do
+        @attributes = {}
+        @relations = {}
+
+        unless const_defined?("Context")
+          self::Context = Class.new do
+            include(JSONAPI::Realizer::Context)
+
+            def initialize(**keyword_arguments)
+              keyword_arguments.keys.each(&singleton_class.method(:attr_accessor))
+
+              super(**keyword_arguments)
+            end
+          end
+        end
+
+        validates_presence_of(:intent)
+        validates_presence_of(:parameters, :allow_empty => true)
+        validates_presence_of(:headers, :allow_empty => true)
+
+        identifier(JSONAPI::Realizer.configuration.default_identifier)
+
+        has(JSONAPI::Realizer.configuration.default_identifier)
       end
+      private_constant :MIXIN_HOOK
+
+      attr_writer(:intent)
+      attr_accessor(:parameters)
+      attr_accessor(:headers)
+      attr_writer(:context)
+      attr_accessor(:scope)
+
+      def initialize(**keyword_arguments)
+        super(**keyword_arguments)
+
+        context.validate!
+        validate!
 
-      def self.resource_mapping
-        @mapping.index_by(&:resource_class)
+        if filtering?
+          @scope = adapter.filtering(scope, filters)
+        end
+
+        if include?
+          @scope = adapter.include_relationships(scope, includes)
+        end
+
+        if sorting?
+          @scope = adapter.sorting(scope, sorts)
+        end
+
+        if paginate?
+          @scope = adapter.paginate(scope, *pagination)
+        end
+
+        if writing? && data?
+          adapter.write_attributes(object, attributes)
+          adapter.write_relationships(object, relationships)
+        end
       end
 
-      def self.type_mapping
-        @mapping.index_by(&:type)
+      def to_hash
+        @native ||= {
+          :pagination => if paginate? then pagination end,
+          :selects => if selects? then selects end,
+          :includes => if include? then includes end,
+          :object => object
+        }.compact
       end
 
-      def initialize(model)
-        @model = model
+      private def writing?
+        [:create, :update].include?(intent)
       end
 
-      private def attribute(name)
-        attributes.public_send(name.to_sym)
+      def paginate?
+        parameters.key?("page") && (parameters.fetch("page").key?("limit") || parameters.fetch("page").key?("offset"))
       end
 
-      private def relationship(name)
-        relationships.public_send(name.to_sym)
+      def pagination
+        [
+          parameters.fetch("page").fetch("limit", nil),
+          parameters.fetch("page").fetch("offset", nil)
+        ]
       end
 
-      private def attributes
-        configuration.attributes
+      def sorting?
+        parameters.key?("sort")
       end
 
-      private def relationships
-        configuration.relationships
+      def sorts
+        @sorts ||= parameters.
+          # {sort: "name,-age,accounts.created_at,-accounts.updated_at"}
+          fetch("sort").
+          # "name,-age,accounts.created_at,-accounts.updated_at"
+          split(",").
+          # ["name", "-age", "accounts.created_at", "-accounts.updated_at"]
+          map do |token|
+            if token.start_with?("-") then [token.sub(/^-/, "").underscore, "-"] else [token.underscore, "+"] end
+          end.
+          # [["name", "+"], ["age", "-"], ["accounts.created_at", "+"], ["accounts.updated_at", "-"]]
+          map do |(path, direction)|
+            [if path.include?(".") then path.split(".") else [self.class.configuration.type, path] end, direction]
+          end
+          # [[["accounts", "name"], "+"], [["accounts", "age"], "-"], [["accounts", "created_at"], "+"], [["accounts", "updated_at"], "-"]]
       end
 
-      private def model_class
-        configuration.model_class
+      def filtering?
+        parameters.key?("filter")
       end
 
-      private def configuration
-        self.class.configuration
+      def filters
+        @filters ||= parameters.
+          # {"filter" => {"full-name" => "Abby Marquardt", "email" => "amado@goldner.com"}}
+          fetch("filter").
+          # {"full-name" => "Abby Marquardt", "email" => "amado@goldner.com"}
+          transform_keys(&:underscore)
+          # {"full_name" => "Abby Marquardt", "email" => "amado@goldner.com"}
       end
 
-      class_methods do
-        def attribute(name)
-          attributes.public_send(name.to_sym)
-        end
+      def include?
+        parameters.key?("include")
+      end
 
-        def relationship(name)
-          relationships.public_send(name.to_sym)
-        end
+      def includes
+        @includes ||= parameters.
+          # {"include" => "active-photographer.photographs,comments,comments.author"}
+          fetch("include").
+          # "active-photographer.photographs,comments,comments.author"
+          split(/\s*,\s*/).
+          # ["active-photographer.photographs", "comments", "comments.author"]
+          map {|chain| chain.split(".")}.
+          # [["active-photographer", "photographs"], ["comments"], ["comments", "author"]]
+          map {|list| list.map(&:underscore)}.
+          # [["active_photographer", "photographs"], ["comments"], ["comments", "author"]]
+          map do |relationship_chain|
+            # This walks down the path of relationships and normalizes thenm to
+            # their defined "as", which lets us expose AccountRealizer#name, but that actually
+            # references Account#full_name.
+            relationship_chain.reduce([[], self.class]) do |(normalized_relationship_chain, realizer_class), relationship_link|
+              [
+                [
+                  *normalized_relationship_chain,
+                  realizer_class.relation(relationship_link).as
+                ],
+                realizer_class.relation(relationship_link).realizer_class
+              ]
+            end.first
+          end
+          # [["account", "photographs"], ["comments"], ["comments", "account"]]
+      end
 
-        def valid_attribute?(name, value)
-          attributes.respond_to?(name.to_sym)
-        end
+      def selects?
+        parameters.key?("fields")
+      end
 
-        def valid_relationship?(name, value)
-          relationships.respond_to?(name.to_sym)
-        end
+      def selects
+        @selects ||= parameters.
+          # {"fields" => {"articles" => "title,body,sub-text", "people" => "name"}}
+          fetch("fields").
+          # {"articles" => "title,body,sub-text", "people" => "name"}
+          transform_keys(&:underscore).
+          # {"articles" => "title,body,sub-text", "people" => "name"}
+          transform_values {|value| value.split(/\s*,\s*/)}.
+          # {"articles" => ["title", "body", "sub-text"], "people" => ["name"]}
+          transform_values {|value| value.map(&:underscore)}
+          # {"articles" => ["title", "body", "sub_text"], "people" => ["name"]}
+      end
+
+      private def data?
+        parameters.key?("data")
+      end
+
+      private def data
+        @data ||= parameters.fetch("data")
+      end
+
+      private def type
+        return unless data.key?("type")
+
+        @type ||= data.fetch("type")
+      end
+
+      def attributes
+        return unless data.key?("attributes")
+
+        @attributes ||= data.
+          fetch("attributes").
+          transform_keys(&:underscore).
+          transform_keys{|key| attribute(key).as}
+      end
+
+      def relationships
+        return unless data.key?("relationships")
 
-        def valid_sparse_field?(name)
-          attribute(name).selectable if attribute(name)
+        @relationships ||= data.
+          fetch("relationships").
+          transform_keys(&:underscore).
+          map(&method(:as_relationship)).to_h.
+          transform_keys{|key| relation(key).as}
+      end
+
+      private def scope
+        @scope ||= adapter.find_many(@scope || model_class)
+      end
+
+      def object
+        @object ||= case intent
+        when :create
+          scope.new
+        when :show, :update, :destroy
+          adapter.find_one(scope, parameters.fetch("id"))
+        else
+          scope
         end
+      end
 
-        def valid_includes?(name)
-          relationship(name).includable if relationship(name)
+      def intent
+        @intent.to_sym
+      end
+
+      private def as_relationship(name, value)
+        data = value.fetch("data")
+
+        relation_configuration = relation(name).realizer_class.configuration
+
+        if data.is_a?(Array)
+          [name, relation_configuration.adapter.find_many(relation_configuration.model_class, {id: data.map {|value| value.fetch("id")}})]
+        else
+          [name, relation_configuration.adapter.find_one(relation_configuration.model_class, data.fetch("id"))]
         end
+      end
 
-        def has(name, selectable: true)
-          attributes.public_send("#{name}=", OpenStruct.new({name: name, selectable: selectable}))
+      private def attribute(name)
+        self.class.attribute(name)
+      end
+
+      private def relation(name)
+        self.class.relation(name)
+      end
+
+      private def adapter
+        self.class.configuration.adapter
+      end
+
+      private def model_class
+        self.class.configuration.model_class
+      end
+
+      def context
+        self.class.const_get("Context").new(**@context || {})
+      end
+
+      included do
+        class_eval(&MIXIN_HOOK) unless @abstract_class
+      end
+
+      class_methods do
+        def inherited(object)
+          object.class_eval(&MIXIN_HOOK) unless object.instance_variable_defined?(:@abstract_class)
         end
 
-        def has_related(name, as: name, includable: true)
-          relationships.public_send("#{name}=", OpenStruct.new({name: name, as: as, includable: includable}))
+        def identifier(value)
+          @identifier ||= value.to_sym
         end
 
-        def has_one(name, as: name.to_s.pluralize.dasherize, includable: true)
-          has_related(name, as: as.to_s.dasherize, includable: includable)
+        def type(value, class_name:, adapter:)
+          @type ||= value.to_s
+          @model_class ||= class_name.constantize
+          @adapter ||= JSONAPI::Realizer::Adapter.new(interface: adapter)
         end
 
-        def has_many(name, as: name.to_s.dasherize, includable: true)
-          has_related(name, as: as.to_s.dasherize, includable: includable)
+        def has(name, as: name)
+          @attributes[name] ||= Attribute.new(
+            :name => name,
+            :as => as,
+            :owner => self
+          )
         end
 
-        def adapter
-          configuration.adapter
+        def has_one(name, as: name, class_name:)
+          @relations[name] ||= Relation.new(
+            :owner => self,
+            :type => :one,
+            :name => name,
+            :as => as,
+            :realizer_class_name => class_name
+          )
         end
 
-        def attributes
-          configuration.attributes
+        def has_many(name, as: name, class_name:)
+          @relations[name] ||= Relation.new(
+            :owner => self,
+            :type => :many,
+            :name => name,
+            :as => as,
+            :realizer_class_name => class_name
+          )
         end
 
-        def relationships
-          configuration.relationships
+        def context
+          const_get("Context")
         end
 
-        def model_class
-          configuration.model_class
+        def configuration
+          @configuration ||= Configuration.new({
+            :owner => self,
+            :type => @type,
+            :model_class => @model_class,
+            :adapter => @adapter,
+            :attributes => @attributes,
+            :relations => @relations
+          })
         end
 
-        def register(type, class_name:, adapter:)
-          JSONAPI::Realizer::Resource.register(
-            resource_class: self,
-            model_class: class_name.constantize,
-            adapter: JSONAPI::Realizer::Adapter.new(adapter),
-            type: type.to_s
-          )
+        def attribute(name)
+          configuration.attributes.fetch(name.to_sym){raise(Error::ResourceRelationshipNotFound, name: name, realizer: self)}
         end
 
-        def configuration
-          JSONAPI::Realizer::Resource.resource_mapping.fetch(self)
+        def relation(name)
+          configuration.relations.fetch(name.to_sym){raise(Error::ResourceRelationshipNotFound, name: name, realizer: self)}
         end
       end
     end