fix: format + lint

backend/src/controllers/learningObjects.ts

@@ -2,17 +2,17 @@ import { Request, Response } from 'express';
 import {
     getLearningObjectById,
     getLearningObjectIdsFromPath,
-    getLearningObjectsFromPath
+    getLearningObjectsFromPath,
 } from '../services/learningObjects.js';
 import { FALLBACK_LANG } from '../config.js';
-import {FilteredLearningObject} from "../interfaces/learningPath";
+import { FilteredLearningObject } from '../interfaces/learningPath';
 
 export async function getAllLearningObjects(
     req: Request,
     res: Response
 ): Promise<void> {
     try {
-        const hruid = (req.query.hruid as string);
+        const hruid = req.query.hruid as string;
         const full = req.query.full === 'true';
         const language = (req.query.language as string) || FALLBACK_LANG;
 
@@ -22,10 +22,14 @@ export async function getAllLearningObjects(
         }
 
         let learningObjects: FilteredLearningObject[] | string[];
-        if (full)
+        if (full) {
-            learningObjects = await getLearningObjectsFromPath(hruid,language);
+            learningObjects = await getLearningObjectsFromPath(hruid, language);
-        else
+        } else {
-            learningObjects = await getLearningObjectIdsFromPath(hruid, language)
+            learningObjects = await getLearningObjectIdsFromPath(
+                hruid,
+                language
+            );
+        }
 
         res.json(learningObjects);
     } catch (error) {
@@ -34,7 +38,6 @@ export async function getAllLearningObjects(
     }
 }
 
-
 export async function getLearningObject(
     req: Request,
     res: Response
@@ -50,7 +53,7 @@ export async function getLearningObject(
 
         const learningObject = await getLearningObjectById(hruid, language);
         res.json(learningObject);
-    } catch (error){
+    } catch (error) {
         console.error('Error fetching learning object:', error);
         res.status(500).json({ error: 'Internal server error' });
     }

backend/src/controllers/learningPaths.ts

@@ -1,41 +1,59 @@
 import { Request, Response } from 'express';
 import { themes } from '../data/themes.js';
 import { FALLBACK_LANG } from '../config.js';
-import { fetchLearningPaths, searchLearningPaths } from '../services/learningPaths.js';
+import {
+    fetchLearningPaths,
+    searchLearningPaths,
+} from '../services/learningPaths.js';
 /**
  * Fetch learning paths based on query parameters.
  */
 export async function getLearningPaths(
     req: Request,
     res: Response
-):  Promise<void> {
+): Promise<void> {
     try {
         const hruids = req.query.hruid;
-        const themeKey = (req.query.theme as string);
+        const themeKey = req.query.theme as string;
-        const searchQuery = (req.query.search as string);
+        const searchQuery = req.query.search as string;
         const language = (req.query.language as string) || FALLBACK_LANG;
 
-        let hruidList = [];
+        let hruidList;
 
         if (hruids) {
-            hruidList = Array.isArray(hruids) ? hruids.map(String) : [String(hruids)];
+            hruidList = Array.isArray(hruids)
+                ? hruids.map(String)
+                : [String(hruids)];
         } else if (themeKey) {
-            const theme = themes.find((t) => t.title === themeKey);
+            const theme = themes.find((t) => {
+                return t.title === themeKey;
+            });
             if (theme) {
                 hruidList = theme.hruids;
             } else {
-                res.status(404).json({ error: `Theme "${themeKey}" not found.` });
+                res.status(404).json({
+                    error: `Theme "${themeKey}" not found.`,
+                });
                 return;
             }
         } else if (searchQuery) {
-            const searchResults = await searchLearningPaths(searchQuery, language);
+            const searchResults = await searchLearningPaths(
+                searchQuery,
+                language
+            );
             res.json(searchResults);
             return;
         } else {
-            hruidList = themes.flatMap((theme) => theme.hruids);
+            hruidList = themes.flatMap((theme) => {
+                return theme.hruids;
+            });
         }
 
-        const learningPaths = await fetchLearningPaths(hruidList, language, `HRUIDs: ${hruidList.join(', ')}`);
+        const learningPaths = await fetchLearningPaths(
+            hruidList,
+            language,
+            `HRUIDs: ${hruidList.join(', ')}`
+        );
         res.json(learningPaths.data);
     } catch (error) {
         console.error('❌ Unexpected error fetching learning paths:', error);

backend/src/routes/learningObjects.ts

@@ -1,5 +1,8 @@
 import express from 'express';
-import {getAllLearningObjects, getLearningObject} from '../controllers/learningObjects.js';
+import {
+    getAllLearningObjects,
+    getLearningObject,
+} from '../controllers/learningObjects.js';
 
 const router = express.Router();
 
@@ -15,7 +18,6 @@ const router = express.Router();
 // Example 2: http://localhost:3000/learningObject?full=true&hruid=un_artificiele_intelligentie
 router.get('/', getAllLearningObjects);
 
-
 // Parameter: hruid of learning object
 // Query: language
 // Route to fetch data of one learning object based on its hruid

backend/src/services/learningObjects.ts

@@ -3,7 +3,8 @@ import { fetchWithLogging } from '../util/apiHelper.js';
 import {
     FilteredLearningObject,
     LearningObjectMetadata,
-    LearningObjectNode, LearningPathResponse,
+    LearningObjectNode,
+    LearningPathResponse,
 } from '../interfaces/learningPath.js';
 import { fetchLearningPaths } from './learningPaths.js';
 
@@ -40,7 +41,7 @@ function filterData(
 export async function getLearningObjectById(
     hruid: string,
     language: string
-):  Promise<FilteredLearningObject | null> {
+): Promise<FilteredLearningObject | null> {
     const metadataUrl = `${DWENGO_API_BASE}/learningObject/getMetadata?hruid=${hruid}&language=${language}`;
     const metadata = await fetchWithLogging<LearningObjectMetadata>(
         metadataUrl,
@@ -65,26 +66,43 @@ async function fetchLearningObjects(
     language: string
 ): Promise<FilteredLearningObject[] | string[]> {
     try {
-        const learningPathResponse: LearningPathResponse = await fetchLearningPaths(
+        const learningPathResponse: LearningPathResponse =
-            [hruid],
+            await fetchLearningPaths(
-            language,
+                [hruid],
-            `Learning path for HRUID "${hruid}"`
+                language,
-        );
+                `Learning path for HRUID "${hruid}"`
+            );
 
-        if (!learningPathResponse.success || !learningPathResponse.data?.length) {
+        if (
-            console.error(`⚠️ WARNING: Learning path "${hruid}" exists but contains no learning objects.`);
+            !learningPathResponse.success ||
+            !learningPathResponse.data?.length
+        ) {
+            console.error(
+                `⚠️ WARNING: Learning path "${hruid}" exists but contains no learning objects.`
+            );
             return [];
         }
 
         const nodes: LearningObjectNode[] = learningPathResponse.data[0].nodes;
 
         if (!full) {
-            return nodes.map(node => node.learningobject_hruid);
+            return nodes.map((node) => {
+                return node.learningobject_hruid;
+            });
         }
 
         return await Promise.all(
-            nodes.map(async (node) => getLearningObjectById(node.learningobject_hruid, language))
+            nodes.map(async (node) => {
-        ).then((objects) => objects.filter((obj): obj is FilteredLearningObject => obj !== null));
+                return getLearningObjectById(
+                    node.learningobject_hruid,
+                    language
+                );
+            })
+        ).then((objects) => {
+            return objects.filter((obj): obj is FilteredLearningObject => {
+                return obj !== null;
+            });
+        });
     } catch (error) {
         console.error('❌ Error fetching learning objects:', error);
         return [];
@@ -98,7 +116,11 @@ export async function getLearningObjectsFromPath(
     hruid: string,
     language: string
 ): Promise<FilteredLearningObject[]> {
-    return await fetchLearningObjects(hruid, true, language) as FilteredLearningObject[];
+    return (await fetchLearningObjects(
+        hruid,
+        true,
+        language
+    )) as FilteredLearningObject[];
 }
 
 /**
@@ -108,5 +130,5 @@ export async function getLearningObjectIdsFromPath(
     hruid: string,
     language: string
 ): Promise<string[]> {
-    return await fetchLearningObjects(hruid, false, language) as string[];
+    return (await fetchLearningObjects(hruid, false, language)) as string[];
 }

backend/src/services/learningPaths.ts

@@ -45,14 +45,17 @@ export async function fetchLearningPaths(
     };
 }
 
-
 export async function searchLearningPaths(
     query: string,
     language: string
-):  Promise<LearningPath[]>  {
+): Promise<LearningPath[]> {
     const apiUrl = `${DWENGO_API_BASE}/learningPath/search`;
     const params = { all: query, language };
 
-    const searchResults = await fetchWithLogging<LearningPath[]>(apiUrl, `Search learning paths with query "${query}"`, params);
+    const searchResults = await fetchWithLogging<LearningPath[]>(
+        apiUrl,
+        `Search learning paths with query "${query}"`,
+        params
+    );
     return searchResults ?? [];
 }