strapi_ruby 0.1.0

data/lib/strapi_ruby/client.rb

@@ -0,0 +1,95 @@
+require "faraday"
+require "json"
+
+module StrapiRuby
+  class Client
+    attr_reader :connection
+
+    def initialize(options = {}, &block)
+      @connection = set_connection(options, &block)
+    end
+
+    def get(endpoint)
+      response = performs_request { @connection.get(endpoint) }
+      handle_response(response)
+    end
+
+    def post(endpoint, body)
+      response = performs_request { @connection.post(endpoint, build_data_payload(body)) }
+      handle_response(response)
+    end
+
+    def put(endpoint, body)
+      response = performs_request { @connection.put(endpoint, build_data_payload(body)) }
+      handle_response(response)
+    end
+
+    def delete(endpoint)
+      response = performs_request { @connection.delete(endpoint) }
+      handle_response(response)
+    end
+
+    private
+
+    def set_connection(options, &block)
+      url = options[:strapi_server_uri]
+      strapi_token = options[:strapi_token]
+
+      default_headers = { "Content-Type" => "application/json",
+                          "Authorization" => "Bearer #{strapi_token}",
+                          "User-Agent" => "StrapiRuby/#{StrapiRuby::VERSION}" }
+
+      Faraday.new(url: url) do |faraday|
+        faraday.request :url_encoded
+        faraday.adapter Faraday.default_adapter
+        block&.call(faraday)
+        faraday.headers = default_headers.merge(faraday.headers)
+      end
+    end
+
+    def performs_request
+      begin
+        yield
+      rescue Faraday::ConnectionFailed => e
+        raise ConnectionError, "#{ErrorMessage.connection_failed} #{e.message}"
+      rescue Faraday::TimeoutError => e
+        raise ConnectionError, "#{ErrorMessage.timeout} #{e.message}"
+      rescue StandardError => e
+        raise ConnectionError, "#{ErrorMessage.unexpected} #{e.message}"
+      end
+    end
+
+    def convert_json_to_open_struct(json)
+      JSON.parse(json, object_class: OpenStruct)
+    rescue JSON::ParserError => e
+      raise JSONParsingError, e.message
+    end
+
+    def build_data_payload(body)
+      { data: body }.to_json
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def handle_response(response)
+      body = convert_json_to_open_struct(response.body)
+      case response.status
+      when 200
+        body
+      when 400
+        raise BadRequestError.new(body.error.message, response.status)
+      when 401
+        raise UnauthorizedError.new(body.error.message, response.status)
+      when 403
+        raise ForbiddenError.new(body.error.message, response.status)
+      when 404
+        raise NotFoundError.new(body.error.message, response.status)
+      when 422
+        raise UnprocessableEntityError.new(body.error.message, response.status)
+      when 500..599
+        raise ServerError.new(body.error.message, response.status)
+      end
+    end
+
+    # rubocop:enable Metrics/AbcSize
+  end
+end

data/lib/strapi_ruby/config.rb

@@ -0,0 +1,27 @@
+module StrapiRuby
+  class Config
+    include StrapiRuby::Validations
+
+    attr_accessor :strapi_server_uri,
+                  :strapi_token,
+                  :faraday,
+                  :convert_to_html,
+                  :convert_to_datetime,
+                  :show_endpoint
+
+    def initialize
+      @strapi_server_uri = nil
+      @strapi_token = nil
+      @faraday = nil
+      @convert_to_datetime = true
+      @convert_to_html = []
+      @show_endpoint = false
+    end
+
+    def call
+      validate_config(self)
+      # We convert to symbols if user passed strings for convert_to_html options
+      @convert_to_html.map!(&:to_sym)
+    end
+  end
+end

data/lib/strapi_ruby/configuration.rb

@@ -0,0 +1,21 @@
+module StrapiRuby
+  module Configuration
+    def config
+      @config ||= Config.new
+    end
+
+    def configure
+      yield(config)
+      config.call
+      client
+    end
+
+    private
+
+    def client
+      @client ||= Client.new(
+        strapi_server_uri: @config.strapi_server_uri, strapi_token: @config.strapi_token, &@config.faraday
+      )
+    end
+  end
+end

