Make a request to an external API

1
const axios = require('axios');
2

3
exports.handler = async (context, event, callback) => {
4
  // Create a new voice response object
5
  const twiml = new Twilio.twiml.VoiceResponse();
6

7
  try {
8
    // Open APIs From Space: http://open-notify.org
9
    // Number of people in space
10
    const response = await axios.get(`http://api.open-notify.org/astros.json`);
11
    const { number, people } = response.data;
12

13
    const names = people.map((astronaut) => astronaut.name).sort();
14
    // Create a list formatter to join the names with commas and 'and'
15
    // so that the played speech sounds more natural
16
    const listFormatter = new Intl.ListFormat('en');
17

18
    twiml.say(`There are ${number} people in space.`);
19
    twiml.pause({ length: 1 });
20
    twiml.say(`Their names are: ${listFormatter.format(names)}`);
21
    // Return the final TwiML as the second argument to `callback`
22
    // This will render the response as XML in reply to the webhook request
23
    // and result in the message being played back to the user
24
    return callback(null, twiml);
25
  } catch (error) {
26
    // In the event of an error, return a 500 error and the error message
27
    console.error(error);
28
    return callback(error);
29
  }
30
};

1
const axios = require('axios');
2
const qs = require('qs');
3

4
exports.handler = async (context, event, callback) => {
5
  // Create a new voice response object
6
  const twiml = new Twilio.twiml.VoiceResponse();
7
  // A pre-initialized Twilio client is available from the `context` object
8
  const twilioClient = context.getTwilioClient();
9

10
  try {
11
    // Open APIs From Space: http://open-notify.org
12
    // Number of people in space
13
    const response = await axios.get(`http://api.open-notify.org/astros.json`);
14
    const { number, people } = response.data;
15

16
    const names = people.map((astronaut) => astronaut.name).sort();
17

18
    // Select a random astronaut
19
    const astronautName = names[Math.floor(Math.random() * names.length)];
20
    // Search Wikipedia for any article's about the astronaut
21
    const { data: wikipediaResult } = await axios.get(
22
      `https://en.wikipedia.org/w/api.php?${qs.stringify({
23
        origin: '*',
24
        action: 'opensearch',
25
        search: astronautName,
26
      })}`
27
    );
28
    // Attempt to select the first relevant article from the nested result
29
    const article = wikipediaResult[3] ? wikipediaResult[3][0] : undefined;
30
    // Create a list formatter to join the names with commas and 'and'
31
    // so that the played speech sounds more natural
32
    const listFormatter = new Intl.ListFormat('en');
33

34
    twiml.say(`There are ${number} people in space.`);
35
    twiml.pause({ length: 1 });
36
    twiml.say(`Their names are: ${listFormatter.format(names)}`);
37
    // If there's a defined article for the astronaut, message the link to the user
38
    // and tell them they've been sent a message
39
    if (article) {
40
      // Use `messages.create` to send a text message to the user that
41
      // is separate from this call and includes the article
42
      await twilioClient.messages.create({
43
        to: event.From,
44
        from: context.TWILIO_PHONE_NUMBER,
45
        body: `Learn more about ${astronautName} on Wikipedia at: ${article}`,
46
      });
47

48
      twiml.pause({ length: 1 });
49
      twiml.say(
50
        `We've just sent you a message with a Wikipedia article about
51
         ${astronautName}, enjoy!`
52
      );
53
    }
54

55
    // Return the final TwiML as the second argument to `callback`
56
    // This will render the response as XML in reply to the webhook request
57
    // and result in the message being played back to the user
58
    return callback(null, twiml);
59
  } catch (error) {
60
    // In the event of an error, return a 500 error and the error message
61
    console.error(error);
62
    return callback(error);
63
  }
64
};

1
const axios = require('axios');
2
const qs = require('qs');
3

