yogurt 0.1.1

data/lib/yogurt/code_generator/variable_definition.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  class CodeGenerator
+    class VariableDefinition < T::Struct
+      extend T::Sig
+      include Comparable
+
+      const :name, Symbol
+      const :graphql_name, String
+      const :signature, String
+      const :serializer, String
+      const :dependency, T.nilable(String)
+
+      sig {returns(T::Boolean)}
+      def optional?
+        signature.start_with?("T.nilable")
+      end
+
+      sig {params(other: VariableDefinition).returns(T.nilable(Integer))}
+      def <=>(other)
+        if optional? && !other.optional?
+          1
+        elsif other.optional? && !optional?
+          -1
+        else
+          name <=> other.name
+        end
+      end
+    end
+  end
+end

data/lib/yogurt/converters.rb

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  module Converters
+    class Date
+      extend T::Sig
+      extend ScalarConverter
+
+      sig {override.returns(T::Types::Base)}
+      def self.type_alias
+        T.type_alias {::Date}
+      end
+
+      sig {override.params(value: ::Date).returns(String)}
+      def self.serialize(value)
+        value.iso8601
+      end
+
+      sig {override.params(raw_value: SCALAR_TYPE).returns(::Date)}
+      def self.deserialize(raw_value)
+        raise "Unexpected value returned for Date: #{raw_value.inspect}" if !raw_value.is_a?(String)
+
+        ::Date.iso8601(raw_value)
+      end
+    end
+
+    class Time
+      extend T::Sig
+      extend ScalarConverter
+
+      sig {override.returns(T::Types::Base)}
+      def self.type_alias
+        T.type_alias {::Time}
+      end
+
+      sig {override.params(value: ::Time).returns(String)}
+      def self.serialize(value)
+        value.iso8601
+      end
+
+      sig {override.params(raw_value: SCALAR_TYPE).returns(::Time)}
+      def self.deserialize(raw_value)
+        raise "Unexpected value returned for Time: #{raw_value.inspect}" if !raw_value.is_a?(String)
+
+        ::Time.iso8601(raw_value)
+      end
+    end
+  end
+end

data/lib/yogurt/error_result.rb

@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  module ErrorResult
+    include Kernel
+    extend T::Sig
+    extend T::Helpers
+
+    interface!
+
+    sig {abstract.returns(T.nilable(T::Array[OBJECT_TYPE]))}
+    def errors; end
+
+    class OnlyErrors
+      extend T::Sig
+      include ErrorResult
+
+      sig {params(errors: T::Array[OBJECT_TYPE]).void}
+      def initialize(errors)
+        @errors = T.let(errors, T::Array[OBJECT_TYPE])
+      end
+
+      sig {override.returns(T.nilable(T::Array[OBJECT_TYPE]))}
+      def errors
+        @errors
+      end
+    end
+  end
+end

data/lib/yogurt/http.rb

@@ -0,0 +1,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'json'
+
+module Yogurt
+  class Http
+    extend T::Sig
+    include QueryExecutor
+
+    sig {params(uri: String, headers: T::Hash[String, String]).void}
+    def initialize(uri, headers: {})
+      parsed = URI.parse(uri)
+      if parsed.is_a?(URI::HTTP) || parsed.is_a?(URI::HTTPS)
+        @uri = T.let(parsed, T.any(URI::HTTP, URI::HTTPS))
+      else
+        raise ArgumentError, "Invalid URI: #{uri} (must be HTTP or HTTPS)"
+      end
+
+      @headers = T.let(headers, T::Hash[String, String])
+    end
+
+    # You can override this method in a subclass to set options on the HTTP request
+    sig {overridable.params(options: T.untyped).returns(T::Hash[String, String])}
+    def headers(options)
+      @headers
+    end
+
+    # You can override this in a subclass to get strongly typed options on auto-generated code
+    sig {override.returns(T::Types::Base)}
+    def options_type_alias
+      T.type_alias {T.untyped}
+    end
+
+    sig do
+      override.params(
+        query: String,
+        operation_name: String,
+        variables: T.nilable(T::Hash[String, T.untyped]),
+        options: T.untyped,
+      ).returns(T::Hash[String, T.untyped])
+    end
+    def execute(query, operation_name:, variables: nil, options: nil)
+      request = Net::HTTP::Post.new(@uri.request_uri)
+      request.basic_auth(@uri.user, @uri.password) if @uri.user || @uri.password
+
+      request["Accept"] = "application/json"
+      request["Content-Type"] = "application/json"
+
+      headers(options).each do |name, value|
+        request[name] = value
+      end
+
+      body = T.let({}, T::Hash[String, T.untyped])
+      body["query"] = query
+      body["variables"] = variables if variables&.any?
+      body["operationName"] = operation_name
+      request.body = JSON.generate(body)
+
+      response = connection.request(request)
+      case response
+      when Net::HTTPOK, Net::HTTPBadRequest
+        JSON.parse(response.body)
+      else
+        { "errors" => [{ "message" => "#{response.code} #{response.message}" }] }
+      end
+    end
+
+    # Returns an HTTP connection. You can override in subclasses to customize the conection.
+    sig {overridable.returns(Net::HTTP)}
+    def connection
+      client = Net::HTTP.new(@uri.host, @uri.port)
+      client.use_ssl = @uri.scheme == "https"
+
+      client
+    end
+  end
+end

