paralin · July 3, 2018 19:28 · paralin · Feb 6, 2017
diff --git a/1_GraphQL.md b/1_GraphQL.md
diff --git a/2_Neelance_GraphQL-Go.md b/2_Neelance_GraphQL-Go.md
diff --git a/3_example_resolvers.go b/3_example_resolvers.go
 schema := `
 type Character {
  name: String
  description: String
 }
 type RootQuery {
  hero(episode: String): Character
  heros(episode: String): [Character]
 }
 `

 type ExampleResolver struct {}

 // Current kinds of resolvers (in master today):
 basicQuery := `
 query testQuery($episode: String) {
  heros(episode:$episode) {
  }
 }
 `

 liveQuery := `
 query liveQuery($episode: String) {
 	heros(episode: $episode) @stream {
 		name @live
 		description @defer
 	}
 }
 `

 func (e *ExampleResolver) Hero(args *struct{ Episode string }) *CharacterResolver {
 	return &CharacterResolver{}
 }

 func (e *ExampleResolver) Heros(ctx context.Context, args *struct{ Episode string }) *[]*CharacterResolver {
 	res := []*CharacterResolver{
 		&CharacterResolver{},
 		&CharacterResolver{},
 	}
 	return &res
 }

 // Proposed "live" resolvers
 type CharacterResolver struct {}

 // This resolver allows the character's name to change over time.
 func (r *CharacterResolver) Name(ctx context.Context) <-chan *string {
 	ch := make(chan *string, 10)
 	
 	go func() {
 		defer func() {
 			close(ch)
 		}()
 		done := ctx.Done()
 		
 		value1 := "Tom"
 		value2 := "Jerry"
 		ch <- &value1
 		select {
 		case <-time.After(time.Duration(1)*time.Second):
 		case <-done: // If we are not doing a live query, context will be cancelled immediately after first value.
 			return
 		}
 		ch <- &value2
 	}()
 	
 	return ch
 }

 // This resolver takes some time to resolve the character's description.
 func (r *CharacterResolver) Description(ctx context.Context) *string {
 	done := ctx.Done()
 	
 	select {
 	case <-time.After(time.Duration(500)*time.Millisecond):
 	case <-done: // If we are not doing a live query, context will be cancelled immediately after first value.
 		return nil
 	}
 		
 	value1 := "Tom was a rather foolish cat who could never catch any mice."
 	return &value1
 }

 // This resolver returns heros over time if @stream is specified. Otherwise, graphql-go will build an array with all the results.
 // NOTE: you could also return a channel of interface{} if you wanted to potentially return an error.
 func (e *ExampleResolver) Heros(ctx context.Context, args *struct{ Episode string }) <-chan *CharacterResolver {
 	ch := make(chan *CharacterResolver, 2)
 	
 	go func() {
 		defer func(){
 			close(ch)
 		}()
 		
 		// Wrap these in select{} if we were actually doing any real work.
 		ch <- &CharacterResolver{}
 		ch <- &CharacterResolver{}
 	}()
 	
 	return ch
 }
diff --git a/4_Example_Notes.md b/4_Example_Notes.md
diff --git a/5_Examples.md b/5_Examples.md
	schema := `
	type Character {
	name: String
	description: String
	}
	type RootQuery {
	hero(episode: String): Character
	heros(episode: String): [Character]
	}
	`

	type ExampleResolver struct {}

	// Current kinds of resolvers (in master today):
	basicQuery := `
	query testQuery($episode: String) {
	heros(episode:$episode) {
	}
	}
	`

	liveQuery := `
	query liveQuery($episode: String) {
	heros(episode: $episode) @stream {
	name @live
	description @defer
	}
	}
	`

	func (e ExampleResolver) Hero(args struct{ Episode string }) *CharacterResolver {
	return &CharacterResolver{}
	}

	func (e ExampleResolver) Heros(ctx context.Context, args struct{ Episode string }) []CharacterResolver {
	res := []*CharacterResolver{
	&CharacterResolver{},
	&CharacterResolver{},
	}
	return &res
	}

	// Proposed "live" resolvers
	type CharacterResolver struct {}

	// This resolver allows the character's name to change over time.
	func (r CharacterResolver) Name(ctx context.Context) <-chan string {
	ch := make(chan *string, 10)

	go func() {
	defer func() {
	close(ch)
	}()
	done := ctx.Done()

	value1 := "Tom"
	value2 := "Jerry"
	ch <- &value1
	select {
	case <-time.After(time.Duration(1)*time.Second):
	case <-done: // If we are not doing a live query, context will be cancelled immediately after first value.
	return
	}
	ch <- &value2
	}()

	return ch
	}

	// This resolver takes some time to resolve the character's description.
	func (r CharacterResolver) Description(ctx context.Context) string {
	done := ctx.Done()

	select {
	case <-time.After(time.Duration(500)*time.Millisecond):
	case <-done: // If we are not doing a live query, context will be cancelled immediately after first value.
	return nil
	}

	value1 := "Tom was a rather foolish cat who could never catch any mice."
	return &value1
	}

	// This resolver returns heros over time if @stream is specified. Otherwise, graphql-go will build an array with all the results.
	// NOTE: you could also return a channel of interface{} if you wanted to potentially return an error.
	func (e ExampleResolver) Heros(ctx context.Context, args struct{ Episode string }) <-chan *CharacterResolver {
	ch := make(chan *CharacterResolver, 2)

	go func() {
	defer func(){
	close(ch)
	}()

	// Wrap these in select{} if we were actually doing any real work.
	ch <- &CharacterResolver{}
	ch <- &CharacterResolver{}
	}()

	return ch
	}