diff --git a/server/src/auth.ts b/server/src/auth.ts
index 8fe2706..9f4ec68 100644
--- a/server/src/auth.ts
+++ b/server/src/auth.ts
@@ -9,13 +9,13 @@ import jwt from 'jsonwebtoken';
  */
 export function generateToken(login?: string, trusted?: boolean): string {
     if (!process.env.JWT_SECRET) {
-        throw Error("Není vyplněna proměnná prostředí JWT_SECRET");
+        throw new Error("Není vyplněna proměnná prostředí JWT_SECRET");
     }
     if (process.env.JWT_SECRET.length < 32) {
-        throw Error("Proměnná prostředí JWT_SECRET musí být minimálně 32 znaků");
+        throw new Error("Proměnná prostředí JWT_SECRET musí být minimálně 32 znaků");
     }
     if (!login || login.trim().length === 0) {
-        throw Error("Nebyl předán login");
+        throw new Error("Nebyl předán login");
     }
     const payload = { login, trusted: trusted || false, logoutUrl: process.env.LOGOUT_URL };
     return jwt.sign(payload, process.env.JWT_SECRET);
@@ -28,7 +28,7 @@ export function generateToken(login?: string, trusted?: boolean): string {
  */
 export function verify(token: string): boolean {
     if (!process.env.JWT_SECRET) {
-        throw Error("Není vyplněna proměnná prostředí JWT_SECRET");
+        throw new Error("Není vyplněna proměnná prostředí JWT_SECRET");
     }
     try {
         jwt.verify(token, process.env.JWT_SECRET);
@@ -45,10 +45,10 @@ export function verify(token: string): boolean {
  */
 export function getLogin(token?: string): string {
     if (!process.env.JWT_SECRET) {
-        throw Error("Není vyplněna proměnná prostředí JWT_SECRET");
+        throw new Error("Není vyplněna proměnná prostředí JWT_SECRET");
     }
     if (!token) {
-        throw Error("Nebyl předán token");
+        throw new Error("Nebyl předán token");
     }
     const payload: any = jwt.verify(token, process.env.JWT_SECRET);
     return payload.login;
@@ -61,10 +61,10 @@ export function getLogin(token?: string): string {
  */
 export function getTrusted(token?: string): boolean {
     if (!process.env.JWT_SECRET) {
-        throw Error("Není vyplněna proměnná prostředí JWT_SECRET");
+        throw new Error("Není vyplněna proměnná prostředí JWT_SECRET");
     }
     if (!token) {
-        throw Error("Nebyl předán token");
+        throw new Error("Nebyl předán token");
     }
     const payload: any = jwt.verify(token, process.env.JWT_SECRET);
     return payload.trusted || false;
diff --git a/server/src/index.ts b/server/src/index.ts
index 66193cf..efeb1f2 100644
--- a/server/src/index.ts
+++ b/server/src/index.ts
@@ -29,7 +29,7 @@ dotenv.config({ path: path.resolve(__dirname, `../.env.${ENVIRONMENT}`) });
 
 // Validace nastavení JWT tokenu - nemá bez něj smysl vůbec povolit server spustit
 if (!process.env.JWT_SECRET) {
-    throw Error("Není vyplněna proměnná prostředí JWT_SECRET");
+    throw new Error("Není vyplněna proměnná prostředí JWT_SECRET");
 }
 
 const app = express();
@@ -83,12 +83,12 @@ app.post("/api/login", (req, res) => {
         if (remoteUser && remoteUser.length > 0) {
             res.status(200).json(generateToken(Buffer.from(remoteUser, 'latin1').toString(), true));
         } else {
-            throw Error("Je zapnuto přihlášení přes hlavičky, ale nepřišla hlavička nebo ??");
+            throw new Error("Je zapnuto přihlášení přes hlavičky, ale nepřišla hlavička nebo ??");
         }
     } else {
         // Klasická autentizace loginem
         if (!req.body?.login || req.body.login.trim().length === 0) {
-            throw Error("Nebyl předán login");
+            throw new Error("Nebyl předán login");
         }
         // TODO zavést podmínky pro délku loginu (min i max)
         res.status(200).json(generateToken(req.body.login, false));
diff --git a/server/src/pizza.ts b/server/src/pizza.ts
index 72e64d6..cebf8e8 100644
--- a/server/src/pizza.ts
+++ b/server/src/pizza.ts
@@ -74,7 +74,7 @@ export async function createPizzaDay(creator: string): Promise<ClientData> {
     await initIfNeeded();
     const clientData = await getClientData(getToday());
     if (clientData.pizzaDay) {
-        throw Error("Pizza day pro dnešní den již existuje");
+        throw new Error("Pizza day pro dnešní den již existuje");
     }
     // TODO berka rychlooprava, vyřešit lépe - stahovat jednou, na jediném místě!
     const [pizzaList, salatList] = await Promise.all([getPizzaList(), getSalatList()]);
@@ -91,10 +91,10 @@ export async function createPizzaDay(creator: string): Promise<ClientData> {
 export async function deletePizzaDay(login: string): Promise<ClientData> {
     const clientData = await getClientData(getToday());
     if (!clientData.pizzaDay) {
-        throw Error("Pizza day pro dnešní den neexistuje");
+        throw new Error("Pizza day pro dnešní den neexistuje");
     }
     if (clientData.pizzaDay.creator !== login) {
-        throw Error("Login uživatele se neshoduje se zakladatelem Pizza Day");
+        throw new Error("Login uživatele se neshoduje se zakladatelem Pizza Day");
     }
     delete clientData.pizzaDay;
     const today = formatDate(getToday());
@@ -113,10 +113,10 @@ export async function addPizzaOrder(login: string, pizza: Pizza, size: PizzaSize
     const today = formatDate(getToday());
     const clientData = await getClientData(getToday());
     if (!clientData.pizzaDay) {
-        throw Error("Pizza day pro dnešní den neexistuje");
+        throw new Error("Pizza day pro dnešní den neexistuje");
     }
     if (clientData.pizzaDay.state !== PizzaDayState.CREATED) {
-        throw Error("Pizza day není ve stavu " + PizzaDayState.CREATED);
+        throw new Error("Pizza day není ve stavu " + PizzaDayState.CREATED);
     }
     let order: PizzaOrder | undefined = clientData.pizzaDay?.orders?.find(o => o.customer === login);
     if (!order) {
@@ -152,10 +152,10 @@ export async function addSalatOrder(login: string, salat: Salat) {
     const today = formatDate(getToday());
     const clientData = await getClientData(getToday());
     if (!clientData.pizzaDay) {
-        throw Error("Pizza day pro dnešní den neexistuje");
+        throw new Error("Pizza day pro dnešní den neexistuje");
     }
     if (clientData.pizzaDay.state !== PizzaDayState.CREATED) {
-        throw Error("Pizza day není ve stavu " + PizzaDayState.CREATED);
+        throw new Error("Pizza day není ve stavu " + PizzaDayState.CREATED);
     }
     let order: PizzaOrder | undefined = clientData.pizzaDay?.orders?.find(o => o.customer === login);
     if (!order) {
@@ -222,16 +222,16 @@ export async function removePizzaOrder(login: string, pizzaOrder: PizzaVariant)
     const today = formatDate(getToday());
     const clientData = await getClientData(getToday());
     if (!clientData.pizzaDay) {
-        throw Error("Pizza day pro dnešní den neexistuje");
+        throw new Error("Pizza day pro dnešní den neexistuje");
     }
     const orderIndex = clientData.pizzaDay.orders!.findIndex(o => o.customer === login);
     if (orderIndex < 0) {
-        throw Error("Nebyly nalezeny žádné objednávky pro uživatele " + login);
+        throw new Error("Nebyly nalezeny žádné objednávky pro uživatele " + login);
     }
     const order = clientData.pizzaDay.orders![orderIndex];
     const index = order.pizzaList!.findIndex(o => o.name === pizzaOrder.name && o.size === pizzaOrder.size);
     if (index < 0) {
-        throw Error("Objednávka s danými parametry nebyla nalezena");
+        throw new Error("Objednávka s danými parametry nebyla nalezena");
     }
     const price = order.pizzaList![index].price;
     order.pizzaList!.splice(index, 1);
@@ -253,13 +253,13 @@ export async function lockPizzaDay(login: string) {
     const today = formatDate(getToday());
     const clientData = await getClientData(getToday());
     if (!clientData.pizzaDay) {
-        throw Error("Pizza day pro dnešní den neexistuje");
+        throw new Error("Pizza day pro dnešní den neexistuje");
     }
     if (clientData.pizzaDay.creator !== login) {
-        throw Error("Pizza day není spravován uživatelem " + login);
+        throw new Error("Pizza day není spravován uživatelem " + login);
     }
     if (clientData.pizzaDay.state !== PizzaDayState.CREATED && clientData.pizzaDay.state !== PizzaDayState.ORDERED) {
-        throw Error("Pizza day není ve stavu " + PizzaDayState.CREATED + " nebo " + PizzaDayState.ORDERED);
+        throw new Error("Pizza day není ve stavu " + PizzaDayState.CREATED + " nebo " + PizzaDayState.ORDERED);
     }
     clientData.pizzaDay.state = PizzaDayState.LOCKED;
     await storage.setData(today, clientData);
@@ -276,13 +276,13 @@ export async function unlockPizzaDay(login: string) {
     const today = formatDate(getToday());
     const clientData = await getClientData(getToday());
     if (!clientData.pizzaDay) {
-        throw Error("Pizza day pro dnešní den neexistuje");
+        throw new Error("Pizza day pro dnešní den neexistuje");
     }
     if (clientData.pizzaDay.creator !== login) {
-        throw Error("Pizza day není spravován uživatelem " + login);
+        throw new Error("Pizza day není spravován uživatelem " + login);
     }
     if (clientData.pizzaDay.state !== PizzaDayState.LOCKED) {
-        throw Error("Pizza day není ve stavu " + PizzaDayState.LOCKED);
+        throw new Error("Pizza day není ve stavu " + PizzaDayState.LOCKED);
     }
     clientData.pizzaDay.state = PizzaDayState.CREATED;
     await storage.setData(today, clientData);
@@ -299,13 +299,13 @@ export async function finishPizzaOrder(login: string) {
     const today = formatDate(getToday());
     const clientData = await getClientData(getToday());
     if (!clientData.pizzaDay) {
-        throw Error("Pizza day pro dnešní den neexistuje");
+        throw new Error("Pizza day pro dnešní den neexistuje");
     }
     if (clientData.pizzaDay.creator !== login) {
-        throw Error("Pizza day není spravován uživatelem " + login);
+        throw new Error("Pizza day není spravován uživatelem " + login);
     }
     if (clientData.pizzaDay.state !== PizzaDayState.LOCKED) {
-        throw Error("Pizza day není ve stavu " + PizzaDayState.LOCKED);
+        throw new Error("Pizza day není ve stavu " + PizzaDayState.LOCKED);
     }
     clientData.pizzaDay.state = PizzaDayState.ORDERED;
     await storage.setData(today, clientData);
@@ -324,13 +324,13 @@ export async function finishPizzaDelivery(login: string, bankAccount?: string, b
     const today = formatDate(getToday());
     const clientData = await getClientData(getToday());
     if (!clientData.pizzaDay) {
-        throw Error("Pizza day pro dnešní den neexistuje");
+        throw new Error("Pizza day pro dnešní den neexistuje");
     }
     if (clientData.pizzaDay.creator !== login) {
-        throw Error("Pizza day není spravován uživatelem " + login);
+        throw new Error("Pizza day není spravován uživatelem " + login);
     }
     if (clientData.pizzaDay.state !== PizzaDayState.ORDERED) {
-        throw Error("Pizza day není ve stavu " + PizzaDayState.ORDERED);
+        throw new Error("Pizza day není ve stavu " + PizzaDayState.ORDERED);
     }
     clientData.pizzaDay.state = PizzaDayState.DELIVERED;
 
@@ -370,14 +370,14 @@ export async function updatePizzaDayNote(login: string, note?: string) {
     const today = formatDate(getToday());
     let clientData = await getClientData(getToday());
     if (!clientData.pizzaDay) {
-        throw Error("Pizza day pro dnešní den neexistuje");
+        throw new Error("Pizza day pro dnešní den neexistuje");
     }
     if (clientData.pizzaDay.state !== PizzaDayState.CREATED) {
-        throw Error("Pizza day není ve stavu " + PizzaDayState.CREATED);
+        throw new Error("Pizza day není ve stavu " + PizzaDayState.CREATED);
     }
     const myOrder = clientData.pizzaDay.orders!.find(o => o.customer === login);
     if (!myOrder?.pizzaList?.length) {
-        throw Error("Pizza day neobsahuje žádné objednávky uživatele " + login);
+        throw new Error("Pizza day neobsahuje žádné objednávky uživatele " + login);
     }
     myOrder.note = note;
     await storage.setData(today, clientData);
@@ -397,17 +397,17 @@ export async function updatePizzaFee(login: string, targetLogin: string, text?:
     const today = formatDate(getToday());
     let clientData = await getClientData(getToday());
     if (!clientData.pizzaDay) {
-        throw Error("Pizza day pro dnešní den neexistuje");
+        throw new Error("Pizza day pro dnešní den neexistuje");
     }
     if (clientData.pizzaDay.state !== PizzaDayState.CREATED) {
-        throw Error(`Pizza day není ve stavu ${PizzaDayState.CREATED}`);
+        throw new Error(`Pizza day není ve stavu ${PizzaDayState.CREATED}`);
     }
     if (clientData.pizzaDay.creator !== login) {
-        throw Error("Příplatky může měnit pouze zakladatel Pizza day");
+        throw new Error("Příplatky může měnit pouze zakladatel Pizza day");
     }
     const targetOrder = clientData.pizzaDay.orders!.find(o => o.customer === targetLogin);
     if (!targetOrder?.pizzaList?.length) {
-        throw Error(`Pizza day neobsahuje žádné objednávky uživatele ${targetLogin}`);
+        throw new Error(`Pizza day neobsahuje žádné objednávky uživatele ${targetLogin}`);
     }
     if (!price) {
         delete targetOrder.fee;
diff --git a/server/src/qr.ts b/server/src/qr.ts
index b1838b2..6da6b7d 100644
--- a/server/src/qr.ts
+++ b/server/src/qr.ts
@@ -34,7 +34,7 @@ export function convertBbanToIban(bankAccountNumber: string): string {
     const checkDigits = (BigInt(98) - remainder).toString().padStart(2, '0');
     iban = `${COUNTRY_CODE}${checkDigits}${bankCode}${prefix}${accountNumber}`;
     if (iban.length !== 24) {
-        throw Error("Neplatná délka sestaveného IBAN: " + iban.length + ", očekáváno 24");
+        throw new Error("Neplatná délka sestaveného IBAN: " + iban.length + ", očekáváno 24");
     }
     return iban;
 }
diff --git a/server/src/routes/foodRoutes.ts b/server/src/routes/foodRoutes.ts
index 6f9fadf..ba0c810 100644
--- a/server/src/routes/foodRoutes.ts
+++ b/server/src/routes/foodRoutes.ts
@@ -56,15 +56,15 @@ function checkRateLimit(key: string, limit: number = RATE_LIMIT): boolean {
  */
 const parseValidateFutureDayIndex = (req: Request<{}, any, AddChoiceData["body"] | UpdateNoteData["body"]>) => {
     if (req.body.dayIndex == null) {
-        throw Error(`Nebyl předán index dne v týdnu.`);
+        throw new Error(`Nebyl předán index dne v týdnu.`);
     }
     const todayDayIndex = getDayOfWeekIndex(getToday());
     const dayIndex = req.body.dayIndex;
     if (isNaN(dayIndex)) {
-        throw Error(`Neplatný index dne v týdnu: ${req.body.dayIndex}`);
+        throw new Error(`Neplatný index dne v týdnu: ${req.body.dayIndex}`);
     }
     if (dayIndex < todayDayIndex) {
-        throw Error(`Předaný index dne v týdnu (${dayIndex}) nesmí být nižší než dnešní den (${todayDayIndex})`);
+        throw new Error(`Předaný index dne v týdnu (${dayIndex}) nesmí být nižší než dnešní den (${todayDayIndex})`);
     }
     return dayIndex;
 }
@@ -72,7 +72,7 @@ const parseValidateFutureDayIndex = (req: Request<{}, any, AddChoiceData["body"]
 const parseSlot = (body: Record<string, any>): MealSlot | undefined => {
     const slot = body?.slot;
     if (slot != null && slot !== MealSlot.OBED) {
-        throw Error(`Neplatný slot: ${slot}`);
+        throw new Error(`Neplatný slot: ${slot}`);
     }
     return slot ?? undefined;
 };
@@ -153,7 +153,7 @@ router.post("/updateNote", async (req: Request<{}, any, UpdateNoteData["body"]>,
     try { slot = parseSlot(req.body); } catch (e: any) { return res.status(400).json({ error: e.message }); }
     try {
         if (note && note.length > 70) {
-            throw Error("Poznámka může mít maximálně 70 znaků");
+            throw new Error("Poznámka může mít maximálně 70 znaků");
         }
         let date = undefined;
         if (req.body.dayIndex != null) {
diff --git a/server/src/routes/pizzaDayRoutes.ts b/server/src/routes/pizzaDayRoutes.ts
index 757e370..435dfe2 100644
--- a/server/src/routes/pizzaDayRoutes.ts
+++ b/server/src/routes/pizzaDayRoutes.ts
@@ -30,10 +30,10 @@ router.post("/add", async (req: Request<{}, any, AddPizzaData["body"]>, res) =>
         const salatIndex = req.body.salatIndex;
         const salaty = await getSalatList();
         if (!salaty) {
-            throw Error("Selhalo získání seznamu dostupných salátů.");
+            throw new Error("Selhalo získání seznamu dostupných salátů.");
         }
         if (!salaty[salatIndex]) {
-            throw Error("Neplatný index salátu: " + salatIndex);
+            throw new Error("Neplatný index salátu: " + salatIndex);
         }
         const data = await addSalatOrder(login, salaty[salatIndex]);
         getWebsocket().emit("message", data);
@@ -41,22 +41,22 @@ router.post("/add", async (req: Request<{}, any, AddPizzaData["body"]>, res) =>
     } else {
         // Přidání pizzy
         if (req.body?.pizzaIndex === undefined || isNaN(req.body.pizzaIndex)) {
-            throw Error("Nebyl předán index pizzy ani salátu");
+            throw new Error("Nebyl předán index pizzy ani salátu");
         }
         const pizzaIndex = req.body.pizzaIndex;
         if (req.body?.pizzaSizeIndex === undefined || isNaN(req.body.pizzaSizeIndex)) {
-            throw Error("Nebyl předán index velikosti pizzy");
+            throw new Error("Nebyl předán index velikosti pizzy");
         }
         const pizzaSizeIndex = req.body.pizzaSizeIndex;
         let pizzy = await getPizzaList();
         if (!pizzy) {
-            throw Error("Selhalo získání seznamu dostupných pizz.");
+            throw new Error("Selhalo získání seznamu dostupných pizz.");
         }
         if (!pizzy[pizzaIndex]) {
-            throw Error("Neplatný index pizzy: " + pizzaIndex);
+            throw new Error("Neplatný index pizzy: " + pizzaIndex);
         }
         if (!pizzy[pizzaIndex].sizes[pizzaSizeIndex]) {
-            throw Error("Neplatný index velikosti pizzy: " + pizzaSizeIndex);
+            throw new Error("Neplatný index velikosti pizzy: " + pizzaSizeIndex);
         }
         const data = await addPizzaOrder(login, pizzy[pizzaIndex], pizzy[pizzaIndex].sizes[pizzaSizeIndex]);
         getWebsocket().emit("message", data);
@@ -67,7 +67,7 @@ router.post("/add", async (req: Request<{}, any, AddPizzaData["body"]>, res) =>
 router.post("/remove", async (req: Request<{}, any, RemovePizzaData["body"]>, res) => {
     const login = getLogin(parseToken(req));
     if (!req.body?.pizzaOrder) {
-        throw Error("Nebyla předána objednávka");
+        throw new Error("Nebyla předána objednávka");
     }
     const data = await removePizzaOrder(login, req.body?.pizzaOrder);
     getWebsocket().emit("message", data);
@@ -106,7 +106,7 @@ router.post("/updatePizzaDayNote", async (req: Request<{}, any, UpdatePizzaDayNo
     const login = getLogin(parseToken(req));
     try {
         if (req.body.note && req.body.note.length > 70) {
-            throw Error("Poznámka může mít maximálně 70 znaků");
+            throw new Error("Poznámka může mít maximálně 70 znaků");
         }
         const data = await updatePizzaDayNote(login, req.body.note);
         getWebsocket().emit("message", data);
diff --git a/server/src/service.ts b/server/src/service.ts
index 9b2b76e..6480303 100644
--- a/server/src/service.ts
+++ b/server/src/service.ts
@@ -485,13 +485,13 @@ export async function addChoice(login: string, trusted: boolean, locationKey: Lu
 async function validateFoodIndex(locationKey: LunchChoice, foodIndex?: number, date?: Date) {
     if (foodIndex != null) {
         if (typeof foodIndex !== 'number') {
-            throw Error(`Neplatný index ${foodIndex} typu ${typeof foodIndex}`);
+            throw new Error(`Neplatný index ${foodIndex} typu ${typeof foodIndex}`);
         }
         if (foodIndex < 0) {
-            throw Error(`Neplatný index ${foodIndex}`);
+            throw new Error(`Neplatný index ${foodIndex}`);
         }
         if (!Object.keys(Restaurant).includes(locationKey)) {
-            throw Error(`Neplatný index ${foodIndex} pro lokalitu ${locationKey} nepodporující indexy`);
+            throw new Error(`Neplatný index ${foodIndex} pro lokalitu ${locationKey} nepodporující indexy`);
         }
         const usedDate = date ?? getToday();
         const menu = await getRestaurantMenu(locationKey as Restaurant, usedDate);
@@ -543,7 +543,7 @@ export async function updateDepartureTime(login: string, time?: string, date?: D
             delete found[login].departureTime;
         } else {
             if (!Object.values<string>(DepartureTime).includes(time)) {
-                throw Error(`Neplatný čas odchodu ${time}`);
+                throw new Error(`Neplatný čas odchodu ${time}`);
             }
             found[login].departureTime = time;
         }
diff --git a/server/src/stats.ts b/server/src/stats.ts
index 66f5495..c12f4f5 100644
--- a/server/src/stats.ts
+++ b/server/src/stats.ts
@@ -22,13 +22,13 @@ export async function getStats(startDate: string, endDate: string): Promise<Week
     // Dočasná validace, aby to někdo ručně neshodil
     const daysDiff = ((end as any) - (start as any)) / (1000 * 60 * 60 * 24);
     if (daysDiff > 4) {
-        throw Error('Neplatný rozsah');
+        throw new Error('Neplatný rozsah');
     }
 
     const today = new Date();
     today.setHours(23, 59, 59, 999);
     if (end > today) {
-        throw Error('Nelze načíst statistiky pro budoucí datum');
+        throw new Error('Nelze načíst statistiky pro budoucí datum');
     }
 
     const result = [];
diff --git a/server/src/storage/index.ts b/server/src/storage/index.ts
index 3b611f5..fe6a468 100644
--- a/server/src/storage/index.ts
+++ b/server/src/storage/index.ts
@@ -20,7 +20,7 @@ if (!process.env.STORAGE || process.env.STORAGE?.toLowerCase() === JSON_KEY) {
 } else if (process.env.STORAGE?.toLowerCase() === MEMORY_KEY) {
     storage = new MemoryStorage();
 } else {
-    throw Error("Nepodporovaná hodnota proměnné STORAGE: " + process.env.STORAGE + ", podporované jsou 'json', 'redis' nebo 'memory'");
+    throw new Error("Nepodporovaná hodnota proměnné STORAGE: " + process.env.STORAGE + ", podporované jsou 'json', 'redis' nebo 'memory'");
 }
 
 export const storageReady: Promise<void> = storage.initialize
diff --git a/server/src/utils.ts b/server/src/utils.ts
index 41f70d4..cbb1751 100644
--- a/server/src/utils.ts
+++ b/server/src/utils.ts
@@ -90,7 +90,7 @@ export const parseToken = (req: any) => {
 export const checkQueryParams = (req: any, paramNames: string[]) => {
     for (const name of paramNames) {
         if (req.query[name] == null) {
-            throw Error(`Nebyl předán parametr '${name}' v query požadavku`);
+            throw new Error(`Nebyl předán parametr '${name}' v query požadavku`);
         }
     }
 }
@@ -105,7 +105,7 @@ export const checkQueryParams = (req: any, paramNames: string[]) => {
 export const checkBodyParams = (req: any, paramNames: string[]) => {
     for (const name of paramNames) {
         if (req.body[name] == null) {
-            throw Error(`Nebyl předán parametr '${name}' v těle požadavku`);
+            throw new Error(`Nebyl předán parametr '${name}' v těle požadavku`);
         }
     }
 }
diff --git a/server/src/voting.ts b/server/src/voting.ts
index e2c86f6..30d6bb9 100644
--- a/server/src/voting.ts
+++ b/server/src/voting.ts
@@ -40,7 +40,7 @@ export async function updateFeatureVote(login: string, option: FeatureRequest, a
     const index = data[login].indexOf(option);
     if (index > -1) {
         if (active) {
-            throw Error('Pro tuto možnost jste již hlasovali');
+            throw new Error('Pro tuto možnost jste již hlasovali');
         } else {
             data[login].splice(index, 1);
             if (data[login].length === 0) {
@@ -49,7 +49,7 @@ export async function updateFeatureVote(login: string, option: FeatureRequest, a
         }
     } else if (active) {
         if (data[login].length == 4) {
-            throw Error('Je možné hlasovat pro maximálně 4 možnosti');
+            throw new Error('Je možné hlasovat pro maximálně 4 možnosti');
         }
         data[login].push(option);
     }