@stamhoofd/backend 2.39.1 → 2.40.0

package/src/endpoints/global/files/ExportToExcelEndpoint.ts

@@ -6,7 +6,7 @@ import { ArchiverWriterAdapter, exportToExcel, XlsxTransformerSheet, XlsxWriter
 import { Platform, RateLimiter, sendEmailTemplate } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { EmailTemplateType, ExcelExportRequest, ExcelExportResponse, ExcelExportType, IPaginatedResponse, LimitedFilteredRequest, Replacement, Version } from '@stamhoofd/structures';
-import { sleep } from "@stamhoofd/utility";
+import { sleep } from '@stamhoofd/utility';
 import { Context } from '../../../helpers/Context';
 import { fetchToAsyncIterator } from '../../../helpers/fetchToAsyncIterator';
 import { FileCache } from '../../../helpers/FileCache';
@@ -17,32 +17,32 @@ type Body = ExcelExportRequest;
 type ResponseBody = ExcelExportResponse;
 
 type ExcelExporter<T> = {
-    fetch(request: LimitedFilteredRequest): Promise<IPaginatedResponse<T[], LimitedFilteredRequest>>
-    sheets: XlsxTransformerSheet<T, unknown>[]
-}
+    fetch(request: LimitedFilteredRequest): Promise<IPaginatedResponse<T[], LimitedFilteredRequest>>;
+    sheets: XlsxTransformerSheet<T, unknown>[];
+};
 
 export const limiter = new RateLimiter({
     limits: [
-        {   
+        {
             // Max 200 per day
             limit: 200,
-            duration: 60 * 1000 * 60 * 24
-        }
-    ]
+            duration: 60 * 1000 * 60 * 24,
+        },
+    ],
 });
 
 export class ExportToExcelEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = ExcelExportRequest as Decoder<ExcelExportRequest>
+    bodyDecoder = ExcelExportRequest as Decoder<ExcelExportRequest>;
 
     // Other endpoints can register exports here
-    static loaders: Map<ExcelExportType, ExcelExporter<unknown>> = new Map()
+    static loaders: Map<ExcelExportType, ExcelExporter<unknown>> = new Map();
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/export/excel/@type", {type: String});
+        const params = Endpoint.parseParameters(request.url, '/export/excel/@type', { type: String });
 
         if (params) {
             return [true, params as Params];
@@ -52,33 +52,33 @@ export class ExportToExcelEndpoint extends Endpoint<Params, Query, Body, Respons
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         await Context.setOptionalOrganizationScope();
-        const {user} = await Context.authenticate()
+        const { user } = await Context.authenticate();
 
         if (user.isApiUser) {
             throw new SimpleError({
-                code: "not_allowed",
-                message: "API users are not allowed to export to Excel. The Excel export endpoint has a side effect of sending e-mails. Please use normal API endpoints to get the data you need.",
-                statusCode: 403
-            })
+                code: 'not_allowed',
+                message: 'API users are not allowed to export to Excel. The Excel export endpoint has a side effect of sending e-mails. Please use normal API endpoints to get the data you need.',
+                statusCode: 403,
+            });
         }
 
         if (QueueHandler.isRunning('user-export-to-excel-' + user.id)) {
             throw new SimpleError({
-                code: "not_allowed",
-                message: "Export is pending",
+                code: 'not_allowed',
+                message: 'Export is pending',
                 human: 'Je hebt momenteel al een Excel export lopen. Wacht tot die klaar is voor je een nieuwe export start.',
-                statusCode: 403
-            })
+                statusCode: 403,
+            });
         }
 
         const loader = ExportToExcelEndpoint.loaders.get(request.params.type as ExcelExportType);
-        
+
         if (!loader) {
             throw new SimpleError({
-                code: "invalid_type",
-                message: "Invalid type " + request.params.type,
-                statusCode: 400
-            })
+                code: 'invalid_type',
+                message: 'Invalid type ' + request.params.type,
+                statusCode: 400,
+            });
         }
 
         limiter.track(user.id, 1);
@@ -91,17 +91,16 @@ export class ExportToExcelEndpoint extends Endpoint<Params, Query, Body, Respons
                 if (sendEmail) {
                     await sendEmailTemplate(null, {
                         template: {
-                            type: EmailTemplateType.ExcelExportSucceeded
+                            type: EmailTemplateType.ExcelExportSucceeded,
                         },
                         recipients: [
                             user.createRecipient(Replacement.create({
                                 token: 'downloadUrl',
-                                value: url
-                            }))
+                                value: url,
+                            })),
                         ],
