2 |
3 | GraphQL meets RoR
4 | with the most Ruby-like DSL
5 |
6 |
14 | 
15 |
16 |
--------------------------------------------------------------------------------
/lib/rails/graphql/alternative/subscription.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | # = GraphQL Alternative Subscription
6 | #
7 | # Same as it's parent class, but for subscription
8 | class Alternative::Subscription < Alternative::Query
9 | redefine_singleton_method(:type_field_class) { :subscription }
10 | self.abstract = true
11 |
12 | class << self
13 | delegate :scope, :trigger_for, :trigger, :unsubscribe_from, :unsubscribe,
14 | to: :@field, allow_nil: true
15 | end
16 | end
17 | end
18 | end
19 |
--------------------------------------------------------------------------------
/test/graphql/type/scalar/string_scalar_test.rb:
--------------------------------------------------------------------------------
1 | require 'config'
2 |
3 | class GraphQL_Type_Scalar_StringScalarTest < GraphQL::TestCase
4 | DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::StringScalar
5 |
6 | def test_as_json
7 | assert_equal('1', DESCRIBED_CLASS.as_json(1))
8 | assert_equal('', DESCRIBED_CLASS.as_json(nil))
9 | assert_equal('a', DESCRIBED_CLASS.as_json('a'))
10 |
11 | str = 'Sample'.encode(Encoding::ISO_8859_1)
12 | result = DESCRIBED_CLASS.as_json(str)
13 |
14 | assert_equal('Sample', result)
15 | assert_equal(result.encoding, Encoding::UTF_8)
16 | end
17 | end
18 |
--------------------------------------------------------------------------------
/benchmarks/append.rb:
--------------------------------------------------------------------------------
1 | require 'benchmark/ips'
2 |
3 | def slow_plus
4 | x = 'foo'
5 | x += 'bar'
6 | end
7 |
8 | def slow_concat
9 | x = 'foo'
10 | x.concat 'bar'
11 | end
12 |
13 | def fast_append
14 | x = 'foo'
15 | x << 'bar'
16 | end
17 |
18 | def fast_interpolation
19 | x = 'foo'
20 | x = "#{x}bar"
21 | end
22 |
23 | Benchmark.ips do |x|
24 | x.report('x += "bar"') { slow_plus }
25 | x.report('x.concat("bar")') { slow_concat }
26 | x.report('x << "bar"') { fast_append }
27 | x.report('x = "#{x}#{\'bar\'}"') { fast_interpolation }
28 | x.compare!
29 | end
30 |
--------------------------------------------------------------------------------
/test/graphql/type/scalar/binary_scalar_test.rb:
--------------------------------------------------------------------------------
1 | require 'config'
2 |
3 | class GraphQL_Type_Scalar_BinaryScalarTest < GraphQL::TestCase
4 | DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::BinaryScalar
5 | FILE_PATH = Pathname.new(__dir__).join('../../../assets/luke.jpg')
6 |
7 | def test_as_json
8 | assert_equal('MQ==', DESCRIBED_CLASS.as_json(1))
9 | assert_equal('YQ==', DESCRIBED_CLASS.as_json('a'))
10 | assert_equal('', DESCRIBED_CLASS.as_json(nil))
11 | end
12 |
13 | def test_deserialize
14 | file = DESCRIBED_CLASS.deserialize(File.read(FILE_PATH))
15 | assert_kind_of(ActiveModel::Type::Binary::Data, file)
16 | end
17 | end
18 |
--------------------------------------------------------------------------------
/test/graphql/type/scalar/float_scalar_test.rb:
--------------------------------------------------------------------------------
1 | require 'config'
2 |
3 | class GraphQL_Type_Scalar_FloatScalarTest < GraphQL::TestCase
4 | DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::FloatScalar
5 |
6 | def test_valid_input_ask
7 | assert(DESCRIBED_CLASS.valid_input?(1.0))
8 |
9 | refute(DESCRIBED_CLASS.valid_input?('12'))
10 | refute(DESCRIBED_CLASS.valid_input?(10))
11 | end
12 |
13 | def test_valid_output_ask
14 | assert(DESCRIBED_CLASS.valid_output?(1.0))
15 |
16 | refute(DESCRIBED_CLASS.valid_input?(false))
17 | end
18 |
19 | def test_as_json_ask
20 | assert_kind_of(Float, DESCRIBED_CLASS.as_json(10))
21 | end
22 | end
23 |
--------------------------------------------------------------------------------
/lib/rails/graphql/alternative.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | # Several alternatives to declare GraphQL objects
6 | module Alternative
7 | extend ActiveSupport::Autoload
8 |
9 | autoload :Query
10 | autoload :Mutation
11 | autoload :Subscription
12 |
13 | autoload_at "#{__dir__}/alternative/query" do
14 | autoload :Field
15 | end
16 |
17 | autoload_at "#{__dir__}/alternative/field_set" do
18 | autoload :FieldSet
19 | autoload :QuerySet
20 | autoload :MutationSet
21 | autoload :SubscriptionSet
22 | end
23 | end
24 | end
25 | end
26 |
--------------------------------------------------------------------------------
/docs/_includes/type-description.md:
--------------------------------------------------------------------------------
1 | ### Description
2 |
3 | Allows documenting {{ include.type }}s. This value can be retrieved using [introspection](/guides/introspection)
4 | or during a [to_gql](/guides/customizing/controller#describe) output. Within the class, `desc`
5 | works as a syntax sugar for `self.description = ''`. It also supports descriptions from
6 | [I18n](/guides/i18n).
7 |
8 | ```ruby
9 | # app/graphql/{{ include.type }}s/{% if include.file %}{{ include.file }}{% else %}{{ include.name | downcase }}{% endif %}.rb
10 | module GraphQL
11 | class {{ include.name }} < GraphQL::{{ include.type | capitalize }}
12 | desc 'This is awesome!'
13 | end
14 | end
15 | ```
16 |
--------------------------------------------------------------------------------
/lib/rails/graphql/railties/app/views/_fetch.js.erb:
--------------------------------------------------------------------------------
1 | function graphQLFetcher(graphQLParams) {
2 | // This example expects a GraphQL server at the path /graphql.
3 | // Change this to point wherever you host your GraphQL server.
4 | return fetch('<%= url %>', {
5 | method: 'post',
6 | headers: {
7 | 'Accept': 'application/json',
8 | 'Content-Type': 'application/json'
9 | },
10 | body: JSON.stringify(graphQLParams),
11 | }).then(function (response) {
12 | return response.text();
13 | }).then(function (responseBody) {
14 | try {
15 | return JSON.parse(responseBody);
16 | } catch (error) {
17 | return responseBody;
18 | }
19 | });
20 | }
21 |
--------------------------------------------------------------------------------
/test/assets/en.yml:
--------------------------------------------------------------------------------
1 | en:
2 | graphql:
3 | sample_a: A
4 | translate:
5 | sample_b: B
6 | field:
7 | sample_c: C
8 | schema:
9 | sample_field: Field
10 | sample_d: D
11 | argument:
12 | sample_field:
13 | arg_sample: Argument
14 | interface:
15 | interface_desc: Interface
16 | enum:
17 | enum_desc: Enum
18 | object:
19 | object_desc: Object
20 | union:
21 | union_desc: Union
22 | input_object:
23 | input_desc_input: Input
24 | scalar:
25 | scalar_desc: Scalar
26 | field:
27 | sample_e: E
28 | schema:
29 | sample_f: F
30 |
--------------------------------------------------------------------------------
/lib/rails/graphql/helpers/with_global_id.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | module Helpers
6 | # Helper module that is a different implementation of the
7 | # +GlobalID::Identification+, but instead of things being found by the
8 | # class that they are, it uses owners and base classes.
9 | module WithGlobalID
10 | def to_global_id(options = nil) # :nodoc:
11 | GlobalID.create(self, options)
12 | end
13 |
14 | alias to_gid to_global_id
15 |
16 | def to_gid_param(options = nil) # :nodoc:
17 | to_global_id(options).to_param
18 | end
19 | end
20 | end
21 | end
22 | end
23 |
--------------------------------------------------------------------------------
/test/graphql/type/scalar/json_scalar_test.rb:
--------------------------------------------------------------------------------
1 | require 'config'
2 |
3 | class GraphQL_Type_Scalar_JsonScalarTest < GraphQL::TestCase
4 | DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::JsonScalar
5 |
6 | def test_valid_input_ask
7 | assert(DESCRIBED_CLASS.valid_input?({}))
8 | refute(DESCRIBED_CLASS.valid_input?(1))
9 | end
10 |
11 | def test_valid_output_ask
12 | assert(DESCRIBED_CLASS.valid_output?({}))
13 | refute(DESCRIBED_CLASS.valid_output?(1))
14 | end
15 |
16 | def test_to_json
17 | assert_equal('{"a":1}', DESCRIBED_CLASS.to_json({ a: 1 }))
18 | end
19 |
20 | def test_as_json
21 | assert_equal({ 'a' => 1 }, DESCRIBED_CLASS.as_json({ a: 1 }))
22 | end
23 | end
24 |
--------------------------------------------------------------------------------
/lib/rails/graphql/type/scalar/any_scalar.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Type
6 | # Handles any type of data for both input and output
7 | class Scalar::AnyScalar < Scalar
8 | desc 'The Any scalar type allows anything for both input and output.'
9 |
10 | class << self
11 | def valid_input?(value)
12 | true
13 | end
14 |
15 | def valid_output?(value)
16 | true
17 | end
18 |
19 | def to_json(value)
20 | value.to_json
21 | end
22 |
23 | def as_json(value)
24 | value.as_json
25 | end
26 | end
27 | end
28 | end
29 | end
30 | end
31 |
--------------------------------------------------------------------------------
/docs/_sass/labels.scss:
--------------------------------------------------------------------------------
1 | // Labels (not the form kind)
2 |
3 | .label,
4 | .label-red {
5 | display: inline-block;
6 | padding-top: 0.16em;
7 | padding-right: 0.56em;
8 | padding-bottom: 0.16em;
9 | padding-left: 0.56em;
10 | margin-right: $sp-2;
11 | margin-left: $sp-2;
12 | color: $white;
13 | text-transform: uppercase;
14 | vertical-align: middle;
15 | background-color: $red-200;
16 | @include fs-2;
17 | border-radius: 24px;
18 | }
19 |
20 | .label-green {
21 | background-color: $green-200;
22 | }
23 |
24 | .label-purple {
25 | background-color: $purple-200;
26 | }
27 |
28 | .label-blue {
29 | background-color: $blue-200;
30 | }
31 |
32 | .label-yellow {
33 | color: $grey-dk-200;
34 | background-color: $yellow-200;
35 | }
36 |
--------------------------------------------------------------------------------
/lib/rails/graphql/directive/skip_directive.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | # = GraphQL Spec Skip Directive
6 | #
7 | # Allow skipping fields given an +if+ condition
8 | class Directive::SkipDirective < Directive
9 | self.spec_object = true
10 |
11 | desc 'Allows for conditional exclusion during execution as described by the if argument.'
12 |
13 | placed_on :field, :fragment_spread, :inline_fragment
14 |
15 | argument :if, :boolean, null: false, desc: <<~DESC
16 | When true, the underlying element will be automatically marked as null.
17 | DESC
18 |
19 | on(:attach) do |source|
20 | source.skip! if args[:if]
21 | end
22 | end
23 | end
24 | end
25 |
--------------------------------------------------------------------------------
/docs/assets/css/site.scss:
--------------------------------------------------------------------------------
1 | ---
2 | ---
3 |
4 | // Import external dependencies
5 | @import "./normalize";
6 |
7 | // Setup settings
8 | @import "./fonts";
9 | @import "./mixins";
10 | @import "./support/support";
11 | @import "./variables";
12 |
13 | // Load parts of the original style
14 | @import "./base";
15 | @import "./layout";
16 | @import "./content";
17 | @import "./typography";
18 | @import "./labels";
19 | @import "./buttons";
20 | @import "./search";
21 | @import "./tables";
22 | @import "./code";
23 | @import "./mermaid";
24 | @import "./utilities/utilities";
25 | @import "./print";
26 | @import "./callouts";
27 |
28 | // Load dark mode
29 | body.dark { @import "./dark"; }
30 | @media (prefers-color-scheme: dark) { @import "./dark"; }
31 |
32 | @import "./overrides";
33 |
--------------------------------------------------------------------------------
/docs/_sass/mixins.scss:
--------------------------------------------------------------------------------
1 | // Colored button
2 |
3 | @mixin colorize-button($fg, $bg1, $bg2) {
4 | color: $fg;
5 | background-color: $bg1;
6 | background-image: linear-gradient($bg1, $bg2);
7 | box-shadow: 0 1px 3px rgba(0, 0, 0, 0.25), 0 4px 10px rgba(0, 0, 0, 0.12);
8 |
9 | &:hover,
10 | &.zeroclipboard-is-hover {
11 | color: $fg;
12 | background-color: $bg1;
13 | background-image: linear-gradient($bg1, $bg2);
14 | box-shadow: inset 0 0 5px 2px rgba(0, 0, 0, 0.3);
15 | }
16 |
17 | &:active,
18 | &.selected,
19 | &.zeroclipboard-is-active {
20 | background-color: $bg1;
21 | background-image: none;
22 | box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15);
23 | }
24 |
25 | &.selected:hover {
26 | background-color: $bg1;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/examples/schema_introspection.rb:
--------------------------------------------------------------------------------
1 | # This reproduces the same result as
2 | # http://spec.graphql.org/June2018/#sec-Schema-Introspection
3 |
4 | [
5 | GraphQL::Object::SchemaObject,
6 | GraphQL::Object::TypeObject,
7 | GraphQL::Object::FieldObject,
8 | GraphQL::Object::InputValueObject,
9 | GraphQL::Object::EnumValueObject,
10 | GraphQL::Enum::TypeKindEnum,
11 | GraphQL::Object::DirectiveObject,
12 | GraphQL::Enum::DirectiveLocationEnum,
13 | ].each_with_index do |klass, i|
14 | puts if i > 0
15 | puts GraphQL.to_gql(klass, with_descriptions: false)
16 | end
17 |
18 | # This displays all the capabilities of the SampleSchema
19 |
20 | class SampleSchema < GraphQL::Schema
21 | end
22 |
23 | Rails::GraphQL.eager_load!
24 | puts SampleSchema.to_gql(with_descriptions: false)
25 |
--------------------------------------------------------------------------------
/lib/rails/graphql/directive/include_directive.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | # = GraphQL Spec Include Directive
6 | #
7 | # Allow including fields only +if+ condition is true
8 | class Directive::IncludeDirective < Directive
9 | self.spec_object = true
10 |
11 | placed_on :field, :fragment_spread, :inline_fragment
12 |
13 | desc 'Allows for conditional inclusion during execution as described by the if argument.'
14 |
15 | argument :if, :boolean, null: false, desc: <<~DESC
16 | When false, the underlying element will be automatically marked as null.
17 | DESC
18 |
19 | on(:attach) do |source|
20 | source.skip! unless args[:if]
21 | end
22 | end
23 | end
24 | end
25 |
--------------------------------------------------------------------------------
/lib/generators/graphql/schema_generator.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'rails/generators/base'
4 |
5 | module GraphQL
6 | module Generators
7 | class SchemaGenerator < Rails::Generators::Base # :nodoc:
8 | include Rails::GraphQL::BaseGenerator
9 |
10 | desc 'Add a new GraphQL schema'
11 |
12 | argument :schema, type: :string, optional: true,
13 | default: "#{APP_MODULE_NAME}Schema",
14 | desc: 'A name for the schema'
15 |
16 | def create_schema_file
17 | template 'schema.erb', "#{options[:directory]}/#{schema_name.underscore}.rb"
18 | end
19 |
20 | private
21 |
22 | def schema_name
23 | @schema_name ||= options.fetch(:schema, "#{APP_MODULE_NAME}Schema")
24 | end
25 | end
26 | end
27 | end
28 |
--------------------------------------------------------------------------------
/docs/_sass/support/mixins/_buttons.scss:
--------------------------------------------------------------------------------
1 | // Colored button
2 |
3 | @mixin btn-color($fg, $bg) {
4 | color: $fg;
5 | background-color: darken($bg, 2%);
6 | background-image: linear-gradient(lighten($bg, 5%), darken($bg, 2%));
7 | box-shadow: 0 1px 3px rgba(0, 0, 0, 0.25), 0 4px 10px rgba(0, 0, 0, 0.12);
8 |
9 | &:hover,
10 | &.zeroclipboard-is-hover {
11 | color: $fg;
12 | background-color: darken($bg, 4%);
13 | background-image: linear-gradient((lighten($bg, 2%), darken($bg, 4%)));
14 | }
15 |
16 | &:active,
17 | &.selected,
18 | &.zeroclipboard-is-active {
19 | background-color: darken($bg, 5%);
20 | background-image: none;
21 | box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15);
22 | }
23 |
24 | &.selected:hover {
25 | background-color: darken($bg, 10%);
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/lib/generators/graphql/channel_generator.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'rails/generators/base'
4 |
5 | module GraphQL
6 | module Generators
7 | class ChannelGenerator < Rails::Generators::Base # :nodoc:
8 | include Rails::GraphQL::BaseGenerator
9 |
10 | desc 'Add a new action cable channel that operates with GraphQL'
11 |
12 | argument :name, type: :string, optional: true,
13 | default: "GraphQLChannel",
14 | desc: 'The name for the channel'
15 |
16 | def create_channel_file
17 | template 'channel.erb', "app/channels/#{channel_name.underscore}.rb"
18 | end
19 |
20 | private
21 |
22 | def channel_name
23 | @channel_name ||= options.fetch(:name, 'GraphQLChannel').classify
24 | end
25 | end
26 | end
27 | end
28 |
--------------------------------------------------------------------------------
/lib/rails/graphql/directive/specified_by_directive.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | # = GraphQL Spec Specified By Directive
6 | #
7 | # Provides a scalar specification URL for specifying the behavior of
8 | # custom scalar types.
9 | class Directive::SpecifiedByDirective < Directive
10 | self.spec_object = true
11 |
12 | placed_on :scalar
13 |
14 | desc <<~DESC
15 | A built-in directive used within the type system definition language to provide
16 | a scalar specification URL for specifying the behavior of custom scalar types.
17 | DESC
18 |
19 | argument :url, :string, null: false, desc: <<~DESC
20 | Point to a human-readable specification of the data format.
21 | DESC
22 | end
23 | end
24 | end
25 |
--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 | # Rake tasks for development purposes
3 |
4 | begin
5 | require 'bundler/setup' unless ENV.key?('CI_COMPILE')
6 | rescue LoadError
7 | puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
8 | end
9 |
10 | require 'rdoc/task'
11 | require 'rake/testtask'
12 |
13 | require_relative 'tasks/libgraphqlparser'
14 |
15 | task default: :test
16 |
17 | Rake::TestTask.new(:test) do |t|
18 | t.libs << 'test'
19 | t.warning = true
20 | t.verbose = true
21 | t.test_files = Dir.glob("test/**/*_test.rb")
22 | end
23 |
24 | RDoc::Task.new(:rdoc) do |rdoc|
25 | rdoc.rdoc_dir = 'rdoc'
26 | rdoc.title = 'Rails::GraphQL'
27 | rdoc.options << '--line-numbers'
28 | rdoc.rdoc_files.include('README.rdoc')
29 | rdoc.rdoc_files.include('lib/**/*.rb')
30 | end
31 |
32 |
--------------------------------------------------------------------------------
/test/graphql/request/component/operation_test.rb:
--------------------------------------------------------------------------------
1 | require 'config'
2 |
3 | class GraphQL_Request_Component_OperationTest < GraphQL::TestCase
4 | def test_build
5 | request = Object.new
6 | request.define_singleton_method(:build) { |klass, *| klass }
7 |
8 | assert_equal(klass::Query, klass.build(request, new_token('', :query)))
9 | assert_equal(klass::Mutation, klass.build(request, new_token('', :mutation)))
10 | assert_equal(klass::Subscription, klass.build(request, new_token('', :subscription)))
11 |
12 | assert_raises(Rails::GraphQL::NameError) { klass.build(request, new_token('', '')) }
13 | assert_raises(Rails::GraphQL::NameError) { klass.build(request, new_token('', :field)) }
14 | end
15 |
16 | private
17 |
18 | def klass
19 | Rails::GraphQL::Request::Component::Operation
20 | end
21 | end
22 |
--------------------------------------------------------------------------------
/lib/generators/graphql/controller_generator.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'rails/generators/base'
4 |
5 | module GraphQL
6 | module Generators
7 | class ControllerGenerator < Rails::Generators::Base # :nodoc:
8 | include Rails::GraphQL::BaseGenerator
9 |
10 | desc 'Add a new controller that operates with GraphQL'
11 |
12 | argument :name, type: :string, optional: true,
13 | default: "GraphQLController",
14 | desc: 'The name for the controller'
15 |
16 | def create_controller_file
17 | template 'controller.erb', "app/controllers/#{controller_name.underscore}.rb"
18 | end
19 |
20 | private
21 |
22 | def controller_name
23 | @controller_name ||= options.fetch(:name, 'GraphQLController').classify
24 | end
25 | end
26 | end
27 | end
28 |
--------------------------------------------------------------------------------
/lib/rails/graphql/type/object/enum_value_object.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Type
6 | # The introspection object for an enum value
7 | class Object::EnumValueObject < Object
8 | self.spec_object = true
9 |
10 | rename! '__EnumValue'
11 |
12 | desc <<~DESC
13 | One of the values of an Enum object. It is unique within the Enum set
14 | of values. It's a string representation, not a numeric representation,
15 | of a value kept as all caps (ie. ONE_VALUE).
16 | DESC
17 |
18 | field :name, :string, null: false
19 | field :description, :string
20 | field :is_deprecated, :boolean, null: false
21 | field :deprecation_reason, :string
22 | end
23 | end
24 | end
25 | end
26 |
--------------------------------------------------------------------------------
/test/graphql/type/scalar/id_scalar_test.rb:
--------------------------------------------------------------------------------
1 | require 'config'
2 |
3 | class GraphQL_Type_Scalar_IdScalarTest < GraphQL::TestCase
4 | DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::IdScalar
5 |
6 | def test_valid_input_ask
7 | assert(DESCRIBED_CLASS.valid_input?(12345))
8 | assert(DESCRIBED_CLASS.valid_input?('bt3btb3t3'))
9 | assert(DESCRIBED_CLASS.valid_input?(SecureRandom.uuid))
10 |
11 | refute(DESCRIBED_CLASS.valid_input?(12.0))
12 | end
13 |
14 | def test_as_json
15 | str = 'Sample'.encode(Encoding::ISO_8859_1)
16 | result = DESCRIBED_CLASS.as_json(str)
17 |
18 | assert_equal('Sample', result)
19 | assert_equal(Encoding::UTF_8, result.encoding)
20 | end
21 |
22 | def test_deserialize
23 | assert_kind_of(String, DESCRIBED_CLASS.deserialize('foo'))
24 | assert_equal('foo', DESCRIBED_CLASS.deserialize('foo'))
25 | end
26 | end
27 |
--------------------------------------------------------------------------------
/lib/rails/graphql/railties/base_generator.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | # = GraphQL Base Generator
6 | #
7 | # A module to help generators to operate
8 | module BaseGenerator
9 | TEMPALTES_PATH = '../../../generators/graphql/templates'
10 | APP_MODULE_NAME = Rails.application.class.name.chomp('::Application')
11 |
12 | def self.included(base)
13 | base.const_set(:APP_MODULE_NAME, APP_MODULE_NAME)
14 | base.send(:namespace, "graphql:#{base.name.demodulize.underscore[0..-11]}")
15 | base.send(:source_root, File.expand_path(TEMPALTES_PATH, __dir__))
16 | base.send(:class_option, :directory, type: :string,
17 | default: 'app/graphql',
18 | desc: 'Directory where generated files should be saved',
19 | )
20 | end
21 | end
22 | end
23 | end
24 |
--------------------------------------------------------------------------------
/docs/_sass/print.scss:
--------------------------------------------------------------------------------
1 | // stylelint-disable selector-max-specificity, selector-max-id, selector-max-type, selector-no-qualifying-type, primer/no-override,
2 |
3 | @media print {
4 | .site-footer,
5 | .site-button,
6 | #edit-this-page,
7 | #back-to-top,
8 | .site-nav,
9 | .main-header {
10 | display: none !important;
11 | }
12 |
13 | .side-bar {
14 | width: 100%;
15 | height: auto;
16 | border-right: 0 !important;
17 | }
18 |
19 | .site-header {
20 | border-bottom: 1px solid $border-color;
21 | }
22 |
23 | .site-title {
24 | font-size: $root-font-size !important;
25 | font-weight: 700 !important;
26 | }
27 |
28 | .text-small {
29 | font-size: 8pt !important;
30 | }
31 |
32 | pre.highlight {
33 | border: 1px solid $border-color;
34 | }
35 |
36 | .main {
37 | max-width: none;
38 | margin-left: 0;
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/test/graphql/type/scalar/decimal_scalar_test.rb:
--------------------------------------------------------------------------------
1 | require 'config'
2 |
3 | class GraphQL_Type_Scalar_DecimalScalarScalarTest < GraphQL::TestCase
4 | DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::DecimalScalar
5 |
6 | def test_valid_input_ask
7 | assert(DESCRIBED_CLASS.valid_input?('1.0'))
8 | assert(DESCRIBED_CLASS.valid_input?('10.0'))
9 | assert(DESCRIBED_CLASS.valid_input?('10.00'))
10 | assert(DESCRIBED_CLASS.valid_input?('100.000'))
11 |
12 | refute(DESCRIBED_CLASS.valid_input?(10))
13 | end
14 |
15 | def test_valid_output_ask
16 | assert(DESCRIBED_CLASS.valid_output?(10.0))
17 |
18 | refute(DESCRIBED_CLASS.valid_output?(false))
19 | end
20 |
21 | def test_as_json
22 | assert_equal('10.0', DESCRIBED_CLASS.as_json(10))
23 | end
24 |
25 | def test_deserialize
26 | assert_kind_of(BigDecimal, DESCRIBED_CLASS.deserialize(1.0))
27 | end
28 | end
29 |
--------------------------------------------------------------------------------
/test/graphql/type/scalar/int_scalar_test.rb:
--------------------------------------------------------------------------------
1 | require 'config'
2 |
3 | class GraphQL_Type_Scalar_IntScalarTest < GraphQL::TestCase
4 | DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::IntScalar
5 |
6 | def test_valid_input_ask
7 | assert(DESCRIBED_CLASS.valid_input?(12345))
8 | assert(DESCRIBED_CLASS.valid_input?(2147483647))
9 |
10 | refute(DESCRIBED_CLASS.valid_input?(12.0))
11 | refute(DESCRIBED_CLASS.valid_input?(2147483649))
12 | refute(DESCRIBED_CLASS.valid_input?('2147483649'))
13 | end
14 |
15 | def test_valid_output_ask
16 | assert(DESCRIBED_CLASS.valid_output?(12345))
17 |
18 | refute(DESCRIBED_CLASS.valid_output?(2147483649))
19 | refute(DESCRIBED_CLASS.valid_output?('2147483649'))
20 | end
21 |
22 | def test_as_json
23 | assert_equal(123, DESCRIBED_CLASS.as_json(123))
24 | assert_nil(nil, DESCRIBED_CLASS.as_json(2147483649))
25 | end
26 | end
27 |
--------------------------------------------------------------------------------
/docs/_sass/support/mixins/_layout.scss:
--------------------------------------------------------------------------------
1 | // Media query
2 |
3 | // Media query mixin
4 | // Usage:
5 | // @include mq(md) {
6 | // ..medium and up styles
7 | // }
8 | @mixin mq($name) {
9 | // Retrieves the value from the key
10 | $value: map-get($media-queries, $name);
11 |
12 | // If the key exists in the map
13 | @if $value != null {
14 | // Prints a media query based on the value
15 | @media (min-width: rem($value)) {
16 | @content;
17 | }
18 | } @else {
19 | @warn "No value could be retrieved from `#{$media-query}`. "
20 | + "Please make sure it is defined in `$media-queries` map.";
21 | }
22 | }
23 |
24 | // Responsive container
25 |
26 | @mixin container {
27 | padding-right: $gutter-spacing-sm;
28 | padding-left: $gutter-spacing-sm;
29 |
30 | @include mq(md) {
31 | padding-right: $gutter-spacing;
32 | padding-left: $gutter-spacing;
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/lib/rails/graphql/field/scoped_config.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | # Helper class to be used while configuring a field using a block. An
6 | # instance of this class works as proxy for changes to the actual field.
7 | class Field::ScopedConfig < Struct.new(:field, :receiver)
8 | delegate :argument, :ref_argument, :id_argument, :use, :internal?, :disabled?,
9 | :enabled?, :disable!, :enable!, :authorize, to: :field
10 |
11 | delegate_missing_to :receiver
12 |
13 | def rename!(name)
14 | field.instance_variable_set(:@gql_name, name.to_s)
15 | end
16 |
17 | def method_name(value)
18 | field.instance_variable_set(:@method_name, value.to_sym)
19 | end
20 |
21 | def desc(value)
22 | field.description = value
23 | end
24 |
25 | alias description desc
26 | end
27 | end
28 | end
29 |
--------------------------------------------------------------------------------
/test/integration/mysql/star_wars_introspection_test.rb:
--------------------------------------------------------------------------------
1 | require 'integration/config'
2 |
3 | class Integration_MySQL_StarWarsIntrospectionTest < GraphQL::IntegrationTestCase
4 | load_schema 'mysql'
5 |
6 | SCHEMA = ::StartWarsMySQLSchema
7 |
8 | def test_auto_introspection
9 | assert(SCHEMA.introspection?)
10 | assert(SCHEMA.has_field?(:query, :__schema))
11 | assert(SCHEMA.has_field?(:query, :__type))
12 | end
13 |
14 | # Test this spec with all available scalars
15 | def remove_keys_form_type_map
16 | end
17 |
18 | # There are some issues with the end sorting, so compare the string result
19 | # with sorted characters, which will produce the exact match
20 | def test_gql_introspection
21 | # File.write('test/assets/mysql.gql', SCHEMA.to_gql)
22 | result = gql_file('mysql').split('').sort.join.squish
23 | assert_equal(result, SCHEMA.to_gql.split('').sort.join.squish)
24 | end
25 | end
26 |
--------------------------------------------------------------------------------
/test/integration/sqlite/star_wars_introspection_test.rb:
--------------------------------------------------------------------------------
1 | require 'integration/config'
2 |
3 | class Integration_SQLite_StarWarsIntrospectionTest < GraphQL::IntegrationTestCase
4 | load_schema 'sqlite'
5 |
6 | SCHEMA = ::StartWarsSqliteSchema
7 |
8 | def test_auto_introspection
9 | assert(SCHEMA.introspection?)
10 | assert(SCHEMA.has_field?(:query, :__schema))
11 | assert(SCHEMA.has_field?(:query, :__type))
12 | end
13 |
14 | # Test this spec with all available scalars
15 | def remove_keys_form_type_map
16 | end
17 |
18 | # There are some issues with the end sorting, so compare the string result
19 | # with sorted characters, which will produce the exact match
20 | def test_gql_introspection
21 | # File.write('test/assets/sqlite.gql', SCHEMA.to_gql)
22 | result = gql_file('sqlite').split('').sort.join.squish
23 | assert_equal(result, SCHEMA.to_gql.split('').sort.join.squish)
24 | end
25 | end
26 |
--------------------------------------------------------------------------------
/lib/rails/graphql/request/strategy/sequenced_strategy.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Request
6 | # = GraphQl Sequenced Strategy
7 | #
8 | # This is the default resolution strategy, where each operation is
9 | # performed in sequece, and they don't relate to each other in any way.
10 | class Strategy::SequencedStrategy < Strategy
11 | def self.can_resolve?(_)
12 | true
13 | end
14 |
15 | # Executes the strategy in the normal mode
16 | def resolve!
17 | response.with_stack('data') do
18 | for_each_operation do |op|
19 | collect_listeners { op.organize! }
20 | collect_data(op.mutation?) { op.prepare! }
21 | collect_response { op.resolve! }
22 | end
23 | end
24 | end
25 | end
26 | end
27 | end
28 | end
29 |
--------------------------------------------------------------------------------
/docs/_sass/typography.scss:
--------------------------------------------------------------------------------
1 | // Typography
2 | h1,
3 | .text-alpha {
4 | @include fs-8;
5 | font-weight: 900;
6 | }
7 |
8 | h2,
9 | .text-beta {
10 | @include fs-6;
11 | }
12 |
13 | h3,
14 | .text-gamma {
15 | @include fs-5;
16 | }
17 |
18 | h4,
19 | .text-delta {
20 | @include fs-2;
21 | font-weight: 400;
22 | text-transform: uppercase;
23 | letter-spacing: 0.1em;
24 | }
25 |
26 | h4 code {
27 | text-transform: none;
28 | }
29 |
30 | h5,
31 | .text-epsilon {
32 | @include fs-3;
33 | color: $grey-dk-200;
34 | }
35 |
36 | h6,
37 | .text-zeta {
38 | @include fs-2;
39 | color: $grey-dk-200;
40 | }
41 |
42 | .text-small {
43 | @include fs-2;
44 | }
45 |
46 | .text-mono {
47 | font-family: $mono-font-family !important;
48 | }
49 |
50 | .text-left {
51 | text-align: left !important;
52 | }
53 |
54 | .text-center {
55 | text-align: center !important;
56 | }
57 |
58 | .text-right {
59 | text-align: right !important;
60 | }
61 |
--------------------------------------------------------------------------------
/test/graphql/type/scalar/date_scalar_test.rb:
--------------------------------------------------------------------------------
1 | require 'config'
2 |
3 | class GraphQL_Type_Scalar_DateScalarTest < GraphQL::TestCase
4 | DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::DateScalar
5 |
6 | def test_valid_input_ask
7 | assert(DESCRIBED_CLASS.valid_input?('2020-02-02'))
8 |
9 | refute(DESCRIBED_CLASS.valid_input?(1))
10 | refute(DESCRIBED_CLASS.valid_input?('abc'))
11 | refute(DESCRIBED_CLASS.valid_input?(nil))
12 | end
13 |
14 | def test_valid_output_ask
15 | assert(DESCRIBED_CLASS.valid_output?('2020-02-02'))
16 |
17 | refute(DESCRIBED_CLASS.valid_output?('abc'))
18 | refute(DESCRIBED_CLASS.valid_output?(nil))
19 | refute(DESCRIBED_CLASS.valid_output?(1))
20 | end
21 |
22 | def test_as_json
23 | assert_equal('2020-02-02', DESCRIBED_CLASS.as_json('2020-02-02'))
24 | end
25 |
26 | def test_deserialize
27 | assert_kind_of(Date, DESCRIBED_CLASS.deserialize('2020-02-02'))
28 | end
29 | end
30 |
--------------------------------------------------------------------------------
/lib/rails/graphql/type/scalar/float_scalar.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Type
6 | # The Float scalar type represents signed double-precision fractional
7 | # values as specified by
8 | # {IEEE 754}[http://en.wikipedia.org/wiki/IEEE_floating_point].
9 | #
10 | # See http://spec.graphql.org/June2018/#sec-Float
11 | class Scalar::FloatScalar < Scalar
12 | self.spec_object = true
13 |
14 | desc 'The Float scalar type represents signed double-precision fractional values.'
15 |
16 | class << self
17 | def valid_input?(value)
18 | valid_token?(value) || value.is_a?(Float)
19 | end
20 |
21 | def valid_output?(value)
22 | value.respond_to?(:to_f)
23 | end
24 |
25 | def as_json(value)
26 | value.to_f
27 | end
28 | end
29 | end
30 | end
31 | end
32 | end
33 |
--------------------------------------------------------------------------------
/lib/rails/graphql/type/scalar/date_time_scalar.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Type
6 | # DateTime uses a ISO 8601 string to exchange the value.
7 | class Scalar::DateTimeScalar < Scalar
8 | aliases :datetime
9 |
10 | desc 'The DateTime scalar type represents a ISO 8601 string value.'
11 |
12 | use :specified_by, url: 'https://en.wikipedia.org/wiki/ISO_8601'
13 |
14 | class << self
15 | def valid_input?(value)
16 | super && !!(Time.iso8601(value) rescue false)
17 | end
18 |
19 | def valid_output?(value)
20 | value.respond_to?(:to_time) && !!value.to_time
21 | end
22 |
23 | def as_json(value)
24 | value.to_time.iso8601
25 | end
26 |
27 | def deserialize(value)
28 | Time.iso8601(value)
29 | end
30 | end
31 | end
32 | end
33 | end
34 | end
35 |
--------------------------------------------------------------------------------
/test/graphql/type/scalar/date_time_scalar_test.rb:
--------------------------------------------------------------------------------
1 | require 'config'
2 |
3 | class GraphQL_Type_Scalar_DateTimeScalarTest < GraphQL::TestCase
4 | DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::DateTimeScalar
5 |
6 | def test_valid_input_ask
7 | assert(DESCRIBED_CLASS.valid_input?(Time.now.iso8601))
8 |
9 | refute(DESCRIBED_CLASS.valid_input?(1))
10 | refute(DESCRIBED_CLASS.valid_input?('abc'))
11 | refute(DESCRIBED_CLASS.valid_input?(nil))
12 | end
13 |
14 | def test_valid_output_ask
15 | assert(DESCRIBED_CLASS.valid_output?(Time.now))
16 |
17 | refute(DESCRIBED_CLASS.valid_output?('abc'))
18 | refute(DESCRIBED_CLASS.valid_output?(1))
19 | refute(DESCRIBED_CLASS.valid_output?(nil))
20 | end
21 |
22 | def test_as_json
23 | assert_equal(Time.strptime('2020-02-02', '%Y-%m-%d'), DESCRIBED_CLASS.as_json('2020-02-02'))
24 | end
25 |
26 | def test_deserialize
27 | assert_kind_of(Time, DESCRIBED_CLASS.deserialize('2020-02-02T00:00:00-03:00'))
28 | end
29 | end
30 |
--------------------------------------------------------------------------------
/lib/rails/graphql/type/scalar/bigint_scalar.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Type
6 | # Bigint basically removes the limit of the value, but it serializes as
7 | # a string so it won't go against the spec
8 | class Scalar::BigintScalar < Scalar
9 | desc <<~DESC
10 | The Bigint scalar type represents a signed numeric non-fractional value.
11 | It can go beyond the Int 32-bit limit, but it's exchanged as a string.
12 | DESC
13 |
14 | class << self
15 | def valid_input?(value)
16 | super && value.match?(/\A[+-]?\d+\z/)
17 | end
18 |
19 | def valid_output?(value)
20 | value.respond_to?(:to_i)
21 | end
22 |
23 | def as_json(value)
24 | value.to_i.to_s
25 | end
26 |
27 | def deserialize(value)
28 | value.to_i
29 | end
30 | end
31 | end
32 | end
33 | end
34 | end
35 |
--------------------------------------------------------------------------------
/docs/_sass/overrides.scss:
--------------------------------------------------------------------------------
1 | // Override the main font of the website
2 | html {
3 | font-size: $root-font-size !important;
4 | }
5 |
6 | code {
7 | font-size: 0.875rem !important;
8 | }
9 |
10 | a:not([class]) {
11 | background-image: none;
12 | }
13 |
14 | .main-content {
15 | a:not([class]) {
16 | font-weight: bold;
17 |
18 | &:hover {
19 | text-decoration: underline;
20 | }
21 | }
22 |
23 | ol > li::before {
24 | top: 0;
25 | }
26 |
27 | h1, h2, h3, h4, h5, h6 {
28 | margin: 1.5rem 0;
29 |
30 | code {
31 | padding: 0.2em 0.5em;
32 | display: inline-block;
33 | vertical-align: text-top;
34 | }
35 | }
36 |
37 | h1, h2 {
38 | color: $red-200;
39 | }
40 |
41 | h4 {
42 | font-size: $font-size-4 !important;
43 | }
44 |
45 | h3 > code {
46 | vertical-align: text-bottom;
47 | }
48 |
49 | details.snippet > summary {
50 | margin-bottom: 1.5rem;
51 | }
52 |
53 | summary > h2 {
54 | margin: 0 !important;
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/ext/gql_parser.h:
--------------------------------------------------------------------------------
1 | #include "ruby.h"
2 |
3 | #define GQL_SAFE_PUSH_AND_NEXT(source, scanner, action) ({ \
4 | GQL_SAFE_PUSH(source, action); \
5 | gql_next_lexeme_no_comments(scanner); \
6 | })
7 | #define GQL_ASSIGN_TOKEN_AND_NEXT(source, scanner) (GQL_ASSIGN_VALUE_AND_NEXT(source, scanner, gql_scanner_to_token(scanner)))
8 | #define GQL_ASSIGN_VALUE_AND_NEXT(source, scanner, value) ({ \
9 | source = value; \
10 | gql_next_lexeme_no_comments(scanner); \
11 | })
12 | #define GQL_BUILD_PARSE_OUTER_TOKEN(type, size, pieces, scanner, mem) ({ \
13 | gql_token_start_from_mem(GQL_BUILD_PARSE_TOKEN(type, size, pieces, scanner), mem); \
14 | })
15 | #define GQL_BUILD_PARSE_TOKEN(type, size, pieces, scanner) ({ \
16 | gql_set_token_type(gql_as_token(rb_ary_new4(size, pieces), scanner, 0), type); \
17 | })
18 |
19 | VALUE GQLParser;
20 | VALUE QLGParserToken;
21 | VALUE gql_eParserError;
22 |
--------------------------------------------------------------------------------
/lib/rails/graphql/type/scalar/date_scalar.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Type
6 | # Date uses a ISO 8601 string to exchange the value.
7 | class Scalar::DateScalar < Scalar
8 | desc 'The Date scalar type represents a ISO 8601 string value.'
9 |
10 | use :specified_by, url: 'https://en.wikipedia.org/wiki/ISO_8601'
11 |
12 | class << self
13 | def valid_input?(value)
14 | super && !!Date.iso8601(value)
15 | rescue Date::Error
16 | false
17 | end
18 |
19 | def valid_output?(value)
20 | value.respond_to?(:to_date) && !!value.to_date
21 | rescue Date::Error
22 | false
23 | end
24 |
25 | def as_json(value)
26 | value.to_date.iso8601
27 | end
28 |
29 | def deserialize(value)
30 | Date.iso8601(value)
31 | end
32 | end
33 | end
34 | end
35 | end
36 | end
37 |
--------------------------------------------------------------------------------
/lib/rails/graphql/type/scalar/binary_scalar.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Type
6 | # Binary basically allows binary data to be shared using Base64 strings,
7 | # ensuring the UTF-8 encoding and performing the necessary conversion.
8 | #
9 | # It also rely on ActiveModel so it can easily share the same Data object.
10 | class Scalar::BinaryScalar < Scalar
11 | aliases :file
12 |
13 | desc <<~DESC
14 | The Binary scalar type represents a Base64 string.
15 | Normally used to share files and uploads.
16 | DESC
17 |
18 | use :specified_by, url: 'https://www.rfc-editor.org/rfc/rfc3548'
19 |
20 | class << self
21 | def as_json(value)
22 | Base64.encode64(value.to_s).chomp
23 | end
24 |
25 | def deserialize(value)
26 | ActiveModel::Type::Binary::Data.new(Base64.decode64(value))
27 | end
28 | end
29 | end
30 | end
31 | end
32 | end
33 |
--------------------------------------------------------------------------------
/test/graphql/type/scalar/any_scalar_test.rb:
--------------------------------------------------------------------------------
1 | require 'config'
2 |
3 | class GraphQL_Type_Scalar_AnyScalarTest < GraphQL::TestCase
4 | DESCRIBED_CLASS = Rails::GraphQL::Type::Scalar::AnyScalar
5 |
6 | OBJECTS = {
7 | 1 => [1, '1'],
8 | 'a' => ['a', '"a"'],
9 | true => [true, 'true'],
10 | 4.2 => [4.2, '4.2'],
11 | [1, 'a'] => [[1, 'a'], '[1,"a"]'],
12 | { a: 1, b: 'c' } => [{ 'a' => 1, 'b' => 'c' }, '{"a":1,"b":"c"}'],
13 | }
14 |
15 | def test_valid_input_ask
16 | OBJECTS.each_value do |(val, _)|
17 | assert(DESCRIBED_CLASS.valid_input?(val))
18 | end
19 | end
20 |
21 | def test_valid_output_ask
22 | OBJECTS.each_value do |(val, _)|
23 | assert(DESCRIBED_CLASS.valid_output?(val))
24 | end
25 | end
26 |
27 | def test_to_json
28 | OBJECTS.each do |source, (_, val)|
29 | assert_equal(val, DESCRIBED_CLASS.to_json(source))
30 | end
31 | end
32 |
33 | def test_as_json
34 | OBJECTS.each do |source, (val, _)|
35 | assert_equal(val, DESCRIBED_CLASS.as_json(source))
36 | end
37 | end
38 | end
39 |
--------------------------------------------------------------------------------
/lib/rails/graphql/request/strategy/multi_query_strategy.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Request
6 | # = GraphQl Multi Query Strategy
7 | #
8 | # This is a resolution strategy to solve requests that only contain
9 | # queries, allowing the strategy to collect all the information for all
10 | # the queries in a single step before resolving it.
11 | class Strategy::MultiQueryStrategy < Strategy
12 | self.priority = 10
13 |
14 | def self.can_resolve?(request)
15 | request.operations.each_value.all? { |op| op.of_type?(:query) }
16 | end
17 |
18 | # Executes the strategy in the normal mode
19 | def resolve!
20 | response.with_stack('data') do
21 | for_each_operation { |op| collect_listeners { op.organize! } }
22 | for_each_operation { |op| collect_data { op.prepare! } }
23 | for_each_operation { |op| collect_response { op.resolve! } }
24 | end
25 | end
26 | end
27 | end
28 | end
29 | end
30 |
--------------------------------------------------------------------------------
/lib/rails/graphql/type/scalar/boolean_scalar.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Type
6 | # The Boolean scalar type represents +true+ or +false+.
7 | #
8 | # See http://spec.graphql.org/June2018/#sec-Boolean
9 | class Scalar::BooleanScalar < Scalar
10 | self.spec_object = true
11 | aliases :bool
12 |
13 | desc 'The Boolean scalar type represents true or false.'
14 |
15 | FALSE_VALUES = ::ActiveModel::Type::Boolean::FALSE_VALUES
16 |
17 | class << self
18 | def valid_input?(value)
19 | valid_token?(value) || value === true || value === false
20 | end
21 |
22 | def valid_output?(*)
23 | true # Pretty much anything can be turned into a boolean
24 | end
25 |
26 | def as_json(value)
27 | !(value.nil? || FALSE_VALUES.include?(value))
28 | end
29 |
30 | def deserialize(value)
31 | as_json(value)
32 | end
33 | end
34 | end
35 | end
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/docs/assets/js/events.js:
--------------------------------------------------------------------------------
1 | (function(site, doc) {
2 | // Shortcut for adding event listeners
3 | site.addEvent = function(el, type, handler) {
4 | if (el.attachEvent) {
5 | el.attachEvent('on'+type, handler);
6 | } else {
7 | el.addEventListener(type, handler);
8 | }
9 | };
10 |
11 | // Shortcut for removing event listeners
12 | site.removeEvent = function(el, type, handler) {
13 | if (el.detachEvent) {
14 | el.detachEvent('on'+type, handler);
15 | } else {
16 | el.removeEventListener(type, handler);
17 | }
18 | };
19 |
20 | // Shortcut for when js is ready
21 | site.onReady = function(ready) {
22 | if (doc.readyState != 'loading') {
23 | // in case the document is already rendered
24 | ready();
25 | } else if (doc.addEventListener) {
26 | // modern browsers
27 | doc.addEventListener('DOMContentLoaded', ready)
28 | } else {
29 | // IE <= 8
30 | doc.attachEvent('onreadystatechange', function() {
31 | (doc.readyState == 'complete') && ready();
32 | });
33 | }
34 | };
35 | })(window.site = {}, document);
36 |
--------------------------------------------------------------------------------
/lib/rails/graphql/type/enum/directive_location_enum.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Type
6 | # Bigint basically removes the limit of the value, but it serializes as
7 | # a string so it won't go against the spec
8 | class Enum::DirectiveLocationEnum < Enum
9 | self.spec_object = true
10 |
11 | rename! '__DirectiveLocation'
12 |
13 | desc 'The valid locations that a directive may be placed.'
14 |
15 | Directive::EXECUTION_LOCATIONS.each do |value|
16 | name = value.to_s.upcase
17 | desc = value.to_s.tr('_', ' ')
18 | add(name, desc: "Mark as a executable directive usable on #{desc} objects.")
19 | end
20 |
21 | Directive::DEFINITION_LOCATIONS.each do |value|
22 | name = value.to_s.upcase
23 | desc = value.to_s.tr('_', ' ')
24 | desc = "Mark as a type system directive usable on #{desc} definitions."
25 | add(name, desc: desc.sub('definition definitions.', 'definitions.'))
26 | end
27 | end
28 | end
29 | end
30 | end
31 |
--------------------------------------------------------------------------------
/lib/rails/graphql/type/scalar/json_scalar.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Type
6 | # Handles an unstructured JSON data
7 | class Scalar::JsonScalar < Scalar
8 | rename! 'JSON'
9 |
10 | desc <<~DESC
11 | The JSON scalar type represents an unstructured JSON data
12 | with all its available keys and values.
13 | DESC
14 |
15 | use :specified_by, url: 'https://www.rfc-editor.org/rfc/rfc8259'
16 |
17 | class << self
18 | def valid_input?(value)
19 | valid_token?(value, :hash) || value.is_a?(::Hash)
20 | end
21 |
22 | def valid_output?(value)
23 | value.is_a?(::Hash)
24 | end
25 |
26 | def to_json(value)
27 | value.to_json
28 | end
29 |
30 | def as_json(value)
31 | value.as_json
32 | end
33 |
34 | def deserialize(value)
35 | value.is_a?(::GQLParser::Token) ? JSON.parse(value) : value
36 | end
37 | end
38 | end
39 | end
40 | end
41 | end
42 |
--------------------------------------------------------------------------------
/MIT-LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2020 "VirtualShield LLC"
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining
4 | a copy of this software and associated documentation files (the
5 | "Software"), to deal in the Software without restriction, including
6 | without limitation the rights to use, copy, modify, merge, publish,
7 | distribute, sublicense, and/or sell copies of the Software, and to
8 | permit persons to whom the Software is furnished to do so, subject to
9 | the following conditions:
10 |
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 |
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 |
--------------------------------------------------------------------------------
/lib/rails/graphql/directive/cached_directive.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | # = GraphQL Cached Directive
6 | #
7 | # Indicates that the request has hard cached operations that need to be
8 | # collected
9 | class Directive::CachedDirective < Directive
10 | placed_on :query
11 |
12 | desc 'Indicates that there are hard cached operations.'
13 |
14 | argument :id, :ID, null: false, desc: <<~DESC
15 | The unique identifier of the cached operation.
16 | DESC
17 |
18 | on(:attach) do |source, request|
19 | source.data.selection = nil
20 | # TODO: Add the request name back
21 | # source.instance_variable_set(:@name, 'here')
22 |
23 | # TODO: Add the arguments and variables
24 | field = request.build(Request::Component::Field, source, nil, { name: 'a', alias: 'b' })
25 | field.assing_to(ApplicationSchema[:query][:a])
26 | field.check_authorization!
27 |
28 | source.instance_variable_set(:@selection, { 'b' => field })
29 | # puts source.inspect
30 | end
31 | end
32 | end
33 | end
34 |
--------------------------------------------------------------------------------
/lib/rails/graphql/type/scalar/decimal_scalar.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Type
6 | # Similar to float, but implies extra precision, making sure that all the
7 | # decimal-point numbers are kept. As Bigint, it uses a string so it won't
8 | # go against the spec.
9 | class Scalar::DecimalScalar < Scalar
10 | desc <<~DESC
11 | The Decimal scalar type represents signed fractional values with extra precision.
12 | The values are exchange as string.
13 | DESC
14 |
15 | use :specified_by, url: 'https://en.wikipedia.org/wiki/IEEE_754-2008_revision'
16 |
17 | class << self
18 | def valid_input?(value)
19 | super && value.match?(/\A[+-]?\d+\.\d+\z/)
20 | end
21 |
22 | def valid_output?(value)
23 | value.respond_to?(:to_d)
24 | end
25 |
26 | def as_json(value)
27 | value.to_d.to_s
28 | end
29 |
30 | def deserialize(value)
31 | value.to_d
32 | end
33 | end
34 | end
35 | end
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/lib/rails/graphql/type/scalar/int_scalar.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Type
6 | # The Int scalar type represents a signed 32-bit numeric
7 | # non-fractional value.
8 | #
9 | # See http://spec.graphql.org/June2018/#sec-Int
10 | class Scalar::IntScalar < Scalar
11 | self.spec_object = true
12 | aliases :integer
13 |
14 | desc 'The Int scalar type represents a signed 32-bit numeric non-fractional value.'
15 |
16 | max_value = (1 << 31)
17 | RANGE = (-max_value...max_value).freeze
18 |
19 | class << self
20 | def valid_input?(value)
21 | (valid_token?(value) && RANGE.cover?(value.to_i)) ||
22 | (value.is_a?(Integer) && RANGE.cover?(value))
23 | end
24 |
25 | def valid_output?(value)
26 | value.respond_to?(:to_i) && RANGE.cover?(value.to_i)
27 | end
28 |
29 | def as_json(value)
30 | value = value.to_i
31 | value if RANGE.cover?(value)
32 | end
33 | end
34 | end
35 | end
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/docs/guides/advanced/abstract.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: default
3 | title: Abstract - Advanced - Guides
4 | description: All about abstract components
5 | ---
6 |
7 | # Abstract
8 |
9 | Most of the GraphQL components of this gem can be marked as `abstract`, which
10 | indicates that such components must be inherited first before being used.
11 |
12 | There are two main reasons why to mark a component as abstract:
13 |
14 | 1. They are not registered to the [Type Map](/guides/type-map);
15 | 1. They can't be instantiated directly during [events](/guides/events).
16 |
17 | This feature is recommended for those that wish to create other gems based on
18 | this one.
19 |
20 | {: .important }
21 | > **Important**
22 | > This feature is under review, which means it may behave differently
23 | > than described in some situations.
24 |
25 | ## How to Use It
26 |
27 | To mark a component as abstract, you can simply:
28 |
29 | ```ruby
30 | # app/graphql/objects/base_object.rb
31 | self.abstract = true
32 | ```
33 |
34 | You use of this to add shared methods, set configurations like
35 | [namespaces](/guides/advanced/namespaces), and create intermediate steps
36 | for [sources](/guides/sources#hooks).
37 |
--------------------------------------------------------------------------------
/docs/_sass/tables.scss:
--------------------------------------------------------------------------------
1 | //
2 | // Tables
3 | //
4 | // stylelint-disable max-nesting-depth, selector-no-type, selector-max-type
5 |
6 | .table-wrapper {
7 | display: block;
8 | width: 100%;
9 | max-width: 100%;
10 | margin-bottom: $sp-5;
11 | overflow-x: auto;
12 | border-radius: $border-radius;
13 | box-shadow: 0 1px 2px rgba(0, 0, 0, 0.12), 0 3px 10px rgba(0, 0, 0, 0.08);
14 | }
15 |
16 | table {
17 | display: table;
18 | min-width: 100%;
19 | border-collapse: separate;
20 | }
21 |
22 | th,
23 | td {
24 | @include fs-3;
25 | min-width: 120px;
26 | padding-top: $sp-2;
27 | padding-right: $sp-3;
28 | padding-bottom: $sp-2;
29 | padding-left: $sp-3;
30 | background-color: $table-background-color;
31 | border-bottom: $border rgba($border-color, 0.5);
32 | border-left: $border $border-color;
33 |
34 | &:first-of-type {
35 | border-left: 0;
36 | }
37 | }
38 |
39 | tbody {
40 | tr {
41 | &:last-of-type {
42 | th,
43 | td {
44 | border-bottom: 0;
45 | }
46 |
47 | td {
48 | padding-bottom: $sp-3;
49 | }
50 | }
51 | }
52 | }
53 |
54 | thead {
55 | th {
56 | border-bottom: $border $border-color;
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/lib/rails/graphql/railties/controller_runtime.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'active_support/core_ext/module/attr_internal'
4 |
5 | module Rails
6 | module GraphQL
7 | # = GraphQL Controller Runtime
8 | #
9 | # Tool that calculates the runtime of a GraphQL operation. This works
10 | # similar to how Rails ActiveRecord calculate its execution time while
11 | # performing a request
12 | module ControllerRuntime
13 | extend ActiveSupport::Concern
14 |
15 | module ClassMethods
16 | def log_process_action(payload)
17 | messages, gql_runtime = super, payload[:gql_runtime]
18 | messages << format(+'GraphQL: %.1fms', gql_runtime.to_f) if gql_runtime
19 | messages
20 | end
21 | end
22 |
23 | private
24 |
25 | attr_internal :gql_runtime
26 |
27 | def process_action(*)
28 | LogSubscriber.runtime = 0
29 | super
30 | end
31 |
32 | def append_info_to_payload(payload)
33 | super
34 |
35 | payload[:gql_runtime] = LogSubscriber.runtime \
36 | if (LogSubscriber.runtime || 0).positive?
37 | end
38 | end
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/lib/rails/graphql/request/steps/resolvable.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module Rails
4 | module GraphQL
5 | class Request
6 | # Helper methods for the resolve step of a request
7 | module Resolvable
8 | # Resolve the object
9 | def resolve!
10 | resolve
11 | rescue => error
12 | report_exception(error)
13 | end
14 |
15 | protected
16 |
17 | # Normal mode of the resolve step
18 | # TODO: Field a way to cache the resolved result, mostly for
19 | # performance improvement in recursion
20 | def resolve
21 | return if skipped?
22 | invalid? ? try(:resolve_invalid) : resolve_then
23 | rescue
24 | try(:resolve_invalid)
25 | raise
26 | end
27 |
28 | # The actual process that resolve the object
29 | def resolve_then(after_block = nil, &block)
30 | return if unresolvable?
31 |
32 | stacked do
33 | block.call if block.present?
34 | after_block.call if after_block.present?
35 | trigger_event(:finalize)
36 | end
37 | end
38 | end
39 | end
40 | end
41 | end
42 |
--------------------------------------------------------------------------------
/docs/_includes/3-steps.html:
--------------------------------------------------------------------------------
1 |