Auto-resolver for maps in input types

[AndreaNassisi]

The utility generates or ingests a GraphQL schema, in which input types can be maps. Generating a resolver that inference a single graph query that creates or merge multiple nodes and edges at once, following the map data structure and the schema directives.

Example
The GraphQL schema has a type Person that includes a list of type Todo, and each the Todo includes a list of Comment.
A corresponed set of nested input types: PersonInput, TodoInput, and CommentInput.
The graph database connects the nodes with label person, todo, and comment with edges of type has.

type Person @alias(property: "person") {
	firstName: String
	todos: [Todo] @relationship(edgeType: "HAS", direction: OUT)
}

type Todo @alias(property: "todo") {
	name: String
	description: String
	priority: Int
	status: String
	comments: [Comment] @relationship(edgeType: "HAS", direction: OUT)
}

type Comment @alias(property: "comment") {
	content: String
}


input PersonInput {
	firstName: String
	todos: [TodoInput]
}

input TodoInput {
	name: String
	description: String
	priority: Int
	status: String
	comments: [CommentInput]
}

input CommentInput {
	content: String
}


type Mutation {
	createNodePerson(input: PersonInput!, merge: [String]): Person
}

type Query {
	# Create Poster
	getNodePerson(filter: PersonInput): Person
	# Create Todo
	getNodeTodo(filter: TodoInput): Todo
}

schema {
	query: Query
	mutation: Mutation
}

The mutation createNodePerson accept as input a map, validated by the nested input types of the schema, like:

mutation MyMutation {
  createNodePerson( input: {
    firstName: "John", 
    todos: [
      { 
        name: "code", 
        comments: [
          {content: "I like it"},
          {content: "Will do more"}
        ]
      },
      { 
        name: "FAQ",
        comments: [
          {content: "I like it too"},
          {content: "just when I need it"}
        ]
      }
    ]}) 
  {
    firstName
  }
}

The resolver will parse the input and based of the schema will create a single openCypher query that creates the nodes and the edges at once.

The option merge toggle if a node type in the map is always created or merged, meaning finding and connecting an existing node. The merge option is a list like ["todos", "todos.comments"].