@20syldev/api 2.8.0 → 3.0.0

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://api.sylvain.pro"><img src="https://api.sylvain.pro/favicon.ico" alt="Logo" width="25%" height="auto"/></a>
 
   # API Personnelle
-  [![Version](https://custom-icon-badges.demolab.com/badge/Version%20:-v2.8.0-6479ee?logo=api.sylvain.pro&labelColor=23272A)](https://github.com/20syldev/api/releases/latest)
+  [![Version](https://custom-icon-badges.demolab.com/badge/Version%20:-v3.0.0-6479ee?logo=api.sylvain.pro&labelColor=23272A)](https://github.com/20syldev/api/releases/latest)
 </div>
 
 ---
@@ -10,14 +10,41 @@
 ## À propos de l'API
 Voici mon API personnelle, disponible sur le domaine [api.sylvain.pro](https://api.sylvain.pro).
 L'API est développée avec Node.js et hébergée **24h/7j**. Elle est **simple d'utilisation** et a une **documentation** disponible sur [docs.sylvain.pro](https://docs.sylvain.pro) !
-> *Une limite de **1000** requêtes maximum chaque **10 secondes** est fixée.* 
+> *Une limite de **1000** requêtes maximum chaque **10 secondes** est fixée. Elle est baissé pour certains endpoints nécessitant plus de ressources.*
 
-## Tester l'API localement
+## Installer le paquet de l'API sur votre machine
+```console
+$ sudo apt install nodejs npm
+$ npm install @20syldev/api 
+```
+
+Pour utiliser le **paquet** dans votre projet, **créez** un fichier **JavaScript**. Par exemple, `index.js` :
+```js
+require('@20syldev/api');
+```
+
+Puis, **démarrez** un serveur [Node.js](https://nodejs.org) pour utiliser l'**API** :
+```console
+$ node index.js
+API is running on
+    - http://127.0.0.1:3000
+    - http://localhost:3000
+```
+> *Remplacez `index.js` par le nom de votre fichier JavaScript.*
+
+## Tester l'API sur votre machine
+**Téléchargez** la [dernière mise à jour](https://github.com/20syldev/api/releases/latest) de l'API, puis **extrayez** le contenu du fichier `.zip` ou `.tar.gz` dans un de vos **répertoires**.  
+Ensuite, **déplacez-vous** dans le dossier du projet, via un terminal **Linux**, **Windows** ou **macOS** :
+```console
+$ cd /chemin/vers/le/projet
+```
+
+Enfin, **exécutez** le script de build, qui installera les **dépendances** et lancera le **serveur** de l'[API](https://api.sylvain.pro) :
 ```console
 $ npm run build
 ```
 ```console
-> @20syldev/api@2.8.0 build
+> @20syldev/api@3.0.0 build
 > npm install && node app.js
 
 [...]
@@ -28,4 +55,4 @@ API is running on
     - http://localhost:3000
 ```
 
-*Visitez la [documentation](https://docs.sylvain.pro) dédiée, vous y retrouverez des exemples de requêtes et des codes simples pour tester l'[API](https://api.sylvain.pro) !*
+*Visitez la [documentation](https://docs.sylvain.pro) dédiée, vous y retrouverez des exemples de requêtes et des codes simples pour tester l'[API](https://api.sylvain.pro) !*

package/app.js

@@ -1,45 +1,97 @@
-require('dotenv').config();
-
-// Built-in module
-const crypto = require('crypto');
-
-// Imported module
-const { createCanvas } = require('canvas');
-const cors = require('cors');
-const express = require('express');
-const fetch = require('node-fetch');
-const math = require('mathjs');
-const path = require('path');
-const qrcode = require('qrcode');
-const random = require('random');
-const uuid = require('uuid');
+import cors from 'cors';
+import dotenv from 'dotenv';
+import express from 'express';
+import fetch from 'node-fetch';
+import { createCanvas } from 'canvas';
+import { randomBytes, getHashes, createHash } from 'crypto';
+import { urlencoded, json } from 'express';
+import { factorial } from 'mathjs';
+import { dirname, join } from 'path';
+import { toDataURL } from 'qrcode';
+import { fileURLToPath } from 'url';
+import { v4 } from 'uuid';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 const app = express();
 
 // Define allowed versions & endpoints for each version
-const versions = ['v1', 'v2'];
+const versions = ['v1', 'v2', 'v3'];
 const endpoints = {
     v1: ['algorithms', 'captcha', 'color', 'convert', 'domain', 'infos', 'personal', 'qrcode', 'token', 'username', 'website'],
-    v2: ['algorithms', 'captcha', 'chat', 'color', 'convert', 'domain', 'hash', 'infos', 'personal', 'qrcode', 'tic-tac-toe', 'token', 'username', 'website']
+    v2: ['algorithms', 'captcha', 'chat', 'color', 'convert', 'domain', 'hash', 'infos', 'personal', 'qrcode', 'tic-tac-toe', 'token', 'username', 'website'],
+    v3: ['algorithms', 'captcha', 'chat', 'color', 'convert', 'date', 'domain', 'hash', 'infos', 'levenshtein', 'personal', 'qrcode', 'tic-tac-toe', 'time', 'token', 'username', 'website']
 };
 
+// Arrowed functions (math & random)
+const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+const genID = () => {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    return Array.from(randomBytes(5)).map(b => chars[b % chars.length]).join('');
+};
+const genIP = () => `${Math.floor(Math.random() * 256)}.${Math.floor(Math.random() * 256)}.${Math.floor(Math.random() * 256)}.${Math.floor(Math.random() * 256)}`;
+const genToken = (chars, length) => Array.from({ length }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+const random = (arr) => arr[Math.floor(Math.random() * arr.length)];
+
 // Store data
 const logs = [], chat = [], privateChats = {}, sessions = {}, rateLimits = {}, games = {};
 
 // Define global variables
-let lastFetch = 0, requests = 0, resetTime = Date.now() + 10000;
+let contributions, lastFetch = 0, requests = 0, resetTime = Date.now() + 10000;
+
+// ----------- ----------- MAIN FUNCTIONS ----------- ----------- //
+
+/**
+ * Check the game result of a Tic-Tac-Toe game.
+ * 
+ * @param {Array} moves - The moves of the game.
+ * @returns {Object} - The result of the game.
+ */
+function checkGame(moves) {
+    let board = Array(3).fill().map(() => Array(3).fill(null));
+    let playerSymbols = {};
+    let playersOrder = [];
+
+    moves.forEach(({ username, move }) => {
+        if (!playerSymbols[username]) {
+            playersOrder.push(username);
+            playerSymbols[username] = playersOrder.length === 1 ? 'X' : 'O';
+        }
+        let [row, col] = move.split('-').map(Number);
+        board[row - 1][col - 1] = playerSymbols[username];
+    });
+
+    const checkWinner = (symbol) => {
+        for (let i = 0; i < 3; i++) {
+            if (board[i][0] === symbol && board[i][1] === symbol && board[i][2] === symbol) return true;
+            if (board[0][i] === symbol && board[1][i] === symbol && board[2][i] === symbol) return true;
+        }
+        if (board[0][0] === symbol && board[1][1] === symbol && board[2][2] === symbol) return true;
+        if (board[0][2] === symbol && board[1][1] === symbol && board[2][0] === symbol) return true;
+        return false;
+    };
+
+    let winner = Object.keys(playerSymbols).find(player => checkWinner(playerSymbols[player]));
+    let isTie = !winner && moves.length === 9;
+    let loser = winner && playersOrder.length === 2 ? playersOrder.find(player => player !== winner) : null;
+
+    return { winner, loser, tie: isTie };
+}
 
 // ----------- ----------- MIDDLEWARES SETUP ----------- ----------- //
 
+dotenv.config();
+
 // CORS & Express setup
 app.use(cors({ methods: ['GET', 'POST'] }));
-app.use(express.urlencoded({ extended: true }));
-app.use(express.json());
+app.use(urlencoded({ extended: true }));
+app.use(json());
 
 // Set favicon for API
-app.use('/favicon.ico', express.static(path.join(__dirname, 'src', 'favicon.ico')));
+app.use('/favicon.ico', express.static(join(__dirname, 'src', 'favicon.ico')));
 
 // Display robots.txt
-app.use('/robots.txt', express.static(path.join(__dirname, 'robots.txt')));
+app.use('/robots.txt', express.static(join(__dirname, 'robots.txt')));
 
 // Return formatted JSON
 app.use((req, res, next) => {
@@ -104,7 +156,7 @@ app.use('/:version', (req, res, next) => {
         return res.status(404).jsonResponse({
             message: 'Not Found',
             error: `Invalid API version (${version}).`,
-            documentation: 'https://docs.sylvain.pro',
+            documentation: `https://docs.sylvain.pro/${versions.at(-1)}`,
             status: '404'
         });
     }
@@ -119,7 +171,7 @@ app.use('/:version/:endpoint', (req, res, next) => {
         return res.status(404).jsonResponse({
             message: 'Not Found',
             error: `Endpoint '${endpoint}' does not exist in ${version}.`,
-            documentation: 'https://docs.sylvain.pro',
+            documentation: `https://docs.sylvain.pro/${versions.at(-1)}`,
             status: '404'
         });
     }
@@ -137,7 +189,8 @@ app.get('/', (req, res) => {
         logs: 'https://api.sylvain.pro/logs',
         versions: { 
             v1: 'https://api.sylvain.pro/v1',
-            v2: 'https://api.sylvain.pro/v2'
+            v2: 'https://api.sylvain.pro/v2',
+            v3: 'https://api.sylvain.pro/v3'
         }
     });
 });
@@ -198,6 +251,41 @@ app.get('/v2', (req, res) => {
     });
 });
 
+// Display v3 endpoints
+app.get('/v3', (req, res) => {
+    res.jsonResponse({
+        version: 'v3',
+        endpoints: {
+            get: {
+                algorithm: '/v3/algorithms?method={algorithm}&value={value}(&value2={value2})',
+                captcha: '/v3/captcha?text={text}',
+                chat: '/v3/chat',
+                color: '/v3/color',
+                convert: '/v3/convert?value={value}&from={unit}&to={unit}',
+                domain: '/v3/domain',
+                infos: '/v3/infos',
+                levenshtein: '/v3/levenshtein?str1={string}&str2={string}',
+                personal: '/v3/personal',
+                qrcode: '/v3/qrcode?url={URL}',
+                time: '/v3/time(?type={type}&start={timestamp}&end={timestamp}&format={format}&timezone={timezone})',
+                username: '/v3/username'
+            },
+            post: {
+                chat: {
+                    chat: '/v3/chat',
+                    private: '/v3/chat/private'
+                },
+                hash: '/v3/hash',
+                tic_tac_toe: {
+                    tic_tac_toe: '/v3/tic-tac-toe',
+                    fetch: '/v3/tic-tac-toe/fetch'
+                },
+                token: '/v3/token'
+            }
+        }
+    });
+});
+
 // Display logs
 app.get('/logs', (req, res) => res.jsonResponse(logs));
 
@@ -206,11 +294,12 @@ app.get('/logs', (req, res) => res.jsonResponse(logs));
 // Algorithms
 app.get('/:version/algorithms', (req, res) => {
     const { method, value, value2 } = req.query;
+    const { version } = req.params;
 
     if (!['anagram', 'bubblesort', 'factorial', 'fibonacci', 'gcd', 'isprime', 'palindrome', 'primefactors', 'primelist', 'reverse'].includes(method)) {
         return res.jsonResponse({
             error: 'Please provide a valid algorithm (?method={algorithm})',
-            documentation: 'https://docs.sylvain.pro/v1/algorithms'
+            documentation: `https://docs.sylvain.pro/${version}/algorithms`
         });
     }
     if (!value) return res.jsonResponse({ error: 'Please provide a valid value (&value={value})' });
@@ -233,7 +322,7 @@ app.get('/:version/algorithms', (req, res) => {
 
     if (method === 'factorial') {
         if (isNaN(value) || value < 0 || value > 170) return res.jsonResponse({ error: 'Please provide a valid number between 0 and 170.' });
-        return res.jsonResponse({ answer: math.factorial(value) });
+        return res.jsonResponse({ answer: factorial(value) });
     }
 
     if (method === 'fibonacci') {
@@ -243,7 +332,6 @@ app.get('/:version/algorithms', (req, res) => {
     }
 
     if (method === 'gcd') {
-        const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
         if (!value2) return res.jsonResponse({ error: 'Please provide a second value (&value2={value})' });
         if (isNaN(value) || isNaN(value2)) return res.jsonResponse({ error: 'Invalid numbers.' });
         return res.jsonResponse({ answer: gcd(value, value2) });
@@ -354,7 +442,7 @@ app.get('/:version/chat/private', (req, res) => {
 
 // Generate color
 app.get('/:version/color', (req, res) => {
-    const r = random.int(0, 255), g = random.int(0, 255), b = random.int(0, 255);
+    const r = Math.floor(Math.random() * 256), g = Math.floor(Math.random() * 256), b = Math.floor(Math.random() * 256);
     const hsl = (() => {
         const r1 = r / 255, g1 = g / 255, b1 = b / 255, max = Math.max(r1, g1, b1), min = Math.min(r1, g1, b1), l = (max + min) / 2;
         if (max === min) return [0, 0, l * 100];
@@ -407,17 +495,15 @@ app.get('/:version/convert', (req, res) => {
 
 // Generate domain informations
 app.get('/:version/domain', (req, res) => {
-    const random = (arr) => arr[Math.floor(Math.random() * arr.length)];
     const subdomains = ['fr.', 'en.', 'docs.', 'api.', 'projects.', 'app.', 'web.', 'info.', 'dev.', 'shop.', 'blog.', 'support.', 'mail.', 'forum.'];
     const domains = ['example', 'site', 'test', 'demo', 'page', 'store', 'portfolio', 'platform', 'hub', 'network', 'service', 'cloud', 'solutions', 'company'];
     const tlds = ['.com', '.fr', '.eu', '.dev', '.net', '.org', '.io', '.tech', '.biz', '.info', '.co', '.app', '.store', '.online', '.shop', '.tv'];
 
     const domain = `${random(domains)}${random(tlds)}`;
     const fulldomain = `${random(subdomains)}${domain}`;
-    
-    const getRandomIp = () => `${Math.floor(Math.random() * 256)}.${Math.floor(Math.random() * 256)}.${Math.floor(Math.random() * 256)}.${Math.floor(Math.random() * 256)}`;
-    const ips = Array.from({ length: Math.floor(Math.random() * 3) + 1 }, getRandomIp);
-    const dns = Array.from({ length: Math.floor(Math.random() * 5) + 1 }, getRandomIp);
+
+    const ips = Array.from({ length: Math.floor(Math.random() * 3) + 1 }, genIP);
+    const dns = Array.from({ length: Math.floor(Math.random() * 5) + 1 }, genIP);
 
     res.jsonResponse({
         domain,
@@ -449,7 +535,7 @@ app.get('/:version/hash', (req, res) => {
 // Display API informations
 app.get('/:version/infos', (req, res) => {
     res.jsonResponse({
-        endpoints: endpoints.length,
+        endpoints: endpoints[versions.at(-1)].length,
         last_version: versions.at(-1),
         documentation: 'https://docs.sylvain.pro',
         github: 'https://github.com/20syldev/api',
@@ -457,10 +543,28 @@ app.get('/:version/infos', (req, res) => {
     });
 });
 
+// Calculate Levenshtein distance
+app.get('/:version/levenshtein', (req, res) => {
+    const { str1, str2 } = req.query;
+
+    if (!str1) return res.jsonResponse({ error: 'Please provide a first string (?str1={string})' });
+    if (!str2) return res.jsonResponse({ error: 'Please provide a second string (&str2={string})' });
+
+    const lev = (a, b) => {
+        const m = Array.from({ length: a.length + 1 }, (_, i) => [i]);
+        for (let j = 0; j <= b.length; j++) m[0][j] = j;
+        for (let i = 1; i <= a.length; i++)
+            for (let j = 1; j <= b.length; j++)
+                m[i][j] = Math.min(m[i - 1][j] + 1, m[i][j - 1] + 1, m[i - 1][j - 1] + (a[i - 1] !== b[j - 1]));
+
+        return m[a.length][b.length];
+    };
+
+    res.jsonResponse({ str1, str2, distance: lev(str1, str2) });
+});
+
 // Generate personal data
 app.get('/:version/personal', (req, res) => {
-    const random = (arr) => arr[Math.floor(Math.random() * arr.length)];
-
     const people = [
         { name: 'John Doe', social: 'john_doe', email: 'john@example.com', country: 'US' },
         { name: 'Jane Martin', social: 'jane_martin', email: 'jane@example.com', country: 'FR' },
@@ -579,7 +683,7 @@ app.get('/:version/qrcode', async (req, res) => {
 
     if (!url) return res.jsonResponse({ error: 'Please provide a valid url (?url={URL})' });
 
-    try { res.jsonResponse({ qr: await qrcode.toDataURL(url) }); }
+    try { res.jsonResponse({ qr: await toDataURL(url) }); }
     catch { res.jsonResponse({ error: 'Error generating QR code.' }); }
 });
 
@@ -593,6 +697,59 @@ app.get('/:version/tic-tac-toe/fetch', (req, res) => {
     res.jsonResponse({ error: 'This endpoint only supports POST requests.' });
 });
 
+// Display or generate time informations
+app.get('/:version/time', (req, res) => {
+    const { type = 'live', start, end, format, timezone } = req.query;
+
+    const validFormats = ['iso', 'utc', 'timestamp', 'locale', 'date', 'time', 'year', 'month', 'day', 'hour', 'minute', 'second', 'ms', 'dayOfWeek', 'dayOfYear', 'weekNumber', 'timezone', 'timezoneOffset'];
+    const validTimezones = ['UTC', 'America/New_York', 'Europe/Paris', 'Asia/Tokyo', 'Australia/Sydney'];
+
+    if (type !== 'live' && type !== 'random') return res.jsonResponse({ error: 'Please provide a valid type (?type={type})' });
+    if (start && !Date.parse(start)) return res.jsonResponse({ error: 'Please provide a valid start date (?start={YYYY-MM-DD})' });
+    if (end && !Date.parse(end)) return res.jsonResponse({ error: 'Please provide a valid end date (?end={YYYY-MM-DD})' });
+    if (format && !validFormats.includes(format)) return res.jsonResponse({ error: 'Please provide a valid format (?format={format})' });
+    if (timezone && !validTimezones.includes(timezone)) return res.jsonResponse({ error: 'Please provide a valid timezone (?timezone={timezone})' });
+
+    const getTimeFormats = (date, timezoneOption) => {
+        return {
+            iso: date.toISOString(),
+            utc: date.toUTCString(),
+            timestamp: date.getTime(),
+            locale: date.toLocaleString('en-US', { timeZone: timezoneOption, timeZoneName: 'long' }),
+            date: date.toLocaleDateString('en-US', { timeZone: timezoneOption }),
+            time: date.toLocaleTimeString('en-US', { timeZone: timezoneOption }),
+            year: date.getFullYear(),
+            month: date.getMonth() + 1,
+            day: date.getDate(),
+            hour: date.getHours(),
+            minute: date.getMinutes(),
+            second: date.getSeconds(),
+            ms: date.getMilliseconds(),
+            dayOfWeek: date.getDay(),
+            dayOfYear: Math.floor((date - new Date(date.getFullYear(), 0, 0)) / 86400000),
+            weekNumber: Math.ceil((((date - new Date(date.getFullYear(), 0, 0)) / 86400000) + 1) / 7),
+            timezone: timezoneOption,
+            timezoneOffset: date.getTimezoneOffset()
+        };
+    };
+
+    if (type === 'random') {
+        const startDate = new Date(start || '1900-01-01').getTime();
+        const endDate = new Date(end || '2100-12-31').getTime();
+        const randomDate = new Date(start ? startDate : startDate + Math.random() * (endDate - startDate));
+        const timezoneOption = timezone || validTimezones[Math.floor(Math.random() * 5)];
+        const formats = getTimeFormats(randomDate, timezoneOption);
+
+        return res.jsonResponse(format && formats[format] ? { date: formats[format] } : formats);
+    }
+
+    const now = new Date();
+    const timezoneOption = timezone || 'UTC';
+    const formats = getTimeFormats(now, timezoneOption);
+
+    res.jsonResponse(format && formats[format] ? { date: formats[format] } : formats);
+});
+
 // GET token error
 app.get('/:version/token', (req, res) => {
     res.jsonResponse({ error: 'This endpoint only supports POST requests.' });
@@ -604,7 +761,6 @@ app.get('/:version/username', (req, res) => {
     const ani = ['Cat', 'Dog', 'Tiger', 'Elephant', 'Monkey', 'Penguin', 'Dolphin', 'Lion', 'Bear', 'Fox', 'Owl', 'Giraffe', 'Zebra', 'Koala', 'Rabbit', 'Squirrel', 'Panda', 'Horse', 'Wolf', 'Eagle'];
     const job = ['Writer', 'Artist', 'Musician', 'Explorer', 'Scientist', 'Engineer', 'Athlete', 'Chef', 'Doctor', 'Teacher', 'Lawyer', 'Entrepreneur', 'Actor', 'Dancer', 'Photographer', 'Architect', 'Pilot', 'Designer', 'Journalist', 'Veterinarian'];
 
-    const random = (arr) => arr[Math.floor(Math.random() * arr.length)];
     const nombre = Math.floor(Math.random() * 100);
     const choix = {
         adj_num: () => random(adj) + nombre,
@@ -702,8 +858,9 @@ app.get('/:version/website', async (req, res) => {
             wrkit: process.env.WRKIT,
             zpki: process.env.ZPKI
         },
-        updated_projects: process.env.RECENT.split(' '),
-        new_projects: process.env.NEW.split(' '),
+        updated_projects: process.env.RECENT !== undefined ? process.env.RECENT.split(' ') : [],
+        new_projects: process.env.NEW !== undefined ? process.env.NEW.split(' ') : [],
+        sub_domains: process.env.DOMAINS !== undefined ? process.env.DOMAINS.split(' ') : [],
         stats: {
             os: process.env.STATS1,
             front: process.env.STATS2,
@@ -805,15 +962,21 @@ app.post('/:version/tic-tac-toe', (req, res) => {
     games[game] = games[game] || [];
 
     const players = [...new Set(games[game].map(play => play.username))];
-    if (players.length >= 2 && !players.includes(username)) {
-        return res.jsonResponse({ error: 'Game is full, you can only watch.' });
-    }
-
+    if (players.length >= 2 && !players.includes(username)) return res.jsonResponse({ error: 'Game is full, you can only watch.' });
     if (games[game].length > 0 && games[game][games[game].length - 1].username === username) return res.jsonResponse({ error: 'Please wait for the other player to make a move.' });
     if (games[game].some(play => play.move === move)) return res.jsonResponse({ error: 'Move already made. Please choose a different move.' });
 
     games[game].push(play);
-    setTimeout(() => { delete games[game]; }, 3600000);
+
+    const result = checkGame(games[game]);
+    if (result.winner || result.tie) {
+        setTimeout(() => delete games[game], 600000);
+        return res.jsonResponse({
+            message: `Move sent successfully. ${result.winner ? result.winner + " wins. " + result.loser + " loses." : "It's a tie."}`,
+            ...result
+        });
+    }
+    if (!result.winner && !result.tie) setTimeout(() => delete games[game], 3600000);
 
     sessions[u] = sessions[u] || { user: session, last: now };
     sessions[u].last = now;
@@ -829,12 +992,7 @@ app.post('/:version/tic-tac-toe/fetch', (req, res) => {
 
     if (!username) return res.jsonResponse({ error: 'Please provide a username (?username={username})' });
 
-    const generateId = () => {
-        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-        return Array.from(crypto.randomBytes(5)).map(b => chars[b % chars.length]).join('');
-    };
-
-    const ID = game || generateId();
+    const ID = game || genID();
     const u = username.toLowerCase(), now = Date.now();
 
     rateLimits[u] = (rateLimits[u] || []).filter(ts => now - ts < 10000);
@@ -846,49 +1004,54 @@ app.post('/:version/tic-tac-toe/fetch', (req, res) => {
 
     if (!games[ID]) games[ID] = [];
 
-    const data = games[ID], last = data.length ? data[data.length - 1].username : null;
-    const players = [...new Set(data.map(p => p.username))], turn = players.find(p => p !== last);
+    const data = games[ID];
+    const last = data.length ? data[data.length - 1].username : null;
+    const players = [...new Set(data.map(p => p.username))];
+    const turn = players.find(p => p !== last);
+    const result = data.length ? checkGame(data) : {};
 
-    res.jsonResponse({ game: data, turn, ID });
+    res.jsonResponse({ game: data, turn, ID, ...result });
 });
 
 // Generate hash
 app.post('/:version/hash', (req, res) => {
     const { text, method } = req.body;
+    const { version } = req.params;
 
     if (!text) return res.jsonResponse({ error: 'Please provide a text (?text={text})' });
     if (!method) return res.jsonResponse({
         error: 'Please provide a valid hash algorithm (?method={algorithm})',
-        documentation: 'https://docs.sylvain.pro/v1/hash'
+        documentation: `https://docs.sylvain.pro/${version}/hash`
     });
 
-    const methods = crypto.getHashes();
+    const methods = getHashes();
     if (!methods.includes(method)) return res.jsonResponse({ error: `Unsupported method. Use one of: ${methods.join(', ')}` });
 
-    const hash = crypto.createHash(method).update(text).digest('hex');
+    const hash = createHash(method).update(text).digest('hex');
     res.jsonResponse({ method, hash });
 });
 
 // Generate Token
 app.post('/:version/token', (req, res) => {
-    const length = parseInt(req.body.len || 24, 10);
-    const type = req.body.type || 'alpha';
+    let { len, type } = req.body;
+
+    len = parseInt(len || 24, 10);
+    type = type ? type.toLowerCase() : 'alpha';
 
-    if (isNaN(length) || length < 0) return res.jsonResponse({ error: 'Invalid number.' });
-    if (length > 4096) return res.jsonResponse({ error: 'Length cannot exceed 4096.' });
-    if (length < 12) return res.jsonResponse({ error: 'Length cannot be less than 12.' });
+    if (isNaN(len) || len < 0) return res.jsonResponse({ error: 'Invalid number.' });
+    if (len > 4096) return res.jsonResponse({ error: 'Length cannot exceed 4096.' });
+    if (len < 12) return res.jsonResponse({ error: 'Length cannot be less than 12.' });
 
-    const generateToken = (chars) => Array.from({ length }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
     const token = {
-        alpha: generateToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'),
-        alphanum: generateToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'),
-        base64: crypto.randomBytes(length).toString('base64').slice(0, length),
-        hex: crypto.randomBytes(length).toString('hex').slice(0, length),
-        num: generateToken('0123456789'),
-        punct: generateToken('!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'),
-        urlsafe: generateToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'),
-        uuid: uuid.v4().replace(/-/g, '').slice(0, length)
-    }[type] || generateToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789');
+        alpha: genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', len),
+        alphanum: genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', len),
+        base64: randomBytes(len).toString('base64').slice(0, len),
+        hex: randomBytes(len).toString('hex').slice(0, len),
+        num: genToken('0123456789', len),
+        punct: genToken('!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~', len),
+        urlsafe: genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_', len),
+        uuid: v4().replace(/-/g, '').slice(0, len)
+    }[type] || genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', len);
 
     res.jsonResponse({ token });
 });

package/package.json

@@ -1,8 +1,9 @@
 {
-    "version": "2.8.0",
+    "version": "3.0.0",
     "name": "@20syldev/api",
-    "description": "Personnal API",
+    "description": "Node.js API with multiple features. Check the documentation at https://docs.sylvain.pro",
     "main": "app.js",
+    "type": "module",
     "scripts": {
         "start": "node app.js",
         "build": "npm install && node app.js",
@@ -11,16 +12,16 @@
         "upgrade:build": "npm upgrade && npm install && node app.js"
     },
     "dependencies": {
-        "canvas": "^3.1.0",
-        "cors": "2.8.5",
-        "dotenv": "^16.4.7",
-        "express": "^4.21.2",
-        "mathjs": "^14.2.0",
-        "node-fetch": "^2.7.0",
-        "prettier": "^3.4.2",
-        "qrcode": "^1.5.4",
-        "random": "^5.1.1",
-        "uuid": "^11.0.5"
+        "canvas": "latest",
+        "cors": "latest",
+        "dotenv": "latest",
+        "express": "latest",
+        "mathjs": "latest",
+        "node-fetch": "latest",
+        "prettier": "latest",
+        "qrcode": "latest",
+        "random": "latest",
+        "uuid": "latest"
     },
     "repository": {
         "type": "git",