-                        type: 'transactional'
-                    })
-
+                        type: 'transactional',
+                    });
                 }
 
                 return url;
@@ -109,32 +108,32 @@ export class ExportToExcelEndpoint extends Endpoint<Params, Query, Body, Respons
                 if (sendEmail) {
                     await sendEmailTemplate(null, {
                         template: {
-                            type: EmailTemplateType.ExcelExportFailed
+                            type: EmailTemplateType.ExcelExportFailed,
                         },
                         recipients: [
-                            user.createRecipient()
+                            user.createRecipient(),
                         ],
-                        type: 'transactional'
-                    })
+                        type: 'transactional',
+                    });
                 }
-                throw error
+                throw error;
             }),
-            sleep(3000)
-        ])
+            sleep(3000),
+        ]);
 
         if (typeof result === 'string') {
             return new Response(ExcelExportResponse.create({
-                url: result
-            }))
+                url: result,
+            }));
         }
-        
+
         // We'll send an e-mail
         // Let the job know to send an e-mail when it is done
         sendEmail = true;
 
         return new Response(ExcelExportResponse.create({
-            url: null
-        }))
+            url: null,
+        }));
     }
 
     async job(loader: ExcelExporter<unknown>, request: ExcelExportRequest, type: string): Promise<string> {
@@ -145,7 +144,7 @@ export class ExportToExcelEndpoint extends Endpoint<Params, Query, Body, Respons
                 // Estimate how long it will take.
                 // If too long, we'll schedule it and write it to Digitalocean Spaces
                 // Otherwise we'll just return the file directly
-                const {file, stream} = await FileCache.getWriteStream('.xlsx');
+                const { file, stream } = await FileCache.getWriteStream('.xlsx');
 
                 const zipWriterAdapter = new ArchiverWriterAdapter(stream);
                 const writer = new XlsxWriter(zipWriterAdapter);
@@ -157,14 +156,14 @@ export class ExportToExcelEndpoint extends Endpoint<Params, Query, Body, Respons
                     definitions: loader.sheets,
                     writer,
                     dataGenerator: fetchToAsyncIterator(request.filter, loader),
-                    filter: request.workbookFilter
-                })
+                    filter: request.workbookFilter,
+                });
 
-                console.log('Done writing excel file')
+                console.log('Done writing excel file');
 
-                const url = 'https://'+ STAMHOOFD.domains.api + '/v'+ Version +'/file-cache?file=' + encodeURIComponent(file) + '&name=' + encodeURIComponent(type)
+                const url = 'https://' + STAMHOOFD.domains.api + '/v' + Version + '/file-cache?file=' + encodeURIComponent(file) + '&name=' + encodeURIComponent(type);
                 return url;
-            }, 2)
+            }, 2);
         });
     }
 }

package/src/endpoints/global/files/GetFileCache.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
 import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Readable } from 'node:stream';
@@ -9,11 +8,11 @@ import { RateLimiter } from '@stamhoofd/models';
 
 type Params = Record<never, never>;
 class Query extends AutoEncoder {
-    @field({ decoder: StringDecoder})
-    file: string
+    @field({ decoder: StringDecoder })
+    file: string;
 
     @field({ decoder: StringDecoder, optional: true })
-    name?: string
+    name?: string;
 }
 
 type Body = undefined;
@@ -21,23 +20,23 @@ type ResponseBody = Readable;
 
 export const limiter = new RateLimiter({
     limits: [
-        {   
+        {
             // Max 200 per day
             limit: 200,
-            duration: 60 * 1000 * 60 * 24
-        }
-    ]
+            duration: 60 * 1000 * 60 * 24,
+        },
+    ],
 });
 
 export class GetFileCache extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = Query as Decoder<Query>