4
exports.handler = async (context, event, callback) => {
5
  // Create a new voice response object
6
  const twiml = new Twilio.twiml.VoiceResponse();
7

8
  try {
9
    // Open APIs From Space: http://open-notify.org
10
    const openNotifyUri = 'http://api.open-notify.org';
11
    // Create a promise for each API call which can be made
12
    // independently of each other
13

14
    // Number of people in space
15
    const getAstronauts = axios.get(`${openNotifyUri}/astros.json`);
16
    // The current position of the ISS
17
    const getIss = axios.get(`${openNotifyUri}/iss-now.json`);
18

19
    // Wait for both requests to be completed in parallel instead of sequentially
20
    const [astronauts, iss] = await Promise.all([getAstronauts, getIss]);
21

22
    const { number, people } = astronauts.data;
23
    const { latitude, longitude } = iss.data.iss_position;
24

25
    const names = people.map((astronaut) => astronaut.name).sort();
26

27
    // We can use reverse geocoding to convert the latitude and longitude
28
    // of the ISS to a human-readable location. We'll use positionstack.com
29
    // since they provide a free API.
30
    // Be sure to set your positionstack API key as an environment variable!
31
    const { data: issLocation } = await axios.get(
32
      `http://api.positionstack.com/v1/reverse?${qs.stringify({
33
        access_key: context.POSITIONSTACK_API_KEY,
34
        query: `${latitude},${longitude}`,
35
      })}`
36
    );
37

38
    const { label: location } = issLocation.data[0] || 'an unknown location';
39

40
    // Create a list formatter to join the names with commas and 'and'
41
    // so that the played speech sounds more natural
42
    const listFormatter = new Intl.ListFormat('en');
43

44
    twiml.say(`There are ${number} people in space.`);
45
    twiml.pause({ length: 1 });
46
    twiml.say(`Their names are: ${listFormatter.format(names)}`);
47
    twiml.pause({ length: 1 });
48
    twiml.say(
49
      `Also, the International Space Station is currently above ${location}`
50
    );
51
    // Return the final TwiML as the second argument to `callback`
52
    // This will render the response as XML in reply to the webhook request
53
    // and result in the message being played back to the user
54
    return callback(null, twiml);
55
  } catch (error) {
56
    // In the event of an error, return a 500 error and the error message
57
    console.error(error);
58
    return callback(error);
59
  }
60
};

1
const axios = require('axios');
2

3
exports.handler = async (context, event, callback) => {
4
  // Create a new message response object
5
  const twiml = new Twilio.twiml.MessagingResponse();
6

7
  // Just for this example, we'll use the first digit of the incoming phone
8
  // number to identify the call. You'll want to use a more robust mechanism
9
  // for your own Functions, such as the full phone number.
10
  const postId = event.From[1];
11

12
  // Since we're making multiple requests, we'll create an instance of axios
13
  // that includes our API's base URL and any custom headers we might want to
14
  // send with each request. This will simplify the GET and POST request paths.
15
  // JSONPlaceholder is a fake REST API that you can use for testing and prototyping
16
  const instance = axios.create({
17
    baseURL: 'https://jsonplaceholder.typicode.com',
18
    headers: { 'X-Custom-Header': 'Twilio' },
19
  });
20

21
  try {
22
    // Get the post based on the derived postId
23
    // If the postId was 1, this is effectively making a GET request to:
24
    // https://jsonplaceholder.typicode.com/posts/1
25
    const { data: post } = await instance.get(`/posts/${postId}`);
26

27
    const newCount = (post.messageCount || 0) + 1;
28

29
    // Use a POST request to "save" the update to the API
30
    // In this case, we're merging the new count and message into the
31
    // existing post object.
32
    const update = await instance.post('/posts/', {
33
      ...post,
34
      messageCount: newCount,
35
      latestMessage: event.Body,
36
    });
37

38
    console.log(update.data);
39

40
    // Add a message to the response to let the user know that everything worked
41
    twiml.message(
42
      `Message received! This was message ${newCount} from your phone number. 🎉`
43
    );
44
    return callback(null, twiml);
45
  } catch (error) {
46
    // As always with async functions, you need to be sure to handle errors
47
    console.error(error);
48
    // Add a message to the response to let the user know that something went wrong
49
    twiml.message(`We received your message, but something went wrong 😭`);
50
    return callback(error);
51
  }
52
};

