@stamhoofd/backend-renderer 2.119.0 → 2.120.1

package/package.json

@@ -1,6 +1,7 @@
 {
     "name": "@stamhoofd/backend-renderer",
-    "version": "2.119.0",
+    "version": "2.120.1",
+    "type": "module",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -10,12 +11,14 @@
     "license": "UNLICENCED",
     "scripts": {
         "dev": "wait-on ../../shared/middleware/dist/index.js && concurrently -r 'yarn -s build --watch --preserveWatchOutput' \"wait-on ./dist/index.js && nodemon --quiet --inspect=5858 --watch dist --watch '../../../shared/*/dist/' --watch '../../shared/*/dist/' --ext .ts,.json,.sql,.js --watch .env.json --delay 1000ms --exec 'node --enable-source-maps ./dist/index.js' --signal SIGTERM\"",
+        "dev:build": "yarn -s build",
         "dev:full": "yarn -s dev",
-        "build": "tsc -b",
+        "build": "tsc --build tsconfig.build.json",
         "build:full": "yarn -s clear && yarn -s build",
-        "clear": "rm -rf ./dist",
+        "clear": "rm -rf ./dist && rm -f *.tsbuildinfo",
         "start": "yarn -s build && node --enable-source-maps ./dist/index.js",
-        "lint": "eslint"
+        "lint": "eslint",
+        "test": "vitest"
     },
     "devDependencies": {
         "@types/formidable": "3.4.5",
@@ -24,16 +27,16 @@
         "@types/node": "^22"
     },
     "dependencies": {
-        "@simonbackx/simple-endpoints": "1.20.1",
+        "@simonbackx/simple-endpoints": "1.21.0",
         "@simonbackx/simple-logging": "^1.0.1",
         "formidable": "3.5.4",
         "luxon": "3.4.4",
         "mockdate": "^3.0.2",
-        "mysql2": "^3.14.1",
+        "mysql2": "^3.20.0",
         "puppeteer": "^24.11.0"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "7bcbadd31fcc4f3109efc67c4034d1382a1d0439"
+    "gitHead": "00f65fc28d68feb86c30789784181a8954d638d7"
 }

package/src/boot.ts

@@ -22,7 +22,7 @@ const start = async () => {
     loadLogger();
     await I18n.load();
     const router = new Router();
-    await router.loadEndpoints(__dirname + '/endpoints');
+    await router.loadEndpoints(import.meta.dirname + '/endpoints');
     router.endpoints.push(new CORSPreflightEndpoint());
 
     const routerServer = new RouterServer(router);

package/src/endpoints/HtmlToPdfEndpoint.ts

@@ -1,11 +1,13 @@
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { verifyInternalSignature } from '@stamhoofd/backend-env';
 import { QueueHandler } from '@stamhoofd/queues';
 import formidable from 'formidable';
 import { firstValues } from 'formidable/src/helpers/firstValues.js';
 import { promises as fs } from 'fs';
-import puppeteer, { Browser } from 'puppeteer';
+import type { Browser } from 'puppeteer';
+import puppeteer from 'puppeteer';
 
 import { FileCache } from '../helpers/FileCache.js';
 
@@ -141,10 +143,10 @@ export class HtmlToPdfEndpoint extends Endpoint<Params, Query, Body, ResponseBod
         return response;
     }
 
-    browsers: ({ browser: Browser; count: number } | null)[] = [null, null, null, null];
-    nextBrowserIndex = 0;
+    static browsers: ({ browser: Browser; count: number } | null)[] = [null, null, null, null];
+    static nextBrowserIndex = 0;
 
-    async useBrowser<T>(callback: (browser: Browser) => Promise<T>): Promise<T> {
+    static async useBrowser<T>(callback: (browser: Browser) => Promise<T>): Promise<T> {
         console.log('Requesting browser');
         this.nextBrowserIndex++;
         if (this.nextBrowserIndex >= this.browsers.length) {
@@ -169,7 +171,7 @@ export class HtmlToPdfEndpoint extends Endpoint<Params, Query, Body, ResponseBod
         });
     }
 
-    async clearBrowser(browser: Browser) {
+    static async clearBrowser(browser: Browser) {
         try {
             await browser.close();
         }
@@ -186,7 +188,7 @@ export class HtmlToPdfEndpoint extends Endpoint<Params, Query, Body, ResponseBod
      * This will move to a different external service
      */
     async htmlToPdf(html: string, options: { retryCount: number; startDate: Date }): Promise<Uint8Array | null> {
-        const response = await this.useBrowser(async (browser) => {
+        const response = await HtmlToPdfEndpoint.useBrowser(async (browser) => {
             try {
                 // Create a new page
                 const page = await browser.newPage();

package/src/endpoints/PdfCacheEndpoint.ts

@@ -1,5 +1,7 @@
-import { AutoEncoder, DateDecoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { Decoder} from '@simonbackx/simple-encoding';
+import { AutoEncoder, DateDecoder, field, StringDecoder } from '@simonbackx/simple-encoding';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 
 import { FileCache } from '../helpers/FileCache.js';

package/src/endpoints/PrerenderEndpoint.test.ts

@@ -0,0 +1,102 @@
+import { Request, TestServer } from '@simonbackx/simple-endpoints';
+import { PrerenderEndpoint } from './PrerenderEndpoint.js';
+import nock from 'nock';
+import { STExpect } from '@stamhoofd/test-utils';
+import fs from 'fs/promises';
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await fs.access(path, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+describe('Endpoint.Prerender', () => {
+    const endpoint = new PrerenderEndpoint();
+    const testServer = new TestServer();
+
+    beforeAll(async () => {
+        await PrerenderEndpoint.fileCache.clear()
+    })
+
+    beforeEach(() => {
+        nock.enableNetConnect();
+    })
+
+    test('Returns 200 when healthy', async () => {
+        const request = Request.post({
+            path: '/prerender',
+            query: { 
+                url: 'https://shop.stamhoofd.be/test/'
+             },
+        });
+
+        const response = await testServer.test(endpoint, request);
+        expect(response.status).toBe(200);
+        expect(typeof response.body).toBe('string');
+        expect(response.body.startsWith('<!doctype html>')).toBe(true);
+    });
+
+    test('Uses cache', async () => {
+        nock.disableNetConnect();
+
+        const request = Request.post({
+            path: '/prerender',
+            query: { 
+                url: 'https://shop.stamhoofd.be/test/'
+             },
+        });
+
+        const response = await testServer.test(endpoint, request);
+        expect(response.status).toBe(200);
+        expect(typeof response.body).toBe('string');
+        expect(response.body.startsWith('<!doctype html>')).toBe(true);
+    });
+
+    test('Does not use stale cache', async () => {
+        nock.disableNetConnect();
+
+        const file = PrerenderEndpoint.fileCache.keyToFilePath('https://shop.stamhoofd.be/test/');
+        const mtimeMs = Date.now() - 13 * 60 * 1000 * 60;
+        await fs.utimes(file, mtimeMs / 1000, mtimeMs / 1000);
+
+        const request = Request.post({
+            path: '/prerender',
+            query: { 
+                url: 'https://shop.stamhoofd.be/test/'
+             },
+        });
+
+        await expect(testServer.test(endpoint, request)).rejects.toThrow(STExpect.simpleError({code: 'unavailable', statusCode: 503}))
+    });
+
+    test('Purges stale cache', async () => {
+        nock.disableNetConnect();
+
+        const file = PrerenderEndpoint.fileCache.keyToFilePath('https://shop.stamhoofd.be/test/');
+        const mtimeMs = Date.now() - 13 * 60 * 1000 * 60;
+        await fs.utimes(file, mtimeMs / 1000, mtimeMs / 1000);
+        expect(await fileExists(file)).toEqual(true);
+
+        await PrerenderEndpoint.fileCache.purgeCache(12 * 60 * 1000 * 60);
+
+        expect(await fileExists(file)).toEqual(false);
+    });
+
+    test('Returns 301 when redirecting to different domain locale', async () => {
+        const request = Request.post({
+            path: '/prerender',
+            query: { 
+                url: 'https://shop.stamhoofd.nl/test/'
+             },
+        });
+
+        const response = await testServer.test(endpoint, request);
+        expect(response.status).toBe(301);
+        expect(response.headers).toEqual(expect.objectContaining({
+            location: 'https://shop.stamhoofd.be/test/'
+        }))
+    });
+});

package/src/endpoints/PrerenderEndpoint.ts

@@ -0,0 +1,227 @@
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+
+import type { Decoder } from '@simonbackx/simple-encoding';
+import { AutoEncoder, field, URLDecoder } from '@simonbackx/simple-encoding';
+import { TTLFileCache } from '../helpers/TTLFileCache.js';
+import { HtmlToPdfEndpoint } from './HtmlToPdfEndpoint.js';
+
+type Params = Record<string, never>;
+type Body = undefined;
+class Query extends AutoEncoder {
+    @field({decoder: new URLDecoder()})
+    url: URL
+}
+
+type Data = {
+    html: string;
+    headers: Record<string, string>;
+    statusCode: number
+}
+
+type ResponseBody = string;
+
+/**
+ * One endpoint to create, patch and delete groups. Usefull because on organization setup, we need to create multiple groups at once. Also, sometimes we need to link values and update multiple groups at once
+ */
+
+export class PrerenderEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = Query as Decoder<Query>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'POST') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/prerender', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const url = request.query.url.href
+
+        console.log('Prerendering ' + url)
+
+        let data: Data | null = null;
+        try {
+            data = await PrerenderEndpoint.getUrlHtml(url, { retryCount: 2, startDate: new Date() });
+        }
+        catch (e) {
+            console.error(e);
+        }
+        if (!data) {
+            throw new SimpleError({
+                statusCode: 503,
+                code: 'unavailable',
+                message: 'Could not prerender',
+            });
+        }
+        const response = new Response(data.html);
+        data.headers['content-type'] = 'text/html'
+        response.headers = data.headers
+        response.status = data.statusCode
+        return response;
+    }
+    
+    static readonly CACHE_TTL_MS = 60 * 1000 * 60 * 12; // 12 hours
+    static fileCache = new TTLFileCache('prerender', this.CACHE_TTL_MS)
+
+    static async getUrlHtml(url: string, options: { retryCount: number; startDate: Date }): Promise<Data | null> {        
+        const existing = await this.fileCache.checkCache(url, this.CACHE_TTL_MS);
+        if (existing) {
+            try {
+                const d = JSON.parse(existing);
+
+                if (typeof d === 'object' && d !== null && 'html' in d && 'statusCode' in d && 'headers' in d)  {
+                    return d;
+                } else {
+                    console.error('Invalid cached data point for ' + url)
+                }
+            } catch (e) {
+                console.error(e);
+            }
+        }
+
+        const response = await HtmlToPdfEndpoint.useBrowser(async (browser) => {
+            try {
+                const page = await browser.newPage();
+
+                await page.setUserAgent({
+                    userAgent: 'prerender'
+                });
+
+                await page.setJavaScriptEnabled(true);
+                await page.emulateMediaType('screen');
+
+                // ── blockResources ────────────────────────────────────────────
+                // Block images, fonts, and media — we only need the HTML
+                await page.setRequestInterception(true);
+                const BLOCKED_RESOURCE_TYPES = new Set([
+                    'image', 'media', 'font',
+                    // Optionally also block these for extra speed:
+                    'stylesheet', 'texttrack', 'object', 'beacon', 'csp_violationreport', 'imageset',
+                ]);
+                page.on('request', (req) => {
+                    if (BLOCKED_RESOURCE_TYPES.has(req.resourceType())) {
+                        req.abort().catch(console.error);
+                    } else {
+                        req.continue().catch(console.error);
+                    }
+                });
+
+                // Navigate and wait until network is quiet
+                const gotoResponse = await page.goto(url, {
+                    waitUntil: 'networkidle0',
+                    timeout: 30000,
+                });
+
+                // ── httpHeaders ───────────────────────────────────────────────
+                // Read prerender meta tags and honour status/header overrides.
+                // e.g. <meta name="prerender-status-code" content="404">
+                //      <meta name="prerender-header" content="Location: /new-url">
+                const statusCode = gotoResponse?.status() ?? 200;
+                const metaStatusCode = await page
+                    .evaluate(() => {
+                        const el = document.querySelector('meta[name="prerender-status-code"]');
+                        return el ? parseInt(el.getAttribute('content') ?? '', 10) : null;
+                    })
+                    .catch(() => null);
+
+                const headers = gotoResponse?.headers();
+
+                let effectiveStatus = metaStatusCode ?? statusCode;
+                // Surface the status so callers can act on it if needed
+                let metaLocation: string | undefined = undefined;
+                if (effectiveStatus === 301 || effectiveStatus === 302) {
+                    const dmetaLocation = await page
+                        .evaluate(() => {
+                            const el = document.querySelector('meta[name="prerender-header"][content^="Location"]');
+                            return el ? el.getAttribute('content')?.replace(/^Location:\s*/i, '') : null;
+                        });
+                    if (dmetaLocation) {
+                        metaLocation = dmetaLocation
+                    } else {
+                        // something went wrong...
+                        console.error('Missing Location header')
+                        effectiveStatus = 500;
+                    }
+                }
+
+                // ── removeScriptTags + removePreloads ─────────────────────────
+                // Strip <script> tags and <link rel="preload|modulepreload"> from the DOM
+                await page.evaluate(() => {
+                    // Remove all script tags
+                    document.querySelectorAll('script').forEach((el) => el.remove());
+
+                    // Remove preload / modulepreload link tags (removePreloads plugin)
+                    document.querySelectorAll('link[rel="preload"][as="script"], link[rel="prefetch"][as="script"], link[rel="prefetch"][as="style"], link[rel="modulepreload"][as="script"]')
+                        .forEach((el) => el.remove());
+                });
+
+                // Ibject <base href="url here" />
+
+                if (STAMHOOFD.environment === 'test') {
+                    await page.evaluate(() => {
+                        const child = document.createElement('base');
+                        child.href = location.href; 
+                        document.head.prepend(child)
+
+                    });
+                }
+
+                const html = await page.evaluate(() => document.documentElement.outerHTML);
+                await page.close();
+
+                if (!headers) {
+                    return null;
+                }
+
+                // lowercase all headers
+                const cleanedHeaders: Record<string, string> = {};
+                for (const key of Object.keys(headers)) {
+                    if (!headers[key]) {
+                        continue;
+                    }
+                    const l = key.toLowerCase();
+                    if (['connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade', 'via', 'content-length', 'content-encoding', 'set-cookie', 'server'].includes(l)) {
+                        continue;
+                    }
+                    cleanedHeaders[l] = headers[key]
+                }
+
+                if (metaLocation) {
+                    cleanedHeaders.location = metaLocation;
+                }
+                delete cleanedHeaders.connection;
+
+                return {
+                    html: '<!doctype html>' + html, 
+                    statusCode: effectiveStatus, 
+                    headers: cleanedHeaders
+                };
+            } catch (e) {
+                console.error('Failed to render url', e);
+                return null;
+            }
+        });
+
+        // Retry logic
+        if (response === null && options.retryCount > 0 && Date.now() - options.startDate.getTime() < 15000) {
+            return this.getUrlHtml(url, { ...options, retryCount: options.retryCount - 1 });
+        }
+
+        // Store in cache
+        if (response !== null) {
+            await this.fileCache.cacheFile(url, JSON.stringify(response))
+            return response;
+
+        }
+        return null;
+
+    }
+}

package/src/helpers/FileCache.ts

@@ -1,6 +1,11 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { promises as fs } from 'fs';
 
+/**
+ * This cache does not use a TTL. 
+ * Instead it uses the updatedAt timestamp of a resource when caching. So we keep the cache forever unless the resource itself has changed.
+ * The cache requester passes the updatedAt timestamp, so this works flawlessly.
+ */
 export class FileCache {
     static async write(cacheId: string, timestamp: Date, data: Uint8Array | Buffer) {
         if (cacheId.includes('/')) {

package/src/helpers/TTLFileCache.ts

@@ -0,0 +1,91 @@
+import { Formatter } from '@stamhoofd/utility';
+import fs from 'fs/promises';
+import path from 'path';
+
+export class TTLFileCache {
+    private cachePath: string;
+
+    constructor(name: string, ttl: number) {
+        if (!STAMHOOFD.CACHE_PATH) {
+            throw new Error('Missing STAMHOOFD.CACHE_PATH')
+        }
+        this.cachePath = STAMHOOFD.CACHE_PATH + '/' + Formatter.slug(name)
+
+        // Clear on boot
+        this.clear().catch(console.error)
+    }
+
+     keyToFilePath(key: string): string {
+        // Percent-encode every character that isn't safe in a filename.
+        // Using encoding rather than replacement ensures the mapping is
+        // injective: no two distinct keys ever produce the same filename.
+        // Safe set: alphanumerics, hyphen, underscore, period.
+        // The percent sign itself is encoded as %25, so encoded output is
+        // always unambiguously decodable.
+        const safeKey = key.replace(/[^\w\-.]/g, (ch) => {
+            return '%' + ch.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0');
+        });
+        return path.join(this.cachePath, safeKey);
+    }
+
+
+    async cacheFile(key: string, contents: string): Promise<void> {
+        await fs.mkdir(this.cachePath, { recursive: true });
+        await fs.writeFile(this.keyToFilePath(key), contents, 'utf-8');
+    }
+
+    async checkCache(key: string, ttlMs?: number): Promise<string | null> {
+        const filePath = this.keyToFilePath(key);
+        try {
+            if (ttlMs !== undefined) {
+                const stat = await fs.stat(filePath);
+                if (stat.mtimeMs < Date.now() - ttlMs) {
+                    return null;
+                }
+            }
+            return await fs.readFile(filePath, 'utf-8');
+        } catch (err: unknown) {
+            if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+                return null;
+            }
+            throw err;
+        }
+    }
+
+    async clear() {
+        try {
+            await fs.rm(this.cachePath, {recursive: true})
+        } catch (e) {
+            // ignore
+        }
+    }
+
+    async purgeCache(ttlMs: number): Promise<void> {
+        let entries: string[];
+
+        try {
+            entries = await fs.readdir(this.cachePath);
+        } catch (err: unknown) {
+            if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+                return; // Cache directory doesn't exist yet — nothing to purge
+            }
+            throw err;
+        }
+
+        const cutoff = Date.now() - ttlMs;
+
+        await Promise.all(
+            entries.map(async (entry) => {
+                const filePath = path.join(this.cachePath, entry);
+                try {
+                    const stat = await fs.stat(filePath);
+                    if (stat.isFile() && stat.mtimeMs < cutoff) {
+                        await fs.unlink(filePath);
+                    }
+                } catch {
+                    // File may have been deleted concurrently — ignore
+                }
+            })
+        );
+    }
+}

package/{index.ts → src/index.ts}

@@ -5,7 +5,7 @@ backendEnv.load({ service: 'renderer' }).catch((error) => {
     console.error('Failed to load environment:', error);
     process.exit(1);
 }).then(async () => {
-    await import('./src/boot.js');
+    await import('./boot.js');
 }).catch((error) => {
     console.error('Failed to start the API:', error);
     process.exit(1);

package/stamhoofd.d.ts

@@ -1,3 +1,5 @@
+import '../../../environment.d.ts';
+
 export {};
 
 /**

package/tests/vitest.global.setup.ts

@@ -0,0 +1,20 @@
+// first import nock
+import nock from 'nock';
+
+// prevent nock import from being removed on save
+console.log('Imported nock: ', !!nock);
+
+import { TestUtils } from '@stamhoofd/test-utils';
+
+
+// Set timezone!
+process.env.TZ = 'UTC';
+
+// Quick check
+if (new Date().getTimezoneOffset() !== 0) {
+    throw new Error('Process should always run in UTC timezone');
+}
+
+export async function setup() {
+    TestUtils.globalSetup();
+};

package/tests/vitest.setup.ts

@@ -0,0 +1,31 @@
+// first import nock
+
+import { Column } from '@simonbackx/simple-database';
+import { Request } from '@simonbackx/simple-endpoints';
+import { Version } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+
+Error.stackTraceLimit = 100;
+
+// Set version of saved structures
+Column.setJSONVersion(Version);
+
+// Automatically set endpoint default version to latest one (only in tests!)
+Request.defaultVersion = Version;
+
+// Set timezone!
+process.env.TZ = 'UTC';
+
+// Quick check
+if (new Date().getTimezoneOffset() !== 0) {
+    throw new Error('Process should always run in UTC timezone');
+}
+
+console.log = () => {};
+
+beforeAll(async () => {
+    // Override default $t handlers
+    TestUtils.loadEnvironment();
+});
+TestUtils.setPermanentEnvironment('CACHE_PATH', import.meta.dirname + '/../.test-cache')
+TestUtils.setup();

package/tsconfig.build.json

@@ -0,0 +1,15 @@
+{
+    "extends": "../../../tsconfig.base.json",
+    "compilerOptions": {
+        "rootDir": "./src",
+        "outDir": "dist"
+    },
+    "include": [
+        "./src",
+        "./stamhoofd.d.ts"
+    ],
+    "exclude": [
+        "./src/**/*.spec.ts", 
+        "./src/**/*.test.ts"
+    ]
+}

package/tsconfig.json

@@ -1,34 +1,12 @@
 {
-    "compilerOptions": {
-        "target": "es2022", // needs to be es2019 to support optional chaining. Node.js doesn't support optional chaining yet, so we need the transpiling
-        "module": "commonjs",
-        "jsx": "preserve",
-        "importHelpers": true,
-        "moduleResolution": "node",
-        "experimentalDecorators": true,
-        "esModuleInterop": true,
-        "allowSyntheticDefaultImports": true,
-        "sourceMap": true,
-        "strictNullChecks": true,
-        "declaration": true,
-        "declarationMap": true,
-        "outDir": "dist",
-        "lib": [
-            "es2022",
-            "dom" // for puppeteer
-        ],
-        "types": [
-            "node",
-            "jest",
-            "@stamhoofd/backend-i18n",
-        ]
-    },
-    "include": [
-        "**/*.ts",
-        "../../../*.d.ts"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist"
+    "extends": "../../../tsconfig.base.json",
+    "files": [],
+    "references": [
+        {
+            "path": "./tsconfig.build.json"
+        },
+        {
+            "path": "./tsconfig.test.json"
+        }
     ]
 }

package/tsconfig.test.json

@@ -0,0 +1,17 @@
+{
+    "extends": "../../../tsconfig.test.json",
+    "compilerOptions": {
+        "rootDir": ".",
+        "outDir": "dist"
+    },
+    "references": [
+        { "path": "./tsconfig.build.json" }
+    ],
+    "include": [
+        "./stamhoofd.d.ts",
+        "../../../jest-extended.d.ts",
+        "./src/**/*.spec.ts", 
+        "./src/**/*.test.ts",
+        "./tests"
+    ]
+}

package/vitest.config.js

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globalSetup: './tests/vitest.global.setup.ts',
+        setupFiles: ['./tests/vitest.setup.ts'],
+        watch: false,
+        globals: true,
+        root: import.meta.dirname,
+        isolate: true,
+        maxWorkers: 1, // For now we can't run parallel because all test files use the same database
+    },
+});

package/eslint.config.mjs

@@ -1,5 +0,0 @@
-import stamhoofdEslint from 'eslint-plugin-stamhoofd';
-
-export default [
-    ...stamhoofdEslint.configs.backend,
-];