oriole 0.1.0.alpha.0

data/lib/oriole/definition/output_type.rb

@@ -0,0 +1,79 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Definition
+    module OutputType
+      extend(T::Sig)
+      extend(T::Helpers)
+
+      class << self
+        extend(T::Sig)
+
+        sig { params(inner: BaseOutputType).returns(OutputType) }
+        def named(inner) = Named.new(required: false, inner:)
+
+        sig { params(inner: BaseOutputType).returns(OutputType) }
+        def named!(inner) = Named.new(required: true, inner:)
+
+        sig { params(inner: OutputType).returns(OutputType) }
+        def list(inner) = List.new(required: false, inner:)
+
+        sig { params(inner: OutputType).returns(OutputType) }
+        def list!(inner) = List.new(required: true, inner:)
+      end
+
+      sealed!
+      abstract!
+
+      sig { abstract.returns(T::Boolean) }
+      def required?; end
+
+      sig { abstract.returns(T::Boolean) }
+      def list?; end
+
+      sig { abstract.returns(BaseOutputType) }
+      def base; end
+
+      sig { abstract.params(base: BaseOutputType).returns(T.self_type) }
+      def with_base(base); end
+
+      class List < T::Struct
+        extend(T::Sig)
+        include(OutputType)
+
+        const(:required, T::Boolean)
+        const(:inner, OutputType)
+
+        alias_method(:required?, :required)
+
+        sig { override.returns(T::Boolean) }
+        def list? = true
+
+        sig { override.returns(BaseOutputType) }
+        def base = inner.base
+
+        sig { override.params(base: BaseOutputType).returns(T.self_type) }
+        def with_base(base) = List.new(required:, inner: inner.with_base(base))
+      end
+
+      class Named < T::Struct
+        extend(T::Sig)
+        include(OutputType)
+
+        const(:required, T::Boolean)
+        const(:inner, BaseOutputType)
+
+        alias_method(:required?, :required)
+
+        sig { override.returns(T::Boolean) }
+        def list? = false
+
+        alias_method(:base, :inner)
+
+        sig { override.params(base: BaseOutputType).returns(T.self_type) }
+        def with_base(base) = Named.new(required:, inner: base)
+      end
+    end
+  end
+end

data/lib/oriole/definition/schema.rb

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Definition
+    class Schema
+      class << self
+        extend(T::Sig)
+        extend(T::Helpers)
+        include(Abstract::SchemaDefinition)
+
+        abstract!
+
+        sig { abstract.returns(T.class_of(ObjectType)) }
+        def query; end
+
+        sig do
+          params(
+            query: String,
+            context: Object,
+            root_value: Object,
+            operation_name: T.nilable(String),
+          ).returns(Object)
+        end
+        def execute(
+          query:,
+          context:,
+          root_value:,
+          operation_name: nil
+        )
+          Execution::Engine.execute(
+            schema_definition: VisibilityScoped::SchemaDefinition.new(
+              definition: self,
+              context:,
+            ),
+            query:,
+            context:,
+            root_value:,
+            operation_name:,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Definition
+    module VisibilityScoped
+      class ObjectTypeDefinition
+        extend(T::Sig)
+        include(Abstract::ObjectTypeDefinition)
+
+        sig { params(definition: T.class_of(ObjectType), context: Object).void }
+        def initialize(definition:, context:)
+          @definition = definition
+          @context = context
+          @field_definitions = T.let(nil, T.nilable(T::Array[FieldDefinition]))
+        end
+
+        class << self
+          extend(T::Sig)
+
+          sig { params(definition: T.class_of(ObjectType), context: Object).returns(T.nilable(T.attached_class)) }
+          def build(definition:, context:)
+            if definition.visible?(context:)
+              new(definition: definition, context: context)
+            end
+          end
+        end
+
+        sig { override.returns(String) }
+        def graphql_name = @definition.graphql_name
+
+        sig { override.returns(T.nilable(String)) }
+        def description = @definition.description
+
+        sig { override.returns(T::Array[FieldDefinition]) }
+        def field_definitions
+          @field_definitions ||= @definition.field_definitions.filter_map do |field_definition|
+            next nil unless field_definition.visible?(context: @context)
+
+            base_type = field_definition.type.base
+
+            scoped_base_type = if base_type.is_a?(Class) && base_type < ObjectType
+              ObjectTypeDefinition.build(definition: base_type, context: @context)
+            else
+              base_type
+            end
+
+            if scoped_base_type
+              FieldDefinition.new(
+                graphql_name: field_definition.graphql_name,
+                description: field_definition.description,
+                type: field_definition.type.with_base(scoped_base_type),
+                visibility: field_definition.visibility,
+                method_name: field_definition.method_name,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Definition
+    module VisibilityScoped
+      class SchemaDefinition
+        extend(T::Sig)
+        include(Abstract::SchemaDefinition)
+
+        sig { params(definition: T.class_of(Schema), context: Object).void }
+        def initialize(definition:, context:)
+          @definition = definition
+          @context = context
+          @query = T.let(
+            ObjectTypeDefinition.new(definition: @definition.query, context: @context),
+            ObjectTypeDefinition,
+          )
+        end
+
+        sig { override.returns(ObjectTypeDefinition) }
+        attr_reader(:query)
+      end
+    end
+  end
+end

data/lib/oriole/execution/coerce_result.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  module Execution
+    module CoerceResult
+      extend(T::Sig)
+      extend(T::Helpers)
+
+      abstract!
+
+      sig { abstract.params(result: Object).returns(Object) }
+      def coerce_result(result:); end
+    end
+  end
+end

data/lib/oriole/execution/engine.rb

@@ -0,0 +1,207 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "tinygql"
+require "set"
+
+module Oriole
+  module Execution
+    class Engine
+      extend(T::Sig)
+
+      sig do
+        params(
+          schema_definition: Definition::Abstract::SchemaDefinition,
+          document: TinyGQL::Nodes::Document,
+          context: Object,
+        ).void
+      end
+      def initialize(schema_definition:, document:, context:)
+        @schema_definition = schema_definition
+        @document = document
+        @context = context
+        @collect_fields_cache = T.let(
+          {},
+          T::Hash[Integer, T::Hash[String, T::Array[TinyGQL::Nodes::Field]]],
+        )
+      end
+
+      private_class_method(:new)
+
+      class << self
+        extend(T::Sig)
+
+        sig do
+          params(
+            schema_definition: Definition::Abstract::SchemaDefinition,
+            query: String,
+            context: Object,
+            operation_name: T.nilable(String),
+            root_value: Object,
+          ).returns(Object)
+        end
+        def execute(schema_definition:, query:, context:, operation_name:, root_value:)
+          document = TinyGQL.parse(query)
+
+          new(schema_definition:, document:, context:).execute(operation_name:, root_value:)
+        end
+      end
+
+      sig { params(operation_name: T.nilable(String), root_value: Object).returns(Object) }
+      def execute(operation_name:, root_value:)
+        operation_definition = if operation_name
+          @document.definitions.find do |definition|
+            definition.is_a?(TinyGQL::Nodes::OperationDefinition) && definition.name == operation_name
+          end || raise("Cannot find operation definition with name #{operation_name}")
+        else
+          operation_definitions = @document.definitions.select do |definition|
+            definition.is_a?(TinyGQL::Nodes::OperationDefinition)
+          end
+          if operation_definitions.one?
+            operation_definitions.first
+          else
+            raise "Cannot use anonymous operation with multiple operation definitions"
+          end
+        end
+
+        execute_operation(operation_definition: operation_definition, initial_value: root_value)
+      end
+
+      private
+
+      sig { params(operation_definition: TinyGQL::Nodes::OperationDefinition, initial_value: Object).returns(Object) }
+      def execute_operation(operation_definition:, initial_value:)
+        case operation_definition.type
+        when "query", nil
+          execute_selection_set(
+            selection_set: operation_definition.selection_set,
+            object_type: @schema_definition.query,
+            object_value: initial_value,
+          )
+        else
+          raise(NotImplementedError)
+        end
+      end
+
+      sig do
+        params(
+          selection_set: T::Array[TinyGQL::Nodes::Node],
+          object_type: Definition::Abstract::ObjectTypeDefinition,
+          object_value: Object,
+        ).returns(Object)
+      end
+      def execute_selection_set(selection_set:, object_type:, object_value:)
+        grouped_fields = collect_fields(object_type:, selection_set:, visited_fragments: Set.new)
+
+        result_map = {}
+
+        has_null_for_required = T.let(false, T::Boolean)
+
+        grouped_fields.each do |_response_key, fields|
+          field_name = T.must(fields.first).name
+          field_definition = object_type.field_definitions.find do |definition|
+            definition.graphql_name == field_name
+          end || raise("Cannot find field definition for #{field_name}")
+
+          field_value = execute_field(
+            object_type:,
+            field_definition:,
+            object_value:,
+            fields:,
+          )
+
+          result_map[field_name] = field_value
+
+          if field_definition.type.required? && field_value.nil?
+            has_null_for_required = true
+          end
+        end
+
+        result_map
+      end
+
+      sig do
+        params(
+          object_type: Definition::Abstract::ObjectTypeDefinition,
+          selection_set: T::Array[TinyGQL::Nodes::Node],
+          visited_fragments: T::Set[String],
+        ).returns(T::Hash[String, T::Array[TinyGQL::Nodes::Field]])
+      end
+      def collect_fields(object_type:, selection_set:, visited_fragments:)
+        if (cached_value = @collect_fields_cache[selection_set.object_id])
+          return cached_value
+        end
+
+        grouped_fields = {}
+
+        selection_set.each do |selection|
+          # TODO: handle include/skip directives
+
+          case selection
+          when TinyGQL::Nodes::Field
+            response_key = selection.aliaz || selection.name
+            grouped_fields[response_key] ||= []
+            grouped_fields[response_key] << selection
+          else
+            raise NotImplementedError
+          end
+        end
+
+        @collect_fields_cache[selection_set.object_id] = grouped_fields
+
+        grouped_fields
+      end
+
+      sig do
+        params(
+          object_type: Definition::Abstract::ObjectTypeDefinition,
+          object_value: Object,
+          field_definition: Definition::Abstract::FieldDefinition,
+          fields: T::Array[TinyGQL::Nodes::Field],
+        ).returns(Object)
+      end
+      def execute_field(object_type:, object_value:, field_definition:, fields:)
+        resolved_value = object_value.send(field_definition.resolver_method_name)
+
+        complete_value(field_type: field_definition.type, fields:, resolved_value:)
+      end
+
+      sig do
+        params(
+          field_type: Definition::OutputType,
+          fields: T::Array[TinyGQL::Nodes::Field],
+          resolved_value: Object,
+        ).returns(Object)
+      end
+      def complete_value(field_type:, fields:, resolved_value:)
+        if resolved_value.nil? && field_type.required?
+          raise "Cannot return null for non-null list type"
+        elsif resolved_value.nil?
+          return
+        end
+
+        case field_type
+        when Definition::OutputType::Named
+          case (inner_type = field_type.inner)
+          when BuiltinScalarDefinition
+            inner_type.coerce_result(result: resolved_value)
+          when Definition::Abstract::ObjectTypeDefinition
+            execute_selection_set(
+              selection_set: T.must(fields.first).selection_set,
+              object_type: inner_type,
+              object_value: resolved_value,
+            )
+          end
+        when Definition::OutputType::List
+          if resolved_value.is_a?(Array)
+            resolved_value.map do |value|
+              complete_value(field_type: field_type.inner, fields: fields, resolved_value: value)
+            end
+          else
+            raise "Cannot return non-list value for list type"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/oriole/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Oriole
+  VERSION = "0.1.0.alpha.0"
+end

data/lib/oriole.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module Oriole
+  class Error < StandardError; end
+  # Your code goes here...
+end
+
+loader.eager_load

data/oriole.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "oriole/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "oriole"
+  spec.version       = Oriole::VERSION
+  spec.authors       = ["Adam Petro"]
+  spec.email         = ["adamapetro@gmail.com"]
+
+  spec.summary       = "A fast GraphQL engine written in pure Ruby."
+  spec.description   = "A fast GraphQL engine written in pure Ruby."
+  spec.homepage      = "https://github.com/adampetro/oriole"
+  spec.license       = "MIT"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/adampetro/oriole"
+  spec.metadata["changelog_uri"] = "https://github.com/adampetro/oriole/blob/main/CHANGELOG"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency("bundler", "~> 2.4.10")
+  spec.add_development_dependency("minitest", "~> 5.0")
+  spec.add_development_dependency("rake", "~> 13.0")
+
+  spec.add_dependency("sorbet-runtime", "~> 0.5")
+  spec.add_dependency("tinygql", "~> 0.1.4")
+  spec.add_dependency("zeitwerk", "~> 2.6")
+end

data/rakelib/bench.rake

@@ -0,0 +1,69 @@
+# typed: ignore
+# frozen_string_literal: true
+
+require "open3"
+require "sorbet-runtime"
+
+class BenchmarkToDocument < T::Struct
+  const(:path, String)
+  const(:description, String)
+end
+
+BENCHMARKS_TO_DOCUMENT = [
+  BenchmarkToDocument.new(path: "execute", description: "Parse + Execute"),
+]
+
+namespace :bench do
+  all_tasks = [:compile]
+
+  Dir.glob("bench/*.rb").each do |path|
+    task_name = File.basename(path, ".rb")
+    next if task_name == "bench" # Bench helper
+
+    desc "Run #{path} benchmark"
+    task task_name do
+      sh "ruby -Ilib #{path}"
+      puts
+    end
+
+    all_tasks << task_name
+  end
+
+  desc "Run all benchmarks"
+  task all: all_tasks
+
+  desc "Document benchmark results"
+  task :doc do
+    output = ""
+
+    BENCHMARKS_TO_DOCUMENT.each do |benchmark|
+      puts "Benchmarking #{benchmark.path}"
+      [true, false].each do |yjit|
+        env = yjit ? { "RUBY_YJIT_ENABLE" => "1" } : {}
+        stdout, status = Open3.capture2e(env, "ruby", "-Ilib", "bench/#{benchmark.path}.rb")
+        unless status.success?
+          abort("Encountered an error: #{stdout}")
+        end
+        padded_stdout = stdout.lines.map { |line| "  #{line.chomp}".tap(&:rstrip!) }.join("\n")
+        output += <<~END
+          <details>
+            <summary>#{benchmark.description} (Ruby 3.2, YJIT #{yjit ? "enabled" : "disabled"})</summary>
+
+            ```
+          #{padded_stdout}
+            ```
+          </details>
+        END
+        output += "\n"
+      end
+    end
+
+    readme = "README.md"
+    contents = File.read(readme)
+    pattern = /(?<=<!---benchmark result start-->\n).*?(?=<!---benchmark result end-->)/m
+    File.write(readme, contents.gsub!(pattern, output.chomp))
+  end
+end
+
+desc "Run all benchmarks"
+task bench: "bench:all"

data/sorbet/config

@@ -0,0 +1,5 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/
+--enable-experimental-requires-ancestor