@stamhoofd/backend 2.39.1 → 2.40.1

package/src/helpers/CookieHelper.ts

@@ -1,45 +1,46 @@
-import { DecodedRequest, Response } from "@simonbackx/simple-endpoints";
+import { DecodedRequest, Response } from '@simonbackx/simple-endpoints';
 import cookie from 'cookie';
 
-type DecodedRequestWithCookies = DecodedRequest<any, any, any> & { cookies?: Record<string, string>}
+type DecodedRequestWithCookies = DecodedRequest<any, any, any> & { cookies?: Record<string, string> };
 
 export class CookieHelper {
     static getCookies(request: DecodedRequest<any, any, any>): Record<string, string> {
-        const r = request as DecodedRequestWithCookies
+        const r = request as DecodedRequestWithCookies;
         if (r.cookies) {
-            return r.cookies
+            return r.cookies;
         }
 
-        const header = r.headers.cookie
+        const header = r.headers.cookie;
         if (!header) {
-            r.cookies = {}
-            return r.cookies
+            r.cookies = {};
+            return r.cookies;
         }
 
         // Parse
-        r.cookies = cookie.parse(header)
-        return r.cookies
+        r.cookies = cookie.parse(header);
+        return r.cookies;
     }
 
     static getCookie(request: DecodedRequest<any, any, any>, name: string): string | undefined {
-        const cookies = this.getCookies(request)
-        return cookies[name]
+        const cookies = this.getCookies(request);
+        return cookies[name];
     }
 
-    static setCookie(response: Response<any>, name: string, value: string, options?: cookie.CookieSerializeOptions | undefined) {
-        const cookies = cookie.serialize(name, value, options)
-        let currentCookies = response.headers['set-cookie']
+    static setCookie(response: Response<any>, name: string, value: string, options?: cookie.CookieSerializeOptions) {
+        const cookies = cookie.serialize(name, value, options);
+        let currentCookies = response.headers['set-cookie'];
         if (!currentCookies) {
             response.headers['set-cookie'] = [
-                cookies
-            ]
-        } else {
+                cookies,
+            ];
+        }
+        else {
             if (!Array.isArray(currentCookies)) {
-                currentCookies = [currentCookies.toString()]
-                response.headers['set-cookie'] = currentCookies
+                currentCookies = [currentCookies.toString()];
+                response.headers['set-cookie'] = currentCookies;
             }
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            (currentCookies ).push(cookies)
+
+            (currentCookies).push(cookies);
         }
     }
-}
+}

package/src/helpers/EmailResumer.ts

@@ -1,7 +1,7 @@
-import { Email, Organization, User } from "@stamhoofd/models";
-import { SQL } from "@stamhoofd/sql";
-import { EmailStatus } from "@stamhoofd/structures";
-import { ContextInstance } from "./Context";
+import { Email, Organization, User } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { EmailStatus } from '@stamhoofd/structures';
+import { ContextInstance } from './Context';
 
 export async function resumeEmails() {
     const query = SQL.select()
@@ -13,25 +13,25 @@ export async function resumeEmails() {
 
     for (const email of emails) {
         if (!email.userId) {
-            console.warn('Cannot retry sending email because userId is not set - which is required for setting the scope', email.id)
+            console.warn('Cannot retry sending email because userId is not set - which is required for setting the scope', email.id);
             continue;
         }
         console.log('Resuming email that has sending status on boot', email.id);
 
         const user = await User.getByID(email.userId);
         if (!user) {
-            console.warn('Cannot retry sending email because user not found', email.id)
+            console.warn('Cannot retry sending email because user not found', email.id);
             continue;
         }
 
         const organization = email.organizationId ? (await Organization.getByID(email.organizationId)) : null;
         if (organization === undefined) {
-            console.warn('Cannot retry sending email because organization not found', email.id)
+            console.warn('Cannot retry sending email because organization not found', email.id);
             continue;
         }
-        
+
         await ContextInstance.startForUser(user, organization, async () => {
-            await email.send()
-        })
+            await email.send();
+        });
     }
 }

package/src/helpers/FileCache.ts

@@ -1,13 +1,13 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Formatter } from '@stamhoofd/utility';
-import basex from "base-x";
-import crypto from "crypto";
+import basex from 'base-x';
+import crypto from 'crypto';
 import fs from 'node:fs';
 import { Writable } from 'node:stream';
 import { Readable } from 'stream';
 
-const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'
-const baseEncoder = basex(ALPHABET)
+const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
+const baseEncoder = basex(ALPHABET);
 
 async function randomBytes(size: number): Promise<Buffer> {
     return new Promise((resolve, reject) => {
@@ -21,18 +21,17 @@ async function randomBytes(size: number): Promise<Buffer> {
     });
 }
 
-
 export class FileCache {
     static async getWriteStream(extension: '.xlsx'): Promise<{
-        file: string,
-        stream: WritableStream
+        file: string;
+        stream: WritableStream;
     }> {
         if (!STAMHOOFD.CACHE_PATH) {
             throw new SimpleError({
-                code: "not_configured",
-                message: "CACHE_PATH environment variable is not configured",
-                statusCode: 500
-            })
+                code: 'not_configured',
+                message: 'CACHE_PATH environment variable is not configured',
+                statusCode: 500,
+            });
         }
 
         // Generate a long and unguessable filename
@@ -41,42 +40,42 @@ export class FileCache {
 
         // Save in folder with the current day
         // Since this contains the day, we can easily restrict access to files after 1 day
-        const folder = STAMHOOFD.CACHE_PATH + "/" + path;
-        await fs.promises.mkdir(folder, { recursive: true })
+        const folder = STAMHOOFD.CACHE_PATH + '/' + path;
+        await fs.promises.mkdir(folder, { recursive: true });
 
         const s = fs.createWriteStream(folder + '/' + fileName, 'binary');
 
         s.on('close', () => {
-            console.log('FileCache closed file: File written to disk', folder + '/' + fileName)
+            console.log('FileCache closed file: File written to disk', folder + '/' + fileName);
         });
 
         return {
             file: path + '/' + fileName,
-            stream: Writable.toWeb(s)
-        }
+            stream: Writable.toWeb(s),
+        };
     }
 