data/lib/yogurt/inspectable.rb

@@ -0,0 +1,22 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'pp'
+
+module Yogurt
+  module Inspectable
+    extend T::Sig
+    extend T::Helpers
+    include PP::ObjectMixin
+
+    abstract!
+
+    sig {abstract.params(p: PP::PPMethods).void}
+    def pretty_print(p); end
+
+    sig {returns(String)}
+    def inspect
+      pretty_print_inspect
+    end
+  end
+end

data/lib/yogurt/memoize.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  module Memoize
+    extend T::Sig
+
+    sig do
+      type_parameters(:ReturnType)
+        .params(
+          name: Symbol,
+          block: T.proc.returns(T.type_parameter(:ReturnType)),
+        )
+        .returns(T.type_parameter(:ReturnType))
+    end
+    def memoize_as(name, &block)
+      memoized_values = @memoized_values
+      memoized_values = @memoized_values = {} if memoized_values.nil?
+
+      return memoized_values[name] if memoized_values.key?(name)
+
+      memoized_values[name] = yield
+    end
+
+    sig {returns(T.self_type)}
+    def freeze
+      @memoized_values = T.let(@memoized_values, T.nilable(T::Hash[Symbol, T.untyped]))
+      @memoized_values&.freeze
+      super
+      self
+    end
+  end
+end

data/lib/yogurt/query.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  class Query
+    extend T::Sig
+    extend T::Helpers
+    abstract!
+
+    sig {params(result: OBJECT_TYPE).returns(T.any(T.attached_class, Yogurt::ErrorResult::OnlyErrors))}
+    def self.from_result(result)
+      data = result['data']
+      if data
+        new(data, result['errors'])
+      else
+        Yogurt::ErrorResult::OnlyErrors.new(result['errors'])
+      end
+    end
+
+    sig {params(data: OBJECT_TYPE, errors: T.nilable(OBJECT_TYPE)).void}
+    def initialize(data, errors); end
+  end
+end

data/lib/yogurt/query_container.rb

@@ -0,0 +1,89 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  module QueryContainer
+    extend T::Sig
+
+    CONTAINER = T.type_alias do
+      T.all(Module, QueryContainer)
+    end
+
+    VALIDATION_RULES = T.let(
+      [
+        *GraphQL::StaticValidation::ALL_RULES,
+        InterfacesAndUnionsHaveTypename
+      ].freeze,
+      T::Array[T.untyped],
+    )
+
+    sig {params(other: Module).void}
+    def self.included(other)
+      Kernel.raise(ValidationError, "You need to `extend Yogurt::QueryContainer`, you cannot use `include`.")
+    end
+
+    sig {params(other: Module).void}
+    def self.extended(other)
+      super
+      QueryContainer.containers << T.cast(other, CONTAINER)
+    end
+
+    sig {returns(T::Array[CONTAINER])}
+    def self.containers
+      @containers = T.let(@containers, T.nilable(T::Array[CONTAINER]))
+      @containers ||= []
+    end
+
+    sig {returns(T::Array[QueryDeclaration])}
+    def declared_queries
+      @declared_queries = T.let(@declared_queries, T.nilable(T::Array[QueryDeclaration]))
+      @declared_queries ||= []
+    end
+
+    sig {params(operation_name: String).returns(QueryDeclaration)}
+    def fetch_query(operation_name)
+      result = declared_queries.detect {|d| d.operations.include?(operation_name)}
+      T.must(result)
+    end
+
+    sig do
+      params(
+        query_text: String,
+        schema: T.nilable(T.class_of(GraphQL::Schema)),
+      ).void
+    end
+    def declare_query(query_text, schema: nil)
+      schema ||= Yogurt.default_schema
+      Kernel.raise(ValidationError, "You need to either provide a `schema:` to declare_query, or set Yogurt.default_schema") if schema.nil?
+
+      case (container = self)
+      when Module
+        # noop
+      else
+        Kernel.raise(ValidationError, "You need to `extend Yogurt::QueryContainer`, you cannot use `include`.")
+      end
+
+      Kernel.raise(ValidationError, "Query containers must be classes or modules that are assigned to constants.") if container.name.nil?
+
+      validator = GraphQL::StaticValidation::Validator.new(schema: schema, rules: VALIDATION_RULES)
+      query = GraphQL::Query.new(schema, query_text)
+      validation_result = validator.validate(query)
+
+      error = validation_result[:errors][0]
+      Kernel.raise(ValidationError, error.message) if error
+
+      if query.operations.key?(nil)
+        Kernel.raise(ValidationError, "You must provide a name for each of the operations in your GraphQL query.")
+      elsif query.operations.none?
+        Kernel.raise(ValidationError, "Your query did not define any operations.")
+      end
+
+      declared_queries << QueryDeclaration.new(
+        container: container,
+        operations: query.operations.keys.freeze,
+        query_text: query_text,
+        schema: schema,
+      )
+    end
+  end
+end