data/lib/strapi_ruby/endpoint/builder.rb

@@ -0,0 +1,40 @@
+module StrapiRuby
+  module Endpoint
+    class Builder
+      def initialize(options = {})
+        @resource = options[:resource]
+        @id = options[:id]
+        @query = Query.new(options).call
+        @result = nil
+      end
+
+      def call
+        build_endpoint
+        append_query
+        @result
+      end
+
+      private
+
+      def build_endpoint
+        @result = if builds_collection?
+                    "#{base_uri}/#{@resource}/#{@id}"
+                  else
+                    "#{base_uri}/#{@resource}"
+                  end
+      end
+
+      def append_query
+        @result += @query if @query
+      end
+
+      def builds_collection?
+        !@id.nil?
+      end
+
+      def base_uri
+        StrapiRuby.config.strapi_server_uri
+      end
+    end
+  end
+end

data/lib/strapi_ruby/endpoint/query.rb

@@ -0,0 +1,31 @@
+module StrapiRuby
+  module Endpoint
+    class Query
+      include StrapiParameters
+
+      def initialize(options = {})
+        @result = ""
+        @options = options
+        parse_query_params
+      end
+
+      def call
+        if @options[:raw]
+          @result = @options[:raw]
+        else
+          @result
+        end
+      end
+
+      private
+
+      def parse_query_params
+        return if @options[:raw]
+
+        @options.each do |key, value|
+          send(key, value) if @options[key] && respond_to?(key, true)
+        end
+      end
+    end
+  end
+end

data/lib/strapi_ruby/endpoint/strapi_parameters.rb

@@ -0,0 +1,132 @@
+require "uri"
+
+module StrapiRuby
+  module Endpoint
+    module StrapiParameters
+      private
+
+      def sort(args)
+        build_query_from_args(args, :sort)
+      end
+
+      def fields(args)
+        build_query_from_args(args, :fields)
+      end
+
+      def populate(args)
+        build_query_from_args(args, :populate)
+      end
+
+      def filters(args)
+        build_query_from_args(args, :filters)
+      end
+
+      def page_size(number)
+        raise TypeError, "#{ErrorMessage.expected_integer} Got #{number.class.name}" unless number.is_a?(Integer)
+
+        check_single_pagination
+        @result += "#{prefix}pagination[pageSize]=#{number}"
+      end
+
+      # Sets the page number for the query result.
+      #
+      # @param number [Integer] An Integer representing the page number.
+      #
+      # @return [String] The updated query string with the page number option added.
+      def page(number)
+        raise TypeError, "#{ErrorMessage.expected_integer} Got #{number.class.name}" unless number.is_a?(Integer)
+
+        check_single_pagination
+        @result += "#{prefix}pagination[page]=#{number}"
+      end
+
+      # Sets the offset for the query result.
+      #
+      # @param number [Integer] An Integer representing the offset.
+      #
+      # @return [String] The updated query string with the offset option added.
+      def start(number)
+        raise TypeError, "#{ErrorMessage.expected_integer} Got #{number.class.name}" unless number.is_a?(Integer)
+
+        check_single_pagination
+        @result += "#{prefix}pagination[start]=#{number}"
+      end
+
+      # Sets the limit for the query result.
+      #
+      # @param number [Integer] An Integer representing the limit.
+      #
+      # @return [String] The updated query string with the limit option added.
+      def limit(number)
+        raise TypeError unless number.is_a?(Integer)
+
+        check_single_pagination
+        @result += "#{prefix}pagination[limit]=#{number}"
+      end
+
+      ##
+      # Sets the locale for the query result.
+      #
+      # @params arg [String, Symbol] A String or Symbol representing the locale.
+      #
+      # @return [String] The updated query string with the locale option added.
+      def locale(arg)
+        raise TypeError, "#{ErrorMessage.expected_string_symbol} Got #{arg.class.name}" unless arg.is_a?(String) || arg.is_a?(Symbol)
+
+        @result += "#{prefix}locale=#{arg}"
+      end
+
+      def publication_state(arg)
+        raise TypeError, "#{ErrorMessage.expected_string_symbol} Got #{arg.class.name}" unless arg.is_a?(String) || arg.is_a?(Symbol)
+        raise ArgumentError, "#{ErrorMessage.publication_state} Got #{arg}" unless arg.to_sym == :live || arg.to_sym == :preview
+
+        @result += "#{prefix}publicationState=#{arg}"
+      end
+
+      # Checks params don't combine pagination methods.
+      #
+      def check_single_pagination
+        return unless (@options.key?(:page) && @options.key?(:start)) ||
+                      (@options.key(:page) && @options.key?(:limit)) ||
+                      (@options.key(:pagination) && options.key?(:start)) ||
+                      (@options.key(:pagination) && options.key?(:limit))
+
+        raise ArgumentError, ErrorMessage.pagination
+      end
+
+      # builds the prefix for the query string (either "?" or "&" depending on whether the query string is empty or not).
+      #
+      # @return [String] A String representing the prefix.
+      def prefix
+        @result.empty? ? "?" : "&"
+      end
+
+      def build_query_from_args(args, method_name)
+        query = prefix
+        hash = {}
+        hash[method_name] = args
+        query += traverse_hash(hash)
+        @result += query
+      end
+
+      def traverse_hash(hash, parent_key = nil)
+        hash.map do |key, value|
+          current_key = parent_key ? "#{parent_key}[#{key}]" : key.to_s
+
+          if value.is_a?(Hash)
+            traverse_hash(value, current_key)
+          elsif value.is_a?(Array)
+            value.map.with_index do |item, index|
+              traverse_hash({ index => item }, current_key)
+            end
+          else
+            # We can pass values as symbols but we need to convert them to string
+            # to be able to escape them
+            value = value.to_s if value.is_a?(Symbol)
+            "#{current_key}=#{CGI.escape(value)}"
+          end
+        end.join("&")
+      end
+    end
+  end
+end

