solidus_graphql_api 0.1.0

data/lib/solidus_graphql_api/batch_loader/has_many.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SolidusGraphqlApi
+  class BatchLoader
+    # A batch loader for +has_many+ associations.
+    class HasMany < BatchLoader
+      def load
+        graphql_loader_for(object.id, default_value: []) do |object_ids, loader|
+          retrieve_records_for(object_ids).each do |associated_record|
+            loader.call(associated_record.send(reflection.foreign_key)) do |memo|
+              memo << associated_record
+            end
+          end
+        end
+      end
+
+      private
+
+      def retrieve_records_for(object_ids)
+        base_relation.where(reflection.foreign_key => object_ids)
+      end
+    end
+  end
+end

data/lib/solidus_graphql_api/batch_loader/has_many_through.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SolidusGraphqlApi
+  class BatchLoader
+    # A batch loader for +has_many :through+ associations.
+    class HasManyThrough < BatchLoader
+      def load
+        graphql_loader_for(object.id, default_value: []) do |object_ids, loader|
+          records_by_parent = group_records_by_parent(retrieve_records_for(object_ids))
+
+          records_by_parent.each_pair do |parent_id, children|
+            loader.call(parent_id) do |memo|
+              memo.concat(children)
+            end
+          end
+        end
+      end
+
+      private
+
+      def retrieve_records_for(object_ids)
+        through_reflection = reflection.through_reflection
+
+        base_relation
+          .joins(through_reflection.name)
+          .where("#{through_reflection.table_name}.#{through_reflection.foreign_key}" => object_ids)
+      end
+
+      def group_records_by_parent(records)
+        result = Hash.new { |h, k| h[k] = [] }
+
+        records.each do |record|
+          record.send(reflection.through_reflection.name).each do |parent|
+            result[parent.send(reflection.through_reflection.foreign_key)] << record
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/solidus_graphql_api/batch_loader/has_one.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SolidusGraphqlApi
+  class BatchLoader
+    # A batch loader for +has_one+ associations.
+    class HasOne < BatchLoader
+      def load
+        graphql_loader_for(object.id) do |object_ids, loader|
+          retrieve_records_for(object_ids).each do |record|
+            loader.call(record.send(reflection.foreign_key), record)
+          end
+        end
+      end
+
+      private
+
+      def retrieve_records_for(object_ids)
+        base_relation.where(reflection.foreign_key => object_ids)
+      end
+    end
+  end
+end

data/lib/solidus_graphql_api/configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SolidusGraphqlApi
+  def self.configure
+    yield configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  class Configuration
+    attr_accessor :payment_sources
+
+    def initialize
+      @payment_sources = ['SolidusGraphqlApi::Types::CreditCard']
+    end
+  end
+end

data/lib/solidus_graphql_api/context.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module SolidusGraphqlApi
+  class Context
+    AUTHORIZATION_HEADER = "Authorization"
+    TOKEN_PATTERN = /^Bearer (?<token>.*)/.freeze
+
+    attr_reader :request, :headers
+
+    def initialize(request:)
+      @request = request
+      @headers = request.headers
+    end
+
+    def to_h
+      { current_user: current_user,
+        current_ability: current_ability,
+        current_store: current_store,
+        current_order: current_order,
+        current_pricing_options: current_pricing_options,
+        order_token: order_token }
+    end
+
+    def current_user
+      @current_user ||= Spree.user_class.find_by(spree_api_key: bearer_token)
+    end
+
+    def current_ability
+      @current_ability ||= Spree::Ability.new(current_user)
+    end
+
+    def order_token
+      @order_token ||= headers["X-Spree-Order-Token"]
+    end
+
+    def current_store
+      @current_store ||= Spree::Config.current_store_selector_class.new(request).store
+    end
+
+    def current_order
+      return @current_order if instance_variable_defined?(:@current_order)
+
+      @current_order = current_order_by_current_user || current_order_by_guest_token
+    end
+
+    def current_pricing_options
+      @current_pricing_options ||= pricing_options_from_context
+    end
+
+    private
+
+    def bearer_token
+      @bearer_token ||= headers[AUTHORIZATION_HEADER].to_s.match(TOKEN_PATTERN) do |match_data|
+        match_data[:token]
+      end
+    end
+
+    def current_order_by_current_user
+      current_user&.last_incomplete_spree_order(store: current_store)
+    end
+
+    def current_order_by_guest_token
+      incomplete_orders = Spree::Order.incomplete
+      incomplete_orders = incomplete_orders.where(store: current_store) if current_store
+
+      incomplete_orders.find_by(guest_token: order_token)
+    end
+
+    def pricing_options_from_context
+      Spree::Config.pricing_options_class.new(
+        currency: current_store&.default_currency.presence || Spree::Config[:currency],
+        country_iso: current_store&.cart_tax_country_iso.presence
+      )
+    end
+  end
+end

