main.go

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"sync"
	"time"
)

const URL = "http://localhost:3000/users"

func main() {
	fmt.Println("Reguler fetch")
	fetchAll()
	time.Sleep(1 * time.Second)
	fmt.Println("Fast fetch")
	fastFetchAll()
}

func fastFetchAll() {
	start := time.Now()
	var body map[string]interface{}

	request, err := http.NewRequest(http.MethodGet, URL, nil)
	if err != nil {
		fmt.Println(err)
		return
	}

	client := http.Client{}
	response, err := client.Do(request)
	if err != nil {
		fmt.Println(err)
		return
	}

	defer response.Body.Close()

	err = json.NewDecoder(response.Body).Decode(&body)
	if err != nil {
		fmt.Println(err)
		return
	}

	data, ok := body["data"]
	if !ok {
		return
	}

	users, ok := data.([]interface{})
	if !ok {
		return
	}

	cBody := make(chan map[string]interface{}, len(users))
	wg := sync.WaitGroup{}
	go func() {
		for _, v := range users {
			x := v.(map[string]interface{})
			id, ok := x["id"]
			if !ok {
				continue
			}

			wg.Add(1)
			go func() {
				cBody <- fetch(int(id.(float64)))
				wg.Done()
			}()
		}
		wg.Wait()
		close(cBody)
	}()

	for v := range cBody {
		result, err := json.Marshal(v)
		if err != nil {
			continue
		}

		fmt.Println(string(result))
	}

	elapsed := time.Since(start)
	log.Printf("Execution time: %s", elapsed)
}

func fetchAll() {
	start := time.Now()
	var body map[string]interface{}

	request, err := http.NewRequest(http.MethodGet, URL, nil)
	if err != nil {
		fmt.Println(err)
		return
	}

	client := http.Client{}
	response, err := client.Do(request)
	if err != nil {
		fmt.Println(err)
		return
	}

	defer response.Body.Close()

	err = json.NewDecoder(response.Body).Decode(&body)
	if err != nil {
		fmt.Println(err)
		return
	}

	data, ok := body["data"]
	if !ok {
		return
	}

	users, ok := data.([]interface{})
	if !ok {
		return
	}

	for _, v := range users {
		x := v.(map[string]interface{})
		id, ok := x["id"]
		if !ok {
			continue
		}

		body = fetch(int(id.(float64)))
		result, err := json.Marshal(body)
		if err != nil {
			continue
		}

		fmt.Println(string(result))
	}

	elapsed := time.Since(start)
	log.Printf("Execution time: %s", elapsed)
}

func fetch(id int) map[string]interface{} {
	var body map[string]interface{}

	request, err := http.NewRequest(http.MethodGet, fmt.Sprintf("%s/%d", URL, id), nil)
	if err != nil {
		fmt.Println(err)
		return nil
	}

	client := http.Client{}
	response, err := client.Do(request)
	if err != nil {
		fmt.Println(err)
		return nil
	}

	defer response.Body.Close()

	err = json.NewDecoder(response.Body).Decode(&body)
	if err != nil {
		fmt.Println(err)
		return nil
	}

	return body
}