graphql 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c86e3ad590a80d6430b2fd781fb097e433d5e5c4
-  data.tar.gz: 60d41b9666ffaa6d63a73238fd572fdbbba38218
+  metadata.gz: 290e890d0a805c3587000af2fbbacf910cf8baf0
+  data.tar.gz: 745511749686efb279e0ee7b7af2484d0ccd82ed
 SHA512:
-  metadata.gz: 27b1a4571a57b15e35dff3dcab058d8f8b9926c374361a6df52930296a1be705a49a5b345e23ad128d73eb81675a0b798e0b225c0c5fc92904cb76ebf3aaccfe
-  data.tar.gz: 5594ef107005a1d7abca4e9f6099a6c4f515176679d4421126e7a332a433271f367d447a981263a89accd573b8060ec22b1ee7f71809cb5a8c23e19d534eccee
+  metadata.gz: 81ba92e0aed50365b5ccd78ab02c035bc0a1ae212669f7d5c668cbe7fec3e48158f9a53a5859b2ece3ebc54d3634187635477a85cf50f2b8d24a822476517b53
+  data.tar.gz: 3a46fb67c848c7b85768979071d28df3b2e21e29087395b5a3ab2297d0660bd51ba84c628678e098a1faae392ef9a4e30d8be0007575ef32468f98c2c043badf

data/lib/graphql.rb

@@ -1,26 +1,95 @@
-require "parslet"
-require "active_support/core_ext/string/inflections"
 require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/inflections"
+require "json"
+require "parslet"
+require "singleton"
 
 module GraphQL
-  VERSION = "0.0.1"
-
-  autoload(:CollectionEdge,   "graphql/collection_edge")
+  autoload(:Call,             "graphql/call")
+  autoload(:Connection,       "graphql/connection")
+  autoload(:Field,            "graphql/field")
+  autoload(:FieldDefiner,     "graphql/field_definer")
+  autoload(:Node,             "graphql/node")
   autoload(:Parser,           "graphql/parser")
   autoload(:Query,            "graphql/query")
-  autoload(:Node,             "graphql/node")
+  autoload(:RootCall,         "graphql/root_call")
+  autoload(:RootCallArgument,         "graphql/root_call_argument")
+  autoload(:RootCallArgumentDefiner,         "graphql/root_call_argument_definer")
+  autoload(:Schema,           "graphql/schema")
   autoload(:Transform,        "graphql/transform")
+  autoload(:VERSION,          "graphql/version")
+
+  module Introspection
+    autoload(:CallNode,             "graphql/introspection/call_node")
+    autoload(:Connection,           "graphql/introspection/connection")
+    autoload(:FieldNode,            "graphql/introspection/field_node")
+    autoload(:RootCallArgumentNode, "graphql/introspection/root_call_argument_node")
+    autoload(:RootCallNode,         "graphql/introspection/root_call_node")
+    autoload(:SchemaCall,           "graphql/introspection/schema_call")
+    autoload(:SchemaNode,           "graphql/introspection/schema_node")
+    autoload(:TypeCall,             "graphql/introspection/type_call")
+    autoload(:TypeNode,             "graphql/introspection/type_node")
+  end
+
 
   module Syntax
     autoload(:Call,       "graphql/syntax/call")
-    autoload(:Edge,       "graphql/syntax/edge")
     autoload(:Field,      "graphql/syntax/field")
+    autoload(:Query,      "graphql/syntax/query")
     autoload(:Node,       "graphql/syntax/node")
+    autoload(:Variable,   "graphql/syntax/variable")
+  end
+
+  module Types
+    autoload(:BooleanField,     "graphql/types/boolean_field")
+    autoload(:ConnectionField,  "graphql/types/connection_field")
+    autoload(:CursorField,      "graphql/types/cursor_field")
+    autoload(:NumberField,      "graphql/types/number_field")
+    autoload(:ObjectField,      "graphql/types/object_field")
+    autoload(:StringField,      "graphql/types/string_field")
+    autoload(:TypeField,        "graphql/types/type_field")
+  end
+
+  class Error < RuntimeError; end
+  class FieldNotDefinedError < Error
+    def initialize(class_name, field_name)
+      super("#{class_name}##{field_name} was requested, but it isn't defined. Defined fields are: #{SCHEMA.field_names}")
+    end
+  end
+  class NodeNotDefinedError < Error
+    def initialize(node_name)
+      super("#{node_name} was requested but was not found. Defined nodes are: #{SCHEMA.type_names}")
+    end
+  end
+  class  ConnectionNotDefinedError < Error
+    def initialize(node_name)
+      super("#{node_name} was requested but was not found. Defined connections are: #{SCHEMA.connection_names}")
+    end
+  end
+  class RootCallNotDefinedError < Error
+    def initialize(name)
+      super("Call '#{name}' was requested but was not found. Defined calls are: #{SCHEMA.call_names}")
+    end
+  end
+  class SyntaxError < Error
+    def initialize(line, col, string)
+      lines = string.split("\n")
+      super("Syntax Error at (#{line}, #{col}), check usage: #{string}")
+    end
+  end
+
+  class RootCallArgumentError < Error
+    def initialize(declaration, actual)
+      super("Wrong type for #{declaration.name}: expected a #{declaration.type} but got #{actual}")
+    end
   end
 
   PARSER = Parser.new
