easy-jsonapi 1.0.0

data/lib/easy/jsonapi/field.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'easy/jsonapi/item'
+
+module JSONAPI
+  # Field is the name of key value pair
+  class Field < JSONAPI::Item
+
+    # @param name [String]  The name of the field
+    # @param type [String | nil] The type of the field
+    def initialize(name, type: String)
+      super({ name: name.to_s, type: type })
+    end
+
+    # @return [String] The Field's name
+    def name
+      @item[:name]
+    end
+
+    # @raise RunTimeError You shoulddn't be able to update the name of a
+    #   Resource::Field
+    def name=(_)
+      raise 'Cannot change the name of a Resource::Field'
+    end
+
+    # @return [Object] The type of the field
+    def type
+      @item[:type]
+    end
+
+    # @param new_type [Object] The new type of field.
+    def type=(new_type)
+      @item[:type] = new_type
+    end
+
+    # @return [String] The name of the field.
+    def to_s
+      name
+    end
+
+    private :method_missing, :item, :item=
+  end
+end

data/lib/easy/jsonapi/header_collection.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'easy/jsonapi/name_value_pair_collection'
+
+module JSONAPI
+  # header_collection # { include: Include, sort: Sort, filter: Filter } 
+  class HeaderCollection < JSONAPI::NameValuePairCollection
+    
+    # Initialize as empty if a array of Header objects not passed to it.
+    # @param header_arr [JSONAPI::HeaderCollection::Header] The array of Header objects that can be used to init
+    #   a Header collection
+    # @return JSONAPI::HeaderCollection
+    def initialize(header_arr = [])
+      super(header_arr, item_type: JSONAPI::HeaderCollection::Header)
+    end
+
+    # Add a header to the collection. (CASE-INSENSITIVE).
+    # @param header [JSONAPI::HeaderCollection::Header] The header to add
+    def add(header)
+      super(header) { |hdr| hdr.name.downcase.gsub(/-/, '_') }
+    end
+
+    # Call super's get but make it case insensitive
+    # @param key [Symbol] The hash key associated with a header
+    def get(key)
+      super(key.to_s.downcase.gsub(/-/, '_'))
+    end
+
+    # #empyt? provided by super
+    # #include provided by super
+    # add provided by super
+    # #each provided from super
+    # #remove provided from super
+    # #keys provided by super
+    # #size provided by super
+
+  end  
+end

data/lib/easy/jsonapi/header_collection/header.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'easy/jsonapi/header_collection'
+
+module JSONAPI
+  class HeaderCollection
+    # A http request or response header
+    class Header < JSONAPI::NameValuePair
+    end
+  end
+end

