jsonapi_helpers 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e0943785b54133ddee5a1597e8f83ebb2336bd1
-  data.tar.gz: 456c0ab8c77f0db5c3f70d6d658179218ac39838
+  metadata.gz: e7c7204fad99ba81fb2677c0bcaf99655ca3991b
+  data.tar.gz: a2e3a050fee11dea4c56c4caa8f51602204db2c0
 SHA512:
-  metadata.gz: bee0ed026e233e84b95ccc18b64c5a0f0a851e0c29c85d32ed50286beec3433d12b74918d99b74be8971fe5bee419bf280e897684dc6bb16259262d2560b6da3
-  data.tar.gz: 3df19149d25c943a0ae7c0242ded7d08ebea0053a82d25f9f8326955b646ca65db1ca72a61dd658958118aae425aa253db9c9a0e2cef2f8767c18c9933087052
+  metadata.gz: 3b6897227e38470925b03f6d5747556abee220ddaf689b1345795d06e25117cd70df3ee507b158be04d20ee4378cdeca4f24b79e60a1cff57c59ee9f707c96cc
+  data.tar.gz: 4a866970c77fe525ee3486b6180353cd867fc8d31654202cff3eaba0f893666bc45907c4c8f351c5a147ea61de7438bdf0ed1709f8faa9e2cc4353f0980f27ae

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+.byebug_history

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jsonapi_helpers.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/jsonapi_helpers.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jsonapi_helpers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'jsonapi_helpers'
+  spec.version       = JSONAPIHelpers::VERSION
+  spec.authors       = ['Jacob Burenstam']
+  spec.email         = ['burenstam@gmail.com']
+
+  spec.summary       = 'A set of helpers for generating JSON API compliant responses.'
+  spec.description   = 'A set of helpers for generating JSON API compliant responses with together with the active_model_serializers gem.' # rubocop:disable Metrics/LineLength
+  spec.homepage      = 'https://github.com/buren/jsonapi_helpers'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport', '>= 4.2'
+
+  spec.add_development_dependency 'active_model_serializers', '~> 0.10'
+  spec.add_development_dependency 'activemodel', '>= 4.2'
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'byebug', '~> 9.0'
+end

data/lib/jsonapi_helpers.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/json'
+
+# Local requires
+require 'jsonapi_helpers/version'
+
+require 'jsonapi_helpers/support/key_transform'
+require 'jsonapi_helpers/support/string_support'
+
+require 'jsonapi_helpers/serializers/deserializer'
+require 'jsonapi_helpers/serializers/model'
+require 'jsonapi_helpers/serializers/model_error'
+require 'jsonapi_helpers/serializers/data'
+require 'jsonapi_helpers/serializers/datum'
+require 'jsonapi_helpers/serializers/error'
+require 'jsonapi_helpers/serializers/errors'
+
+require 'jsonapi_helpers/params/fields'
+require 'jsonapi_helpers/params/filter'
+require 'jsonapi_helpers/params/includes'
+require 'jsonapi_helpers/params/sort'
+
+module JSONAPIHelpers
+  class << self
+    attr_accessor :config
+  end
+
+  def self.configure
+    self.config ||= Configuration.new
+    block_given? ? yield(config) : config
+    config
+  end
+
+  class Configuration
+    KEY_TRANSFORMS = %i(dash camel camel_lower underscore unaltered).freeze
+
+    attr_reader :key_transform
+    attr_writer :deserializer_klass, :params_klass
+
+    def initialize
+      @key_transform = :unaltered
+      @deserializer_klass = nil
+      @params_klass = nil
+    end
+
+    def key_transform=(key_transform)
+      type = key_transform.to_sym
+      unknown_key_transform!(type) unless KEY_TRANSFORMS.include?(type)
+
+      @key_transform = type
+    end
+
+    def deserializer_klass
+      @deserializer_klass || fail('deserializer_klass must be set, e.g: ActiveModelSerializers::Deserialization') # rubocop:disable Metrics/LineLength
+    end
+
+    def params_klass
+      @params_klass || fail('params_klass must be set, e.g: ActionController::Parameters')
+    end
+
+    private
+
+    def unknown_key_transform!(type)
+      types = KEY_TRANSFORMS.join(', ')
+      fail(ArgumentError, "Unknown key transform type '#{type}', known types: #{types}")
+    end
+  end
+end

