Began work on Executor flow

Author: Håkan Rosenhorn

src/main/scala/se/uprise/graphql/GraphQL.scala

@@ -4,26 +4,40 @@ import java.io.ByteArrayInputStream
 
 import org.antlr.v4.runtime.{CommonTokenStream, ANTLRInputStream}
 import se.uprise.graphql.error.GraphQLFormattedError
-import se.uprise.parser.GraphQlParser.FieldContext
+import se.uprise.graphql.execution.Executor
+import se.uprise.parser.GraphQlParser.{DocumentContext, FieldContext}
 import se.uprise.parser.{GraphQlBaseVisitor, GraphQlParser, GraphQlLexer}
 
 
 import se.uprise.graphql.types.GraphQLSchema
 
 
-case class GraphQLResult(data: String, errors: List[GraphQLFormattedError])
+/**
+ * The result of a GraphQL parse, validation and execution.
+ *
+ * `data` is the result of a successful execution of the query.
+ * `errors` is included when any errors occurred as a non-empty array.
+ */
+// FIXME: Should not be type Any
+case class GraphQLResult(data: Any, errors: List[GraphQLFormattedError])
 
 
-class GraphQlVisitor extends GraphQlBaseVisitor[Unit] {
- override def visitField(ctx: FieldContext): Unit = {
- println("HEJ HEJ", ctx.fieldName().NAME())
- }
-}
+/**
+ * This is the primary entry point function for fulfilling GraphQL operations
+ * by parsing, validating, and executing a GraphQL document along side a
+ * GraphQL schema.
+ *
+ * More sophisticated GraphQL servers, such as those which persist queries,
+ * may wish to separate the validation and execution phases to a static time
+ * tooling step, and a server runtime step.
+ */
+
 
+// The rootObject seems to be some object/context you can pass along that will be available in all your resolve methods
 object GraphQL {
  def apply(schema: GraphQLSchema,
- requestString: String,
- rootObject: Option[String],
+  requestString: String,
+  rootObject: Any,
  variableValues: Map[String, String],
  operationName: String
  ): GraphQLResult = {
@@ -32,10 +46,15 @@ object GraphQL {
  val lexer = new GraphQlLexer(input)
  val tokens = new CommonTokenStream(lexer)
  val parser = new GraphQlParser(tokens)
- 
- val visitor = new GraphQlVisitor()
- visitor.visit(parser.document())
- 
+
+ val document: DocumentContext = parser.document()
+
+ Executor(schema,
+ rootObject,
+ document,
+ operationName,
+ variableValues)
+
 
  new GraphQLResult("svejs", List.empty)
  }

src/main/scala/se/uprise/graphql/error/GraphQLError.scala

@@ -0,0 +1,4 @@
+package se.uprise.graphql.error
+
+// FIXME: Extend with proper values from js ref
+case class GraphQLError(message: String) extends Exception(message)

src/main/scala/se/uprise/graphql/execution/ExecutionContext.scala

@@ -0,0 +1,23 @@
+package se.uprise.graphql.execution
+
+import se.uprise.graphql.types.GraphQLSchema
+import se.uprise.parser.GraphQlParser.{OperationDefinitionContext, FragmentDefinitionContext}
+
+
+/**
+ * Data that must be available at all points during query execution.
+ *
+ * Namely, schema of the type system that is currently executing,
+ * and the fragments defined in the query document
+ */
+// FIXME: root should not have type Any
+// FIXME: Variables should not be map of Any (?)
+case class ExecutionContext(
+ schema: GraphQLSchema,
+ fragments: Map[String, FragmentDefinitionContext],
+ root: Any,
+ operation: OperationDefinitionContext,
+ variables: Map[String, Any],
+ errors: List[Exception]) {
+
+}

src/main/scala/se/uprise/graphql/execution/Executor.scala

@@ -0,0 +1,148 @@
+package se.uprise.graphql.execution
+
+import se.uprise.graphql.error.{GraphQLError, GraphQLFormattedError}
+import se.uprise.graphql.types.GraphQLSchema
+import se.uprise.parser.GraphQlParser
+import se.uprise.parser.GraphQlParser._
+import scala.collection.JavaConversions._
+
+/**
+ * Terminology
+ *
+ * "Definitions" are the generic name for top-level statements in the document.
+ * Examples of this include:
+ * 1) Operations (such as a query)
+ * 2) Fragments
+ *
+ * "Operations" are a generic name for requests in the document.
+ * Examples of this include:
+ * 1) query,
+ * 2) mutation
+ *
+ * "Selections" are the statements that can appear legally and at
+ * single level of the query. These include:
+ * 1) field references e.g "a"
+ * 2) fragment "spreads" e.g. "...c"
+ * 3) inline fragment "spreads" e.g. "...on Type { a }"
+ */
+
+
+/**
+ * The result of execution. `data` is the result of executing the
+ * query, `errors` is null if no errors occurred, and is a
+ * non-empty array if an error occurred.
+ */
+// FIXME: root should not be type Any
+case class ExecutionResult(data: Any, errors: List[GraphQLFormattedError])
+
+
+object Executor {
+ def apply(schema: GraphQLSchema,
+ root: Any,
+ ast: DocumentContext,
+ operationName: String,
+ variableValues: Map[String, String] = Map.empty): ExecutionResult = {
+
+ // FIXME: We cannot pass a immutable List of errors in the execution context
+ val exeContext = buildExecutionContext(schema, root, ast, operationName, variableValues, List.empty)
+
+ // FIXME: Result is currently Any
+ val result = executeOperation(exeContext, root, exeContext.operation)
+
+ new ExecutionResult("FIXME", List.empty)
+ }
+
+ /**
+ * Implements the "Evaluating operations" section of the spec.
+ */
+ def executeOperation(exeContext: ExecutionContext,
+ root: Any,
+ operation: OperationDefinitionContext): Any = {
+
+ }
+
+
+ // FIXME: root should perhaps not be type Any
+ def buildExecutionContext(schema: GraphQLSchema,
+ root: Any,
+ ast: DocumentContext,
+ operationName: String,
+ variableValues: Map[String, String] = Map.empty,
+ errors: List[Exception]): ExecutionContext = {
+
+ // Convert from Java to Scala
+ val definitionSet: List[DefinitionContext] = ast.definition().toList
+
+ // FIXME: Might be improved...
+ val fragments: Map[String, FragmentDefinitionContext] = definitionSet flatMap { entry =>
+ entry.getRuleIndex match {
+ case GraphQlParser.RULE_fragmentDefinition =>
+ val fragment = entry.asInstanceOf[FragmentDefinitionContext]
+ Some(fragment.fragmentName().NAME().getText -> fragment)
+ case _ => None
+ }
+ } toMap
+
+ // FIXME: Might be improved...
+ val operations: Map[String, OperationDefinitionContext] = definitionSet flatMap { entry =>
+ entry.getRuleIndex match {
+ case GraphQlParser.RULE_operationDefinition =>
+ val operation = entry.asInstanceOf[OperationDefinitionContext]
+ Some(operation.NAME().getText -> operation)
+ case _ => None
+ }
+ } toMap
+
+ if (operationName.length > 0 && operations.size != 1) {
+ throw new GraphQLError("Must provide operation name if query contains multiple operations")
+ }
+
+ val opName = operationName match {
+ case name if name.length > 0 => name
+ case _ => operations.head._1
+ }
+
+ val operation = operations.get(opName) match {
+ case Some(entry) => entry
+ case None => throw new GraphQLError("Unknown operation name: " + opName)
+ }
+
+ val variables = getVariableValues(schema,
+ operation.variableDefinitions().variableDefinition().toList,
+ variableValues
+ )
+
+ ExecutionContext(schema, fragments, root, operation, variables, errors)
+ }
+
+
+ /**
+ * Prepares an object map of variables of the correct type based on the provided
+ * variable definitions and arbitrary input. If the input cannot be coerced
+ * to match the variable definitions, a GraphQLError will be thrown.
+ */
+ /*
+ FIXME: Replace Any types with proper Types resolved from the variableValues
+ Ex: query Example($size: Int) {
+ variableValues = { size: 100 }
+ */
+
+ def getVariableValues(schema: GraphQLSchema,
+ definitionASTs: List[VariableDefinitionContext] = List.empty,
+ variableValues: Map[String, String] = Map.empty): Map[String, Any] = {
+
+
+ // FIXME: Implement
+// definitionASTs map { definition =>
+// val varName = definition.variable().NAME().getText
+// }
+
+ Map.empty
+ }
+
+ def getVariableValue(schema: GraphQLSchema,
+ definitionAST: VariableDefinitionContext,
+ input: String) = {
+
+ }
+}

src/main/scala/se/uprise/graphql/types/GraphQLInputType.scala

@@ -1,6 +1,3 @@
 package se.uprise.graphql.types
 
-/**
- * Created by Håkan Rosenhorn on 2015-07-09.
- */
 trait GraphQLInputType