data/lib/easy/jsonapi/item.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module JSONAPI
+
+  # Models a Item's key -> value relationship
+  class Item
+
+    # @return the value of an Item
+    attr_accessor :item
+    
+    # Able to take a hash and dynamically create instance variables using the hash keys
+    #   Ex: obj == { :name => 'fields', :value => {'articles' => 'title,body,author', 'people' => 'name' }}
+    # @param obj [Object] Can be anything, but if a hash is provided, dynamic instance variable can be created
+    #   upon trying to access them.
+    def initialize(obj)
+      if obj.is_a? Hash
+        ensure_keys_are_sym(obj)
+      end
+      @item = obj
+    end
+
+    # A special to_string method if @item is a hash.
+    def to_s
+      return @item.to_s unless @item.is_a? Hash
+      tr = '{ '
+      first = true
+      @item.each do |k, v|
+        if first
+          first = false
+          tr += "\"#{k}\": \"#{v}\", "
+        else
+          tr += "\"#{k}\": \"#{v}\""
+        end
+      end
+      tr += ' }'
+    end
+
+    # Represent item as a hash
+    def to_h
+      @item.to_h
+    end
+
+    private
+
+    # Only used if implementing Item directly.
+    #   dynamically creates accessor methods for instance variables
+    #   created in the initialize
+    def method_missing(method_name, *args, &block)
+      return super unless is_a? JSONAPI::Item
+      return super unless @item.is_a? Hash
+      if should_update_var?(method_name)
+        @item[method_name[..-2].to_sym] = args[0]
+      elsif should_get_var?(method_name)
+        @item[method_name]
+      else
+        super
+      end
+    end
+
+    # Needed when using #method_missing
+    def respond_to_missing?(method_name, *args)
+      instance_variables.include?("@#{method_name}".to_sym) || super
+    end
+
+    # Ensures that hash keys are symbol (and not String) when passing a hash to item.
+    # @param obj [Object]  A hash that can represent an item.
+    def ensure_keys_are_sym(obj)
+      obj.each_key do |k|
+        raise "All keys must be Symbols. '#{k}' was #{k.class}" unless k.is_a? Symbol
+      end
+    end
+    
+    # Checks to see if the method name has a '=' at the end and if the 
+    #   prefix before the '=' has the same name as an existing instance
+    #   variable.
+    # @param (see #method_missing)
+    def should_update_var?(method_name)
+      method_name.to_s[-1] == '=' && @item[method_name[..-2].to_sym].nil? == false
+    end
+    
+    # Checks to see if the method has the same name as an existing instance
+    #   variable
+    # @param (see #method_missing)
+    def should_get_var?(method_name)
+      @item[method_name].nil? == false
+    end
+  end
+end