+    queryDecoder = Query as Decoder<Query>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/file-cache", {});
+        const params = Endpoint.parseParameters(request.url, '/file-cache', {});
 
         if (params) {
             return [true, params as Params];
@@ -51,7 +50,7 @@ export class GetFileCache extends Endpoint<Params, Query, Body, ResponseBody> {
         limiter.track(request.request.getIP(), 1);
 
         // Return readable stream
-        const {stream, contentLength, extension} = await FileCache.read(request.query.file, 1);
+        const { stream, contentLength, extension } = await FileCache.read(request.query.file, 1);
 
         const response = new Response(stream);
         response.headers['Content-Type'] = 'application/octet-stream';
@@ -59,7 +58,8 @@ export class GetFileCache extends Endpoint<Params, Query, Body, ResponseBody> {
         if (request.query.name) {
             const slug = Formatter.fileSlug(request.query.name) + extension;
             response.headers['Content-Disposition'] = `attachment; filename="${slug}"`;
-        } else {
+        }
+        else {
             response.headers['Content-Disposition'] = `attachment; filename="bestand${extension}"`;
         }
         response.headers['Content-Length'] = contentLength.toString();

package/src/endpoints/global/files/UploadFile.ts

@@ -1,46 +1,44 @@
-
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { File } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import AWS from 'aws-sdk';
 import formidable from 'formidable';
-import { promises as fs } from "fs";
-import { v4 as uuidv4 } from "uuid";
+import { promises as fs } from 'fs';
+import { v4 as uuidv4 } from 'uuid';
 
 import { Context } from '../../../helpers/Context';
 import { limiter } from './UploadImage';
 
 type Params = Record<string, never>;
-type Query = {};
-type Body = undefined
-type ResponseBody = File
-
+type Query = Record<string, never>;
+type Body = undefined;
+type ResponseBody = File;
 
 interface FormidableFile {
-  // The size of the uploaded file in bytes.
-  // If the file is still being uploaded (see `'fileBegin'` event),
-  // this property says how many bytes of the file have been written to disk yet.
-  size: number;
+    // The size of the uploaded file in bytes.
+    // If the file is still being uploaded (see `'fileBegin'` event),
+    // this property says how many bytes of the file have been written to disk yet.
+    size: number;
 
-  // The path this file is being written to. You can modify this in the `'fileBegin'` event in
-  // case you are unhappy with the way formidable generates a temporary path for your files.
-  filepath: string;
+    // The path this file is being written to. You can modify this in the `'fileBegin'` event in
+    // case you are unhappy with the way formidable generates a temporary path for your files.
+    filepath: string;
 
-  // The name this file had according to the uploading client.
-  originalFilename: string | null;
+    // The name this file had according to the uploading client.
+    originalFilename: string | null;
 
-  // The mime type of this file, according to the uploading client.
-  mimetype: string | null;
+    // The mime type of this file, according to the uploading client.
+    mimetype: string | null;
 }
 
-export class UploadFile extends Endpoint<Params, Query, Body, ResponseBody> {    
+export class UploadFile extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/upload-file", {});
+        const params = Endpoint.parseParameters(request.url, '/upload-file', {});
 
         if (params) {
             return [true, params as Params];
@@ -50,23 +48,23 @@ export class UploadFile extends Endpoint<Params, Query, Body, ResponseBody> {
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        await Context.setOptionalOrganizationScope()
-        const {user} = await Context.authenticate();
+        await Context.setOptionalOrganizationScope();
+        const { user } = await Context.authenticate();
 
         if (!Context.auth.canUpload()) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
         if (!STAMHOOFD.SPACES_BUCKET || !STAMHOOFD.SPACES_ENDPOINT || !STAMHOOFD.SPACES_KEY || !STAMHOOFD.SPACES_SECRET) {
             throw new SimpleError({
-                code: "not_available",
-                message: "This endpoint is temporarily not available",
-                statusCode: 503
-            })
+                code: 'not_available',
+                message: 'This endpoint is temporarily not available',
+                statusCode: 503,
+            });
         }
 
         if (!request.request.request) {
-            throw new Error("Not supported without real request")
+            throw new Error('Not supported without real request');
         }
 
         limiter.track(user.id, 1);
@@ -75,9 +73,9 @@ export class UploadFile extends Endpoint<Params, Query, Body, ResponseBody> {
         const file = await new Promise<FormidableFile>((resolve, reject) => {
             if (!request.request.request) {
                 reject(new SimpleError({
-                    code: "invalid_request",
-                    message: "Invalid request",
-                    statusCode: 500
+                    code: 'invalid_request',
+                    message: 'Invalid request',
+                    statusCode: 500,
                 }));
                 return;
             }
@@ -87,26 +85,25 @@ export class UploadFile extends Endpoint<Params, Query, Body, ResponseBody> {
                     return;
                 }
 
-                if (!files.file || !Array.isArray(files.file) || files.file.length !== 1){
+                if (!files.file || !Array.isArray(files.file) || files.file.length !== 1) {
                     reject(new SimpleError({
-                        code: "missing_field",
-                        message: "Missing file",
-                        field: "file"
-                    }))
+                        code: 'missing_field',
+                        message: 'Missing file',
+                        field: 'file',
+                    }));
                     return;
                 }
-               
+
                 resolve(files.file[0]);
             });
         });
 
-
         if (!STAMHOOFD.SPACES_BUCKET || !STAMHOOFD.SPACES_ENDPOINT || !STAMHOOFD.SPACES_KEY || !STAMHOOFD.SPACES_SECRET) {
             throw new SimpleError({
-                code: "not_available",
-                message: "Uploading is not available",
-                statusCode: 503
-            })
+                code: 'not_available',
+                message: 'Uploading is not available',
+                statusCode: 503,
+            });
         }
 
         const fileContent = await fs.readFile(file.filepath);
