Database Mapping
@alias
This directive maps a GraphQL field to a Neo4j property on a node or relationship.
This can be used on any fields that are not @cypher
or @relationship
fields.
Definition
"""Indicates that the field is to be mapped to the underlying Neo4j under a different property name."""
directive @alias(property: String!) on FIELD_DEFINITION
Usage
type User {
id: ID! @id @alias(property: "dbId")
username: String!
}
type User {
id: ID! @id
username: String! @alias(property: "dbUserName")
livesIn: [City!]! @relationship(direction: OUT, type: "LIVES_IN", properties: "UserLivesInProperties")
}
type City {
name: String
}
interface UserLivesInProperties @relationshipProperties {
since: DateTime @alias(property: "moveInDate")
}
@node
The @node
directive is used to specify the configuration of a GraphQL object type which represents a Neo4j node.
Definition
"""Informs @neo4j/graphql of node metadata"""
directive @node(
"""Map the GraphQL type to a custom Neo4j node label"""
label: String
"""Map the GraphQL type to match additional Neo4j node labels"""
additionalLabels: [String]
"""Allows for the specification of the plural of the type name."""
plural: String
) on OBJECT
Usage
@node
can be used with the following optional parameters.
label
The parameter label
defines the label to be used in Neo4j instead of the GraphQL type name:
type Movie @node(label: "Film") {
title: String!
}
This way, the following query:
{
movies {
title
}
}
Generates the cypher query:
MATCH (this: Film)
RETURN this { .title } as this
Using $jwt
and $context
In some cases, we may want to generate dynamic labels depending on the user requesting. In these cases, we can use the variable $jwt
to define a custom label define in the JWT (similarly to how it is used in the @auth
directive):
type User @node(label: "$jwt.username") {
name: String!
}
The following query will yield a different cypher query depending on the user JWT:
{
users {
name
}
}
Assuming an user with the value "username": "arthur"
in JWT, the Cypher query will look like:
MATCH (this:arthur)
RETURN this { .name } as this
Similarly, context values can be passed directly:
type User @node(label: "$context.appId") {
name: String!
}
When running the server with Apollo:
neoSchema.getSchema().then((schema) => {
new ApolloServer({
schema,
context: ({ req }) => ({ req, appId: "myApp" }),
});
})
additionalLabels
additionalLabels
lets you define extra Neo4j labels that need to exist on the node for that GraphQL type.
type Actor @node(additionalLabels: ["Person", "User"]) {
name: String!
}
The following query:
{
Actor {
name
}
}
Generates the following cypher query, with the labels Actor
, Person
and User
:
MATCH (this:Actor:Person:User)
RETURN this { .name } as this
Note that additionalLabels
can be used along with label
:
type Actor @node(label: "ActorDB", additionalLabels: ["Person"]) {
name: String!
}
In this case, the resulting Cypher query will use the labels ActorDB
and Person
instead of Actor
:
MATCH (this:ActorDB:Person) RETURN this { .name } as this
Context and JWT variables can be used with additionalLabels
in the same fashion as in label
:
type User @node(additionalLabels: ["$jwt.username"]) {
name: String!
}
plural
The parameter plural
redefines how to compose the plural of the type for the generated operations. This is particularly
useful for types that are not correctly pluralized or are non-English words.
type Tech @node(plural: "Techs") {
name: String
}
This way, instead of the wrongly generated teches
, the type is properly written as techs
:
{
techs {
title
}
}
The same is applied to other operations such as createTechs
. Note that database labels will not change.
Was this page helpful?