@20syldev/api 2.7.0 → 2.9.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.7.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:-v2.9.0-6479ee?logo=api.sylvain.pro&labelColor=23272A)](https://github.com/20syldev/api/releases/latest)
 </div>
 
 ---
@@ -12,12 +12,39 @@ Voici mon API personnelle, disponible sur le domaine [api.sylvain.pro](https://a
 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.* 
 
-## 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](http://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.7.0 build
+> @20syldev/api@2.9.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,23 +1,35 @@
-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 { createCanvas } from 'canvas';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import { randomBytes, getHashes, createHash } from 'crypto';
+import express, { urlencoded, json } from 'express';
+import { factorial } from 'mathjs';
+import fetch from 'node-fetch';
+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
-const versions = ['v1'];
-const endpoints = ['algorithms', 'captcha', 'chat', 'color', 'convert', 'domain', 'hash', 'infos', 'personal', 'qrcode', 'tic-tac-toe', 'token', 'username', 'website'];
+// Define allowed versions & endpoints for each version
+const versions = ['v1', 'v2'];
+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']
+};
+
+// 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 = {};
@@ -27,16 +39,18 @@ let lastFetch = 0, requests = 0, resetTime = Date.now() + 10000;
 
 // ----------- ----------- 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) => {
@@ -101,7 +115,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'
         });
     }
@@ -112,11 +126,11 @@ app.use('/:version', (req, res, next) => {
 app.use('/:version/:endpoint', (req, res, next) => {
     const { version, endpoint } = req.params;
 
-    if (!versions.includes(version) || !endpoints.includes(endpoint)) {
+    if (!versions.includes(version) || !endpoints[version].includes(endpoint)) {
         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'
         });
     }
@@ -133,7 +147,8 @@ app.get('/', (req, res) => {
         latest: 'https://api.sylvain.pro/latest',
         logs: 'https://api.sylvain.pro/logs',
         versions: { 
-            v1: 'https://api.sylvain.pro/v1'
+            v1: 'https://api.sylvain.pro/v1',
+            v2: 'https://api.sylvain.pro/v2'
         }
     });
 });
@@ -146,7 +161,6 @@ app.get('/v1', (req, res) => {
             get: {
                 algorithm: '/v1/algorithms?method={algorithm}&value={value}(&value2={value2})',
                 captcha: '/v1/captcha?text={text}',
-                chat: '/v1/chat',
                 color: '/v1/color',
                 convert: '/v1/convert?value={value}&from={unit}&to={unit}',
                 domain: '/v1/domain',
@@ -156,14 +170,45 @@ app.get('/v1', (req, res) => {
                 username: '/v1/username'
             },
             post: {
-                chat: '/v1/chat',
-                hash: '/v1/hash',
                 token: '/v1/token'
             }
         }
     });
 });
 
+// Display v2 endpoints
+app.get('/v2', (req, res) => {
+    res.jsonResponse({
+        version: 'v2',
+        endpoints: {
+            get: {
+                algorithm: '/v2/algorithms?method={algorithm}&value={value}(&value2={value2})',
+                captcha: '/v2/captcha?text={text}',
+                chat: '/v2/chat',
+                color: '/v2/color',
+                convert: '/v2/convert?value={value}&from={unit}&to={unit}',
+                domain: '/v2/domain',
+                infos: '/v2/infos',
+                personal: '/v2/personal',
+                qrcode: '/v2/qrcode?url={URL}',
+                username: '/v2/username'
+            },
+            post: {
+                chat: {
+                    chat: '/v2/chat',
+                    private: '/v2/chat/private'
+                },
+                hash: '/v2/hash',
+                tic_tac_toe: {
+                    tic_tac_toe: '/v2/tic-tac-toe',
+                    fetch: '/v2/tic-tac-toe/fetch'
+                },
+                token: '/v2/token'
+            }
+        }
+    });
+});
+
 // Display logs
 app.get('/logs', (req, res) => res.jsonResponse(logs));
 
@@ -172,11 +217,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})' });
@@ -199,7 +245,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') {
@@ -209,7 +255,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) });
@@ -320,7 +365,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];
@@ -373,17 +418,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,
@@ -415,7 +458,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',
@@ -425,8 +468,6 @@ app.get('/:version/infos', (req, res) => {
 
 // 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' },
@@ -545,7 +586,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.' }); }
 });
 
@@ -570,7 +611,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,
@@ -651,13 +691,16 @@ app.get('/:version/website', async (req, res) => {
             doc_coopbot: process.env.DOC_COOPBOT,
             docs: process.env.DOCS,
             donut: process.env.DONUT,
+            drawio_plugin: process.env.DRAWIO_PLUGIN,
             flowers: process.env.FLOWERS,
             gemsync: process.env.GEMSYNC,
             gitsite: process.env.GITSITE,
             logs: process.env.LOGS,
+            morpion: process.env.MORPION,
             nitrogen: process.env.NITROGEN,
             old_database: process.env.OLD_DATABASE,
             php: process.env.PHP,
+            ping: process.env.PING,
             portfolio: process.env.PORTFOLIO,
             python_api: process.env.PYTHON_API,
             readme: process.env.README,
@@ -792,12 +835,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);
@@ -818,40 +856,42 @@ app.post('/:version/tic-tac-toe/fetch', (req, res) => {
 // 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.7.0",
+    "version": "2.9.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",