Vertx vertx = Vertx.vertx();

Router router = Router.router(vertx);

router.route("/hello").handler(rc -> {
	rc.response().end("World");
});

vertx.createHttpServer()
	.requestHandler(router::accept)
	.listen(8080);

MeshRestClient client = MeshRestClient.create("localhost", Vertx.vertx());

List<String> names = Arrays.asList("Iron Man",
	"Captain America", "Star Lord",
	"Black Widow", "Hulk");

client.findProjectByName("MCU").toSingle().flatMapCompletable(project -> {
	return Observable.fromIterable(names).flatMapSingle(name -> {

		NodeCreateRequest request = new NodeCreateRequest();
		request.setParentNodeUuid(project.getRootNode().getUuid());
		request.setLanguage("en");

		return client.createNode("MCU", request).toSingle();
	}).ignoreElements();
}).subscribe();

{
  node(path: "/aircrafts/space-shuttle") {
    uuid
    fields {
      ... on vehicle {
        weight
        price
        slug
      }
    }
  }
}

{
  "data": {
    "node": {
      "uuid": "f915b16fa68f40e395b16fa68f10e32d",
      "fields": {
        "weight": 22700,
        "price": 192000000000,
        "slug": "space-shuttle"
      }
    }
  }
}

<dependency>
    <groupId>com.graphql-java</groupId>
    <artifactId>graphql-java</artifactId>
    <version>8.0</version>
</dependency>

public class Conference {

	private final Workshop workshop;

	public Conference(Workshop workshop) {
		this.workshop = workshop;
	}

	public Workshop getWorkshop() {
		return workshop;
	}
}

public class Workshop {

	private final String name;
	private final long id;

	public Workshop(long id, String name) {
		this.id = id;
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public long getId() {
		return id;
	}
}

public static GraphQLSchema createSchema() {
	return GraphQLSchema.newSchema()
		.query(createQueryType())
		.build();
}

private static GraphQLObjectType createQueryType() {
	return newObject().name("QueryType")

		// .workshop
		.field(newFieldDefinition().name("workshop")
			.type(createWorkshopType())
			.dataFetcher((env) -> {
				Conference root = env.getSource();
				return root.getWorkshop();
			}))

		.build();
}

private static GraphQLObjectType createWorkshopType() {
	return newObject().name("Workshop")
		.description("A workshop element")

		// .id
		.field(newFieldDefinition().name("id")
			.description("The id of the workshop.")
			.type(new GraphQLNonNull(GraphQLLong)))

		// .name
		.field(newFieldDefinition().name("name")
			.description("The name of the workshop.")
			.type(GraphQLString))

		.build();
}

{
    workshop {
        name, id
    }
}

GraphQLSchema schema = ConferenceSchema.createSchema();

Workshop demo = new Workshop(42, "Gentics Mesh Tech Stack");
Conference rootElement = new Conference(demo);

// Execute the query
GraphQL graphQL = newGraphQL(schema).build();
String operation = null;
Map<String, Object> variables = null;
ExecutionInput in =
	new ExecutionInput(query, operation, queryJson, rootElement, variables);

ExecutionResult result = graphQL.execute(in);
Map<String, Object> data = (Map<String, Object>) result.getData();

System.out.println(new JsonObject(data).encodePrettily());

…
.dataFetcher((env) -> {
    RootElement root = env.getSource();
    return root.getDemo();
}))
…

TinkerGraph graph = TinkerGraph.open();
GraphTraversalSource g = graph.traversal();

Vertex johannes = g.addV("name", "johannes").next();
Vertex tinkerpop = g.addV("name", "tinkerpop").next();
Edge egde = johannes.addEdge("presents", tinkerpop);

@Singleton
@Component(modules = { AppModule.class })
public interface AppComponent {

	JsonObject configuration();

	HelloService hello();

	@Component.Builder
	interface Builder {
		@BindsInstance
		Builder configuration(JsonObject configuration);

		AppComponent build();
	}

}

@Singleton
public class HelloService {

	@Inject
	JsonObject configuration;

	@Inject
	public HelloService() {
	}

	public String getResult() {
		return configuration.getString("hello");
	}

}

JsonObject config = new JsonObject();
config.put("hello", "world");
AppComponent app = DaggerAppComponent.builder()
	.configuration(config)
	.build();

System.out.println(app.hello().getResult());

<dependencies>
    <dependency>
        <groupId>com.google.dagger</groupId>
        <artifactId>dagger-compiler</artifactId>
        <version>${dagger.version}</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <configuration>
                <verbose>true</verbose>
                <source>8</source>
                <target>8</target>
                <forceJavacCompilerUse>true</forceJavacCompilerUse>
            </configuration>
            <dependencies>
                <dependency>
                    <groupId>com.google.dagger</groupId>
                    <artifactId>dagger-compiler</artifactId>
                    <version>${dagger.version}</version>
                    <optional>true</optional>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

AppComponent app = DaggerAppComponent.builder()
	.configuration(config)
	.build();

Map<String, String> sourceVersions = loadVersionsFromGraph();

Map<String, String> sinkVersions = loadVersionsFromIndex(indexName);
MapDifference<String, String> diff = Maps.difference(sourceVersions,
                                       sinkVersions);

Set<String> needInsertionInES = diff.entriesOnlyOnLeft().keySet();
Set<String> needRemovalInES = diff.entriesOnlyOnRight().keySet();
Set<String> needUpdate = diff.entriesDiffering().keySet();