Maps the data coming back from the GraphQL endpoint. In this example, User.name is a function that the @dillonkearns/elm-graphql CLI tool created which tells us that the name field on a User object is a String according to your GraphQL schema.

import Graphql.Operation exposing (RootQuery)
import Graphql.SelectionSet exposing (SelectionSet)
import StarWars.Query as Query


query : SelectionSet String RootQuery
query =
    Query.hello |> SelectionSet.map String.toUpper

You can also map to values of a different type. For example, if we use a (String -> Int) map function, it will change the type of our SelectionSet accordingly:

import Graphql.Operation exposing (RootQuery)
import Graphql.SelectionSet exposing (SelectionSet)
import StarWars.Query as Query


query : SelectionSet Int RootQuery
query =
    Query.hello |> SelectionSet.map String.length

SelectionSet.map is also helpful when using a record to wrap a type:

import Graphql.Operation exposing (RootQuery)
import Graphql.SelectionSet exposing (SelectionSet)
import StarWars.Query as Query


type alias Response =
    { hello : String }


query : SelectionSet Response RootQuery
query =
    SelectionSet.map Response Query.hello

Mapping is also handy when you are dealing with polymorphic GraphQL types (Interfaces and Unions).

import Graphql.SelectionSet as SelectionSet exposing (SelectionSet)
import StarWars.Object.Droid as Droid
import StarWars.Object.Human as Human
import StarWars.Union
import StarWars.Union.CharacterUnion


type HumanOrDroidDetails
    = HumanDetails (Maybe String)
    | DroidDetails (Maybe String)


heroUnionSelection : SelectionSet HumanOrDroidDetails StarWars.Union.CharacterUnion
heroUnionSelection =
    StarWars.Union.CharacterUnion.fragments
        { onHuman = SelectionSet.map HumanDetails Human.homePlanet
        , onDroid = SelectionSet.map DroidDetails Droid.primaryFunction
        }

Combine two SelectionSets into one, using the given combine function to merge the two data sets together.

import Graphql.SelectionSet as SelectionSet exposing (SelectionSet)
import StarWars.Object
import StarWars.Object.Human as Human
import StarWars.Scalar


type alias Human =
    { name : String
    , id : StarWars.Scalar.Id
    }


hero : SelectionSet Hero StarWars.Object.Human
hero =
    SelectionSet.map2 Human
        Human.name
        Human.id

Check out the examples folder, there are lots of end-to-end examples there!

Combine three SelectionSets into one, using the given combine function to merge the two data sets together. This gives more clear error messages than the pipeline syntax (using SelectionSet.succeed to start the pipeline and SelectionSet.with to continue it).

import Graphql.SelectionSet as SelectionSet exposing (SelectionSet)
import StarWars.Interface
import StarWars.Interface.Character as Character
import StarWars.Scalar


type alias Character =
    { name : String
    , id : StarWars.Scalar.Id
    , friends : List String
    }


characterSelection : SelectionSet Character StarWars.Interface.Character
characterSelection =
    SelectionSet.map3 Character
        Character.name
        Character.id
        (Character.friends Character.name)

A helper for mapping a SelectionSet to provide a default value.

See the explanation in the Pipeline section. This function is used to add SelectionSets onto a pipeline.

Include a hardcoded value. This is used analagously to with to add values into a pipeline.

    import StarWars.Enum.Episode as Episode exposing (Episode)
    import StarWars.Object
    import Graphql.SelectionSet exposing (SelectionSet, with, hardcoded)


    type alias Hero =
        { name : String
        , movie : String
        }


    hero : SelectionSet Hero StarWars.Interface.Character
    hero =
        Character.commonSelection Hero
            |> with Character.name
            |> hardcoded "Star Wars"

Most commonly succeed is used to start a pipeline. See the description in the Pipeline section above for more.

There are other ways to use succeed. It simply takes the value you pass into it and decodes into that value without looking at the GraphQL response (just like Json.Decode.succeed).

So instead of hardcoding a field like hardcoded, SelectionSet.succeed hardcodes an entire SelectionSet. This can be useful if you want hardcoded data based on only the type when using a polymorphic type (Interface or Union).

import Graphql.SelectionSet as SelectionSet exposing (SelectionSet, with)
import StarWars.Interface
import StarWars.Interface.Character as Character


type alias Character =
    { typename : HumanOrDroid
    , name : String
    }


type HumanOrDroid
    = Human
    | Droid


hero : SelectionSet Character StarWars.Interface.Character
hero =
    SelectionSet.succeed Character
        |> with heroType
        |> with Character.name


heroType : SelectionSet HumanOrDroid StarWars.Interface.Character
heroType =
    Character.fragments
        { onHuman = SelectionSet.succeed Human
        , onDroid = SelectionSet.succeed Droid
        }

Useful for Mutations when you don't want any data back.

import Graphql.Operation exposing (RootMutation)
import Graphql.SelectionSet as SelectionSet exposing (SelectionSet)
import StarWars.Mutation as Mutation


sendChatMessage : String -> SelectionSet () RootMutation
sendChatMessage message =
    Mutation.sendMessage
        { message = message }
        SelectionSet.empty

SelectionSet type

This type is used internally only in the generated code.

If the map function provided returns an Ok Result, it will map to that value. If it returns an Err, the entire response will fail to decode.

import Time exposing (Posix)
import Github.Object
import Github.Object.Repository
import Github.Scalar
-- NOTE: Iso8601 comes from an external dependency in Elm >= 0.19:
-- https://package.elm-lang.org/packages/rtfeldman/elm-iso8601-date-strings/latest/
import Iso8601
import Graphql.SelectionSet as SelectionSet exposing (with)


type alias Timestamps =
{ created : Posix
, updated : Posix
}




timestampsSelection : SelectionSet Timestamps Github.Object.Repository
timestampsSelection =
    SelectionSet.succeed Timestamps
        |> with (Repository.createdAt |> mapToDateTime)
        |> with (Repository.updatedAt |> mapToDateTime)




mapToDateTime : Field Github.Scalar.DateTime typeLock -> Field Posix typeLock
mapToDateTime =
    Field.mapOrFail
        (\(Github.Scalar.DateTime value) ->
            Iso8601.toTime value
                |> Result.mapError (\_ -> "Failed to parse "
                 ++ value ++ " as Iso8601 DateTime.")

Effectively turns an attribute that is String => String!, or User => User! (if you're not familiar with the GraphQL type language notation, learn more here).

This will cause your entire decoder to fail if the field comes back as null. It's far better to fix your schema then to use this escape hatch!

Effectively turns a field that is [String] => [String!], or [User] => [User!] (if you're not familiar with the GraphQL type language notation, learn more here).

This will cause your entire decoder to fail if any elements in the list for this field comes back as null. It's far better to fix your schema then to use this escape hatch!

Often GraphQL schemas will contain things like [String] (i.e. a nullable list of nullable strings) when they really mean [String!]! (a non-nullable list of non-nullable strings). You can chain together these nullable helpers if for some reason you can't go in and fix this in the schema, for example:

releases : SelectionSet (List Release) Github.Object.ReleaseConnection
releases =
    Github.Object.ReleaseConnection.nodes release
        |> Field.nonNullOrFail
        |> Field.nonNullElementsOrFail

Without the Field.nonNull... transformations here, the type would be SelectionSet (Maybe (List (Maybe Release))) Github.Object.ReleaseConnection.