active_graphql 0.2.1

data/lib/active_graphql.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'active_graphql/version'
+
+# nodoc
+module ActiveGraphql
+  require 'active_support/core_ext/module/delegation'
+  require 'active_graphql/client'
+  require 'active_graphql/model'
+end

data/lib/active_graphql/client.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  # GraphQL client which can be used to make requests to graphql endpoint
+  #
+  # Example usage:
+  #   client = Client.new(url: 'http://example.com/graphql', headers: { 'Authorization' => 'secret'})
+  #   client.query(:users).select(:name).result
+  class Client
+    require 'active_graphql/client/actions'
+    require 'active_graphql/client/adapters'
+    require 'active_graphql/client/response'
+
+    def initialize(config)
+      @config = config.dup
+      @adapter_class = @config.delete(:adapter)
+    end
+
+    def query(name)
+      Actions::QueryAction.new(name: name, client: adapter)
+    end
+
+    def mutation(name)
+      Actions::MutationAction.new(name: name, client: adapter)
+    end
+
+    def adapter
+      @adapter ||= begin
+        adapter_builder = @adapter_class || Adapters::GraphlientAdapter
+        adapter_builder.new(config)
+      end
+    end
+
+    private
+
+    attr_reader :config
+  end
+end

data/lib/active_graphql/client/actions.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  class Client
+    # nodoc
+    module Actions
+      require 'active_graphql/errors'
+      require 'active_graphql/client/actions/action'
+      require 'active_graphql/client/actions/query_action'
+      require 'active_graphql/client/actions/mutation_action'
+
+      class WrongTypeError < ActiveGraphql::Errors::Error; end
+    end
+  end
+end

data/lib/active_graphql/client/actions/action.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  class Client
+    module Actions
+      # Base class for query/mutation action objects
+      class Action
+        class InvalidActionError < StandardError; end
+
+        require 'active_graphql/client/actions/action/format_outputs'
+        require 'active_graphql/client/actions/action/format_inputs'
+
+        attr_reader :name, :type, :output_values, :client, :input_attributes, :meta_attributes
+
+        delegate :result, :result!, to: :response
+
+        def initialize(name:, client:, output_values: [], input_attributes: {}, meta_attributes: {})
+          @name = name
+          @output_values = output_values
+          @input_attributes = input_attributes
+          @meta_attributes = meta_attributes
+          @client = client
+        end
+
+        def inspect
+          "#<#{self.class} " \
+            "name: #{name.inspect}, " \
+            "input: #{input_attributes.inspect}, " \
+            "output: #{output_values.inspect}, " \
+            "meta: #{meta_attributes.inspect}" \
+            '>'
+        end
+
+        def rewhere(**input_attributes)
+          chain(input_attributes: input_attributes)
+        end
+
+        def where(**extra_input_attributes)
+          rewhere(**input_attributes, **extra_input_attributes)
+        end
+        alias input where
+
+        def response
+          client.post(self)
+        end
+
+        def meta(new_attributes)
+          chain(meta_attributes: meta_attributes.merge(new_attributes))
+        end
+
+        def reselect(*array_outputs, **hash_outputs)
+          outputs = join_array_and_hash(*array_outputs, **hash_outputs)
+          chain(output_values: outputs)
+        end
+
+        def select(*array_outputs, **hash_outputs)
+          full_array_outputs = (output_values + array_outputs).uniq
+          reselect(*full_array_outputs, **hash_outputs)
+        end
+        alias output select
+
+        def to_graphql
+          assert_format
+
+          <<~TXT
+            #{type} {
+              #{name}#{wrapped_header formatted_inputs} {
+                #{formatted_outputs}
+              }
+            }
+          TXT
+        end
+
+        private
+
+        def join_array_and_hash(*array, **hash)
+          array + hash.map { |k, v| { k => v } }
+        end
+
+        def formatted_inputs
+          FormatInputs.new(input_attributes).call
+        end
+
+        def formatted_outputs
+          FormatOutputs.new(output_values).call
+        end
+
+        def assert_format
+          return unless output_values.empty?
+
+          raise(
+            InvalidActionError,
+            'at least one return value must be set. Do `query.select(:fields_to_return)` to do so'
+          )
+        end
+
+        def chain(**new_values)
+          self.class.new(
+            name: name,
+            output_values: output_values,
+            input_attributes: input_attributes,
+            meta_attributes: meta_attributes,
+            client: client,
+            **new_values
+          )
+        end
+
+        def wrapped_header(header_text)
+          return '' if header_text.empty?
+
+          "(#{header_text})"
+        end
+      end
+    end
+  end
+end

