rails_react_errors 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7ef71a095ca3fcaef5dc57a2add11dd13dea5c088226c4561957a93d72f7be5
-  data.tar.gz: 43401d67835cddd1ad89efeafefc0f91eb8b10671c36060832d5ec1cb5693d1c
+  metadata.gz: ac6abfaf6c7bcfb5c7b9e363ecf4385e313043b48b9a6c488f1d618a8dcab77d
+  data.tar.gz: 4af4ffa98d1d3b4e9d64064e5a10f10f28ffc86ccfd10be4aeb61c309b37ae2f
 SHA512:
-  metadata.gz: 5f032bd5f67b6c8938cc07a3d0d173cc973e2c834687829703e7402eda367bd0fa30f475d0b1994b0a3bdd58659a242fe2654bc1b8fa0dc584209bcffdba9543
-  data.tar.gz: 5c3b634d195ab8bc05be86366cfa5ab85d5fd7c9476dbfacc3c0f010ab3ce55cfcc2239da30d186b585f568314d123d1794a2c68289448b8c3c75ce7254227ae
+  metadata.gz: 8e73812697af09fdc076ae881e55dfab37969d1a90e6b75d59546e08fa3b34e4d4183dcde978a1452cdc6b1b621b74dabf666cb28d1034a758eb62a95e2d9d78
+  data.tar.gz: dd7cd735f7cc112029b4d5434dfbe8a0d2a2f0fc03bf06bc09144d6d72ad187d730ddfd2fbafe0e140276971c05ca9d2847e0bdf45634d608f71680e1073b0b4

data/README.md

@@ -1,74 +1,187 @@
-# RailsReactErrors
+# rails_react_errors
+
+Consistent error responses for **Rails APIs used by React frontends**.
+
+`rails_react_errors` standardizes API error responses so React applications can easily handle validation errors, authentication errors, and server failures.
 
-TODO: Delete this and the text below, and describe your gem
+Instead of handling multiple Rails error formats, this gem provides a **single predictable JSON structure**.
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rails_react_errors`. To experiment with that code, run `bin/console` for an interactive prompt.
+---
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+Add this line to your application's Gemfile:
+
+```ruby
+gem "rails_react_errors"
+```
 
-Install the gem and add to the application's Gemfile by executing:
+Then run:
 
 ```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+bundle install
 ```
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+---
 
-```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+## Quick Setup
+
+Include the controller module in your base controller.
+
+```ruby
+class ApplicationController < ActionController::API
+  include RailsReactErrors::Controller
+end
 ```
 
-## Usage
+That's it. Your Rails API will now automatically return standardized error responses.
 
-TODO: Write usage instructions here
+---
 
-## Development
+## Automatic Exception Handling
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+The gem automatically handles common Rails exceptions and converts them into consistent JSON responses.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Supported exceptions:
 
-## Contributing
+* `ActiveRecord::RecordNotFound`
+* `ActiveRecord::RecordInvalid`
+* `ActiveRecord::RecordNotUnique`
+* `ActionController::ParameterMissing`
+* `JSON::ParserError`
+* `StandardError` *(optional)*
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rails_react_errors. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/rails_react_errors/blob/master/CODE_OF_CONDUCT.md).
+Example:
 
-## License
+```ruby
+class UsersController < ApplicationController
+  def show
+    user = User.find(params[:id])
+    render json: user
+  end
+end
+```
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+If the record does not exist:
 
-## Code of Conduct
+```json
+{
+  "success": false,
+  "message": "Couldn't find User with 'id'=99",
+  "code": "NOT_FOUND",
+  "errors": {}
+}
+```
 
-Everyone interacting in the RailsReactErrors project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rails_react_errors/blob/master/CODE_OF_CONDUCT.md).
+---
 
-# rails_react_errors
+## Validation Error Example
 
-Consistent error responses for Rails APIs used by React frontends.
+```ruby
+class UsersController < ApplicationController
+  def create
+    user = User.create!(user_params)
+    render json: { success: true, data: user }, status: :created
+  end
+
+  private
+
+  def user_params
+    params.require(:user).permit(:email, :password)
+  end
+end
+```
 
-## Installation
+Response:
+
+```json
+{
+  "success": false,
+  "message": "Validation failed",
+  "code": "VALIDATION_ERROR",
+  "errors": {
+    "email": ["Email can't be blank"]
+  }
+}
+```
 
-## Usage
+---
 
-## Validation Errors
+## JSON Parsing Error
 
-## Not Found Errors
+If an invalid JSON payload is sent:
 
-## Unauthorized Errors
+```json
+{ email: "test"
+```
 
-## Configuration
+Response:
 
-## React Example
+```json
+{
+  "success": false,
+  "message": "Invalid JSON payload",
+  "code": "INVALID_JSON",
+  "errors": {}
+}
+```
 
-## Contributing
+---
 
-# rails_react_errors
+## Available Helper Methods
 
-Consistent error responses for Rails APIs used by React frontends.
+You can also manually render errors if needed.
 
-## Installation
+```ruby
+render_validation_error(record)
+render_not_found_error("User not found")
+render_parameter_missing_error("param is missing")
+render_conflict_error("Duplicate record")
+render_server_error("Something went wrong")
+render_error(message:, code:, status:, errors: {})
+```
 