data/lib/easy/jsonapi/middleware.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'easy/jsonapi/exceptions'
+require 'easy/jsonapi/config_manager'
+require 'oj'
+
+module JSONAPI
+
+  # The middleware of the gem and also the contact point between the
+  # the gem and the rack application using it
+  class Middleware
+    # @param app The Rack Application
+    def initialize(app, &block)
+      @app = app
+      return unless block_given?
+
+      @config_manager = JSONAPI::ConfigManager.new
+      block.call(@config_manager)
+    end
+
+    # If not in maintenance_mode and the request is intended to be JSONAPI, 
+    #   it checks headers, params, and body it for compliance and raises
+    #   and error if any section is found to be non-compliant.
+    # @param env The rack envirornment hash
+    def call(env)
+      if in_maintenance_mode?(env)
+        return maintenance_response(env)
+      end
+
+      if jsonapi_request?(env)
+        error_response = check_compliance(env, @config_manager)
+        return error_response unless error_response.nil?
+      end
+
+      @app.call(env)
+    end
+
+    private
+
+    # Checks the 'MAINTENANCE' environment variable
+    # @param (see #call)
+    # @return [TrueClass | FalseClass]
+    def in_maintenance_mode?(env)
+      !env['MAINTENANCE'].nil?
+    end
+
+    # Return 503 with or without msg depending on environment
+    # @param (see #call)
+    # @return [Array] Http Error Responses
+    def maintenance_response(env)
+      if environment_development?(env)
+        [503, {}, ['MAINTENANCE envirornment variable set']]
+      else
+        [503, {}, []]
+      end
+    end
+
+    # If the Content-type or Accept header values include the JSON:API media type without media 
+    #   parameters, then it is a jsonapi request.
+    # @param (see #call)
+    def jsonapi_request?(env)
+      accept_header_jsonapi?(env) || content_type_header_jsonapi?(env)
+    end
+
+    # Determines whether the request is JSONAPI or not by looking at
+    #   the ACCEPT header.
+    # @env (see #call)
+    # @return [TrueClass | FalseClass] Whether or not the request is JSONAPI
+    def accept_header_jsonapi?(env)
+      return true if env['HTTP_ACCEPT'].nil? # no header means assume any
+
+      env['HTTP_ACCEPT'].split(',').any? do |hdr|
+        ['application/vnd.api+json', '*/*', 'application/*'].include?(hdr.split(';').first)
+      end
+    end
+
+    # Determines whether there is a request body, and whether the Content-Type is jsonapi compliant.
+    # @param (see #call)
+    # @return [TrueClass | FalseClass] Whether the document body is supposed to be jsonapi
+    def content_type_header_jsonapi?(env)
+      return false unless env['CONTENT_TYPE']
+
+      env['CONTENT_TYPE'].include? 'application/vnd.api+json'
+    end
+
+    # Checks whether the request is JSON:API compliant and raises an error if not.
+    # @param env (see #call)
+    # @param config_manager [JSONAPI::ConfigManager::Config] The config object to use modify compliance checking
+    # @return [NilClass | Array] Nil meaning no error or a 400 level http response
+    def check_compliance(env, config_manager)
+      opts = { http_method: env['REQUEST_METHOD'], path: env['PATH_INFO'] }
+
+      header_error = check_headers_compliance(env, config_manager, opts)
+      return header_error unless header_error.nil?
+
+      req = Rack::Request.new(env)
+      param_error = check_query_param_compliance(env, req.GET, config_manager, opts)
+      return param_error unless param_error.nil?
+      
+      return unless env['CONTENT_TYPE']
+
+      body_error = check_req_body_compliance(env, config_manager, opts)
+      return body_error unless body_error.nil?
+    end
+
+    # Checks whether the http headers are jsonapi compliant
+    # @param (see #call)
+    # @return [NilClass | Array] Nil meaning no error or a 400 level http response
+    def check_headers_compliance(env, config_manager, opts)
+      JSONAPI::Exceptions::HeadersExceptions.check_request(env, config_manager, opts)
+    rescue JSONAPI::Exceptions::HeadersExceptions::InvalidHeader || JSONAPI::Exceptions::UserDefinedExceptions::InvalidHeader => e
+      raise if environment_development?(env)
+
+      [e.status_code, {}, []]
+    end
+
+    # @param query_params [Hash] The rack request query_param hash
+    # @raise If the query parameters are not JSONAPI compliant
+    # @return [NilClass | Array] Nil meaning no error or a 400 level http response
+    def check_query_param_compliance(env, query_params, config_manager, opts)
+      JSONAPI::Exceptions::QueryParamsExceptions.check_compliance(query_params, config_manager, opts)
+    rescue JSONAPI::Exceptions::QueryParamsExceptions::InvalidQueryParameter || JSONAPI::Exceptions::UserDefinedExceptions::InvalidQueryParam => e
+      raise if environment_development?(env)
+      
+      [e.status_code, {}, []]
+    end
+
+    # @param env (see #call)
+    # @param req (see #check_query_param_compliance)
+    # @raise If the document body is not JSONAPI compliant
+    def check_req_body_compliance(env, config_manager, opts)
+      # Store separately so you can rewind for next middleware or app
+      body = env['rack.input'].read
+      env['rack.input'].rewind
+      JSONAPI::Exceptions::DocumentExceptions.check_compliance(body, config_manager, opts)
+    rescue JSONAPI::Exceptions::DocumentExceptions::InvalidDocument || JSONAPI::Exceptions::UserDefinedExceptions::InvalidDocument => e
+      raise if environment_development?(env)
+
+      [e.status_code, {}, []]
+    rescue Oj::ParseError
+      raise if environment_development?(env)
+
+      [400, {}, []]
+    end
+
+    # @param (see #call)
+    def post_put_or_patch?(env)
+      env['REQUEST_METHOD'] == 'POST' ||
+        env['REQUEST_METHOD'] == 'PATCH' ||
+        env['REQUEST_METHOD'] == 'PUT'
+    end
+
+    # @param (see #call)
+    def environment_development?(env)
+      env['RACK_ENV'].to_s.downcase == 'development' || env['RACK_ENV'].nil?
+    end
+  end
+end