data/lib/active_graphql/client/actions/action/format_inputs.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  class Client
+    module Actions
+      class Action
+        # converts ruby object in to grapqhl input string
+        class FormatInputs
+          def initialize(inputs)
+            @inputs = inputs
+          end
+
+          def call
+            return '' if inputs.empty?
+
+            formatted(inputs)
+          end
+
+          private
+
+          attr_reader :inputs
+
+          def formatted(attributes)
+            if attributes.is_a?(Hash)
+              formatted_attributes(attributes)
+            else
+              raise(
+                ActiveGraphql::Client::Actions::WrongTypeError,
+                "Unsupported attribute type: #{attributes.inspect}:#{attributes.class}"
+              )
+            end
+          end
+
+          def formatted_attributes(attributes)
+            attributes = attributes.dup
+            keyword_fields = (attributes.delete(:__keyword_attributes) || []).map(&:to_s)
+
+            formatted_attributes = attributes.map do |key, val|
+              if keyword_fields.include?(key.to_s)
+                formatted_key_and_keyword(key, val)
+              else
+                formatted_key_and_value(key, val)
+              end
+            end
+
+            formatted_attributes.join(', ')
+          end
+
+          def formatted_key_and_value(key, value)
+            "#{key}: #{formatted_value(value)}"
+          end
+
+          def formatted_key_and_keyword(key, value)
+            if value.is_a?(String) || value.is_a?(Symbol)
+              "#{key}: #{value}"
+            else
+              "#{key}: #{formatted_value(value)}"
+            end
+          end
+
+          def formatted_value(value) # rubocop:disable Metrics/MethodLength
+            case value
+            when Hash
+              "{ #{formatted(value)} }"
+            when Array
+              formatted_values = value.map { |it| formatted_value(it) }
+              "[#{formatted_values.join(', ')}]"
+            when nil
+              'null'
+            when Symbol
+              value.to_s.inspect
+            else
+              value.inspect
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_graphql/client/actions/action/format_outputs.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  class Client
+    module Actions
+      class Action
+        # converts ruby object in to grapqhl output string
+        class FormatOutputs
+          def initialize(outputs)
+            @outputs = outputs
+          end
+
+          def call
+            Array.wrap(outputs).map { |it| formatted(it) }.join(', ')
+          end
+
+          private
+
+          attr_reader :outputs
+
+          def formatted(attribute) # rubocop:disable Metrics/MethodLength
+            case attribute
+            when Hash
+              attribute.map { |key, value| "#{key} { #{formatted(value)} }" }.join(', ')
+            when Symbol, String
+              attribute.to_s
+            when Array
+              attribute.map { |it| formatted(it) }.join(', ')
+            else
+              raise(
+                ActiveGraphql::Client::Actions::WrongTypeError,
+                "Unsupported attribute type: #{attribute.inspect}:#{attribute.class}"
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_graphql/client/actions/mutation_action.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  class Client
+    module Actions
+      # handles all action details which are specific for mutation type request
+      class MutationAction < Action
+        require 'active_graphql/errors'
+
+        class UnsuccessfullRequestError < ActiveGraphql::Errors::Error; end
+
+        def type
+          :mutation
+        end
+
+        def update(inputs)
+          where(inputs).response
+        end
+
+        def update!(inputs)
+          response = where(inputs).response
+          return response.result if response.success?
+
+          raise UnsuccessfullRequestError, response.errors.first
+        end
+      end
+    end
+  end
+end

data/lib/active_graphql/client/actions/query_action.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  class Client
+    module Actions
+      # handles all action details which are specific for query type request
+      class QueryAction < Action
+        def type
+          :query
+        end
+
+        def find_by(inputs)
+          where(inputs).result
+        end
+
+        def select_paginated(*array_outputs, **hash_outputs)
+          outputs = join_array_and_hash(*array_outputs, **hash_outputs)
+          select(edges: { node: outputs })
+        end
+      end
+    end
+  end
+end

data/lib/active_graphql/client/adapters.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  class Client
+    # nodoc
+    module Adapters
+      autoload :GraphlientAdapter, 'active_graphql/client/adapters/graphlient_adapter'
+    end
+  end
+end

data/lib/active_graphql/client/adapters/graphlient_adapter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  class Client
+    module Adapters
+      # Client which makes raw API requests to GraphQL server
+      class GraphlientAdapter
+        require 'graphlient'
+
+        def initialize(config)
+          @url = config[:url]
+          @adapter_config = config.except(:url)
+        end
+
+        def post(action)
+          raw_response = graphql_client.query(action.to_graphql)
+          Response.new(raw_response.data)
+        rescue Graphlient::Errors::GraphQLError => e
+          Response.new(nil, e)
+        end
+
+        private
+
+        attr_reader :url, :adapter_config
+
+        def graphql_client
+          @graphql_client ||= Graphlient::Client.new(url, **adapter_config)
+        end
+      end
+    end
+  end
+end

data/lib/active_graphql/client/response.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  class Client
+    # graphql response wrapper
+    class Response
+      attr_reader :graphql_object
+
+      def initialize(graphql_object, error = nil)
+        if graphql_object
+          root_field = graphql_object.to_h.keys.first.to_s.underscore
+          @graphql_object = graphql_object.public_send(root_field)
+        end
+
+        @graphql_error = error if error
+      end
+
+      def result
+        graphql_object
+      end
+
+      def result!
+        raise ResponseError, errors.first if errors.any?
+
+        graphql_object
+      end
+
+      def success?
+        graphql_error.nil?
+      end
+
+      def detailed_errors
+        return [] if graphql_error.blank?
+
+        graphql_error.errors.details['data'].map(&:with_indifferent_access)
+      end
+
+      def errors
+        detailed_errors.map { |error| error[:message] }
+      end
+
+      private
+
+      attr_reader :graphql_error
+    end
+  end
+end