nulogy_graphql_api 0.4.0

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
+
+task default: [:rubocop, :spec]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nulogy_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.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/gemfiles/rails_5.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.9"
+gem "rails", "5.2.4"
+
+gemspec :path => "../"

data/gemfiles/rails_6.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.9"
+gem "rails", "6.0.0"
+
+gemspec :path => "../"

data/lib/nulogy_graphql_api.rb

@@ -0,0 +1,13 @@
+require "graphql"
+
+require "nulogy_graphql_api/error_handling"
+require "nulogy_graphql_api/graphql_executor"
+require "nulogy_graphql_api/graphql_response"
+require "nulogy_graphql_api/transaction_service"
+require "nulogy_graphql_api/types/user_error_type"
+require "nulogy_graphql_api/types/uuid"
+require "nulogy_graphql_api/version"
+require "nulogy_graphql_api/railtie"
+
+module NulogyGraphqlApi
+end

data/lib/nulogy_graphql_api/error_handling.rb

@@ -0,0 +1,45 @@
+require "nulogy_graphql_api/graphql_error"
+
+module NulogyGraphqlApi
+  module ErrorHandling
+    extend ActiveSupport::Concern
+
+    included do
+      rescue_from StandardError do |exception|
+        render_error(exception)
+      end
+
+      rescue_from ActiveRecord::RecordNotFound do
+        render_not_found
+      end
+    end
+
+    private
+
+    def show_detailed_error_information?
+      Rails.application.config.consider_all_requests_local
+    end
+
+    def render_error(exception)
+      error = if show_detailed_error_information?
+        NulogyGraphqlApi::GraphQLError.new(exception.message, backtrace: exception.backtrace)
+      else
+        NulogyGraphqlApi::GraphQLError.new("Something went wrong")
+      end
+
+      render json: error.render, status: :internal_server_error
+    end
+
+    def render_not_found
+      render json: NulogyGraphqlApi::GraphQLError.new("Not Found").render, status: :not_found
+    end
+
+    def render_unauthorized
+      render json: NulogyGraphqlApi::GraphQLError.new("Unauthorized").render, status: :unauthorized
+    end
+
+    def render_timeout
+      render json: NulogyGraphqlApi::GraphQLError.new("Request Timeout").render, status: :request_timeout
+    end
+  end
+end

data/lib/nulogy_graphql_api/graphql_error.rb

@@ -0,0 +1,23 @@
+module NulogyGraphqlApi
+  class GraphQLError
+    def initialize(message, backtrace: nil)
+      @message = message
+      @backtrace = backtrace
+    end
+
+    def render
+      {
+        data: {},
+        errors: [{ message: @message }.merge(extensions)]
+      }
+    end
+
+    def extensions
+      if @backtrace
+        { extensions: { backtrace: @backtrace } }
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/nulogy_graphql_api/graphql_executor.rb

@@ -0,0 +1,62 @@
+require "action_controller"
+
+module NulogyGraphqlApi
+  class GraphqlExecutor
+    attr_reader :schema, :transaction_service
+
+    def self.execute(params, context, schema, transaction_service)
+      new(schema, transaction_service).execute(params, context)
+    end
+
+    def execute(params, context)
+      graphql_response(params, context).render_http_response
+    end
+
+    private
+
+    def initialize(schema, transaction_service)
+      @schema = schema
+      @transaction_service = transaction_service
+    end
+
+    def graphql_response(params, context)
+      execute_graphql(params, context)
+    end
+
+    def execute_graphql(params, context)
+      query = params[:query]
+      variables = ensure_hash(params[:variables])
+      operation_name = params[:operationName]
+
+      transaction_service.execute_in_transaction do |tx|
+        result = GraphqlResponse.new(
+          schema.execute(
+            query,
+            variables: variables,
+            operation_name: operation_name,
+            context: context
+          )
+        )
+        tx.rollback if result.contains_errors?
+        result
+      end
+    end
+
+    def ensure_hash(ambiguous_param)
+      case ambiguous_param
+      when String
+        if ambiguous_param.present?
+          ensure_hash(JSON.parse(ambiguous_param))
+        else
+          {}
+        end
+      when Hash, ActionController::Parameters
+        ambiguous_param
+      when nil
+        {}
+      else
+        raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
+      end
+    end
+  end
+end

data/lib/nulogy_graphql_api/graphql_response.rb

