active_graphql 0.2.1

data/lib/active_graphql/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  module Errors
+    class Error < StandardError; end
+    class RecordNotFoundError < ActiveGraphql::Errors::Error; end
+    class ResponseError < ActiveGraphql::Errors::Error; end
+    class WrongTypeError < ActiveGraphql::Errors::Error; end
+    class RecordNotValidError < ActiveGraphql::Errors::Error; end
+  end
+end

data/lib/active_graphql/model.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  # Allows to have ActiveRecord-like models which comunicates with graphql endpoint instead of DB:
+  # class RemoteUser
+  #   include ActiveGraphql::Model
+  #
+  #   graphql_url('http://localhost:3001/graphql')
+  #   graphql_attributes :id, :full_name
+  # end
+  #
+  # Now you can do:
+  # RemoteUser.where(created_at { from: '2000-01-01', to: '2010-01-01' })
+  # RemoteUser.all.for_each { |user| ... }
+  # RemoteUser.where(...).count
+  #
+  # Model expects that graphql has GraphqlRails CRUD actions with default naming (createRemoteUser, remoteUsers, etc.)
+  module Model
+    require 'active_graphql/model/configuration'
+    require 'active_graphql/model/action_formatter'
+    require 'active_graphql/model/relation_proxy'
+    require 'active_support'
+    require 'active_support/core_ext/hash'
+    require 'active_model'
+
+    extend ActiveSupport::Concern
+
+    included do # rubocop:disable Metrics/BlockLength
+      include ActiveModel::Validations
+
+      validate :validate_graphql_errors
+
+      attr_reader :attributes
+      attr_writer :graphql_errors
+
+      def initialize(attributes)
+        @attributes = attributes.deep_transform_keys { |it| it.to_s.underscore.to_sym }
+      end
+
+      def mutate(action_name, params = {})
+        all_params = { primary_key => primary_key_value }.merge(params)
+        response = exec_graphql { |api| api.mutation(action_name.to_s).input(all_params) }
+        self.attributes = response.result.to_h
+        self.graphql_errors = response.detailed_errors
+        valid?
+      end
+
+      def update(params)
+        action_name = "update_#{self.class.active_graphql.resource_name}"
+        mutate(action_name, params)
+      end
+
+      def update!(params)
+        success = update(params)
+        return true if success
+
+        error_message = (errors['graphql'] || errors.full_messages).first
+        raise Errors::RecordNotValidError, error_message
+      end
+
+      def attributes=(new_attributes)
+        formatted_new_attributes = new_attributes.deep_transform_keys { |it| it.to_s.underscore.to_sym }
+        @attributes = attributes.merge(formatted_new_attributes)
+      end
+
+      def destroy
+        action_name = "destroy_#{self.class.active_graphql.resource_name}"
+        response = exec_graphql { |api| api.mutation(action_name).input(primary_key => primary_key_value) }
+        response.success?
+      end
+
+      def reload
+        self.attributes = self.class.find(primary_key_value).attributes
+        self
+      end
+
+      protected
+
+      def exec_graphql(*args, &block)
+        self.class.exec_graphql(*args, &block)
+      end
+
+      def read_graphql_attribute(attribute)
+        value = attributes[attribute.name]
+        if attribute.decorate_with
+          send(attribute.decorate_with, value)
+        else
+          value
+        end
+      end
+
+      private
+
+      def graphql_errors
+        @graphql_errors ||= []
+      end
+
+      def validate_graphql_errors
+        graphql_errors.each do |error|
+          error_key = error[:field] || 'graphql'
+          error_message = error[:short_message] || error[:message]
+
+          errors.add(error_key, error_message)
+        end
+      end
+
+      def read_attribute_for_validation(key)
+        key == 'graphql' ? key : super
+      end
+
+      def primary_key
+        self.class.active_graphql.primary_key
+      end
+
+      def primary_key_value
+        send(primary_key)
+      end
+    end
+
+    class_methods do # rubocop:disable Metrics/BlockLength
+      delegate :first, :last, :limit, :count, :where, :select, :select_attributes, :find_each, :find, to: :all
+
+      def inherited(sublass)
+        sublass.instance_variable_set(:@active_graphql, active_graphql.dup)
+      end
+
+      def active_graphql
+        @active_graphql ||= ActiveGraphql::Model::Configuration.new
+        if block_given?
+          yield(@active_graphql)
+          @active_graphql.attributes.each do |attribute|
+            define_method(attribute.name) do
+              read_graphql_attribute(attribute)
+            end
+          end
+        end
+        @active_graphql
+      end
+
+      def create(params)
+        action_name = "create_#{active_graphql.resource_name}"
+        response = exec_graphql { |api| api.mutation(action_name).input(params) }
+        new(response.result.to_h).tap do |record|
+          record.graphql_errors = response.detailed_errors if !response.success? || !record.valid?
+        end
+      end
+
+      def create!(params)
+        record = create(params)
+
+        return record if record.valid?
+
+        error_message = (record.errors['graphql'] || record.errors.full_messages).first
+        raise Errors::RecordNotValidError, error_message
+      end
+
+      def all
+        @all ||= ::ActiveGraphql::Model::RelationProxy.new(self)
+      end
+
+      def exec_graphql
+        formatter = active_graphql.formatter
+        api = active_graphql.graphql_client
+
+        raw_action = \
+          yield(api)
+          .output(*select_attributes)
+          .meta(primary_key: active_graphql.primary_key)
+
+        formatter.call(raw_action).response
+      end
+    end
+  end
+end

