implement members controller

packages/api/src/controllers/membersController.ts

@@ -1,13 +1,90 @@
-import { Controller, Route } from "@tsoa/runtime";
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Path,
+    Post,
+    Put,
+    Response,
+    Route,
+    Security,
+    SuccessResponse,
+} from "@tsoa/runtime";
 import { inject } from "../infrastructure/di/index.js";
+import { ErrorStates } from "../infrastructure/errorStates.js";
+import { Claim } from "../models/claim.js";
+import type { Member, MemberCreateArgs } from "../models/member.js";
+import { KC_SECURITY_NAME } from "../services/keycloak/user/index.js";
 import { MembersService } from "../services/membersService.js";
 
 @Route("members")
 export class MembersContoller extends Controller {
     private readonly membersService = inject(MembersService);
-    // @Security(KC_SECURITY_NAME)
+    @Security(KC_SECURITY_NAME, [Claim.MemberAdmin])
-    // @Get()
+    @Get()
-    // public async getMembers(): Promise<Member[]> {
+    public async getMembers(): Promise<Member[]> {
-    //     return await this.membersService.getMembers();
+        return await this.membersService.getMembers();
-    // }
+    }
+
+    @Security(KC_SECURITY_NAME, [Claim.MemberAdmin])
+    @SuccessResponse("200", "OK")
+    @Response(404, "Member not found")
+    @Get("{memberId}")
+    public async getMember(@Path() memberId: string): Promise<Member> {
+        try {
+            const foundMember =
+                await this.membersService.getMemberById(memberId);
+            return foundMember;
+        } catch (error) {
+            if (
+                error instanceof Error &&
+                error.cause === ErrorStates.ENTITY_NOT_FOUND
+            ) {
+                this.setStatus(404);
+                throw new Error(`Member with id ${memberId} not found`);
+            }
+            throw error;
+        }
+    }
+
+    @Security(KC_SECURITY_NAME, [Claim.MemberAdmin])
+    @SuccessResponse("201", "Created")
+    @Post()
+    public async createMember(
+        @Body() createArgs: MemberCreateArgs,
+    ): Promise<Member> {
+        return await this.membersService.createMember(createArgs);
+    }
+
+    @Security(KC_SECURITY_NAME, [Claim.MemberAdmin])
+    @SuccessResponse("200", "OK")
+    @Response(400, "Bad Request")
+    @Response(404, "Member not found")
+    @Put()
+    public async updateMember(@Body() member: Member): Promise<void> {
+        try {
+            await this.membersService.updateMember(member);
+        } catch (error) {
+            if (
+                error instanceof Error &&
+                error.cause === ErrorStates.BAD_REQUEST
+            ) {
+                this.setStatus(400);
+                throw new Error(`Member id is required for update`);
+            }
+            throw error;
+        }
+    }
+
+    @Security(KC_SECURITY_NAME, [Claim.MemberAdmin])
+    @SuccessResponse("200", "OK")
+    @Response(404, "Member not found")
+    @Delete("{memberId}")
+    public async scheduleDeletion(
+        @Path() memberId: string,
+        @Body() cancelDate: Date
+    ){
+        await this.membersService.scheduleDeletion(memberId, cancelDate);
+    }
 }

packages/api/src/index.ts

@@ -1,6 +1,6 @@
 import express from "express";
 import { RegisterRoutes } from "./generated/routes.js";
-import { sessionHandler } from "./infrastructure/session.js";
+import { sessionHandler } from "./infrastructure/sessionHandler.js";
 import { keycloak } from "./services/keycloak/user/index.js";
 
 const app = express();

packages/api/src/infrastructure/database.ts

@@ -1,2 +0,0 @@
-
-

packages/api/src/infrastructure/errorStates.ts

@@ -0,0 +1,5 @@
+export enum ErrorStates {
+    UNKNOWN_ERROR = 0,
+    ENTITY_NOT_FOUND = 1,
+    BAD_REQUEST = 2,
+}

packages/api/src/models/member.ts

@@ -1,17 +1,38 @@
+import { type MemberModel as DbMember } from "../generated/prisma/models.js";
+
 export interface Member {
-    id?: string | undefined;
+    id?: string | null;
-    vorname?: string | undefined;
+    vorname?: string | null;
-    nachname?: string | undefined;
+    nachname?: string | null;
-    geburtsdatum?: string | undefined;
+    geburtsdatum?: Date | null;
-    geburtsort?: string | undefined;
+    geburtsort?: string | null;
-    geschlecht?: string | undefined;
+    geschlecht?: string | null;
-    passnummer?: string | undefined;
+    passnummer?: string | null;
-    uvertrag?: boolean | undefined;
+    uvertrag?: boolean | null;
-    verein?: boolean | undefined;
+    verein?: boolean | null;
-    graduierung?: string | undefined;
+    graduierung?: string | null;
-    letztePruefung?: string | undefined;
+    letztePruefung?: Date | null;
-    kontakt?: string | undefined;
+    kontakt?: string | null;
-    kuendigungzum?: string | undefined;
+    kuendigungzum?: Date | null;
-    loeschenam?: string | undefined;
+    loeschenam?: string | null;
-    level?: string | undefined;
+}
+
+export type MemberCreateArgs = Omit<Member, "id" | "loeschenam">;
+
+export function mapDbMemberToMember(dbMember: DbMember): Member {
+    return {
+        geburtsdatum: dbMember.geburtsdatum,
+        id: dbMember.id,
+        nachname: dbMember.nachname,
+        geburtsort: dbMember.geburtsort,
+        geschlecht: dbMember.geschlecht,
+        graduierung: dbMember.graduierung,
+        vorname: dbMember.vorname,
+        kontakt: dbMember.kontakt,
+        kuendigungzum: dbMember.kuendigungzum,
+        letztePruefung: dbMember.letztePruefung,
+        passnummer: dbMember.passnummer,
+        uvertrag: dbMember.uvertrag,
+        verein: dbMember.verein,
+    };
 }