data/lib/solidus_graphql_api/engine.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spree/core'
+require 'solidus_graphql_api'
+
+module SolidusGraphqlApi
+  class Engine < Rails::Engine
+    include SolidusSupport::EngineExtensions
+
+    isolate_namespace ::Spree
+
+    engine_name 'solidus_graphql_api'
+
+    # use rspec for tests
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    config.autoload_paths << File.expand_path('..', __dir__)
+
+    initializer "solidus_graphql_api.setup_batch_loader_middleware" do |app|
+      app.middleware.use BatchLoader::Middleware
+    end
+  end
+end

data/lib/solidus_graphql_api/factories.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'solidus_graphql_api/factories/address_factory'
+require 'solidus_graphql_api/factories/country_factory'
+require 'solidus_graphql_api/factories/store_factory'
+require 'solidus_graphql_api/factories/taxonomy_factory'
+
+module SolidusGraphqlApi
+  module Factories
+  end
+end

data/lib/solidus_graphql_api/factories/address_factory.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+FactoryBot.modify do
+  factory :address do
+    firstname { 'John' }
+    lastname { nil }
+  end
+end

data/lib/solidus_graphql_api/factories/country_factory.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+FactoryBot.modify do
+  factory :country do
+    trait :with_states do
+      after :create do |country|
+        create(:state, id: 1, country: country)
+        create(:state, id: 2, country: country, state_code: 'CA')
+      end
+    end
+  end
+end

data/lib/solidus_graphql_api/factories/store_factory.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+FactoryBot.modify do
+  factory :store do
+    trait :with_defaults do
+      cart_tax_country_iso { 'US' }
+      code { 'solidus' }
+      default_currency { 'USD' }
+      meta_description { 'store description' }
+      meta_keywords { 'store, metaKeywords' }
+      name { 'Solidus Test Store' }
+      seo_title { 'Store Title' }
+      url { 'www.example.com' }
+    end
+  end
+end

data/lib/solidus_graphql_api/factories/taxonomy_factory.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+FactoryBot.modify do
+  factory :taxonomy do
+    transient do
+      root_taxon_id {}
+    end
+
+    after :create do |taxonomy, options|
+      if options.root_taxon_id.present? && taxonomy.root.id != options.root_taxon_id
+        taxonomy.root.update(id: options.root_taxon_id)
+      end
+    end
+
+    trait :with_taxon_meta do
+      after :create do |taxonomy|
+        taxonomy.root.update(
+          description: 'Brand description',
+          meta_description: 'Brand meta description',
+          meta_keywords: 'Brand meta keywords',
+          meta_title: 'Brand meta title',
+        )
+      end
+    end
+  end
+end

