A "Component" pattern for GraphQL

Problem

The GraphQL API does not support Union types, yet you need query results that are comparable to using Unions.

This recipe is one solution to the problem outlined in Composable Types without Unions.

Solution

The following "component" pattern describes entities as being a single type built from various components, rather than as individual types. It is similar to the "sparse fields" introduced in the previous recipe: it uses a single Type for all entities, but rather than put additional fields at the top level, you wrap the entities' data into various @embedded types. This pattern provides more control over types and GraphQL queries.

Not all entities have the same properties: A movie does not have a number of pages like a book, and a book does not have a length of time like a movie. However, entities of different types can share some properties, such as whether they are "new releases" or are being "promoted" somehow. This pattern allows us to reuse the same component to describe multiple types, similar to how Union types would.

Setup

  1. Update your GraphQL schema to include:

    type User {
      name: String! @unique
      favorites: [MediaItem]! @relation
    }
    
    type MediaItem {
      title: String!
      favoritedBy: [User]! @relation
    
      components: Components
    }
    
    type Components @embedded {
      # components with data
      movie: Movie,
      show: Show,
      book: Book,
    
      # singleton components
      promoted: Boolean
      newRelease: Boolean
    }
    
    type Movie @embedded {
      length: Float!
      # ... other Movie fields
    }
    
    type Show @embedded {
      seasons: Int!
      # ... other Show fields
    }
    
    type Book @embedded {
      pages: Int!
      # ... other Book fields
    }
    
    type Query {
      itemsWithComponent(component: String!): [MediaItem]!
        @resolver(paginated: true)
      itemsWithAllComponents(components: [String!]!): [MediaItem]!
        @resolver(paginated: true)
      itemsWithAnyComponents(components: [String!]!): [MediaItem]!
        @resolver(paginated: true)
    }

    This involves editing the GraphQL schema definition, wherever you have stored it, and then uploading the new schema in the Fauna Dashboard.

  2. Create a new Index to support some custom resolvers.

    The following code sample includes variations for the supported Drivers, as well as a Shell example that you can copy+paste into the Shell tab in the Fauna Dashboard.

    try
    {
        Value result = await client.Query(
            CreateIndex(
                Obj(
                    "name", "MediaItem_has_component",
                    "source", Obj(
                        "collection", Collection("MediaItem"),
                        "fields", Obj(
                            "components", Query(
                                Lambda(
                                    "doc",
                                    Let(
                                        "components",
                                        Select(
                                            Arr("data", "components"),
                                            Var("doc"),
                                            Obj()
                                        ),
                                        "component_keys",
                                        Map(
                                            ToArray(Var("components")),
                                            Lambda(
                                                "c",
                                                Select(0, Var("c"))
                                            )
                                        )
                                    ).In(
                                        Var("component_keys")
                                    )
                                )
                            )
                        )
                    ),
                    "terms", Arr(
                        Obj("binding", "components")
                    )
                )
            )
        );
        Console.WriteLine(result);
    }
    catch (Exception e)
    {
        Console.WriteLine($"ERROR: {e.Message}");
    }
    ObjectV(ref: RefV(id = "MediaItem_has_component", collection = RefV(id = "indexes")),ts: LongV(1654791391840000),active: BooleanV(True),serialized: BooleanV(True),name: StringV(MediaItem_has_component),source: ObjectV(collection: RefV(id = "MediaItem", collection = RefV(id = "collections")),fields: ObjectV(components: QueryV(System.Collections.Generic.Dictionary`2[System.String,FaunaDB.Query.Expr]))),terms: Arr(ObjectV(binding: StringV(components))),partitions: LongV(1))
    The Go version of this example is not currently available.
    System.out.println(
        client.query(
            CreateIndex(
                Obj(
                    "name", Value("MediaItem_has_component"),
                    "source", Obj(
                        "collection", Collection("MediaItem"),
                        "fields", Obj(
                            "components", Query(
                                Lambda(
                                    "doc",
                                    Let(
                                        "components", Select(
                                            Arr(Value("data"), Value("components")),
                                            Var("doc"),
                                            Obj()
                                        ),
                                        "component_keys", Map(
                                            ToArray(Var("components")),
                                            Lambda("c", Select(Value(0), Var("c")))
                                        )
                                    ).in(
                                        Var("component_keys")
                                    )
                                )
                            )
                        )
                    ),
                    "terms", Arr(
                        Obj("binding", Value("components"))
                    )
                )
            )
        ).get());
    {ref: ref(id = "MediaItem_has_component", collection = ref(id = "indexes")), ts: 1654791419640000, active: true, serialized: true, name: "MediaItem_has_component", source: {collection: ref(id = "MediaItem", collection = ref(id = "collections")), fields: {components: QueryV({api_version=4, lambda=doc, expr={let={components={select=[data, components], from={var=doc}, default={object={}}}, component_keys={map={lambda=c, expr={select=0, from={var=c}}}, collection={to_array={var=components}}}}, in={var=component_keys}}})}}, terms: [{binding: "components"}], partitions: 1}
    client.query(
      q.CreateIndex({
        name: 'MediaItem_has_component',
        source: {
          collection: q.Collection('MediaItem'),
          fields: {
            components: q.Query(
              q.Lambda(
                'doc',
                q.Let(
                  {
                    components: q.Select(
                      ['data', 'components'],
                      q.Var('doc'),
                      {}
                    ),
                    component_keys: q.Map(
                      q.ToArray(q.Var('components')),
                      q.Lambda('c', q.Select(0, q.Var('c')))
                    ),
                  },
                  q.Var('component_keys')
                )
              )
            ),
          },
        },
        terms: [{ binding: 'components' }],
      })
    )
    .then((ret) => console.log(ret))
    .catch((err) => console.error(
      'Error: [%s] %s: %s',
      err.name,
      err.message,
      err.errors()[0].description,
    ))
    {
      ref: Index("MediaItem_has_component"),
      ts: 1654791433510000,
      active: true,
      serialized: true,
      name: 'MediaItem_has_component',
      source: {
        collection: Collection("MediaItem"),
        fields: {
          components: Query(Lambda("doc", Let({"components": Select(["data", "components"], Var("doc"), {}), "component_keys": Map(ToArray(Var("components")), Lambda("c", Select(0, Var("c"))))}, Var("component_keys"))))
        }
      },
      terms: [ { binding: 'components' } ],
      partitions: 1
    }
    result = client.query(
      q.create_index({
        "name": "MediaItem_has_component",
        "source": {
          "collection": q.collection("MediaItem"),
          "fields": {
            "components": q.query(
              q.lambda_(
                "doc",
                q.let(
                  {
                    "components": q.select(
                      ["data", "components"],
                      q.var("doc"),
                      {}
                    ),
                    "component_keys": q.map_(
                      q.lambda_("c", q.select(0, q.var("c"))),
                      q.to_array(q.var("components"))
                    ),
                  },
                  q.var("component_keys")
                )
              )
            ),
          },
        },
        "terms": [{ "binding": "components" }],
      })
    )
    print(result)
    {'ref': Ref(id=MediaItem_has_component, collection=Ref(id=indexes)), 'ts': 1654791436680000, 'active': True, 'serialized': True, 'name': 'MediaItem_has_component', 'source': {'collection': Ref(id=MediaItem, collection=Ref(id=collections)), 'fields': {'components': Query({'api_version': '4', 'lambda': 'doc', 'expr': {'let': {'components': {'select': ['data', 'components'], 'from': {'var': 'doc'}, 'default': {'object': {}}}, 'component_keys': {'map': {'lambda': 'c', 'expr': {'select': 0, 'from': {'var': 'c'}}}, 'collection': {'to_array': {'var': 'components'}}}}, 'in': {'var': 'component_keys'}}})}}, 'terms': [{'binding': 'components'}], 'partitions': 1}
    CreateIndex({
      name: "MediaItem_has_component",
      source: {
        collection: Collection("MediaItem"),
        fields: {
          components: Query(
            Lambda(
              "doc",
              Let(
                {
                  components: Select(
                    ["data", "components"],
                    Var("doc"),
                    {}
                  ),
                  component_keys: Map(
                    ToArray(Var("components")),
                    Lambda("c",  Select(0, Var("c")))
                  )
                },
                Var("component_keys")
              )
            )
          )
        }
      },
      terms: [
        { binding: "components" }
      ]
    })
    {
      ref: Index("MediaItem_has_component"),
      ts: 1654791439330000,
      active: true,
      serialized: true,
      name: 'MediaItem_has_component',
      source: {
        collection: Collection("MediaItem"),
        fields: {
          components: Query(Lambda("doc", Let({"components": Select(["data", "components"], Var("doc"), {}), "component_keys": Map(ToArray(Var("components")), Lambda("c", Select(0, Var("c"))))}, Var("component_keys"))))
        }
      },
      terms: [ { binding: 'components' } ],
      partitions: 1
    }
    Query metrics:
    •    bytesIn:   500

    •   bytesOut:   667

    • computeOps:     1

    •    readOps:     0

    •   writeOps:     1

    •  readBytes: 1,718

    • writeBytes:   692

    •  queryTime:  26ms

    •    retries:     0

    This index is required by the UDF resolvers defined in the following steps.

  3. Create a UDF to aid pagination with custom resolvers.

    Each of the resolver UDFs that we need to create involve pagination. Since the pagination logic is identical in each case, we can create a helper UDF that the resolver UDFs can call.

    The following code sample includes variations for the supported Drivers, as well as a Shell example that you can copy+paste into the Shell tab in the Fauna Dashboard.

    try
    {
        Value result = await client.Query(
            CreateFunction(
                Obj(
                    "name", "paginate_helper",
                    "body", Query(
                        Lambda(
                            Arr("match", "size", "after", "before"),
                            If(
                                Equals(Var("before"), null),
                                If(
                                    Equals(Var("after"), null),
                                    Paginate(
                                        Var("match"),
                                        size: Var("size")
                                    ),
                                    Paginate(
                                        Var("match"),
                                        size: Var("size"),
                                        after: Var("after")
                                    )
                                ),
                                Paginate(
                                    Var("match"),
                                    size: Var("size"),
                                    before: Var("before")
                                )
                            )
                        )
                    )
                )
            )
        );
        Console.WriteLine(result);
    }
    catch (Exception e)
    {
        Console.WriteLine($"ERROR: {e.Message}");
    }
    ObjectV(ref: RefV(id = "paginate_helper", collection = RefV(id = "functions")),ts: LongV(1654791395650000),name: StringV(paginate_helper),body: QueryV(System.Collections.Generic.Dictionary`2[System.String,FaunaDB.Query.Expr]))
    The Go version of this example is not currently available.
    System.out.println(
        client.query(
            CreateFunction(
                Obj(
                    "name", Value("paginate_helper"),
                    "body", Query(
                        Lambda(
                            Arr(
                                Value("match"),
                                Value("size"),
                                Value("after"),
                                Value("before")
                            ),
                            If(
                                Equals(Var("before"), null),
                                If(
                                    Equals(Var("after"), null),
                                    Paginate(Var("match"))
                                        .size(Var("size")),
                                    Paginate(Var("match"))
                                        .after(Var("after"))
                                        .size(Var("size"))
                                ),
                                Paginate(Var("match"))
                                    .before(Var("before"))
                                    .size(Var("size"))
                            )
                        )
                    )
                )
            )
        ).get());
    {ref: ref(id = "paginate_helper", collection = ref(id = "functions")), ts: 1654791431950000, name: "paginate_helper", body: QueryV({api_version=4, lambda=[match, size, after, before], expr={if={equals=[{var=before}, null]}, then={if={equals=[{var=after}, null]}, then={paginate={var=match}, size={var=size}}, else={paginate={var=match}, after={var=after}, size={var=size}}}, else={paginate={var=match}, before={var=before}, size={var=size}}}})}
    client.query(
      q.CreateFunction({
        name: 'paginate_helper',
        body: q.Query(
          q.Lambda(
            ['match', 'size', 'after', 'before'],
            q.If(
              q.Equals(q.Var('before'), null),
              q.If(
                q.Equals(q.Var('after'), null),
                q.Paginate(q.Var('match'), { size: q.Var('size') }),
                q.Paginate(q.Var('match'), { size: q.Var('size'), after: q.Var('after') })
              ),
              q.Paginate(q.Var('match'), { size: q.Var('size'), before: q.Var('before') }),
            )
          )
        ),
      })
    )
    .then((ret) => console.log(ret))
    .catch((err) => console.error(
      'Error: [%s] %s: %s',
      err.name,
      err.message,
      err.errors()[0].description,
    ))
    {
      ref: Function("paginate_helper"),
      ts: 1654791433630000,
      name: 'paginate_helper',
      body: Query(Lambda(["match", "size", "after", "before"], If(Equals(Var("before"), null), If(Equals(Var("after"), null), Paginate(Var("match"), {"size": Var("size")}), Paginate(Var("match"), {"after": Var("after"), "size": Var("size")})), Paginate(Var("match"), {"before": Var("before"), "size": Var("size")}))))
    }
    result = client.query(
      q.create_function({
        "name": "paginate_helper",
        "body": q.query(
          q.lambda_(
            ["match", "size", "after", "before"],
            q.if_(
              q.equals(q.var("before"), None),
              q.if_(
                q.equals(q.var("after"), None),
                q.paginate(q.var("match"), size=q.var("size")),
                q.paginate(q.var("match"), size=q.var("size"), after=q.var("after"))
              ),
              q.paginate(q.var("match"), size=q.var("size"), before=q.var("before")),
            )
          )
        )
      })
    )
    print(result)
    {'ref': Ref(id=paginate_helper, collection=Ref(id=functions)), 'ts': 1655424431870000, 'name': 'paginate_helper', 'body': Query({'api_version': '4', 'lambda': ['match', 'size', 'after', 'before'], 'expr': {'if': {'equals': [{'var': 'before'}, None]}, 'then': {'if': {'equals': [{'var': 'after'}, None]}, 'then': {'paginate': {'var': 'match'}, 'size': {'var': 'size'}}, 'else': {'paginate': {'var': 'match'}, 'after': {'var': 'after'}, 'size': {'var': 'size'}}}, 'else': {'paginate': {'var': 'match'}, 'before': {'var': 'before'}, 'size': {'var': 'size'}}}})}
    CreateFunction({
      name: "paginate_helper",
      body: Query(
        Lambda(
          ["match", "size", "after", "before"],
          If(
            Equals(Var("before"), null),
            If(
              Equals(Var("after"), null),
              Paginate(Var("match"), { size: Var("size") }),
              Paginate(Var("match"), { size: Var("size"), after: Var("after") })
            ),
            Paginate(Var("match"), { size: Var("size"), before: Var("before") }),
          )
        )
      )
    })
    {
      ref: Function("paginate_helper"),
      ts: 1654791439670000,
      name: 'paginate_helper',
      body: Query(Lambda(["match", "size", "after", "before"], If(Equals(Var("before"), null), If(Equals(Var("after"), null), Paginate(Var("match"), {"size": Var("size")}), Paginate(Var("match"), {"after": Var("after"), "size": Var("size")})), Paginate(Var("match"), {"before": Var("before"), "size": Var("size")}))))
    }
    Query metrics:
    •    bytesIn: 440

    •   bytesOut: 544

    • computeOps:   1

    •    readOps:   0

    •   writeOps:   1

    •  readBytes:  28

    • writeBytes: 607

    •  queryTime: 9ms

    •    retries:   0

  4. Update the auto-generated itemsWithComponent resolver UDF.

    Auto-generated resolver UDFs are only stub functions, so we have to provide the implementation that we need.

    The following code sample includes variations for the supported Drivers, as well as a Shell example that you can copy+paste into the Shell tab in the Fauna Dashboard.

    try
    {
        Value result = await client.Query(
            Update(
                Function("itemsWithComponent"),
                Obj(
                    "body", Query(
                        Lambda(
                            Arr("component", "size", "after", "before"),
                            Let(
                                "match", Match(
                                    Index("MediaItem_has_component"),
                                    Var("component")
                                ),
                                "page", Call(
                                    "paginate_helper",
                                    Arr(
                                        Var("match"),
                                        Var("size"),
                                        Var("after"),
                                        Var("before")
                                    )
                                )
                            ).In(
                                Map(
                                    Var("page"),
                                    Lambda(
                                        "ref",
                                        Get(Var("ref"))
                                    )
                                )
                            )
                        )
                    )
                )
            )
        );
        Console.WriteLine(result);
    }
    catch (Exception e)
    {
        Console.WriteLine($"ERROR: {e.Message}");
    }
    ObjectV(ref: RefV(id = "itemsWithComponent", collection = RefV(id = "functions")),ts: LongV(1654896505910000),name: StringV(itemsWithComponent),data: ObjectV(gql: ObjectV(ts: FaunaTime(2022-06-10T21:28:16.399Z),meta: ObjectV(location: StringV(Query),field: ObjectV(name: StringV(itemsWithComponent),directives: Arr(ObjectV(name: StringV(resolver),args: ObjectV(name: StringV(itemsWithComponent),paginated: BooleanV(True)))),type: ObjectV(NotNull: ObjectV(List: ObjectV(Named: StringV(MediaItem)))),arguments: Arr(ObjectV(name: StringV(component),type: ObjectV(NotNull: ObjectV(Named: StringV(String))))))))),body: QueryV(System.Collections.Generic.Dictionary`2[System.String,FaunaDB.Query.Expr]))
    The Go version of this example is not currently available.
    System.out.println(
        client.query(
            Update(
                Function("itemsWithComponent"),
                Obj(
                    "body", Query(
                        Lambda(
                            Arr(
                                Value("component"),
                                Value("size"),
                                Value("after"),
                                Value("before")
                            ),
                            Let(
                                "match", Match(
                                    Index("MediaItem_has_component"),
                                    Var("component")
                                ),
                                "page", Call(
                                    Function("paginate_helper"),
                                    Arr(
                                        Var("match"),
                                        Var("size"),
                                        Var("after"),
                                        Var("before")
                                    )
                                )
                            ).in(
                                Map(
                                    Var("page"),
                                    Lambda(
                                        "ref",
                                        Get(Var("ref"))
                                    )
                                )
                            )
                        )
                    )
                )
            )
        ).get());
    {ref: ref(id = "itemsWithComponent", collection = ref(id = "functions")), ts: 1654897645750000, name: "itemsWithComponent", data: {gql: {ts: 2022-06-10T21:46:50.548Z, meta: {location: "Query", field: {name: "itemsWithComponent", directives: [{name: "resolver", args: {name: "itemsWithComponent", paginated: true}}], type: {NotNull: {List: {Named: "MediaItem"}}}, arguments: [{name: "component", type: {NotNull: {Named: "String"}}}]}}}}, body: QueryV({api_version=4, lambda=[component, size, after, before], expr={let={match={match={index=MediaItem_has_component}, terms={var=component}}, page={call={function=paginate_helper}, arguments=[{var=match}, {var=size}, {var=after}, {var=before}]}}, in={map={lambda=ref, expr={get={var=ref}}}, collection={var=page}}}})}
    client.query(
      q.Update(
        q.Function('itemsWithComponent'),
        {
          body: q.Query(
            q.Lambda(
              ['component', 'size', 'after', 'before'],
              q.Let(
                {
                  match: q.Match(
                    q.Index('MediaItem_has_component'),
                    q.Var('component')
                  ),
                  page: q.Call(
                    'paginate_helper',
                    [
                      q.Var('match'),
                      q.Var('size'),
                      q.Var('after'),
                      q.Var('before'),
                    ],
                  ),
                },
                q.Map(
                  q.Var('page'),
                  q.Lambda('ref', q.Get(q.Var('ref')))
                )
              )
            )
          ),
        },
      )
    )
    .then((ret) => console.log(ret))
    .catch((err) => console.error(
      'Error: [%s] %s: %s',
      err.name,
      err.message,
      err.errors()[0].description,
    ))
    {
      ref: Function("itemsWithComponent"),
      ts: 1654893973790000,
      name: 'itemsWithComponent',
      data: {
        gql: {
          ts: Time("2022-06-10T20:46:13.490Z"),
          meta: {
            location: 'Query',
            field: {
              name: 'itemsWithComponent',
              directives: [
                {
                  name: 'resolver',
                  args: { name: 'itemsWithComponent', paginated: true }
                }
              ],
              type: { NotNull: { List: { Named: 'MediaItem' } } },
              arguments: [
                {
                  name: 'component',
                  type: { NotNull: { Named: 'String' } }
                }
              ]
            }
          }
        }
      },
      body: Query(Lambda(["component", "size", "after", "before"], Let({"match": Match(Index("MediaItem_has_component"), Var("component")), "page": Call("paginate_helper", [Var("match"), Var("size"), Var("after"), Var("before")])}, Map(Var("page"), Lambda("ref", Get(Var("ref")))))))
    }
    result = client.query(
      q.update(
        q.function("itemsWithComponent"),
        {
          "body": q.query(
            q.lambda_(
              ["component", "size", "after", "before"],
              q.let(
                {
                  "match": q.match(
                    q.index("MediaItem_has_component"),
                    q.var("component")
                  ),
                  "page": q.call(
                    "paginate_helper",
                    [
                      q.var("match"),
                      q.var("size"),
                      q.var("after"),
                      q.var("before")
                    ]
                  )
                },
                q.map_(
                  q.lambda_(
                    "ref",
                    q.get(q.var("ref"))
                  ),
                  q.var("page")
                )
              )
            )
          )
        }
      )
    )
    print(result)
    {'ref': Ref(id=itemsWithComponent, collection=Ref(id=functions)), 'ts': 1654898104170000, 'name': 'itemsWithComponent', 'data': {'gql': {'ts': FaunaTime('2022-06-10T21:55:01.598Z'), 'meta': {'location': 'Query', 'field': {'name': 'itemsWithComponent', 'directives': [{'name': 'resolver', 'args': {'name': 'itemsWithComponent', 'paginated': True}}], 'type': {'NotNull': {'List': {'Named': 'MediaItem'}}}, 'arguments': [{'name': 'component', 'type': {'NotNull': {'Named': 'String'}}}]}}}}, 'body': Query({'api_version': '4', 'lambda': ['component', 'size', 'after', 'before'], 'expr': {'let': {'match': {'match': {'index': 'MediaItem_has_component'}, 'terms': {'var': 'component'}}, 'page': {'call': 'paginate_helper', 'arguments': [{'var': 'match'}, {'var': 'size'}, {'var': 'after'}, {'var': 'before'}]}}, 'in': {'map': {'lambda': 'ref', 'expr': {'get': {'var': 'ref'}}}, 'collection': {'var': 'page'}}}})}
    Update(
      Function("itemsWithComponent"),
      {
        body: Query(
          Lambda(
            ["component", "size", "after", "before"],
            Let(
              {
                match: Match(
                  Index("MediaItem_has_component"),
                  Var("component")
                ),
                page: Call(
                  "paginate_helper",
                  [
                    Var("match"),
                    Var("size"),
                    Var("after"),
                    Var("before")
                  ]
                )
              },
              Map(Var("page"), Lambda("ref", Get(Var("ref"))))
            )
          )
        )
      }
    )
    {
      ref: Function("itemsWithComponent"),
      ts: 1654893376660000,
      name: 'itemsWithComponent',
      data: {
        gql: {
          ts: Time("2022-06-10T20:36:15.483Z"),
          meta: {
            location: 'Query',
            field: {
              name: 'itemsWithComponent',
              directives: [
                {
                  name: 'resolver',
                  args: { name: 'itemsWithComponent', paginated: true }
                }
              ],
              type: { NotNull: { List: { Named: 'MediaItem' } } },
              arguments: [
                {
                  name: 'component',
                  type: { NotNull: { Named: 'String' } }
                }
              ]
            }
          }
        }
      },
      body: Query(Lambda(["component", "size", "after", "before"], Let({"match": Match(Index("MediaItem_has_component"), Var("component")), "page": Call("paginate_helper", [Var("match"), Var("size"), Var("after"), Var("before")])}, Map(Var("page"), Lambda("ref", Get(Var("ref")))))))
    }
    Query metrics:
    •    bytesIn:  434

    •   bytesOut:  866

    • computeOps:    1

    •    readOps:    0

    •   writeOps:    1

    •  readBytes:  491

    • writeBytes:  766

    •  queryTime: 15ms

    •    retries:    0

  5. Update the auto-generated itemsWithAllComponents resolver UDF.

    The following code sample includes variations for the supported Drivers, as well as a Shell example that you can copy+paste into the Shell tab in the Fauna Dashboard.

    try
    {
        Value result = await client.Query(
            Update(
                Function("itemsWithAllComponents"),
                Obj(
                    "body", Query(
                        Lambda(
                            Arr("components", "size", "after", "before"),
                            Let(
                                "match", Intersection(
                                    Map(
                                        Var("components"),
                                        Lambda(
                                            "component",
                                            Match(
                                                Index("MediaItem_has_component"),
                                                Var("component")
                                            )
                                        )
                                    )
                                ),
                                "page", Call(
                                    "paginate_helper",
                                    Arr(
                                        Var("match"),
                                        Var("size"),
                                        Var("after"),
                                        Var("before")
                                    )
                                )
                            ).In(
                                Map(
                                    Var("page"),
                                    Lambda(
                                        "ref",
                                        Get(Var("ref"))
                                    )
                                )
                            )
                        )
                    )
                )
            )
        );
        Console.WriteLine(result);
    }
    catch (Exception e)
    {
        Console.WriteLine($"ERROR: {e.Message}");
    }
    ObjectV(ref: RefV(id = "itemsWithAllComponents", collection = RefV(id = "functions")),ts: LongV(1654900917990000),name: StringV(itemsWithAllComponents),data: ObjectV(gql: ObjectV(ts: FaunaTime(2022-06-10T22:41:44.598Z),meta: ObjectV(location: StringV(Query),field: ObjectV(name: StringV(itemsWithAllComponents),directives: Arr(ObjectV(name: StringV(resolver),args: ObjectV(name: StringV(itemsWithAllComponents),paginated: BooleanV(True)))),type: ObjectV(NotNull: ObjectV(List: ObjectV(Named: StringV(MediaItem)))),arguments: Arr(ObjectV(name: StringV(components),type: ObjectV(NotNull: ObjectV(List: ObjectV(NotNull: ObjectV(Named: StringV(String))))))))))),body: QueryV(System.Collections.Generic.Dictionary`2[System.String,FaunaDB.Query.Expr]))
    The Go version of this example is not currently available.
    System.out.println(
        client.query(
            Update(
                Function("itemsWithAllComponents"),
                Obj(
                    "body", Query(
                        Lambda(
                            Arr(
                                Value("components"),
                                Value("size"),
                                Value("after"),
                                Value("before")
                            ),
                            Let(
                                "match", Intersection(
                                    Map(
                                        Var("components"),
                                        Lambda(
                                            "component",
                                            Match(
                                                Index("MediaItem_has_component"),
                                                Var("component")
                                            )
                                        )
                                    )
                                ),
                                "page", Call(
                                    Function("paginate_helper"),
                                    Arr(
                                        Var("match"),
                                        Var("size"),
                                        Var("after"),
                                        Var("before")
                                    )
                                )
                            ).in(
                                Map(
                                    Var("page"),
                                    Lambda(
                                        "ref",
                                        Get(Var("ref"))
                                    )
                                )
                            )
                        )
                    )
                )
            )
        ).get());
    {ref: ref(id = "itemsWithAllComponents", collection = ref(id = "functions")), ts: 1654899752410000, name: "itemsWithAllComponents", data: {gql: {ts: 2022-06-10T22:21:45.316Z, meta: {location: "Query", field: {name: "itemsWithAllComponents", directives: [{name: "resolver", args: {name: "itemsWithAllComponents", paginated: true}}], type: {NotNull: {List: {Named: "MediaItem"}}}, arguments: [{name: "components", type: {NotNull: {List: {NotNull: {Named: "String"}}}}}]}}}}, body: QueryV({api_version=4, lambda=[components, size, after, before], expr={let={match={intersection={map={lambda=component, expr={match={index=MediaItem_has_component}, terms={var=component}}}, collection={var=components}}}, page={call={function=paginate_helper}, arguments=[{var=match}, {var=size}, {var=after}, {var=before}]}}, in={map={lambda=ref, expr={get={var=ref}}}, collection={var=page}}}})}
    client.query(
      q.Update(
        q.Function('itemsWithAllComponents'),
        {
          body: q.Query(
            q.Lambda(
              ['components', 'size', 'after', 'before'],
              q.Let(
                {
                  match: q.Intersection(
                    q.Map(
                      q.Var('components'),
                      q.Lambda(
                        'component',
                        q.Match(
                          q.Index('MediaItem_has_component'),
                          q.Var('component'),
                        ),
                      ),
                    )
                  ),
                  page: q.Call(
                    'paginate_helper',
                    [
                      q.Var('match'),
                      q.Var('size'),
                      q.Var('after'),
                      q.Var('before'),
                    ],
                  ),
                },
                q.Map(
                  q.Var('page'),
                  q.Lambda('ref', q.Get(q.Var('ref')))
                )
              )
            )
          ),
        },
      )
    )
    .then((ret) => console.log(ret))
    .catch((err) => console.error(
      'Error: [%s] %s: %s',
      err.name,
      err.message,
      err.errors()[0].description,
    ))
    {
      ref: Function("itemsWithAllComponents"),
      ts: 1654899476190000,
      name: 'itemsWithAllComponents',
      data: {
        gql: {
          ts: Time("2022-06-10T22:17:55.662Z"),
          meta: {
            location: 'Query',
            field: {
              name: 'itemsWithAllComponents',
              directives: [
                {
                  name: 'resolver',
                  args: { name: 'itemsWithAllComponents', paginated: true }
                }
              ],
              type: { NotNull: { List: { Named: 'MediaItem' } } },
              arguments: [
                {
                  name: 'components',
                  type: {
                    NotNull: { List: { NotNull: { Named: 'String' } } }
                  }
                }
              ]
            }
          }
        }
      },
      body: Query(Lambda(["components", "size", "after", "before"], Let({"match": Intersection(Map(Var("components"), Lambda("component", Match(Index("MediaItem_has_component"), Var("component"))))), "page": Call("paginate_helper", [Var("match"), Var("size"), Var("after"), Var("before")])}, Map(Var("page"), Lambda("ref", Get(Var("ref")))))))
    }
    result = client.query(
      q.update(
        q.function("itemsWithAllComponents"),
        {
          "body": q.query(
            q.lambda_(
              ["components", "size", "after", "before"],
              q.let(
                {
                  "match": q.intersection(
                    q.map_(
                      q.lambda_(
                        "component",
                        q.match(
                          q.index("MediaItem_has_component"),
                          q.var("component")
                        )
                      ),
                      q.var("components")
                    )
                  ),
                  "page": q.call(
                    "paginate_helper",
                    [
                      q.var("match"),
                      q.var("size"),
                      q.var("after"),
                      q.var("before")
                    ]
                  )
                },
                q.map_(
                  q.lambda_(
                    "ref",
                    q.get(q.var("ref"))
                  ),
                  q.var("page")
                )
              )
            )
          )
        }
      )
    )
    print(result)
    {'ref': Ref(id=itemsWithAllComponents, collection=Ref(id=functions)), 'ts': 1654899353360000, 'name': 'itemsWithAllComponents', 'data': {'gql': {'ts': FaunaTime('2022-06-10T22:15:49.739Z'), 'meta': {'location': 'Query', 'field': {'name': 'itemsWithAllComponents', 'directives': [{'name': 'resolver', 'args': {'name': 'itemsWithAllComponents', 'paginated': True}}], 'type': {'NotNull': {'List': {'Named': 'MediaItem'}}}, 'arguments': [{'name': 'components', 'type': {'NotNull': {'List': {'NotNull': {'Named': 'String'}}}}}]}}}}, 'body': Query({'api_version': '4', 'lambda': ['components', 'size', 'after', 'before'], 'expr': {'let': {'match': {'intersection': {'map': {'lambda': 'component', 'expr': {'match': {'index': 'MediaItem_has_component'}, 'terms': {'var': 'component'}}}, 'collection': {'var': 'components'}}}, 'page': {'call': 'paginate_helper', 'arguments': [{'var': 'match'}, {'var': 'size'}, {'var': 'after'}, {'var': 'before'}]}}, 'in': {'map': {'lambda': 'ref', 'expr': {'get': {'var': 'ref'}}}, 'collection': {'var': 'page'}}}})}
    Update(
      Function("itemsWithAllComponents"),
      {
        body: Query(
          Lambda(
            ["components", "size", "after", "before"],
            Let(
              {
                match: Intersection(
                  Map(
                    Var("components"),
                    Lambda(
                      "component",
                      Match(
                        Index("MediaItem_has_component"),
                        Var("component")
                      )
                    )
                  )
                ),
                page: Call(
                  "paginate_helper",
                  [
                    Var("match"),
                    Var("size"),
                    Var("after"),
                    Var("before")
                  ]
                )
              },
              Map(Var("page"), Lambda("ref", Get(Var("ref"))))
            )
          )
        )
      }
    )
    {
      ref: Function("itemsWithAllComponents"),
      ts: 1654899106920000,
      name: 'itemsWithAllComponents',
      data: {
        gql: {
          ts: Time("2022-06-10T22:11:45.474Z"),
          meta: {
            location: 'Query',
            field: {
              name: 'itemsWithAllComponents',
              directives: [
                {
                  name: 'resolver',
                  args: { name: 'itemsWithAllComponents', paginated: true }
                }
              ],
              type: { NotNull: { List: { Named: 'MediaItem' } } },
              arguments: [
                {
                  name: 'components',
                  type: {
                    NotNull: { List: { NotNull: { Named: 'String' } } }
                  }
                }
              ]
            }
          }
        }
      },
      body: Query(Lambda(["components", "size", "after", "before"], Let({"match": Intersection(Map(Var("components"), Lambda("component", Match(Index("MediaItem_has_component"), Var("component"))))), "page": Call("paginate_helper", [Var("match"), Var("size"), Var("after"), Var("before")])}, Map(Var("page"), Lambda("ref", Get(Var("ref")))))))
    }
    Query metrics:
    •    bytesIn:  528

    •   bytesOut:  994

    • computeOps:    1

    •    readOps:    0

    •   writeOps:    1

    •  readBytes:  527

    • writeBytes:  872

    •  queryTime: 10ms

    •    retries:    0

    The Intersection function is used to match all components.
  6. Update the itemsWithAnyComponents resolver UDF.

    The following code sample includes variations for the supported Drivers, as well as a Shell example that you can copy+paste into the Shell tab in the Fauna Dashboard.

    try
    {
        Value result = await client.Query(
            Update(
                Function("itemsWithAnyComponents"),
                Obj(
                    "body", Query(
                        Lambda(
                            Arr("components", "size", "after", "before"),
                            Let(
                                "match", Union(
                                    Map(
                                        Var("components"),
                                        Lambda(
                                            "component",
                                            Match(
                                                Index("MediaItem_has_component"),
                                                Var("component")
                                            )
                                        )
                                    )
                                ),
                                "page", Call(
                                    "paginate_helper",
                                    Arr(
                                        Var("match"),
                                        Var("size"),
                                        Var("after"),
                                        Var("before")
                                    )
                                )
                            ).In(
                                Map(
                                    Var("page"),
                                    Lambda(
                                        "ref",
                                        Get(Var("ref"))
                                    )
                                )
                            )
                        )
                    )
                )
            )
        );
        Console.WriteLine(result);
    }
    catch (Exception e)
    {
        Console.WriteLine($"ERROR: {e.Message}");
    }
    ObjectV(ref: RefV(id = "itemsWithAnyComponents", collection = RefV(id = "functions")),ts: LongV(1655142746710000),name: StringV(itemsWithAnyComponents),data: ObjectV(gql: ObjectV(ts: FaunaTime(2022-06-13T17:52:08.929Z),meta: ObjectV(location: StringV(Query),field: ObjectV(name: StringV(itemsWithAnyComponents),directives: Arr(ObjectV(name: StringV(resolver),args: ObjectV(name: StringV(itemsWithAnyComponents),paginated: BooleanV(True)))),type: ObjectV(NotNull: ObjectV(List: ObjectV(Named: StringV(MediaItem)))),arguments: Arr(ObjectV(name: StringV(components),type: ObjectV(NotNull: ObjectV(List: ObjectV(NotNull: ObjectV(Named: StringV(String))))))))))),body: QueryV(System.Collections.Generic.Dictionary`2[System.String,FaunaDB.Query.Expr]))
    The Go version of this example is not currently available.
    System.out.println(
        client.query(
            Update(
                Function("itemsWithAnyComponents"),
                Obj(
                    "body", Query(
                        Lambda(
                            Arr(
                                Value("components"),
                                Value("size"),
                                Value("after"),
                                Value("before")
                            ),
                            Let(
                                "match", Union(
                                    Map(
                                        Var("components"),
                                        Lambda(
                                            "component",
                                            Match(
                                                Index("MediaItem_has_component"),
                                                Var("component")
                                            )
                                        )
                                    )
                                ),
                                "page", Call(
                                    Function("paginate_helper"),
                                    Arr(
                                        Var("match"),
                                        Var("size"),
                                        Var("after"),
                                        Var("before")
                                    )
                                )
                            ).in(
                                Map(
                                    Var("page"),
                                    Lambda(
                                        "ref",
                                        Get(Var("ref"))
                                    )
                                )
                            )
                        )
                    )
                )
            )
        ).get());
    {ref: ref(id = "itemsWithAnyComponents", collection = ref(id = "functions")), ts: 1655142852770000, name: "itemsWithAnyComponents", data: {gql: {ts: 2022-06-13T17:53:12.289Z, meta: {location: "Query", field: {name: "itemsWithAnyComponents", directives: [{name: "resolver", args: {name: "itemsWithAnyComponents", paginated: true}}], type: {NotNull: {List: {Named: "MediaItem"}}}, arguments: [{name: "components", type: {NotNull: {List: {NotNull: {Named: "String"}}}}}]}}}}, body: QueryV({api_version=4, lambda=[components, size, after, before], expr={let={match={union={map={lambda=component, expr={match={index=MediaItem_has_component}, terms={var=component}}}, collection={var=components}}}, page={call={function=paginate_helper}, arguments=[{var=match}, {var=size}, {var=after}, {var=before}]}}, in={map={lambda=ref, expr={get={var=ref}}}, collection={var=page}}}})}
    client.query(
      q.Update(
        q.Function('itemsWithAnyComponents'),
        {
          body: q.Query(
            q.Lambda(
              ['components', 'size', 'after', 'before'],
              q.Let(
                {
                  match: q.Union(
                    q.Map(
                      q.Var('components'),
                      q.Lambda(
                        'component',
                        q.Match(
                          q.Index('MediaItem_has_component'),
                          q.Var('component'),
                        ),
                      ),
                    )
                  ),
                  page: q.Call(
                    'paginate_helper',
                    [
                      q.Var('match'),
                      q.Var('size'),
                      q.Var('after'),
                      q.Var('before'),
                    ],
                  ),
                },
                q.Map(
                  q.Var('page'),
                  q.Lambda('ref', q.Get(q.Var('ref')))
                )
              )
            )
          ),
        },
      )
    )
    .then((ret) => console.log(ret))
    .catch((err) => console.error(
      'Error: [%s] %s: %s',
      err.name,
      err.message,
      err.errors()[0].description,
    ))
    {
      ref: Function("itemsWithAnyComponents"),
      ts: 1655142530560000,
      name: 'itemsWithAnyComponents',
      data: {
        gql: {
          ts: Time("2022-06-13T17:48:49.894Z"),
          meta: {
            location: 'Query',
            field: {
              name: 'itemsWithAnyComponents',
              directives: [
                {
                  name: 'resolver',
                  args: { name: 'itemsWithAnyComponents', paginated: true }
                }
              ],
              type: { NotNull: { List: { Named: 'MediaItem' } } },
              arguments: [
                {
                  name: 'components',
                  type: {
                    NotNull: { List: { NotNull: { Named: 'String' } } }
                  }
                }
              ]
            }
          }
        }
      },
      body: Query(Lambda(["components", "size", "after", "before"], Let({"match": Union(Map(Var("components"), Lambda("component", Match(Index("MediaItem_has_component"), Var("component"))))), "page": Call("paginate_helper", [Var("match"), Var("size"), Var("after"), Var("before")])}, Map(Var("page"), Lambda("ref", Get(Var("ref")))))))
    }
    result = client.query(
      q.update(
        q.function("itemsWithAnyComponents"),
        {
          "body": q.query(
            q.lambda_(
              ["components", "size", "after", "before"],
              q.let(
                {
                  "match": q.union(
                    q.map_(
                      q.lambda_(
                        "component",
                        q.match(
                          q.index("MediaItem_has_component"),
                          q.var("component")
                        )
                      ),
                      q.var("components")
                    )
                  ),
                  "page": q.call(
                    "paginate_helper",
                    [
                      q.var("match"),
                      q.var("size"),
                      q.var("after"),
                      q.var("before")
                    ]
                  )
                },
                q.map_(
                  q.lambda_(
                    "ref",
                    q.get(q.var("ref"))
                  ),
                  q.var("page")
                )
              )
            )
          )
        }
      )
    )
    print(result)
    {'ref': Ref(id=itemsWithAnyComponents, collection=Ref(id=functions)), 'ts': 1655142956620000, 'name': 'itemsWithAnyComponents', 'data': {'gql': {'ts': FaunaTime('2022-06-13T17:55:51.408Z'), 'meta': {'location': 'Query', 'field': {'name': 'itemsWithAnyComponents', 'directives': [{'name': 'resolver', 'args': {'name': 'itemsWithAnyComponents', 'paginated': True}}], 'type': {'NotNull': {'List': {'Named': 'MediaItem'}}}, 'arguments': [{'name': 'components', 'type': {'NotNull': {'List': {'NotNull': {'Named': 'String'}}}}}]}}}}, 'body': Query({'api_version': '4', 'lambda': ['components', 'size', 'after', 'before'], 'expr': {'let': {'match': {'union': {'map': {'lambda': 'component', 'expr': {'match': {'index': 'MediaItem_has_component'}, 'terms': {'var': 'component'}}}, 'collection': {'var': 'components'}}}, 'page': {'call': 'paginate_helper', 'arguments': [{'var': 'match'}, {'var': 'size'}, {'var': 'after'}, {'var': 'before'}]}}, 'in': {'map': {'lambda': 'ref', 'expr': {'get': {'var': 'ref'}}}, 'collection': {'var': 'page'}}}})}
    Update(
      Function("itemsWithAnyComponents"),
      {
        body: Query(
          Lambda(
            ["components", "size", "after", "before"],
            Let(
              {
                match: Union(
                  Map(
                    Var("components"),
                    Lambda(
                      "component",
                      Match(
                        Index("MediaItem_has_component"),
                        Var("component")
                      )
                    )
                  )
                ),
                page: Call(
                  "paginate_helper",
                  [
                    Var("match"),
                    Var("size"),
                    Var("after"),
                    Var("before")
                  ]
                )
              },
              Map(Var("page"), Lambda("ref", Get(Var("ref"))))
            )
          )
        )
      }
    )
    {
      ref: Function("itemsWithAnyComponents"),
      ts: 1654901367040000,
      name: 'itemsWithAnyComponents',
      data: {
        gql: {
          ts: Time("2022-06-10T22:49:25.339Z"),
          meta: {
            location: 'Query',
            field: {
              name: 'itemsWithAnyComponents',
              directives: [
                {
                  name: 'resolver',
                  args: { name: 'itemsWithAnyComponents', paginated: true }
                }
              ],
              type: { NotNull: { List: { Named: 'MediaItem' } } },
              arguments: [
                {
                  name: 'components',
                  type: {
                    NotNull: { List: { NotNull: { Named: 'String' } } }
                  }
                }
              ]
            }
          }
        }
      },
      body: Query(Lambda(["components", "size", "after", "before"], Let({"match": Union(Map(Var("components"), Lambda("component", Match(Index("MediaItem_has_component"), Var("component"))))), "page": Call("paginate_helper", [Var("match"), Var("size"), Var("after"), Var("before")])}, Map(Var("page"), Lambda("ref", Get(Var("ref")))))))
    }
    Query metrics:
    •    bytesIn:  521

    •   bytesOut:  987

    • computeOps:    1

    •    readOps:    0

    •   writeOps:    1

    •  readBytes:  527

    • writeBytes:  865

    •  queryTime: 13ms

    •    retries:    0

    The Union function is used to match any components.
  7. Run a GraphQL mutation to create a User and some MediaItems. Use the GraphQL tab in the Fauna Dashboard to execute the following mutation:

    mutation {
      createUser(
        data: {
          name: "Alice",
          favorites: {
            create: [
              {
                title: "Black Widow",
                components: {
                  movie: { length: 2.2 }
                  newRelease: true
                }
              },
              {
                title: "Psycho"
                components: {
                  movie: { length:1.8 }
                  promoted: true
                }
              },
              {
                title: "The Expanse"
                components: {
                  show: { seasons: 6 }
                  newRelease: true
                }
              },
              {
                title: "Fellowship of the Ring"
                components: {
                  book: { pages: 544 }
                  promoted: true
                }
              }
            ]
          }
        }
      ) {
        name
        _id
        favorites {
          data {
            title
            components {
              movie { length }
              show { seasons }
              book { pages }
              newRelease
              promoted
            }
            _id
          }
        }
      }
    }

    The result should be similar to:

    {
      "data": {
        "createUser": {
          "name": "Alice",
          "_id": "332207514480280098",
          "favorites": {
            "data": [
              {
                "title": "Black Widow",
                "components": {
                  "movie": {
                    "length": 2.2
                  },
                  "show": null,
                  "book": null,
                  "newRelease": true,
                  "promoted": null
                },
                "_id": "332207514484474402"
              },
              {
                "title": "Psycho",
                "components": {
                  "movie": {
                    "length": 1.8
                  },
                  "show": null,
                  "book": null,
                  "newRelease": null,
                  "promoted": true
                },
                "_id": "332207514493911586"
              },
              {
                "title": "The Expanse",
                "components": {
                  "movie": null,
                  "show": {
                    "seasons": 6
                  },
                  "book": null,
                  "newRelease": true,
                  "promoted": null
                },
                "_id": "332207514497057314"
              },
              {
                "title": "Fellowship of the Ring",
                "components": {
                  "movie": null,
                  "show": null,
                  "book": {
                    "pages": 544
                  },
                  "newRelease": null,
                  "promoted": true
                },
                "_id": "332207514500203042"
              }
            ]
          }
        }
      }
    }
    The document IDs presented in the _id fields are different for every new document created in Fauna. The Objective 3 query requires two of the document IDs present in this result.

Objective 1: Query for all entities of a given type

You can get all items of a type by indexing on the existence of the component field.

{
  allMovies: itemsWithComponent(component: "movie") {
    data {
      title
      components {
        movie { length }
        newRelease
        promoted
      }
    }
  }

  allShows: itemsWithComponent(component: "show") {
    data {
      title
      components {
        show { seasons }
        newRelease
        promoted
      }
    }
  }

  allBooks: itemsWithComponent(component: "book") {
    data {
      title
      components {
        book { pages }
        newRelease
        promoted
      }
    }
  }
}
{
  "data": {
    "allMovies": {
      "data": [
        {
          "title": "Black Widow",
          "components": {
            "movie": {
              "length": 2.2
            },
            "newRelease": true,
            "promoted": null
          }
        },
        {
          "title": "Psycho",
          "components": {
            "movie": {
              "length": 1.8
            },
            "newRelease": null,
            "promoted": true
          }
        }
      ]
    },
    "allShows": {
      "data": [
        {
          "title": "The Expanse",
          "components": {
            "show": {
              "seasons": 6
            },
            "newRelease": true,
            "promoted": null
          }
        }
      ]
    },
    "allBooks": {
      "data": [
        {
          "title": "Fellowship of the Ring",
          "components": {
            "book": {
              "pages": 544
            },
            "newRelease": null,
            "promoted": true
          }
        }
      ]
    }
  }
}

Objective 2: Query for all entities with certain properties

Every entity is searchable by every property. You can use the current schema to match all items that have multiple components.

Additional Indexes can be created to extend the above schema to match on terms such as data.components.book.author.

{
  allMovies: itemsWithAllComponents(components: ["movie", "newRelease"]) {
    data {
      title
      components {
        movie { length }
        newRelease
        promoted
      }
    }
  }
}
{
  "data": {
    "allMovies": {
      "data": [
        {
          "title": "Black Widow",
          "components": {
            "movie": {
              "length": 2.2
            },
            "newRelease": true,
            "promoted": null
          }
        }
      ]
    }
  }
}

Objective 3: Query for all relationships of an entity, regardless of which type it points to

  1. You can search for all user favorites by selecting the single favorites field.

  2. You can search for all users that have the media item marked as a favorite through the favoritedBy field.

To make the following query work:

  • replace <$USERID> with the document ID for the user created in the setup’s step 7 (just below the name field in the result).

  • replace <$MEDIAITEMID> with the document ID for the "Black Widow" movie created in the setup’s step 7.

{
  findUserByID(id: "<$USERID>") {
    name
    favorites {
      data {
        title
        components {
          movie { length }
          show { seasons }
          book { pages }
          newRelease
          promoted
        }
      }
    }
  }

  findMediaItemByID(id:"<$MEDIAITEMID>") {
    title
    components {
      movie { length }
      show { seasons }
      book { pages }
      newRelease
      promoted
    }
    favoritedBy {
      data { name }
    }
  }
}
{
  "data": {
    "findUserByID": {
      "name": "Alice",
      "favorites": {
        "data": [
          {
            "title": "Black Widow",
            "components": {
              "movie": {
                "length": 2.2
              },
              "show": null,
              "book": null,
              "newRelease": true,
              "promoted": null
            }
          },
          {
            "title": "Psycho",
            "components": {
              "movie": {
                "length": 1.8
              },
              "show": null,
              "book": null,
              "newRelease": null,
              "promoted": true
            }
          },
          {
            "title": "The Expanse",
            "components": {
              "movie": null,
              "show": {
                "seasons": 6
              },
              "book": null,
              "newRelease": true,
              "promoted": null
            }
          },
          {
            "title": "Fellowship of the Ring",
            "components": {
              "movie": null,
              "show": null,
              "book": {
                "pages": 544
              },
              "newRelease": null,
              "promoted": true
            }
          }
        ]
      }
    },
    "findMediaItemByID": {
      "title": "Black Widow",
      "components": {
        "movie": {
          "length": 2.2
        },
        "show": null,
        "book": null,
        "newRelease": true,
        "promoted": null
      },
      "favoritedBy": {
        "data": [
          {
            "name": "Alice"
          }
        ]
      }
    }
  }
}

Was this article helpful? 

We're sorry to hear that.
Tell us how we can improve!
Visit Fauna's forums or email docs@fauna.com

Thank you for your feedback!