Children

GraphQL can significantly enhance the power of your API Integration. To onboard, please reach out to your Account Manager for pricing information.

Children is a field on the Entity root type that represents the entity's associated child records. Children is an array of type Entity, and is specified by passing a char type ID parameter.

{
    entity(id: 10, charTypeId: 4) {
       children(charTypeId: 3) {
            items {
                 id
                 title
                 template {
                      templateId
                 }
            }
       }   
    }
}

The Children field is especially powerful because it allows you to traverse a record's hierarchy. You can include multiple Children fields for each entity to represent different char types, and each Children Entity can have its own Children field. These Children fields can be chained together to traverse an entire records hierarchy.

In the below example, we retrieve a Deal record, it's child Table records, and the Catalog records that are associated to each of those Table records.

{
    entity(id: 10, charTypeId: 4) {
        children(charTypeId: 5) {
            items {
                id
                title
                template {
                    templateId
                }
                children(charTypeId: 1) {
                    items {
                        id
                        title
                        template {
                            templateId
                        }
                    }
                }
            }
        }    
    }
}

Response:

{
    "data": {
        "entity": {
            "children": {
                "items": [
                    {
                        "id": 500,
                        "title": "Table 1",
                        "template": {
                            "templateId": 1
                        }
                        "children": {
                            "items": [
                                {
                                    "id": 100,
                                    "title": "Catalog 1",
                                    "template": {
                                        "templateId": 1
                                    }
                                },
                                {
                                    "id": 101,
                                    "title": "Catalog 2",
                                    "template": {
                                        "templateId": 2
                                    }
                                }
                            ]
                        }
                    },
                    {
                        "id": 501,
                        "title": "Table 2",
                        "template": {
                            "templateId": 2
                        }
                        "children": {
                            "items": []
                        }
                    }
                ]
            }
        }
    }
}

Aliasing

When including multiple Children fields, in order to keep track of what a certain Children field represents, you can add an Alias. Adding an alias to a field will rename the response Children field with the desire alias name.

In the below example, the alias rights has been added to the Children field where char type ID = 3, and the alias tables has been added to the Children field where char type ID = 5. You can see in the response that these two fields have been replaced with their respective aliases.

{
    entity(id: 10, charTypeId: 4) {
       rights: children(charTypeId: 3) {
            items {
                 id
                 title
                 template {
                      templateId
                 }
            }
       } 
       tables: children(charTypeId: 5) {
            items {
                 id
                 title
                 template {
                      templateId
                 }
            }
       }    
    }
}

Response:

{
    "data": {
        "entity": {
            "id": 10,
            "title": "Deal 1",
            "template": {
                "templateId": 1
            },
            : {
                "items": [
                    {
                        "id": 100,
                        "template": {
                            "templateId": 1
                        },
                        "title": "Rights 1"
                    },
                    {
                        "id": 101,
                        "template": {
                            "templateId": 2
                        },
                        "title": "Rights 2"
                    }
                ]
            },
            : {
                "items": [
                    {
                        "id": 200,
                        "template": {
                            "templateId": 1
                        },
                        "title": "Table 1"
                    },
                    {
                        "id": 201,
                        "template": {
                            "templateId": 2
                        },
                        "title": "Table 2"
                    }
                ]
            }
        }
    }
}

Paging

To limit response sizes, the Children field utilizes paging. To page through the children records, use the skip and take parameters:

{
    entity(id: 10, charTypeId: 4) {
       rights: children(charTypeId: 3, : 10, : 10) {
            items {
                 id
                 title
                 template {
                      templateId
                 }
            }
       }  
    }
}

The default page size is 50.

There are also additional fields in the request that help to identify the total number of Children records (totalCount), if a previous page exists (hasPreviousPage), and if a next page exists (hasNextPage). hasPreviousPage and hasNextPage are nested in a pageInfo object on the Children object:

{
    entity(id: 10, charTypeId: 4) {
       rights: children(charTypeId: 3, skip: 10, take: 2) {
            
            pageInfo {
                 hasPreviousPage
                 hasNextPage
            }
            items {
                 id
                 title
                 template {
                      templateId
                 }
            }
       }  
    }
}

Response:

{
    "data": {
        "entity": {
            "id": 10,
            "title": "Deal 1",
            "template": {
                "templateId": 1
            },
            "rights": {
                "totalCount": 24,
                "pageInfo": {
                    "hasPreviousPage": true,
                    "hasNextPage": true
                },
                "items": [
                    {
                        "id": 100,
                        "template": {
                            "templateId": 1
                        },
                        "title": "Rights 1"
                    },
                    {
                        "id": 101,
                        "template": {
                            "templateId": 2
                        },
                        "title": "Rights 2"
                    }
                ]
            }
        }
    }
}