-    static async read(file: string, dayTimeout = 1): Promise<{stream: Readable, contentLength: number, extension: string}> {
-        const splitted = file.split("/");
-        if (splitted.length != 2) {
+    static async read(file: string, dayTimeout = 1): Promise<{ stream: Readable; contentLength: number; extension: string }> {
+        const splitted = file.split('/');
+        if (splitted.length !== 2) {
             throw new SimpleError({
-                code: "invalid_file",
-                message: "Invalid file",
-                human: "Ongeldig bestand",
-                statusCode: 400
-            })
+                code: 'invalid_file',
+                message: 'Invalid file',
+                human: 'Ongeldig bestand',
+                statusCode: 400,
+            });
         }
 
         const fileName = splitted[1];
 
         const extension = fileName.substring(fileName.length - 5);
-        if (extension != '.xlsx') {
+        if (extension !== '.xlsx') {
             throw new SimpleError({
-                code: "invalid_file",
-                message: "Invalid file",
-                human: "Ongeldig bestand",
-                statusCode: 400
-            })
+                code: 'invalid_file',
+                message: 'Invalid file',
+                human: 'Ongeldig bestand',
+                statusCode: 400,
+            });
         }
 
         const fileNameWithoutExtension = fileName.substring(0, fileName.length - 5);
@@ -85,66 +84,67 @@ export class FileCache {
         for (const char of fileNameWithoutExtension) {
             if (!ALPHABET.includes(char)) {
                 throw new SimpleError({
-                    code: "invalid_file",
-                    message: "Invalid file",
-                    human: "Onbekend karakters in bestandsnaam",
-                    statusCode: 400
-                })
+                    code: 'invalid_file',
+                    message: 'Invalid file',
+                    human: 'Onbekend karakters in bestandsnaam',
+                    statusCode: 400,
+                });
             }
         }
 
         const path = splitted[0];
 
         // Verify date
-        if (path.length != 10) {
+        if (path.length !== 10) {
             throw new SimpleError({
-                code: "invalid_file",
-                message: "Invalid file",
-                human: "Ongelidge datum",
-                statusCode: 400
-            })
+                code: 'invalid_file',
+                message: 'Invalid file',
+                human: 'Ongelidge datum',
+                statusCode: 400,
+            });
         }
         const year = parseInt(path.substring(0, 4));
-        const month = parseInt(path.substring(5,  5 + 2));
+        const month = parseInt(path.substring(5, 5 + 2));
         const day = parseInt(path.substring(8, 8 + 2));
 
         if (isNaN(year) || isNaN(month) || isNaN(day)) {
             throw new SimpleError({
-                code: "invalid_file",
-                message: "Invalid file",
-                human: "Ongeldige datum",
-                statusCode: 400
-            })
+                code: 'invalid_file',
+                message: 'Invalid file',
+                human: 'Ongeldige datum',
+                statusCode: 400,
+            });
         }
 
         const date = new Date(year, month - 1, day, 0, 0, 0);
         const now = new Date();
         now.setHours(0, 0, 0, 0);
 
-        const diff = now.getTime() - date.getTime()
+        const diff = now.getTime() - date.getTime();
 
         if (date > now || diff > dayTimeout * 24 * 60 * 60 * 1000) {
             throw new SimpleError({
-                code: "file_expired",
-                message: "File expired",
-                human: "Het bestand is verlopen",
-                statusCode: 404
-            })
+                code: 'file_expired',
+                message: 'File expired',
+                human: 'Het bestand is verlopen',
+                statusCode: 404,
+            });
         }
 
-        const filePath = STAMHOOFD.CACHE_PATH + "/" + Formatter.dateIso(date) + "/" + fileName;
+        const filePath = STAMHOOFD.CACHE_PATH + '/' + Formatter.dateIso(date) + '/' + fileName;
 
         let stat: fs.Stats;
         try {
             stat = await fs.promises.stat(filePath);
-        } catch (e) {
+        }
+        catch (e) {
             if (e.code == 'ENOENT') {
                 throw new SimpleError({
-                    code: "file_expired",
-                    message: "File expired",
-                    human: "Het bestand bestaat niet",
-                    statusCode: 404
-                })
+                    code: 'file_expired',
+                    message: 'File expired',
+                    human: 'Het bestand bestaat niet',
+                    statusCode: 404,
+                });
             }
             throw e;
         }
@@ -152,7 +152,7 @@ export class FileCache {
         return {
             stream: fs.createReadStream(filePath),
             contentLength: stat.size,
-            extension
-        }
+            extension,
+        };
     }
 }