data/lib/jsonapi_helpers/params/fields.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module JSONAPIHelpers
+  module Params
+    class Fields
+      attr_reader :fields_params
+
+      def initialize(fields_params)
+        @fields_params = {}
+        (fields_params || {}).each do |model_name, value|
+          @fields_params[model_name] = value.split(',').map do |name|
+            StringSupport.underscore(name.strip)
+          end
+        end
+      end
+
+      def to_h
+        fields_params
+      end
+    end
+  end
+end

data/lib/jsonapi_helpers/params/filter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module JSONAPIHelpers
+  module Params
+    module Filter
+      def self.build(filters, allowed, transform = {})
+        return {} if filters.nil? || filters.is_a?(String)
+
+        filtered = {}
+        filters.each do |key, value|
+          key_sym = StringSupport.underscore(key).to_sym
+          if allowed.include?(key_sym)
+            filtered[key_sym] = format_value(value, transform[key_sym])
+          end
+        end
+        filtered
+      end
+
+      def self.format_value(value, type)
+        case type
+        when :date_range
+          format_date_range(value)
+        else
+          value
+        end
+      end
+
+      def self.format_date_range(value)
+        date_parts = value.split('..')
+        start = _parse_date_string(date_parts.first)
+        finish = _parse_date_string(date_parts.last)
+        start..finish
+      rescue ArgumentError
+        nil
+      end
+
+      def self._parse_date_string(string)
+        Date.parse(string, false)
+      end
+    end
+  end
+end

data/lib/jsonapi_helpers/params/includes.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module JSONAPIHelpers
+  module Params
+    class Includes
+      attr_reader :include_param
+
+      def initialize(include_param)
+        @include_param = StringSupport.underscore(include_param || '')
+      end
+
+      def permit(*permitted_includes)
+        include_array = include_param.split(',')
+        include_array & permitted_includes.flatten(1)
+      end
+    end
+  end
+end

data/lib/jsonapi_helpers/params/sort.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module JSONAPIHelpers
+  module Params
+    module Sort
+      def self.build(sort, allowed, default)
+        allowed = allowed.map(&:to_s)
+        fields = sort.to_s.split(',')
+
+        ordered_fields = convert_to_ordered_hash(fields)
+        filtered_fields = ordered_fields.select { |key, _value| allowed.include?(key) }
+        filtered_fields.empty? ? default : filtered_fields
+      end
+
+      def self.convert_to_ordered_hash(fields)
+        fields.each_with_object({}) do |field, hash|
+          if field.start_with?('-')
+            field = StringSupport.underscore(field[1..-1])
+            hash[field] = :desc
+          else
+            hash[StringSupport.underscore(field)] = :asc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_helpers/serializers/data.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/keys'
+require 'jsonapi_helpers/serializers/relationships'
+
+module JSONAPIHelpers
+  module Serializers
+    class Data
+      def initialize(
+        id:,
+        type:,
+        attributes: {},
+        meta: {},
+        relationships: nil,
+        key_transform: JSONAPIHelpers.config.key_transform
+      )
+        @id = id
+        @type = type
+        @attributes = attributes
+        @meta = meta
+        @relationships = relationships
+        @key_transform = key_transform
+      end
+
+      def to_h(shallow: false)
+        data = {
+          id: @id,
+          type: KeyTransform.call(@type.to_s, key_transform: @key_transform),
+          attributes: KeyTransform.call(@attributes, key_transform: @key_transform)
+        }
+
+        if @relationships
+          data[:relationships] = KeyTransform.call(
+            @relationships.to_h,
+            key_transform: @key_transform
+          )
+        end
+
+        if shallow
+          data
+        else
+          { data: data, meta: @meta }
+        end
+      end
+
+      # Rails is awkward and calls #to_json with a context argument
+      # NOTE: Rails only method Hash#to_json
+      def to_json(_context = nil)
+        to_h.to_json
+      end
+    end
+  end
+end

