oriole 0.1.0.alpha.0

data/bench/schemas/models.rb

@@ -0,0 +1,216 @@
+# typed: ignore
+# frozen_string_literal: true
+
+require_relative "bluejay"
+
+module Schemas
+  module Models
+    class DraftPosition < T::Struct
+      extend(T::Sig)
+      include(Schemas::Bluejay::DraftPosition::Interface)
+
+      const(:round, Integer)
+      const(:selection, Integer)
+      const(:year, Integer)
+    end
+
+    class Player < T::Struct
+      extend(T::Sig)
+      include(Schemas::Bluejay::Player::Interface)
+
+      const(:first_name, String)
+      const(:last_name, String)
+      const(:age, Integer)
+      const(:draft_position, T.nilable(DraftPosition))
+    end
+
+    class Team < T::Struct
+      extend(T::Sig)
+      include(Schemas::Bluejay::Team::Interface)
+
+      const(:name, String)
+      const(:city, String)
+      const(:players, T::Array[Player])
+
+      class << self
+        extend(T::Sig)
+
+        sig { returns(T::Array[Team]) }
+        def all
+          [
+            Team.new(
+              name: "Maple Leafs",
+              city: "Toronto",
+              players: [
+                Player.new(
+                  first_name: "Auston",
+                  last_name: "Matthews",
+                  age: 25,
+                  draft_position: DraftPosition.new(
+                    round: 1,
+                    selection: 1,
+                    year: 2016,
+                  ),
+                ),
+                Player.new(
+                  first_name: "Mitch",
+                  last_name: "Marner",
+                  age: 25,
+                  draft_position: DraftPosition.new(
+                    round: 1,
+                    selection: 4,
+                    year: 2015,
+                  ),
+                ),
+                Player.new(
+                  first_name: "William",
+                  last_name: "Nylander",
+                  age: 26,
+                  draft_position: DraftPosition.new(
+                    round: 1,
+                    selection: 8,
+                    year: 2014,
+                  ),
+                ),
+                Player.new(
+                  first_name: "John",
+                  last_name: "Tavares",
+                  age: 32,
+                  draft_position: DraftPosition.new(
+                    round: 1,
+                    selection: 1,
+                    year: 2009,
+                  ),
+                ),
+              ],
+            ),
+            Team.new(
+              name: "Bruins",
+              city: "Boston",
+              players: [
+                Player.new(
+                  first_name: "Patrice",
+                  last_name: "Bergeron",
+                  age: 37,
+                ),
+                Player.new(
+                  first_name: "Brad",
+                  last_name: "Marchand",
+                  age: 34,
+                ),
+                Player.new(
+                  first_name: "David",
+                  last_name: "Pastrňák",
+                  age: 26,
+                ),
+                Player.new(
+                  first_name: "Charlie",
+                  last_name: "McAvoy",
+                  age: 25,
+                ),
+              ],
+            ),
+            Team.new(
+              name: "Canadiens",
+              city: "Montréal",
+              players: [
+                Player.new(
+                  first_name: "Nick",
+                  last_name: "Suzuki",
+                  age: 23,
+                ),
+                Player.new(
+                  first_name: "Cole",
+                  last_name: "Caufield",
+                  age: 22,
+                ),
+                Player.new(
+                  first_name: "Kirby",
+                  last_name: "Dach",
+                  age: 21,
+                ),
+                Player.new(
+                  first_name: "Sean",
+                  last_name: "Monahan",
+                  age: 28,
+                ),
+              ],
+            ),
+            Team.new(
+              name: "Blackhawks",
+              city: "Chicago",
+              players: [],
+            ),
+            Team.new(
+              name: "Red Wings",
+              city: "Detroit",
+              players: [],
+            ),
+            Team.new(
+              name: "Rangers",
+              city: "New York",
+              players: [
+                Player.new(
+                  first_name: "Adam",
+                  last_name: "Fox",
+                  age: 24,
+                ),
+                Player.new(
+                  first_name: "Artemi",
+                  last_name: "Panarin",
+                  age: 31,
+                ),
+                Player.new(
+                  first_name: "Alexis",
+                  last_name: "Lafrenière",
+                  age: 21,
+                ),
+                Player.new(
+                  first_name: "Igor",
+                  last_name: "Shesterkin",
+                  age: 27,
+                ),
+              ],
+            ),
+          ]
+        end
+      end
+    end
+
+    class QueryRoot < T::Struct
+      extend(T::Sig)
+      include(Schemas::Bluejay::QueryRoot::Interface)
+
+      const(:teams, T::Array[Team])
+    end
+
+    class PlayersCreate < T::Struct
+      const(:count, Integer)
+    end
+
+    class MutationRoot
+      class << self
+        extend(T::Sig)
+
+        include(Schemas::Bluejay::MutationRoot::Interface)
+
+        sig { params(players: T::Array[Schemas::Bluejay::PlayerInput]).returns(PlayersCreate) }
+        def players_create(players:)
+          PlayersCreate.new(
+            count: players.length,
+          )
+        end
+      end
+    end
+
+    class SchemaRoot < T::Struct
+      extend(T::Sig)
+      include(Schemas::Bluejay::Schema::Root)
+
+      const(:query, QueryRoot)
+
+      sig { override.returns(Schemas::Bluejay::MutationRoot::Interface) }
+      def mutation = MutationRoot
+    end
+  end
+end

