lontara_utilities 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a5cf89378d3ae64ad5517aa214ff99ba9aa73c419266d8392e7291e8f13bd47e
+  data.tar.gz: 1b1ec1916807d80d5fcf69c13139647f2bb34475dacc4abe036a4207e3812d1a
+SHA512:
+  metadata.gz: ca4ceeba469609e6ebc470ccae64869a45bae24b0cc822aec801f017f953db6320587fcc8017e6fbf7e707e946504f69db4af97806bd6fc15dbfe5432b3bb422
+  data.tar.gz: 93aaa2a7abfc9733c83b0f1be0b6e6473f1ac6104afe51c92a212f7f7afc6aa483e4c4b446f191253a88294d4107ae11e34334fd241c72740956f9f4e535cfaa

data/.gitignore

@@ -0,0 +1,3 @@
+lontara.gem
+recovery_codes
+build.sh

data/.rubocop.yml

@@ -0,0 +1,17 @@
+# The behavior of RuboCop can be controlled via the .rubocop.yml
+# configuration file. It makes it possible to enable/disable
+# certain cops (checks) and to alter their behavior if they accept
+# any parameters. The file can be placed either in your home
+# directory or in some project directory.
+#
+# RuboCop will start looking for the configuration file in the directory
+# where the inspected file is and continue its way up to the root directory.
+#
+# See https://docs.rubocop.org/rubocop/configuration
+
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+
+Style/FetchEnvVar:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,70 @@
+PATH
+  remote: .
+  specs:
+    lontara_utilities (3.0.0)
+      bunny (~> 2.20)
+      connection_pool (~> 2.3)
+      faraday (~> 2.7)
+      json (~> 2.6)
+      securerandom (~> 0.2)
+      uri (~> 0.12)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.1)
+      public_suffix (>= 2.0.2, < 6.0)
+    amq-protocol (2.3.2)
+    bunny (2.20.3)
+      amq-protocol (~> 2.3, >= 2.3.1)
+      sorted_set (~> 1, >= 1.0.2)
+    byebug (11.1.3)
+    connection_pool (2.3.0)
+    crack (0.4.5)
+      rexml
+    diff-lcs (1.5.0)
+    faraday (2.7.4)
+      faraday-net_http (>= 2.0, < 3.1)
+      ruby2_keywords (>= 0.0.4)
+    faraday-net_http (3.0.2)
+    hashdiff (1.0.1)
+    json (2.6.3)
+    public_suffix (5.0.1)
+    rbtree (0.4.6)
+    rexml (3.2.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.1)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    ruby2_keywords (0.0.5)
+    securerandom (0.2.2)
+    set (1.0.3)
+    sorted_set (1.0.3)
+      rbtree
+      set (~> 1.0)
+    uri (0.12.0)
+    webmock (3.18.1)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  byebug (~> 11.1)
+  lontara_utilities!
+  rspec (~> 3.12)
+  webmock (~> 3.18)
+
+BUNDLED WITH
+   2.3.26

data/README.md