data/lib/jsonapi_helpers/serializers/datum.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module JSONAPIHelpers
+  module Serializers
+    class Datum
+      def initialize(jsonapi_datums)
+        @datums = jsonapi_datums
+      end
+
+      def to_h
+        {
+          data: @datums.map { |data| data.to_h(shallow: true) },
+          meta: {
+            total: @datums.length
+          }
+        }
+      end
+
+      # Rails is awkward and calls #to_json with a context argument
+      # NOTE: Rails only method Hash#to_json
+      def to_json(_context = nil)
+        to_h.to_json
+      end
+    end
+  end
+end

data/lib/jsonapi_helpers/serializers/deserializer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module JSONAPIHelpers
+  module Serializers
+    module Deserializer
+      def self.parse(params)
+        # Parse the params hash and "flatten" the structure
+        parsed_params = JSONAPIHelpers.config.deserializer_klass.jsonapi_parse(params)
+        # Pass the hash to a params klass where normal whitelisting of params can be made
+        JSONAPIHelpers.config.params_klass.new(parsed_params || {})
+      end
+    end
+  end
+end

data/lib/jsonapi_helpers/serializers/error.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module JSONAPIHelpers
+  module Serializers
+    class Error
+      attr_reader :status, :detail, :code
+
+      def initialize(
+        detail:,
+        status: 422,
+        code: nil,
+        pointer: nil,
+        attribute: nil,
+        key_transform: JSONAPIHelpers.config.key_transform
+      )
+        @status = status
+        @detail = detail
+        @pointer = pointer(
+          pointer: pointer,
+          attribute: attribute,
+          key_transform: key_transform
+        )
+        @code = code
+      end
+
+      def to_h
+        response = { status: @status, detail: @detail }
+        response[:code] = @code unless @code.nil?
+        response.merge!(@pointer)
+      end
+
+      private
+
+      def pointer(pointer:, attribute:, key_transform:)
+        return {} if pointer.nil? && attribute.nil?
+
+        full_pointer = if pointer
+                         pointer
+                       else
+                         attribute_pointer(attribute, key_transform: key_transform)
+                       end
+        {
+          source: {
+            pointer: full_pointer
+          }
+        }
+      end
+
+      def attribute_pointer(attribute, key_transform:)
+        attribute_name = KeyTransform.call(attribute.to_s, key_transform: key_transform)
+        "/data/attributes/#{attribute_name}"
+      end
+    end
+  end
+end

data/lib/jsonapi_helpers/serializers/errors.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module JSONAPIHelpers
+  module Serializers
+    class Errors
+      include Enumerable
+
+      def initialize
+        @errors = []
+      end
+
+      def add(**args)
+        @errors << Error.new(**args)
+      end
+
+      def each(&block)
+        @errors.each(&block)
+      end
+
+      def length
+        @errors.length
+      end
+      alias_method :size, :length
+
+      def to_h
+        { errors: @errors.map(&:to_h) }
+      end
+
+      # Rails is awkward and calls #to_json with a context argument
+      # NOTE: Rails only method Hash#to_json
+      def to_json(_context = nil)
+        to_h.to_json
+      end
+    end
+  end
+end

