Main ts

backend/.eslintrc.cjs

@@ -1,9 +1,14 @@
 module.exports = {
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint'],
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended'
+  ],
   env: {
     browser: true,
     es2021: true
   },
-  extends: 'standard',
   overrides: [
   ],
   parserOptions: {

backend/middlewares/auth.js → backend/middlewares/auth.ts

@@ -1,15 +1,9 @@
 import jwt from 'jsonwebtoken'
-import { JWT_SECRET } from '../consts/secret.js'
-/**
- * Middleware function type import
- * @typedef {import('express').RequestHandler} RequestHandler
- */
+import { JWT_SECRET } from '../consts/secret'
+import {Request, Response, NextFunction} from "express";
+import {Token} from "../types/types";
 
-/**
- * Middleware for authentification
- * @type {RequestHandler}
- */
-const authMiddleware = (req, res, next) => {
+const authMiddleware = (req: Request & {user?: Token}, res: Response, next: NextFunction) => {
   // Récupération du token d'authentification depuis le header Authorization
   const authHeader = req.headers.authorization
   const token = authHeader && authHeader.split(' ')[1]
@@ -26,7 +20,7 @@ const authMiddleware = (req, res, next) => {
     }
 
     // Ajout des informations du token décodé à l'objet de requête pour être utilisées par les routes suivantes
-    req.user = decodedToken
+    req.user = decodedToken as Token
     next()
   })
 }

backend/orm/database.ts

@@ -0,0 +1,11 @@
+import { Sequelize } from 'sequelize-typescript';
+import {Product} from "./models/product.js";
+import {Bid} from "./models/bid.js";
+import {User} from "./models/user.js";
+
+export const sequelize = new Sequelize({
+    database: 'db',
+    dialect: 'sqlite',
+    storage: ':memory:',
+    models: [Bid, Product, User],
+})

backend/orm/fixtures/index.js → backend/orm/fixtures/index.ts

@@ -6,8 +6,8 @@ import { Bid, Product, User } from '../index.js'
 
 export async function regenerateFixtures () {
   await Bid.destroy({ where: { } })
-  await User.destroy({ where: { } })
   await Product.destroy({ where: { } })
+  await User.destroy({ where: { } })
 
   const DAY = 24 * 60 * 60 * 1000
 
@@ -224,7 +224,7 @@ export async function regenerateFixtures () {
     if (Math.random() < 0.8) {
       let price = product.originalPrice
 
-      let lastBuyer = null
+      let lastBuyer: null | undefined | User = null
 
       for (let date = new Date(Date.now() + DAY); date < product.endDate; date = new Date(date.getTime() + DAY / 4)) {
         if (Math.random() < 0.2) {
@@ -236,7 +236,7 @@ export async function regenerateFixtures () {
 
           await Bid.create({
             productId: product.id,
-            bidderId: bidder.id,
+            bidderId: bidder?.id,
             price,
             date
           })

backend/orm/index.ts

@@ -0,0 +1,10 @@
+import {User} from './models/user.js'
+import {Bid} from './models/bid.js'
+import {Product} from './models/product.js'
+import { sequelize } from './database.js'
+
+export async function initializeDatabase () {
+  return await sequelize.sync()
+}
+
+export { User, Bid, Product }

backend/orm/models/bid.ts

@@ -0,0 +1,53 @@
+import { DataTypes } from 'sequelize'
+import {Table, Column, Model, BelongsTo} from 'sequelize-typescript';
+import {Product} from "./product.js";
+import {User} from "./user.js";
+
+@Table
+export class Bid extends Model {
+
+  @Column({
+    type: DataTypes.UUID,
+    defaultValue: DataTypes.UUIDV4,
+    allowNull: false,
+    primaryKey: true
+  })
+  declare id: string
+
+  @Column({
+    type: DataTypes.UUID,
+    allowNull: false
+  })
+  declare productId: string
+
+  @Column({
+    type: DataTypes.UUID,
+    allowNull: false
+  })
+  declare bidderId: string
+
+  @Column({
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    validate: {
+      isInt: true,
+      min: 0
+    }
+  })
+  declare price: number
+
+  @Column({
+    type: DataTypes.DATE,
+    allowNull: false,
+    validate: {
+      isDate: true
+    }
+  })
+  declare date: Date
+
+  @BelongsTo(() => Product, {foreignKey: 'productId'})
+  declare product: Awaited<Product>;
+
+  @BelongsTo(() => User, {foreignKey: 'bidderId'})
+  declare bidder: Awaited<User>;
+}

backend/orm/models/product.js → backend/orm/models/product.ts

@@ -1,70 +1,83 @@
 import { DataTypes } from 'sequelize'
-import { sequelize } from '../database.js'
+import {Table, Column, Model, HasMany, BelongsTo} from 'sequelize-typescript';
+import {User} from "./user.js";
+import {Bid} from "./bid.js";
 
-/**
- * @typedef {Object} ProductObject
- * @property {string} id
- * @property {string} name
- * @property {string} description
- * @property {string} category
- * @property {number} originalPrice
- * @property {string} pictureUrl
- * @property {Date} endDate
- * @property {number} sellerId
- */
+@Table
+export class Product extends Model {
 
-export default sequelize.define('Product', {
-  id: {
+  @Column({
     type: DataTypes.UUID,
     defaultValue: DataTypes.UUIDV4,
     allowNull: false,
     primaryKey: true
-  },
-  name: {
+  })
+  declare id: string
+
+  @Column({
     type: DataTypes.STRING,
     allowNull: false,
     validate: {
       notEmpty: true
     }
-  },
-  description: {
+  })
+  declare name: string
+
+  @Column({
     type: DataTypes.STRING,
     allowNull: false,
     validate: {
       notEmpty: true
     }
-  },
-  category: {
+  })
+  declare description: string
+
+  @Column({
     type: DataTypes.STRING,
     allowNull: false,
     validate: {
       notEmpty: true
     }
-  },
-  originalPrice: {
+  })
+  declare category: string
+
+  @Column({
     type: DataTypes.INTEGER,
     allowNull: false,
     validate: {
       isInt: true,
       min: 0
     }
-  },
-  pictureUrl: {
+  })
+  declare originalPrice: number
+
+  @Column({
     type: DataTypes.STRING,
     allowNull: false,
     validate: {
       notEmpty: true
     }
-  },
-  endDate: {
+  })
+  declare pictureUrl: string
+
+  @Column({
     type: DataTypes.DATE,
     allowNull: false,
     validate: {
       isDate: true
     }
-  },
-  sellerId: {
+  })
+  declare endDate: Date
+
+  @Column({
     type: DataTypes.UUID,
     allowNull: false
-  }
-})
+  })
+  declare sellerId: string
+
+  @BelongsTo(() => User, {foreignKey: 'sellerId'})
+  declare seller: Awaited<User>;
+
+  @HasMany(() => Bid, {foreignKey: 'productId', onDelete: 'CASCADE'})
+  declare bids: Awaited<Bid[]>;
+}