1
const axios = require('axios');
2
const qs = require('qs');
3

4
exports.handler = async (context, event, callback) => {
5
  // Create a new message response object
6
  const twiml = new Twilio.twiml.MessagingResponse();
7

8
  // Just for this example, we'll use the first digit of the incoming phone
9
  // number to identify the call. You'll want to use a more robust mechanism
10
  // for your own Functions, such as the full phone number.
11
  const postId = event.From[1];
12

13
  // Since we're making multiple requests, we'll create an instance of axios
14
  // that includes our API's base URL and any custom headers we might want to
15
  // send with each request. This will simply be our GET and POST request paths.
16
  // JSONPlaceholder is a fake REST API that you can use for testing and prototyping
17
  const instance = axios.create({
18
    baseURL: 'https://jsonplaceholder.typicode.com',
19
    headers: { 'X-Custom-Header': 'Twilio' },
20
  });
21

22
  try {
23
    // Get the post based on the derived postId
24
    // If the postId was 1, this is effectively making a GET request to:
25
    // https://jsonplaceholder.typicode.com/posts/1
26
    const { data: post } = await instance.get(`/posts/${postId}`);
27

28
    const newCount = (post.messageCount || 0) + 1;
29

30
    // Like before, we're merging the new count and message into the
31
    // existing post object
32
    // In order to send this data in the application/x-www-form-urlencoded
33
    // format, the payload must be encoded via a utility such as qs
34
    const data = qs.stringify({
35
      ...post,
36
      messageCount: newCount,
37
      latestMessage: event.Body,
38
    });
39

40
    // Use a POST request to "save" the update to the API
41
    const update = await instance.post('/posts/', data);
42

43
    console.log(update.data);
44

45
    // Add a message to the response to let the user know that everything worked
46
    twiml.message(
47
      `Message received! This was message ${newCount} from your phone number. 🎉`
48
    );
49
    return callback(null, twiml);
50
  } catch (error) {
51
    // As always with async functions, you need to be sure to handle errors
52
    console.error(error);
53
    // Add a message to the response to let the user know that something went wrong
54
    twiml.message(`We received your message, but something went wrong 😭`);
55
    return callback(error);
56
  }
57
};

1
const axios = require('axios');
2

3
const getAstronauts = () => axios.get('https://unstable-5604.twil.io/astros');
4

5
exports.handler = async (context, event, callback) => {
6
  // We need to asynchronously import p-retry since it is an ESM module
7
  const { default: pRetry } = await import('p-retry');
8
  // Create a new voice response object
9
  const twiml = new Twilio.twiml.VoiceResponse();
10

11
  try {
12
    let attempts = 1;
13
    // Open APIs From Space: http://open-notify.org
14
    // Number of people in space
15
    const response = await pRetry(getAstronauts, {
16
      retries: 3,
17
      onFailedAttempt: ({ attemptNumber, retriesLeft }) => {
18
        attempts = attemptNumber;
19
        console.log(
20
          `Attempt ${attemptNumber} failed. There are ${retriesLeft} retries left.`
21
        );
22
        // 1st request => "Attempt 1 failed. There are 3 retries left."
23
        // 2nd request => "Attempt 2 failed. There are 2 retries left."
24
        // …
25
      },
26
    });
27
    const { number, people } = response.data;
28

29
    const names = people.map((astronaut) => astronaut.name).sort();
30
    // Create a list formatter to join the names with commas and 'and'
31
    // so that the played speech sounds more natural
32
    const listFormatter = new Intl.ListFormat('en');
33

34
    twiml.say(`There are ${number} people in space.`);
35
    twiml.pause({ length: 1 });
36
    twiml.say(`Their names are: ${listFormatter.format(names)}`);
37
    // If retries were necessary, add that information to the response
38
    if (attempts > 1) {
39
      twiml.pause({ length: 1 });
40
      twiml.say(`It took ${attempts} attempts to retrieve this information.`);
41
    }
42
    // Return the final TwiML as the second argument to `callback`
43
    // This will render the response as XML in reply to the webhook request
44
    // and result in the message being played back to the user
45
    return callback(null, twiml);
46
  } catch (error) {
47
    // In the event of an error, return a 500 error and the error message
48
    console.error(error);
49
    return callback(error);
50
  }
51
};

