Add retry wrapper to all discord endpoints (#1857)

Author: garrrikkotua

services/libs/integrations/src/integrations/discord/api/getChannel.ts

@@ -2,6 +2,7 @@ import axios, { AxiosRequestConfig } from 'axios'
 import { handleDiscordError } from './errorHandler'
 import { DiscordApiChannel } from '../types'
 import { IProcessStreamContext } from '../../../types'
+import { retryWrapper } from './handleRateLimit'
 
 export const getChannel = async (
   channelId: string,
@@ -16,13 +17,15 @@ export const getChannel = async (
     },
   }
 
-  try {
-    const response = await axios(config)
-    return response.data
-  } catch (err) {
-    const newErr = handleDiscordError(err, config, { channelId }, ctx)
-    if (newErr) {
-      throw newErr
+  return await retryWrapper(3, async () => {
+    try {
+      const response = await axios(config)
+      return response.data
+    } catch (err) {
+      const newErr = handleDiscordError(err, config, { channelId }, ctx)
+      if (newErr) {
+        throw newErr
+      }
     }
-  }
+  })
 }

services/libs/integrations/src/integrations/discord/api/getChannels.ts

@@ -4,6 +4,7 @@ import { DiscordApiChannel, DiscordGetChannelsInput, DiscordGetMessagesInput } f
 import getMessages from './getMessages'
 import { IProcessStreamContext } from '../../../types'
 import { handleDiscordError } from './errorHandler'
+import { retryWrapper } from './handleRateLimit'
 
 /**
  * Try if a channel is readable
@@ -40,43 +41,45 @@ async function getChannels(
     },
   }
 
-  try {
-    const response = await axios(config)
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const result: any = response.data
-
-    if (tryChannels) {
+  return await retryWrapper(3, async () => {
+    try {
+      const response = await axios(config)
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const out: any[] = []
-      for (const channel of result) {
-        const limit = await tryChannel(
-          {
-            channelId: channel.id,
-            token: input.token,
-            perPage: 1,
-            page: undefined,
-          },
-          ctx,
-        )
-        if (limit) {
-          out.push(channel)
-          if (limit <= 1 && limit !== false) {
-            await timeout(5 * 1000)
+      const result: any = response.data
+
+      if (tryChannels) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const out: any[] = []
+        for (const channel of result) {
+          const limit = await tryChannel(
+            {
+              channelId: channel.id,
+              token: input.token,
+              perPage: 1,
+              page: undefined,
+            },
+            ctx,
+          )
+          if (limit) {
+            out.push(channel)
+            if (limit <= 1 && limit !== false) {
+              await timeout(5 * 1000)
+            }
           }
         }
+        return out
       }
-      return out
-    }
 
-    return result
-  } catch (err) {
-    const newErr = handleDiscordError(err, config, { input }, ctx)
-    if (newErr) {
-      throw newErr
-    } else {
-      return []
+      return result
+    } catch (err) {
+      const newErr = handleDiscordError(err, config, { input }, ctx)
+      if (newErr) {
+        throw newErr
+      } else {
+        return []
+      }
     }
-  }
+  })
 }
 
 export default getChannels

services/libs/integrations/src/integrations/discord/api/getMember.ts

@@ -2,6 +2,7 @@ import axios, { AxiosRequestConfig } from 'axios'
 import { DiscordApiMember } from '../types'
 import { handleDiscordError } from './errorHandler'
 import { IProcessStreamContext } from '../../../types'
+import { retryWrapper } from './handleRateLimit'
 
 export const getMember = async (
   guildId: string,
@@ -18,13 +19,15 @@ export const getMember = async (
     },
   }
 
-  try {
-    const response = await axios(config)
-    return response.data
-  } catch (err) {
-    const newErr = handleDiscordError(err, config, { guildId, userId }, ctx)
-    if (newErr) {
-      throw newErr
+  return await retryWrapper(3, async () => {
+    try {
+      const response = await axios(config)
+      return response.data
+    } catch (err) {
+      const newErr = handleDiscordError(err, config, { guildId, userId }, ctx)
+      if (newErr) {
+        throw newErr
+      }
     }
-  }
+  })
 }

services/libs/integrations/src/integrations/discord/api/getMembers.ts

@@ -2,6 +2,7 @@ import axios from 'axios'
 import { DiscordApiMember, DiscordGetMembersInput, DiscordGetMembersOutput } from '../types'
 import { IProcessStreamContext } from '../../../types'
 import { handleDiscordError } from './errorHandler'
+import { retryWrapper } from './handleRateLimit'
 
 async function getMembers(
   input: DiscordGetMembersInput,
@@ -19,24 +20,27 @@ async function getMembers(
       Authorization: input.token,
     },
   }
-  try {
-    const response = await axios(config)
-    const records: DiscordApiMember[] = response.data
-    const limit = parseInt(response.headers['x-ratelimit-remaining'], 10)
-    const timeUntilReset = parseInt(response.headers['x-ratelimit-reset-after'], 10)
-    const nextPage = records.length > 0 ? (records[records.length - 1].user.id as string) : ''
-    return {
-      records,
-      nextPage,
-      limit,
-      timeUntilReset,
-    }
-  } catch (err) {
-    const newErr = handleDiscordError(err, config, { input }, ctx)
-    if (newErr) {
-      throw newErr
+
+  return await retryWrapper(3, async () => {
+    try {
+      const response = await axios(config)
+      const records: DiscordApiMember[] = response.data
+      const limit = parseInt(response.headers['x-ratelimit-remaining'], 10)
+      const timeUntilReset = parseInt(response.headers['x-ratelimit-reset-after'], 10)
+      const nextPage = records.length > 0 ? (records[records.length - 1].user.id as string) : ''
+      return {
+        records,
+        nextPage,
+        limit,
+        timeUntilReset,
+      }
+    } catch (err) {
+      const newErr = handleDiscordError(err, config, { input }, ctx)
+      if (newErr) {
+        throw newErr
+      }
     }
-  }
+  })
 }
 
 export default getMembers

services/libs/integrations/src/integrations/discord/api/getMessage.ts

@@ -1,6 +1,7 @@
 import axios, { AxiosRequestConfig } from 'axios'
 import { handleDiscordError } from './errorHandler'
 import { IProcessStreamContext } from '../../../types'
+import { retryWrapper } from './handleRateLimit'
 
 export const getMessage = async (
   channelId: string,
@@ -16,45 +17,47 @@ export const getMessage = async (
     },
   }
 
-  try {
-    const response = await axios(config)
-    return response.data
-  } catch (err) {
-    if (
-      err.response &&
-      err.response.status === 404 &&
-      err.response.data &&
-      err.response.data.message === 'Unknown Channel' &&
-      err.response.data.code === 10003
-    ) {
-      ctx.log.warn(
-        { channelId, messageId },
-        'Discord API returned Unknown Channel error when fetching message during webhook processing, skipping message.',
-      )
-      return null
-    } else if (
-      err.response &&
-      err.response.status === 404 &&
-      err.response.data &&
-      err.response.data.message === 'Unknown Message' &&
-      err.response.data.code === 10008
-    ) {
-      ctx.log.warn(
-        { channelId, messageId },
-        'Discord API returned Unknown Message error when fetching message during webhook processing, skipping message.',
-      )
-      return null
-    } else if (err.response && err.response.status === 404) {
-      ctx.log.warn(
-        { channelId, messageId },
-        'Discord API returned 404 error when fetching message during webhook processing, skipping message.',
-      )
-      return null
-    } else {
-      const newErr = handleDiscordError(err, config, { channelId, messageId }, ctx)
-      if (newErr) {
-        throw newErr
+  return await retryWrapper(3, async () => {
+    try {
+      const response = await axios(config)
+      return response.data
+    } catch (err) {
+      if (
+        err.response &&
+        err.response.status === 404 &&
+        err.response.data &&
+        err.response.data.message === 'Unknown Channel' &&
+        err.response.data.code === 10003
+      ) {
+        ctx.log.warn(
+          { channelId, messageId },
+          'Discord API returned Unknown Channel error when fetching message during webhook processing, skipping message.',
+        )
+        return null
+      } else if (
+        err.response &&
+        err.response.status === 404 &&
+        err.response.data &&
+        err.response.data.message === 'Unknown Message' &&
+        err.response.data.code === 10008
+      ) {
+        ctx.log.warn(
+          { channelId, messageId },
+          'Discord API returned Unknown Message error when fetching message during webhook processing, skipping message.',
+        )
+        return null
+      } else if (err.response && err.response.status === 404) {
+        ctx.log.warn(
+          { channelId, messageId },
+          'Discord API returned 404 error when fetching message during webhook processing, skipping message.',
+        )
+        return null
+      } else {
+        const newErr = handleDiscordError(err, config, { channelId, messageId }, ctx)
+        if (newErr) {
+          throw newErr
+        }
       }
     }
-  }
+  })
 }

services/libs/integrations/src/integrations/discord/api/getMessages.ts

@@ -2,6 +2,7 @@ import axios from 'axios'
 import { DiscordApiMessage, DiscordParsedReponse, DiscordGetMessagesInput } from '../types'
 import { IProcessStreamContext } from '../../../types'
 import { handleDiscordError } from './errorHandler'
+import { retryWrapper } from './handleRateLimit'
 
 async function getMessages(
   input: DiscordGetMessagesInput,
@@ -21,33 +22,35 @@ async function getMessages(
     },
   }
 
-  try {
-    const response = await axios(config)
-    const records: DiscordApiMessage[] = response.data
+  return await retryWrapper(3, async () => {
+    try {
+      const response = await axios(config)
+      const records: DiscordApiMessage[] = response.data
 
-    const limit = parseInt(response.headers['x-ratelimit-remaining'], 10)
-    const timeUntilReset = parseInt(response.headers['x-ratelimit-reset-after'], 10)
-    const nextPage = records.length > 0 ? records[records.length - 1].id : ''
-    return {
-      records,
-      nextPage,
-      limit,
-      timeUntilReset,
-    }
-  } catch (err) {
-    if (!showErrors) {
+      const limit = parseInt(response.headers['x-ratelimit-remaining'], 10)
+      const timeUntilReset = parseInt(response.headers['x-ratelimit-reset-after'], 10)
+      const nextPage = records.length > 0 ? records[records.length - 1].id : ''
       return {
-        records: [],
-        nextPage: '',
-        limit: 0,
-        timeUntilReset: 0,
+        records,
+        nextPage,
+        limit,
+        timeUntilReset,
+      }
+    } catch (err) {
+      if (!showErrors) {
+        return {
+          records: [],
+          nextPage: '',
+          limit: 0,
+          timeUntilReset: 0,
+        }
+      }
+      const newErr = handleDiscordError(err, config, { input }, ctx)
+      if (newErr) {
+        throw newErr
       }
     }
-    const newErr = handleDiscordError(err, config, { input }, ctx)
-    if (newErr) {
-      throw newErr
-    }
-  }
+  })
 }
 
 export default getMessages

services/libs/integrations/src/integrations/discord/api/getThreads.ts

@@ -2,6 +2,7 @@ import axios from 'axios'
 import { DiscordApiChannel, DiscordGetChannelsInput } from '../types'
 import { IProcessStreamContext } from '../../../types'
 import { handleDiscordError } from './errorHandler'
+import { retryWrapper } from './handleRateLimit'
 
 async function getThreads(
   input: DiscordGetChannelsInput,
@@ -14,15 +15,18 @@ async function getThreads(
       Authorization: input.token,
     },
   }
-  try {
-    const response = await axios(config)
-    return response.data.threads
-  } catch (err) {
-    const newErr = handleDiscordError(err, config, { input }, ctx)
-    if (newErr) {
-      throw newErr
+
+  return await retryWrapper(3, async () => {
+    try {
+      const response = await axios(config)
+      return response.data.threads
+    } catch (err) {
+      const newErr = handleDiscordError(err, config, { input }, ctx)
+      if (newErr) {
+        throw newErr
+      }
     }
-  }
+  })
 }
 
 export default getThreads