fix(proxy): modify the registration of the axios interceptors

The previous way of adding Axios interceptors added a new interceptor each time, causing lags after
a while because of all the duplicate interceptors added.

fix #1787

jellyseerr-api.yml

@@ -141,83 +141,14 @@ components:
     UserSettings:
       type: object
       properties:
-        username:
-          type: string
-          nullable: true
-          example: 'Mr User'
-        email:
-          type: string
-          example: 'user@example.com'
-        discordId:
-          type: string
-          nullable: true
-          example: '123456789'
         locale:
           type: string
-          nullable: true
-          example: 'en'
         discoverRegion:
           type: string
-          nullable: true
-          example: 'US'
-        streamingRegion:
-          type: string
-          nullable: true
-          example: 'US'
         originalLanguage:
           type: string
-          nullable: true
-          example: 'en'
-        movieQuotaLimit:
-          type: number
-          nullable: true
-          description: 'Maximum number of movie requests allowed'
-          example: 10
-        movieQuotaDays:
-          type: number
-          nullable: true
-          description: 'Time period in days for movie quota'
-          example: 30
-        tvQuotaLimit:
-          type: number
-          nullable: true
-          description: 'Maximum number of TV requests allowed'
-          example: 5
-        tvQuotaDays:
-          type: number
-          nullable: true
-          description: 'Time period in days for TV quota'
-          example: 14
-        globalMovieQuotaDays:
-          type: number
-          nullable: true
-          description: 'Global movie quota days setting'
-          example: 30
-        globalMovieQuotaLimit:
-          type: number
-          nullable: true
-          description: 'Global movie quota limit setting'
-          example: 10
-        globalTvQuotaLimit:
-          type: number
-          nullable: true
-          description: 'Global TV quota limit setting'
-          example: 5
-        globalTvQuotaDays:
-          type: number
-          nullable: true
-          description: 'Global TV quota days setting'
-          example: 14
-        watchlistSyncMovies:
-          type: boolean
-          nullable: true
-          description: 'Enable watchlist sync for movies'
-          example: true
-        watchlistSyncTv:
-          type: boolean
-          nullable: true
-          description: 'Enable watchlist sync for TV'
-          example: false
+        streamingRegion:
+          type: string
     MainSettings:
       type: object
       properties:
@@ -4538,7 +4469,11 @@ paths:
           content:
             application/json:
               schema:
-                $ref: '#/components/schemas/UserSettings'
+                type: object
+                properties:
+                  username:
+                    type: string
+                    example: 'Mr User'
     post:
       summary: Update general settings for a user
       description: Updates and returns general settings for a specific user. Requires `MANAGE_USERS` permission if editing other users.
@@ -4555,14 +4490,22 @@ paths:
         content:
           application/json:
             schema:
-              $ref: '#/components/schemas/UserSettings'
+              type: object
+              properties:
+                username:
+                  type: string
+                  nullable: true
       responses:
         '200':
           description: Updated user general settings returned
           content:
             application/json:
               schema:
-                $ref: '#/components/schemas/UserSettings'
+                type: object
+                properties:
+                  username:
+                    type: string
+                    example: 'Mr User'
   /user/{userId}/settings/password:
     get:
       summary: Get password page informatiom
@@ -6656,16 +6599,9 @@ paths:
           example: '1'
           schema:
             type: string
-        - in: query
-          name: is4k
-          description: Whether to remove from 4K service instance (true) or regular service instance (false)
-          required: false
-          example: false
-          schema:
-            type: boolean
       responses:
         '204':
-          description: Successfully removed media item
+          description: Succesfully removed media item
   /media/{mediaId}/{status}:
     post:
       summary: Update media status
@@ -7332,22 +7268,11 @@ paths:
             example: 1
       responses:
         '200':
-          description: Keyword returned (null if not found)
+          description: Keyword returned
           content:
             application/json:
               schema:
-                nullable: true
                 $ref: '#/components/schemas/Keyword'
-        '500':
-          description: Internal server error
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  message:
-                    type: string
-                    example: 'Unable to retrieve keyword data.'
   /watchproviders/regions:
     get:
       summary: Get watch provider regions

server/api/themoviedb/index.ts