data/lib/active_graphql/model/action_formatter.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  module Model
+    # reformats action to default format which very opinionated and based in following assumptions:
+    # * all attributes and fields are camel cased
+    # * all mutation actions accept one or two fields: id and input (input is everyting except 'id')
+    # * collection actions are paginated and accepts input attribute `filter`
+    #
+    # github graphql structure was used as inspiration
+    class ActionFormatter
+      require 'active_support/core_ext/string'
+
+      def self.call(action)
+        new(action).call
+      end
+
+      def initialize(action)
+        @action = action
+      end
+
+      def call
+        action.class.new(
+          name: formatted_name,
+          client: action.client,
+          output_values: formatted_outputs,
+          input_attributes: formatted_inputs.symbolize_keys
+        )
+      end
+
+      private
+
+      attr_reader :action
+
+      def primary_key
+        action.meta_attributes.fetch(:primary_key, 'id').to_s
+      end
+
+      def formatted_name
+        action.name.camelize(:lower)
+      end
+
+      def formatted_inputs
+        attributes = action.input_attributes.deep_transform_keys do |key|
+          key.to_s.starts_with?('__') ? key : key.to_s.camelize(:lower)
+        end
+
+        if mutation?
+          formatted_mutation_inputs(attributes)
+        else
+          attributes
+        end
+      end
+
+      def formatted_mutation_inputs(attributes)
+        {
+          'input' => attributes.except(primary_key).presence,
+          primary_key => attributes[primary_key]
+        }.compact
+      end
+
+      def mutation?
+        action.type == :mutation
+      end
+
+      def paginated?
+        action.meta_attributes[:paginated]
+      end
+
+      def formatted_outputs
+        outputs = formatted_output_values(action.output_values)
+
+        if paginated?
+          {
+            edges: { node: outputs },
+            pageInfo: [:hasNextPage]
+          }
+        else
+          outputs.is_a?(Hash) ? outputs.symbolize_keys : outputs
+        end
+      end
+
+      def formatted_output_values(attributes)
+        if attributes.is_a?(Array)
+          attributes.map { |it| formatted_output_values(it) }
+        elsif attributes.is_a?(Hash)
+          attributes
+            .transform_keys { |key| formatted_output_values(key) }
+            .transform_values { |value| formatted_output_values(value) }
+        else
+          attributes.to_s.camelize(:lower)
+        end
+      end
+    end
+  end
+end

data/lib/active_graphql/model/build_or_relation.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  module Model
+    # reformats action to default format which very opinionated and based in following assumptions:
+    # * all attributes and fields are camel cased
+    # * all mutation actions accept one or two fields: id and input (input is everyting except 'id')
+    # * collection actions are paginated and accepts input attribute `filter`
+    #
+    # github graphql structure was used as inspiration
+    class BuildOrRelation
+      def self.call(*args)
+        new(*args).call
+      end
+
+      def initialize(left_scope, right_scope)
+        @left_scope = left_scope
+        @right_scope = right_scope
+      end
+
+      def call
+        shared_scope.where(or: or_attributes)
+      end
+
+      private
+
+      attr_reader :left_scope, :right_scope
+
+      def shared_scope
+        @shared_scope ||= clean_scope.where(shared_attributes)
+      end
+
+      def clean_scope
+        left_scope.where_attributes.keys.reduce(left_scope) { |final, key| final.unscope(where: key) }
+      end
+
+      def shared_attributes
+        @shared_attributes ||= begin
+          left_attributes = left_scope.where_attributes
+          right_attributes = right_scope.where_attributes
+          left_attributes.select { |key, value| right_attributes.key?(key) && right_attributes[key] == value }
+        end
+      end
+
+      def or_attributes
+        left_unique_attributes.merge(right_unique_attributes) { |_key, old_value, new_value| [*old_value, new_value] }
+      end
+
+      def left_unique_attributes
+        left_or_attributes = left_scope.where_attributes[:or] || {}
+
+        unique_attributes = left_scope.where_attributes.except(:or).select do |key, value|
+          !shared_attributes.key?(key) || shared_attributes[key] != value
+        end
+
+        left_or_attributes.merge(unique_attributes)
+      end
+
+      def right_unique_attributes
+        right_scope.where_attributes.select do |key, value|
+          !shared_attributes.key?(key) || shared_attributes[key] != value
+        end
+      end
+    end
+  end
+end