data/lib/strapi_ruby/errors/client_error.rb

@@ -0,0 +1,48 @@
+module StrapiRuby
+  class ClientError < StandardError
+  end
+
+  class ConnectionError < ClientError
+    def initialize(message)
+      super("There is a problem while initializing the connection with Faraday: #{message}")
+    end
+  end
+
+  class UnauthorizedError < ClientError
+    def initialize(message, status)
+      super("There is an error from the Strapi server with status #{status}: #{message}. Make sure your strapi_token is valid.")
+    end
+  end
+
+  class ForbiddenError < ClientError
+    def initialize(message, status)
+      super("There is an error from the Strapi server with status #{status}: #{message}. Make sure your strapi_token has the correct permissions or allow public access.")
+    end
+  end
+
+  class NotFoundError < ClientError
+    def initialize(message, status)
+      super("There is an error from the Strapi server with status #{status}: #{message}.")
+    end
+  end
+
+  class UnprocessableEntityError < ClientError
+    def initialize(message, status)
+      super("There is an error from the Strapi server with status #{status}: #{message}.")
+    end
+  end
+
+  class ServerError < ClientError
+    def initialize(message, status)
+      super("There is an error from the Strapi server with status #{status}: #{message}. Please try again later.")
+    end
+  end
+
+  class BadRequestError < ClientError
+    def initialize(message, status)
+      super("There is an error from the Strapi server with status #{status}: #{message}. Check parameters")
+    end
+  end
+
+  class JSONParsingError < ClientError; end
+end

data/lib/strapi_ruby/errors/configuration_error.rb

@@ -0,0 +1,7 @@
+module StrapiRuby
+  class ConfigurationError < StandardError
+    def initialize(message)
+      super("You must configure StrapiRuby before using it. See README.md for details.\n #{message}")
+    end
+  end
+end

data/lib/strapi_ruby/errors/error_code.yml