@@ -0,0 +1,65 @@
+module NulogyGraphqlApi
+  # This class provides a wrapper around the hash returned by GraphQL::Schema#execute.
+  #
+  # The hash is assumed to have String keys rather than Symbol keys because that is what
+  # the Graphql-ruby gem outputs.
+  class GraphqlResponse
+    def initialize(graphql_response_json)
+      @graphql_response_json = graphql_response_json
+    end
+
+    # Detects errors embedded in the GraphQL schema (intended to be shown to end-users):
+    # {
+    #   "data": {
+    #     "somePayload": {
+    #       "errors": [{
+    #         "message": "Something went wrong!"
+    #       }]
+    #     }
+    #   }
+    # }
+    def contains_errors_in_data_payload?
+      if @graphql_response_json["data"].present?
+        @graphql_response_json["data"].values.any? do |payload|
+          payload.is_a?(Hash) ? payload["errors"].present? : false
+        end
+      else
+        false
+      end
+    end
+
+    # Detects errors in the standard GraphQL error list (intended to be shown to developers and API clients):
+    # {
+    #   "errors": [{
+    #     "message": "Something went wrong!"
+    #   }]
+    # }
+    def contains_errors_in_graphql_errors?
+      @graphql_response_json["errors"].present?
+    end
+
+    def contains_errors?
+      contains_errors_in_graphql_errors? || contains_errors_in_data_payload?
+    end
+
+    def http_response_code
+      if contains_errors_in_graphql_errors?
+        400
+      elsif contains_errors_in_data_payload?
+        # mimic Rails behaviour when there are validation errors. Also enable clients to easily
+        # identify user-facing errors. CPI for instance will retry these to deal with race
+        # conditions.
+        422
+      else
+        200
+      end
+    end
+
+    def render_http_response
+      {
+        json: @graphql_response_json,
+        status: http_response_code
+      }
+    end
+  end
+end

data/lib/nulogy_graphql_api/railtie.rb

@@ -0,0 +1,7 @@
+module NulogyGraphqlApi
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/graphql_schema.rake"
+    end
+  end
+end

data/lib/nulogy_graphql_api/rspec.rb

@@ -0,0 +1,4 @@
+# relative-require all rspec files
+Dir[File.dirname(__FILE__) + "/rspec/*.rb"].each do |file|
+  require "nulogy_graphql_api/rspec/" + File.basename(file, File.extname(file))
+end

data/lib/nulogy_graphql_api/rspec/graphql_helpers.rb

@@ -0,0 +1,28 @@
+module NulogyGraphqlApi
+  module GraphqlHelpers
+    def execute_graphql(query, schema, variables: {}, context: {})
+      camelized_variables = variables.deep_transform_keys! { |key| key.to_s.camelize(:lower) } || {}
+
+      response = schema.execute(
+        query,
+        variables: camelized_variables,
+        context: context,
+        operation_name: nil
+      )
+
+      response.to_h.deep_symbolize_keys
+    end
+
+    def request_graphql(url, query, variables: {}, headers: {})
+      params = { query: query, variables: variables }.to_json
+      default_headers = {
+        "CONTENT_TYPE": "application/json",
+        "HTTP_AUTHORIZATION": basic_auth_token(default_user.login)
+      }
+
+      post url, params: params, headers: default_headers.merge(headers)
+
+      JSON.parse(response.body, symbolize_names: true)
+    end
+  end
+end

data/lib/nulogy_graphql_api/rspec/graphql_matchers.rb

@@ -0,0 +1,38 @@
+require "rspec/matchers"
+require "rspec/expectations"
+
+module NulogyGraphqlApi
+  module GraphqlMatchers
+    RSpec::Matchers.define :have_graphql_data do |expected_data|
+      match do |graphql_response|
+        @expected_response = { data: expected_data }
+        expect(graphql_response).to match(@expected_response)
+      end
+
+      failure_message do |actual_response|
+        <<~MSG
+          expected: #{@expected_response.pretty_inspect}
+
+          got: #{actual_response.pretty_inspect}
+        MSG
+      end
+    end
+
+    RSpec::Matchers.define :have_graphql_error do |message|
+      match do |actual_response|
+        expect(actual_response.fetch(:errors, nil)).to contain_exactly(a_hash_including(
+          message: include(message)
+        ))
+      end
+    end
+
+    RSpec::Matchers.define :have_network_error do |message, error_extensions = {}|
+      match do |actual_response|
+        expect(actual_response).to match({
+          data: {},
+          errors: [{ message: message }.merge(error_extensions)]
+        })
+      end
+    end
+  end
+end

data/lib/nulogy_graphql_api/transaction_service.rb