data/bench/schemas/oriole.rb

@@ -0,0 +1,144 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Schemas
+  module Oriole
+    class DraftPosition < ::Oriole::Definition::ObjectType
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T::Array[::Oriole::Definition::FieldDefinition]) }
+        def field_definitions
+          @field_definitions ||= T.let(
+            [
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "__typename",
+                type: ::Oriole::Definition::OutputType.named!(::Oriole::BuiltinScalarDefinition::String),
+                method_name: "resolve_typename",
+              ),
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "round",
+                type: ::Oriole::Definition::OutputType.named!(::Oriole::BuiltinScalarDefinition::Int),
+              ),
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "selection",
+                type: ::Oriole::Definition::OutputType.named!(::Oriole::BuiltinScalarDefinition::Int),
+              ),
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "year",
+                type: ::Oriole::Definition::OutputType.named!(::Oriole::BuiltinScalarDefinition::Int),
+              ),
+            ],
+            T.nilable(T::Array[::Oriole::Definition::FieldDefinition]),
+          )
+        end
+      end
+    end
+
+    class Player < ::Oriole::Definition::ObjectType
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T::Array[::Oriole::Definition::FieldDefinition]) }
+        def field_definitions
+          @field_definitions ||= T.let(
+            [
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "__typename",
+                type: ::Oriole::Definition::OutputType.named!(::Oriole::BuiltinScalarDefinition::String),
+                method_name: "resolve_typename",
+              ),
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "firstName",
+                type: ::Oriole::Definition::OutputType.named!(::Oriole::BuiltinScalarDefinition::String),
+                method_name: "first_name",
+              ),
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "lastName",
+                type: ::Oriole::Definition::OutputType.named!(::Oriole::BuiltinScalarDefinition::String),
+                method_name: "last_name",
+              ),
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "age",
+                type: ::Oriole::Definition::OutputType.named!(::Oriole::BuiltinScalarDefinition::Int),
+              ),
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "draftPosition",
+                type: ::Oriole::Definition::OutputType.named(DraftPosition),
+                method_name: "draft_position",
+              ),
+            ],
+            T.nilable(T::Array[::Oriole::Definition::FieldDefinition]),
+          )
+        end
+      end
+    end
+
+    class Team < ::Oriole::Definition::ObjectType
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T::Array[::Oriole::Definition::FieldDefinition]) }
+        def field_definitions
+          @field_definitions ||= T.let(
+            [
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "__typename",
+                type: ::Oriole::Definition::OutputType.named!(::Oriole::BuiltinScalarDefinition::String),
+                method_name: "resolve_typename",
+              ),
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "name",
+                type: ::Oriole::Definition::OutputType.named!(::Oriole::BuiltinScalarDefinition::String),
+              ),
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "city",
+                type: ::Oriole::Definition::OutputType.named!(::Oriole::BuiltinScalarDefinition::String),
+              ),
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "players",
+                type: ::Oriole::Definition::OutputType.list!(::Oriole::Definition::OutputType.named!(Player)),
+              ),
+            ],
+            T.nilable(T::Array[::Oriole::Definition::FieldDefinition]),
+          )
+        end
+      end
+    end
+
+    class QueryRoot < ::Oriole::Definition::ObjectType
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T::Array[::Oriole::Definition::FieldDefinition]) }
+        def field_definitions
+          @field_definitions ||= T.let(
+            [
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "__typename",
+                type: ::Oriole::Definition::OutputType.named!(::Oriole::BuiltinScalarDefinition::String),
+                method_name: "resolve_typename",
+              ),
+              ::Oriole::Definition::FieldDefinition.new(
+                graphql_name: "teams",
+                type: ::Oriole::Definition::OutputType.list!(::Oriole::Definition::OutputType.named!(Team)),
+              ),
+            ],
+            T.nilable(T::Array[::Oriole::Definition::FieldDefinition]),
+          )
+        end
+      end
+    end
+
+    class Schema < ::Oriole::Definition::Schema
+      class << self
+        extend(T::Sig)
+
+        sig { override.returns(T.class_of(::Oriole::Definition::ObjectType)) }
+        def query
+          QueryRoot
+        end
+      end
+    end
+  end
+end

data/bin/console

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

data/bin/setup

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

data/bin/style

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+bundle exec rubocop "$@"

data/bin/tapioca

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'tapioca' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("tapioca", "tapioca")

data/bin/typecheck

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+bundle exec srb tc "$@"

data/lib/oriole/builtin_scalar_definition.rb

@@ -0,0 +1,53 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  class BuiltinScalarDefinition < T::Enum
+    extend(T::Sig)
+    include(Execution::CoerceResult)
+
+    enums do
+      Int = new
+      Float = new
+      String = new
+      Boolean = new
+      ID = new
+    end
+
+    sig { override.params(result: Object).returns(Object) }
+    def coerce_result(result:)
+      case self
+      when Int
+        if result.is_a?(Integer) && result < T.cast(2**31, Integer) && result >= T.cast(-2**31, Integer)
+          result
+        else
+          raise "Value not an i32"
+        end
+      when Float
+        if result.is_a?(Numeric) && result.finite?
+          result
+        else
+          raise "Value not a finite float"
+        end
+      when String
+        if result.is_a?(::String)
+          result
+        else
+          raise "Value not a string"
+        end
+      when Boolean
+        if result == true || result == false
+          result
+        else
+          raise "Value not a boolean"
+        end
+      when ID
+        if result.is_a?(::String) || result.is_a?(Integer)
+          result
+        else
+          raise "Value not a string or integer"
+        end
+      end
+    end
+  end
+end

data/lib/oriole/definition/abstract/definition.rb

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Definition
+    module Abstract
+      module Definition
+        extend(T::Sig)
+        extend(T::Helpers)
+
+        abstract!
+
+        sig { abstract.returns(String) }
+        def graphql_name; end
+
+        sig { abstract.returns(T.nilable(String)) }
+        def description; end
+      end
+    end
+  end
+end

data/lib/oriole/definition/abstract/field_definition.rb

@@ -0,0 +1,22 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Definition
+    module Abstract
+      module FieldDefinition
+        extend(T::Sig)
+        extend(T::Helpers)
+        include(Definition)
+
+        abstract!
+
+        sig { abstract.returns(OutputType) }
+        def type; end
+
+        sig { abstract.returns(String) }
+        def resolver_method_name; end
+      end
+    end
+  end
+end

data/lib/oriole/definition/abstract/object_type_definition.rb

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Definition
+    module Abstract
+      module ObjectTypeDefinition
+        extend(T::Sig)
+        extend(T::Helpers)
+        include(Definition)
+
+        requires_ancestor { Kernel }
+
+        abstract!
+
+        sig { abstract.returns(T::Array[FieldDefinition]) }
+        def field_definitions; end
+      end
+    end
+  end
+end

data/lib/oriole/definition/abstract/schema_definition.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Definition
+    module Abstract
+      module SchemaDefinition
+        extend(T::Sig)
+        extend(T::Helpers)
+
+        abstract!
+
+        sig { abstract.returns(ObjectTypeDefinition) }
+        def query; end
+      end
+    end
+  end
+end

data/lib/oriole/definition/abstract/visibility.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Definition
+    module Abstract
+      module Visibility
+        extend(T::Sig)
+        extend(T::Helpers)
+
+        abstract!
+
+        sig { abstract.params(context: Object).returns(T::Boolean) }
+        def visible?(context:); end
+      end
+    end
+  end
+end

data/lib/oriole/definition/base_output_type.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Definition
+    BaseOutputType = T.type_alias do
+      T.any(
+        BuiltinScalarDefinition,
+        Abstract::ObjectTypeDefinition,
+      )
+    end
+  end
+end

data/lib/oriole/definition/field_definition.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Definition
+    class FieldDefinition < T::Struct
+      extend(T::Sig)
+      include(Abstract::FieldDefinition)
+
+      const(:graphql_name, String)
+      const(:description, T.nilable(String))
+      const(:type, OutputType)
+      const(:visibility, T.nilable(Abstract::Visibility))
+      const(:method_name, T.nilable(String))
+
+      sig { params(context: Object).returns(T::Boolean) }
+      def visible?(context:)
+        @visibility ? @visibility.visible?(context: context) : true
+      end
+
+      sig { override.returns(String) }
+      def resolver_method_name
+        @method_name || @graphql_name
+      end
+    end
+  end
+end

data/lib/oriole/definition/object_type.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Definition
+    class ObjectType
+      class << self
+        extend(T::Sig)
+        extend(T::Helpers)
+        include(Definition::Abstract::ObjectTypeDefinition)
+
+        abstract!
+
+        sig { overridable.returns(T.nilable(Abstract::Visibility)) }
+        def visibility
+          nil
+        end
+
+        sig { override.returns(String) }
+        def graphql_name
+          name&.split("::")&.last || "Anonymous"
+        end
+
+        sig { override.returns(T.nilable(String)) }
+        def description
+        end
+
+        sig { abstract.returns(T::Array[FieldDefinition]) }
+        def field_definitions; end
+
+        sig { params(context: Object).returns(T::Boolean) }
+        def visible?(context:)
+          visibility = self.visibility
+
+          visibility ? visibility.visible?(context: context) : true
+        end
+      end
+    end
+  end
+end