data/lib/jsonapi_helpers/serializers/model.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'jsonapi_helpers/action_dispatch_request_wrapper'
+
+module JSONAPIHelpers
+  module Serializers
+    class Model
+      attr_reader :serializer, :included, :fields, :current_user, :current_language, :model_scope, :meta, :request, :key_transform # rubocop:disable Metrics/LineLength
+
+      def self.serialize(*args)
+        new(*args).serialize
+      end
+
+      # private
+
+      def initialize(
+        model_scope,
+        included: [],
+        fields: {},
+        current_user: nil,
+        current_language: nil,
+        meta: {},
+        request: nil,
+        key_transform: JSONAPIHelpers.config.key_transform
+      )
+        @model_scope = model_scope
+        @included = included
+        @fields = fields
+        @meta = meta
+        @current_user = current_user
+        @current_language = current_language
+        @key_transform = key_transform
+        # NOTE: ActiveModel::Serializer#serializer_for is from active_model_serializers
+        @serializer = ActiveModel::Serializer.serializer_for(model_scope)
+        @request = ActionDispatchRequestWrapper.new(request)
+      end
+
+      def serializer_instance
+        serializer_options = {
+          scope: {
+            current_user: current_user,
+            current_language: current_language,
+            current_language_id: current_language&.id
+          }
+        }
+
+        if @model_scope.respond_to?(:to_ary)
+          serializer_options[:each_serializer] = serializer
+        end
+
+        serializer.new(@model_scope, serializer_options)
+      end
+
+      def serialize
+        # NOTE: ActiveModelSerializers::Adapter#create is from active_model_serializers
+        ActiveModelSerializers::Adapter.create(
+          serializer_instance,
+          key_transform: key_transform,
+          include: included,
+          fields: fields,
+          meta: meta,
+          serialization_context: request
+        )
+      end
+    end
+  end
+end

data/lib/jsonapi_helpers/serializers/model_error.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module JSONAPIHelpers
+  module Serializers
+    module ModelError
+      KNOWN_ERROR_TYPES = Set.new(%i(
+                                    accepted
+                                    blank
+                                    confirmation
+                                    empty
+                                    equal_to
+                                    even
+                                    exclusion
+                                    greater_than
+                                    greater_than_or_equal_to
+                                    inclusion
+                                    invalid
+                                    less_than
+                                    less_than_or_equal_to
+                                    not_a_number
+                                    not_an_integer
+                                    odd
+                                    other_than
+                                    present
+                                    required
+                                    taken
+                                    too_long
+                                    too_short
+                                    wrong_length
+                                  )).freeze
+
+      def self.serialize(model, key_transform: JSONAPIHelpers.config.key_transform)
+        model.errors.details.flat_map do |field, errors|
+          errors.map do |error|
+            attribute_name = KeyTransform.call(field.to_s, key_transform: key_transform)
+
+            {
+              status: 422,
+              source: { pointer: "/data/attributes/#{attribute_name}" },
+              detail: error_message_for(model.errors, field, error),
+              meta: error_meta_for(error)
+            }
+          end
+        end
+      end
+
+      def self.error_message_for(model_errors, field, error)
+        message = error.fetch(:error)
+        return message if message.is_a?(String) # expects it to already be translated
+
+        model_errors.generate_message(field, message, count: error[:count])
+      end
+
+      def self.error_meta_for(error)
+        meta = {
+          type: error_type_for(error.fetch(:error))
+        }
+        meta[:count] = error[:count] if error[:count]
+        meta[:value] = error[:value] if error[:value]
+        meta
+      end
+
+      def self.error_type_for(error_type)
+        return error_type if KNOWN_ERROR_TYPES.include?(error_type)
+        :invalid
+      end
+    end
+  end
+end

data/lib/jsonapi_helpers/serializers/relationships.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/keys'
+
+module JSONAPIHelpers
+  module Serializers
+    class Relationships
+      def initialize
+        @relationships = {}
+      end
+
+      def add(relation:, id:, type:)
+        @relationships[relation] = { id: id, type: type }
+      end
+
+      def to_h
+        @relationships
+      end
+
+      # Rails is awkward and calls #to_json with a context argument
+      # NOTE: Rails only method Hash#to_json
+      def to_json(_context = nil)
+        to_h.to_json
+      end
+    end
+  end
+end