@@ -0,0 +1,9 @@
+missing_configuration: >
+  StrapiRuby.configure do |config|
+    config.strapi_server_uri = 'https://example.com'
+    config.strapi_token = '123'
+  end
+missing_ressource: >
+  StrapiRuby.get(resource: :restaurants)
+missing_data: >
+  StrapiRuby.post(resource: :restaurants, data: { name: 'My restaurant' })

data/lib/strapi_ruby/errors/error_message.rb

@@ -0,0 +1,41 @@
+require "yaml"
+
+module StrapiRuby
+  class ErrorMessage
+    class << self
+      def method_missing(method_name, *_args)
+        define_singleton_method(method_name) do
+          text = text_yaml[method_name.to_s]
+          code = code_yaml[method_name.to_s]
+
+          build_error_message(text, code)
+        end
+
+        send(method_name)
+      end
+
+      private
+
+      def text_yaml
+        load_yaml("text")
+      end
+
+      def code_yaml
+        load_yaml("code")
+      end
+
+      def load_yaml(filename)
+        path = File.join(current_directory, "error_#{filename}.yml")
+        YAML.load_file(path)
+      end
+
+      def current_directory
+        File.dirname(__FILE__)
+      end
+
+      def build_error_message(text, code = nil)
+        "\n\n#{text}\n\n#{code ? "Example:\n\n#{code}\n\n" : ""}"
+      end
+    end
+  end
+end

data/lib/strapi_ruby/errors/error_text.yml

@@ -0,0 +1,13 @@
+missing_configuration: Config block missing. Configure plugin in /config/strapi_ruby.rb.
+missing_ressource: Ressource is missing.
+missing_data: Data key is missing from parameters. You need to pass a body to perform this HTTP request (POST, PUT).
+connection_failed: Connection failed!
+timeout: Timeout reached!
+unexpected: An unexpected error occured.
+expected_array: Invalid argument type. Expected Array.
+expected_hash: Invalid argument type. Expected Hash.
+expected_string_symbol: Invalid argument type. Expected String or Symbol.
+expected_integer: Invalid argument type. Expected Integer.
+expected_proc: Invalid argument type. Expected Proc.
+publication_state: Invalid argument. Expected :live or :preview.
+pagination: Use a single pagination method, either by page or by offset

data/lib/strapi_ruby/formatter.rb

@@ -0,0 +1,88 @@
+module StrapiRuby
+  class Formatter
+    def initialize(options = {})
+      @keys_to_convert = options[:convert_to_html] || StrapiRuby.config.convert_to_html
+    end
+
+    def call(data)
+      # Check data for emptiness
+      check_emptiness(data)
+
+      converted_data = data.clone
+      convert_to_html!(converted_data)
+      convert_to_datetime!(converted_data)
+      converted_data
+    end
+
+    private
+
+    def convert_to_datetime!(data)
+      return unless StrapiRuby.config.convert_to_datetime
+
+      if collection?(data)
+        data.each { |item| parse_into_datetime!(item.attributes) }
+      else
+        parse_into_datetime!(data.attributes)
+      end
+    end
+
+    def parse_into_datetime!(attributes)
+      traverse_struct_and_change_key!(attributes, "createdAt")
+      traverse_struct_and_change_key!(attributes, "publishedAt")
+      traverse_struct_and_change_key!(attributes, "updatedAt")
+    end
+
+    def traverse_struct_and_change_key!(struct, key_to_check, path = [])
+      struct.each_pair do |key, value|
+        current_path = path + [key]
+
+        struct.send("#{key}=", DateTime.parse(struct.send(key_to_check.to_sym))) if key.to_s == key_to_check && struct.respond_to?(key_to_check.to_sym)
+
+        if value.is_a?(OpenStruct)
+          traverse_struct_and_change_key!(value, key_to_check, current_path)
+        elsif value.is_a?(Array)
+          value.each_with_index do |item, index|
+            traverse_struct_and_change_key!(item, key_to_check, current_path + [index]) if item.is_a?(OpenStruct)
+          end
+        end
+      end
+    end
+
+    def check_emptiness(data)
+      if collection?(data)
+        data if data.all? { |item| item.to_h.empty? }
+      elsif data.to_h.empty?
+        data
+      end
+    end
+
+    def collection?(data)
+      data.is_a?(Array)
+    end
+
+    def convert_to_html!(data)
+      if collection?(data)
+        data.each { |item| convert_attributes!(item.attributes) }
+      else
+        convert_attributes!(data.attributes)
+      end
+    end
+
+    def convert_attributes!(attributes)
+      # Loop through the methods of the attributes
+      attributes.methods.map do |method|
+        # Check if the method is in the keys to convert
+        next unless @keys_to_convert.include?(method)
+
+        # Get the value of the method
+        method_value = attributes.send(method)
+        # Convert and set the value of the method
+        attributes.send("#{method}=", convert_value_to_html(method_value))
+      end
+    end
+
+    def convert_value_to_html(value)
+      Markdown.instance.to_html(value)
+    end
+  end
+end