data/lib/easy/jsonapi/name_value_pair.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'easy/jsonapi/item'
+require 'easy/jsonapi/utility'
+
+module JSONAPI
+  # A generic name->value query pair
+  class NameValuePair < JSONAPI::Item
+    
+    # @param name The name of the pair
+    # @param value The value of the pair
+    def initialize(name, value)
+      name = name.to_s.gsub('-', '_')
+      super({ name: name.to_s, value: value })
+    end
+
+    # @return [String] The name of the name->val pair
+    def name
+      @item[:name]
+    end
+
+    # @raise RunTimeError You shouldn't be able to update the name of a
+    #   NameValuePair
+    def name=(_)
+      raise 'Cannot change the name of NameValuePair Objects'
+    end
+
+    # @return [String] The value of the name->val pair
+    def value
+      @item[:value]
+    end
+
+    # @param new_value [String | Symbol]  The name->val pair value
+    def value=(new_value)
+      @item[:value] = new_value
+    end
+
+    # Represents a pair as a string
+    def to_s
+      v = value
+      val_str = case v
+                when Array
+                  val_str = '['
+                  first = true
+                  v.each do |val|
+                    if first
+                      val_str += "\"#{val}\""
+                      first = false
+                    else
+                      val_str += ", \"#{val}\""
+                    end
+                  end
+                  val_str += ']'
+                when String
+                  "\"#{v}\""
+                when JSONAPI::NameValuePair
+                  "{ #{v} }"
+                else
+                  v
+                end
+      "\"#{name}\": #{val_str}"
+    end
+
+    # Represents a pair as a hash
+    def to_h
+      { name.to_sym => JSONAPI::Utility.to_h_value(value) }
+    end
+
+    # prevent users and sublcasses from accessing Parent's #method_missing
+    private :method_missing, :item, :item=
+  end
+end

data/lib/easy/jsonapi/name_value_pair_collection.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'easy/jsonapi/collection'
+require 'easy/jsonapi/name_value_pair'
+require 'easy/jsonapi/utility'
+
+module JSONAPI
+  
+  # Collection of Items that all have names and values.
+  class NameValuePairCollection < JSONAPI::Collection
+
+    # Creates an empty collection by default
+    # @param pair_arr [Array<JSONAPI::NameValuePair>] The pairs to be initialized with.
+    def initialize(pair_arr = [], item_type: JSONAPI::NameValuePair, &block)
+      if block_given?
+        super(pair_arr, item_type: item_type, &block)
+      else
+        super(pair_arr, item_type: item_type, &:name)
+      end
+    end
+
+    # #empyt? provided by super
+    # #include provided by super
+
+    # Add a pair to the collection. (CASE-SENSITIVE)
+    # @param pair [JSONAPI::NameValuePair] The pair to add
+    def add(pair, &block)
+      if block_given?
+        super(pair, &block)
+      else
+        super(pair, &:name)
+      end
+    end
+
+    # Another way to add a query_param
+    # @oaram (see #add)
+    def <<(pair, &block)
+      add(pair, &block)
+    end
+
+    # #each provided from super
+    # #remove provided from super
+    # #get provided by super
+    # #keys provided by super
+    # #size provided by super
+
+    # Represent the collection as a string
+    # @return [String] The representation of the collection
+    def to_s
+      JSONAPI::Utility.to_string_collection(self, pre_string: '{ ', post_string: ' }')
+    end
+
+    # Represent the collection as a hash
+    # @return [Hash] The representation of the collection
+    def to_h
+      JSONAPI::Utility.to_h_collection(self)
+    end
+
+    protected :insert
+
+    private
+
+    # Gets the NameValuePair object value whose name matches the method_name called
+    # @param method_name [Symbol] The name of the method called
+    # @param args If any arguments were passed to the method called
+    # @param block If a block was passed to the method called
+    def method_missing(method_name, *args, &block)
+      super unless include?(method_name)
+      get(method_name).value
+    end
+
+    # Whether or not method missing should be called.
+    def respond_to_missing?(method_name, *)
+      include?(method_name) || super
+    end
+
+  end
+end