Added repositories, made database unit-testable.

backend/.env.test

@@ -0,0 +1,3 @@
+PORT=3000
+DWENGO_DB_UPDATE=true
+DWENGO_DB_NAME=":memory:"

backend/config/db/init.sql

@@ -1,2 +0,0 @@
--- Create the database
-CREATE DATABASE dwengo;

backend/package.json

@@ -11,12 +11,13 @@
         "format": "prettier --write src/",
         "format-check": "prettier --check src/",
         "lint": "eslint . --fix",
-        "test:unit": "vitest --run"
+        "test:unit": "vitest"
     },
     "dependencies": {
-        "@mikro-orm/core": "^6.4.6",
-        "@mikro-orm/postgresql": "^6.4.6",
-        "@mikro-orm/reflection": "^6.4.6",
+        "@mikro-orm/core": "6.4.6",
+        "@mikro-orm/postgresql": "6.4.6",
+        "@mikro-orm/sqlite": "6.4.6",
+        "@mikro-orm/reflection": "6.4.6",
         "dotenv": "^16.4.7",
         "express": "^5.0.1",
         "uuid": "^11.1.0"

backend/src/app.ts

@@ -1,5 +1,5 @@
 import express, { Express, Response } from 'express';
-import initORM from './orm.js';
+import { initORM } from './orm.js';
 
 const app: Express = express();
 const port: string | number = process.env.PORT || 3000;
@@ -19,4 +19,4 @@ async function startServer() {
     });
 }
 
-startServer();
+await startServer();

backend/src/data/dwengo-entity-repository.ts

@@ -0,0 +1,17 @@
+import {EntityRepository, FilterQuery} from "@mikro-orm/core";
+
+export abstract class DwengoEntityRepository<T extends object> extends EntityRepository<T> {
+    public async save(entity: T) {
+        let em = this.getEntityManager();
+        em.persist(entity);
+        await em.flush();
+    }
+    public async deleteWhere(query: FilterQuery<T>) {
+        let toDelete = await this.findOne(query);
+        let em = this.getEntityManager();
+        if (toDelete) {
+            em.remove(toDelete);
+            await em.flush();
+        }
+    }
+}

backend/src/data/users/student-repository.ts

@@ -0,0 +1,11 @@
+import {DwengoEntityRepository} from "../dwengo-entity-repository";
+import {Student} from "../../entities/users/student.entity";
+
+export class StudentRepository extends DwengoEntityRepository<Student> {
+    public findByUsername(username: string): Promise<Student | null> {
+        return this.findOne({username: username});
+    }
+    public deleteByUsername(username: string): Promise<void> {
+        return this.deleteWhere({username: username});
+    }
+}

backend/src/entities/users/student.entity.ts

@@ -2,12 +2,17 @@ import {User} from "./user.entity";
 import {Collection, Entity, ManyToMany} from '@mikro-orm/core';
 import {Class} from "../classes/class.entity";
 import {Group} from "../assigments/group.entity";
+import {StudentRepository} from "../../data/users/student-repository";
 
-@Entity()
+@Entity({repository: () => StudentRepository})
 export class Student extends User {
     @ManyToMany(() => Class)
     classes!: Collection<Class>;
 
     @ManyToMany(() => Group)
     groups!: Collection<Group>;
+
+    constructor(public username: string, public firstName: string, public lastName: string) {
+        super();
+    }
 }

backend/src/mikro-orm.config.ts

@@ -1,17 +1,35 @@
 import {Options} from '@mikro-orm/core';
 import {PostgreSqlDriver} from "@mikro-orm/postgresql";
 import {EnvVars, getEnvVar, getNumericEnvVar} from "./util/envvars";
+import {SqliteDriver} from "@mikro-orm/sqlite";
 
-const config: Options = {
+const entities = ['dist/**/*.entity.js'];
+const entitiesTs = ['src/**/*.entity.ts'];
+function config(testingMode: boolean = false): Options {
+    if (testingMode) {
+        return {
+            driver: SqliteDriver,
+            dbName: getEnvVar(EnvVars.DbName),
+            entities: entities,
+            entitiesTs: entitiesTs,
+
+            // Workaround: vitest: `TypeError: Unknown file extension ".ts"` (ERR_UNKNOWN_FILE_EXTENSION)
+            // (see https://mikro-orm.io/docs/guide/project-setup#testing-the-endpoint)
+            dynamicImportProvider: id => import(id)
+        };
+    } else {
+        return {
             driver: PostgreSqlDriver,
-    host: getEnvVar(EnvVars.DbHost, {required: true}),
-    port: getNumericEnvVar(EnvVars.DbPort, {defaultValue: 5432}),
-    dbName: getEnvVar(EnvVars.DbName, {defaultValue: "dwengo"}),
-    user: getEnvVar(EnvVars.DbUsername, {required: true}),
-    password: getEnvVar(EnvVars.DbPassword, {required: true}),
-    entities: ['dist/**/*.entity.js'],
-    entitiesTs: ['src/**/*.entity.ts'],
-    debug: true,
-};
+            host: getEnvVar(EnvVars.DbHost),
+            port: getNumericEnvVar(EnvVars.DbPort),
+            dbName: getEnvVar(EnvVars.DbName),
+            user: getEnvVar(EnvVars.DbUsername),
+            password: getEnvVar(EnvVars.DbPassword),
+            entities: entities,
+            entitiesTs: entitiesTs,
+            debug: true
+        };
+    }
+}
 
 export default config;