data/lib/active_graphql/model/configuration.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  module Model
+    # stores all information for how to handle graphql requets for model
+    class Configuration
+      class Attribute
+        attr_reader :name, :nesting, :decorate_with
+
+        def initialize(name, nesting: nil, decorate_with: nil)
+          @name = name.to_sym
+          @nesting = nesting
+          @decorate_with = decorate_with
+        end
+
+        def to_graphql_output
+          nesting ? { name => nesting } : name
+        end
+      end
+
+      def initialize
+        @attributes = []
+        @primary_key = :id
+      end
+
+      def initialize_copy(other)
+        super
+        @attributes = other.attributes.dup
+        @graphql_client = other.graphql_client
+        @url = other.url.dup
+        @resource_name = other.resource_name.dup
+        @resource_plural_name = other.resource_plural_name.dup
+      end
+
+      def graphql_client(client = nil)
+        @graphql_client = client if client
+        @graphql_client ||= ActiveGraphql::Client.new(url: url)
+      end
+
+      def formatter(new_formatter = nil, &block)
+        @formatter = new_formatter || block if new_formatter || block
+        @formatter ||= Model::ActionFormatter
+      end
+
+      def attributes(*list, **detailed_attributes)
+        list.each { |name| attribute(name) }
+        detailed_attributes.each { |key, val| attribute(key, val) }
+        @attributes
+      end
+
+      def attributes_graphql_output
+        attributes.map(&:to_graphql_output)
+      end
+
+      def attribute(name, nesting = nil, decorate_with: nil)
+        @attributes << Attribute.new(name, nesting: nesting, decorate_with: decorate_with)
+      end
+
+      def url(value = nil)
+        update_or_return_config(:url, value)
+      end
+
+      def resource_name(value = nil)
+        update_or_return_config(:resource_name, value)
+      end
+
+      def resource_plural_name(value = nil)
+        update_or_return_config(:resource_plural_name, value)
+      end
+
+      def primary_key(value = nil)
+        update_or_return_config(:primary_key, value&.to_sym)
+      end
+
+      private
+
+      def update_or_return_config(name, value)
+        instance_variable_set("@#{name}", value) if value
+        instance_variable_get("@#{name}")
+      end
+    end
+  end
+end

data/lib/active_graphql/model/find_in_batches.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActiveGraphql
+  module Model
+    # fetches graphql paginated records in batches
+    class FindInBatches
+      def self.call(*args, &block)
+        new(*args).call(&block)
+      end
+
+      def initialize(relation, batch_size: 100, fetched_items_count: 0)
+        @relation = relation
+        @batch_size = batch_size
+        @fetched_items_count = fetched_items_count
+      end
+
+      def call(&block)
+        scope = relation.limit(batch_size).offset(offset_size)
+
+        items = scope.first_batch
+        return nil if items.empty?
+
+        yield(items)
+        fetch_next_batch(items_count: items.count, &block) if scope.next_page?
+      end
+
+      private
+
+      attr_reader :relation, :fetched_items_count
+
+      def fetch_next_batch(items_count:, &block)
+        self.class.call(
+          relation,
+          batch_size: batch_size,
+          fetched_items_count: fetched_items_count + items_count,
+          &block
+        )
+      end
+
+      def offset_size
+        relation.send(:offset_number).to_i + fetched_items_count
+      end
+
+      def batch_size
+        items_to_fetch = collection_limit_number - fetched_items_count if collection_limit_number
+        [@batch_size, collection_limit_number, items_to_fetch].compact.min
+      end
+
+      def collection_limit_number
+        relation.send(:limit_number)
+      end
+    end
+  end
+end