+  SCHEMA = Schema.instance
   TRANSFORM = Transform.new
-
-  class FieldNotDefinedError < RuntimeError
+  # preload these so they're in SCHEMA
+  ["types", "introspection"].each do |preload_dir|
+    Dir["#{File.dirname(__FILE__)}/graphql/#{preload_dir}/*.rb"].each { |f| require f }
   end
+  Node.field.__type__(:__type__)
 end

data/lib/graphql/call.rb

@@ -0,0 +1,7 @@
+class GraphQL::Call
+  attr_reader :name, :lambda
+  def initialize(name:, lambda:)
+    @name = name
+    @lambda = lambda
+  end
+end

data/lib/graphql/connection.rb

@@ -0,0 +1,44 @@
+class GraphQL::Connection < GraphQL::Node
+  exposes "Array"
+  field.any(:edges)
+
+  attr_reader :calls, :syntax_fields, :query
+
+  def initialize(items, query:, fields: [])
+    @target = items
+    @syntax_fields = fields
+    @query = query
+  end
+
+  def items
+    @target
+  end
+
+  def edge_fields
+    @edge_fields ||= syntax_fields.find { |f| f.identifier == "edges" }.fields
+  end
+
+  def edges
+    raise "#{self.class} expected a connection, but got `nil`" if items.nil?
+    items.map do |item|
+      node_class = GraphQL::SCHEMA.type_for_object(item)
+      node = node_class.new(item, fields: edge_fields, query: query)
+      res = node.as_result
+      res
+    end
+  end
+
+  class << self
+    def default_schema_name
+      name.split("::").last.sub(/Connection$/, '').underscore
+    end
+
+    attr_accessor :default_connection
+    def default_connection!
+      GraphQL::Connection.default_connection = self
+    end
+
+  end
+
+  self.default_connection!
+end

data/lib/graphql/field.rb

@@ -0,0 +1,117 @@
+class GraphQL::Field
+  attr_reader :query, :owner, :calls, :fields
+  def initialize(query: nil, owner: nil, calls: [], fields: [])
+    @query = query
+    @owner = owner
+    @calls = calls
+    @fields = fields
+  end
+
+  def raw_value
+    owner.send(method)
+  end
+
+  def as_result
+    finished_value
+  end
+
+  def finished_value
+    @finished_value ||= begin
+      val = raw_value
+      calls.each do |call|
+        registered_call = self.class.calls[call.identifier]
+        if registered_call.nil?
+          raise "Call not found: #{self.class.name}##{call.identifier}"
+        end
+        val = registered_call.lambda.call(val, *call.arguments)
+      end
+      val
+    end
+  end
+
+  # instance `const_get` reaches up to class namespace
+  def const_get(const_name)
+    self.class.const_get(const_name)
+  rescue
+    nil
+  end
+
+  # delegate to class constant
+  ["name", "description"].each do |method_name|
+    define_method(method_name) do
+      const_get(method_name.upcase)
+    end
+  end
+
+  def method; name; end
+
+  class << self
+    def inherited(child_class)
+      GraphQL::SCHEMA.add_field(child_class)
+    end
+
+    def create_class(name:, owner_class:, type:, description: nil, connection_class_name: nil, node_class_name: nil)
+      if type.is_a?(Symbol)
+        type = GraphQL::SCHEMA.get_field(type)
+      end
+
+      field_superclass = type || self
+      new_class = Class.new(field_superclass)
+      new_class.const_set :NAME, name
+      new_class.const_set :OWNER_CLASS, owner_class
+      new_class.const_set :DESCRIPTION , description
+      new_class.const_set :CONNECTION_CLASS_NAME, connection_class_name
+      new_class.const_set :NODE_CLASS_NAME, node_class_name
+      new_class
+    end
+
+    def to_s
+      if const_defined?(:NAME)
+        "<FieldClass: #{const_get(:OWNER_CLASS).name}::#{const_get(:NAME)}>"
+      else
+        super
+      end
+    end
+
+    def type(value_type_name)
+      @value_type = value_type_name.to_s
+      GraphQL::SCHEMA.add_field(self)
+    end
+
+    def value_type
+      @value_type || superclass.value_type
+    end
+
+    def schema_name
+      @value_type || (name.present? ? default_schema_name : nil)
+    end
+
+    def default_schema_name
+      name.split("::").last.sub(/Field$/, '').underscore
+    end
+
+    def field_name
+      const_get(:NAME)
+    end
+
+    def description
+      const_get(:DESCRIPTION)
+    end
+
+    def calls
+      superclass.calls.merge(_calls)
+    rescue NoMethodError
+      {}
+    end
+
+    def _calls
+      @calls ||= {}
+    end
+
+    def call(name, lambda)
+      _calls[name.to_s] = GraphQL::Call.new(name: name.to_s, lambda: lambda)
+    end
+  end
+
+  type :any
+end

