solidus_graphql_api 0.1.0

data/Rakefile

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'solidus_dev_support/rake_tasks'
+SolidusDevSupport::RakeTasks.install
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+task default: %w[rubocop extension:specs]
+
+namespace :schema do
+  desc 'Dump the schema to JSON and IDL'
+  task :dump do
+    setup_graphql_rake_tasks
+
+    Rake::Task['graphql:schema:dump'].invoke
+  end
+
+  desc 'Dump the schema to IDL in schema.graphql'
+  task :idl do
+    setup_graphql_rake_tasks
+
+    Rake::Task['graphql:schema:idl'].invoke
+  end
+
+  desc 'Dump the schema to JSON in schema.json'
+  task :json do
+    setup_graphql_rake_tasks
+
+    Rake::Task['graphql:schema:json'].invoke
+  end
+end
+
+private
+
+def setup_graphql_rake_tasks
+  require 'graphql/rake_task'
+  GraphQL::RakeTask.new(schema_name: 'SolidusGraphqlApi::Schema')
+
+  Rake::Task['extension:test_app'].invoke if Dir['spec/dummy'].empty?
+
+  require File.expand_path('spec/dummy/config/environment.rb', __dir__)
+end

data/app/controllers/spree/graphql_controller.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Spree
+  class GraphqlController < ApplicationController
+    skip_before_action :verify_authenticity_token
+
+    def execute
+      render json: SolidusGraphqlApi::Schema.execute(
+        params[:query],
+        variables: ensure_hash(params[:variables]),
+        context: SolidusGraphqlApi::Context.new(request: request).to_h,
+        operation_name: params[:operationName]
+      )
+    rescue StandardError => e
+      raise e unless Rails.env.development?
+
+      handle_error_in_development e
+    end
+
+    private
+
+    # Handle form data, JSON body, or a blank value
+    def ensure_hash(ambiguous_param)
+      case ambiguous_param
+      when String
+        if ambiguous_param.present?
+          ensure_hash(JSON.parse(ambiguous_param))
+        else
+          {}
+        end
+      when Hash
+        ambiguous_param
+      when ActionController::Parameters
+        ambiguous_param.permit!
+      when nil
+        {}
+      else
+        raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
+      end
+    end
+
+    def handle_error_in_development(error)
+      logger.error error.message
+      logger.error error.backtrace.join("\n")
+
+      render json: { error: { message: error.message, backtrace: error.backtrace }, data: {} }, status: 500
+    end
+  end
+end

data/bin/console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "solidus_graphql_api"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+$LOAD_PATH.unshift(*Dir["#{__dir__}/../app/*"])
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/rails

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+if %w[g generate].include? ARGV.first
+  exec "#{__dir__}/rails-engine", *ARGV
+else
+  exec "#{__dir__}/rails-sandbox", *ARGV
+end

data/bin/rails-engine

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/solidus_graphql_api/engine', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/bin/rails-sandbox

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+app_root = 'sandbox'
+
+unless File.exist? "#{app_root}/bin/rails"
+  warn 'Creating the sandbox app...'
+  Dir.chdir "#{__dir__}/.." do
+    system "#{__dir__}/sandbox" or begin # rubocop:disable Style/AndOr
+      warn 'Automatic creation of the sandbox app failed'
+      exit 1
+    end
+  end
+end
+
+Dir.chdir app_root
+exec 'bin/rails', *ARGV

data/bin/rake

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/sandbox

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+
+set -e
+
+case "$DB" in
+postgres|postgresql)
+  RAILSDB="postgresql"
+  ;;
+mysql)
+  RAILSDB="mysql"
+  ;;
+sqlite|'')
+  RAILSDB="sqlite3"
+  ;;
+*)
+  echo "Invalid DB specified: $DB"
+  exit 1
+  ;;
+esac
+
+if [ ! -z $SOLIDUS_BRANCH ]
+then
+  BRANCH=$SOLIDUS_BRANCH
+else
+  BRANCH="master"
+fi
+
+extension_name="solidus_graphql_api"
+
+# Stay away from the bundler env of the containing extension.
+function unbundled {
+  ruby -rbundler -e'b = proc {system *ARGV}; Bundler.respond_to?(:with_unbundled_env) ? Bundler.with_unbundled_env(&b) : Bundler.with_clean_env(&b)' -- $@
+}
+
+rm -rf ./sandbox
+unbundled bundle exec rails new sandbox --database="$RAILSDB" \
+  --skip-bundle \
+  --skip-git \
+  --skip-keeps \
+  --skip-rc \
+  --skip-spring \
+  --skip-test \
+  --skip-javascript
+
+if [ ! -d "sandbox" ]; then
+  echo 'sandbox rails application failed'
+  exit 1
+fi
+
+cd ./sandbox
+cat <<RUBY >> Gemfile
+gem 'solidus', github: 'solidusio/solidus', branch: '$BRANCH'
+gem 'solidus_auth_devise', '>= 2.1.0'
+gem 'rails-i18n'
+gem 'solidus_i18n'
+
+gem '$extension_name', path: '..'
+
+group :test, :development do
+  platforms :mri do
+    gem 'pry-byebug'
+  end
+end
+RUBY
+
+unbundled bundle install --gemfile Gemfile
+
+unbundled bundle exec rake db:drop db:create
+
+unbundled bundle exec rails generate spree:install \
+  --auto-accept \
+  --user_class=Spree::User \
+  --enforce_available_locales=true \
+  --with-authentication=false \
+  $@
+
+unbundled bundle exec rails generate solidus:auth:install
+
+echo
+echo "🚀 Sandbox app successfully created for $extension_name!"
+echo "🚀 Using $RAILSDB and Solidus $BRANCH"
+echo "🚀 Use 'export DB=[postgres|mysql|sqlite]' to control the DB adapter"
+echo "🚀 Use 'export SOLIDUS_BRANCH=<BRANCH-NAME>' to control the Solidus version"
+echo "🚀 This app is intended for test purposes."

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+gem install bundler --conservative
+bundle update
+bin/rake clobber

