Handling API's

    const reqUrl = "https://example.com";
  const requestBody = {
    a: 1,
  };

  const requestOptions = {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${apiResource.token}`,
      "Content-Type": "application/json",
      "Accept": "application/json",
    },
    body: JSON.stringify(requestBody),
  };

  const res = await fetch(`${reqUrl}/finish`, requestOptions)
  const resJson = await res.json()
  

  const token = 'b5c06574-a1e8-4ba6-8f40-62fc389ef84b'

const url = new URL('https://example.com');
url.searchParams.set('queryParam1', 'valueParam');
url.searchParams.set('queryParam2', "valueParam")

let urlencoded = new URLSearchParams();
urlencoded.append("bodyParam1", "valueParam");
urlencoded.append("bodyParam2", "valueParam");

const requestOptions = {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: urlencoded,
}

const res = fetch(url, requestOptions)
  

  const res = await fetch('https://example.com', {
  method: "PUT",
  headers: {
    Authorization: `Bearer ${token}`,
    'Content-Type': 'application/x-www-form-urlencoded',
    Accept: 'application/json',
  },
  body: new URLSearchParams({
    var1: String(data.var1),
    var2: String(data.var2),
  })
});
  

  const token = 'b5c06574-a1e8-4ba6-8f40-62fc389ef84b'

const url = new URL('https://example.com');
url.searchParams.set('queryParam1', 'valueParam');
url.searchParams.set('queryParam2', "valueParam")

const body = {
  bodyParam1: "valueParam",
  bodyParam2: "valueParam",
}

const requestOptions = {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(body),
}

const res = fetch(url, requestOptions)
  

  /**
 * Retry a function n times with exponential backoff.
 * Example: retry(exampleFunction, 3, 5, 10) will do 3 retries of exampleFunction(5, 10)
 */
async function retry<T>(fn: (...args: any[]) => Promise<T>, n: number, ...args: any[]): Promise<T> {
  for (let i = 0; i < n; i++) {
    try {
      return await fn(...args);
    } catch (e) {
      console.error(e);
      const backoff = Math.floor(Math.random() * Math.pow(2, i));
      await new Promise((resolve) => setTimeout(resolve, backoff * 1000));
    }
  }
  throw new Error("Retry limit exceeded");
}
  

  function apiResponse(status: string, message: string, data: object) {
  return { status, message, data }
}
  

  import requests

token = 'b5c06574-a1e8-4ba6-8f40-62fc389ef84b'
headers = {
    "Authentication": f"Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
}
req = requests.get(f"https://example.com", headers=headers)
if req.status_code == 200:
    req_json = req.json()
    return {
        "status": "success",
        "message": "good response",
        "data": req_json,
    }
else:
    return {
        "status": "failed",
        "message": "bad response",
        "data": {"error": req.text},
    }
  

  import requests

token = 'b5c06574-a1e8-4ba6-8f40-62fc389ef84b'
headers = {
    "Authentication": f"Bearer {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
}
body = {
    "hello": "world",
}
req = requests.post(f"https://example.com", headers=headers, json=body, params={'limit': 1})
if req.status_code == 200:
    req_json = req.json()
    return {
        "status": "success",
        "message": "good response",
        "data": req_json,
    }
else:
    return {
        "status": "success",
        "message": "good response",
        "data": {"error": req.text},
    }
  

  resp, err := http.Get(url)
if err != nil {
  fmt.Println("Error:", err)
  os.Exit(1)
}

bs := make([]byte, 99999)
rest.Body.Read(bs)
fmt.Println(string(bs))
  

  resp, err := http.Get(url)
if err != nil {
  fmt.Println("Error:", err)
  os.Exit(1)
}

io.Copy(os.Stdout, resp.Body)
  

  package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
)

type PostData struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

func makeJSONPostRequest(url, token string, data *PostData) (string, error) {
	payload, err := json.Marshal(data)
	if err != nil {
		return "", fmt.Errorf("error preparing request body: %v", err)
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payload))
	if err != nil {
		return "", fmt.Errorf("error creating new request: %v", err)
	}

	// API token authentication
	req.Header.Add("Authorization", "Bearer "+token)
	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("Accept", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return "", fmt.Errorf("error on request: %v", err)
	}
	defer resp.Body.Close()

	// Here you can add logic to handle response

	return resp.Status, nil
}

func main() {
	data := PostData{
        Key:   "ExampleKey",
        Value: "ExampleValue",
	}

	status, err := makeJSONPostRequest("https://example.com", "your-api-token", &data)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	fmt.Println("Response status:", status)
}