1
const axios = require('axios');
2
const qs = require('qs');
3

4
// The root URL for an API which is known to fail on occasion
5
const unstableSpaceUri = 'https://unstable-5604.twil.io';
6
// We'll declare these functions outside of the handler since they have no
7
// dependencies on other values, and this will tidy up our pRetry calls.
8
const astronautRequest = () => axios.get(`${unstableSpaceUri}/astros`);
9
const issRequest = () => axios.get(`${unstableSpaceUri}/iss`);
10
// Use a common object for retry configuration to DRY up our code :)
11
const retryConfig = (reqName) => ({
12
  retries: 3,
13
  onFailedAttempt: () => console.log(`Retrying ${reqName}...`),
14
});
15

16
exports.handler = async (context, event, callback) => {
17
  // We need to asynchronously import p-retry since it is an ESM module
18
  const { default: pRetry } = await import('p-retry');
19
  // Create a new voice response object
20
  const twiml = new Twilio.twiml.VoiceResponse();
21

22
  try {
23
    // Create a promise with retry for each API call that can be made
24
    // independently of each other
25
    const getAstronauts = pRetry(astronautRequest, retryConfig('astros'));
26
    const getIss = pRetry(issRequest, retryConfig('iss'));
27
    // pRetry returns a promise, so we can still use Promise.all to await
28
    // the result of both requests in parallel with retry and backoff enabled!
29
    const [astronauts, iss] = await Promise.all([getAstronauts, getIss]);
30

31
    const { number, people } = astronauts.data;
32
    const { latitude, longitude } = iss.data.iss_position;
33

34
    const names = people.map((astronaut) => astronaut.name).sort();
35

36
    // We can use reverse geocoding to convert the latitude and longitude
37
    // of the ISS to a human-readable location. We'll use positionstack.com
38
    // since they provide a free API.
39
    // Be sure to set your positionstack API key as an environment variable!
40
    const { data: issLocation } = await pRetry(
41
      () =>
42
        axios.get(
43
          `http://api.positionstack.com/v1/reverse?${qs.stringify({
44
            access_key: context.POSITIONSTACK_API_KEY,
45
            query: `${latitude},${longitude}`,
46
          })}`
47
        ),
48
      retryConfig('iss location')
49
    );
50

51
    const { label } = issLocation.data[0] || 'an unknown location';
52

53
    // Create a list formatter to join the names with commas and 'and'
54
    // so that the played speech sounds more natural
55
    const listFormatter = new Intl.ListFormat('en');
56

57
    twiml.say(`There are ${number} people in space.`);
58
    twiml.pause({ length: 1 });
59
    twiml.say(`Their names are: ${listFormatter.format(names)}`);
60
    twiml.pause({ length: 1 });
61
    twiml.say(
62
      `Also, the International Space Station is currently above ${label}`
63
    );
64
    // Return the final TwiML as the second argument to `callback`
65
    // This will render the response as XML in reply to the webhook request
66
    // and result in the message being played back to the user
67
    return callback(null, twiml);
68
  } catch (error) {
69
    // In the event of an error, return a 500 error and the error message
70
    console.error(error);
71
    return callback(error);
72
  }
73
};