Using these fields and parameters, you can page through the Children in subsequent requests, using logic similar to:

if (pageInfo.hasNextPage)

skip = skip + take

Filtering

Children can be filtered by using a special parameter object called where:

{
    entity(id: 10, charTypeId: 4) {
       rights: children(charTypeId: 3, where: {templateId: {eq: 1}}) {
            items {
                 id
                 title
                 template {
                      templateId
                 }
            }
       }  
    }
}

All of the following Entity fields can be filtered on in the Children collection:

  • title

  • templateId

  • statusId

  • createdBy

  • createdDate

  • lastUpdatedBy

  • lastUpdatedDate

  • statusUpdatedBy

  • statusUpdatedDate

String Filtering

String fields (title) can be filtered using the following operators:

operator
value type
description
usage

eq

String

exact match

{title: {eq: "Episode 1"}}

neq

String

doesn't match

{title: {neq: "Episode 1"}}

contains

String

substring match

{title: {contains: "Episode"}}

ncontains

String

doesn't contain substring match

{title: {ncontains: "Episode"}}

in

[String]

exact match one of the following

{title: {in: ["Episode 1", "Episode 2"]}}

nin

[String]

doesn't match any of the following

{title: {nin: ["Episode 1", "Episode 2"]}}

startsWith

String

string starts with

{title: {startsWith: "Episode"}}

nstartsWith

String

string doesn't start with

{title: {nstartsWith: "Episode"}}

endsWith

String

string ends with

{title: {endsWith: "Episode"}}

nendsWith

String

string doesn't end with

{title: {nendsWith: "Episode"}}

Comparable Filtering

Field types of bool, int, and DateTime such as templateId, statusId, createdBy, createdDate, lastUpdatedBy, lastUpdatedDate, statusUpdatedBy, statusUpdatedDate can be filtered using the following operators:

operator
value type
description
usage

eq

Int, Bool, DateTime

exact match

{templateId: {eq: 1}}

neq

Int, Bool, DateTime

doesn't match

{templateId: {eq: 1}}

in

[Int], [Bool], [DateTime]

matches one of the following

{templateId: {in: [1,2]}}

nin

[Int], [Bool], [DateTime]

doesn't match any of the following

{statusId: {nin: [1,2,3]}}

gt

Int, Bool, DateTime

greater than

{createdDate: {gt:

"2023-06-27T16:07:08.570Z"}}

ngt

Int, Bool, DateTime

not greater than

{createdDate: {gt:

"2023-06-27T16:07:08.570Z"}}

gte

Int, Bool, DateTime

greater than or equal

{createdDate: {gte:

"2023-06-27T16:07:08.570Z"}}

ngte

Int, Bool, DateTime

not greater than or equal

{createdDate: {ngte:

"2023-06-27T16:07:08.570Z"}}

lt

Int, Bool, DateTime

less than

{createdDate: {lt:

"2023-06-27T16:07:08.570Z"}}

nlt

Int, Bool, DateTime

not less than

{createdDate: {nlt:

"2023-06-27T16:07:08.570Z"}}

lte

Int, Bool, DateTime

less than or equal

{createdDate: {lte:

"2023-06-27T16:07:08.570Z"}}

nlte

Int, Bool, DateTime

not less than or equal

{createdDate: {nlte:

"2023-06-27T16:07:08.570Z"}}

and / or Filtering

All of the above operators can be combined using the and & or operators:

operator
description
usage

and

all conditions must be true

{ and: [ {lastUpdatedDate: {gt: "2023-06-27T16:07:08.570Z"}}, {templateId: {in: [1,2]}} ] }

or

one condition must be true

{ or: [ {lastUpdatedDate: {gt: "2023-06-27T16:07:08.570Z"}}, {templateId: {in: [1,2]}} ] }

Sorting

To sort the records in the response by a specific field, specify an order parameter:

{
    entity(id: 10, charTypeId: 4) {
       rights: children(charTypeId: 3, order: [{ lastUpdatedDate: DESC }]) {
            items {
                 id
                 title
                 template {
                      templateId
                 }
            }
       }  
    }
}

You can sort by the following fields:

  • id

  • title

  • createdBy

  • createdDate

  • lastUpdatedBy

  • lastUpdatedDate

  • statusUpdatedBy

  • statusUpdatedDate

You can sort each of the fields above either ascending using ASC or descending using DESC.

You can also sort on a field and then by another field:

{
    entity(id: 10, charTypeId: 4) {
       rights: children(charTypeId: 3, order: [{ lastUpdatedDate: DESC }, { id: ASC }]) {
            items {
                 id
                 title
                 template {
                      templateId
                 }
            }
       }  
    }
}
PreviousParentsNextCharacteristics

Last updated