data/lib/solidus_graphql_api/mutations/base_mutation.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SolidusGraphqlApi
+  module Mutations
+    class BaseMutation < GraphQL::Schema::RelayClassicMutation
+      argument_class Types::Base::Argument
+      field_class Types::Base::Field
+      input_object_class Types::Base::InputObject
+      object_class Types::Base::Object
+
+      private
+
+      def guest_token
+        context[:order_token]
+      end
+
+      def current_order
+        context[:current_order]
+      end
+
+      def current_user
+        context[:current_user]
+      end
+
+      def current_ability
+        context[:current_ability]
+      end
+
+      def current_store
+        context[:current_store]
+      end
+
+      def user_errors(*path, errors)
+        return [] if errors.empty?
+
+        errors.map do |attribute, message|
+          {
+            path: ["input", *path].concat(attribute.to_s.camelize(:lower).split('.')),
+            message: message,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/solidus_graphql_api/mutations/checkout/add_addresses_to_checkout.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SolidusGraphqlApi
+  module Mutations
+    module Checkout
+      class AddAddressesToCheckout < BaseMutation
+        null true
+
+        argument :billing_address, Types::InputObjects::AddressInput, required: true
+        argument :shipping_address, Types::InputObjects::AddressInput, required: false
+        argument :ship_to_billing_address, Boolean, required: false
+
+        field :order, Types::Order, null: true
+        field :errors, [Types::UserError], null: false
+
+        def resolve(billing_address:, shipping_address: nil, ship_to_billing_address: false)
+          current_order.update(state: :address)
+
+          update_params = {
+            bill_address: Spree::Address.new(billing_address.to_h),
+            ship_address: Spree::Address.new(shipping_address.to_h),
+            use_billing: ship_to_billing_address
+          }
+
+          if Spree::OrderUpdateAttributes.new(current_order, update_params).apply
+            current_order.recalculate
+            errors = []
+          else
+            errors = current_order.errors
+          end
+
+          { errors: user_errors('order', errors), order: current_order }
+        end
+
+        def ready?(*)
+          current_ability.authorize!(:update, current_order, guest_token)
+        end
+      end
+    end
+  end
+end

data/lib/solidus_graphql_api/mutations/checkout/add_payment_to_checkout.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SolidusGraphqlApi
+  module Mutations
+    module Checkout
+      class AddPaymentToCheckout < BaseMutation
+        null true
+
+        argument :payment_method_id, ID, required: true, loads: Types::PaymentMethod
+        argument :amount, Float, required: false
+        argument :source, Types::Json, required: false
+
+        field :order, Types::Order, null: true
+        field :errors, [Types::UserError], null: false
+
+        def resolve(payment_method:, amount: nil, source:)
+          current_order.update(state: :payment)
+
+          update_params = {
+            payments_attributes: [{
+              payment_method_id: payment_method.id,
+              amount: amount || current_order.total,
+              source_attributes: source
+            }]
+          }
+
+          if Spree::OrderUpdateAttributes.new(current_order, update_params).apply
+            current_order.recalculate
+            errors = []
+          else
+            errors = current_order.errors
+          end
+
+          { errors: user_errors('order', errors), order: current_order }
+        end
+
+        private
+
+        def ready?(*)
+          current_ability.authorize!(:update, current_order, guest_token)
+        end
+      end
+    end
+  end
+end

data/lib/solidus_graphql_api/mutations/checkout/add_to_cart.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SolidusGraphqlApi
+  module Mutations
+    module Checkout
+      class AddToCart < BaseMutation
+        null true
+
+        argument :variant_id, ID, required: true, loads: Types::Variant
+        argument :quantity, Integer, required: true
+
+        field :order, Types::Order, null: true
+        field :errors, [Types::UserError], null: false
+
+        def resolve(variant:, quantity:)
+          line_item = current_order.contents.add(variant, quantity)
+
+          {
+            order: current_order,
+            errors: user_errors("line_item", line_item.errors)
+          }
+        end
+
+        def ready?(*)
+          current_ability.authorize!(:update, current_order, guest_token)
+        end
+      end
+    end
+  end
+end