data/lib/graphql/field_definer.rb

@@ -0,0 +1,29 @@
+class GraphQL::FieldDefiner
+  attr_reader :owner_class
+  def initialize(owner_class)
+    @owner_class = owner_class
+  end
+
+  def method_missing(method_name, *args, &block)
+    type = GraphQL::SCHEMA.get_field(method_name)
+    if type.present?
+      create_field(args[0], type: type, description: args[1])
+    else
+      super
+    end
+  end
+
+  def create_field(field_name, type: nil, description: nil)
+    field_name = field_name.to_s
+    field_class = GraphQL::Field.create_class({
+      name: field_name,
+      type: type,
+      owner_class: owner_class,
+      description: description,
+    })
+
+    field_class_name = field_name.camelize + "Field"
+    owner_class.const_set(field_class_name, field_class)
+    owner_class.own_fields[field_name] = field_class
+  end
+end

data/lib/graphql/introspection/call_node.rb

@@ -0,0 +1,13 @@
+class GraphQL::Introspection::CallNode < GraphQL::Node
+  exposes "GraphQL::Call"
+  field.string(:name)
+  field.string(:arguments)
+
+  def arguments
+    args = target.lambda.parameters
+    args.shift
+    args.map { |p| "#{p[1]} (#{p[0]})" }.join(", ")
+  rescue StandardError => e
+    raise "Errored on #{name} (#{self}): #{e}"
+  end
+end

data/lib/graphql/introspection/connection.rb

@@ -0,0 +1,9 @@
+class GraphQL::Introspection::Connection < GraphQL::Connection
+  type :introspection_connection
+
+  field.number(:count)
+
+  def count
+    size
+  end
+end

data/lib/graphql/introspection/field_node.rb

@@ -0,0 +1,19 @@
+class GraphQL::Introspection::FieldNode < GraphQL::Node
+  exposes "GraphQL::Field"
+  field.string(:name)
+  field.string(:type)
+  field.string(:description)
+  field.connection(:calls)
+
+  def calls
+    target.calls.values
+  end
+
+  def name
+    schema_name
+  end
+
+  def type
+    value_type
+  end
+end

data/lib/graphql/introspection/root_call_argument_node.rb

@@ -0,0 +1,5 @@
+class GraphQL::Introspection::RootCallArgumentNode < GraphQL::Node
+  exposes "GraphQL::RootCallArgument"
+  field.string(:name)
+  field.string(:type)
+end

data/lib/graphql/introspection/root_call_node.rb

@@ -0,0 +1,16 @@
+class GraphQL::Introspection::RootCallNode < GraphQL::Node
+  exposes "GraphQL::RootCall"
+  field.string(:name)
+  field.string(:returns)
+  field.connection(:arguments)
+
+
+  def returns
+    return_declarations = @target.return_declarations
+    return_declarations.keys.map(&:to_s)
+  end
+
+  def name
+    schema_name
+  end
+end

data/lib/graphql/introspection/schema_call.rb

@@ -0,0 +1,8 @@
+class GraphQL::Introspection::SchemaCall < GraphQL::RootCall
+  returns :schema
+  argument.none
+
+  def execute!
+    GraphQL::SCHEMA
+  end
+end

data/lib/graphql/introspection/schema_node.rb

@@ -0,0 +1,17 @@
+class GraphQL::Introspection::SchemaNode < GraphQL::Node
+  exposes "GraphQL::Schema"
+  field.connection(:calls)
+  field.connection(:types)
+
+  def cursor
+    "schema"
+  end
+
+  def types
+    @target.types.values
+  end
+
+  def calls
+    target.calls.values
+  end
+end

data/lib/graphql/introspection/type_call.rb

@@ -0,0 +1,8 @@
+class GraphQL::Introspection::TypeCall < GraphQL::RootCall
+  returns :type
+  argument.string("type_name")
+
+  def execute!(type_name)
+    GraphQL::SCHEMA.get_type(type_name)
+  end
+end

data/lib/graphql/introspection/type_node.rb

@@ -0,0 +1,16 @@
+class GraphQL::Introspection::TypeNode < GraphQL::Node
+  exposes "GraphQL::Node"
+  field.string(:name)
+  field.string(:description)
+  field.connection(:fields)
+
+  cursor :name
+
+  def fields
+    target.all_fields.values
+  end
+
+  def name
+    schema_name
+  end
+end