Initial commit

Author: ADAM Hugo

.env.example

@@ -0,0 +1,3 @@
+# Clé API Riot — obligatoire
+# Obtenez-en une sur https://developer.riotgames.com
+RIOT_API_KEY=RGAPI-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

.gitignore

@@ -0,0 +1,16 @@
+# Dépendances
+node_modules/
+
+# Build
+dist/
+.next/
+
+# Env (ne jamais committer la vraie clé !)
+.env
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log

README.md

@@ -0,0 +1,5 @@
+node_modules
+dist
+npm-debug.log
+.env
+.git

backend/.dockerignore

@@ -0,0 +1,20 @@
+# === Stage 1 : build TypeScript ===
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json tsconfig.json ./
+RUN npm install
+COPY src ./src
+RUN npm run build
+
+# === Stage 2 : runtime ===
+FROM node:20-alpine AS runner
+WORKDIR /app
+ENV NODE_ENV=production
+COPY package*.json ./
+RUN npm install --omit=dev && npm cache clean --force
+COPY --from=builder /app/dist ./dist
+# Le schema SQL est embarqué pour permettre l'init au démarrage
+COPY src/lib/schema.sql ./dist/lib/schema.sql
+USER node
+EXPOSE 3001
+CMD ["node", "dist/server.js"]

backend/Dockerfile

@@ -0,0 +1,22 @@
+{
+  "name": "lol-stats-backend",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/server.js",
+    "dev": "tsx watch src/server.ts"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.5",
+    "fastify": "^4.28.0",
+    "ioredis": "^5.4.1",
+    "pg": "^8.13.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "@types/pg": "^8.11.10",
+    "tsx": "^4.16.0",
+    "typescript": "^5.5.0"
+  }
+}

backend/package.json

@@ -0,0 +1,19 @@
+import 'dotenv/config';
+
+/**
+ * Validation à l'import : si la clé Riot manque, l'app refuse de démarrer.
+ * Cela évite des erreurs silencieuses 403 en production.
+ */
+function required(name: string): string {
+  const value = process.env[name];
+  if (!value) throw new Error(`Variable d'environnement manquante : ${name}`);
+  return value;
+}
+
+export const env = {
+  RIOT_API_KEY: required('RIOT_API_KEY'),
+  REDIS_URL: process.env.REDIS_URL ?? 'redis://redis:6379',
+  DATABASE_URL: process.env.DATABASE_URL ?? 'postgres://lolstats:lolstats_local_only@postgres:5432/lolstats',
+  PORT: Number(process.env.PORT ?? 3001),
+  HOST: process.env.HOST ?? '0.0.0.0',
+} as const;

backend/src/config/env.ts

@@ -0,0 +1,56 @@
+import { createHash } from 'node:crypto';
+import { redis } from './redis.js';
+import { env } from '../config/env.js';
+
+/**
+ * Préfixe de cache lié à la clé API Riot.
+ *
+ * Pourquoi : Riot chiffre les PUUID/summonerId différemment pour chaque clé.
+ * Quand on renouvelle sa clé dev (toutes les 24h pour une clé dev), les
+ * anciens identifiants en cache deviennent invalides et Riot renvoie
+ * "Exception decrypting".
+ *
+ * En préfixant toutes les clés Redis par un hash court de la clé API
+ * actuelle, on s'assure que le cache est automatiquement segmenté
+ * par clé API : pas de risque d'utiliser un ID pourri d'une session
+ * précédente, et le purge se fait naturellement quand le TTL expire.
+ */
+const KEY_PREFIX = createHash('sha256')
+  .update(env.RIOT_API_KEY)
+  .digest('hex')
+  .slice(0, 8);
+
+/**
+ * Wrapper de cache "read-through" autour de Redis.
+ */
+export async function cached<T>(
+  key: string,
+  ttlSeconds: number,
+  fetcher: () => Promise<T>,
+): Promise<T> {
+  const scopedKey = `${KEY_PREFIX}:${key}`;
+  const hit = await redis.get(scopedKey);
+  if (hit) {
+    try {
+      return JSON.parse(hit) as T;
+    } catch {
+      await redis.del(scopedKey);
+    }
+  }
+
+  const fresh = await fetcher();
+  await redis.set(scopedKey, JSON.stringify(fresh), 'EX', ttlSeconds);
+  return fresh;
+}
+
+export const TTL = {
+  account: 60 * 60 * 24,
+  summoner: 60 * 60 * 6,
+  league: 60 * 5,
+  mastery: 60 * 60,
+  matchIds: 60 * 2,
+  matchDetail: 60 * 60 * 24 * 30,
+  ddragonVersion: 60 * 60,
+  ddragonChampions: 60 * 60 * 6,
+  tierList: 60 * 60 * 6,
+} as const;

backend/src/lib/cache.ts

@@ -0,0 +1,43 @@
+import pg from 'pg';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { env } from '../config/env.js';
+
+/**
+ * Pool de connexions PostgreSQL.
+ *
+ * On utilise un pool plutôt qu'une connexion unique : Fastify est asynchrone
+ * et plusieurs requêtes HTTP peuvent vouloir parler à la BDD en parallèle.
+ * Le pool gère ça proprement avec un nombre limité de connexions ouvertes.
+ */
+export const pool = new pg.Pool({
+  connectionString: env.DATABASE_URL,
+  max: 10,
+  idleTimeoutMillis: 30_000,
+  connectionTimeoutMillis: 5_000,
+});
+
+pool.on('error', (err) => {
+  console.error('[Postgres] erreur de pool', err);
+});
+
+/**
+ * Initialise le schéma au démarrage.
+ * Idempotent : utilise CREATE TABLE IF NOT EXISTS partout.
+ */
+export async function initSchema(): Promise<void> {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const sqlPath = join(__dirname, 'schema.sql');
+  const sql = await readFile(sqlPath, 'utf-8');
+  await pool.query(sql);
+  console.info('[Postgres] schéma initialisé');
+}
+
+/** Helper pour exécuter une requête simple (avec types). */
+export async function query<T extends pg.QueryResultRow = pg.QueryResultRow>(
+  text: string,
+  params?: unknown[],
+): Promise<pg.QueryResult<T>> {
+  return pool.query<T>(text, params as never);
+}

backend/src/lib/db.ts

@@ -0,0 +1,15 @@
+import { Redis } from 'ioredis';
+import { env } from '../config/env.js';
+
+/**
+ * Singleton Redis — ioredis gère reconnexion et pool en interne.
+ *
+ * Note : on importe la classe nommée { Redis } plutôt que l'export
+ * par défaut, plus fiable avec module: NodeNext.
+ */
+export const redis = new Redis(env.REDIS_URL, {
+  maxRetriesPerRequest: 3,
+  enableReadyCheck: true,
+});
+
+redis.on('error', (err: Error) => console.error('[Redis] Erreur :', err.message));