data/lib/yogurt/query_container/interfaces_and_unions_have_typename.rb

@@ -0,0 +1,107 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Yogurt
+  module QueryContainer
+    module InterfacesAndUnionsHaveTypename
+      include Kernel
+      extend T::Sig
+
+      class Error < GraphQL::StaticValidation::Error
+        extend T::Sig
+
+        sig {returns(T.nilable(String))}
+        attr_reader :type_name
+
+        sig {returns(String)}
+        attr_reader :node_name
+
+        sig do
+          params(
+            message: String,
+            node_name: String,
+            path: T.nilable(String),
+            nodes: T.untyped,
+            type: T.nilable(String),
+          ).void
+        end
+        def initialize(message, node_name:, path: nil, nodes: [], type: nil)
+          super(message, path: path, nodes: nodes)
+          @node_name = T.let(node_name, String)
+          @type_name = T.let(type, T.nilable(String))
+        end
+
+        # A hash representation of this Message
+        sig {returns(T::Hash[String, T.untyped])}
+        def to_h
+          extensions = {
+            "code" => code,
+            "nodeName" => @node_name
+          }
+
+          extensions['typeName'] = @type_name if @type_name
+          super.merge({ "extensions" => extensions })
+        end
+
+        sig {returns(String)}
+        def code
+          "interfaceOrUnionMissingTypename"
+        end
+      end
+
+      sig {params(node: GraphQL::Language::Nodes::Field, parent: T.untyped).void}
+      def on_field(node, parent)
+        super if validate_interface_union_includes_typename(node, T.unsafe(self).field_definition.type.unwrap)
+      end
+
+      sig {params(node: GraphQL::Language::Nodes::OperationDefinition, parent: T.untyped).void}
+      def on_operation_definition(node, parent)
+        super if validate_interface_union_includes_typename(node, T.unsafe(self).type_definition)
+      end
+
+      sig do
+        params(
+          node: T.any(GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::OperationDefinition),
+          type_definition: T.untyped,
+        ).returns(T::Boolean)
+      end
+      private def validate_interface_union_includes_typename(node, type_definition)
+        return true if node.selections.nil?
+        return true if node.selections.empty?
+
+        type_kind = type_definition.kind
+        return true unless type_kind.interface? || type_kind.union?
+        return true if node.selections.any? do |selection|
+          next false unless selection.is_a?(GraphQL::Language::Nodes::Field)
+          next false unless selection.name == '__typename'
+
+          selection.alias.nil?
+        end
+
+        msg = "Interfaces and unions must include the __typename field (%{node_name} returns #{type_definition.graphql_name} but doesn't select __typename)"
+        node_name = case node
+        when GraphQL::Language::Nodes::Field
+          "field '#{node.name}'"
+        when GraphQL::Language::Nodes::OperationDefinition
+          if node.name.nil?
+            "anonymous query"
+          else
+            "#{node.operation_type} '#{node.name}'"
+          end
+        else
+          T.absurd(node)
+        end
+
+        error = Error.new(
+          format(msg, node_name: node_name),
+          nodes: node,
+          node_name: node_name,
+          type: type_definition.graphql_name,
+        )
+
+        send(:add_error, error)
+        false
+      end
+    end
+  end
+end