@@ -114,33 +111,33 @@ export class UploadFile extends Endpoint<Params, Query, Body, ResponseBody> {
         const s3 = new AWS.S3({
             endpoint: STAMHOOFD.SPACES_ENDPOINT,
             accessKeyId: STAMHOOFD.SPACES_KEY,
-            secretAccessKey: STAMHOOFD.SPACES_SECRET
+            secretAccessKey: STAMHOOFD.SPACES_SECRET,
         });
 
-        let prefix = (STAMHOOFD.SPACES_PREFIX ?? "")
+        let prefix = (STAMHOOFD.SPACES_PREFIX ?? '');
         if (prefix.length > 0) {
-            prefix += "/"
+            prefix += '/';
         }
-        
+
         // Also include the source, in private mode
         const fileId = uuidv4();
-        const uploadExt = file.mimetype == "application/pdf" ? "pdf" : "pdf"
-        const filenameWithoutExt = file.originalFilename?.split(".").slice(0, -1).join(".") ?? fileId
-        const key = prefix+(STAMHOOFD.environment ?? "development")+"/"+fileId+"/" + (Formatter.slug(filenameWithoutExt) +"."+uploadExt);
+        const uploadExt = file.mimetype == 'application/pdf' ? 'pdf' : 'pdf';
+        const filenameWithoutExt = file.originalFilename?.split('.').slice(0, -1).join('.') ?? fileId;
+        const key = prefix + (STAMHOOFD.environment ?? 'development') + '/' + fileId + '/' + (Formatter.slug(filenameWithoutExt) + '.' + uploadExt);
         const params = {
             Bucket: STAMHOOFD.SPACES_BUCKET,
             Key: key,
             Body: fileContent, // TODO
-            ContentType: file.mimetype ?? "application/pdf",
-            ACL: "public-read"
+            ContentType: file.mimetype ?? 'application/pdf',
+            ACL: 'public-read',
         };
 
         const fileStruct = new File({
             id: fileId,
-            server: "https://"+STAMHOOFD.SPACES_BUCKET+"."+STAMHOOFD.SPACES_ENDPOINT,
+            server: 'https://' + STAMHOOFD.SPACES_BUCKET + '.' + STAMHOOFD.SPACES_ENDPOINT,
             path: key,
             size: fileContent.length,
-            name: file.originalFilename
+            name: file.originalFilename,
         });
 
         await s3.putObject(params).promise();

package/src/endpoints/global/files/UploadImage.ts

@@ -1,53 +1,52 @@
-
 import { Decoder, ObjectData } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Image, RateLimiter } from '@stamhoofd/models';
 import { Image as ImageStruct, ResolutionRequest } from '@stamhoofd/structures';
 import formidable from 'formidable';
-import { promises as fs } from "fs";
+import { promises as fs } from 'fs';
 
 import { Context } from '../../../helpers/Context';
 
 type Params = Record<string, never>;
-type Query = {};
-type Body = undefined
-type ResponseBody = ImageStruct
+type Query = Record<string, never>;
+type Body = undefined;
+type ResponseBody = ImageStruct;
 
 interface FormidableFile {
-  // The size of the uploaded file in bytes.
-  // If the file is still being uploaded (see `'fileBegin'` event),
-  // this property says how many bytes of the file have been written to disk yet.
-  size: number;
+    // The size of the uploaded file in bytes.
+    // If the file is still being uploaded (see `'fileBegin'` event),
+    // this property says how many bytes of the file have been written to disk yet.
+    size: number;
 
-  // The path this file is being written to. You can modify this in the `'fileBegin'` event in
-  // case you are unhappy with the way formidable generates a temporary path for your files.
-  filepath: string;
+    // The path this file is being written to. You can modify this in the `'fileBegin'` event in
+    // case you are unhappy with the way formidable generates a temporary path for your files.
+    filepath: string;
 
-  // The name this file had according to the uploading client.
-  originalFilename: string | null;
+    // The name this file had according to the uploading client.
+    originalFilename: string | null;
 
-  // The mime type of this file, according to the uploading client.
-  mimetype: string | null;
+    // The mime type of this file, according to the uploading client.
+    mimetype: string | null;
 }
 
 export const limiter = new RateLimiter({
     limits: [
-        {   
+        {
             // Max 50 per hour
             limit: 50,
-            duration: 60 * 1000 * 60
-        }
-    ]
+            duration: 60 * 1000 * 60,
+        },
+    ],
 });
 