backend/src/orm.ts

@@ -1,10 +1,10 @@
-import { MikroORM } from '@mikro-orm/core';
+import {AnyEntity, EntityName, EntityRepository, MikroORM} from '@mikro-orm/core';
 import config from './mikro-orm.config.js';
 import {EnvVars, getEnvVar} from "./util/envvars";
 
-export default async function initORM() {
-    const orm = await MikroORM.init(config);
-
+let orm: MikroORM | undefined;
+export async function initORM(testingMode: boolean = false) {
+    orm = await MikroORM.init(config(testingMode));
     // Update the database scheme if necessary and enabled.
     if (getEnvVar(EnvVars.DbUpdate)) {
         await orm.schema.updateSchema();
@@ -17,3 +17,10 @@ export default async function initORM() {
         }
     }
 }
+
+export function getRepository<T extends AnyEntity>(entityName: EntityName<T>): EntityRepository<T> {
+    if (orm === undefined) {
+        throw new Error("ORM is not initialized yet");
+    }
+    return orm.em.fork().getRepository(entityName);
+}

backend/src/util/envvars.ts

@@ -1,15 +1,15 @@
 const PREFIX = "DWENGO_";
 const DB_PREFIX = PREFIX + "DB_";
 
-type EnvVar = {[key: string]: {name: string, required?: boolean, defaultValue?: boolean}};
+type EnvVar = {key: string, required?: boolean, defaultValue?: any}
 
-export const EnvVars: EnvVar = {
-    DbHost: {key: DB_PREFIX + "HOST", required: true},
-    DbPort: {key: DB_PREFIX + "PORT", defaultValue: 5432},
-    DbName: {key: DB_PREFIX + "NAME", defaultValue: "dwengo"},
-    DbUsername: {key: DB_PREFIX + "USERNAME", required: true},
-    DbPassword: {key: DB_PREFIX + "PASSWORD", required: true},
-    DbUpdate: {key: DB_PREFIX + "UPDATE", defaultValue: false},
+export const EnvVars: {[key: string]: EnvVar} = {
+    "DbHost": {key: DB_PREFIX + "HOST", required: true},
+    "DbPort": {key: DB_PREFIX + "PORT", defaultValue: 5432},
+    "DbName": {key: DB_PREFIX + "NAME", defaultValue: "dwengo"},
+    "DbUsername": {key: DB_PREFIX + "USERNAME", required: true},
+    "DbPassword": {key: DB_PREFIX + "PASSWORD", required: true},
+    "DbUpdate": {key: DB_PREFIX + "UPDATE", defaultValue: false},
 } as const;
 
 /**

backend/tests/data/users.test.ts

@@ -0,0 +1,33 @@
+import {initializeTests} from "../testutils"
+import {Student} from "../../src/entities/users/student.entity";
+import {describe, it, expect, beforeAll} from "vitest";
+import {getRepository} from "../../src/orm";
+import {StudentRepository} from "../../src/data/users/student-repository";
+
+const username = "teststudent";
+const firstName = "John";
+const lastName = "Doe";
+describe("StudentRepository", () => {
+    let studentRepository: StudentRepository;
+
+    beforeAll(async () => {
+        await initializeTests()
+        studentRepository = getRepository(Student) as StudentRepository;
+    });
+
+    it("should return the queried student after he was added", async () => {
+        await studentRepository.insert(new Student(username, firstName, lastName));
+
+        let retrievedStudent = await studentRepository.findByUsername(username);
+        expect(retrievedStudent).toBeTruthy();
+        expect(retrievedStudent?.firstName).toBe(firstName);
+        expect(retrievedStudent?.lastName).toBe(lastName);
+    });
+
+    it("should no longer return the queried student after he was removed again", async () => {
+        await studentRepository.deleteByUsername(username);
+
+        let retrievedStudent = await studentRepository.findByUsername(username);
+        expect(retrievedStudent).toBeNull();
+    });
+});

backend/tests/example.test.ts

@@ -4,6 +4,6 @@ describe("Sample test", () => {
     it("should sum to 2", () => {
         const expected = 2;
         const result = 1 + 1;
-        expect(result).toBe(expected);
+        expect(result).equals(expected);
     });
 })

backend/tests/testutils.ts

@@ -0,0 +1,7 @@
+import {initORM} from "../src/orm";
+import dotenv from "dotenv";
+
+export async function initializeTests() {
+    dotenv.config({path: ".env.test"});
+    await initORM(true);
+}

backend/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        environment: 'node',
+        globals: true
+    }
+});