graphqlite 0.1.0

data/lib/graphqlite/validator.rb

@@ -0,0 +1,183 @@
+module GraphQLite
+  # Validator validates GraphQL documents against the schema
+  class Validator
+    attr_reader :schema, :errors
+
+    def initialize(schema)
+      @schema = schema
+      @errors = []
+    end
+
+    def validate(document)
+      @errors = []
+
+      document.definitions.each do |definition|
+        case definition
+        when Parser::OperationDefinition
+          validate_operation(definition)
+        when Parser::FragmentDefinition
+          validate_fragment(definition)
+        end
+      end
+
+      @errors
+    end
+
+    private
+
+    def validate_operation(operation)
+      # Get root type
+      root_type = case operation.operation_type
+      when 'query'
+        @schema.query_type
+      when 'mutation'
+        @schema.mutation_type
+      when 'subscription'
+        @schema.subscription_type
+      end
+
+      unless root_type
+        @errors << ValidationError.new("Schema does not support #{operation.operation_type}")
+        return
+      end
+
+      # Validate variable definitions
+      validate_variable_definitions(operation.variable_definitions)
+
+      # Validate selection set
+      validate_selection_set(operation.selection_set, root_type)
+    end
+
+    def validate_fragment(fragment)
+      # Validate type condition exists
+      type = @schema.get_type(fragment.type_condition.name)
+      unless type
+        @errors << ValidationError.new("Unknown type: #{fragment.type_condition.name}")
+        return
+      end
+
+      # Validate selection set
+      validate_selection_set(fragment.selection_set, type)
+    end
+
+    def validate_variable_definitions(variable_definitions)
+      return if variable_definitions.empty?
+
+      variable_definitions.each do |var_def|
+        # Validate variable type exists
+        type = resolve_type_ref(var_def.type)
+        unless type
+          @errors << ValidationError.new("Unknown type for variable $#{var_def.variable.name}")
+        end
+      end
+    end
+
+    def validate_selection_set(selection_set, parent_type)
+      return unless selection_set
+
+      selection_set.selections.each do |selection|
+        case selection
+        when Parser::Field
+          validate_field(selection, parent_type)
+        when Parser::FragmentSpread
+          # Fragment validation would require storing fragments
+          # Skip for minimal implementation
+        when Parser::InlineFragment
+          if selection.type_condition
+            type = @schema.get_type(selection.type_condition.name)
+            unless type
+              @errors << ValidationError.new("Unknown type: #{selection.type_condition.name}")
+              next
+            end
+            validate_selection_set(selection.selection_set, type)
+          else
+            validate_selection_set(selection.selection_set, parent_type)
+          end
+        end
+      end
+    end
+
+    def validate_field(field, parent_type)
+      field_name = field.name
+
+      # Introspection fields are always valid
+      return if %w[__typename __schema __type].include?(field_name)
+
+      # Check if field exists on parent type
+      unless parent_type.respond_to?(:fields) && parent_type.fields[field_name]
+        @errors << ValidationError.new("Field '#{field_name}' does not exist on type '#{parent_type.name}'")
+        return
+      end
+
+      field_def = parent_type.fields[field_name]
+
+      # Validate arguments
+      validate_arguments(field.arguments, field_def)
+
+      # Validate nested selection set
+      if field.selection_set
+        field_type = unwrap_type(field_def.type)
+
+        unless field_type.respond_to?(:fields)
+          @errors << ValidationError.new("Field '#{field_name}' is a scalar and cannot have a selection set")
+          return
+        end
+
+        validate_selection_set(field.selection_set, field_type)
+      elsif requires_selection_set?(field_def.type)
+        @errors << ValidationError.new("Field '#{field_name}' requires a selection set")
+      end
+    end
+
+    def validate_arguments(arguments, field_def)
+      return if arguments.empty?
+
+      arguments.each do |arg|
+        arg_def = field_def.arguments[arg.name]
+        unless arg_def
+          @errors << ValidationError.new("Unknown argument '#{arg.name}' on field '#{field_def.name}'")
+        end
+      end
+
+      # Check for required arguments
+      field_def.arguments.each do |arg_name, arg_def|
+        if arg_def.type.is_a?(Types::NonNullType)
+          unless arguments.any? { |arg| arg.name == arg_name }
+            @errors << ValidationError.new("Required argument '#{arg_name}' missing on field '#{field_def.name}'")
+          end
+        end
+      end
+    end
+
+    def unwrap_type(type)
+      case type
+      when Types::NonNullType, Types::ListType
+        unwrap_type(type.of_type)
+      else
+        type
+      end
+    end
+
+    def requires_selection_set?(type)
+      unwrapped = unwrap_type(type)
+      unwrapped.is_a?(Types::ObjectType) ||
+        unwrapped.is_a?(Types::InterfaceType) ||
+        unwrapped.is_a?(Types::UnionType)
+    end
+
+    def resolve_type_ref(type_ref)
+      case type_ref
+      when Parser::NamedType
+        @schema.get_type(type_ref.name)
+      when Parser::ListType
+        inner = resolve_type_ref(type_ref.type)
+        inner ? Types::ListType.new(inner) : nil
+      when Parser::NonNullType
+        inner = resolve_type_ref(type_ref.type)
+        inner ? Types::NonNullType.new(inner) : nil
+      else
+        type_ref
+      end
+    end
+  end
+end

data/lib/graphqlite/version.rb

@@ -0,0 +1,3 @@
+module GraphQLite
+  VERSION = "0.1.0"
+end

data/lib/graphqlite.rb

@@ -0,0 +1,18 @@
+require_relative "graphqlite/version"
+require_relative "graphqlite/lexer"
+require_relative "graphqlite/parser"
+require_relative "graphqlite/types"
+require_relative "graphqlite/schema"
+require_relative "graphqlite/executor"
+require_relative "graphqlite/validator"
+require_relative "graphqlite/introspection"
+require_relative "graphqlite/errors"
+
+module GraphQLite
+  class << self
+    # Create a new schema
+    def schema(&block)
+      Schema.new(&block)
+    end
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: graphqlite
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- zyxzen
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: GraphQLite is a simple, minimal, and clean GraphQL implementation with
+  zero dependencies. It's designed to be easier to use and faster than existing solutions
+  while maintaining full GraphQL spec compliance.
+email:
+- dev@zyxzen.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/graphqlite.rb
+- lib/graphqlite/errors.rb
+- lib/graphqlite/executor.rb
+- lib/graphqlite/introspection.rb
+- lib/graphqlite/lexer.rb
+- lib/graphqlite/parser.rb
+- lib/graphqlite/schema.rb
+- lib/graphqlite/types.rb
+- lib/graphqlite/validator.rb
+- lib/graphqlite/version.rb
+homepage: https://github.com/zyxzen/graphqlite
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/zyxzen/graphqlite
+  changelog_uri: https://github.com/zyxzen/graphqlite/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A lightweight, production-ready GraphQL implementation for Ruby
+test_files: []