graphqlite 0.1.0

data/lib/graphqlite/schema.rb

@@ -0,0 +1,238 @@
+module GraphQLite
+  # Schema is the main entry point for defining GraphQL schemas
+  class Schema
+    attr_reader :query_type, :mutation_type, :subscription_type, :types, :directives
+
+    def initialize(&block)
+      @types = {}
+      @directives = {}
+      @query_type = nil
+      @mutation_type = nil
+      @subscription_type = nil
+      @type_resolver = TypeResolver.new(self)
+
+      # Register built-in scalars
+      register_type(Types::INT)
+      register_type(Types::FLOAT)
+      register_type(Types::STRING)
+      register_type(Types::BOOLEAN)
+      register_type(Types::ID)
+
+      # Build schema using DSL
+      instance_eval(&block) if block_given?
+
+      # Add introspection types
+      Introspection.add_introspection_types(self)
+    end
+
+    def query(&block)
+      @query_type = define_root_type('Query', &block)
+    end
+
+    def mutation(&block)
+      @mutation_type = define_root_type('Mutation', &block)
+    end
+
+    def subscription(&block)
+      @subscription_type = define_root_type('Subscription', &block)
+    end
+
+    def object(name, description: nil, interfaces: [], &block)
+      type = Types::ObjectType.new(name.to_s, description: description, interfaces: interfaces)
+      register_type(type)
+
+      builder = TypeBuilder.new(type, self)
+      builder.instance_eval(&block) if block_given?
+
+      type
+    end
+
+    def interface(name, description: nil, resolve_type: nil, &block)
+      type = Types::InterfaceType.new(name.to_s, description: description, resolve_type: resolve_type)
+      register_type(type)
+
+      builder = TypeBuilder.new(type, self)
+      builder.instance_eval(&block) if block_given?
+
+      type
+    end
+
+    def union(name, types: [], description: nil, resolve_type: nil)
+      type = Types::UnionType.new(name.to_s, types: types, description: description, resolve_type: resolve_type)
+      register_type(type)
+      type
+    end
+
+    def enum(name, values: {}, description: nil)
+      type = Types::EnumType.new(name.to_s, values: values, description: description)
+      register_type(type)
+      type
+    end
+
+    def input_object(name, description: nil, &block)
+      type = Types::InputObjectType.new(name.to_s, description: description)
+      register_type(type)
+
+      builder = TypeBuilder.new(type, self)
+      builder.instance_eval(&block) if block_given?
+
+      type
+    end
+
+    def scalar(name, description: nil, serialize: nil, parse_value: nil, parse_literal: nil)
+      type = Types::ScalarType.new(
+        name.to_s,
+        description: description,
+        serialize: serialize,
+        parse_value: parse_value,
+        parse_literal: parse_literal
+      )
+      register_type(type)
+      type
+    end
+
+    def execute(query_string, variables: {}, operation_name: nil, context: {})
+      # Parse the query
+      document = Parser.new(query_string).parse
+
+      # Validate the query
+      validator = Validator.new(self)
+      errors = validator.validate(document)
+      return { 'errors' => errors.map { |e| { 'message' => e.message } } } unless errors.empty?
+
+      # Execute the query
+      executor = Executor.new(self)
+      executor.execute(document, variables: variables, operation_name: operation_name, context: context)
+    rescue ParseError, ValidationError, ExecutionError => e
+      { 'errors' => [{ 'message' => e.message }] }
+    end
+
+    def get_type(name)
+      return nil if name.nil?
+      @types[name.to_s]
+    end
+
+    def register_type(type)
+      @types[type.name] = type
+    end
+
+    private
+
+    def define_root_type(name, &block)
+      type = Types::ObjectType.new(name)
+      register_type(type)
+
+      builder = TypeBuilder.new(type, self)
+      builder.instance_eval(&block) if block_given?
+
+      type
+    end
+
+    # Helper class for building types using DSL
+    class TypeBuilder
+      def initialize(type, schema)
+        @type = type
+        @schema = schema
+        @resolver = TypeResolver.new(schema)
+      end
+
+      def field(name, type = nil, description: nil, null: true, deprecation_reason: nil, &block)
+        # Resolve type reference
+        resolved_type = @resolver.resolve(type)
+        resolved_type = Types::NonNullType.new(resolved_type) unless null
+
+        if @type.is_a?(Types::ObjectType)
+          # Check if block expects a parameter (builder pattern) or not (resolver pattern)
+          if block && block.arity > 0
+            # Builder pattern: pass FieldBuilder to block
+            field_def = @type.field(name, resolved_type, description: description, deprecation_reason: deprecation_reason)
+            field_builder = FieldBuilder.new(field_def, @schema)
+            block.call(field_builder)
+            field_builder
+          else
+            # Resolver pattern: block is the resolver
+            field_def = @type.field(name, resolved_type, description: description, deprecation_reason: deprecation_reason, &block)
+            FieldBuilder.new(field_def, @schema)
+          end
+        elsif @type.is_a?(Types::InterfaceType)
+          @type.field(name, resolved_type, description: description, deprecation_reason: deprecation_reason)
+        elsif @type.is_a?(Types::InputObjectType)
+          default_value = null ? nil : block&.call
+          @type.field(name, resolved_type, description: description, default_value: default_value)
+        end
+      end
+    end
+
+    # Helper class for building fields with arguments
+    class FieldBuilder
+      attr_reader :field
+
+      def initialize(field, schema)
+        @field = field
+        @schema = schema
+        @resolver = TypeResolver.new(schema)
+      end
+
+      def argument(name, type, description: nil, default_value: nil)
+        resolved_type = @resolver.resolve(type)
+        @field.argument(name, resolved_type, description: description, default_value: default_value)
+        self
+      end
+
+      alias arg argument
+
+      def resolve(&block)
+        @field.instance_variable_set(:@resolve, block)
+        self
+      end
+    end
+
+    # Lazy type reference for forward references
+    class TypeReference
+      attr_reader :name, :schema
+
+      def initialize(name, schema)
+        @name = name
+        @schema = schema
+      end
+
+      def resolve
+        type = @schema.get_type(@name.to_s)
+        raise TypeError, "Unknown type: #{@name}" unless type
+        type
+      end
+    end
+
+    # Type resolver handles type references (symbols, strings, types)
+    class TypeResolver
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def resolve(type_ref)
+        case type_ref
+        when Types::BaseType, Types::ListType, Types::NonNullType
+          type_ref
+        when String, Symbol
+          # Look up type by name - if it doesn't exist yet, return a lazy reference
+          type = @schema.get_type(type_ref.to_s)
+          return type if type
+          # Return lazy reference for forward references (mainly for introspection)
+          TypeReference.new(type_ref, @schema)
+        when Array
+          # Array notation for lists: [String] -> ListType
+          raise TypeError, "Array type must have exactly one element" unless type_ref.length == 1
+          Types::ListType.new(resolve(type_ref[0]))
+        when Class
+          # Ruby class reference - auto-convert to type name
+          type_name = type_ref.name.split('::').last
+          type = @schema.get_type(type_name)
+          return type if type
+          TypeReference.new(type_name, @schema)
+        else
+          raise TypeError, "Invalid type reference: #{type_ref.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/graphqlite/types.rb

