func TestConnectionFromArray_HandlesPagination_RespectsLastAndAfterAndBefore_TooFew(t *testing.T) {
filter := map[string]interface{}{
"last": 2,
"after": "YXJyYXljb25uZWN0aW9uOjA=",
"before": "YXJyYXljb25uZWN0aW9uOjQ=",
}
args := relay.NewConnectionArguments(filter)
expected := &relay.Connection{
Edges: []*relay.Edge{
&relay.Edge{
Node: "C",
Cursor: "YXJyYXljb25uZWN0aW9uOjI=",
},
&relay.Edge{
Node: "D",
Cursor: "YXJyYXljb25uZWN0aW9uOjM=",
},
},
PageInfo: relay.PageInfo{
StartCursor: "YXJyYXljb25uZWN0aW9uOjI=",
EndCursor: "YXJyYXljb25uZWN0aW9uOjM=",
HasPreviousPage: true,
HasNextPage: false,
},
}
result := relay.ConnectionFromArray(arrayConnectionTestLetters, args)
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, connection result diff: %v", testutil.Diff(expected, result))
}
}
func TestConnectionFromArraySlice_UndersizedSliceBoth(t *testing.T) {
filter := map[string]interface{}{
"first": 3,
"after": "YXJyYXljb25uZWN0aW9uOjE=",
}
args := relay.NewConnectionArguments(filter)
expected := &relay.Connection{
Edges: []*relay.Edge{
&relay.Edge{
Node: "D",
Cursor: "YXJyYXljb25uZWN0aW9uOjM=",
},
},
PageInfo: relay.PageInfo{
StartCursor: "YXJyYXljb25uZWN0aW9uOjM=",
EndCursor: "YXJyYXljb25uZWN0aW9uOjM=",
HasPreviousPage: false,
HasNextPage: true,
},
}
result := relay.ConnectionFromArraySlice(
arrayConnectionTestLetters[3:4],
args,
relay.ArraySliceMetaInfo{
SliceStart: 3,
ArrayLength: 5,
},
)
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, connection result diff: %v", testutil.Diff(expected, result))
}
}
func TestConnectionFromArray_HandlesCursorEdgeCases_ReturnsNoElementsIfFirstIsZero(t *testing.T) {
filter := map[string]interface{}{
"first": 0,
}
args := relay.NewConnectionArguments(filter)
expected := &relay.Connection{
Edges: []*relay.Edge{},
PageInfo: relay.PageInfo{},
}
result := relay.ConnectionFromArray(arrayConnectionTestLetters, args)
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, connection result diff: %v", testutil.Diff(expected, result))
}
}
func TestConnectionFromArray_HandlesCursorEdgeCases_ReturnsNoElementsIfCursorsCross(t *testing.T) {
filter := map[string]interface{}{
"before": "YXJyYXljb25uZWN0aW9uOjI=", // ==> offset: int(2)
"after": "YXJyYXljb25uZWN0aW9uOjQ=", // ==> offset: int(4)
}
args := relay.NewConnectionArguments(filter)
expected := &relay.Connection{
Edges: []*relay.Edge{},
PageInfo: relay.PageInfo{},
}
result := relay.ConnectionFromArray(arrayConnectionTestLetters, args)
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, connection result diff: %v", testutil.Diff(expected, result))
}
}
func TestConnectionFromArray_HandlesBasicSlicing_RespectsAnOverlyLargeFirst(t *testing.T) {
filter := map[string]interface{}{
"first": 10,
}
args := relay.NewConnectionArguments(filter)
expected := &relay.Connection{
Edges: []*relay.Edge{
&relay.Edge{
Node: "A",
Cursor: "YXJyYXljb25uZWN0aW9uOjA=",
},
&relay.Edge{
Node: "B",
Cursor: "YXJyYXljb25uZWN0aW9uOjE=",
},
&relay.Edge{
Node: "C",
Cursor: "YXJyYXljb25uZWN0aW9uOjI=",
},
&relay.Edge{
Node: "D",
Cursor: "YXJyYXljb25uZWN0aW9uOjM=",
},
&relay.Edge{
Node: "E",
Cursor: "YXJyYXljb25uZWN0aW9uOjQ=",
},
},
PageInfo: relay.PageInfo{
StartCursor: "YXJyYXljb25uZWN0aW9uOjA=",
EndCursor: "YXJyYXljb25uZWN0aW9uOjQ=",
HasPreviousPage: false,
HasNextPage: false,
},
}
result := relay.ConnectionFromArray(arrayConnectionTestLetters, args)
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, connection result diff: %v", testutil.Diff(expected, result))
}
}
func TestConnectionFromArray_HandlesCursorEdgeCases_ReturnsAllElementsIfCursorsAreOnTheOutside(t *testing.T) {
filter := map[string]interface{}{
"before": "YXJyYXljb25uZWN0aW9uOjYK", // ==> offset: int(6)
"after": "YXJyYXljb25uZWN0aW9uOi0xCg==", // ==> offset: int(-1)
}
args := relay.NewConnectionArguments(filter)
expected := &relay.Connection{
Edges: []*relay.Edge{
&relay.Edge{
Node: "A",
Cursor: "YXJyYXljb25uZWN0aW9uOjA=",
},
&relay.Edge{
Node: "B",
Cursor: "YXJyYXljb25uZWN0aW9uOjE=",
},
&relay.Edge{
Node: "C",
Cursor: "YXJyYXljb25uZWN0aW9uOjI=",
},
&relay.Edge{
Node: "D",
Cursor: "YXJyYXljb25uZWN0aW9uOjM=",
},
&relay.Edge{
Node: "E",
Cursor: "YXJyYXljb25uZWN0aW9uOjQ=",
},
},
PageInfo: relay.PageInfo{
StartCursor: "YXJyYXljb25uZWN0aW9uOjA=",
EndCursor: "YXJyYXljb25uZWN0aW9uOjQ=",
HasPreviousPage: false,
HasNextPage: false,
},
}
result := relay.ConnectionFromArray(arrayConnectionTestLetters, args)
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, connection result diff: %v", testutil.Diff(expected, result))
}
}
func TestConnectionFromArray_HandlesBasicSlicing_ReturnsAllElementsWithoutFilters(t *testing.T) {
args := relay.NewConnectionArguments(nil)
expected := &relay.Connection{
Edges: []*relay.Edge{
&relay.Edge{
Node: "A",
Cursor: "YXJyYXljb25uZWN0aW9uOjA=",
},
&relay.Edge{
Node: "B",
Cursor: "YXJyYXljb25uZWN0aW9uOjE=",
},
&relay.Edge{
Node: "C",
Cursor: "YXJyYXljb25uZWN0aW9uOjI=",
},
&relay.Edge{
Node: "D",
Cursor: "YXJyYXljb25uZWN0aW9uOjM=",
},
&relay.Edge{
Node: "E",
Cursor: "YXJyYXljb25uZWN0aW9uOjQ=",
},
},
PageInfo: relay.PageInfo{
StartCursor: "YXJyYXljb25uZWN0aW9uOjA=",
EndCursor: "YXJyYXljb25uZWN0aW9uOjQ=",
HasPreviousPage: false,
HasNextPage: false,
},
}
result := relay.ConnectionFromArray(arrayConnectionTestLetters, args)
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, connection result diff: %v", testutil.Diff(expected, result))
}
}
func TestConnectionFromArray_HandlesBasicSlicing_RespectsASmallerFirst(t *testing.T) {
// Create connection arguments from map[string]interface{},
// which you usually get from types.GQLParams.Args
filter := map[string]interface{}{
"first": 2,
}
args := relay.NewConnectionArguments(filter)
// Alternatively, you can create connection arg the following way.
// args := relay.NewConnectionArguments(filter)
// args.First = 2
expected := &relay.Connection{
Edges: []*relay.Edge{
&relay.Edge{
Node: "A",
Cursor: "YXJyYXljb25uZWN0aW9uOjA=",
},
&relay.Edge{
Node: "B",
Cursor: "YXJyYXljb25uZWN0aW9uOjE=",
},
},
PageInfo: relay.PageInfo{
StartCursor: "YXJyYXljb25uZWN0aW9uOjA=",
EndCursor: "YXJyYXljb25uZWN0aW9uOjE=",
HasPreviousPage: false,
HasNextPage: true,
},
}
result := relay.ConnectionFromArray(arrayConnectionTestLetters, args)
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, connection result diff: %v", testutil.Diff(expected, result))
}
}
func init() {
connectionTestUserType = graphql.NewObject(graphql.ObjectConfig{
Name: "User",
Fields: graphql.Fields{
"name": &graphql.Field{
Type: graphql.String,
},
// re-define `friends` field later because `connectionTestUserType` has `connectionTestConnectionDef` has `connectionTestUserType` (cyclic-reference)
"friends": &graphql.Field{},
},
})
connectionTestConnectionDef = relay.ConnectionDefinitions(relay.ConnectionConfig{
Name: "Friend",
NodeType: connectionTestUserType,
EdgeFields: graphql.Fields{
"friendshipTime": &graphql.Field{
Type: graphql.String,
Resolve: func(p graphql.ResolveParams) (interface{}, error) {
return "Yesterday", nil
},
},
},
ConnectionFields: graphql.Fields{
"totalCount": &graphql.Field{
Type: graphql.Int,
Resolve: func(p graphql.ResolveParams) (interface{}, error) {
return len(connectionTestAllUsers), nil
},
},
},
})
// define `friends` field here after getting connection definition
connectionTestUserType.AddFieldConfig("friends", &graphql.Field{
Type: connectionTestConnectionDef.ConnectionType,
Args: relay.ConnectionArgs,
Resolve: func(p graphql.ResolveParams) (interface{}, error) {
arg := relay.NewConnectionArguments(p.Args)
res := relay.ConnectionFromArray(connectionTestAllUsers, arg)
return res, nil
},
})
connectionTestQueryType = graphql.NewObject(graphql.ObjectConfig{
Name: "Query",
Fields: graphql.Fields{
"user": &graphql.Field{
Type: connectionTestUserType,
Resolve: func(p graphql.ResolveParams) (interface{}, error) {
return connectionTestAllUsers[0], nil
},
},
},
})
var err error
connectionTestSchema, err = graphql.NewSchema(graphql.SchemaConfig{
Query: connectionTestQueryType,
})
if err != nil {
panic(err)
}
}
func init() {
/**
* We get the node interface and field from the relay library.
*
* The first method is the way we resolve an ID to its object. The second is the
* way we resolve an object that implements node to its type.
*/
nodeDefinitions = relay.NewNodeDefinitions(relay.NodeDefinitionsConfig{
IDFetcher: func(id string, info graphql.ResolveInfo) interface{} {
// resolve id from global id
resolvedID := relay.FromGlobalID(id)
// based on id and its type, return the object
if resolvedID.Type == "Faction" {
return GetFaction(resolvedID.ID)
} else {
return GetShip(resolvedID.ID)
}
},
TypeResolve: func(value interface{}, info graphql.ResolveInfo) *graphql.Object {
// based on the type of the value, return GraphQLObjectType
switch value.(type) {
case *Faction:
return factionType
default:
return shipType
}
},
})
/**
* We define our basic ship type.
*
* This implements the following type system shorthand:
* type Ship : Node {
* id: String!
* name: String
* }
*/
shipType = graphql.NewObject(graphql.ObjectConfig{
Name: "Ship",
Description: "A ship in the Star Wars saga",
Fields: graphql.Fields{
"id": relay.GlobalIDField("Ship", nil),
"name": &graphql.Field{
Type: graphql.String,
Description: "The name of the ship.",
},
},
Interfaces: []*graphql.Interface{
nodeDefinitions.NodeInterface,
},
})
/**
* We define a connection between a faction and its ships.
*
* connectionType implements the following type system shorthand:
* type ShipConnection {
* edges: [ShipEdge]
* pageInfo: PageInfo!
* }
*
* connectionType has an edges field - a list of edgeTypes that implement the
* following type system shorthand:
* type ShipEdge {
* cursor: String!
* node: Ship
* }
*/
shipConnectionDefinition := relay.ConnectionDefinitions(relay.ConnectionConfig{
Name: "Ship",
NodeType: shipType,
})
/**
* We define our faction type, which implements the node interface.
*
* This implements the following type system shorthand:
* type Faction : Node {
* id: String!
* name: String
* ships: ShipConnection
* }
*/
factionType = graphql.NewObject(graphql.ObjectConfig{
Name: "Faction",
Description: "A faction in the Star Wars saga",
Fields: graphql.Fields{
"id": relay.GlobalIDField("Faction", nil),
"name": &graphql.Field{
Type: graphql.String,
Description: "The name of the faction.",
},
"ships": &graphql.Field{
Type: shipConnectionDefinition.ConnectionType,
Args: relay.ConnectionArgs,
Resolve: func(p graphql.ResolveParams) interface{} {
// convert args map[string]interface into ConnectionArguments
args := relay.NewConnectionArguments(p.Args)
// get ship objects from current faction
ships := []interface{}{}
if faction, ok := p.Source.(*Faction); ok {
for _, shipId := range faction.Ships {
ships = append(ships, GetShip(shipId))
}
}
// let relay library figure out the result, given
// - the list of ships for this faction
// - and the filter arguments (i.e. first, last, after, before)
return relay.ConnectionFromArray(ships, args)
},
},
},
Interfaces: []*graphql.Interface{
nodeDefinitions.NodeInterface,
},
})
/**
* This is the type that will be the root of our query, and the
* entry point into our schema.
*
* This implements the following type system shorthand:
* type Query {
* rebels: Faction
* empire: Faction
* node(id: String!): Node
* }
*/
queryType := graphql.NewObject(graphql.ObjectConfig{
Name: "Query",
Fields: graphql.Fields{
"rebels": &graphql.Field{
Type: factionType,
Resolve: func(p graphql.ResolveParams) interface{} {
return GetRebels()
},
},
"empire": &graphql.Field{
Type: factionType,
Resolve: func(p graphql.ResolveParams) interface{} {
return GetEmpire()
},
},
"node": nodeDefinitions.NodeField,
},
})
/**
* This will return a GraphQLField for our ship
* mutation.
*
* It creates these two types implicitly:
* input IntroduceShipInput {
* clientMutationID: string!
* shipName: string!
* factionId: ID!
* }
*
* input IntroduceShipPayload {
* clientMutationID: string!
* ship: Ship
* faction: Faction
* }
*/
shipMutation := relay.MutationWithClientMutationID(relay.MutationConfig{
Name: "IntroduceShip",
InputFields: graphql.InputObjectConfigFieldMap{
"shipName": &graphql.InputObjectFieldConfig{
Type: graphql.NewNonNull(graphql.String),
},
"factionId": &graphql.InputObjectFieldConfig{
Type: graphql.NewNonNull(graphql.ID),
},
},
OutputFields: graphql.Fields{
"ship": &graphql.Field{
Type: shipType,
Resolve: func(p graphql.ResolveParams) interface{} {
if payload, ok := p.Source.(map[string]interface{}); ok {
return GetShip(payload["shipId"].(string))
}
return nil
},
},
"faction": &graphql.Field{
Type: factionType,
Resolve: func(p graphql.ResolveParams) interface{} {
if payload, ok := p.Source.(map[string]interface{}); ok {
return GetFaction(payload["factionId"].(string))
}
return nil
},
},
},
MutateAndGetPayload: func(inputMap map[string]interface{}, info graphql.ResolveInfo) map[string]interface{} {
// `inputMap` is a map with keys/fields as specified in `InputFields`
// Note, that these fields were specified as non-nullables, so we can assume that it exists.
shipName := inputMap["shipName"].(string)
factionId := inputMap["factionId"].(string)
// This mutation involves us creating (introducing) a new ship
newShip := CreateShip(shipName, factionId)
// return payload
return map[string]interface{}{
"shipId": newShip.ID,
"factionId": factionId,
}
},
})
/**
* This is the type that will be the root of our mutations, and the
* entry point into performing writes in our schema.
*
* This implements the following type system shorthand:
* type Mutation {
* introduceShip(input IntroduceShipInput!): IntroduceShipPayload
* }
*/
mutationType := graphql.NewObject(graphql.ObjectConfig{
Name: "Mutation",
Fields: graphql.Fields{
"introduceShip": shipMutation,
},
})
/**
* Finally, we construct our schema (whose starting query type is the query
* type we defined above) and export it.
*/
var err error
Schema, err = graphql.NewSchema(graphql.SchemaConfig{
Query: queryType,
Mutation: mutationType,
})
if err != nil {
// panic if there is an error in schema
panic(err)
}
}
func init() {
/**
* We get the node interface and field from the Relay library.
*
* The first method defines the way we resolve an ID to its object.
* The second defines the way we resolve an object to its GraphQL type.
*/
nodeDefinitions = relay.NewNodeDefinitions(relay.NodeDefinitionsConfig{
IDFetcher: func(id string, info graphql.ResolveInfo, ct context.Context) (interface{}, error) {
resolvedID := relay.FromGlobalID(id)
if resolvedID.Type == "User" {
return GetUser(resolvedID.ID), nil
}
if resolvedID.Type == "Widget" {
return GetWidget(resolvedID.ID), nil
}
return nil, nil
},
TypeResolve: func(value interface{}, info graphql.ResolveInfo) *graphql.Object {
switch value.(type) {
case *User:
return userType
case *Widget:
return widgetType
}
return nil
},
})
/**
* Define your own types here
*/
widgetType = graphql.NewObject(graphql.ObjectConfig{
Name: "Widget",
Description: "A shiny widget'",
Fields: graphql.Fields{
"id": relay.GlobalIDField("Widget", nil),
"name": &graphql.Field{
Description: "The name of the widget",
Type: graphql.String,
},
},
Interfaces: []*graphql.Interface{
nodeDefinitions.NodeInterface,
},
})
widgetConnection = relay.ConnectionDefinitions(relay.ConnectionConfig{
Name: "WidgetConnection",
NodeType: widgetType,
})
userType = graphql.NewObject(graphql.ObjectConfig{
Name: "User",
Description: "A person who uses our app",
Fields: graphql.Fields{
"id": relay.GlobalIDField("User", nil),
"widgets": &graphql.Field{
Type: widgetConnection.ConnectionType,
Description: "A person's collection of widgets",
Args: relay.ConnectionArgs,
Resolve: func(p graphql.ResolveParams) (interface{}, error) {
args := relay.NewConnectionArguments(p.Args)
dataSlice := WidgetsToInterfaceSlice(GetWidgets()...)
return relay.ConnectionFromArray(dataSlice, args), nil
},
},
},
Interfaces: []*graphql.Interface{
nodeDefinitions.NodeInterface,
},
})
/**
* This is the type that will be the root of our query,
* and the entry point into our schema.
*/
queryType := graphql.NewObject(graphql.ObjectConfig{
Name: "Query",
Fields: graphql.Fields{
"node": nodeDefinitions.NodeField,
// Add you own root fields here
"viewer": &graphql.Field{
Type: userType,
Resolve: func(p graphql.ResolveParams) (interface{}, error) {
return GetViewer(), nil
},
},
},
})
/**
* This is the type that will be the root of our mutations,
* and the entry point into performing writes in our schema.
*/
// mutationType := graphql.NewObject(graphql.ObjectConfig{
// Name: "Mutation",
// Fields: graphql.Fields{
// // Add you own mutations here
// },
// })
/**
* Finally, we construct our schema (whose starting query type is the query
* type we defined above) and export it.
*/
var err error
Schema, err = graphql.NewSchema(graphql.SchemaConfig{
Query: queryType,
})
if err != nil {
panic(err)
}
}
func init() {
nodeDefinitions = relay.NewNodeDefinitions(relay.NodeDefinitionsConfig{
IDFetcher: func(id string, info graphql.ResolveInfo) interface{} {
resolvedID := relay.FromGlobalID(id)
if resolvedID.Type == "Todo" {
return GetTodo(resolvedID.ID)
}
if resolvedID.Type == "User" {
return GetUser(resolvedID.ID)
}
return nil
},
TypeResolve: func(value interface{}, info graphql.ResolveInfo) *graphql.Object {
switch value.(type) {
case *Todo:
return todoType
case *User:
return userType
default:
return userType
}
},
})
todoType = graphql.NewObject(graphql.ObjectConfig{
Name: "Todo",
Fields: graphql.Fields{
"id": relay.GlobalIDField("Todo", nil),
"text": &graphql.Field{
Type: graphql.String,
},
"complete": &graphql.Field{
Type: graphql.Boolean,
},
},
Interfaces: []*graphql.Interface{nodeDefinitions.NodeInterface},
})
todosConnection = relay.ConnectionDefinitions(relay.ConnectionConfig{
Name: "Todo",
NodeType: todoType,
})
userType = graphql.NewObject(graphql.ObjectConfig{
Name: "User",
Fields: graphql.Fields{
"id": relay.GlobalIDField("User", nil),
"todos": &graphql.Field{
Type: todosConnection.ConnectionType,
Args: relay.NewConnectionArgs(graphql.FieldConfigArgument{
"status": &graphql.ArgumentConfig{
Type: graphql.String,
DefaultValue: "any",
},
}),
Resolve: func(p graphql.ResolveParams) interface{} {
status, _ := p.Args["status"].(string)
args := relay.NewConnectionArguments(p.Args)
todos := TodosToSliceInterface(GetTodos(status))
return relay.ConnectionFromArray(todos, args)
},
},
"totalCount": &graphql.Field{
Type: graphql.Int,
Resolve: func(p graphql.ResolveParams) interface{} {
return len(GetTodos("any"))
},
},
"completedCount": &graphql.Field{
Type: graphql.Int,
Resolve: func(p graphql.ResolveParams) interface{} {
return len(GetTodos("completed"))
},
},
},
Interfaces: []*graphql.Interface{nodeDefinitions.NodeInterface},
})
rootType := graphql.NewObject(graphql.ObjectConfig{
Name: "Root",
Fields: graphql.Fields{
"viewer": &graphql.Field{
Type: userType,
Resolve: func(p graphql.ResolveParams) interface{} {
return GetViewer()
},
},
"node": nodeDefinitions.NodeField,
},
})
addTodoMutation := relay.MutationWithClientMutationID(relay.MutationConfig{
Name: "AddTodo",
InputFields: graphql.InputObjectConfigFieldMap{
"text": &graphql.InputObjectFieldConfig{
Type: graphql.NewNonNull(graphql.String),
},
},
OutputFields: graphql.Fields{
"todoEdge": &graphql.Field{
Type: todosConnection.EdgeType,
Resolve: func(p graphql.ResolveParams) interface{} {
payload, _ := p.Source.(map[string]interface{})
todoId, _ := payload["todoId"].(string)
todo := GetTodo(todoId)
return relay.EdgeType{
Node: todo,
Cursor: relay.CursorForObjectInConnection(TodosToSliceInterface(GetTodos("any")), todo),
}
},
},
"viewer": &graphql.Field{
Type: userType,
Resolve: func(p graphql.ResolveParams) interface{} {
return GetViewer()
},
},
},
MutateAndGetPayload: func(inputMap map[string]interface{}, info graphql.ResolveInfo) map[string]interface{} {
text, _ := inputMap["text"].(string)
todoId := AddTodo(text, false)
return map[string]interface{}{
"todoId": todoId,
}
},
})
changeTodoStatusMutation := relay.MutationWithClientMutationID(relay.MutationConfig{
Name: "ChangeTodoStatus",
InputFields: graphql.InputObjectConfigFieldMap{
"id": &graphql.InputObjectFieldConfig{
Type: graphql.NewNonNull(graphql.ID),
},
"complete": &graphql.InputObjectFieldConfig{
Type: graphql.NewNonNull(graphql.Boolean),
},
},
OutputFields: graphql.Fields{
"todo": &graphql.Field{
Type: todoType,
Resolve: func(p graphql.ResolveParams) interface{} {
payload, _ := p.Source.(map[string]interface{})
todoId, _ := payload["todoId"].(string)
todo := GetTodo(todoId)
return todo
},
},
"viewer": &graphql.Field{
Type: userType,
Resolve: func(p graphql.ResolveParams) interface{} {
return GetViewer()
},
},
},
MutateAndGetPayload: func(inputMap map[string]interface{}, info graphql.ResolveInfo) map[string]interface{} {
id, _ := inputMap["id"].(string)
complete, _ := inputMap["complete"].(bool)
resolvedId := relay.FromGlobalID(id)
ChangeTodoStatus(resolvedId.ID, complete)
return map[string]interface{}{
"todoId": resolvedId.ID,
}
},
})
markAllTodosMutation := relay.MutationWithClientMutationID(relay.MutationConfig{
Name: "MarkAllTodos",
InputFields: graphql.InputObjectConfigFieldMap{
"complete": &graphql.InputObjectFieldConfig{
Type: graphql.NewNonNull(graphql.Boolean),
},
},
OutputFields: graphql.Fields{
"changedTodos": &graphql.Field{
Type: graphql.NewList(todoType),
Resolve: func(p graphql.ResolveParams) interface{} {
payload, _ := p.Source.(map[string]interface{})
todoIds, _ := payload["todoIds"].([]string)
todos := []*Todo{}
for _, todoId := range todoIds {
todo := GetTodo(todoId)
if todo != nil {
todos = append(todos, todo)
}
}
return todos
},
},
"viewer": &graphql.Field{
Type: userType,
Resolve: func(p graphql.ResolveParams) interface{} {
return GetViewer()
},
},
},
MutateAndGetPayload: func(inputMap map[string]interface{}, info graphql.ResolveInfo) map[string]interface{} {
complete, _ := inputMap["complete"].(bool)
todoIds := MarkAllTodos(complete)
return map[string]interface{}{
"todoIds": todoIds,
}
},
})
removeCompletedTodosMutation := relay.MutationWithClientMutationID(relay.MutationConfig{
Name: "RemoveCompletedTodos",
OutputFields: graphql.Fields{
"deletedTodoIds": &graphql.Field{
Type: graphql.NewList(graphql.String),
Resolve: func(p graphql.ResolveParams) interface{} {
payload, _ := p.Source.(map[string]interface{})
return payload["todoIds"]
},
},
"viewer": &graphql.Field{
Type: userType,
Resolve: func(p graphql.ResolveParams) interface{} {
return GetViewer()
},
},
},
MutateAndGetPayload: func(inputMap map[string]interface{}, info graphql.ResolveInfo) map[string]interface{} {
todoIds := RemoveCompletedTodos()
return map[string]interface{}{
"todoIds": todoIds,
}
},
})
removeTodoMutation := relay.MutationWithClientMutationID(relay.MutationConfig{
Name: "RemoveTodo",
InputFields: graphql.InputObjectConfigFieldMap{
"id": &graphql.InputObjectFieldConfig{
Type: graphql.NewNonNull(graphql.ID),
},
},
OutputFields: graphql.Fields{
"deletedTodoId": &graphql.Field{
Type: graphql.ID,
Resolve: func(p graphql.ResolveParams) interface{} {
payload, _ := p.Source.(map[string]interface{})
return payload["todoId"]
},
},
"viewer": &graphql.Field{
Type: userType,
Resolve: func(p graphql.ResolveParams) interface{} {
return GetViewer()
},
},
},
MutateAndGetPayload: func(inputMap map[string]interface{}, info graphql.ResolveInfo) map[string]interface{} {
id, _ := inputMap["id"].(string)
resolvedId := relay.FromGlobalID(id)
RemoveTodo(resolvedId.ID)
return map[string]interface{}{
"todoId": resolvedId.ID,
}
},
})
renameTodoMutation := relay.MutationWithClientMutationID(relay.MutationConfig{
Name: "RenameTodo",
InputFields: graphql.InputObjectConfigFieldMap{
"id": &graphql.InputObjectFieldConfig{
Type: graphql.NewNonNull(graphql.ID),
},
"text": &graphql.InputObjectFieldConfig{
Type: graphql.NewNonNull(graphql.String),
},
},
OutputFields: graphql.Fields{
"todo": &graphql.Field{
Type: todoType,
Resolve: func(p graphql.ResolveParams) interface{} {
payload, _ := p.Source.(map[string]interface{})
todoId, _ := payload["todoId"].(string)
return GetTodo(todoId)
},
},
"viewer": &graphql.Field{
Type: userType,
Resolve: func(p graphql.ResolveParams) interface{} {
return GetViewer()
},
},
},
MutateAndGetPayload: func(inputMap map[string]interface{}, info graphql.ResolveInfo) map[string]interface{} {
id, _ := inputMap["id"].(string)
resolvedId := relay.FromGlobalID(id)
text, _ := inputMap["text"].(string)
RenameTodo(resolvedId.ID, text)
return map[string]interface{}{
"todoId": resolvedId.ID,
}
},
})
mutationType := graphql.NewObject(graphql.ObjectConfig{
Name: "Mutation",
Fields: graphql.Fields{
"addTodo": addTodoMutation,
"changeTodoStatus": changeTodoStatusMutation,
"markAllTodos": markAllTodosMutation,
"removeCompletedTodos": removeCompletedTodosMutation,
"removeTodo": removeTodoMutation,
"renameTodo": renameTodoMutation,
},
})
var err error
Schema, err = graphql.NewSchema(graphql.SchemaConfig{
Query: rootType,
Mutation: mutationType,
})
if err != nil {
panic(err)
}
}
func (api *SearchAPI) Start() error {
api.Type = graphql.NewObject(graphql.ObjectConfig{
Name: "Search",
Fields: graphql.Fields{
"id": relay.GlobalIDField("Search", func(obj interface{}, info graphql.ResolveInfo, ctx context.Context) (string, error) {
se, ok := obj.(*Search)
if !ok {
return "", fmt.Errorf("Search's GlobalIDField() was called with a non-Search")
}
cid, err := se.ClientID()
if err != nil {
return "", fmt.Errorf("Failed to create a ClientID for %v", se)
}
return cid, nil
}),
"createdAt": &graphql.Field{
Description: "When the search was first saved.",
Type: graphql.String,
},
"name": &graphql.Field{
Description: "The name to display for the search.",
Type: graphql.String,
},
// TODO#Perf: Consider storing the search results on the context or ResolveInfo to avoid computing them twice (numResults and results).
"numResults": &graphql.Field{
Description: "The total number of results that match the query",
Type: graphql.Int,
Resolve: func(p graphql.ResolveParams) (interface{}, error) {
span := trace.FromContext(p.Context).NewChild("trythings.searchAPI.numResults")
defer span.Finish()
se, ok := p.Source.(*Search)
if !ok {
return nil, errors.New("expected search source")
}
sp, err := api.SearchService.Space(p.Context, se)
if err != nil {
return nil, err
}
// TODO#Perf: Run a count query instead of fetching all of the matches.
ts, err := api.TaskService.Search(p.Context, sp, se.Query)
if err != nil {
return nil, err
}
return len(ts), nil
},
},
"query": &graphql.Field{
Description: "The query used to search for tasks.",
Type: graphql.String,
},
"results": &graphql.Field{
Description: "The tasks that match the query",
Type: api.TaskAPI.ConnectionType,
Args: relay.ConnectionArgs,
Resolve: func(p graphql.ResolveParams) (interface{}, error) {
span := trace.FromContext(p.Context).NewChild("trythings.searchAPI.results")
defer span.Finish()
se, ok := p.Source.(*Search)
if !ok {
return nil, errors.New("expected search source")
}
sp, err := api.SearchService.Space(p.Context, se)
if err != nil {
return nil, err
}
ts, err := api.TaskService.Search(p.Context, sp, se.Query)
if err != nil {
return nil, err
}
objs := []interface{}{}
for _, t := range ts {
objs = append(objs, *t)
}
// TODO#Performance: Run a limited query instead of filtering after the query.
args := relay.NewConnectionArguments(p.Args)
return relay.ConnectionFromArray(objs, args), nil
},
},
},
Interfaces: []*graphql.Interface{
api.NodeInterface,
},
})
return nil
}