data/lib/jsonapi_helpers/support/key_transform.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/hash/keys'
+
+# Slightly modified from https://github.com/rails-api/active_model_serializers/blob/a1826186e556b4aa6cbe2a2588df8b2186e06252/lib/active_model_serializers/key_transform.rb
+module JSONAPIHelpers
+  module KeyTransform
+    module_function
+
+    def call(object, key_transform: nil)
+      key_transform ||= JSONAPIHelpers.config.key_transform
+      public_send(key_transform, object)
+    end
+
+    # Transforms values to UpperCamelCase or PascalCase.
+    #
+    # @example:
+    #    "some_key" => "SomeKey",
+    def camel(value)
+      case value
+      when Hash then value.deep_transform_keys! { |key| camel(key) }
+      when Symbol then camel(value.to_s).to_sym
+      when String then StringSupport.camel(value)
+      else value
+      end
+    end
+
+    # Transforms values to camelCase.
+    #
+    # @example:
+    #    "some_key" => "someKey",
+    def camel_lower(value)
+      case value
+      when Hash then value.deep_transform_keys! { |key| camel_lower(key) }
+      when Symbol then camel_lower(value.to_s).to_sym
+      when String then StringSupport.camel_lower(value)
+      else value
+      end
+    end
+
+    # Transforms values to dashed-case.
+    # This is the default case for the JsonApi adapter.
+    #
+    # @example:
+    #    "some_key" => "some-key",
+    def dash(value)
+      case value
+      when Hash then value.deep_transform_keys! { |key| dash(key) }
+      when Symbol then dash(value.to_s).to_sym
+      when String then StringSupport.dash(value)
+      else value
+      end
+    end
+
+    # Transforms values to underscore_case.
+    # This is the default case for deserialization in the JsonApi adapter.
+    #
+    # @example:
+    #    "some-key" => "some_key",
+    def underscore(value)
+      case value
+      when Hash then value.deep_transform_keys! { |key| underscore(key) }
+      when Symbol then underscore(value.to_s).to_sym
+      when String then StringSupport.underscore(value)
+      else value
+      end
+    end
+
+    # Returns the value unaltered
+    def unaltered(value)
+      value
+    end
+  end
+end

data/lib/jsonapi_helpers/support/string_support.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module JSONAPIHelpers
+  module StringSupport
+    module_function
+
+    def camel(string)
+      string.underscore.camelize
+    end
+
+    def camel_lower(string)
+      string.underscore.camelize(:lower)
+    end
+
+    def dash(string)
+      string.underscore.dasherize
+    end
+
+    def underscore(string)
+      string.underscore
+    end
+  end
+end

data/lib/jsonapi_helpers/version.rb

@@ -2,7 +2,7 @@
 
 module JSONAPIHelpers
   MAJOR = '0'
-  MINOR = '1'
-  PATCH = '1'
+  MINOR = '2'
+  PATCH = '0'
   VERSION = [MAJOR, MINOR, PATCH].join('.').freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi_helpers
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Jacob Burenstam
@@ -116,11 +116,32 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
 - LICENSE.txt
-- README.MD
+- README.md
+- Rakefile
 - bin/console
 - bin/setup
+- jsonapi_helpers.gemspec
+- lib/jsonapi_helpers.rb
 - lib/jsonapi_helpers/action_dispatch_request_wrapper.rb
+- lib/jsonapi_helpers/params/fields.rb
+- lib/jsonapi_helpers/params/filter.rb
+- lib/jsonapi_helpers/params/includes.rb
+- lib/jsonapi_helpers/params/sort.rb
+- lib/jsonapi_helpers/serializers/data.rb
+- lib/jsonapi_helpers/serializers/datum.rb
+- lib/jsonapi_helpers/serializers/deserializer.rb
+- lib/jsonapi_helpers/serializers/error.rb
+- lib/jsonapi_helpers/serializers/errors.rb
+- lib/jsonapi_helpers/serializers/model.rb
+- lib/jsonapi_helpers/serializers/model_error.rb
+- lib/jsonapi_helpers/serializers/relationships.rb
+- lib/jsonapi_helpers/support/key_transform.rb
+- lib/jsonapi_helpers/support/string_support.rb
 - lib/jsonapi_helpers/version.rb
 homepage: https://github.com/buren/jsonapi_helpers
 licenses: