OlegIlyenko

import sangria.schema._
import sangria.ast
import sangria.macros._
import sangria.execution._

case class MyContext(originalQuery: ast.Document) {
  def loadEntity(id: String, typeHints: Set[String]): Option[Identifiable] = {
    println(typeHints)
    None // your entity loagic goes here
  }

OlegIlyenko

import sangria.marshalling.queryAst._
import sangria.macros._
import sangria.ast

val query =
  graphql"""
    query MyQuery($$humanId: String!, $$episode: Episode!) {
      hero(episode: $$episode) {
        id, name, appearsIn
      }

OlegIlyenko

import sangria.renderer.QueryRenderer
import sangria.macros._
import sangria.ast

val parsed: ast.Value =
  graphqlInput"""
    {
      id: "1234345"
      version: 2 # changed 2 times

OlegIlyenko

In this gist I would like to describe an idea for GraphQL subscriptions. It was inspired by conversations about subscriptions in the GraphQL slack channel and different GH issues, like #89 and #411.

Conceptual Model

At the moment GraphQL allows 2 types of queries:

• query
• mutation

Reference implementation also adds the third type: subscription. It does not have any semantics yet, so here I would like to propose one possible semantics interpretation and the reasoning behind it.

OlegIlyenko

// In your project

// General stuff like name, description, version

// Publishing

publishMavenStyle := true
publishArtifact in Test := false
pomIncludeRepository := (_ => false)
publishTo := Some(

OlegIlyenko

case object DateCoercionViolation extends ValueCoercionViolation("Date value expected")

def parseDate(s: String) = Try(new DateTime(s, DateTimeZone.UTC)) match {
  case Success(date) => Right(date)
  case Failure(_) => Left(DateCoercionViolation)
}

val DateTimeType = ScalarType[DateTime]("DateTime",
  coerceOutput = date => ast.StringValue(ISODateTimeFormat.dateTime().print(date)),
  coerceUserInput = {

OlegIlyenko

import akka.actor.ActorSystem
import akka.stream.ActorFlowMaterializer

import akka.http.scaladsl.model.headers._
import akka.http.scaladsl.Http
import akka.http.scaladsl.server._
import akka.http.scaladsl.model.StatusCodes._
import akka.http.scaladsl.server.Directives._

object OptionsMethod extends App  {

OlegIlyenko

import scala.annotation.switch
import org.parboiled2._
import scala.io.Source
import scala.util.{Failure, Success}

class PredicateParser(val input: ParserInput) extends Parser with CommonRules {
  def And = Keyword("and")
  def Or = Keyword("or")
  def Not = Keyword("not")

OlegIlyenko

// First you need to create module with actor system and actor bindings in it:
// IMPORTANT: `Actor` bindings should always be providers (bound with `toProvider` method, 
// IMPORTANT: which will create new instances each time it gets injected)
implicit val module = new Module {
  bind [ActorSystem] to ActorSystem("MySystem")
 
  bind [GreetPrinter] toProvider new GreetPrinter
  binding toProvider new GenericPrinter
 
  bind [PrintStream] to Console.out

OlegIlyenko

import scala.reflect.runtime.universe.TypeTag
import scala.annotation.implicitNotFound

@implicitNotFound("Sorry, type inference was unable to figure out the type. You need to provide it explicitly.")
trait NotNothing[T]

object NotNothing {
  private val evidence: NotNothing[Any] = new Object with NotNothing[Any]

  implicit def notNothingEvidence[T](implicit n: T =:= T): NotNothing[T] =