data/config/locales/en.yml

@@ -0,0 +1,6 @@
+en:
+  activerecord:
+    exceptions:
+      not_found: Record not found
+  unauthorized:
+    default: You are not authorized to access this resource.

data/config/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Spree::Core::Engine.routes.draw do
+  post '/graphql', to: 'graphql#execute'
+end

data/lib/generators/solidus_graphql_api/install/install_generator.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SolidusGraphqlApi
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+    end
+  end
+end

data/lib/solidus_graphql_api.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'graphql'
+require 'batch-loader'
+
+require 'solidus_core'
+require 'solidus_support'
+
+require 'solidus_graphql_api/version'
+require 'solidus_graphql_api/engine'
+require 'solidus_graphql_api/configuration'

data/lib/solidus_graphql_api/batch_loader.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module SolidusGraphqlApi
+  # Provides an abstraction layer on top of +BatchLoader::GraphQL+ that removes all the
+  # boilerplate normally needed to batch-load ActiveRecord associations.
+  #
+  # @example Batch-loading a user's posts
+  #   BatchLoader.for(user, :posts)
+  class BatchLoader
+    LOADER_CLASSES = {
+      has_one: BatchLoader::HasOne,
+      has_many: BatchLoader::HasMany,
+      has_many_through: BatchLoader::HasManyThrough,
+      belongs_to: BatchLoader::BelongsTo,
+    }.freeze
+
+    class << self
+      # Generates the batch loader for an ActiveRecord instance-association pair.
+      #
+      # @param object [ActiveRecord::Base] the record whose association you want to batch-load
+      # @param association [Symbol] the association to batch-load
+      # @param options [Hash] an options hash
+      #
+      # @option scope [ActiveRecord::Relation] a relation to use for scoping the association
+      #
+      # @return [BatchLoader::GraphQL]
+      #
+      # @see #new
+      def for(object, association, options = {})
+        reflection = object.class.reflect_on_association(association)
+        loader_class_for(reflection).new(object, reflection, options).load
+      end
+
+      private
+
+      def loader_class_for(reflection)
+        association_type = association_type(reflection)
+        LOADER_CLASSES[association_type] ||
+          raise(ArgumentError, "#{association_type} associations do not support batch loading")
+      end
+
+      def association_type(reflection)
+        macro = reflection.macro.to_sym
+
+        case macro
+        when :has_many
+          if reflection.through_reflection
+            :has_many_through
+          else
+            :has_many
+          end
+        else
+          macro
+        end
+      end
+    end
+
+    attr_reader :object, :reflection, :options
+
+    # Generates a new instance of this batch loader for an ActiveRecord instance-association pair.
+    #
+    # @param object [ActiveRecord::Base] the record whose association you want to batch-load
+    # @param reflection [ActiveRecord::Reflection] the association to batch-load
+    # @param options [Hash] an options hash
+    #
+    # @option scope [ActiveRecord::Relation] a relation to use for scoping the association
+    # @option klass [Class] the model class to load (only for polymorphic associations)
+    def initialize(object, reflection, options = {})
+      @object = object
+      @reflection = reflection
+      @options = options
+    end
+
+    # Returns the batch loading logic.
+    #
+    # @return [BatchLoader::GraphQL]
+    def load
+      raise NotImplementedError
+    end
+
+    private
+
+    def association_klass
+      if reflection.polymorphic?
+        options[:klass] || raise(
+          ArgumentError,
+          'You need to provide :klass when batch-loading a polymorphic association!',
+        )
+      else
+        reflection.klass
+      end
+    end
+
+    def base_relation
+      relation = association_klass
+      relation = relation.instance_eval(&reflection.scope) if reflection.scope
+      relation = relation.merge(options[:scope]) if options[:scope]
+      relation
+    end
+
+    def default_options
+      return @default_options if @default_options
+
+      key_components = [object.class, reflection.name, options.inspect]
+      key = Digest::MD5.hexdigest(key_components.join)
+
+      @default_options ||= { key: key }.freeze
+    end
+
+    def graphql_loader_for(object_id, options = {}, &block)
+      ::BatchLoader::GraphQL.for(object_id).batch(default_options.merge(options), &block)
+    end
+  end
+end

data/lib/solidus_graphql_api/batch_loader/belongs_to.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SolidusGraphqlApi
+  class BatchLoader
+    # A batch loader for +belongs_to+ associations.
+    class BelongsTo < BatchLoader
+      def load
+        graphql_loader_for(object.send(reflection.foreign_key)) do |object_ids, loader|
+          retrieve_records_for(object_ids).each do |record|
+            loader.call(record.send(association_primary_key), record)
+          end
+        end
+      end
+
+      private
+
+      def retrieve_records_for(object_ids)
+        base_relation.where(association_primary_key => object_ids)
+      end
+
+      def association_primary_key
+        if reflection.polymorphic?
+          association_klass.primary_key
+        else
+          reflection.association_primary_key
+        end
+      end
+    end
+  end
+end