-export class UploadImage extends Endpoint<Params, Query, Body, ResponseBody> {    
+export class UploadImage extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/upload-image", {});
+        const params = Endpoint.parseParameters(request.url, '/upload-image', {});
 
         if (params) {
             return [true, params as Params];
@@ -57,39 +56,39 @@ export class UploadImage extends Endpoint<Params, Query, Body, ResponseBody> {
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        await Context.setOptionalOrganizationScope()
-        const {user} = await Context.authenticate();
+        await Context.setOptionalOrganizationScope();
+        const { user } = await Context.authenticate();
 
         if (!Context.auth.canUpload()) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
         if (!STAMHOOFD.SPACES_BUCKET || !STAMHOOFD.SPACES_ENDPOINT || !STAMHOOFD.SPACES_KEY || !STAMHOOFD.SPACES_SECRET) {
             throw new SimpleError({
-                code: "not_available",
-                message: "This endpoint is temporarily not available",
-                statusCode: 503
-            })
+                code: 'not_available',
+                message: 'This endpoint is temporarily not available',
+                statusCode: 503,
+            });
         }
 
         if (!request.request.request) {
-            throw new Error("Not supported without real request")
+            throw new Error('Not supported without real request');
         }
 
         limiter.track(user.id, 1);
 
-        const form = formidable({ 
-            maxFileSize: 5 * 1024 * 1024, 
-            keepExtensions: true, 
-            maxFiles: 1 
+        const form = formidable({
+            maxFileSize: 5 * 1024 * 1024,
+            keepExtensions: true,
+            maxFiles: 1,
         });
 
         const [file, resolutions] = await new Promise<[FormidableFile, ResolutionRequest[]]>((resolve, reject) => {
             if (!request.request.request) {
                 reject(new SimpleError({
-                    code: "invalid_request",
-                    message: "Invalid request",
-                    statusCode: 500
+                    code: 'invalid_request',
+                    message: 'Invalid request',
+                    statusCode: 500,
                 }));
                 return;
             }
@@ -99,33 +98,34 @@ export class UploadImage extends Endpoint<Params, Query, Body, ResponseBody> {
                     reject(err);
                     return;
                 }
-                if (!fields.resolutions || !Array.isArray(fields.resolutions) || fields.resolutions.length !== 1){
+                if (!fields.resolutions || !Array.isArray(fields.resolutions) || fields.resolutions.length !== 1) {
                     reject(new SimpleError({
-                        code: "missing_field",
-                        message: "Field resolutions is required",
-                        field: "resolutions"
-                    }))
+                        code: 'missing_field',
+                        message: 'Field resolutions is required',
+                        field: 'resolutions',
+                    }));
                     return;
                 }
-                if (!files.file || !Array.isArray(files.file) || files.file.length !== 1){
+                if (!files.file || !Array.isArray(files.file) || files.file.length !== 1) {
                     reject(new SimpleError({
-                        code: "missing_field",
-                        message: "Missing file",
-                        field: "file"
-                    }))
+                        code: 'missing_field',
+                        message: 'Missing file',
+                        field: 'file',
+                    }));
                     return;
                 }
-                try {   
-                    const resolutions = new ObjectData(JSON.parse(fields.resolutions[0]), { version: request.request.getVersion() }).array(ResolutionRequest as Decoder<ResolutionRequest>)
+                try {
+                    const resolutions = new ObjectData(JSON.parse(fields.resolutions[0]), { version: request.request.getVersion() }).array(ResolutionRequest as Decoder<ResolutionRequest>);
                     resolve([files.file[0], resolutions]);
-                } catch (e) {
-                    reject(e)
+                }
+                catch (e) {
+                    reject(e);
                 }
             });
         });
 
         const fileContent = await fs.readFile(file.filepath);
-        const image = await Image.create(fileContent, file.mimetype ?? undefined, resolutions)
+        const image = await Image.create(fileContent, file.mimetype ?? undefined, resolutions);
         return new Response(ImageStruct.create(image));
     }
 }