grape-jsonapi 1.0.0

data/Rakefile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'

data/grape-jsonapi.gemspec

@@ -0,0 +1,29 @@
+# Generated by EmCousin
+# frozen_string_literal: true
+
+require File.expand_path('lib/grape_jsonapi/version', __dir__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Emmanuel Cousin']
+  gem.email         = ['emmanuel_cousin@hotmail.fr']
+  gem.summary       = 'Use grape-jsonapi in grape'
+  gem.description   = 'Provides a Formatter for the Grape API DSL to emit objects serialized with jsonapi-serializer.'
+  gem.homepage      = 'https://github.com/EmCousin/grape-jsonapi'
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec}/*`.split("\n")
+  gem.name          = 'grape-jsonapi'
+  gem.require_paths = ['lib']
+  gem.version       = Grape::Jsonapi::VERSION
+  gem.licenses      = ['MIT']
+
+  gem.required_ruby_version = '>= 2.6.0'
+
+  gem.add_dependency 'grape'
+  gem.add_dependency 'jsonapi-serializer'
+
+  gem.add_development_dependency 'rails', '>= 4.2.0'
+  gem.add_development_dependency 'rspec', '~> 3.7'
+  gem.add_development_dependency 'rubocop'
+end

data/lib/grape_jsonapi.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'jsonapi/serializer'
+require 'grape'
+require 'grape_jsonapi/endpoint_extension'
+require 'grape_jsonapi/formatter'
+require 'grape_jsonapi/parser'
+require 'grape_jsonapi/version'
+
+require 'grape_jsonapi/deprecated/formatter'
+require 'grape_jsonapi/deprecated/parser'

data/lib/grape_jsonapi/deprecated/formatter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Grape
+  module Formatter
+    module FastJsonapi
+      include Grape::Formatter::Jsonapi
+
+      class << self
+        def call(object, env)
+          warn "
+            WARNING: Grape::Formatter::FastJsonapi is deprecated
+            and will be removed on version 1.1
+            Use Grape::Formatter::Jsonapi instead
+          "
+
+          super(object, env)
+        end
+
+        def deprecated?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/grape_jsonapi/deprecated/parser.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module GrapeSwagger
+  module FastJsonapi
+    class Parser < GrapeSwagger::Jsonapi::Parser
+      def initialize(model, endpoint)
+        warn "
+          WARNING: Grape::FastJsonapi::Parser is deprecated
+          and will be removed on version 1.1
+          Use Grape::Jsonapi::Parser instead
+        "
+
+        super(model, endpoint)
+      end
+
+      def self.deprecated?
+        true
+      end
+    end
+  end
+end

data/lib/grape_jsonapi/endpoint_extension.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Grape
+  module EndpointExtension
+    def render(resources, options = {})
+      env['jsonapi_serializer_options'] = options
+      resources
+    end
+  end
+
+  Endpoint.include EndpointExtension
+end

data/lib/grape_jsonapi/formatter.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Grape
+  module Formatter
+    module Jsonapi
+      class << self
+        def call(object, env)
+          return object if object.is_a?(String)
+          return ::Grape::Json.dump(serialize(object, env)) if serializable?(object)
+          return object.to_json if object.respond_to?(:to_json)
+
+          ::Grape::Json.dump(object)
+        end
+
+        private
+
+        def serializable?(object)
+          return false if object.nil?
+          return true if object.respond_to?(:serializable_hash)
+          return true if object.is_a?(Hash)
+
+          serializable_collection?(object)
+        end
+
+        def serialize(object, env)
+          if object.respond_to?(:serializable_hash)
+            serializable_object(object, jsonapi_options(env)).serializable_hash
+          elsif serializable_collection?(object)
+            serializable_collection(object, jsonapi_options(env))
+          elsif object.is_a?(Hash)
+            serialize_each_pair(object, env)
+          else
+            object
+          end
+        end
+
+        def serializable_collection?(object)
+          object.respond_to?(:to_a) && object.all? do |o|
+            o.respond_to?(:serializable_hash)
+          end
+        end
+
+        def serializable_object(object, options)
+          jsonapi_serializable(object, options) || object
+        end
+
+        def jsonapi_serializable(object, options)
+          serializable_class(object, options)&.new(object, options)
+        end
+
+        def serializable_collection(collection, options)
+          if heterogeneous_collection?(collection)
+            collection.map do |o|
+              serialize_resource(o, options)
+            end
+          else
+            serialize_resource(collection, options)
+          end
+        end
+
+        def heterogeneous_collection?(collection)
+          collection.map { |item| item.class.name }.uniq.many?
+        end
+
+        def serialize_resource(resource, options)
+          jsonapi_serializable(resource, options)&.serializable_hash || resource.map(&:serializable_hash)
+        end
+
+        def serializable_class(object, options)
+          klass_name = options['serializer'] || options[:serializer]
+          klass_name ||= begin
+            object = object.first if object.is_a?(Array)
+
+            "#{(object.try(:model_name) || object.class).name}Serializer"
+          end
+
+          klass_name&.safe_constantize
+        end
+
+        def serialize_each_pair(object, env)
+          h = {}
+          object.each_pair { |k, v| h[k] = serialize(v, env) }
+          h
+        end
+
+        def jsonapi_options(env)
+          env['jsonapi_serializer_options'] || {}
+        end
+      end
+    end
+  end
+end

data/lib/grape_jsonapi/parser.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module GrapeSwagger
+  module Jsonapi
+    class Parser
+      attr_reader :model, :endpoint
+
+      def initialize(model, endpoint)
+        @model = model
+        @endpoint = endpoint
+      end
+
+      def call
+        schema = default_schema
+        schema = enrich_with_attributes(schema)
+        schema = enrich_with_relationships(schema)
+        schema.deep_merge!(model.additional_schema) if model.respond_to?(:additional_schema)
+
+        schema
+      end
+
+      private
+
+      def default_schema
+        { data: {
+          type: :object,
+          properties: default_schema_propeties,
+          example: {
+            id: 1,
+            type: model.record_type,
+            attributes: {},
+            relationships: {}
+          }
+        } }
+      end
+
+      def default_schema_propeties
+        { id: { type: :integer },
+          type: { type: :string },
+          attributes: default_schema_object,
+          relationships: default_schema_object }
+      end
+
+      def default_schema_object
+        { type: :object, properties: {} }
+      end
+
+      def enrich_with_attributes(schema)
+        attributes_hash.each do |attribute, type|
+          schema[:data][:properties][:attributes][:properties][attribute] = { type: type }
+          example_method = "#{type}_example"
+          unless respond_to?(example_method, true)
+            puts "WARN unexpected type encountered, missing #{example_method}  --use string example instead"
+            example_method = 'string_example'
+          end
+          schema[:data][:example][:attributes][attribute] = send(example_method)
+        end
+
+        schema
+      end
+
+      def attributes_hash
+        return map_model_attributes.symbolize_keys unless defined?(ActiveRecord)
+
+        map_model_attributes.symbolize_keys.merge(
+          map_active_record_columns_to_attributes.symbolize_keys
+        )
+      end
+
+      def enrich_with_relationships(schema)
+        relationships_hash.each do |model_type, relationship_data|
+          relationships_attributes = relationship_data.instance_values.symbolize_keys
+          schema[:data][:properties][:relationships][:properties][model_type] = {
+            type: :object,
+            properties: relationships_properties(relationships_attributes)
+          }
+          schema[:data][:example][:relationships][model_type] = relationships_example(relationships_attributes)
+        end
+
+        schema
+      end
+
+      def relationships_hash
+        hash = model.relationships_to_serialize || []
+
+        # If relationship has :key set different than association name, it should be rendered under that key
+
+        hash.each_with_object({}) do |(_relationship_name, relationship), accu|
+          accu[relationship.key] = relationship
+        end
+      end
+
+      def map_active_record_columns_to_attributes
+        return map_model_attributes unless activerecord_model && activerecord_model < ActiveRecord::Base
+
+        activerecord_model.columns.each_with_object({}) do |column, attributes|
+          next unless model.attributes_to_serialize.key?(column.name.to_sym)
+
+          attributes[column.name] = column.type
+        end
+      end
+
+      def activerecord_model
+        model.record_type.to_s.camelize.safe_constantize
+      end
+
+      def map_model_attributes
+        attributes = {}
+        (model.attributes_to_serialize || []).each do |attribute, _|
+          attributes[attribute] =
+            if model.respond_to? :attribute_types
+              model.attribute_types[attribute] || :string
+            else
+              :string
+            end
+        end
+        attributes
+      end
+
+      def relationships_properties(relationship_data)
+        return { data: RELATIONSHIP_DEFAULT_ITEM } unless relationship_data[:relationship_type] == :has_many
+
+        { data: {
+          type: :array,
+          items: RELATIONSHIP_DEFAULT_ITEM
+        } }
+      end
+
+      RELATIONSHIP_DEFAULT_ITEM = {
+        type: :object,
+        properties: {
+          id: { type: :integer },
+          type: { type: :string }
+        }
+      }.freeze
+
+      def relationships_example(relationship_data)
+        data = {
+          id: 1,
+          type: relationship_data[:record_type] ||
+                relationship_data[:static_record_type] ||
+                relationship_data[:object_method_name]
+        }
+
+        data = [data] if relationship_data[:relationship_type] == :has_many
+
+        { data: data }
+      end
+
+      def integer_example
+        defined?(Faker) ? Faker::Number.number.to_i : rand(1..9999)
+      end
+
+      def string_example
+        defined?(Faker) ? Faker::Lorem.word : 'Example string'
+      end
+
+      def text_example
+        defined?(Faker) ? Faker::Lorem.paragraph : 'Example string'
+      end
+      alias citext_example text_example
+
+      def float_example
+        rand * rand(1..100)
+      end
+
+      def date_example
+        Date.today.to_s
+      end
+
+      def datetime_example
+        Time.current.to_s
+      end
+      alias time_example datetime_example
+
+      def object_example
+        return { example: :object } unless defined?(Faker)
+
+        { string_example.parameterize.underscore.to_sym => string_example.parameterize.underscore.to_sym }
+      end
+
+      def array_example
+        [string_example]
+      end
+
+      def boolean_example
+        [true, false].sample
+      end
+
+      def uuid_example
+        SecureRandom.uuid
+      end
+    end
+  end
+end

data/lib/grape_jsonapi/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Grape
+  module Jsonapi
+    VERSION = '1.0.0'
+  end
+end

data/spec/lib/grape_jsonapi/deprecated.rb/formatter_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+describe Grape::Formatter::FastJsonapi do
+  subject { described_class }
+
+  it { expect(subject.deprecated?).to be true }
+end

data/spec/lib/grape_jsonapi/deprecated.rb/parser_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+describe GrapeSwagger::FastJsonapi::Parser do
+  subject { described_class }
+
+  it { expect(subject.deprecated?).to be true }
+end

data/spec/lib/grape_jsonapi/formatter_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+describe Grape::Formatter::Jsonapi do
+  describe 'class methods' do
+    let(:user) do
+      User.new(id: 1, first_name: 'Chuck', last_name: 'Norris', password: 'supersecretpassword', email: 'chuck@norris.com')
+    end
+    let(:another_user) do
+      User.new(id: 2, first_name: 'Bruce', last_name: 'Lee', password: 'supersecretpassword', email: 'bruce@lee.com')
+    end
+    let(:blog_post) do
+      BlogPost.new(id: 1, title: 'Blog Post title', body: 'Blog post body')
+    end
+    let(:admin) do
+      UserAdmin.new(id: 1, first_name: 'Jean Luc', last_name: 'Picard', password: 'supersecretpassword', email: 'jeanluc@picard.com')
+    end
+
+    describe '.call' do
+      subject { described_class.call(object, env) }
+      let(:jsonapi_serializer_options) { nil }
+      let(:env) { { 'jsonapi_serializer_options' => jsonapi_serializer_options } }
+
+      context 'when the object is a string' do
+        let(:object) { 'I am a string' }
+
+        it { is_expected.to eq object }
+      end
+
+      context 'when the object is serializable' do
+        let(:user_serializer) { UserSerializer.new(object, {}) }
+        let(:another_user_serializer) { AnotherUserSerializer.new(object, {}) }
+        let(:blog_post_serializer) { BlogPostSerializer.new(object, {}) }
+
+        context 'when the object has a model_name defined' do
+          let(:object) { admin }
+          it { is_expected.to eq ::Grape::Json.dump(user_serializer.serializable_hash) }
+        end
+
+        context 'when the object is a active serializable model instance' do
+          let(:object) { user }
+
+          it { is_expected.to eq ::Grape::Json.dump(user_serializer.serializable_hash) }
+        end
+
+        context 'when the object is an array of active serializable model instances' do
+          let(:object) { [user, another_user] }
+
+          it { is_expected.to eq ::Grape::Json.dump(user_serializer.serializable_hash) }
+        end
+
+        context 'when the array contains instances of different models' do
+          let(:object) { [user, blog_post] }
+
+          it 'returns an array of jsonapi serialialized objects' do
+            expect(subject).to eq(::Grape::Json.dump([
+                                                       UserSerializer.new(user, {}).serializable_hash,
+                                                       BlogPostSerializer.new(blog_post, {}).serializable_hash
+                                                     ]))
+          end
+        end
+
+        context 'when the object is an empty array ' do
+          let(:object) { [] }
+
+          it { is_expected.to eq ::Grape::Json.dump(object) }
+        end
+
+        context 'when the object is an array of null objects ' do
+          let(:object) { [nil, nil] }
+
+          it { is_expected.to eq ::Grape::Json.dump(object) }
+        end
+
+        context 'when the object is a Hash of plain values' do
+          let(:object) { user.as_json }
+
+          it { is_expected.to eq ::Grape::Json.dump(object) }
+        end
+
+        context 'when the object is a Hash with serializable object values' do
+          let(:object) do
+            {
+              user: user,
+              blog_post: blog_post
+            }
+          end
+
+          it 'returns an hash of with jsonapi serialialized objects values' do
+            expect(subject).to eq(::Grape::Json.dump({
+                                                       user: UserSerializer.new(user, {}).serializable_hash,
+                                                       blog_post: BlogPostSerializer.new(blog_post, {}).serializable_hash
+                                                     }))
+          end
+        end
+
+        context 'when the object is nil' do
+          let(:object) { nil }
+
+          it { is_expected.to eq 'null' }
+        end
+
+        context 'when the object is a number' do
+          let(:object) { 42 }
+
+          it { is_expected.to eq '42' }
+        end
+
+        context 'when a custom serializer is passed as an option' do
+          let(:object) { user }
+          let(:jsonapi_serializer_options) do
+            {
+              'serializer' => '::AnotherUserSerializer'
+            }
+          end
+
+          it { is_expected.to eq ::Grape::Json.dump(another_user_serializer.serializable_hash) }
+        end
+      end
+    end
+  end
+end