-Add this line to your application's Gemfile:
+---
+
+## Custom Exception Mapping
+
+You can configure your own exceptions.
 
 ```ruby
-gem "rails_react_errors"
+RailsReactErrors.configure do |config|
+  config.custom_exceptions = {
+    "Pundit::NotAuthorizedError" => {
+      code: "FORBIDDEN",
+      status: :forbidden
+    },
+    "JWT::DecodeError" => {
+      code: "INVALID_TOKEN",
+      status: :unauthorized
+    }
+  }
+end
+```
+
+---
+
+## Enable Global Error Handling
+
+To automatically handle unexpected errors:
+
+```ruby
+RailsReactErrors.configure do |config|
+  config.rescue_standard_error = true
+end
+```
+
+---
+
+## License
+
+MIT License
+
+---
+
+## Author
+
+Manish Prajapati

data/lib/rails_react_errors/configuration.rb

@@ -4,12 +4,14 @@ module RailsReactErrors
   class Configuration
     attr_accessor :include_full_messages,
                   :rescue_standard_error,
-                  :log_errors
+                  :log_errors,
+                  :custom_exceptions
 
     def initialize
       @include_full_messages = true
       @rescue_standard_error = false
       @log_errors = true
+      @custom_exceptions = {}
     end
   end
 end

data/lib/rails_react_errors/controller.rb

@@ -9,10 +9,31 @@ module RailsReactErrors
         base.rescue_from ActiveRecord::RecordNotFound, with: :handle_record_not_found
       end
 
+      if defined?(ActiveRecord::RecordInvalid)
+        base.rescue_from ActiveRecord::RecordInvalid, with: :handle_record_invalid
+      end
+
       if defined?(ActionController::ParameterMissing)
         base.rescue_from ActionController::ParameterMissing, with: :handle_parameter_missing
       end
 
+      base.rescue_from ActiveRecord::RecordNotUnique, with: :handle_conflict if defined?(ActiveRecord::RecordNotUnique)
+
+      base.rescue_from JSON::ParserError, with: :handle_invalid_json if defined?(JSON::ParserError)
+
+      RailsReactErrors.configuration.custom_exceptions.each do |klass, config|
+        exception_class = Object.const_get(klass)
+        base.rescue_from exception_class do |exception|
+          render_error(
+            message: exception.message,
+            code: config[:code],
+            status: config[:status]
+          )
+        end
+      rescue NameError
+        next
+      end
+
       return unless RailsReactErrors.configuration.rescue_standard_error
 
       base.rescue_from StandardError, with: :handle_internal_server_error
@@ -24,13 +45,20 @@ module RailsReactErrors
       render_not_found_error(exception.message)
     end
 
+    def handle_record_invalid(exception)
+      render_validation_error(exception.record)
+    end
+
     def handle_parameter_missing(exception)
-      render json: {
-        success: false,
-        message: exception.message,
-        code: 'PARAMETER_MISSING',
-        errors: {}
-      }, status: :bad_request
+      render_parameter_missing_error(exception.message)
+    end
+
+    def handle_conflict(exception)
+      render_conflict_error(exception.message)
+    end
+
+    def handle_invalid_json(_exception)
+      render_invalid_json_error('Invalid JSON payload')
     end
 
     def handle_internal_server_error(exception)

data/lib/rails_react_errors/renderer.rb

@@ -22,6 +22,18 @@ module RailsReactErrors
       render json: RailsReactErrors::Serializer.server_error(message), status: status
     end
 
+    def render_parameter_missing_error(message, status: :bad_request)
+      render json: RailsReactErrors::Serializer.parameter_missing(message), status: status
+    end
+
+    def render_conflict_error(message, status: :conflict)
+      render json: RailsReactErrors::Serializer.conflict(message), status: status
+    end
+
+    def render_invalid_json_error(message = 'Invalid JSON payload', status: :bad_request)
+      render json: RailsReactErrors::Serializer.invalid_json(message), status: status
+    end
+
     def render_error(message:, code:, status:, errors: {})
       render json: {
         success: false,

data/lib/rails_react_errors/serializer.rb

@@ -22,6 +22,18 @@ module RailsReactErrors
       new.server_error(message)
     end
 
+    def self.parameter_missing(message)
+      new.parameter_missing(message)
+    end
+
+    def self.conflict(message = 'Conflict')
+      new.conflict(message)
+    end
+
+    def self.invalid_json(message = 'Invalid JSON payload')
+      new.invalid_json(message)
+    end
+
     def validation(record)
       {
         success: false,
@@ -67,6 +79,33 @@ module RailsReactErrors
       }
     end
 
+    def parameter_missing(message)
+      {
+        success: false,
+        message: message,
+        code: 'PARAMETER_MISSING',
+        errors: {}
+      }
+    end
+
+    def conflict(message)
+      {
+        success: false,
+        message: message,
+        code: 'CONFLICT',
+        errors: {}
+      }
+    end
+
+    def invalid_json(message)
+      {
+        success: false,
+        message: message,
+        code: 'INVALID_JSON',
+        errors: {}
+      }
+    end
+
     private
 
     def serialized_errors(record)

data/lib/rails_react_errors/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsReactErrors
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_react_errors
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Manish0407
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-03-06 00:00:00.000000000 Z
+date: 2026-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel