mini_api 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf126960ba6eec18c20dcf69715848c827eef16840540c45fe0d76fc1a61341c
-  data.tar.gz: 69caf5e66fdacee7e9b5a4c5271387e0823f6f10f90373b9cdd149966563ad3f
+  metadata.gz: c5d0ed96803b2a46a7e13aa3705c1b06dd2ffa2a1474d4d646e2a4deaad2aa8c
+  data.tar.gz: 22d55b43c092628891398ba8eb4238f4bcea484e7705936e0e25b545f61dc27f
 SHA512:
-  metadata.gz: 11a71582b7e0ed144cc0d3256dabc4c2e7f2f459c81459f2d809af16ddd02de0ee9ec9af45cdc6fbaae4d2c809857148b668e47186c0c110a1b708153f687373
-  data.tar.gz: c34d2b7773016ccd2328778d1d8b9a9be5cca14c403684b3870dfe47d3fe5988ae3acad1ec0bcb2453468304b4a329e16a35aa7f72efec48f64d9da1ca2fcf19
+  metadata.gz: d15be33457f31c83030d04f4d52e2b859cd917e2753393b55add61c00654e1e8729311a00a21de25fc44488a26b5c56e99abd9bfedcd85b6894644a699e5105d
+  data.tar.gz: 6fc53a392a57940498ee5a4b205e5388e6b409ebca9bc81b1323ce4dd7a709460d91044d551fd07510a4b82c04ab165fb0bcf420a24e410f2ad37d5937945100

data/README.md

@@ -1,6 +1,6 @@
 ![](https://github.com/leoncruz/api-responder/actions/workflows/tests.yml/badge.svg)
-[![Maintainability](https://api.codeclimate.com/v1/badges/ec2939be693459b7ce4d/maintainability)](https://codeclimate.com/github/leoncruz/api-responder/maintainability)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/ec2939be693459b7ce4d/test_coverage)](https://codeclimate.com/github/leoncruz/api-responder/test_coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/6ed70a7ed0d28e32b56c/maintainability)](https://codeclimate.com/github/leoncruz/mini_api/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/6ed70a7ed0d28e32b56c/test_coverage)](https://codeclimate.com/github/leoncruz/mini_api/test_coverage)
 
 # Mini Api
 A gem to standardize json responses in Rails applications, highly inspired on [Responders](https://github.com/heartcombo/responders)
@@ -8,6 +8,7 @@ A gem to standardize json responses in Rails applications, highly inspired on [R
 ## Table of Contents
 - [Usage](#usage)
   - [Respondering json](#respondering-json)
+  - [Data Serialization](#data-serialization)
   - [Success and failure actions](#success-and-failure-actions)
   - [Errors](#errors)
   - [Message](#message)
@@ -30,7 +31,6 @@ $ bundle
 ```
 
 You must install [Kaminari](https://github.com/kaminari/kaminari) to handle pagination
-and [Active Model Serializers](http://github.com/rails-api/active_model_serializers) to handle data serialization
 
 ## Usage
 
@@ -92,6 +92,22 @@ The response will be like:
 }
 ```
 
+### Data Serialization
+
+This gem is integrated to [Alba](https://github.com/okuramasafumi/Alba) to create your `resources`. A simple resource example:
+```ruby
+class UserResource
+  include Alba::Resource
+
+  attributes :id, :name, :email
+end
+```
+When the `render_json` methods receive an instance of `user` or a `ActiveRecord::Relation` of `users` will search by `UserResource`.
+
+If you have a nested controller like: `Api::V1::UsersController`, `mini_api` will search by resources in controller namespace.
+First will search per `Api::V1::UserResource`, after `Api::UserResource` and then `UserResource` until find.
+That way, even if your `controller` and `resource` are defined in different namespace levels, `MiniApi` will find.
+
 ### Success and failure actions
 
 Many times, our controller actions need to persist or validate some data coming from request, the default approach to do that is like:
@@ -145,20 +161,20 @@ The `message` key is different based on actions on informed model: create, updat
 You can respond any type of data, but ActiveRecord/ActiveModel::Model and ActiveRecord::Relation has a special treatment as shown above
 
 ### Errors
-To show errors of a model, by default will use the `errors.messages` method, but `MiniApi` adds an ability to `active_model_serializers` to create a error serializer
-as a nested class in your serializer. Example:
+To show errors of a model, by default will use the `errors.messages` method, but `MiniApi` adds an ability to `Alba` to create a error resource
+as a nested class in your resource. Example:
+
 ```ruby
-class UserSerializer < ActiveModel::Serializer
-  attributes :id, :first_name, :last_name
+class UserResource
+  include Alba::Resource
+
+  attributes :id, :name, :email
 
-  class Error < ActiveModel::Serializer
-    attributes :user
+  class Error
+    include Alba::Resource
 
-    def user
-      {
-        first_name: object.errors[:first_name],
-        last_name: object.errors[:last_name],
-      }
+    attribute :user do
+      object.errors.full_messages
     end
   end
 end
@@ -168,10 +184,7 @@ The response will be like:
 {
   "success": false,
   "errors": {
-    "user": {
-      "first_name": "can't be blank",
-      "last_name": "can't be blank"
-    }
+    "user": ["First name can't be blank"]
   },
   "message": "User could not be created."
 }
@@ -188,6 +201,14 @@ By default support the actions: `create`, `update` and `delete`, but you can add
 You can add translation based on models, changing the `action` key for your model name. Example:
 `mini_api.messages.model_name.create.alert`. With this, is more easy personalize messages
 
+It is possible define a translation based on controller, useful if you use nested controlers. The path is:
+`min_api.messages.controller_name.action_name.alert`
+
+If you would like to send the message as `null`, has to use the `:empty` symbol, like:
+```ruby
+render_json @object, message: :empty
+```
+
 ### Transform keys
 
 It is possible to transform the keys of request and response. By default, will transform to `snake_case`, but the possible values are `snake_case`, `camel_lower` and `camel_case`

data/lib/mini_api/model_responder.rb

@@ -2,11 +2,13 @@
 
 require 'mini_api/serialization'
 require 'mini_api/case_transform'
+require 'mini_api/translation/message'
 
 module MiniApi
   # class to handle json render of ActiveRecord::Base instances and ActiveModel::Model's
   class ModelResponder
     include Serialization
+    include Translation::Message
 
     def initialize(controller, resource, options = {})
       @controller = controller
@@ -17,7 +19,7 @@ module MiniApi
     def respond
       body = {
         success: resource_has_errors? == false,
-        message: @options[:message] || default_message
+        message: message
       }
 
       body =
@@ -27,10 +29,6 @@ module MiniApi
           { data: serialiable_body(@resource).as_json }.merge(body)
         end
 
-      # This is for an problem with ActiveModelSerializer that adds an error
-      # attribute when resource is an ActiveModel instance
-      body[:data] = body[:data].except('errors') if body[:data]&.key?('errors')
-
       body = CaseTransform.response_keys(body)
 
       @controller.render json: body, status: status_code
@@ -38,6 +36,12 @@ module MiniApi
 
     private
 
+    def message
+      return if @options[:message] == :empty
+
+      @options[:message] || i18n_message
+    end
+
     def resource_has_errors?
       !@resource.errors.empty?
     end
@@ -62,28 +66,6 @@ module MiniApi
       :ok
     end
 
-    def default_message
-      kind = resource_has_errors? ? 'alert' : 'notice'
-
-      model_path = "mini_api.messages.#{@resource.model_name.i18n_key}"
-
-      if I18n.exists? model_path
-        I18n.t(
-          kind,
-          scope: "#{model_path}.#{@controller.action_name}",
-          resource_name: @resource.class.model_name.human,
-          default: ''
-        )
-      else
-        I18n.t(
-          kind,
-          scope: [:mini_api, :messages, :actions, @controller.action_name],
-          resource_name: @resource.class.model_name.human,
-          default: ''
-        )
-      end
-    end
-
     def previously_new_record?
       return true if @resource.is_a?(ActiveRecord::Base) && @resource.previously_new_record?
 

data/lib/mini_api/serialization.rb

@@ -1,22 +1,48 @@
 # frozen_string_literal: true
 
-module MiniApi
-  #
-  # This module is responsible to handler integration with Active Model Serialier gem
-  # call the +get_serializer+ method of controller implemented by gem
-  # to find the serializer of informed object.
+require 'alba'
 
+module MiniApi
   module Serialization
+    # This method search by serializer using the module parents of controller.
+    # With this, is possible define serializers for the same resource
+    # in different controller scopes.
+    # If the resource class does not have a resource, will be use the default `as_json` method
     def serialiable_body(resource)
-      return resource unless defined?(ActiveModel::Serializer)
+      controller_scope = @controller.class.module_parents
+
+      resource_class =
+        if resource.respond_to?(:model)
+          resource.model
+        else
+          resource.class
+        end
+
+      serializer_class =
+        loop do
+          serializer_class =
+            "#{controller_scope.first}::#{resource_class}Resource".safe_constantize
+
+          break serializer_class if serializer_class
 
-      @controller.get_serializer(resource)
+          break if controller_scope.empty?
+
+          controller_scope.shift
+        end
+
+      return serializer_class.new(resource) if serializer_class
+
+      resource
     end
 
+    # Search by the nested class +Error+ on serializer
+    # Follow the same steps for +get_serializer+
     def get_error_serializer(resource)
-      serializer_class = @controller.get_serializer(resource)
+      error_serializer = serialiable_body(resource)
+
+      return unless error_serializer
 
-      "#{serializer_class.serializer}::Error".safe_constantize
+      "#{error_serializer.class}::Error".safe_constantize
     end
   end
 end

data/lib/mini_api/translation/message.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module MiniApi
+  module Translation
+    # Module to handle the +message+ key on json response.
+    # Will identify if model has errors or not and define the I18n path to +notice+, for model without errors
+    # and +alert+ for model with errors.
+    # There is three possible path for messages:
+    #
+    # The path based on model name
+    # mini_api:
+    #   messages:
+    #     model_name:
+    #       action_name:
+    #         notitce:
+    #         alert:
+    #
+    # The path based on controller name
+    # mini_api:
+    #   messages:
+    #     controller:
+    #       controller_name:
+    #         action_name:
+    #           notitce:
+    #           alert:
+    #
+    # And the last, is per action path:
+    # mini_api:
+    #   messages:
+    #     actions:
+    #       create:
+    #         notice: '%{resource_name} foi criado com sucesso.'
+    #         alert: '%{resource_name} não pôde ser criado.'
+
+    module Message
+      def i18n_message
+        kind = @resource.errors.empty? ? 'notice' : 'alert'
+
+        I18n.t(
+          kind,
+          scope: model_message_path || controller_message_path || default_message_path,
+          resource_name: @resource.class.model_name.human,
+          default: ''
+        )
+      end
+
+      private
+
+      def model_message_path
+        model_path = "mini_api.messages.#{@resource.model_name.i18n_key}.#{@controller.action_name}"
+
+        model_path if I18n.exists? model_path
+      end
+
+      def controller_message_path
+        controller_path =
+          "mini_api.messages.controller.#{@controller.controller_name}.#{@controller.action_name}"
+
+        controller_path if I18n.exists? controller_path
+      end
+
+      def default_message_path
+        ['mini_api', 'messages', 'actions', @controller.action_name].join('.')
+      end
+    end
+  end
+end

data/lib/mini_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniApi
-  VERSION = '0.1.4'
+  VERSION = '0.1.6'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: mini_api
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Leon Cruz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-21 00:00:00.000000000 Z
+date: 2023-07-30 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: alba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -46,6 +60,7 @@ files:
 - lib/mini_api/relation_responder.rb
 - lib/mini_api/responder.rb
 - lib/mini_api/serialization.rb
+- lib/mini_api/translation/message.rb
 - lib/mini_api/version.rb
 homepage:
 licenses: