wcc-contentful-graphql 1.0.0.pre.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b2546f3684d711b927716615568c5a1d90994bd3242a91f056be643b0e9a8976
+  data.tar.gz: a396b86a4fe13e61b031b73c3f55889dfeaf0cc0406bcf7413d00159daf7cd8d
+SHA512:
+  metadata.gz: 8415a779ccb2d1997531d741b49e2b57a1d37f27f4283102047b8152ed7a5f2b234ef54661b2642d47ee1ae4f2b2c054698d71e225ae237815879cb55aa17c45
+  data.tar.gz: fe9ad8a75a6be28f8b2eb996601741238dc5a9df0f314555c069a330bf79139214a70c21d041ae069dc4a2411a69cd496fae21520aba07f8fde3894a3b1f659e

data/.rspec

@@ -0,0 +1,4 @@
+--require spec_helper
+--format documentation
+--color
+--order rand

data/Guardfile

@@ -0,0 +1,101 @@
+# A guardfile for making Danger Plugins
+# For more info see https://github.com/guard/guard#readme
+
+# To run, use `bundle exec guard`.
+
+def watch_async(regexp)
+  raise ArgumentError, "No block given" unless block_given?
+  match_queue = Queue.new
+  
+  watch(regexp) do |match|
+    # Producer - add matches to the match queue
+    match_queue << match
+    nil
+  end
+
+  # Consumer - process matches as a batch
+  Thread.new do
+    loop do
+      matches = []
+      matches << match_queue.pop
+
+      loop do
+        begin
+          matches << match_queue.pop(true)
+        rescue ThreadError
+          break
+        end
+      end
+
+      begin
+        yield matches if matches.length > 0
+      rescue StandardError => ex
+        STDERR.puts "Error! #{ex}"
+      end
+    end
+  end
+end
+
+group :red_green_refactor, halt_on_fail: true do
+  guard :rspec, cmd: 'bundle exec rspec' do
+    require 'guard/rspec/dsl'
+    dsl = Guard::RSpec::Dsl.new(self)
+
+    # RSpec files
+    rspec = dsl.rspec
+    watch(rspec.spec_helper) { rspec.spec_dir }
+    # watch(rspec.spec_support) { rspec.spec_dir }
+    watch(rspec.spec_files)
+
+    # Ruby files
+    ruby = dsl.ruby
+    watch(%r{lib/wcc/(.+)\.rb$}) { |m| rspec.spec.call("wcc/#{m[1]}") }
+    watch(%r{lib/generators/(.+)\.rb$}) { |m| rspec.spec.call("generators/#{m[1]}") }
+
+    # Rails files
+    rails = dsl.rails(view_extensions: %w[erb haml slim])
+    dsl.watch_spec_files_for(rails.app_files)
+    dsl.watch_spec_files_for(rails.views)
+
+    watch(rails.controllers) do |m|
+      [
+        rspec.spec.call("routing/#{m[1]}_routing"),
+        rspec.spec.call("controllers/#{m[1]}_controller"),
+        rspec.spec.call("acceptance/#{m[1]}")
+      ]
+    end
+
+    # Rails config changes
+    watch(rails.spec_helper)     { rspec.spec_dir }
+    watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+    watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+    # Capybara features specs
+    watch(rails.view_dirs)     { |m| rspec.spec.call("features/#{m[1]}") }
+    watch(rails.layouts)       { |m| rspec.spec.call("features/#{m[1]}") }
+  end
+
+  guard :rubocop, cli: ['--display-cop-names'] do
+    watch(%r{.+\.rb$})
+    watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
+  end
+
+  guard :shell, all_on_start: false do
+    watch_async(%r{app/views/(.+\.html.*\.erb)}) { |matches|
+      
+      matches = matches.map { |m| File.absolute_path(m[0]) }
+      Dir.chdir('..') {
+        system("bundle exec erblint #{matches.join(' ')}")
+      }
+    }
+  end
+end
+
+group :autofix do
+  guard :rubocop, all_on_start: false, cli: ['--auto-correct', '--display-cop-names'] do
+    watch(%r{.+\.rb$})
+    watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
+  end
+end
+
+scope group: :red_green_refactor

data/README.md

@@ -0,0 +1,128 @@
+[![Gem Version](https://badge.fury.io/rb/wcc-contentful-graphql.svg)](https://rubygems.org/gems/wcc-contentful-graphql)
+[![Build Status](https://travis-ci.org/watermarkchurch/wcc-contentful.svg?branch=master)](https://travis-ci.org/watermarkchurch/wcc-contentful)
+[![Coverage Status](https://coveralls.io/repos/github/watermarkchurch/wcc-contentful/badge.svg?branch=master)](https://coveralls.io/github/watermarkchurch/wcc-contentful?branch=master)
+
+# WCC::Contentful::Graphql
+
+This gem creates a GraphQL schema over your configured [data store](https://www.rubydoc.info/gems/wcc-contentful#Store_API).
+You can execute queries against this GraphQL schema to get all your contentful
+data.  Under the hood, queries are executed against your backing store to
+resolve all the requested data.
+
+### Important note!
+The GraphQL schema currently does not utilize the "include" parameter, so it is
+a very good idea to configure your store to either `:direct`
+or `:lazy_sync`.  If you don't do this, you will see a lot of requests to
+Contentful for specific entries by ID as the GraphQL resolver walks all your links!
+
+[More info on configuration can be found here](https://www.rubydoc.info/gems/wcc-contentful/WCC%2FContentful%2FConfiguration:store=)
+
+## Usage
+
+Querying directly within your app
+```rb
+schema = WCC::Contentful::Services.instance.graphql_schema
+=> #<GraphQL::Schema ...>
+
+result = schema.execute(<<~QUERY)
+          {
+            allConference(filter: { code: { eq: "CLC2020" } }) {
+              title
+              startDate
+              code
+            }
+          }
+        QUERY
+GET https://cdn.contentful.com/spaces/xxxxx/entries?content_type=conference&fields.code.en-US=CLC2020&locale=%2A
+Status 200
+=> #<GraphQL::Query::Result @query=... @to_h={"data"=>{"allConference"=>[{"title"=>"Church Leaders Conference", "startDate"=>"2020-04-28", "code"=>"CLC2020"}]}}>
+result.to_h
+=> {"data"=>
+  {"allConference"=>
+    [{"title"=>"Church Leaders Conference",
+      "startDate"=>"2020-04-28",
+      "code"=>"CLC2020"}]}}
+```
+
+Setting up a controller to respond to GraphQL queries
+
+```rb
+class Api::GraphqlController < Api::BaseController
+  include WCC::Contentful::ServiceAccessors
+
+  skip_before_action :authenticate_user!, only: :query
+
+  def query
+    result = graphql_schema.execute(
+      params[:query],
+      variables: params[:variables]
+    )
+    render json: result
+  end
+end
+```
+
+## Advanced Configuration
+
+### Including your Contentful schema inside another GraphQL schema
+
+```rb
+QueryType = GraphQL::ObjectType.define do
+  # extend this to get 'schema_stitch'
+  extend WCC::Contentful::Graphql::Federation
+
+  name 'RootQuery'
+
+  field 'a', types.String
+
+  schema_stitch(WCC::Contentful::Services.instance.graphql_schema,
+    namespace: 'contentful')
+end
+
+Schema = GraphQL::Schema.define do
+  query QueryType
+  
+  resolve_type ->(type, obj, ctx) {
+    raise StandardError, "Cannot resolve type #{type} #{obj.inspect} #{ctx.inspect}"
+  }
+end
+
+File.write('schema.gql', GraphQL::Schema::Printer.print_schema(Schema))
+```
+results in...
+```gql
+schema {
+  query: RootQuery
+}
+
+type Contentful {
+  """
+  Find a Asset
+  """
+  Asset(_content_type: Contentful_StringQueryOperatorInput, description: Contentful_StringQueryOperatorInput, id: ID, title: Contentful_StringQueryOperatorInput): Contentful_Asset
+
+  """
+  Find a CallToAction
+  """
+  CallToAction(_content_type: Contentful_StringQueryOperatorInput, id: ID, internalTitle: Contentful_StringQueryOperatorInput, style: Contentful_StringQueryOperatorInput, text: Contentful_StringQueryOperatorInput, title: Contentful_StringQueryOperatorInput): Contentful_CallToAction
+...
+```
+
+### Limiting the schema to only a few fields
+
+```rb
+store = WCC::Contentful::Services.instance.store
+builder =
+  WCC::Contentful::Graphql::Builder.new(
+    WCC::Contentful.types,
+    store,
+  ).configure do
+    root_types.slice!('conference')
+
+    schema_types['conference'].define do
+      # change the types of some fields, undefine fields, etc...
+    end
+  end
+
+@schema = builder.build_schema
+```

data/lib/wcc/contentful/ext/services.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module WCC::Contentful
+  class Services
+    # A GraphQL schema that will query Contentful using your configured store.
+    #
+    # @api Store
+    def graphql_schema
+      @graphql_schema ||=
+        ensure_configured do |_config|
+          WCC::Contentful::Graphql::Builder.new(
+            WCC::Contentful.types,
+            store
+          ).build_schema
+        end
+    end
+  end
+
+  module ServiceAccessors
+    def graphql_schema
+      Services.instance.graphql_schema
+    end
+  end
+end

data/lib/wcc/contentful/graphql.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+gem 'graphql', '~> 1.7'
+require 'graphql'
+
+module WCC::Contentful
+  # This module builds a GraphQL schema out of our IndexedRepresentation.
+  # It is currently unused and not hooked up in the WCC::Contentful.init! method.
+  # TODO: https://github.com/watermarkchurch/wcc-contentful/issues/14 hook it up
+  module Graphql
+  end
+end
+
+require_relative 'graphql/builder'
+require_relative 'graphql/federation'
+require_relative 'ext/services'

data/lib/wcc/contentful/graphql/builder.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'graphql'
+
+require_relative 'types'
+require_relative 'field_helper'
+
+GraphQL::Define::DefinedObjectProxy.__send__(:include, WCC::Contentful::Graphql::FieldHelper)
+
+module WCC::Contentful::Graphql
+  class Builder
+    attr_reader :schema_types
+    attr_reader :root_types
+
+    def initialize(types, store)
+      @types = types if types.is_a? WCC::Contentful::IndexedRepresentation
+      @types ||=
+        if types.is_a?(String) && File.exist?(types)
+          WCC::Contentful::ContentTypeIndexer.load(types).types
+        end
+
+      unless @types
+        raise ArgumentError, 'Cannot parse types - not an IndexedRepresentation ' \
+          "nor a schema file on disk: #{types}"
+      end
+
+      @store = store
+
+      @schema_types = build_schema_types
+      @root_types = @schema_types.dup
+    end
+
+    def configure(&block)
+      instance_exec(&block)
+      self
+    end
+
+    def build_schema
+      root_query_type = build_root_query(root_types)
+
+      builder = self
+      GraphQL::Schema.define do
+        query root_query_type
+
+        resolve_type ->(_type, obj, _ctx) {
+          content_type = WCC::Contentful::Helpers.content_type_from_raw(obj)
+          builder.schema_types[content_type]
+        }
+      end
+    end
+
+    private
+
+    def build_root_query(schema_types)
+      store = @store
+
+      GraphQL::ObjectType.define do
+        name 'Query'
+        description 'The query root of this schema'
+
+        schema_types.each do |content_type, schema_type|
+          field schema_type.name.to_sym do
+            type schema_type
+            argument :id, types.ID
+            description "Find a #{schema_type.name}"
+
+            schema_type.fields.each do |(name, field)|
+              next unless input_type = Types::QueryOperatorInput.call(field.type)
+
+              argument name, input_type
+            end
+
+            resolve ->(_obj, args, _ctx) {
+              if args['id'].nil?
+                store.find_by(content_type: content_type, filter: args.to_h)
+              else
+                store.find(args['id'])
+              end
+            }
+          end
+
+          field "all#{schema_type.name}".to_sym do
+            type schema_type.to_list_type
+            argument :filter, Types::FilterInputType.call(schema_type)
+
+            resolve ->(_obj, args, ctx) {
+              relation = store.find_all(content_type: content_type)
+              relation = relation.apply(args[:filter].to_h, ctx) if args[:filter]
+              relation.to_enum
+            }
+          end
+        end
+      end
+    end
+
+    def build_schema_types
+      @types.each_with_object({}) do |(k, v), h|
+        h[k] = build_schema_type(v)
+      end
+    end
+
+    def build_schema_type(typedef)
+      store = @store
+      builder = self
+      content_type = typedef.content_type
+
+      GraphQL::ObjectType.define do
+        name(typedef.name)
+
+        description("Generated from content type #{content_type}")
+
+        field :id, !types.ID do
+          resolve ->(obj, _args, _ctx) {
+            obj.dig('sys', 'id')
+          }
+        end
+
+        field :_content_type, !types.String do
+          resolve ->(_, _, _) {
+            content_type
+          }
+        end
+
+        # Make a field for each column:
+        typedef.fields.each_value do |f|
+          case f.type
+          when :Asset
+            field(f.name.to_sym, -> {
+              type = builder.schema_types['Asset']
+              type = type.to_list_type if f.array
+              type
+            }) do
+              resolve contentful_link_resolver(f.name, store: store)
+            end
+          when :Link
+            field(f.name.to_sym, -> {
+              type =
+                if f.link_types.nil? || f.link_types.empty?
+                  builder.schema_types['AnyContentful'] ||=
+                    Types::BuildUnionType.call(builder.schema_types, 'AnyContentful')
+                elsif f.link_types.length == 1
+                  builder.schema_types[f.link_types.first]
+                else
+                  from_types = builder.schema_types.select { |key| f.link_types.include?(key) }
+                  name = "#{typedef.name}_#{f.name}"
+                  builder.schema_types[name] ||= Types::BuildUnionType.call(from_types, name)
+                end
+              type = type.to_list_type if f.array
+              type
+            }) do
+              resolve contentful_link_resolver(f.name, store: store)
+            end
+          else
+            contentful_field(f.name, f.type, array: f.array)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wcc/contentful/graphql/federation.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Extend this module inside a root query definition to do schema federation.
+# https://blog.apollographql.com/apollo-federation-f260cf525d21
+#
+# This handles only queries, not mutations or subscriptions.
+module WCC::Contentful::Graphql::Federation
+  extend self
+
+  # Accepts an externally defined schema with a root query, and "stitches" it's
+  # query root into the current GraphQL::ObjectType definition.
+  # All fields on the external query object like `resource()`, `allResource()`
+  # will be inserted into the current object.  The `resolve` method for those
+  # fields will execute a query on the external schema, returning the results.
+  def schema_stitch(schema, namespace: nil)
+    ns_titleized = namespace&.titleize
+    ns = NamespacesTypes.new(namespace: ns_titleized)
+
+    def_fields =
+      proc {
+        schema.query.fields.each do |(key, field_def)|
+          field key, ns.namespaced(field_def.type) do
+            description field_def.description
+
+            field_def.arguments.each do |(arg_name, arg)|
+              argument arg_name, ns.namespaced(arg.type)
+            end
+
+            resolve delegate_to_schema(schema)
+          end
+        end
+      }
+
+    if namespace
+      stub_class = Struct.new(:name)
+      namespaced_type =
+        GraphQL::ObjectType.define do
+          name ns_titleized
+
+          instance_exec(&def_fields)
+        end
+
+      field namespace, namespaced_type do
+        resolve ->(_obj, _arguments, _context) { stub_class.new(namespace) }
+      end
+    else
+      def_fields.call
+    end
+  end
+
+  def delegate_to_schema(schema, field_name: nil, arguments: nil)
+    ->(obj, inner_args, context) {
+      field_name ||= context.ast_node.name
+
+      arguments = arguments.call(obj, inner_args, context) if arguments&.respond_to?(:call)
+      arguments = BuildsArguments.call(arguments) if arguments
+      arguments ||= context.ast_node.arguments
+
+      field_node = GraphQL::Language::Nodes::Field.new(
+        name: field_name,
+        arguments: arguments,
+        selections: context.ast_node.selections,
+        directives: context.ast_node.directives
+      )
+
+      query_node = GraphQL::Language::Nodes::OperationDefinition.new(
+        name: context.query.operation_name,
+        operation_type: 'query',
+        variables: context.query.selected_operation.variables,
+        selections: [
+          field_node
+        ]
+      )
+
+      # the ast_node.to_query_string prints the relevant section of the query to
+      # a string.  We build a query out of that which we execute on the external
+      # schema.
+      query = query_node.to_query_string
+
+      result = schema.execute(query,
+        variables: context.query.variables)
+
+      if result['errors'].present?
+        raise GraphQL::ExecutionError.new(
+          result.dig('errors', 0, 'message'),
+          ast_node: context.ast_node
+        )
+      end
+
+      result.dig('data', field_name)
+    }
+  end
+end
+
+GraphQL::Define::DefinedObjectProxy.__send__(:include, WCC::Contentful::Graphql::Federation)
+
+require_relative './federation/namespaces_types'
+require_relative './federation/builds_arguments'

data/lib/wcc/contentful/graphql/federation/builds_arguments.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::Graphql::Federation
+  BuildsArguments =
+    Struct.new(:argument) do
+      def self.call(arguments)
+        arguments.map { |arg| new(arg).call }
+      end
+
+      def call
+        return argument if argument.is_a? GraphQL::Language::Nodes::Argument
+
+        GraphQL::Language::Nodes::Argument.new(name: key, value: value)
+      end
+
+      private
+
+      def key
+        argument[0]
+      end
+
+      def value
+        if argument[1].is_a? Hash
+          return GraphQL::Language::Nodes::InputObject.new(arguments: BuildsArguments.call(argument[1]))
+        end
+
+        argument[1]
+      end
+    end
+end

data/lib/wcc/contentful/graphql/federation/namespaces_types.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# This GraphQL type definition wraps a type definition from an external schema
+# and redefines it in our top-level schema, so that names do not clash.
+# ex. "Campus" in the events schema becomes "Event_Campus"
+class WCC::Contentful::Graphql::Federation::NamespacesTypes
+  class << self
+    def registry
+      @registry ||= {}
+    end
+  end
+
+  attr_reader :namespace
+
+  def initialize(namespace:)
+    @namespace = namespace
+  end
+
+  # Gets the graphql type definition for the externally resolved field
+  def namespaced(type)
+    return type if type.default_scalar?
+    return namespaced(type.of_type).to_list_type if type.is_a?(GraphQL::ListType)
+    return namespaced(type.of_type).to_non_null_type if type.is_a?(GraphQL::NonNullType)
+
+    me = self
+    ns = namespace
+    typename = [namespace, type.to_s].compact.join('_')
+    self.class.registry[typename] ||=
+      if type.is_a?(GraphQL::UnionType)
+        possible_types =
+          type.possible_types.map { |t| me.namespaced(t) }
+        GraphQL::UnionType.define do
+          name typename
+          possible_types possible_types
+        end
+      elsif type.is_a?(GraphQL::InputObjectType)
+        GraphQL::InputObjectType.define do
+          name typename
+          type.arguments.each do |(name, arg)|
+            argument name, me.namespaced(arg.type)
+          end
+        end
+      elsif type.is_a?(GraphQL::ScalarType)
+        GraphQL::ScalarType.define do
+          name typename
+
+          coerce_input type.method(:coerce_input)
+          coerce_result type.method(:coerce_result)
+        end
+      elsif type.is_a?(GraphQL::ObjectType)
+        GraphQL::ObjectType.define do
+          name typename
+          description "#{type.name} from remote#{ns ? ' ' + ns : ''}"
+
+          type.fields.each do |(name, field_def)|
+            field name, me.namespaced(field_def.type) do
+              field_def.arguments.each do |(arg_name, arg)|
+                argument arg_name, me.namespaced(arg.type)
+              end
+
+              resolve ->(obj, _args, _ctx) do
+                # The object is a JSON response that came back from the
+                # external schema.  Resolve the value by using the hash key.
+                obj[name]
+              end
+            end
+          end
+        end
+      else
+        raise ArgumentError, "Cannot namespace type #{type} (#{type.class})"
+      end
+  end
+  # rubocop:enable
+end

data/lib/wcc/contentful/graphql/field_helper.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::Graphql::FieldHelper
+  extend self
+
+  def contentful_field_resolver(field_name)
+    field_name = field_name.to_s
+
+    ->(obj, _args, ctx) {
+      if obj.is_a? Array
+        obj.map { |o| o.dig('fields', field_name, ctx[:locale] || 'en-US') }
+      else
+        obj.dig('fields', field_name, ctx[:locale] || 'en-US')
+      end
+    }
+  end
+
+  def contentful_field(field_name, type, array: false, &block)
+    field_name = field_name.to_s
+
+    type =
+      case type
+      when :DateTime
+        types.String
+      when :Coordinates
+        WCC::Contentful::Graphql::Types::CoordinatesType
+      when :Json
+        WCC::Contentful::Graphql::Types::HashType
+      else
+        if type.is_a?(Symbol) || type.is_a?(String)
+          types.public_send(type)
+        elsif type.is_a?(GraphQL::BaseType)
+          type
+        else
+          raise ArgumentError, "Unknown type arg '#{type}' for field #{field_name}"
+        end
+      end
+    type = type.to_list_type if array
+    field(field_name.to_sym, type) do
+      resolve contentful_field_resolver(field_name)
+
+      instance_exec(&block) if block_given?
+    end
+  end
+
+  def contentful_link_resolver(field_name, store:)
+    ->(obj, _args, ctx) {
+      links = obj.dig('fields', field_name, ctx[:locale] || 'en-US')
+      return if links.nil?
+
+      if links.is_a? Array
+        links.reject(&:nil?).map { |l| store.find(l.dig('sys', 'id')) }
+      else
+        store.find(links.dig('sys', 'id'))
+      end
+    }
+  end
+end

data/lib/wcc/contentful/graphql/types.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module WCC::Contentful::Graphql::Types
+  DateTimeType =
+    GraphQL::ScalarType.define do
+      name 'DateTime'
+
+      coerce_result ->(value, _ctx) { Time.zone.parse(value) }
+    end
+
+  HashType =
+    GraphQL::ScalarType.define do
+      name 'Hash'
+
+      coerce_result ->(value, _ctx) {
+        return value if value.is_a? Array
+        return value.to_h if value.respond_to?(:to_h)
+        return JSON.parse(value) if value.is_a? String
+
+        raise ArgumentError, "Cannot coerce value '#{value}' to a hash"
+      }
+    end
+
+  CoordinatesType =
+    GraphQL::ObjectType.define do
+      name 'Coordinates'
+
+      field :lat, !types.Float, hash_key: 'lat'
+      field :lon, !types.Float, hash_key: 'lon'
+    end
+
+  StringQueryOperatorInput =
+    GraphQL::InputObjectType.define do
+      name 'StringQueryOperatorInput'
+
+      argument :eq, types.String
+    end
+
+  QueryOperatorInput =
+    ->(type) do
+      map = {
+        'String' => StringQueryOperatorInput
+        # 'Int' =>
+        # 'Boolean' =>
+      }
+
+      map[type.unwrap.name]
+    end
+
+  FilterInputType =
+    ->(schema_type) do
+      GraphQL::InputObjectType.define do
+        name "#{schema_type.name}FilterInput"
+
+        schema_type.fields.each do |(name, field)|
+          next unless input_type = QueryOperatorInput.call(field.type)
+
+          argument name, input_type
+        end
+      end
+    end
+
+  BuildUnionType =
+    ->(from_types, union_type_name) do
+      possible_types = from_types.values.reject { |t| t.is_a? GraphQL::UnionType }
+
+      GraphQL::UnionType.define do
+        name union_type_name
+        possible_types possible_types
+      end
+    end
+end

data/lib/wcc/contentful/graphql/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module WCC
+  module Contentful
+    module Graphql
+      VERSION = '1.0.0-rc1'
+    end
+  end
+end

data/wcc-contentful-graphql.gemspec

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wcc/contentful/graphql/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'wcc-contentful-graphql'
+  spec.version       = WCC::Contentful::Graphql::VERSION
+  spec.authors       = ['Watermark Dev']
+  spec.email         = ['dev@watermark.org']
+
+  spec.summary       = File.readlines(File.expand_path('README.md', __dir__)).join
+  spec.description   = 'GraphQL interface over WCC::Contentful store'
+  spec.homepage      = 'https://github.com/watermarkchurch/wcc-contentful/wcc-contentful-graphql'
+  spec.license       = 'MIT'
+
+  spec.required_ruby_version = '>= 2.3'
+
+  spec.files         =
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(test|spec|features)/})
+    end
+
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'dotenv', '~> 2.2'
+  spec.add_development_dependency 'httplog', '~> 1.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec_junit_formatter', '~> 0.3.0'
+  spec.add_development_dependency 'rubocop', '0.68'
+  spec.add_development_dependency 'simplecov', '~> 0.16.1'
+  spec.add_development_dependency 'webmock', '~> 3.0'
+
+  # Makes testing easy via `bundle exec guard`
+  spec.add_development_dependency 'guard', '~> 2.14'
+  spec.add_development_dependency 'guard-rspec', '~> 4.7'
+  spec.add_development_dependency 'guard-rubocop', '~> 1.3.0'
+  spec.add_development_dependency 'guard-shell', '~> 0.7.1'
+
+  # for generators
+  spec.add_development_dependency 'generator_spec', '~> 0.9.4'
+  # spec.add_development_dependency 'rails', '~> 5.1'
+  # spec.add_development_dependency 'rspec-rails', '~> 3.7'
+  spec.add_development_dependency 'sqlite3', '~> 1.3.6'
+  spec.add_development_dependency 'timecop', '~> 0.9.1'
+
+  spec.add_dependency 'graphql', '~> 1.7'
+  spec.add_dependency 'wcc-contentful', "~> #{WCC::Contentful::Graphql::VERSION}"
+end

metadata

@@ -0,0 +1,347 @@
+--- !ruby/object:Gem::Specification
+name: wcc-contentful-graphql
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre.rc1
+platform: ruby
+authors:
+- Watermark Dev
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: httplog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.68'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.68'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.1
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: guard-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: guard-shell
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: generator_spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.4
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: wcc-contentful
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0.pre.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0.pre.rc1
+description: GraphQL interface over WCC::Contentful store
+email:
+- dev@watermark.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Guardfile
+- README.md
+- lib/wcc/contentful/ext/services.rb
+- lib/wcc/contentful/graphql.rb
+- lib/wcc/contentful/graphql/builder.rb
+- lib/wcc/contentful/graphql/federation.rb
+- lib/wcc/contentful/graphql/federation/builds_arguments.rb
+- lib/wcc/contentful/graphql/federation/namespaces_types.rb
+- lib/wcc/contentful/graphql/field_helper.rb
+- lib/wcc/contentful/graphql/types.rb
+- lib/wcc/contentful/graphql/version.rb
+- wcc-contentful-graphql.gemspec
+homepage: https://github.com/watermarkchurch/wcc-contentful/wcc-contentful-graphql
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project:
+rubygems_version: 2.7.6.2
+signing_key:
+specification_version: 4
+summary: '[![Gem Version](https://badge.fury.io/rb/wcc-contentful-graphql.svg)](https://rubygems.org/gems/wcc-contentful-graphql)
+  [![Build Status](https://travis-ci.org/watermarkchurch/wcc-contentful.svg?branch=master)](https://travis-ci.org/watermarkchurch/wcc-contentful)
+  [![Coverage Status](https://coveralls.io/repos/github/watermarkchurch/wcc-contentful/badge.svg?branch=master)](https://coveralls.io/github/watermarkchurch/wcc-contentful?branch=master)  #
+  WCC::Contentful::Graphql  This gem creates a GraphQL schema over your configured
+  [data store](https://www.rubydoc.info/gems/wcc-contentful#Store_API). You can execute
+  queries against this GraphQL schema to get all your contentful data.  Under the
+  hood, queries are executed against your backing store to resolve all the requested
+  data.  ### Important note! The GraphQL schema currently does not utilize the "include"
+  parameter, so it is a very good idea to configure your store to either `:direct`
+  or `:lazy_sync`.  If you don''t do this, you will see a lot of requests to Contentful
+  for specific entries by ID as the GraphQL resolver walks all your links!  [More
+  info on configuration can be found here](https://www.rubydoc.info/gems/wcc-contentful/WCC%2FContentful%2FConfiguration:store=)  ##
+  Usage  Querying directly within your app ```rb schema = WCC::Contentful::Services.instance.graphql_schema
+  => #<GraphQL::Schema ...>  result = schema.execute(<<~QUERY) { allConference(filter:
+  { code: { eq: "CLC2020" } }) { title startDate code } } QUERY GET https://cdn.contentful.com/spaces/xxxxx/entries?content_type=conference&fields.code.en-US=CLC2020&locale=%2A
+  Status 200 => #<GraphQL::Query::Result @query=... @to_h={"data"=>{"allConference"=>[{"title"=>"Church
+  Leaders Conference", "startDate"=>"2020-04-28", "code"=>"CLC2020"}]}}> result.to_h
+  => {"data"=> {"allConference"=> [{"title"=>"Church Leaders Conference", "startDate"=>"2020-04-28",
+  "code"=>"CLC2020"}]}} ```  Setting up a controller to respond to GraphQL queries  ```rb
+  class Api::GraphqlController < Api::BaseController include WCC::Contentful::ServiceAccessors  skip_before_action
+  :authenticate_user!, only: :query  def query result = graphql_schema.execute( params[:query],
+  variables: params[:variables] ) render json: result end end ```  ## Advanced Configuration  ###
+  Including your Contentful schema inside another GraphQL schema  ```rb QueryType
+  = GraphQL::ObjectType.define do # extend this to get ''schema_stitch'' extend WCC::Contentful::Graphql::Federation  name
+  ''RootQuery''  field ''a'', types.String  schema_stitch(WCC::Contentful::Services.instance.graphql_schema,
+  namespace: ''contentful'') end  Schema = GraphQL::Schema.define do query QueryType  resolve_type
+  ->(type, obj, ctx) { raise StandardError, "Cannot resolve type #{type} #{obj.inspect}
+  #{ctx.inspect}" } end  File.write(''schema.gql'', GraphQL::Schema::Printer.print_schema(Schema))
+  ``` results in... ```gql schema { query: RootQuery }  type Contentful { """ Find
+  a Asset """ Asset(_content_type: Contentful_StringQueryOperatorInput, description:
+  Contentful_StringQueryOperatorInput, id: ID, title: Contentful_StringQueryOperatorInput):
+  Contentful_Asset  """ Find a CallToAction """ CallToAction(_content_type: Contentful_StringQueryOperatorInput,
+  id: ID, internalTitle: Contentful_StringQueryOperatorInput, style: Contentful_StringQueryOperatorInput,
+  text: Contentful_StringQueryOperatorInput, title: Contentful_StringQueryOperatorInput):
+  Contentful_CallToAction ... ```  ### Limiting the schema to only a few fields  ```rb
+  store = WCC::Contentful::Services.instance.store builder = WCC::Contentful::Graphql::Builder.new(
+  WCC::Contentful.types, store, ).configure do root_types.slice!(''conference'')  schema_types[''conference''].define
+  do # change the types of some fields, undefine fields, etc... end end  @schema =
+  builder.build_schema ```'
+test_files: []