@@ -0,0 +1,336 @@
+module GraphQLite
+  module Types
+    # Base class for all types
+    class BaseType
+      attr_reader :name, :description
+
+      def initialize(name, description: nil)
+        @name = name
+        @description = description
+      end
+
+      def to_s
+        name
+      end
+
+      def non_null?
+        false
+      end
+
+      def list?
+        false
+      end
+    end
+
+    # Scalar types
+    class ScalarType < BaseType
+      attr_reader :serialize, :parse_value, :parse_literal
+
+      def initialize(name, description: nil, serialize: nil, parse_value: nil, parse_literal: nil)
+        super(name, description: description)
+        @serialize = serialize || ->(value) { value }
+        @parse_value = parse_value || ->(value) { value }
+        @parse_literal = parse_literal || ->(value) { value }
+      end
+
+      def kind
+        'SCALAR'
+      end
+    end
+
+    # Object types
+    class ObjectType < BaseType
+      attr_reader :fields, :interfaces
+
+      def initialize(name, description: nil, interfaces: [])
+        super(name, description: description)
+        @fields = {}
+        @interfaces = interfaces
+      end
+
+      def field(name, type = nil, description: nil, deprecation_reason: nil, &block)
+        @fields[name.to_s] = Field.new(
+          name: name.to_s,
+          type: type,
+          description: description,
+          deprecation_reason: deprecation_reason,
+          resolve: block
+        )
+      end
+
+      def kind
+        'OBJECT'
+      end
+    end
+
+    # Interface types
+    class InterfaceType < BaseType
+      attr_reader :fields, :resolve_type
+
+      def initialize(name, description: nil, resolve_type: nil)
+        super(name, description: description)
+        @fields = {}
+        @resolve_type = resolve_type
+      end
+
+      def field(name, type, description: nil, deprecation_reason: nil)
+        @fields[name.to_s] = Field.new(
+          name: name.to_s,
+          type: type,
+          description: description,
+          deprecation_reason: deprecation_reason
+        )
+      end
+
+      def kind
+        'INTERFACE'
+      end
+    end
+
+    # Union types
+    class UnionType < BaseType
+      attr_reader :types, :resolve_type
+
+      def initialize(name, types: [], description: nil, resolve_type: nil)
+        super(name, description: description)
+        @types = types
+        @resolve_type = resolve_type
+      end
+
+      def kind
+        'UNION'
+      end
+    end
+
+    # Enum types
+    class EnumType < BaseType
+      attr_reader :values
+
+      def initialize(name, values: {}, description: nil)
+        super(name, description: description)
+        @values = values.transform_values do |value|
+          value.is_a?(Hash) ? EnumValue.new(**value) : EnumValue.new(value: value)
+        end
+      end
+
+      def kind
+        'ENUM'
+      end
+    end
+
+    EnumValue = Struct.new(:value, :description, :deprecation_reason, keyword_init: true)
+
+    # Input object types
+    class InputObjectType < BaseType
+      attr_reader :fields
+
+      def initialize(name, description: nil)
+        super(name, description: description)
+        @fields = {}
+      end
+
+      def field(name, type, description: nil, default_value: nil)
+        @fields[name.to_s] = InputField.new(
+          name: name.to_s,
+          type: type,
+          description: description,
+          default_value: default_value
+        )
+      end
+
+      def kind
+        'INPUT_OBJECT'
+      end
+    end
+
+    # List type wrapper
+    class ListType
+      attr_reader :of_type
+
+      def initialize(of_type)
+        @of_type = of_type
+      end
+
+      def to_s
+        "[#{@of_type}]"
+      end
+
+      def list?
+        true
+      end
+
+      def non_null?
+        false
+      end
+
+      def kind
+        'LIST'
+      end
+
+      # Resolve lazy type references
+      def resolve_types
+        @of_type = @of_type.resolve if @of_type.respond_to?(:resolve)
+        self
+      end
+    end
+
+    # Non-null type wrapper
+    class NonNullType
+      attr_reader :of_type
+
+      def initialize(of_type)
+        # Allow TypeReference as of_type, will be resolved later
+        raise TypeError, "Cannot wrap NonNullType in NonNullType" if of_type.is_a?(NonNullType)
+        @of_type = of_type
+      end
+
+      def to_s
+        "#{@of_type}!"
+      end
+
+      def non_null?
+        true
+      end
+
+      def list?
+        false
+      end
+
+      def kind
+        'NON_NULL'
+      end
+
+      # Resolve lazy type references
+      def resolve_types
+        @of_type = @of_type.resolve if @of_type.respond_to?(:resolve)
+        self
+      end
+    end
+
+    # Field definition
+    class Field
+      attr_reader :name, :type, :description, :deprecation_reason, :arguments, :resolve
+
+      def initialize(name:, type:, description: nil, deprecation_reason: nil, resolve: nil)
+        @name = name
+        @type = type
+        @description = description
+        @deprecation_reason = deprecation_reason
+        @arguments = {}
+        @resolve = resolve
+      end
+
+      def argument(name, type, description: nil, default_value: nil)
+        @arguments[name.to_s] = Argument.new(
+          name: name.to_s,
+          type: type,
+          description: description,
+          default_value: default_value
+        )
+      end
+
+      def deprecated?
+        !@deprecation_reason.nil?
+      end
+    end
+
+    # Argument definition
+    class Argument
+      attr_reader :name, :type, :description, :default_value
+
+      def initialize(name:, type:, description: nil, default_value: nil)
+        @name = name
+        @type = type
+        @description = description
+        @default_value = default_value
+      end
+    end
+
+    # Input field definition
+    class InputField
+      attr_reader :name, :type, :description, :default_value
+
+      def initialize(name:, type:, description: nil, default_value: nil)
+        @name = name
+        @type = type
+        @description = description
+        @default_value = default_value
+      end
+    end
+
+    # Built-in scalar types
+    INT = ScalarType.new(
+      'Int',
+      description: 'The `Int` scalar type represents non-fractional signed whole numeric values.',
+      serialize: ->(value) { value.to_i },
+      parse_value: ->(value) { value.to_i },
+      parse_literal: ->(value) { value.is_a?(Parser::IntValue) ? value.value.to_i : nil }
+    )
+
+    FLOAT = ScalarType.new(
+      'Float',
+      description: 'The `Float` scalar type represents signed double-precision fractional values.',
+      serialize: ->(value) { value.to_f },
+      parse_value: ->(value) { value.to_f },
+      parse_literal: ->(value) {
+        case value
+        when Parser::FloatValue
+          value.value.to_f
+        when Parser::IntValue
+          value.value.to_f
+        end
+      }
+    )
+
+    STRING = ScalarType.new(
+      'String',
+      description: 'The `String` scalar type represents textual data.',
+      serialize: ->(value) { value.to_s },
+      parse_value: ->(value) { value.to_s },
+      parse_literal: ->(value) { value.is_a?(Parser::StringValue) ? value.value : nil }
+    )
+
+    BOOLEAN = ScalarType.new(
+      'Boolean',
+      description: 'The `Boolean` scalar type represents `true` or `false`.',
+      serialize: ->(value) { !!value },
+      parse_value: ->(value) { !!value },
+      parse_literal: ->(value) { value.is_a?(Parser::BooleanValue) ? value.value : nil }
+    )
+
+    ID = ScalarType.new(
+      'ID',
+      description: 'The `ID` scalar type represents a unique identifier.',
+      serialize: ->(value) { value.to_s },
+      parse_value: ->(value) { value.to_s },
+      parse_literal: ->(value) {
+        case value
+        when Parser::StringValue, Parser::IntValue
+          value.value.to_s
+        end
+      }
+    )
+
+    # Helper methods to create type wrappers
+    def self.list(type)
+      ListType.new(type)
+    end
+
+    def self.non_null(type)
+      NonNullType.new(type)
+    end
+
+    # Convenience method for non-null types
+    class BaseType
+      def !
+        NonNullType.new(self)
+      end
+    end
+
+    class ListType
+      def !
+        NonNullType.new(self)
+      end
+    end
+  end
+end