feat: converted src/APIs to TS

src/APIs/FlagsAPI.ts

@@ -0,0 +1,56 @@
+import compact from 'lodash/compact';
+import assign from 'lodash/assign';
+import omit from 'lodash/omit';
+
+interface Word {
+  id?: string;
+  stems?: Array<string | { id?: string }>;
+  relatedTerms?: Array<string | { id?: string }>;
+  examples?: any; // Update the type of `examples` accordingly
+  dialects?: any; // Update the type of `dialects` accordingly
+}
+
+interface Data {
+  words: Word[];
+  contentLength: number;
+}
+
+interface Flags {
+  examples?: boolean;
+  dialects?: boolean;
+  resolve?: boolean;
+}
+
+interface HandleWordFlagsParams {
+  data: Data;
+  flags: Flags;
+}
+
+export const handleWordFlags = ({
+  data: { words, contentLength },
+  flags: { examples, dialects, resolve },
+}: HandleWordFlagsParams) => {
+  const updatedWords = compact(
+    words.map((word) => {
+      let updatedWord = assign({}, word);
+      if (!examples) {
+        updatedWord = omit(updatedWord, ['examples']);
+      }
+      if (!dialects) {
+        updatedWord = omit(updatedWord, ['dialects']);
+      }
+      if (!resolve) {
+        if (updatedWord.stems) {
+          updatedWord.stems = updatedWord.stems.map((stem) => (typeof stem === 'string' ? stem : stem.id));
+        }
+        if (updatedWord.relatedTerms) {
+          updatedWord.relatedTerms = updatedWord.relatedTerms.map((relatedTerm) =>
+            typeof relatedTerm === 'string' ? relatedTerm : relatedTerm.id
+          );
+        }
+      }
+      return updatedWord;
+    })
+  );
+  return { words: updatedWords, contentLength };
+};

src/APIs/RedisAPI.js → src/APIs/RedisAPI.ts

@@ -1,8 +1,14 @@
+import { RedisClient } from 'redis'; // Import the appropriate Redis client type
 import assign from 'lodash/assign';
 import { REDIS_CACHE_EXPIRATION } from '../config';
 import minimizeWords from '../controllers/utils/minimizeWords';
 
-export const getCachedWords = async ({ key, redisClient }) => {
+interface GetCachedWordsParams {
+  key: string;
+  redisClient: RedisClient;
+}
+
+export const getCachedWords = async ({ key, redisClient }: GetCachedWordsParams) => {
   console.time('Getting cached words');
   const rawCachedWords = await redisClient.get(key);
   const cachedWords = typeof rawCachedWords === 'string' ? JSON.parse(rawCachedWords) : rawCachedWords;
@@ -11,49 +17,75 @@ export const getCachedWords = async ({ key, redisClient }) => {
   return cachedWords;
 };
 
-export const setCachedWords = async ({
-  key,
-  data,
-  redisClient,
-  version,
-}) => {
-  const updatedData = assign(data);
+interface SetCachedWordsParams {
+  key: string;
+  data: any; // Update the type of `data` accordingly
+  redisClient: RedisClient;
+  version: string; // Update the type of `version` accordingly
+}
+
+export const setCachedWords = async ({ key, data, redisClient, version }: SetCachedWordsParams) => {
+  const updatedData = assign({}, data);
   updatedData.words = minimizeWords(data.words, version);
   if (!redisClient.isFake) {
     await redisClient.set(key, JSON.stringify(updatedData), { EX: REDIS_CACHE_EXPIRATION });
   }
   return updatedData;
 };
 
-export const getCachedExamples = async ({ key, redisClient }) => {
+interface GetCachedExamplesParams {
+  key: string;
+  redisClient: RedisClient;
+}
+
+export const getCachedExamples = async ({ key, redisClient }: GetCachedExamplesParams) => {
   const rawCachedExamples = await redisClient.get(key);
   const cachedExamples = typeof rawCachedExamples === 'string' ? JSON.parse(rawCachedExamples) : rawCachedExamples;
   console.log(`Retrieved cached data for examples ${key}:`, !!cachedExamples);
   return cachedExamples;
 };
 
-export const setCachedExamples = async ({ key, data, redisClient }) => {
+interface SetCachedExamplesParams {
+  key: string;
+  data: any; // Update the type of `data` accordingly
+  redisClient: RedisClient;
+}
+
+export const setCachedExamples = async ({ key, data, redisClient }: SetCachedExamplesParams) => {
   if (!redisClient.isFake) {
     await redisClient.set(key, JSON.stringify(data), { EX: REDIS_CACHE_EXPIRATION });
   }
   return data;
 };
 
-export const getAllCachedVerbsAndSuffixes = async ({ key, redisClient }) => {
+interface GetAllCachedVerbsAndSuffixesParams {
+  key: string;
+  redisClient: RedisClient;
+}
+
+export const getAllCachedVerbsAndSuffixes = async ({ key, redisClient }: GetAllCachedVerbsAndSuffixesParams) => {
   const redisAllVerbsAndSuffixesKey = `verbs-and-suffixes-${key}`;
   const rawCachedAllVerbsAndSuffixes = await redisClient.get(redisAllVerbsAndSuffixesKey);
-  const cachedAllVerbsAndSuffixes = typeof rawCachedAllVerbsAndSuffixes === 'string'
-    ? JSON.parse(rawCachedAllVerbsAndSuffixes)
-    : rawCachedAllVerbsAndSuffixes;
+  const cachedAllVerbsAndSuffixes =
+    typeof rawCachedAllVerbsAndSuffixes === 'string'
+      ? JSON.parse(rawCachedAllVerbsAndSuffixes)
+      : rawCachedAllVerbsAndSuffixes;
   return cachedAllVerbsAndSuffixes;
 };
 
+interface SetAllCachedVerbsAndSuffixesParams {
+  key: string;
+  data: any; // Update the type of `data` accordingly
+  redisClient: RedisClient;
+  version: string; // Update the type of `version` accordingly
+}
+
 export const setAllCachedVerbsAndSuffixes = async ({
   key,
   data,
   redisClient,
   version,
-}) => {
+}: SetAllCachedVerbsAndSuffixesParams) => {
   const redisAllVerbsAndSuffixesKey = `verbs-and-suffixes-${key}`;
   const updatedData = minimizeWords(data, version);
   if (!redisClient.isFake) {