graphql-extras 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51f813e6dda5daf0c9c0b94a768b2dc339c19e45ae08277b7fa6e1f0b7a33361
-  data.tar.gz: c0359145f282a0e86ea53e23a5240712c2cde97331daec88d2b754244fe5af4e
+  metadata.gz: 29213c20e07ca49b31f25ee4c66a1b60537c746ac3a66030eee023eb33d35f65
+  data.tar.gz: 45694df9fb4e00159e7394bcab9f9253de8dd949b891cc6b78a6e28fa548a99e
 SHA512:
-  metadata.gz: 58851891def9df659c6effdc2633954ffdcafbfcad544196b32f1f502bacd8d6d227e3e3a95b78bf418859b2541a284f746368934d6fa3fd8000ae36a53b86a2
-  data.tar.gz: 21517e559a3ab8835839b16b39689b780118838d016e9348b0c3189309ae6dfc57376eee89f920423b78ebd0f8577b18e2b796ce72f721dc8460fe00d62041b0
+  metadata.gz: 22ca80f894bdae011ee6707f35a43097b699534dfc4295e5369100f993dced3a6906df29518dff0729683320db7dd72d9186c0edc8d0378ffb2b5bee24941e0d
+  data.tar.gz: e6df88738196ecf8b02b15fcad0da085ee6cfca9762a27dc06942458797b73a624fa300252338e3f04c92aff73a52a59543eeee29bc5f9ee2631c27563223423

data/README.md

@@ -2,13 +2,29 @@
 
 <div align="center">
 