@@ -1054,7 +1054,7 @@ class TheMovieDb extends ExternalAPI {
     keywordId,
   }: {
     keywordId: number;
-  }): Promise<TmdbKeyword | null> {
+  }): Promise<TmdbKeyword> {
     try {
       const data = await this.get<TmdbKeyword>(
         `/keyword/${keywordId}`,
@@ -1064,9 +1064,6 @@ class TheMovieDb extends ExternalAPI {
 
       return data;
     } catch (e) {
-      if (e.response?.status === 404) {
-        return null;
-      }
       throw new Error(`[TMDB] Failed to fetch keyword: ${e.message}`);
     }
   }

server/job/blacklistedTagsProcessor.ts

@@ -72,7 +72,6 @@ class BlacklistedTagProcessor implements RunnableScanner<StatusBase> {
     const blacklistedTagsArr = blacklistedTags.split(',');
 
     const pageLimit = settings.main.blacklistedTagsLimit;
-    const invalidKeywords = new Set<string>();
 
     if (blacklistedTags.length === 0) {
       return;
@@ -88,19 +87,6 @@ class BlacklistedTagProcessor implements RunnableScanner<StatusBase> {
 
       // Iterate for each tag
       for (const tag of blacklistedTagsArr) {
-        const keywordDetails = await tmdb.getKeywordDetails({
-          keywordId: Number(tag),
-        });
-
-        if (keywordDetails === null) {
-          logger.warn('Skipping invalid keyword in blacklisted tags', {
-            label: 'Blacklisted Tags Processor',
-            keywordId: tag,
-          });
-          invalidKeywords.add(tag);
-          continue;
-        }
-
         let queryMax = pageLimit * SortOptionsIterable.length;
         let fixedSortMode = false; // Set to true when the page limit allows for getting every page of tag
 
@@ -116,51 +102,24 @@ class BlacklistedTagProcessor implements RunnableScanner<StatusBase> {
             throw new AbortTransaction();
           }
 
-          try {
-            const response = await getDiscover({
-              page,
-              sortBy,
-              keywords: tag,
-            });
+          const response = await getDiscover({
+            page,
+            sortBy,
+            keywords: tag,
+          });
+          await this.processResults(response, tag, type, em);
+          await new Promise((res) => setTimeout(res, TMDB_API_DELAY_MS));
 
-            await this.processResults(response, tag, type, em);
-            await new Promise((res) => setTimeout(res, TMDB_API_DELAY_MS));
-
-            this.progress++;
-            if (page === 1 && response.total_pages <= queryMax) {
-              // We will finish the tag with less queries than expected, move progress accordingly
-              this.progress += queryMax - response.total_pages;
-              fixedSortMode = true;
-              queryMax = response.total_pages;
-            }
-          } catch (error) {
-            logger.error('Error processing keyword in blacklisted tags', {
-              label: 'Blacklisted Tags Processor',
-              keywordId: tag,
-              errorMessage: error.message,
-            });
+          this.progress++;
+          if (page === 1 && response.total_pages <= queryMax) {
+            // We will finish the tag with less queries than expected, move progress accordingly
+            this.progress += queryMax - response.total_pages;
+            fixedSortMode = true;
+            queryMax = response.total_pages;
           }
         }
       }
     }
-
-    if (invalidKeywords.size > 0) {
-      const currentTags = blacklistedTagsArr.filter(
-        (tag) => !invalidKeywords.has(tag)
-      );
-      const cleanedTags = currentTags.join(',');
-
-      if (cleanedTags !== blacklistedTags) {
-        settings.main.blacklistedTags = cleanedTags;
-        await settings.save();
-
-        logger.info('Cleaned up invalid keywords from settings', {
-          label: 'Blacklisted Tags Processor',
-          removedKeywords: Array.from(invalidKeywords),
-          newBlacklistedTags: cleanedTags,
-        });
-      }
-    }
   }
 
   private async processResults(

server/routes/discover.ts

@@ -128,15 +128,11 @@ discoverRoutes.get('/movies', async (req, res, next) => {
     if (keywords) {
       const splitKeywords = keywords.split(',');
 
-      const keywordResults = await Promise.all(
+      keywordData = await Promise.all(
         splitKeywords.map(async (keywordId) => {
           return await tmdb.getKeywordDetails({ keywordId: Number(keywordId) });
         })
       );
-
-      keywordData = keywordResults.filter(
-        (keyword): keyword is TmdbKeyword => keyword !== null
-      );
     }
 
     return res.status(200).json({
@@ -419,15 +415,11 @@ discoverRoutes.get('/tv', async (req, res, next) => {
     if (keywords) {
       const splitKeywords = keywords.split(',');
 
-      const keywordResults = await Promise.all(
+      keywordData = await Promise.all(
         splitKeywords.map(async (keywordId) => {
           return await tmdb.getKeywordDetails({ keywordId: Number(keywordId) });
         })
       );
-
-      keywordData = keywordResults.filter(
-        (keyword): keyword is TmdbKeyword => keyword !== null
-      );
     }
 
     return res.status(200).json({

server/routes/imageproxy.ts

@@ -4,40 +4,27 @@ import { Router } from 'express';
 
 const router = Router();
 
-// Delay the initialization of ImageProxy instances until the proxy (if any) is properly configured
-let _tmdbImageProxy: ImageProxy;
-function initTmdbImageProxy() {
-  if (!_tmdbImageProxy) {
-    _tmdbImageProxy = new ImageProxy('tmdb', 'https://image.tmdb.org', {
-      rateLimitOptions: {
-        maxRequests: 20,
-        maxRPS: 50,
-      },
-    });
-  }
-  return _tmdbImageProxy;
-}
-let _tvdbImageProxy: ImageProxy;
-function initTvdbImageProxy() {
-  if (!_tvdbImageProxy) {
-    _tvdbImageProxy = new ImageProxy('tvdb', 'https://artworks.thetvdb.com', {
-      rateLimitOptions: {
-        maxRequests: 20,
-        maxRPS: 50,
-      },
-    });
-  }
-  return _tvdbImageProxy;
-}
+const tmdbImageProxy = new ImageProxy('tmdb', 'https://image.tmdb.org', {
+  rateLimitOptions: {
+    maxRequests: 20,
+    maxRPS: 50,
+  },
+});
+const tvdbImageProxy = new ImageProxy('tvdb', 'https://artworks.thetvdb.com', {
+  rateLimitOptions: {
+    maxRequests: 20,
+    maxRPS: 50,
+  },
+});
 
 router.get('/:type/*', async (req, res) => {
   const imagePath = req.path.replace(/^\/\w+/, '');
   try {
     let imageData;
     if (req.params.type === 'tmdb') {
-      imageData = await initTmdbImageProxy().getImage(imagePath);
+      imageData = await tmdbImageProxy.getImage(imagePath);
     } else if (req.params.type === 'tvdb') {
-      imageData = await initTvdbImageProxy().getImage(imagePath);
+      imageData = await tvdbImageProxy.getImage(imagePath);
     } else {
       logger.error('Unsupported image type', {
         imagePath,

server/routes/media.ts

@@ -197,10 +197,8 @@ mediaRoutes.delete(
       const media = await mediaRepository.findOneOrFail({
         where: { id: Number(req.params.id) },
       });
-
-      const is4k = req.query.is4k === 'true';
+      const is4k = media.serviceUrl4k !== undefined;
       const isMovie = media.mediaType === MediaType.MOVIE;
-
       let serviceSettings;
       if (isMovie) {
         serviceSettings = settings.radarr.find(
@@ -227,7 +225,6 @@ mediaRoutes.delete(
           );
         }
       }
-
       if (!serviceSettings) {
         logger.warn(
           `There is no default ${
@@ -242,7 +239,6 @@ mediaRoutes.delete(
         );
         return;
       }
-
       let service;
       if (isMovie) {
         service = new RadarrAPI({

server/subscriber/MediaRequestSubscriber.ts

@@ -33,93 +33,52 @@ import { EventSubscriber } from 'typeorm';
 export class MediaRequestSubscriber
   implements EntitySubscriberInterface<MediaRequest>
 {
-  private async notifyAvailableMovie(
-    entity: MediaRequest,
-    event?: UpdateEvent<MediaRequest>
-  ) {
-    // Get fresh media state using event manager
-    let latestMedia: Media | null = null;
-    if (event?.manager) {
-      latestMedia = await event.manager.findOne(Media, {
-        where: { id: entity.media.id },
-      });
-    }
-    if (!latestMedia) {
-      const mediaRepository = getRepository(Media);
-      latestMedia = await mediaRepository.findOne({
-        where: { id: entity.media.id },
-      });
-    }
-
-    // Check availability using fresh media state
+  private async notifyAvailableMovie(entity: MediaRequest) {
     if (
-      !latestMedia ||
-      latestMedia[entity.is4k ? 'status4k' : 'status'] !== MediaStatus.AVAILABLE
+      entity.media[entity.is4k ? 'status4k' : 'status'] ===
+      MediaStatus.AVAILABLE
     ) {
-      return;
-    }
+      const tmdb = new TheMovieDb();
 
-    const tmdb = new TheMovieDb();
+      try {
+        const movie = await tmdb.getMovie({
+          movieId: entity.media.tmdbId,
+        });
 
-    try {
-      const movie = await tmdb.getMovie({
-        movieId: entity.media.tmdbId,
-      });
-
-      notificationManager.sendNotification(Notification.MEDIA_AVAILABLE, {
-        event: `${entity.is4k ? '4K ' : ''}Movie Request Now Available`,
-        notifyAdmin: false,
-        notifySystem: true,
-        notifyUser: entity.requestedBy,
-        subject: `${movie.title}${
-          movie.release_date ? ` (${movie.release_date.slice(0, 4)})` : ''
-        }`,
-        message: truncate(movie.overview, {
-          length: 500,
-          separator: /\s/,
-          omission: '…',
-        }),
-        media: latestMedia,
-        image: `https://image.tmdb.org/t/p/w600_and_h900_bestv2${movie.poster_path}`,
-        request: entity,
-      });
-    } catch (e) {
-      logger.error('Something went wrong sending media notification(s)', {
-        label: 'Notifications',
-        errorMessage: e.message,
-        mediaId: entity.id,
-      });
+        notificationManager.sendNotification(Notification.MEDIA_AVAILABLE, {
+          event: `${entity.is4k ? '4K ' : ''}Movie Request Now Available`,
+          notifyAdmin: false,
+          notifySystem: true,
+          notifyUser: entity.requestedBy,
+          subject: `${movie.title}${
+            movie.release_date ? ` (${movie.release_date.slice(0, 4)})` : ''
+          }`,
+          message: truncate(movie.overview, {
+            length: 500,
+            separator: /\s/,
+            omission: '…',
+          }),
+          media: entity.media,
+          image: `https://image.tmdb.org/t/p/w600_and_h900_bestv2${movie.poster_path}`,
+          request: entity,
+        });
+      } catch (e) {
+        logger.error('Something went wrong sending media notification(s)', {
+          label: 'Notifications',
+          errorMessage: e.message,
+          mediaId: entity.id,
+        });
+      }
     }
   }
 
-  private async notifyAvailableSeries(
-    entity: MediaRequest,
-    event?: UpdateEvent<MediaRequest>
-  ) {
-    // Get fresh media state with seasons using event manager
-    let latestMedia: Media | null = null;
-    if (event?.manager) {
-      latestMedia = await event.manager.findOne(Media, {
-        where: { id: entity.media.id },
-        relations: { seasons: true },
-      });
-    }
-    if (!latestMedia) {
-      const mediaRepository = getRepository(Media);
-      latestMedia = await mediaRepository.findOne({
-        where: { id: entity.media.id },
-        relations: { seasons: true },
-      });
-    }
-
-    if (!latestMedia) {
-      return;
-    }
-
-    // Check availability using fresh media state
+  private async notifyAvailableSeries(entity: MediaRequest) {
+    // Find all seasons in the related media entity
+    // and see if they are available, then we can check
+    // if the request contains the same seasons
     const requestedSeasons =
       entity.seasons?.map((entitySeason) => entitySeason.seasonNumber) ?? [];
-    const availableSeasons = latestMedia.seasons.filter(
+    const availableSeasons = entity.media.seasons.filter(
       (season) =>
         season[entity.is4k ? 'status4k' : 'status'] === MediaStatus.AVAILABLE &&
         requestedSeasons.includes(season.seasonNumber)
@@ -128,46 +87,44 @@ export class MediaRequestSubscriber
       availableSeasons.length > 0 &&
       availableSeasons.length === requestedSeasons.length;
 
-    if (!isMediaAvailable) {
-      return;
-    }
+    if (isMediaAvailable) {
+      const tmdb = new TheMovieDb();
 
-    const tmdb = new TheMovieDb();
+      try {
+        const tv = await tmdb.getTvShow({ tvId: entity.media.tmdbId });
 
-    try {
-      const tv = await tmdb.getTvShow({ tvId: entity.media.tmdbId });
-
-      notificationManager.sendNotification(Notification.MEDIA_AVAILABLE, {
-        event: `${entity.is4k ? '4K ' : ''}Series Request Now Available`,
-        subject: `${tv.name}${
-          tv.first_air_date ? ` (${tv.first_air_date.slice(0, 4)})` : ''
-        }`,
-        message: truncate(tv.overview, {
-          length: 500,
-          separator: /\s/,
-          omission: '…',
-        }),
-        notifyAdmin: false,
-        notifySystem: true,
-        notifyUser: entity.requestedBy,
-        image: `https://image.tmdb.org/t/p/w600_and_h900_bestv2${tv.poster_path}`,
-        media: latestMedia,
-        extra: [
-          {
-            name: 'Requested Seasons',
-            value: entity.seasons
-              .map((season) => season.seasonNumber)
-              .join(', '),
-          },
-        ],
-        request: entity,
-      });
-    } catch (e) {
-      logger.error('Something went wrong sending media notification(s)', {
-        label: 'Notifications',
-        errorMessage: e.message,
-        mediaId: entity.id,
-      });
+        notificationManager.sendNotification(Notification.MEDIA_AVAILABLE, {
+          event: `${entity.is4k ? '4K ' : ''}Series Request Now Available`,
+          subject: `${tv.name}${
+            tv.first_air_date ? ` (${tv.first_air_date.slice(0, 4)})` : ''
+          }`,
+          message: truncate(tv.overview, {
+            length: 500,
+            separator: /\s/,
+            omission: '…',
+          }),
+          notifyAdmin: false,
+          notifySystem: true,
+          notifyUser: entity.requestedBy,
+          image: `https://image.tmdb.org/t/p/w600_and_h900_bestv2${tv.poster_path}`,
+          media: entity.media,
+          extra: [
+            {
+              name: 'Requested Seasons',
+              value: entity.seasons
+                .map((season) => season.seasonNumber)
+                .join(', '),
+            },
+          ],
+          request: entity,
+        });
+      } catch (e) {
+        logger.error('Something went wrong sending media notification(s)', {
+          label: 'Notifications',
+          errorMessage: e.message,
+          mediaId: entity.id,
+        });
+      }
     }
   }
 
@@ -825,10 +782,10 @@ export class MediaRequestSubscriber
 
     if (event.entity.status === MediaRequestStatus.COMPLETED) {
       if (event.entity.media.mediaType === MediaType.MOVIE) {
-        this.notifyAvailableMovie(event.entity as MediaRequest, event);
+        this.notifyAvailableMovie(event.entity as MediaRequest);
       }
       if (event.entity.media.mediaType === MediaType.TV) {
-        this.notifyAvailableSeries(event.entity as MediaRequest, event);
+        this.notifyAvailableSeries(event.entity as MediaRequest);
       }
     }
   }

src/components/BlacklistedTagsBadge/index.tsx

@@ -29,10 +29,14 @@ const BlacklistedTagsBadge = ({ data }: BlacklistedTagsBadgeProps) => {
     const keywordIds = data.blacklistedTags.slice(1, -1).split(',');
     Promise.all(
       keywordIds.map(async (keywordId) => {
-        const { data } = await axios.get<Keyword | null>(
-          `/api/v1/keyword/${keywordId}`
-        );
-        return data?.name || `[Invalid: ${keywordId}]`;
+        try {
+          const { data } = await axios.get<Keyword>(
+            `/api/v1/keyword/${keywordId}`
+          );
+          return data.name;
+        } catch (err) {
+          return '';
+        }
       })
     ).then((keywords) => {
       setTagNamesBlacklistedFor(keywords.join(', '));

src/components/BlacklistedTagsSelector/index.tsx

@@ -5,10 +5,7 @@ import { encodeURIExtraParams } from '@app/hooks/useDiscover';
 import defineMessages from '@app/utils/defineMessages';
 import { Transition } from '@headlessui/react';
 import { ArrowDownIcon } from '@heroicons/react/24/solid';
-import type {
-  TmdbKeyword,
-  TmdbKeywordSearchResponse,
-} from '@server/api/themoviedb/interfaces';
+import type { TmdbKeywordSearchResponse } from '@server/api/themoviedb/interfaces';
 import type { Keyword } from '@server/models/common';
 import axios from 'axios';
 import { useFormikContext } from 'formik';
@@ -127,19 +124,15 @@ const ControlledKeywordSelector = ({
 
       const keywords = await Promise.all(
         defaultValue.split(',').map(async (keywordId) => {
-          const { data } = await axios.get<Keyword | null>(
+          const { data } = await axios.get<Keyword>(
             `/api/v1/keyword/${keywordId}`
           );
           return data;
         })
       );
 
-      const validKeywords: TmdbKeyword[] = keywords.filter(
-        (keyword): keyword is TmdbKeyword => keyword !== null
-      );
-
       onChange(
-        validKeywords.map((keyword) => ({
+        keywords.map((keyword) => ({
           label: keyword.name,
           value: keyword.id,
         }))

src/components/Discover/CreateSlider/index.tsx

@@ -77,19 +77,16 @@ const CreateSlider = ({ onCreate, slider }: CreateSliderProps) => {
 
         const keywords = await Promise.all(
           slider.data.split(',').map(async (keywordId) => {
-            const keyword = await axios.get<Keyword | null>(
+            const keyword = await axios.get<Keyword>(
               `/api/v1/keyword/${keywordId}`
             );
+
             return keyword.data;
           })
         );
 
-        const validKeywords: Keyword[] = keywords.filter(
-          (keyword): keyword is Keyword => keyword !== null
-        );
-
         setDefaultDataValue(
-          validKeywords.map((keyword) => ({
+          keywords.map((keyword) => ({
             label: keyword.name,
             value: keyword.id,
           }))

src/components/ManageSlideOver/index.tsx

@@ -118,11 +118,9 @@ const ManageSlideOver = ({
     }
   };
 
-  const deleteMediaFile = async (is4k = false) => {
+  const deleteMediaFile = async () => {
     if (data.mediaInfo) {
-      await axios.delete(
-        `/api/v1/media/${data.mediaInfo.id}/file?is4k=${is4k}`
-      );
+      await axios.delete(`/api/v1/media/${data.mediaInfo.id}/file`);
       await axios.delete(`/api/v1/media/${data.mediaInfo.id}`);
       revalidate();
       onClose();
@@ -416,7 +414,7 @@ const ManageSlideOver = ({
                   isDefaultService() && (
                     <div>
                       <ConfirmButton
-                        onClick={() => deleteMediaFile(false)}
+                        onClick={() => deleteMediaFile()}
                         confirmText={intl.formatMessage(
                           globalMessages.areyousure
                         )}
@@ -575,7 +573,7 @@ const ManageSlideOver = ({
                     {isDefaultService() && (
                       <div>
                         <ConfirmButton
-                          onClick={() => deleteMediaFile(true)}
+                          onClick={() => deleteMediaFile()}
                           confirmText={intl.formatMessage(
                             globalMessages.areyousure
                           )}

src/components/RequestList/RequestItem/index.tsx

@@ -343,9 +343,7 @@ const RequestItem = ({ request, revalidateList }: RequestItemProps) => {
 
   const deleteMediaFile = async () => {
     if (request.media) {
-      await axios.delete(
-        `/api/v1/media/${request.media.id}/file?is4k=${request.is4k}`
-      );
+      await axios.delete(`/api/v1/media/${request.media.id}/file`);
       await axios.delete(`/api/v1/media/${request.media.id}`);
       revalidateList();
     }

src/components/Selector/index.tsx

@@ -309,19 +309,16 @@ export const KeywordSelector = ({
 
       const keywords = await Promise.all(
         defaultValue.split(',').map(async (keywordId) => {
-          const keyword = await axios.get<Keyword | null>(
+          const keyword = await axios.get<Keyword>(
             `/api/v1/keyword/${keywordId}`
           );
+
           return keyword.data;
         })
       );
 
-      const validKeywords: Keyword[] = keywords.filter(
-        (keyword): keyword is Keyword => keyword !== null
-      );
-
       setDefaultDataValue(
-        validKeywords.map((keyword) => ({
+        keywords.map((keyword) => ({
           label: keyword.name,
           value: keyword.id,
         }))

src/components/Settings/OverrideRule/OverrideRuleTiles.tsx

@@ -113,16 +113,12 @@ const OverrideRuleTiles = ({
           .flat()
           .filter((keywordId) => keywordId)
           .map(async (keywordId) => {
-            const response = await axios.get<Keyword | null>(
-              `/api/v1/keyword/${keywordId}`
-            );
-            return response.data;
+            const response = await axios.get(`/api/v1/keyword/${keywordId}`);
+            const keyword: Keyword = response.data;
+            return keyword;
           })
       );
-      const validKeywords: Keyword[] = keywords.filter(
-        (keyword): keyword is Keyword => keyword !== null
-      );
-      setKeywords(validKeywords);
+      setKeywords(keywords);
       const allUsersFromRules = rules
         .map((rule) => rule.users)
         .filter((users) => users)