04 - Browser JavaScript REST API implementation

// Need to know what types a and b
function callbackFunction(a, b){
   return a + b;
}

function doOtherFunction(a, b, otherFunc){
 // We assume the other function will be passing a and b of some type here
    return otherFunc(a,b);
}

// Send only the name of the first function as an argument of the second function
let result = doOtherFunction(2, 2, callbackFunction);

myPromise
  .then(handleFulfilledA, handleRejectedA)
  .catch((err) => {
      console.error(err);
    });

...
const apiFullEndpoint = tsHost + "/" + publicApiUrl + endpoint;

await fetch(
  apiFullEndpoint, // URL
    {
      method: ‘POST’,
      headers: {
          "Accept": "application/json",
          "X-Requested-By": "ThoughtSpot",
          "Content-Type": "application/json"
         },
       credentials: "include",
       body: JSON.stringify(apiRequestObject)
    }
) .then(response =>  response.json())
  .catch(error => {
        console.error("Unable to get the" + endpoint + "response: " + error);
  });

<script type = 'module'>
    import {
        LiveboardEmbed,
        AuthType,
        init,
        prefetch,
        tokenizedFetch
    }
from 'https://cdn.jsdelivr.net/npm/@thoughtspot/visual-embed-sdk/dist/tsembed.es.js';

const apiFullEndpoint = tsHost + "/" + publicApiUrl + endpoint;

await tokenizedFetch(
  apiFullEndpoint, // URL
    {
      method: ‘POST’,
      headers: {
          "Accept": "application/json",
          "X-Requested-By": "ThoughtSpot",
          "Content-Type": "application/json"
         },
       credentials: "include",
       body: JSON.stringify(apiRequestObject)
    }
) .then(response =>  response.json())
  .catch(error => {
        console.error("Unable to get the" + endpoint + "response: " + error);
  });

</script>

async function restApiCallV2(endpoint, httpVerb, apiRequestObj){
  const tsApiVersion = '2.0';
  const baseUrl = `${tsHost}/api/rest/${tsApiVersion}/`;  // Forward ticks allow variables in strings
  const apiFullEndpoint = baseUrl + endpoint;
  console.log("Executing fetch");
  /*
  * Fetch is asynchronous and returns a Promise, which always has a .then() and .catch() method so you can chain
  * additional code to happen after the REST API call returns back.
  * Alternatively, you can use the 'async' and 'await' patterns
  * https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Asynchronous/Promises
  */

  let fetchArgs = {
          method: httpVerb.toUpperCase(),
          headers: {
              "Accept": "application/json",
              "X-Requested-By": "ThoughtSpot",
              "Content-Type": "application/json"
              },
          credentials: "include"
      }
  // Some type of request might not have a body
  if (apiRequestObj !== null){
      fetchArgs['body'] = JSON.stringify(apiRequestObj);
  }

  // With the async modifier on the function, you add return await to the fetch() call here
  return await tokenizedFetch(
      apiFullEndpoint,
      fetchArgs
  ).then(response =>
  {
      console.log("Fetch response returned with status code " + response.status);
      // Parse 4XX or 500 HTTP status code errors from the API
      if (!response.ok) {
          console.log("HTTP response indicates an error from the API");
          throw new Error("Received HTTP response " + response.status + "with the message " + response.statusText)

          //
          // Alternatively, check for specific error codes you might expect, like a 403
          /*
          if( response.status == 403){
              // retrySSOProcess(); // Example action to take based on status
          }
          else{
              throw new Error("Received HTTP response " + response.status + "with the message " + response.statusText)
          }
          */
      }
      else {
          if( response.status === 200){
              return response.json(); // Returns the JSON of the response
          }
          else if (response.status === 204){
              return true;  // 204 is success without any body
          }

      }
  }).catch(error =>
  {
      console.error("Unable to get the " + endpoint + " response: " + error);
  });
}

/*
* Wrapper function for calling /metadata/search with any request
*/
async function callMetadataSearchApi(searchRequestObject){
    let endpoint = 'metadata/search';
    let verb = 'POST';

    return await restApiCallV2(endpoint, verb, searchRequestObject).then(
        response => {
            // Additional logging to the console
            console.log("API response:", response);
            console.log(response);
            return response;
        }
    );
}

// Here we actually CALL the functions to make the request
function makeSearchRequest(){
   // Copy the request directly from the REST API Playground, substituting in any variables you need
   const apiRequestObject = {
       "metadata": [
           {
               "name_pattern": "(Sample)",
               "type": "LIVEBOARD"
           },
           {
               "name_pattern": "(Sample)",
               "type": "ANSWER"
           }
           ],
       'record_offset': 0,
       'record_size': 100000
   }


   let results = callMetadataSearchApi(apiRequestObject);
   console.log("Final results from the callMetadataSearchApi function: ");
   console.log(results);
}