@@ -0,0 +1,60 @@
+# Lontara Utilities
+
+> Build Version: 3.0.0
+
+This is a collection of utilities for your Ruby project provided by Lontara. These are:
+- `LontaraUtilities` - a collection of utilities
+- `HTTPClient` - Client for HTTP Connection
+- `RMQ::Client` - Client for RabbitMQ Connection
+- `RMQ::Server` - Server for RabbitMQ Connection
+- `Git` - An interface to Git Branch and Release
+- `BaseError` - Custom Error inherited from StandardError with some features
+
+## Installation
+Open your terminal and type:
+```bash
+gem install lontara_utilities
+```
+
+or add this line to your application's Gemfile:
+```ruby
+gem 'lontara_utilities'
+```
+
+If you wanna use the `git` method, you need to install `git` first, and then initialize it in your project directory.
+
+For Rails project, you can use initializer to run RMQ Server. Just add `rmq.rb` file in `config/initializers` directory, and add this code:
+
+> Note: Currently we only support `RPCConsumer` (from RPC Pattern) or `Subscriber` (from Pub/Sub Messaging Pattern) server.
+
+```ruby
+require 'lontara_utilities/rmq'
+
+LontaraUtilities::RMQ.start(
+  server: 'RPCConsumer',
+  url: ENV.fetch('RABBITMQ_URL', 'amqp://guest:guest@rmqserver:5672'),
+  queue: ENV.fetch('RABBITMQ_QUEUE_VOUCHER', 'lontara-dev.voucher')
+)
+```
+
+## Usage
+You can require this utilities by adding `require 'lontara_utilities'`, or you can require each utilities separately.
+
+```ruby
+require 'lontara_utilities/http_client'
+
+LontaraUtilities::HTTPClient.get('http://example.com')
+```
+
+But, if `lontara_utilities` or it's alias: `lontara` is required, you can call these methods using  method format.
+
+```ruby
+require 'lontara_utilities' # or require 'lontara'
+
+Lontara.http_client.get(url: 'http://example.com')
+```
+
+For usage of each utilities, please refer to the documentation: [Lontara Utilities](https://www.rubydoc.info/gems/lontara-utilities)
+
+## Contributing
+Bug reports and pull requests are welcome on GitHub at [Lontara Utilities](https://github.com/lontara-app/lontara-utilities).

data/lib/lontara.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Lontara is an alias for LontaraUtilities.
+Lontara = LontaraUtilities

data/lib/lontara_utilities/base_error.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  # This Base Error gives you a standard way to raise & handle errors with some additional features.
+  #
+  # Use this class directly:
+  #
+  #   begin
+  #     raise LontaraUtilities::BaseError, 'This is a test'
+  #   rescue LontaraUtilities::BaseError => e
+  #     puts e.message
+  #   end
+  #
+  # or inherited by other classes:
+  #
+  #   class RMQ::ConnectionError < LontaraUtilities::BaseError
+  #     def initialize(message = "Can't established connection") = super
+  #   end
+  #
+  # Note: You must call `super` in the initialize method of the inherited class.
+  #
+  # Parameter `handler` is a Proc or Any. If it is a Proc, it will be called.
+  # If it is not a Proc, it will be assigned to the `handler` attribute.
+  #
+  #   class RMQ::QueueNotDefined < LontaraUtilities::BaseError
+  #     def initialize(message = 'Queue not defined', handler: -> { logger }) = super
+  #
+  #     # Write logs to 'rmq.log'
+  #     def logger
+  #       File.open(File.join(__dir__, 'log', 'rmq.log'), 'a') do |f|
+  #         f.puts "#{timestamp} | #{code} | #{message}"
+  #       end
+  #     end
+  #   end
+  #
+  # You also can pass a Backtrace after the message in raise method.
+  #
+  #   raise LontaraUtilities::BaseError, 'This is a test', caller
+  #
+  # **Important**:
+  # You cannot pass other arguments except `message`, and `backtrace`
+  # to the raise method. `backtrace` only callable from rescue block also.
+  class BaseError < StandardError
+    # @param message [String] Error message. Default is 'LontaraUtilities::BaseError'.
+    # @param code [String] Error code. Default is LontaraUtilities::BaseError, or the class name of the inherited class.
+    # @param timestamp [Time] Error timestamp. Default is Time.now.
+    # @param handler [Proc | Any] Error han dler. Default is nil.
+    def initialize(message = 'BaseError', code: self.class.name, timestamp: Time.now, handler: nil)
+      @message = message
+      @code = code.to_s.split('::').last
+      @timestamp = timestamp
+      @handler = handler.is_a?(Proc) ? handler.call : handler
+
+      super(message)
+    end
+
+    attr_reader :message, :code, :timestamp, :handler 
+  end
+end

data/lib/lontara_utilities/git/branch.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  module Git
+    # Class Branch used to show all git branches in your project.
+    class Branch
+      # Show current running branch in your project.
+      def self.current_branch
+        `git rev-parse --abbrev-ref HEAD`.strip
+      end
+
+      # Show all branches in your project.
+      def self.all
+        `git branch -a`.split("\n").map { |branch| branch.gsub('*', '').strip }
+      end
+
+      # Show all remote branches in your project.
+      def self.remote
+        all.select { |branch| branch.start_with?('remotes') }
+      end
+
+      # Show all local branches in your project.
+      def self.local
+        all.reject { |branch| branch.start_with?('remotes') }
+      end
+
+      # Use metaprogramming to define methods
+      # for checking current branch using method_missing and plain ruby method.
+      def self.method_missing(method_name, *args, &)
+        if method_name.to_s.end_with?('?')
+          current_branch == method_name.to_s.gsub('?', '')
+        else
+          super
+        end
+      end
+
+      def self.respond_to_missing?(method_name, include_private = false)
+        method_name.to_s.end_with?('?') || super
+      end
+    end
+  end
+end

data/lib/lontara_utilities/git/release.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  module Git
+    # Class Release used to show all release tag in your project.
+    class Release
+      # Show current running release in your project.
+      def self.current_release
+        `git describe --tags --abbrev=0`.strip
+      end
+
+      # Show all release in your project.
+      def self.all
+        `git tag`.split("\n").map(&:strip)
+      end
+
+      # Show latest release in your project.
+      def self.latest
+        all.last
+      end
+
+      # Check if current release is latest release.
+      def self.latest?(release)
+        release = release.to_s.downcase.gsub('v', '')
+        latest == release
+      end
+
+      # Check if release is current release.
+      def self.current?(release)
+        release = release.to_s.downcase.gsub('v', '')
+        current_release == release
+      end
+    end
+  end
+end

data/lib/lontara_utilities/git.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'git/branch'
+require_relative 'git/release'
+
+module LontaraUtilities
+  # Module Git responsible for handling git Branch and Release.
+  module Git
+    module_function
+
+    # Module function of Git Branch.
+    # Call this function like this: `LontaraUtilities::Git.branch#method_name`
+    def branch
+      Branch
+    end
+
+    # Module function of Git Release.
+    # Call this function like this: `LontaraUtilities::Git.release#method_name`
+    def release
+      Release
+    end
+  end
+end

data/lib/lontara_utilities/http_client/body_parser.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  module HTTPClient
+    # Body Parser responsible for parsing body based on content type.
+    class BodyParser
+      def initialize(content_type:, body:)
+        @content_type = content_type
+        @body = body
+      end
+
+      # Parse body based on content type.
+      def parse
+        case content_type
+        when 'application/json'
+          body.to_json
+        when 'application/x-www-form-urlencoded'
+          URI.encode_www_form(body)
+        else
+          body
+        end
+      end
+
+      private
+
+      attr_reader :content_type, :body
+    end
+  end
+end

data/lib/lontara_utilities/http_client/request.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  module HTTPClient
+    # Request class responsible for handling HTTP request.
+    class Request
+      def initialize(method, url:, headers: {}, body: nil, params: nil)
+        @method = method
+        @url = url
+        @headers = headers
+        @body = body
+        @params = params
+
+        headers.merge!(user_agent:) unless headers.key?(:user_agent)
+      end
+
+      # Perform HTTP request.
+      def perform
+        call
+      end
+
+      private
+
+      attr_reader :method, :url, :headers, :body, :params
+
+      def call
+        connection.send(method, url) do |req|
+          req.body = parsed_body if body
+          req.params = params if params
+          req.options.timeout = 10
+          req.options.open_timeout = 10
+        end
+      end
+
+      def connection
+        Faraday.new do |faraday|
+          faraday.headers = headers
+          faraday.adapter Faraday.default_adapter
+        end
+      end
+
+      def parsed_body
+        BodyParser.new(**headers.slice(:content_type), body:).parse
+      end
+
+      def app_name
+        # Check if Rails is defined
+        return 'Lontara HTTPClient' unless defined?(Rails)
+
+        Rails.application.class.module_parent.name
+      end
+
+      def app_version
+        release = Git::Release.current_release
+        return VERSION if release.empty?
+
+        release
+      end
+
+      def user_agent
+        "#{app_name}/#{app_version}"
+      end
+    end
+  end
+end

data/lib/lontara_utilities/http_client.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'uri'
+require 'faraday'
+
+require_relative 'git'
+require_relative 'http_client/body_parser'
+require_relative 'http_client/request'
+
+module LontaraUtilities
+  # Lontara HTTP Client
+  #
+  # Request dapat menggunakan method `new` disertai HTTP method sebagai parameter,
+  # atau menggunakan method predifined `.get`, `.post`, `.put`, `.delete`, `.patch`.
+  #
+  # Parameter yang dibutuhkan:
+  # - method. Contoh: `:get`, `:post`, `:put`, `:delete`. Dapat menerima dalam bentuk String.
+  # - :url. Contoh: `http://localhost:4000/book/category`
+  # - :params. Contoh: `params: { sort: "createDate,desc" }`
+  # - :body. Contoh: `body: { username: admin, password: admin }`
+  # - :headers. Headers dapat diisi dengan berbagai key-value dalam format lowercase.
+  #             Pisahkan dengan underscore jika key lebih dari satu kata.
+  #             Contoh: `headers: { authorization: "Bearer hnjuvdiwv67wwqvn....", content_type: "application/json" }`
+  #
+  # Contoh:
+  #
+  #   Lontara::HTTPClient.new(:get,
+  #     url: 'http://localhost:4000/book/category',
+  #     params: { sort: 'createDate,desc' }
+  #   )
+  #
+  # atau
+  #
+  #   request = Lontara::HTTPClient.get(
+  #     url: 'http://localhost:4000/user',
+  #     params: { id: "123GHANIY" },
+  #     headers: {
+  #       authorization: "Bearer #{token}",
+  #       content_type: 'application/json'
+  #     }
+  #   )
+  #
+  #   JSON.parse(request.body)
+  #
+  module HTTPClient
+    def self.new(method, url:, **options)
+      Request.new(method, url:, **options).perform
+    end
+
+    # Use predifined method to make HTTP request.
+    %i[get post put delete patch].each do |method|
+      define_singleton_method(method) do |url:, **options|
+        Request.new(method, url:, **options).perform
+      end
+    end
+  end
+end

data/lib/lontara_utilities/rmq/client/publisher.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  module RMQ
+    module Client
+      # Client for AMQ on Pub/Sub Pattern
+      class Publisher
+        def initialize(connection, queue:, exchange: nil, exchange_type: :direct)
+          @channel = connection.channel
+
+          # Use `default_exchange` if exchange is not declared in parameter
+          # nor use the specified exchange from the connection.
+          x = -> { exchange.nil? ? channel.default_exchange : channel.exchange(exchange, type: exchange_type) }
+          @exchange = connection.exchange.nil? ? x.call : connection.exchange
+
+          @queue = channel.queue(queue, durable: true)
+        end
+
+        # Publish message to the queue.
+        #
+        # This method will yield the block to get the message.
+        # Message published to NestJS Service must contain `id` key.
+        #
+        # Example:
+        #
+        # ```
+        # client.publish do
+        #   {
+        #     id: 'message_1',
+        #     pattern: 'voucher.voucher.find_one',
+        #     data: { id: 1 }
+        #   }
+        # end
+        # ```
+        def publish(&block)
+          @request = block.call
+
+          exchange.publish(
+            request.to_json,
+            routing_key: queue.name
+          )
+        end
+
+        private
+
+        attr_reader :channel, :exchange, :queue, :request_id, :request
+      end
+    end
+  end
+end

data/lib/lontara_utilities/rmq/client/rpc_producer.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  module RMQ
+    module Client
+      # Client for AMQ on RPC Pattern
+      class RPCProducer
+        def initialize(connection, queue:, reply_queue: 'amq.rabbitmq.reply-to')
+          @channel = connection.channel
+          @exchange = connection.exchange
+          @queue = channel.queue(queue, durable: true)
+          @reply_queue = channel.queue(reply_queue, durable: true)
+
+          # Consumer must be initialized to Reply Queue
+          # before publishing the message.
+          consume_reply
+        end
+
+        # Publish message to the queue.
+        #
+        # This method will yield the block to get the message.
+        # Message published to NestJS Service must contain `id` key.
+        #
+        # Example:
+        #
+        # ```
+        # client.publish do
+        #   {
+        #     id: 'message_1',
+        #     pattern: 'voucher.voucher.find_one',
+        #     data: { id: 1 }
+        #   }
+        # end
+        # ```
+        def publish(&block) # rubocop:disable Metrics/AbcSize
+          @request = block.call
+          @request_id = SecureRandom.uuid
+
+          exchange.publish(
+            request.to_json,
+            routing_key: queue.name,
+            correlation_id: request_id,
+            reply_to: reply_queue.name
+          )
+
+          # waits for the signal from #consume_reply
+          lock.synchronize { condition.wait(lock) }
+
+          response
+        end
+
+        private
+
+        attr_reader :channel,
+                    :exchange,
+                    :queue,
+                    :reply_queue,
+                    :request_id,
+                    :lock,
+                    :condition,
+                    :request,
+                    :response
+
+        def consume_reply
+          @lock = Mutex.new
+          @condition = ConditionVariable.new
+
+          reply_queue.subscribe do |_delivery_info, properties, payload|
+            if properties[:correlation_id] == request_id
+              @response = payload
+
+              # sends the signal to continue the execution of #call
+              lock.synchronize { condition.signal }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lontara_utilities/rmq/client.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  module RMQ
+    # Base module for RMQ client.
+    module Client
+      class << self
+        # Client interface for RMQ Publisher or RPC Publisher.
+        #
+        # Start client by giving url and queue name.
+        # Parameter client must be `RPCProducer` or `Publisher`.
+        # If parameter not defined, default is `RPCProducer`.
+        #
+        # **Use `Publisher` if no need to listen the request's responses.**
+        #
+        # Options params are:
+        # - `default_exchange: (default: true)`
+        #
+        # That option is changing the way Connection object is created.
+        # If set to `false`, connection object didn't create exchange, also connection.exchange property will be `nil`.
+        #
+        # - `queue:`,
+        # - `reply_queue: (default: 'amq.rabbitmq.reply-to')`
+        # (Reply queue is only applicable if `client` is `RPCProducer`).
+        #
+        # These options only applicable if `default_exchange` is `false`, and `client` is `Publisher` (exchange created inside consumer).
+        #  - `exchange:`
+        #  - `exchange_type: (default: :direct)`
+        def start(url: ENV['RABBITMQ_URL'], client: 'RPCProducer', **options)
+          parameter_validator(client, options)
+
+          client_opts = client_opts_assigner(client, options)
+          conn_opts = %i[exchange exchange_type]
+          client = Object.const_get("LontaraUtilities::RMQ::Client::#{client}")
+
+          @connection = Connection.new(url:, **options.slice(*conn_opts))
+
+          @client = client.new(@connection, **client_opts)
+
+          self
+        end
+
+        def publish(request)
+          @client.publish { request }
+        end
+
+        def stop
+          @connection.close
+        end
+
+        private
+
+        def client_opts_assigner(client, options)
+          pubsub_opts = %i[queue exchange exchange_type]
+          rpc_opts = %i[queue reply_queue]
+
+          return options.slice(*pubsub_opts) if client == 'Publisher'
+          return options.slice(*rpc_opts) if client == 'RPCProducer'
+        end
+
+        def parameter_validator(client, options)
+          raise Errors::ClientParameterRequired unless %w[RPCProducer Publisher].include?(client)
+
+          return unless options[:default_exchange] == false
+          raise Errors::DefaultExchangeParameterRequired if client == 'Publisher'
+
+          return unless options[:exchange].nil?
+
+          raise Errors::ExchangeParameterRequired
+        end
+      end
+    end
+  end
+end

data/lib/lontara_utilities/rmq/connection.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  module RMQ
+    # Initializing the connection to RabbitMQ.
+    class Connection
+      # **Connection can be initialized within a block.**
+      #
+      # If block is given, connection object will be yielded.
+      # You can use the object to define the `exchange`, `queue`, or `reply queue`.
+      #
+      # Example:
+      #
+      #   def initialize(url, queue, reply_queue)
+      #     Connection.new(url:) do |conn|
+      #       @exchange = conn.channel.default_exchange
+      #       @queue = conn.channel.queue(queue)
+      #       @reply_queue = conn.channel.queue(reply_queue, exclusive: true)
+      #     end
+      #   end
+      #   # ... your code goes here
+      def initialize(url: ENV['RABBITMQ_URL'], default_exchange: true)
+        @connection = Bunny.new(url)
+        @connection.start
+
+        @channel = channel_pool
+        @exchange = channel.default_exchange if default_exchange
+      end
+
+      def close
+        @connection.close
+      end
+
+      attr_reader :connection, :channel, :exchange
+
+      private
+
+      def channel_pool
+        @channel_pool ||= ConnectionPool.new { @connection }.with(&:create_channel)
+      end
+    end
+  end
+end

data/lib/lontara_utilities/rmq/errors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../base_error'
+
+module LontaraUtilities
+  module RMQ
+    module Errors
+      class ClientParameterRequired < BaseError # rubocop:disable Style/Documentation
+        def initialize(message = 'Client parameter required, and must be RPCProducer or Publisher.') = super
+      end
+
+      class DefaultExchangeParameterRequired < BaseError # rubocop:disable Style/Documentation
+        def initialize(message = "Default exchange parameter required, and shouldn't be false.") = super
+      end
+
+      class ExchangeParameterRequired < BaseError # rubocop:disable Style/Documentation
+        def initialize(message = 'Exchange parameter required unless default_exchange declared.') = super
+      end
+    end
+  end
+end

data/lib/lontara_utilities/rmq/listener.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  module RMQ
+    # Listener for RabbitMQ.
+    #
+    # This class used to define the listener for each request type.
+    # Same as routes.rb in Rails, that define the routes for each request type
+    # and the method to be called.
+    class Listener
+      def self.listen(request)
+        new(request).start
+      end
+
+      def initialize(request)
+        @id = request[:id] if request[:id].present?
+        @pattern = request[:pattern]
+        @data = request[:data]
+      end
+
+      # Start listening the request and process it to the defined listener.
+      def start
+        # Merge message ID if present.
+        id.present? ? { id: }.merge!(listener_response) : listener_response
+      rescue StandardError => e
+        id.present? ? { id: }.merge!(error_response(e)) : error_response(e)
+      end
+
+      private
+
+      attr_reader :id, :pattern, :data
+
+      def listener_response
+        RMQRoutes.draw(with: pattern, data:)
+      end
+
+      def error_response(error)
+        {
+          type: :error,
+          timestamp: Time.now.to_i,
+          data: {
+            message: error.message,
+            code: error.class.name.split('::').last,
+            stacktrace: error.backtrace
+          }
+        }
+      end
+    end
+  end
+end

data/lib/lontara_utilities/rmq/server/rpc_consumer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  module RMQ
+    module Server
+      # Server for AMQ on RPC Pattern,m
+      class RPCConsumer
+        def initialize(connection, queue:)
+          @channel = connection.channel
+          @exchange = connection.exchange
+          @queue = channel.queue(queue, durable: true)
+        end
+
+        # Start consuming the queue, process the request, and publish the response.
+        def start
+          queue.subscribe do |_, properties, payload|
+            @request = JSON.parse(payload, symbolize_names: true)
+
+            publish_response(properties.reply_to, properties.correlation_id)
+          end
+        end
+
+        private
+
+        attr_reader :channel, :exchange, :queue, :request, :response
+
+        def publish_response(reply_queue, correlation_id)
+          process_request
+
+          exchange.publish(response.to_json, routing_key: reply_queue, correlation_id:)
+        end
+
+        def process_request
+          @response = Listener.listen request
+        end
+      end
+    end
+  end
+end

data/lib/lontara_utilities/rmq/server/subscriber.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  module RMQ
+    module Server
+      # Server for AMQ on Direct Pattern
+      class Subscriber
+        def initialize(connection, queue:)
+          @channel = connection.channel
+          @queue = channel.queue(queue, durable: true)
+        end
+
+        # Start consuming the queue and process the request.
+        def start
+          queue.subscribe(manual_ack: true) do |delivery_info, _, body|
+            @request = JSON.parse(body, symbolize_names: true)
+
+            channel.ack(delivery_info.delivery_tag)
+
+            process_request
+          end
+        end
+
+        private
+
+        attr_reader :channel, :queue, :request
+
+        def process_request
+          Listener.listen request
+        end
+      end
+    end
+  end
+end

data/lib/lontara_utilities/rmq/server.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  module RMQ
+    # Base module for RMQ server.
+    module Server
+      class << self
+        # Server interface for RMQ Publisher or RPC Publisher.
+        #
+        # Start server by giving url and queue name.
+        # Parameter server must be `RPCConsumer` or `Subscriber`.
+        # If parameter not defined, default is `RPCConsumer`.
+        #
+        # **Use `Subscriber` if no need to reply the request's responses.**
+        #
+        # Options params is: `default_exchange: (default: true)`
+        #
+        # That option is changing the way Connection object is created.
+        # If set to `false`, connection object didn't create exchange, also connection.exchange property will be `nil`.
+        #
+        # These options only applicable if `default_exchange` is `false`, and `server` is `RPCConsumer` (exchange created inside consumer).
+        #  - `exchange:`
+        #  - `exchange_type: (default: :direct)`
+        #
+        # Be aware of this conditions:
+        # - Don't leave `exchange` where `default_exchange` is `false`, or Server object will raise error.
+        def start(url:, queue:, server: 'RPCConsumer', **options)
+          parameter_validator(server, options)
+
+          server = Object.const_get("LontaraUtilities::RMQ::Server::#{server}")
+          server_opts = %i[exchange exchange_type]
+
+          connection = Connection.new(url:, **options.except(*server_opts))
+
+          server.new(connection, queue:, **options.slice(*server_opts)).start
+        end
+
+        private
+
+        def parameter_validator(server, options)
+          raise ArgumentError, 'server parameter is required, and must be RPCConsumer or Subscriber' if server.nil?
+
+          return unless options[:default_exchange] == false
+          raise ArgumentError, "default_exchange shouldn't be false if server is RPCConsumer" if server == 'RPCConsumer'
+
+          return unless options[:exchange].nil?
+
+          raise ArgumentError, 'exchange parameter is required if default_exchange is false'
+        end
+      end
+    end
+  end
+end

data/lib/lontara_utilities/rmq.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'bunny'
+require 'connection_pool'
+require 'securerandom'
+
+require_relative 'rmq/server/rpc_consumer'
+require_relative 'rmq/client/rpc_producer'
+require_relative 'rmq/server/subscriber'
+require_relative 'rmq/client/publisher'
+require_relative 'rmq/connection'
+require_relative 'rmq/listener'
+require_relative 'rmq/server'
+require_relative 'rmq/client'
+require_relative 'rmq/errors'
+
+module LontaraUtilities
+  # Lontara RMQ
+  #
+  # RMQ module responsible for handling AMQP connection
+  # between services.
+  module RMQ
+    module_function
+
+    # Instantiating RMQ connection.
+    def connection(url:, **options)
+      Connection.new(url:, **options)
+    end
+
+    # RPC Consumer server.
+    # Options parameter are: `exchange:` and `exchange_type:`
+    def rpc_consumer(connection, queue:, **options)
+      Server::RPCConsumer.new(connection, queue:, **options)
+    end
+
+    # Publisher server.
+    def subscriber(connection, queue:)
+      Server::Subscriber.new(connection, queue:)
+    end
+
+    # RPC Producer client.
+    # Options parameter are: `exchange:` and `exchange_type:`
+    def rpc_producer(connection, queue:, reply_queue:, **options)
+      Client::RPCProducer.new(connection, queue:, reply_queue:, **options)
+    end
+
+    # Publisher client.
+    # Options parameter are: `exchange:` and `exchange_type:`
+    def publisher(connection, queue:, **options)
+      Client::Publisher.new(connection, queue:, **options)
+    end
+
+    def client
+      Client
+    end
+
+    def server
+      Server
+    end
+  end
+end

data/lib/lontara_utilities/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LontaraUtilities
+  VERSION = '3.0.0'
+end

data/lib/lontara_utilities.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'lontara_utilities/base_error'
+require_relative 'lontara_utilities/git'
+require_relative 'lontara_utilities/http_client'
+require_relative 'lontara_utilities/rmq'
+require_relative 'lontara_utilities/version'
+require_relative 'lontara'
+
+# Base module for Lontara Utilities
+module LontaraUtilities
+  module_function
+
+  def git
+    Git
+  end
+
+  def rmq
+    RMQ
+  end
+
+  def http_client
+    HTTPClient
+  end
+
+  def version
+    VERSION
+  end
+end

data/lontara-utilities.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'json'
+require 'lontara_utilities/version'
+
+# Load JSON File for Gem metadata
+metadata = JSON.parse(File.read('metadata.json')).transform_keys!(&:to_sym)
+
+Gem::Specification.new do |spec|
+  spec.version = LontaraUtilities::VERSION
+
+  metadata.each do |key, value|
+    # Create keys as methods
+    spec.send("#{key}=", value)
+  end
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 3.1.0'
+
+  spec.add_dependency 'bunny', '~> 2.20'
+  spec.add_dependency 'connection_pool', '~> 2.3'
+  spec.add_dependency 'faraday', '~> 2.7'
+  spec.add_dependency 'json', '~> 2.6'
+  spec.add_dependency 'securerandom', '~> 0.2'
+  spec.add_dependency 'uri', '~> 0.12'
+
+  spec.add_development_dependency 'byebug', '~> 11.1'
+  spec.add_development_dependency 'rspec', '~> 3.12'
+  spec.add_development_dependency 'webmock', '~> 3.18'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/metadata.json

@@ -0,0 +1,9 @@
+{
+    "name": "lontara_utilities",
+    "authors": ["Abdul Hakim Ghaniy"],
+    "email": "abdulhakimghaniy@outlook.co.id",
+    "homepage": "https://github.com/lontara-app/lontara-utilities",
+    "summary": "Lontara Utilities provided by Lontara.app",
+    "description": "Lontara Utilities provides some utils for your Ruby's project, like RabbitMQ Connection for Pub/Sub Messaging and RPC, HTTP Client, Git Branch or Release, and Base Error with some features. This utils used by our Lontara.app's services and we want to share it with you. Built with Faraday, Bunny, SecureRandom, and ConnectionPool. Enjoy!",
+    "license": "GPL-3.0"
+}

metadata

@@ -0,0 +1,200 @@
+--- !ruby/object:Gem::Specification
+name: lontara_utilities
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- Abdul Hakim Ghaniy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-02-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  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: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: securerandom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+description: Lontara Utilities provides some utils for your Ruby's project, like RabbitMQ
+  Connection for Pub/Sub Messaging and RPC, HTTP Client, Git Branch or Release, and
+  Base Error with some features. This utils used by our Lontara.app's services and
+  we want to share it with you. Built with Faraday, Bunny, SecureRandom, and ConnectionPool.
+  Enjoy!
+email: abdulhakimghaniy@outlook.co.id
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- lib/lontara.rb
+- lib/lontara_utilities.rb
+- lib/lontara_utilities/base_error.rb
+- lib/lontara_utilities/git.rb
+- lib/lontara_utilities/git/branch.rb
+- lib/lontara_utilities/git/release.rb
+- lib/lontara_utilities/http_client.rb
+- lib/lontara_utilities/http_client/body_parser.rb
+- lib/lontara_utilities/http_client/request.rb
+- lib/lontara_utilities/rmq.rb
+- lib/lontara_utilities/rmq/client.rb
+- lib/lontara_utilities/rmq/client/publisher.rb
+- lib/lontara_utilities/rmq/client/rpc_producer.rb
+- lib/lontara_utilities/rmq/connection.rb
+- lib/lontara_utilities/rmq/errors.rb
+- lib/lontara_utilities/rmq/listener.rb
+- lib/lontara_utilities/rmq/server.rb
+- lib/lontara_utilities/rmq/server/rpc_consumer.rb
+- lib/lontara_utilities/rmq/server/subscriber.rb
+- lib/lontara_utilities/version.rb
+- lontara-utilities.gemspec
+- metadata.json
+homepage: https://github.com/lontara-app/lontara-utilities
+licenses:
+- GPL-3.0
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key: 
+specification_version: 4
+summary: Lontara Utilities provided by Lontara.app
+test_files: []