data/lib/strapi_ruby/interface.rb

@@ -0,0 +1,81 @@
+module StrapiRuby
+  module Interface
+    include StrapiRuby::Validations
+
+    def get(options = {})
+      request(:get, options)
+    end
+
+    def post(options = {})
+      request(:post, options)
+    end
+
+    def put(options = {})
+      request(:put, options)
+    end
+
+    def delete(options = {})
+      request(:delete, options)
+    end
+
+    def escape_empty_answer(answer)
+      return answer.error.message if answer.data.nil? && answer.error
+      yield
+    end
+
+    private
+
+    def request(http_verb, options = {})
+      begin
+        validate_options(options)
+        @endpoint = build_endpoint(options)
+        answer = build_answer(http_verb, @endpoint, options)
+        data = format_data(answer.data, options)
+        meta = answer.meta
+
+        return_success_open_struct(data, meta, options)
+      rescue StrapiRuby::ClientError, StrapiRuby::ConfigError => e
+        return_error_open_struct(e, options)
+      end
+    end
+
+    def build_answer(http_verb, endpoint, options)
+      if %i[get delete].include?(http_verb)
+        @client.public_send(http_verb, endpoint)
+      else
+        validate_data_presence(options)
+        body = options[:data]
+        @client.public_send(http_verb, endpoint, body)
+      end
+    end
+
+    def show_endpoint?(options)
+      options[:show_endpoint] || StrapiRuby.config.show_endpoint
+    end
+
+    def return_success_open_struct(data, meta, error = nil, options = {})
+      if show_endpoint?(options)
+        OpenStruct.new(data: data,
+                       meta: meta,
+                       endpoint: @endpoint).freeze
+      else
+        OpenStruct.new(data: data, meta: meta).freeze
+      end
+    end
+
+    def return_error_open_struct(error, options = {})
+      OpenStruct.new(error: OpenStruct.new(message: "#{error.class}: #{error.message}"),
+                     endpoint: @endpoint,
+                     data: nil,
+                     meta: nil).freeze
+    end
+
+    def build_endpoint(options)
+      Endpoint::Builder.new(options).call
+    end
+
+    def format_data(data, options = {})
+      Formatter.new(options).call(data)
+    end
+  end
+end

data/lib/strapi_ruby/markdown.rb

@@ -0,0 +1,20 @@
+require "singleton"
+require "redcarpet"
+
+# Use with Markdown.instance.to_html
+
+module StrapiRuby
+  class Markdown
+    include Singleton
+
+    def to_html(markdown)
+      markdown_renderer.render(markdown)
+    end
+
+    private
+
+    def markdown_renderer
+      @markdown_renderer ||= Redcarpet::Markdown.new(Redcarpet::Render::HTML, { autolink: true })
+    end
+  end
+end

data/lib/strapi_ruby/railtie.rb

@@ -0,0 +1,12 @@
+module StrapiRuby
+  class Railtie < Rails::Railtie
+    railtie_name :strapi_ruby
+
+    if defined?(Rake)
+      rake_tasks do
+        path = File.expand_path(__dir__)
+        Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
+      end
+    end
+  end
+end