packages/api/src/services/db/prisma.ts

@@ -0,0 +1,62 @@
+import { PrismaPg } from "@prisma/adapter-pg";
+import { PrismaClient } from "../../generated/prisma/client.js";
+
+type ExtendedClient = ReturnType<typeof createExtendedClient>;
+
+export type SafeClient = Omit<
+    ExtendedClient,
+    | "$connect"
+    | "$disconnect"
+    | "$on"
+    | "$transaction"
+    | "$executeRaw"
+    | "$executeRawUnsafe"
+    | "$queryRaw"
+    | "$queryRawUnsafe"
+    | "$extends"
+>;
+
+function createExtendedClient(client: PrismaClient) {
+    return client;
+    // .$extends({
+    //     name: "testExtension",
+    //     model: {
+    //         member: {
+    //             withFullName(member: Member) {
+    //                 return {
+    //                     ...member,
+    //                     fullName: ` ${member.vorname} ${member.nachname}`,
+    //                 };
+    //             },
+    //         },
+    //     },
+    // });
+}
+
+export class DatabaseService {
+    private readonly prismaClient: ExtendedClient;
+    private readonly safeClient: SafeClient;
+
+    public constructor() {
+        const dbUser = process.env["TKD_DB_USER"];
+        const dbPassword = process.env["TKD_DB_PASSWORD"];
+        const dbHost = process.env["TKD_DB_HOST"];
+
+        const connectionString = `postgresql://${dbUser}:${dbPassword}@${dbHost}:5432/taekwondo?schema=public`;
+
+        const adapter = new PrismaPg({ connectionString });
+        this.prismaClient = createExtendedClient(new PrismaClient({ adapter }));
+        this.safeClient = this.prismaClient as SafeClient;
+
+        // this.prismaClient.$connect();
+        // this.prismaClient.$disconnect();
+        // this.prismaClient.$on();
+        // this.prismaClient.$transaction();
+    }
+
+    public async doRequest<T>(
+        request: (prisma: SafeClient) => Promise<T>,
+    ): Promise<T> {
+        return await request(this.safeClient);
+    }
+}

packages/api/src/services/keycloak/user/keycloak-user.ts

@@ -1,5 +1,5 @@
 import KeycloakConnect from "keycloak-connect";
-import { sessionStore } from "../../../infrastructure/session.js";
+import { sessionStore } from "../../../infrastructure/sessionHandler.js";
 import keycloakConfig from "./keycloak.json" with { type: "json" };
 
 export const KC_SECURITY_NAME = "bearerAuth";

packages/api/src/services/membersService.ts

@@ -1,6 +1,67 @@
-import { Injectable } from "../infrastructure/di/index.js";
+import { inject, Injectable } from "../infrastructure/di/index.js";
+import { ErrorStates } from "../infrastructure/errorStates.js";
+import {
+    type Member,
+    type MemberCreateArgs,
+    mapDbMemberToMember,
+} from "../models/member.js";
+import { DatabaseService } from "./db/prisma.js";
 
 @Injectable()
 export class MembersService {
-    // public async getMembers(): Promise<Member[]> {}
+    private readonly database = inject(DatabaseService);
+
+    public async getMembers(): Promise<Member[]> {
+        const dbMembers = await this.database.doRequest(prisma =>
+            prisma.member.findMany(),
+        );
+        return dbMembers.map(mapDbMemberToMember);
+    }
+
+    public async getMemberById(memberId: string): Promise<Member> {
+        const member = await this.database.doRequest(prisma =>
+            prisma.member.findFirst({ where: { id: memberId } }),
+        );
+
+        if (!member) {
+            throw new Error(`Member with id ${memberId} not found`, {
+                cause: ErrorStates.ENTITY_NOT_FOUND,
+            });
+        }
+
+        return mapDbMemberToMember(member);
+    }
+
+    public async createMember(createArgs: MemberCreateArgs): Promise<Member> {
+        const newMember = await this.database.doRequest(prisma =>
+            prisma.member.create({ data: createArgs }),
+        );
+        return mapDbMemberToMember(newMember);
+    }
+
+    public async updateMember(member: Member): Promise<Member> {
+        const id = member.id;
+        if (!id) {
+            throw new Error("Member id is required for update", {
+                cause: ErrorStates.BAD_REQUEST,
+            });
+        }
+        const modifiedMember = await this.database.doRequest(prisma =>
+            prisma.member.update({
+                data: { ...member, id: id },
+                where: { id: id },
+            }),
+        );
+
+        return mapDbMemberToMember(modifiedMember);
+    }
+
+    public async scheduleDeletion(memberId: string, cancelDate: Date) {
+        await this.database.doRequest(prisma =>
+            prisma.member.update({
+                where: { id: memberId },
+                data: { kuendigungzum: cancelDate },
+            }),
+        );
+    }
 }