GraphQL Aggregation Directives

1Operations

1.1Map

Directive
directive @map(key: String!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@map can be applied to objects or list of objects of any depth. If @map is applied on an object, it pulls the field key up. If @map is applied on a list, the algorithm is applied for each element of this list.

Given the following data:

Example № 1{
  "list": [
    {
      "string": "a"
    },
    {
      "string": "b"
    },
    {
      "string": "c"
    }
  ]
}

The execution of the following query:

Example № 2{
  list @map(key: "string"){
    string
  }
}

will retrun the following result:

Example № 3{
  "list": [
    "a",
    "b",
    "c"
  ]
}
Execution

node is the value node where the directive is applied

RewriteMap(node)
  1. Let key be the value of the argument key of the directive
  2. If node is ObjectValue
    1. If Exists(node, key)
      1. Let valueOfKey be Get(node, key)
      2. Retrun valueOfKey
    2. Otherwise
      1. Return null
  3. Otherwise If node is ListValue
    1. Let listResult be a empty list
    2. For each element in node
      1. Let rewritten be the result of RewriteMap(element)
      2. If rewritten is NOT null
        1. Add rewritten to listResult
    3. Return listResult
  4. Otherwise
    1. Assert: AG0002

1.2Chunk

Directive
directive @chunk(size: Int! = 1) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@chunk can be applied on list values of any depth. @chunk splits the list into groups the length of size. If the list cannot be split evenly, the final chunk will contain the remaining elements.

Given the following data:

Example № 4{
  "list": [
    {
      "string": "a"
    },
    {
      "string": "b"
    },
    {
      "string": "c"
    }
  ]
}

The execution of the following query:

Example № 5{
  list @chunk(size: 2){
    string
  }
}

will retrun the following result:

Example № 6{
  "list": [
    [
      {
        "string": "a"
      },
      {
        "string": "b"
      }
    ],
    [
      {
        "string": "c"
      }
    ]
  ]
}
Execution

node is the value node where the directive is applied

RewriteChunk(node)
  1. Let size be the value of the argument size of the directive
  2. If size is < 1
    1. Assert: AG0005
  3. If node is ObjectValue
    1. Assert: AG0001
  4. If node is ScalarValue
    1. Assert: AG0004
  5. Otherwise
    1. Let chunks be an empty list
    2. Let currentChunk be an empty list
    3. While count of node is NOT 0
      1. Let element be the value of the first element of node
      2. Remove the first element of node
      3. Add element to currentChunk
      4. If count of currentChunk is size
        1. Add currentChunk to chunks
        2. Let currentChunk be an empty list
    4. If count of currentChunk is NOT 0
      1. Add currentChunk to chunks
    5. Retrun chunks

1.3CountBy

Directive
directive @countBy(key: String!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@countBy can only be applied list of objects of depth 1. Nested lists can be flattened with @flatten first. @countBy returns an object where the keys are the values of the field selected with key. The values are the number of times the key was found.

Given the following data:

Example № 7{
  "list": [
    {
      "string": "a"
    },
    {
      "string": "a"
    },
    {
      "string": "c"
    }
  ]
}

The execution of the following query:

Example № 8{
  list @countBy(key: "string"){
    string
  }
}

will retrun the following result:

Example № 9{
  "list": {
    "a": 2,
    "c": 1
  }
}
Execution

node is the value node where the directive is applied

RewriteCountBy(node)
  1. Let key be the value of the argument key of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Return RewriteCountByArray(node)
RewriteCountByArray(value)
  1. Let result be a unordered map
  2. For each element in value
    1. If element is ListValue
      1. Assert: AG0003
    2. Otherwise If element is ScalarValue
      1. Assert: AG0002
    3. Otherwise If element is ObjectValue
      1. If Exists(element, key)
        1. Let fieldValue be Get(element, key)
        2. If IsConvertibleToString(fieldValue)
          1. Let convertedValue be ConvertToString(fieldValue)
          2. If NOT Exists(result, convertedValue)
            1. Set value of convertedValue in result to 0
          3. Increase convertedValue in result by 1
  3. Return result

1.4Drop

Directive
directive @drop(count: Int!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@drop can be applied a list any depth. @drop removes the first count elements of the list. If there are less elements than count a empty list is returned.

Given the following data:

Example № 10{
  "list": [
    {
      "string": "a"
    },
    {
      "string": "a"
    },
    {
      "string": "c"
    }
  ]
}

The execution of the following query:

Example № 11{
  list @drop(count: 2){
    string
  }
}

will retrun the following result:

Example № 12{
  "list": [
    {
      "string": "c"
    }
  ]
}
Execution

node is the value node where the directive is applied

RewriteDrop(node)
  1. Let size be the value of the argument size of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Remove size elements from the beginning of node
    2. Return node

1.5DropRight

Directive
directive @dropRight(count: Int!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@dropRight can be applied a list any depth. @dropRight removes the last count elements of the list. If there are less elements than count a empty list is returned.

Given the following data:

Example № 13{
  "list": [
    {
      "string": "a"
    },
    {
      "string": "a"
    },
    {
      "string": "c"
    }
  ]
}

The execution of the following query:

Example № 14{
  list @dropRight(count: 2){
    string
  }
}

will retrun the following result:

Example № 15{
  "list": [
    {
      "string": "a"
    }
  ]
}
Execution

node is the value node where the directive is applied

RewriteDropRight(node)
  1. Let size be the value of the argument size of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Remove size elements from the end of node
    2. Return node

1.6Flatten

Directive
directive @flatten(depth: Int! = 1) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@flatten can be applied to all value nodes. @flatten recursivly flattens an array depth times.

Note If @flatten is applied to a ObjectValue or a ScalarValue, the value will be wrapped in an array with length 1

Given the following data:

Example № 16{
  "nestedList": [
    [
      {
        "string": "b"
      }
    ],
    [
      {
        "string": "d"
      }
    ],
    [
      {
        "string": "d"
      }
    ],
  ]
}

The execution of the following query:

Example № 17{
  nestedList @flatten(depth: 1){
    string
  }
}

will retrun the following result:

Example № 18{
  "list": [
    {
      "string": "b"
    },
    {
      "string": "d"
    } ,
    {
      "string": "d"
    }
  ]
}
Execution

node is the value node where the directive is applied

RewriteFlatten(node)
  1. Let depth be the value of the argument depth of the directive
  2. If dpeth is lower than 1
    1. Assert: AG0006
  3. Otherwise
    1. Let result be a empty list
    2. Let initialDepth be 0
    3. RewriteFlattenList(node, initialDepth, result)
    4. Return result
  4. Otherwise
    1. Assert: AG0002
RewriteFlattenList(node, currentDepth, result)
  1. If node is ListValue
    1. For each element in node
      1. Let nextDepth be currentDepth + 1
      2. RewriteFlattenList(node, nextDepth, result)
  2. Otherwise
    1. Add node to result

1.7GroupBy

Directive
directive @groupBy(key: String!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@groupBy can only be applied list of objects of depth 1. Nested lists can be flattened with @flatten first. @groupBy returns an object where the keys are the values of the field selected with key. The values of the object are lists with the corresponding elements.

Given the following data:

Example № 19{
  "list": [
    {
      "string": "a"
    },
    {
      "string": "a"
    },
    {
      "string": "b"
    }
  ]
}

The execution of the following query:

Example № 20{
  list @groupBy(key: "string"){
    string
  }
}

will retrun the following result:

Example № 21{
  "list": {
    "a": [
      {
        "string": "a"
      },
      {
        "string": "a"
      }
    ],
    "b": [
      {
        "string": "b"
      }
    ]
  }
}
Execution

node is the value node where the directive is applied

RewriteGroupBy(node)
  1. Let key be the value of the argument key of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Return RewriteGroupByArray(node)
RewriteGroupByArray(value)
  1. Let result be a unordered map
  2. For each element in value
    1. If element is ListValue
      1. Assert: AG0003
    2. Otherwise If element is ScalarValue
      1. Assert: AG0002
    3. Otherwise If element is ObjectValue
      1. If Exists(element, key)
        1. Let fieldValue be Get(element, key)
        2. If IsConvertibleToString(fieldValue)
          1. Let convertedValue be ConvertToString(fieldValue)
          2. If NOT Exists(result, convertedValue)
            1. Set value of convertedValue in result to a empty list
          3. Add element to the list of convertedValue in result
  3. Return result

1.8KeyBy

Directive
directive @keyBy(key: String!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@keyBy can only be applied list of objects of depth 1. Nested lists can be flattened with @flatten first. @keyBy returns an object where the keys are the values of the field selected with key. The values are the first element with the corresponding key.

Given the following data:

Example № 22{
  "list": [
    {
      "id": 1,
      "string": "a"
    },
    {
      "id": 2,
      "string": "a"
    },
    {
      "id": 3,
      "string": "b"
    }
  ]
}

The execution of the following query:

Example № 23{
  list @keyBy(key: "string"){
    string
  }
}

will retrun the following result:

Example № 24{
  "list": {
    "a": {
      "id": 1,
      "string": "a"
    },
    "b": {
      "id": 3,
      "string": "b"
    }
  }
}
Execution

node is the value node where the directive is applied

RewriteKeyBy(node)
  1. Let key be the value of the argument key of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Return RewriteKeyByArray(node)
RewriteKeyByArray(value)
  1. Let result be a unordered map
  2. For each element in value
    1. If element is ListValue
      1. Assert: AG0003
    2. Otherwise If element is ScalarValue
      1. Assert: AG0002
    3. Otherwise If element is ObjectValue
      1. If Exists(element, key)
        1. Let fieldValue be Get(element, key)
        2. If IsConvertibleToString(fieldValue)
          1. Let convertedValue be ConvertToString(fieldValue)
          2. If NOT Exists(result, convertedValue)
            1. Set value of convertedValue in result to element
  3. Return result

1.9Keys

Directive
directive @keys repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@keys can only be to objects. @keys returns a list of all fields in this object.

Given the following data:

Example № 25{
  "single": {
    "id": 1,
    "string": "a"
  }
}

The execution of the following query:

Example № 26{
  single @keys {
    id
    string
  }
}

will retrun the following result:

Example № 27{
  "single": [ 
    "id", 
    "string", 
  ]
}
Execution

node is the value node where the directive is applied

RewriteKeys(node)
  1. If node is ListValue
    1. Assert: AG0003
  2. Otherwise If node is ScalarValue
    1. Assert: AG0002
  3. Otherwise
    1. Let result be a empty list
    2. For each key in keys of value
      1. Add key to result
    3. Return result

1.10MaxBy

Directive
directive @maxBy(key: String!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@maxBy can only be applied list of objects of depth 1. Nested lists can be flattened with @flatten first. @maxBy returns the object where the value of the field with name key is the highest. If no value was found, @maxBy retruns the first element of the list.

Given the following data:

Example № 28{
  "list": [
    {
      "string": "a",
      "int": 1
    },
    {
      "string": "b",
      "int": 2
    },
    {
      "string": "c",
      "int": 3
    }
  ]
}

The execution of the following query:

Example № 29{
  list @maxBy(key: "int"){
    string
    int
  }
}

will retrun the following result:

Example № 30{
  "list": {
    "string": "c",
    "int": 3
  }
}
Execution

node is the value node where the directive is applied

RewriteMaxBy(node)
  1. Let key be the value of the argument key of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Return RewriteMaxByArray(node)
RewriteMaxByArray(value)
  1. If value has 0 elements
    1. Return null
  2. Let lastValue be a null
  3. Let result be a null
  4. If the first element of value is ObjectValue
    1. Set result to the first element of value
  5. For each element in value
    1. If element is ListValue
      1. Assert: AG0003
    2. Otherwise If element is ScalarValue
      1. Assert: AG0002
    3. Otherwise If element is ObjectValue
      1. If Exists(element, key)
        1. Let fieldValue be Get(element, key)
        2. If IsConvertibleToComparable(fieldValue)
          1. Let convertedValue be ConvertToComparable(fieldValue)
          2. If result is null OR lastValue is null OR convertedValue is greater than lastValue
            1. Set value of result to element
            2. Set value of lastValue to convertedValue
  6. Return result

1.11MeanBy

Directive
directive @meanBy(key: String!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@meanBy can only be applied list of objects of depth 1. Nested lists can be flattened with @flatten first. @meanBy returns mean of all values of the fields with name key. If no value was found, @meanBy retruns null.

Given the following data:

Example № 31{
  "list": [
    {
      "int": 1
    },
    {
      "int": 2
    },
    {
      "int": 3
    }
  ]
}

The execution of the following query:

Example № 32{
  list @meanBy(key: "int"){
    int
  }
}

will retrun the following result:

Example № 33{
  "list": 2
}
Execution

node is the value node where the directive is applied

RewriteMeanBy(node)
  1. Let key be the value of the argument key of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Return RewriteMeanByArray(node)
RewriteMeanByArray(value)
  1. Let divisor be 0
  2. Let sum be 0
  3. For Each element in value
    1. If element is ListValue
      1. Assert: AG0003
    2. Otherwise If element is ScalarValue
      1. Assert: AG0002
    3. Otherwise If element is ObjectValue
      1. If Exists(element, key)
        1. Let fieldValue be Get(element, key)
        2. If IsNumber(fieldValue)
          1. Add fieldValue to sum
          2. Increase divisor by 1
  4. If divisor is 0
    1. Return null
  5. Return sum / divisor

1.12MinBy

Directive
directive @minBy(key: String!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@minBy can only be applied list of objects of depth 1. Nested lists can be flattened with @flatten first. @minBy returns the object where the value of the field with name key is the lowest. If no value was found, @minBy retruns the first element of the list.

Given the following data:

Example № 34{
  "list": [
    {
      "string": "a",
      "int": 1
    },
    {
      "string": "b",
      "int": 2
    },
    {
      "string": "c",
      "int": 3
    }
  ]
}

The execution of the following query:

Example № 35{
  list @minBy(key: "int"){
    string
    int
  }
}

will retrun the following result:

Example № 36{
  "list": {
    "string": "a",
    "int": 1
  }
}
Execution

node is the value node where the directive is applied

RewriteMinBy(node)
  1. Let key be the value of the argument key of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Return RewriteMinByArray(node)
RewriteMinByArray(value)
  1. If value has 0 elements
    1. Return null
  2. Let lastValue be a null
  3. Let result be a null
  4. If the first element of value is ObjectValue
    1. Set result to the first element of value
  5. For each element in value
    1. If element is ListValue
      1. Assert: AG0003
    2. Otherwise If element is ScalarValue
      1. Assert: AG0002
    3. Otherwise If element is ObjectValue
      1. If Exists(element, key)
        1. Let fieldValue be Get(element, key)
        2. If IsConvertibleToComparable(fieldValue)
          1. Let convertedValue be ConvertToComparable(fieldValue)
          2. If result is null OR lastValue is null OR convertedValue is lower than lastValue
            1. Set value of result to element
            2. Set value of lastValue to convertedValue
  6. Return result

1.13SumBy

Directive
directive @sumBy(key: String!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@sumBy can only be applied list of objects of depth 1. Nested lists can be flattened with @flatten first. @sumBy returns the sum of all values of the fields with name key. If no value was found, @sumBy retruns null.

Given the following data:

Example № 37{
  "list": [
    {
      "int": 1
    },
    {
      "int": 2
    },
    {
      "int": 3
    }
  ]
}

The execution of the following query:

Example № 38{
  list @sumBy(key: "int"){
    int
  }
}

will retrun the following result:

Example № 39{
  "list": 6
}
Execution

node is the value node where the directive is applied

RewriteSumBy(node)
  1. Let key be the value of the argument key of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Return RewriteSumByArray(node)
RewriteSumByArray(value)
  1. Let sum be null
  2. For Each element in value
    1. If element is ListValue
      1. Assert: AG0003
    2. Otherwise If element is ScalarValue
      1. Assert: AG0002
    3. Otherwise If element is ObjectValue
      1. If Exists(element, key)
        1. Let fieldValue be Get(element, key)
        2. If IsNumber(fieldValue)
          1. If sum is null
            1. Set sum to 0
          2. Add fieldValue to sum
  3. Return sum

1.14Take

Directive
directive @take(count: Int!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@take can be applied a list any depth. @take returns the first count elements of the list. If there are less elements than count the list does not change.

Given the following data:

Example № 40{
  "list": [
    {
      "string": "a"
    },
    {
      "string": "b"
    },
    {
      "string": "c"
    }
  ]
}

The execution of the following query:

Example № 41{
  list @take(count: 2){
    string
  }
}

will retrun the following result:

Example № 42{
  "list": [
    {
      "string": "a"
    },
    {
      "string": "b"
    },
  ]
}
Execution

node is the value node where the directive is applied

RewriteTake(node)
  1. Let size be the value of the argument size of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Let result be the a list of the first size elements from the beginning of node
    2. Return result

1.15TakeRight

Directive
directive @takeRight(count: Int!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@takeRight can be applied a list any depth. @takeRight returns the last count elements of the list. If there are less elements than count the list does not change.

Given the following data:

Example № 43{
  "list": [
    {
      "string": "a"
    },
    {
      "string": "b"
    },
    {
      "string": "c"
    }
  ]
}

The execution of the following query:

Example № 44{
  list @takeRight(count: 2){
    string
  }
}

will retrun the following result:

Example № 45{
  "list": [
    {
      "string": "b"
    },
    {
      "string": "c"
    }
  ]
}
Execution

node is the value node where the directive is applied

RewriteTakeRight(node)
  1. Let size be the value of the argument size of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Let result be the a list of the first size elements from the end of node
    2. Return node

1.16Uniq

Directive
directive @uniq(count: Int!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@uniq can be applied a list any depth. @uniq returns a duplicate-free version of the list.

Given the following data:

Example № 46{
  "stringList": [ "a", "a", "b" ]
}

The execution of the following query:

Example № 47{
  stringList @uniq
}

will retrun the following result:

Example № 48{
  "stringList": [ "a", "b" ]
}
Execution

node is the value node where the directive is applied

RewriteUniq(node)
  1. Let size be the value of the argument size of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Return RewriteUniqArray(node)
RewriteUniqArray(value)
  1. Let result be a ordered set
  2. For each element in value
    1. If IsConvertibleToComparable(element)
      1. Let convertedValue be ConvertToComparable(fieldValue)
      2. If convertedValue does NOT exist in result
        1. Add convertedValue to result
    2. Otherwise
      1. Add element to result
  3. Return result

1.17UniqBy

Directive
directive @uniqBy(key: String!) repeatable on QUERY | MUTATION | SUBSCRIPTION | FIELD

@uniqBy can be applied to a list of objects of depth 1. @uniqBy returns a duplicate-free version of the list based on the the values of the field selected with key.

Given the following data:

Example № 49{
  "list": [
    {
      "string": "a"
    },
    {
      "string": "a"
    },
    {
      "string": "c"
    }
  ]
}

The execution of the following query:

Example № 50{
  list @uniqBy(key: "string"){
    string
  }
}

will retrun the following result:

Example № 51{
  "list": {
    {
      "string": "a"
    },
    {
      "string": "c"
    }
  }
}
Execution

node is the value node where the directive is applied

RewriteUniqBy(node)
  1. Let key be the value of the argument key of the directive
  2. If node is ObjectValue
    1. Assert: AG0001
  3. Otherwise If node is ScalarValue
    1. Assert: AG0004
  4. Otherwise
    1. Return RewriteUniqByArray(node)
RewriteUniqByArray(value)
  1. Let result be a empty list
  2. Let values be a ordered set
  3. For each element in value
    1. If element is ListValue
      1. Assert: AG0003
    2. Otherwise If element is ScalarValue
      1. Assert: AG0002
    3. Otherwise If element is ObjectValue
      1. If Exists(element, key)
        1. Let fieldValue be Get(element, key)
        2. If IsConvertibleToComparable(element)
          1. Let convertedValue be ConvertToComparable(fieldValue)
          2. If convertedValue does NOT exist in values
            1. Add element to result
    4. Otherwise
      1. Add element to result
  4. Return result

2Transformations

Exists(node, key)
  1. If node is ObjectValue AND field key exists in node
    1. return true
  2. Otherwise
    1. return false
Get(node, key)
  1. If Exists(node, key)
    1. return value of field key in node
  2. Otherwise
    1. Assert: Field key is not present in node
ConvertToString(node)
  1. If node is string
    1. return node
  2. Otherwise If node is number
    1. return number as string
  3. Otherwise If node is boolean
    1. return boolean as string
  4. Otherwise If node is null
    1. return "null"
  5. Otherwise
    1. return null
IsConvertibleToString(node)
  1. If node is string
    1. return true
  2. Otherwise If node is number
    1. return true
  3. Otherwise If node is boolean
    1. return true
  4. Otherwise If node is null
    1. return true
  5. Otherwise
    1. return false
ConvertToComparable(node)
  1. If node is number
    1. return number
  2. Otherwise If node is boolean
    1. return boolean
  3. Otherwise
    1. return null
Note TODO We might want to add support for datetime strings
IsConvertibleToComparable(node)
  1. If node is number
    1. return true
  2. Otherwise If node is boolean
    1. return true
  3. Otherwise
    1. return false
IsNumber(node)
  1. If node is number
    1. return true
  2. Otherwise
    1. return false

3Definitions

ObjectValue
Key Value pair
Example № 52{
   "string": "string",
   "int": 1,
   "float": 2,
}
ScalarValue
A primitive leaf value
Example № 53"string"

Example № 541
ListValue
A collection of either ObjectValue, ScalarValue or ListValue
Example № 55[ 
  {
   "string": "string",
  },
  1,
  [
    {
     "string": "string",
    },
  ]
]

4Errors

AG0001
The field path expects a list but received an object
AG0002
The field path expects a object but received a scalar
AG0003
The field path expects a object but received an list
AG0004
The field path expects a list but received a scalar
AG0005
The argument size of chunk on field path must be greater than 0
AG0006
The argument size of flatten on field path must be greater than 0,

§Index

  1. @chunk
  2. @countBy
  3. @drop
  4. @dropRight
  5. @flatten
  6. @groupBy
  7. @keyBy
  8. @keys
  9. @map
  10. @maxBy
  11. @meanBy
  12. @minBy
  13. @sumBy
  14. @take
  15. @takeRight
  16. @uniq
  17. @uniqBy
  18. AG0001
  19. AG0002
  20. AG0003
  21. AG0004
  22. AG0005
  23. AG0006
  24. ConvertToComparable
  25. ConvertToString
  26. Exists
  27. Get
  28. IsConvertibleToComparable
  29. IsConvertibleToString
  30. IsNumber
  31. ListValue
  32. ObjectValue
  33. RewriteChunk
  34. RewriteCountBy
  35. RewriteCountByArray
  36. RewriteDrop
  37. RewriteDropRight
  38. RewriteFlatten
  39. RewriteFlattenList
  40. RewriteGroupBy
  41. RewriteGroupByArray
  42. RewriteKeyBy
  43. RewriteKeyByArray
  44. RewriteKeys
  45. RewriteMap
  46. RewriteMaxBy
  47. RewriteMaxByArray
  48. RewriteMeanBy
  49. RewriteMeanByArray
  50. RewriteMinBy
  51. RewriteMinByArray
  52. RewriteSumBy
  53. RewriteSumByArray
  54. RewriteTake
  55. RewriteTakeRight
  56. RewriteUniq
  57. RewriteUniqArray
  58. RewriteUniqBy
  59. RewriteUniqByArray
  60. ScalarValue
GraphQL Aggregation Directives
  1. 1Operations
    1. 1.1Map
    2. 1.2Chunk
    3. 1.3CountBy
    4. 1.4Drop
    5. 1.5DropRight
    6. 1.6Flatten
    7. 1.7GroupBy
    8. 1.8KeyBy
    9. 1.9Keys
    10. 1.10MaxBy
    11. 1.11MeanBy
    12. 1.12MinBy
    13. 1.13SumBy
    14. 1.14Take
    15. 1.15TakeRight
    16. 1.16Uniq
    17. 1.17UniqBy
  2. 2Transformations
  3. 3Definitions
  4. 4Errors
  5. §Index