-![Build](https://github.com/rzane/graphql-extras/workflows/CI/badge.svg)
+![Build](https://github.com/rzane/graphql-extras/workflows/Build/badge.svg)
 ![Version](https://img.shields.io/gem/v/graphql-extras)
 
 </div>
 
 A collection of utilities for building GraphQL APIs.
 
+**Table of Contents**
+
+- [Installation](#installation)
+- [Usage](#usage)
+  - [GraphQL::Extras::Controller](#graphqlextrascontroller)
+  - [GraphQL::Extras::AssociationLoader](#graphqlextrasassociationloader)
+  - [GraphQL::Extras::Preload](#graphqlextraspreload)
+  - [GraphQL::Extras::Types](#graphqlextrastypes)
+    - [Date](#date)
+    - [DateTime](#datetime)
+    - [Decimal](#decimal)
+    - [Upload](#upload)
+  - [GraphQL::Extras::Test](#graphqlextrastest)
+- [Development](#development)
+- [Contributing](#contributing)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -37,30 +53,36 @@ class GraphqlController < ApplicationController
 end
 ```
 
-### GraphQL::Extras::Batch::AssociationLoader
+### GraphQL::Extras::AssociationLoader
 
 This is a subclass of [`GraphQL::Batch::Loader`](https://github.com/Shopify/graphql-batch) that performs eager loading of Active Record associations.
 
 ```ruby
-loader = GraphQL::Extras::Batch::AssociationLoader.for(:blog)
+loader = GraphQL::Extras::AssociationLoader.for(:blog)
 loader.load(Post.first)
 loader.load_many(Post.all)
 ```
 
-### GraphQL::Extras::Batch::Resolvers
+### GraphQL::Extras::Preload
 
-This includes a set of convenience methods for query batching.
+This allows you to preload associations before resolving fields.
 
 ```ruby
-class Post < GraphQL::Schema::Object
-  include GraphQL::Extras::Batch::Resolver
+class BaseField < GraphQL::Schema::Field
+  prepend GraphQL::Extras::Preload
+end
 
-  field :blog, BlogType, resolve: association(:blog), null: false
-  field :comments, [CommentType], resolve: association(:comments, preload: { comments: :user }), null: false
-  field :blog_title, String, null: false
+class BaseObject < GraphQL::Schema::Object
+  field_class BaseField
+end
 
-  def blog_title
-    association(object, :blog).then(&:title)
+class PostType < BaseObject
+  field :author, AuthorType, preload: :author, null: false
+  field :author_posts, [PostType], preload: {author: :posts}, null: false
+  field :depends_on_author, Integer, preload: :author, null: false
+
+  def author_posts
+    object.author.posts
   end
 end
 ```
@@ -95,7 +117,7 @@ This scalar takes a `DateTime` and transmits it as a string, using ISO 8601 form
 field :created_at, DateTime, required: true
 ```
 
-*Note: This is just an alias for the `ISO8601DateTime` type that is included in the `graphql` gem.*
+_Note: This is just an alias for the `ISO8601DateTime` type that is included in the `graphql` gem._
 
 #### Decimal
 
@@ -126,36 +148,44 @@ Take note of the correspondence between the value `"image"` and the additional H
 
 See [apollo-link-upload](https://github.com/rzane/apollo-link-upload) for the client-side implementation.
 
-### RSpec integration
+### GraphQL::Extras::Test
+
+This module makes it really easy to test your schema.
 
-Add the following to your `rails_helper.rb` (or `spec_helper.rb`).
+First, create a test schema:
 
 ```ruby
-require "graphql/extras/rspec"
+# spec/support/test_schema.rb
+require "graphql/extras/test"
+
+class TestSchema < GraphQL::Extras::Test::Schema
+  configure schema: Schema, queries: "spec/**/*.graphql"
+end
 ```
 
 Now, you can run tests like so:
 
 ```ruby
+require "support/test_schema"
+
 RSpec.describe "hello" do
   let(:context) { { name: "Ray" } }
-  let(:schema)  { use_schema(Schema, context: context) }
-  let(:queries) { graphql_fixture("hello.graphql") }
+  let(:schema)  { TestSchema.new(context) }
 
   it "allows easily executing queries" do
-    result = schema.execute(queries.hello)
+    query = schema.hello
 
-    expect(result).to be_successful_query
-    expect(result['data']['hello']).to eq("world")
+    expect(query).to be_successful
+    expect(query.data["hello"]).to eq("world")
   end
-end
-```
 
-The `graphql_fixture` method assumes that your queries live in `spec/fixtures/graphql`. You can change this assumption with the following configuration:
+  it "parses errors" do
+    query = schema.kaboom
 
-```ruby
-RSpec.configure do |config|
-  config.graphql_fixture_path = '/path/to/queries'
+    expect(query).not_to be_successful
+    expect(query.errors[0].message).to eq("Invalid")
+    expect(query.errors[0].code).to eq("VALIDATION_ERROR")
+  end
 end
 ```
 

data/graphql-extras.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activesupport", ">= 5.2"
-  spec.add_dependency "graphql", "~> 1.9"
+  spec.add_dependency "graphql", "~> 1.12"
   spec.add_dependency "graphql-batch", "~> 0.4"
 
   spec.add_development_dependency "bundler", "~> 2.0"

data/lib/graphql/extras.rb

@@ -1,7 +1,8 @@
 require "graphql/extras/version"
 require "graphql/extras/types"
 require "graphql/extras/controller"
-require "graphql/extras/batch"
+require "graphql/extras/association_loader"
+require "graphql/extras/preload"
 
 module GraphQL
   module Extras

data/lib/graphql/extras/association_loader.rb

@@ -0,0 +1,24 @@
+require "graphql/batch"
+
+module GraphQL
+  module Extras
+    class AssociationLoader < GraphQL::Batch::Loader
+      def initialize(preload)
+        @preload = preload
+      end
+
+      def cache_key(record)
+        record.object_id
+      end
+
+      def perform(records)
+        preloader = ActiveRecord::Associations::Preloader.new
+        preloader.preload(records, @preload)
+
+        records.each do |record|
+          fulfill(record, nil) unless fulfilled?(record)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/extras/preload.rb

@@ -0,0 +1,23 @@
+require "graphql/extras/association_loader"
+
+module GraphQL
+  module Extras
+    module Preload
+      # @override
+      def initialize(*args, preload: nil, **opts, &block)
+        @preload = preload
+        super(*args, **opts, &block)
+      end
+
+      # @override
+      def resolve(object, args, ctx)
+        return super unless @preload
+
+        loader = AssociationLoader.for(@preload)
+        loader.load(object.object).then do
+          super(object, args, ctx)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/extras/test.rb

@@ -0,0 +1 @@
+require "graphql/extras/test/schema"

data/lib/graphql/extras/test/loader.rb

@@ -0,0 +1,59 @@
+module GraphQL
+  module Extras
+    module Test
+      class Loader
+        FragmentNotFoundError = Class.new(StandardError)
+
+        attr_reader :fragments
+        attr_reader :operations
+
+        def initialize
+          @fragments = {}
+          @operations = {}
+        end
+
+        def load(path)
+          document = ::GraphQL.parse_file(path)
+          document.definitions.each do |node|
+            case node
+            when Nodes::FragmentDefinition
+              fragments[node.name] = node
+            when Nodes::OperationDefinition
+              operations[node.name] = node
+            end
+          end
+        end
+
+        def print(operation)
+          printer = ::GraphQL::Language::Printer.new
+          nodes = [operation, *resolve_fragments(operation)]
+          nodes.map { |node| printer.print(node) }.join("\n")
+        end
+
+        private
+
+        Nodes = ::GraphQL::Language::Nodes
+
+        # Recursively iterate through the node's fields and find
+        # resolve all of the fragment definitions that are needed.
+        def resolve_fragments(node)
+          node.selections.flat_map do |field|
+            case field
+            when Nodes::FragmentSpread
+              fragment = fetch_fragment!(field.name)
+              [fragment, *resolve_fragments(fragment)]
+            else
+              resolve_fragments(field)
+            end
+          end
+        end
+
+        def fetch_fragment!(name)
+          fragments.fetch(name) do
+            raise FragmentNotFoundError, "Fragment `#{name}` is not defined"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/extras/test/response.rb

@@ -0,0 +1,37 @@
+module GraphQL
+  module Extras
+    module Test
+      class Response
+        attr_reader :data
+        attr_reader :errors
+
+        def initialize(payload)
+          @data = payload["data"]
+          @errors = payload.fetch("errors", []).map do |error|
+            Error.new(error)
+          end
+        end
+
+        def successful?
+          errors.empty?
+        end
+
+        class Error
+          attr_reader :message
+          attr_reader :extensions
+          attr_reader :code
+          attr_reader :path
+          attr_reader :locations
+
+          def initialize(payload)
+            @message = payload["message"]
+            @path = payload["path"]
+            @locations = payload["locations"]
+            @extensions = payload["extensions"]
+            @code = payload.dig("extensions", "code")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/extras/test/schema.rb

@@ -0,0 +1,53 @@
+require "securerandom"
+require "active_support/inflector"
+require "active_support/core_ext/hash/deep_transform_values"
+require "graphql/extras/test/loader"
+require "graphql/extras/test/response"
+
+module GraphQL
+  module Extras
+    module Test
+      class Schema
+        def self.configure(schema:, queries:)
+          loader = Loader.new
+
+          Dir.glob(queries) do |path|
+            loader.load(path)
+          end
+
+          loader.operations.each do |name, operation|
+            query = loader.print(operation)
+
+            define_method(name.underscore) do |variables = {}|
+              __execute(schema, query, variables)
+            end
+          end
+        end
+
+        def initialize(context = {})
+          @context = context
+        end
+
+        private
+
+        def __execute(schema, query, variables)
+          uploads = {}
+
+          variables = variables.deep_transform_values do |value|
+            if value.respond_to? :tempfile
+              id = SecureRandom.uuid
+              uploads[id] = value
+              id
+            else
+              value
+            end
+          end
+
+          context = @context.merge(uploads: uploads)
+          result = schema.execute(query, variables: variables, context: context)
+          Response.new(result.to_h)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/extras/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module Extras
-    VERSION = "0.2.6"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-extras
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Ray Zane
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-17 00:00:00.000000000 Z
+date: 2021-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: graphql-batch
   requirement: !ruby/object:Gem::Requirement
@@ -168,9 +168,13 @@ files:
 - bin/setup
 - graphql-extras.gemspec
 - lib/graphql/extras.rb
-- lib/graphql/extras/batch.rb
+- lib/graphql/extras/association_loader.rb
 - lib/graphql/extras/controller.rb
-- lib/graphql/extras/rspec.rb
+- lib/graphql/extras/preload.rb
+- lib/graphql/extras/test.rb
+- lib/graphql/extras/test/loader.rb
+- lib/graphql/extras/test/response.rb
+- lib/graphql/extras/test/schema.rb
 - lib/graphql/extras/types.rb
 - lib/graphql/extras/version.rb
 homepage: https://github.com/promptworks/graphql-extras

data/lib/graphql/extras/batch.rb

@@ -1,47 +0,0 @@
-require "graphql/batch"
-
-module GraphQL
-  module Extras
-    module Batch
-      class AssociationLoader < GraphQL::Batch::Loader
-        def initialize(name, preload: name)
-          @name = name
-          @preload = preload
-        end
-
-        def cache_key(record)
-          record.object_id
-        end
-
-        def perform(records)
-          preloader = ActiveRecord::Associations::Preloader.new
-          preloader.preload(records, @preload)
-
-          records.each do |record|
-            fulfill(record, record.public_send(@name))
-          end
-        end
-      end
-
-      module Resolvers
-        def self.included(base)
-          base.extend ClassMethods
-        end
-
-        module ClassMethods
-          def association(name)
-            lambda do |record, _args, _ctx|
-              loader = AssociationLoader.for(name)
-              loader.load(record)
-            end
-          end
-        end
-
-        def association(record, name)
-          loader = AssociationLoader.for(name)
-          loader.load(record)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/extras/rspec.rb

@@ -1,133 +0,0 @@
-require "yaml"
-require "active_support/inflector"
-require "active_support/core_ext/hash"
-
-module GraphQL
-  module Extras
-    module RSpec
-      class Queries
-        def add(key, value)
-          define_singleton_method(key) { value }
-        end
-      end
-
-      class Schema
-        def initialize(schema, context: {})
-          @schema = schema
-          @context = context
-        end
-
-        def execute(query, variables = {})
-          variables = deep_camelize_keys(variables)
-          variables, uploads = extract_uploads(variables)
-          context = @context.merge(uploads: uploads)
-
-          result = @schema.execute(query, variables: variables, context: context)
-          result.to_h
-        end
-
-        private
-
-        def extract_uploads(variables)
-          uploads = {}
-          variables = deep_transform_values(variables) { |value|
-            if upload?(value)
-              SecureRandom.hex.tap { |key| uploads.merge!(key => value) }
-            else
-              value
-            end
-          }
-
-          [variables, uploads]
-        end
-
-        def deep_camelize_keys(variables)
-          variables.deep_transform_keys { |key| key.to_s.camelize(:lower) }
-        end
-
-        def deep_transform_values(data, &block)
-          case data
-          when Array
-            data.map { |v| deep_transform_values(v, &block) }
-          when Hash
-            data.transform_values { |v| deep_transform_values(v, &block) }
-          else
-            yield data
-          end
-        end
-
-        def upload?(value)
-          value.respond_to?(:tempfile) && value.respond_to?(:original_filename)
-        end
-      end
-
-      class Parser
-        include ::GraphQL::Language
-
-        def initialize(document)
-          @operations = document.definitions
-            .grep(Nodes::OperationDefinition)
-
-          @fragments = document.definitions
-            .grep(Nodes::FragmentDefinition)
-            .reduce({}) { |acc, f| acc.merge(f.name => f) }
-        end
-
-        def parse
-          queries = Queries.new
-          printer = Printer.new
-
-          @operations.each do |op|
-            nodes = [op, *find_fragments(op)]
-            nodes = nodes.map { |node| printer.print(node) }
-            queries.add op.name.underscore, nodes.join
-          end
-
-          queries
-        end
-
-        private
-
-        def find_fragments(node)
-          node.selections.flat_map do |field|
-            if field.is_a? Nodes::FragmentSpread
-              fragment = @fragments.fetch(field.name)
-              [fragment, *find_fragments(fragment)]
-            else
-              find_fragments(field)
-            end
-          end
-        end
-      end
-
-      def graphql_fixture(filename)
-        root = ::RSpec.configuration.graphql_fixture_path
-        file = File.join(root, filename)
-        document = ::GraphQL.parse_file(file)
-        parser = Parser.new(document)
-        parser.parse
-      end
-
-      def use_schema(*args, **opts)
-        Schema.new(*args, **opts)
-      end
-    end
-  end
-end
-
-RSpec::Matchers.define :be_successful_query do
-  match do |result|
-    result['errors'].nil?
-  end
-
-  failure_message do |result|
-    errors = result['errors'].map(&:deep_stringify_keys)
-    message = "expected query to be successful, but encountered errors:\n"
-    message + errors.to_yaml.lines.drop(1).join.indent(2)
-  end
-end
-
-RSpec.configure do |config|
-  config.add_setting :graphql_fixture_path, default: "spec/fixtures/graphql"
-  config.include GraphQL::Extras::RSpec, type: :graphql
-end