Ajout des routes en lien avec l'authentification

package.json

@@ -10,6 +10,7 @@
     "db:migrate": "bun --bun drizzle-kit migrate"
   },
   "dependencies": {
+    "@elysiajs/jwt": "^1.4.0",
     "drizzle-orm": "^0.44.7",
     "drizzle-typebox": "^0.3.3",
     "elysia": "latest",

src/index.ts

@@ -1,7 +1,8 @@
 import { Elysia } from 'elysia';
+import { authenticationModule } from './modules/authentication';
 import { eventsModule } from './modules/events';
 import { seriesModule } from './modules/series';
 
-const app = new Elysia().use(seriesModule).use(eventsModule).listen(3000);
+const app = new Elysia().use(authenticationModule).use(seriesModule).use(eventsModule).listen(3000);
 
 console.log(`🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`);

src/modules/authentication/index.ts

@@ -0,0 +1,14 @@
+import Elysia from 'elysia';
+import { AuthenticationModel } from './model';
+import { AuthenticationService } from './service';
+
+export const authenticationModule = new Elysia({ prefix: '/authentication' })
+  // POST /authentication/register
+  // Créer un nouvel utilisateur
+  .post('/register', async ({ body }) => AuthenticationService.createUser(body), {
+    body: AuthenticationModel.createUsersBody,
+  })
+  // DELETE /authentication/delete
+  .delete('/delete', async ({ body }) => AuthenticationService.deleteUser(body), {
+    body: AuthenticationModel.deleteUsersBody,
+  });

src/modules/authentication/model.ts

@@ -0,0 +1,27 @@
+import { UserRoles } from '@/utils/db/schema';
+import { t } from 'elysia';
+
+export namespace AuthenticationModel {
+  export const createUsersBody = t.Object({
+    name: t.String({
+      minLength: 1,
+    }),
+    role: t.UnionEnum(UserRoles, {
+      default: undefined,
+    }),
+  });
+
+  export type CreateUserBody = typeof createUsersBody.static;
+
+  export const findUsersByNameBody = t.Object({
+    name: t.String({ minLength: 1 }),
+  });
+
+  export type FindUserByNameBody = typeof findUsersByNameBody.static;
+
+  export const deleteUsersBody = t.Object({
+    id: t.String({ format: 'uuid' }),
+  });
+
+  export type DeleteUserBody = typeof deleteUsersBody.static;
+}

src/modules/authentication/service.ts

@@ -0,0 +1,36 @@
+import { db } from '@/utils/db';
+import { usersTable } from '@/utils/db/schema';
+import { eq } from 'drizzle-orm';
+import { status } from 'elysia';
+import { AuthenticationModel } from './model';
+
+export abstract class AuthenticationService {
+  static async findUserByName(data: AuthenticationModel.FindUserByNameBody) {
+    return db.query.usersTable.findFirst({
+      where: eq(usersTable.name, data.name),
+    });
+  }
+
+  static async createUser(data: AuthenticationModel.CreateUserBody) {
+    const existingUser = await AuthenticationService.findUserByName(data);
+    if (existingUser) {
+      throw status(409, 'Un utilisateur avec ce nom existe déjà.');
+    }
+
+    const [createdUser] = await db.insert(usersTable).values(data).returning();
+
+    return status(201, createdUser);
+  }
+
+  static async deleteUser(data: AuthenticationModel.DeleteUserBody) {
+    const [deletedUser] = await db.delete(usersTable).where(eq(usersTable.id, data.id)).returning({
+      id: usersTable.id,
+    });
+
+    if (!deletedUser) {
+      throw status(404);
+    }
+
+    return status(204);
+  }
+}

src/utils/db/schema.ts

@@ -1,6 +1,21 @@
 import { relations } from 'drizzle-orm';
 import { integer, pgEnum, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
 
+/**
+ * Énumération des rôles attribuables à un utilisateur
+ */
+export const UserRoles = ['TO'] as [string, ...string[]];
+export const userRoles = pgEnum('user_roles', UserRoles);
+
+/**
+ * Tables des utilisateurs
+ */
+export const usersTable = pgTable('users', {
+  id: uuid().defaultRandom().primaryKey(),
+  name: text().notNull().unique(),
+  role: userRoles().notNull(),
+});
+
 /**
  * Table des séries d'événements
  */