Skip to main content

@addField

The @addField directive is defined as follows:

Directive Definition
Directive Definition
directive @addField(
"""
Name of the new field to be added
"""
name: String!

"""
Path of the data where the field should point to
"""
path: [String!]
) repeatable on OBJECT

The @addField directive simplifies data structures and queries by adding a field that inline or flattens a nested field or node within your schema. It modifies the schema and the data transformation process, making nested data more accessible and straightforward to present.

For instance, consider a schema:

schema {
query: Query
}

type User
@addField(name: "street", path: ["address", "street"]) {
id: Int!
name: String!
username: String!
email: String!
phone: String
website: String
address: Address @modify(omit: true)
}

type Address {
street: String!
city: String!
state: String!
}

type Query {
user(id: Int!): User
@http(
url: "https://jsonplaceholder.typicode.com/users/{{.args.id}}"
)
}

Suppose we focus on the street field in Address.

In this case, applying the @addField directive to the User type creates a street field within the User type. It uses a path argument to specify the sequence of fields from a declared field (address), leading to the Address field to add. We also can apply @modify(omit: true) to remove the address field from the schema, as the street field from Address is now directly accessible on the User type.

Post application, the schema becomes:

schema {
query: Query
}

type User {
id: Int!
name: String!
username: String!
email: String!
phone: String
website: String
street: String
}

type Query {
user(id: Int): Post!
}

In the above example, since we added a @modify(omit: true) on the address field, the schema no longer includes the Address type.

The @addField directive also take cares of nullablity of the fields. If any of the fields in the path is nullable, the resulting type will be nullable.

@addField also supports indexing, allowing for the specification of an array index for inline inclusion. For instance, if a field posts is of type [Post], and the goal is to access the title of the first post, specify the path as ["posts","0","title"].

type User
@addField(
name: "firstPostTitle"
path: ["posts", "0", "title"]
) {
id: Int!
name: String!
username: String!
email: String!
phone: String
website: String
posts: Post
@http(
url: "https://jsonplaceholder.typicode.com/users/{{.value.id}}/posts"
)
}

type Post {
id: Int!
userId: Int!
title: String!
body: String!
}

In conclusion, the @addField directive helps tidy up your schema and streamline data fetching by reducing query depth, promoting better performance and simplicity.