@@ -0,0 +1,44 @@
+require "active_record"
+
+module NulogyGraphqlApi
+  class TransactionService
+    def execute_in_transaction
+      context = Transaction.new
+      result = nil
+      ActiveRecord::Base.transaction(requires_new: true, joinable: false) do
+        result = yield(context)
+        raise ActiveRecord::Rollback if context.rolledback?
+      end
+      result
+    end
+
+    class Transaction
+      def initialize
+        @rollback = false
+      end
+
+      def rollback
+        @rollback = true
+      end
+
+      def rolledback?
+        @rollback
+      end
+    end
+
+    # TODO: Move to the spec folder
+    class Dummy
+      attr_reader :transaction
+
+      def execute_in_transaction
+        @transaction = Transaction.new
+        @was_called = true
+        yield(@transaction)
+      end
+
+      def was_called?
+        @was_called
+      end
+    end
+  end
+end

data/lib/nulogy_graphql_api/types/user_error_type.rb

@@ -0,0 +1,12 @@
+module NulogyGraphqlApi
+  module Types
+    class UserErrorType < ::GraphQL::Schema::Object
+      description "An end-user readable error"
+
+      field :message, String, null: false,
+        description: "A description of the error"
+      field :path, [String], null: false,
+        description: "Which input value this error came from"
+    end
+  end
+end

data/lib/nulogy_graphql_api/types/uuid.rb

@@ -0,0 +1,8 @@
+module NulogyGraphqlApi
+  module Types
+    # "Type" is not included in the name as this is a scalar type
+    class UUID < GraphQL::Types::String
+      description "A scalar type to represent a UUID. The UUID appears in the JSON response as a string."
+    end
+  end
+end

data/lib/nulogy_graphql_api/version.rb

@@ -0,0 +1,3 @@
+module NulogyGraphqlApi
+  VERSION = "0.4.0"
+end

data/lib/tasks/graphql_schema.rake

@@ -0,0 +1,75 @@
+namespace :nulogy_graphql_api do
+  desc "Generate a schema.graphql file"
+
+  class GraphqlSchemaChangesChecker
+    def check_changes(old_schema, new_schema)
+      compare_result = GraphQL::SchemaComparator.compare(old_schema, new_schema)
+
+      abort "Task aborted!\n #{Rainbow('No schema changes found.').green}" if compare_result.identical?
+      abort "Task aborted!" unless accept_breaking_changes?(compare_result)
+    end
+
+    private
+
+    def accept_breaking_changes?(compare_result)
+      return true if !compare_result.breaking? && compare_result.dangerous_changes.none?
+
+      puts Rainbow("\nThe current GraphQL Schema has breaking or dangerous changes:").yellow
+
+      compare_result.breaking_changes.concat(compare_result.dangerous_changes).each do |change|
+        puts Rainbow("\n\n- #{change.message} #{change.dangerous? ? '(Dangerous)' : '(Breaking)'}").yellow
+        puts Rainbow("  #{change.criticality.reason}").yellow
+      end
+
+      puts "\n\nDo you want to update the schema anyway? [Y/n]"
+
+      STDIN.gets.chomp != "n"
+    end
+  end
+
+  class GraphqlSchemaGenerator
+    SCHEMA_FILE_NAME = "schema.graphql"
+
+    def generate_schema(old_schema_file_path, new_schema_file_path)
+      @old_schema_file_path = old_schema_file_path
+      @new_schema_file_path = new_schema_file_path
+
+      generate_schema_file
+    end
+
+    private
+
+    def check_changes(old_schema, new_schema)
+      GraphqlSchemaChangesChecker.new.check_changes(old_schema, new_schema)
+    end
+
+    def new_schema
+      require @new_schema_file_path
+
+      GraphQL::Schema.descendants.first.to_definition
+    end
+
+    def old_schema
+      return nil unless File.exists?(@old_schema_file_path)
+
+      File.read(@old_schema_file_path)
+    end
+
+    def generate_schema_file
+      check_changes(old_schema, new_schema) if old_schema
+
+      write_new_schema_file
+    end
+
+    def write_new_schema_file
+      File.write(@old_schema_file_path, new_schema)
+      puts Rainbow("\nSuccessfully updated #{@old_schema_file_path}").green
+    end
+  end
+
+  task :generate_schema, [:old_schema_file_path, :new_schema_file_path] => :environment do |_task, args|
+    abort "new_schema_file_path is required" unless args.key?(:new_schema_file_path)
+
+    GraphqlSchemaGenerator.new.generate_schema(args[:old_schema_file_path], args[:new_schema_file_path])
+  end
+end