fix: format

backend/src/config.ts

@@ -7,4 +7,4 @@
 
 export const DWENGO_API_BASE = 'https://dwengo.org/backend/api';
 
-export const FALLBACK_LANG = "nl";
+export const FALLBACK_LANG = 'nl';

backend/src/controllers/learningObjects.ts

@@ -1,6 +1,6 @@
 import { Request, Response } from 'express';
 import { getLearningObjectsFromPath } from '../services/learningObjects.js';
-import {FALLBACK_LANG} from "../config";
+import { FALLBACK_LANG } from '../config';
 
 export async function getAllLearningObjects(
     req: Request,

backend/src/controllers/learningPaths.ts

@@ -1,16 +1,19 @@
 import { Request, Response } from 'express';
 import { themes } from '../data/themes.js';
-import {DWENGO_API_BASE, FALLBACK_LANG} from '../config.js';
+import { DWENGO_API_BASE, FALLBACK_LANG } from '../config.js';
-import { fetchWithLogging } from "../util/apiHelper.js";
+import { fetchWithLogging } from '../util/apiHelper.js';
-import { fetchLearningPaths } from "../services/learningPaths.js";
+import { fetchLearningPaths } from '../services/learningPaths.js';
-import {LearningPath} from "../interfaces/learningPath";
+import { LearningPath } from '../interfaces/learningPath';
 
 /**
  * Fetch learning paths based on HRUIDs or return all if no HRUIDs are provided.
  * - If `hruids` are given -> fetch specific learning paths.
  * - If `hruids` is missing -> return all available learning paths.
  */
-export async function getLearningPaths(req: Request, res: Response): Promise<void> {
+export async function getLearningPaths(
+    req: Request,
+    res: Response
+): Promise<void> {
     try {
         const hruids = req.query.hruids; // Can be string or array
         const language = (req.query.language as string) || FALLBACK_LANG;
@@ -18,13 +21,21 @@ export async function getLearningPaths(req: Request, res: Response): Promise<voi
         let hruidList: string[];
 
         if (hruids) {
-            hruidList = Array.isArray(hruids) ? hruids.map(String) : [String(hruids)];
+            hruidList = Array.isArray(hruids)
+                ? hruids.map(String)
+                : [String(hruids)];
         } else {
             // If no hruids are provided, fetch ALL learning paths
-            hruidList = themes.flatMap((theme) => {return 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);
     } catch (error) {
@@ -33,37 +44,51 @@ export async function getLearningPaths(req: Request, res: Response): Promise<voi
     }
 }
 
-
 /**
  * Fetch all learning paths for a specific theme.
  */
-export async function getLearningPathsByTheme(req: Request, res: Response): Promise<void> {
+export async function getLearningPathsByTheme(
+    req: Request,
+    res: Response
+): Promise<void> {
     try {
         const themeKey = req.params.theme;
         const language = (req.query.language as string) || FALLBACK_LANG;
 
-        const theme = themes.find((t) => {return t.title === themeKey});
+        const theme = themes.find((t) => {
+            return t.title === themeKey;
+        });
         if (!theme) {
             console.error(`⚠️ WARNING: Theme "${themeKey}" not found.`);
             res.status(404).json({ error: 'Theme not found' });
             return;
         }
 
-        const response = await fetchLearningPaths(theme.hruids, language, `theme "${themeKey}"`);
+        const response = await fetchLearningPaths(
+            theme.hruids,
+            language,
+            `theme "${themeKey}"`
+        );
         res.json({
             theme: themeKey,
             hruids: theme.hruids,
             ...response,
         });
     } catch (error) {
-        console.error('❌ Unexpected error fetching learning paths by theme:', error);
+        console.error(
+            '❌ Unexpected error fetching learning paths by theme:',
+            error
+        );
     }
 }
 
 /**
  * Search learning paths by query.
  */
-export async function searchLearningPaths(req: Request, res: Response): Promise<void> {
+export async function searchLearningPaths(
+    req: Request,
+    res: Response
+): Promise<void> {
     try {
         const query = req.query.query as string;
         const language = (req.query.language as string) || FALLBACK_LANG;
@@ -76,7 +101,11 @@ export async function searchLearningPaths(req: Request, res: Response): Promise<
         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
+        );
         res.json(searchResults ?? []);
     } catch (error) {
         console.error('❌ Unexpected error searching learning paths:', error);

backend/src/controllers/themes.ts

@@ -3,7 +3,7 @@ import path from 'path';
 import yaml from 'js-yaml';
 import { Request, Response } from 'express';
 import { themes } from '../data/themes.js';
-import {FALLBACK_LANG} from "../config";
+import { FALLBACK_LANG } from '../config';
 
 interface Translations {
     curricula_page: {
@@ -27,7 +27,8 @@ function loadTranslations(language: string): Translations {
 }
 
 export function getThemes(req: Request, res: Response) {
-    const language = (req.query.language as string)?.toLowerCase() || FALLBACK_LANG;
+    const language =
+        (req.query.language as string)?.toLowerCase() || FALLBACK_LANG;
     const translations = loadTranslations(language);
 
     const themeList = themes.map((theme) => {

backend/src/routes/learningObjects.ts

@@ -8,7 +8,7 @@ const router = express.Router();
 // Arg: hruid learningPath
 // Query: language
 // Route to fetch list of learning objects based on hruid of learning path
-// example: http://localhost:3000/learningObject/un_artificiele_intelligentie
+// Example: http://localhost:3000/learningObject/un_artificiele_intelligentie
 router.get('/:hruid', getAllLearningObjects);
 
 export default router;

backend/src/services/learningObjects.ts

@@ -1,10 +1,16 @@
 import { DWENGO_API_BASE } from '../config.js';
-import { fetchWithLogging } from "../util/apiHelper.js";
+import { fetchWithLogging } from '../util/apiHelper.js';
-import {FilteredLearningObject, LearningObjectMetadata, LearningObjectNode} from "../interfaces/learningPath.js";
+import {
-import {fetchLearningPaths} from "./learningPaths.js";
+    FilteredLearningObject,
+    LearningObjectMetadata,
+    LearningObjectNode,
+} from '../interfaces/learningPath.js';
+import { fetchLearningPaths } from './learningPaths.js';
 
-
+function filterLearningObjectMetadata(
-function filterLearningObjectMetadata(data: LearningObjectMetadata, htmlUrl: string) : FilteredLearningObject {
+    data: LearningObjectMetadata,
+    htmlUrl: string
+): FilteredLearningObject {
     return {
         key: data.hruid, // Hruid learningObject (not path)
         _id: data._id,
@@ -31,12 +37,22 @@ function filterLearningObjectMetadata(data: LearningObjectMetadata, htmlUrl: str
 export async function getLearningObjectsFromPath(
     hruid: string,
     language: string
-):  Promise<FilteredLearningObject[]> {
+): Promise<FilteredLearningObject[]> {
     try {
-        const learningPathResponse = await fetchLearningPaths([hruid], language, `Learning path for HRUID "${hruid}"`);
+        const learningPathResponse = await fetchLearningPaths(
+            [hruid],
+            language,
+            `Learning path for HRUID "${hruid}"`
+        );
 
-        if (!learningPathResponse.success || !learningPathResponse.data || learningPathResponse.data.length === 0) {
+        if (
-            console.error(`⚠️ WARNING: Learning path "${hruid}" exists but contains no learning objects.`);
+            !learningPathResponse.success ||
+            !learningPathResponse.data ||
+            learningPathResponse.data.length === 0
+        ) {
+            console.error(
+                `⚠️ WARNING: Learning path "${hruid}" exists but contains no learning objects.`
+            );
             return [];
         }
 
@@ -50,12 +66,18 @@ export async function getLearningObjectsFromPath(
                     `Metadata for Learning Object HRUID "${node.learningobject_hruid}" (version ${node.version}, language ${language})`
                 );
 
-                if (!metadata) {return null;}
+                if (!metadata) {
+                    return null;
+                }
 
                 const htmlUrl = `${DWENGO_API_BASE}/learningObject/getRaw?hruid=${node.learningobject_hruid}&version=${node.version}&language=${language}`;
                 return filterLearningObjectMetadata(metadata, htmlUrl);
             })
-        ).then((objects) => {return objects.filter((obj): obj is FilteredLearningObject => {return obj !== null})});
+        ).then((objects) => {
+            return objects.filter((obj): obj is FilteredLearningObject => {
+                return obj !== null;
+            });
+        });
     } catch (error) {
         console.error('Error fetching learning objects:', error);
         return [];

backend/src/services/learningPaths.ts

@@ -1,6 +1,9 @@
-import { fetchWithLogging } from "../util/apiHelper.js";
+import { fetchWithLogging } from '../util/apiHelper.js';
-import { DWENGO_API_BASE } from "../config.js";
+import { DWENGO_API_BASE } from '../config.js';
-import {LearningPath, LearningPathResponse} from "../interfaces/learningPath.js";
+import {
+    LearningPath,
+    LearningPathResponse,
+} from '../interfaces/learningPath.js';
 
 export async function fetchLearningPaths(
     hruids: string[],
@@ -19,7 +22,11 @@ export async function fetchLearningPaths(
     const apiUrl = `${DWENGO_API_BASE}/learningPath/getPathsFromIdList`;
     const params = { pathIdList: JSON.stringify({ hruids }), language };
 
-    const learningPaths = await fetchWithLogging<LearningPath[]>(apiUrl, `Learning paths for ${source}`, params);
+    const learningPaths = await fetchWithLogging<LearningPath[]>(
+        apiUrl,
+        `Learning paths for ${source}`,
+        params
+    );
 
     if (!learningPaths || learningPaths.length === 0) {
         console.error(`⚠️ WARNING: No learning paths found for ${source}.`);

backend/src/util/apiHelper.ts

@@ -1,4 +1,4 @@
-import axios, {AxiosRequestConfig} from 'axios';
+import axios, { AxiosRequestConfig } from 'axios';
 
 // !!!! when logger is done -> change
 
@@ -14,8 +14,8 @@ import axios, {AxiosRequestConfig} from 'axios';
 export async function fetchWithLogging<T>(
     url: string,
     description: string,
-    params?: Record<string,any>
+    params?: Record<string, any>
-):  Promise<T | null> {
+): Promise<T | null> {
     try {
         const config: AxiosRequestConfig = params ? { params } : {};
 
@@ -24,12 +24,19 @@ export async function fetchWithLogging<T>(
     } catch (error: any) {
         if (error.response) {
             if (error.response.status === 404) {
-                console.error(`❌ ERROR: ${description} not found (404) at "${url}".`);
+                console.error(
+                    `❌ ERROR: ${description} not found (404) at "${url}".`
+                );
             } else {
-                console.error(`❌ ERROR: Failed to fetch ${description}. Status: ${error.response.status} - ${error.response.statusText} (URL: "${url}")`);
+                console.error(
+                    `❌ ERROR: Failed to fetch ${description}. Status: ${error.response.status} - ${error.response.statusText} (URL: "${url}")`
+                );
             }
         } else {
-            console.error(`❌ ERROR: Network or unexpected error when fetching ${description}:`, error.message);
+            console.error(
+                `❌ ERROR: Network or unexpected error when fetching ${description}:`,
+                error.message
+            );
         }
         return null;
     }