@20syldev/api 3.5.0 → 4.0.0

package/src/middleware/ratelimit.ts

@@ -0,0 +1,66 @@
+import type { Request, Response, NextFunction } from 'express';
+import { env } from '../config/env.js';
+import { ipLimits } from '../storage/index.js';
+import { SESSION_TTL } from '../constants.js';
+import { error } from '../utils/response.js';
+
+let requests = 0;
+let resetTime = Date.now() + SESSION_TTL;
+
+export function rateLimitMiddleware(req: Request, res: Response, next: NextFunction): void {
+    const ip = (req.headers['cf-connecting-ip'] as string) || req.socket.remoteAddress || '';
+    const token = req.headers.authorization?.split(' ')[1] || '';
+
+    const now = Date.now();
+    const minute = String(Math.floor(now / 60000) % 60);
+    const hour = String(Math.floor(now / 3600000) % 24);
+
+    if (
+        (token && ![...env.BUSINESS_TOKEN_LIST, ...env.PRO_TOKEN_LIST, ...env.ADVANCED_TOKEN_LIST].includes(token)) ||
+        token === 'undefined'
+    ) {
+        error(res, 401, 'Invalid token.');
+        return;
+    }
+
+    let requestLimit: number;
+    if (env.BUSINESS_TOKEN_LIST.includes(token) && !env.BUSINESS_TOKEN_LIST.includes('undefined')) {
+        requestLimit = env.BUSINESS_LIMIT;
+    } else if (env.PRO_TOKEN_LIST.includes(token) && !env.PRO_TOKEN_LIST.includes('undefined')) {
+        requestLimit = env.PRO_LIMIT;
+    } else if (env.ADVANCED_TOKEN_LIST.includes(token) && !env.ADVANCED_TOKEN_LIST.includes('undefined')) {
+        requestLimit = env.ADVANCED_LIMIT;
+    } else {
+        requestLimit = env.DEFAULT_LIMIT;
+    }
+
+    if (now > resetTime) {
+        requests = 0;
+        resetTime = now + SESSION_TTL;
+    }
+
+    if (++requests > Math.max(env.GLOBAL_LIMIT, requestLimit)) {
+        error(res, 429, 'Global rate limit exceeded.');
+        return;
+    }
+
+    if (['__proto__', 'constructor', 'prototype'].includes(ip)) {
+        error(res, 400, 'Invalid IP address.');
+        return;
+    }
+
+    if (!ipLimits[ip]) ipLimits[ip] = {};
+    if (!ipLimits[ip]![hour]) ipLimits[ip]![hour] = {};
+    ipLimits[ip]![hour]![minute] = (ipLimits[ip]![hour]![minute] ?? 0) + 1;
+
+    if (ipLimits[ip]![hour]![minute]! > requestLimit) {
+        error(res, 429, `You have exceeded the limit of ${requestLimit} requests per hour.`);
+        return;
+    }
+
+    Object.keys(ipLimits[ip]!).forEach((h) => {
+        if (h != hour) delete ipLimits[ip]![h];
+    });
+
+    next();
+}

package/src/middleware/version.ts

@@ -0,0 +1,39 @@
+import type { Request, Response, NextFunction } from 'express';
+import { versions } from '../config/versions.js';
+import { error } from '../utils/response.js';
+
+export function versionCheckMiddleware(req: Request, res: Response, next: NextFunction): void {
+    const version = req.params.version as string;
+    const latest = Object.keys(versions).pop()!;
+
+    req.version = version;
+    req.latest = latest;
+
+    if (!versions[version]) {
+        error(res, 404, `Invalid API version (${version}).`, latest);
+        return;
+    }
+
+    req.module = versions[version]!.modules;
+
+    if (!req.module) {
+        error(res, 404, `Module not found for version ${version}.`, latest);
+        return;
+    }
+
+    next();
+}
+
+export function endpointCheckMiddleware(req: Request, res: Response, next: NextFunction): void {
+    const version = req.params.version as string;
+    const endpoint = req.params.endpoint as string;
+
+    req.version = version;
+    req.endpoint = endpoint;
+
+    if (!endpoint) {
+        error(res, 404, `Endpoint '${endpoint}' does not exist in ${req.version}.`);
+        return;
+    }
+    next();
+}

package/{modules → src/modules}/v3/algorithms.js

@@ -215,4 +215,4 @@ export function reverse(value) {
     if (typeof value !== 'string') throw new Error('Value must be a string');
 
     return value.split('').reverse().join('');
-}
+}

package/src/modules/v3/captcha.js

@@ -0,0 +1,60 @@
+import { createCanvas } from 'canvas';
+
+/**
+ * Generate a captcha image from the provided text
+ *
+ * @param {string} text - Text to render in the captcha image
+ * @returns {Buffer} - PNG image buffer of the rendered captcha
+ * @throws {Error} - If text is not provided
+ */
+export default function captcha(text) {
+    if (!text) throw new Error('Text is required to generate a captcha.');
+
+    const size = 60,
+        font = '60px Comic Sans Ms',
+        width = text.length * size,
+        height = 120;
+    const canvas = createCanvas(width, height),
+        ctx = canvas.getContext('2d');
+
+    // Set white background
+    ctx.fillStyle = 'white';
+    ctx.fillRect(0, 0, width, height);
+
+    // Add random lines for noise
+    for (let i = 0; i < 20; i++) {
+        ctx.strokeStyle = 'rgba(0, 0, 0, 0.3)';
+        ctx.beginPath();
+        ctx.moveTo(Math.random() * width, Math.random() * height);
+        ctx.lineTo(Math.random() * width, Math.random() * height);
+        ctx.lineWidth = Math.random() * 2;
+        ctx.stroke();
+    }
+
+    let x = (canvas.width + 20 - width) / 2;
+
+    // Draw each character with random rotation and color
+    for (let i = 0; i < text.length; i++) {
+        const offsetX = Math.cos(i * 0.3) * 10,
+            y = height / 2.5 + Math.floor(Math.random() * (height / 2));
+
+        ctx.font = font;
+        ctx.fillStyle = `rgb(${Math.floor(Math.random() * 192)}, ${Math.floor(Math.random() * 192)}, ${Math.floor(Math.random() * 192)})`;
+
+        ctx.save();
+        ctx.translate(x + size / 2, y);
+        ctx.rotate((Math.random() - 0.5) * 0.5);
+        ctx.fillText(text[i], -size / 2 + offsetX, 0);
+        ctx.restore();
+
+        x += size;
+    }
+
+    // Add noise dots
+    for (let i = 0; i < 200; i++) {
+        ctx.fillStyle = 'black';
+        ctx.fillRect(Math.floor(Math.random() * width), Math.floor(Math.random() * height), 1.2, 1.2);
+    }
+
+    return canvas.toBuffer('image/png');
+}

package/{modules → src/modules}/v3/chat.js

@@ -1,4 +1,4 @@
-import { checkRateLimit } from "./utils.js";
+import { checkRateLimit } from './utils.js';
 
 /**
  * Manages a chat system with public and private messages
@@ -61,14 +61,16 @@ function sendMessage(params, messages, privateChats, sessions, u, now) {
     const msg = {
         username: params.username,
         message,
-        timestamp: params.timestamp || new Date().toISOString()
+        timestamp: params.timestamp || new Date().toISOString(),
     };
 
     // Store message based on whether it's private or public
     if (token) {
         privateChats[token] = privateChats[token] || [];
         privateChats[token].push(msg);
-        setTimeout(() => { delete privateChats[token]; }, 3600000);
+        setTimeout(() => {
+            delete privateChats[token];
+        }, 3600000);
     } else {
         messages.push(msg);
         setTimeout(() => messages.splice(messages.indexOf(msg), 1), 3600000);
@@ -106,4 +108,4 @@ function getPrivateChat(params, privateChats) {
 function fetchMessages(messages) {
     if (messages.length > 0) return messages;
     throw new Error('No messages stored.');
-}
+}

package/src/modules/v3/color.js

@@ -0,0 +1,60 @@
+/**
+ * Generate a random color in multiple formats
+ *
+ * @returns {Object} Color in various formats (hex, rgb, hsl, hsv, hwb, cmyk)
+ */
+export default function color() {
+    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];
+        const d = max - min,
+            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        let h = { [r1]: (g1 - b1) / d + (g1 < b1 ? 6 : 0), [g1]: (b1 - r1) / d + 2, [b1]: (r1 - g1) / d + 4 }[max];
+        return [(h * 60) % 360, s * 100, l * 100];
+    })();
+
+    const hsv = (() => {
+        const max = Math.max(r, g, b),
+            min = Math.min(r, g, b),
+            v = max / 255,
+            s = max ? (max - min) / max : 0;
+        let h =
+            max === min
+                ? 0
+                : { [r]: (g - b) / (max - min), [g]: 2 + (b - r) / (max - min), [b]: 4 + (r - g) / (max - min) }[max];
+        return [(h * 60) % 360, s * 100, v * 100];
+    })();
+
+    const hwb = (() => {
+        const [h] = hsv,
+            whiteness = Math.min(r, g, b) / 255,
+            blackness = 1 - Math.max(r, g, b) / 255;
+        return [h, whiteness * 100, blackness * 100];
+    })();
+
+    const cmyk = (() => {
+        const k = 1 - Math.max(r, g, b) / 255,
+            c = (1 - r / 255 - k) / (1 - k) || 0,
+            m = (1 - g / 255 - k) / (1 - k) || 0,
+            y = (1 - b / 255 - k) / (1 - k) || 0;
+        return [c, m, y, k].map((x) => x * 100);
+    })();
+
+    return {
+        hex: `#${[r, g, b].map((x) => x.toString(16).padStart(2, '0')).join('')}`,
+        rgb: `rgb(${r}, ${g}, ${b})`,
+        hsl: `hsl(${hsl[0].toFixed(1)}, ${hsl[1].toFixed(1)}%, ${hsl[2].toFixed(1)}%)`,
+        hsv: `hsv(${hsv[0].toFixed(1)}, ${hsv[1].toFixed(1)}%, ${hsv[2].toFixed(1)}%)`,
+        hwb: `hwb(${hwb[0].toFixed(1)}, ${hwb[1].toFixed(1)}%, ${hwb[2].toFixed(1)}%)`,
+        cmyk: `cmyk(${cmyk.map((x) => x.toFixed(1)).join('%, ')}%)`,
+    };
+}

package/{modules → src/modules}/v3/convert.js

@@ -11,15 +11,15 @@ export default function convert(value, from, to) {
     const conversions = {
         celsius: {
             fahrenheit: (val) => (val * 9) / 5 + 32,
-            kelvin: (val) => val + 273.15
+            kelvin: (val) => val + 273.15,
         },
         fahrenheit: {
             celsius: (val) => ((val - 32) * 5) / 9,
-            kelvin: (val) => ((val - 32) * 5) / 9 + 273.15
+            kelvin: (val) => ((val - 32) * 5) / 9 + 273.15,
         },
         kelvin: {
             celsius: (val) => val - 273.15,
-            fahrenheit: (val) => ((val - 273.15) * 9) / 5 + 32
+            fahrenheit: (val) => ((val - 273.15) * 9) / 5 + 32,
         },
     };
 
@@ -34,6 +34,6 @@ export default function convert(value, from, to) {
         from,
         to,
         value: parseFloat(value),
-        result: convert(parseFloat(value))
+        result: convert(parseFloat(value)),
     };
-}
+}

package/{modules → src/modules}/v3/domain.js

@@ -6,9 +6,56 @@ import { random, genIP } from './utils.js';
  * @returns {Object} Domain details including DNS, hosting, and SEO metrics
  */
 export default function domain() {
-    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 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}`;
@@ -36,4 +83,4 @@ export default function domain() {
         creation_date: new Date(Date.now() - Math.floor(Math.random() * 10000000000)).toISOString(),
         expiration_date: new Date(Date.now() + Math.floor(Math.random() * 10000000000)).toISOString(),
     };
-}
+}

package/{modules → src/modules}/v3/hash.js

@@ -13,4 +13,4 @@ export default function hash(text, method) {
 
     const hash = createHash(method).update(text).digest('hex');
     return { method, hash };
-}
+}

package/{modules → src/modules}/v3/hyperplanning.js

@@ -1,6 +1,5 @@
 import { formatDate } from './utils.js';
 import ical from 'ical.js';
-import fetch from 'node-fetch';
 
 /**
  * Parse an ICS calendar file and extract event information
@@ -19,24 +18,26 @@ export default async function hyperplanning(url, detail) {
 
     const events = new ical.Component(ical.parse(await response.text()))
         .getAllSubcomponents('vevent')
-        .map(e => {
+        .map((e) => {
             const evt = new ical.Event(e);
-            const summary = (evt.summary || '').split(' ').filter(part => part !== '-');
+            const summary = (evt.summary || '').split(' ').filter((part) => part !== '-');
             const start = formatDate(evt.startDate.toJSDate());
             const end = formatDate(evt.endDate.toJSDate());
 
             if (detail === 'full') {
-                const desc = (evt.description || '').split('\n').map(l => l.trim());
-                const extract = (p) => (desc.find(l => l.startsWith(p)) || '').replace(p, '').trim();
+                const desc = (evt.description || '').split('\n').map((l) => l.trim());
+                const extract = (p) => (desc.find((l) => l.startsWith(p)) || '').replace(p, '').trim();
 
                 return {
                     summary,
                     subject: extract('Matière :'),
                     teacher: extract('Enseignant :'),
-                    classes: extract('Promotions :').split(', ').map(c => c.trim()),
+                    classes: extract('Promotions :')
+                        .split(', ')
+                        .map((c) => c.trim()),
                     type: extract('Salle :') || undefined,
                     start,
-                    end
+                    end,
                 };
             }
 
@@ -45,11 +46,11 @@ export default async function hyperplanning(url, detail) {
             return {
                 summary: evt.summary || '',
                 start,
-                end
+                end,
             };
         })
         .sort((a, b) => new Date(a.start) - new Date(b.start))
-        .filter(e => new Date(e.end) >= new Date());
+        .filter((e) => new Date(e.end) >= new Date());
 
     return events;
-}
+}

package/{modules → src/modules}/v3/levenshtein.js

@@ -33,7 +33,7 @@ export default function levenshtein(str1, str2) {
             m[i][j] = Math.min(
                 m[i - 1][j] + 1,
                 m[i][j - 1] + 1,
-                m[i - 1][j - 1] + (str1[i - 1] !== str2[j - 1] ? 1 : 0)
+                m[i - 1][j - 1] + (str1[i - 1] !== str2[j - 1] ? 1 : 0),
             );
         }
     }
@@ -41,6 +41,6 @@ export default function levenshtein(str1, str2) {
     return {
         str1,
         str2,
-        distance: m[str1.length][str2.length]
+        distance: m[str1.length][str2.length],
     };
-}
+}

package/{modules → src/modules}/v3/personal.js

@@ -16,7 +16,7 @@ export default function personal() {
         { name: 'Daniel Brown', social: 'daniel_brown', email: 'daniel@example.com', country: 'JP' },
         { name: 'Sophia Wilson', social: 'sophia_wilson', email: 'sophia@example.com', country: 'BR' },
         { name: 'James Taylor', social: 'james_taylor', email: 'james@example.com', country: 'CA' },
-        { name: 'Olivia Thomas', social: 'olivia_thomas', email: 'olivia@example.com', country: 'AU' }
+        { name: 'Olivia Thomas', social: 'olivia_thomas', email: 'olivia@example.com', country: 'AU' },
     ];
 
     const countries = {
@@ -29,12 +29,24 @@ export default function personal() {
         JP: { tel: '080-1234-5678', code: '81', lang: 'Japanese' },
         BR: { tel: '(11) 98765-4321', code: '55', lang: 'Portuguese' },
         CA: { tel: '416-123-4567', code: '1', lang: 'English' },
-        AU: { tel: '0412 345 678', code: '61', lang: 'English' }
+        AU: { tel: '0412 345 678', code: '61', lang: 'English' },
     };
 
     const jobs = ['Writer', 'Artist', 'Musician', 'Explorer', 'Scientist', 'Engineer', 'Athlete', 'Doctor'];
     const hobbies = ['Reading', 'Traveling', 'Gaming', 'Cooking', 'Fitness', 'Music', 'Photography', 'Writing'];
-    const cities = ['New York', 'Paris', 'London', 'Madrid', 'Berlin', 'Rome', 'Tokyo', 'Los Angeles', 'Sydney', 'São Paulo', 'Toronto'];
+    const cities = [
+        'New York',
+        'Paris',
+        'London',
+        'Madrid',
+        'Berlin',
+        'Rome',
+        'Tokyo',
+        'Los Angeles',
+        'Sydney',
+        'São Paulo',
+        'Toronto',
+    ];
     const streets = ['Main St', '2nd Ave', 'Broadway', 'Park Lane', 'Elm St', 'Sunset Blvd', 'Maple St', 'Highland Rd'];
 
     const card = Array.from({ length: 4 }, () => randomNumber(1000, 9999)).join(' ');
@@ -66,7 +78,7 @@ export default function personal() {
         let emergencyContact = random(people);
         while (
             emergencyContact.email === person.email ||
-            emergencyContacts.some(e => e.email === emergencyContact.email)
+            emergencyContacts.some((e) => e.email === emergencyContact.email)
         ) {
             emergencyContact = random(people);
         }
@@ -74,7 +86,7 @@ export default function personal() {
         emergencyContacts.push({
             name: emergencyContact.name,
             relationship: random(['Spouse', 'Parent', 'Sibling', 'Friend']),
-            phone: `+${countries[country].code} ${emergencyPhone}`
+            phone: `+${countries[country].code} ${emergencyPhone}`,
         });
     }
 
@@ -113,15 +125,15 @@ export default function personal() {
             twitter: `@${social}`,
             facebook: `facebook.com/${social}`,
             linkedin: `linkedin.com/in/${social}`,
-            instagram: `instagram.com/${social}`
+            instagram: `instagram.com/${social}`,
         },
         year_income: `${yearIncome} USD/year`,
         month_income: `${(yearIncome / 12).toFixed(2)} USD/month`,
-        education: random(['High School', 'Bachelor\'s', 'Master\'s', 'PhD']),
+        education: random(['High School', "Bachelor's", "Master's", 'PhD']),
         work_experience: `${randomNumber(0, 20)} years`,
         health_status: random(['Healthy', 'Minor Issues', 'Chronic Conditions']),
         emergency_contacts: emergencyContacts,
         subscriptions,
         pets,
     };
-}
+}

package/{modules → src/modules}/v3/qrcode.js

@@ -17,4 +17,4 @@ export default async function qrcode(url) {
     } catch (error) {
         throw new Error(`Failed to generate QR code: ${error.message}`);
     }
-}
+}

package/{modules → src/modules}/v3/tic_tac_toe.js

@@ -30,7 +30,7 @@ export default function tic_tac_toe(action, params = {}) {
     const now = Date.now();
 
     // Rate limiting
-    rateLimits[u] = (rateLimits[u] || []).filter(ts => now - ts < 10000);
+    rateLimits[u] = (rateLimits[u] || []).filter((ts) => now - ts < 10000);
     if (rateLimits[u].length > 50) {
         const remainingTime = Math.ceil((rateLimits[u][0] + 10000 - now) / 1000);
         throw new Error(`Rate limit exceeded. Try again in ${remainingTime} seconds.`);
@@ -70,12 +70,12 @@ function playMove(params, games, sessions, u, now) {
         moves: [],
         players: [],
         private: params.private || false,
-        creation: Date.now()
+        creation: Date.now(),
     };
     const moves = games[game].moves;
 
     // Check if game is full
-    const players = [...new Set(moves.map(play => play.username))];
+    const players = [...new Set(moves.map((play) => play.username))];
     if (players.length >= 2 && !players.includes(params.username)) {
         throw new Error('Game is full, you can only watch.');
     }
@@ -86,7 +86,7 @@ function playMove(params, games, sessions, u, now) {
     }
 
     // Check if move is already made
-    if (moves.some(play => play.move === move)) {
+    if (moves.some((play) => play.move === move)) {
         throw new Error('Move already made. Please choose a different move.');
     }
 
@@ -99,8 +99,8 @@ function playMove(params, games, sessions, u, now) {
     if (result.winner || result.tie) {
         setTimeout(() => delete games[game], 600000);
         return {
-            message: `Move sent successfully. ${result.winner ? result.winner + ' wins. ' + result.loser + ' loses.' : 'It\'s a tie.'}`,
-            ...result
+            message: `Move sent successfully. ${result.winner ? result.winner + ' wins. ' + result.loser + ' loses.' : "It's a tie."}`,
+            ...result,
         };
     }
 
@@ -110,7 +110,9 @@ function playMove(params, games, sessions, u, now) {
     // Update session
     sessions[u] = sessions[u] || { user: session, last: now };
     sessions[u].last = now;
-    setTimeout(() => { if (now - sessions[u].last >= 3600000) delete sessions[u]; }, 3600000);
+    setTimeout(() => {
+        if (now - sessions[u].last >= 3600000) delete sessions[u];
+    }, 3600000);
 
     return { message: 'Move sent successfully' };
 }
@@ -125,7 +127,7 @@ function fetchGame(params, games, u) {
             moves: [],
             players: [],
             private: params.private || false,
-            creation: Date.now()
+            creation: Date.now(),
         };
     }
     if (!games[id].players.includes(u)) {
@@ -136,7 +138,7 @@ function fetchGame(params, games, u) {
     const players = games[id].players;
     const privateGame = games[id].private;
     const lastPlayer = moves.length ? moves[moves.length - 1].username : null;
-    const turn = players.find(p => p !== lastPlayer) || players[0];
+    const turn = players.find((p) => p !== lastPlayer) || players[0];
     const status = players.length >= 2 ? 'ready' : 'waiting';
     const result = moves.length ? checkGame(moves) : {};
 
@@ -147,7 +149,7 @@ function fetchGame(params, games, u) {
         turn,
         status,
         private: privateGame,
-        ...result
+        ...result,
     };
 }
 
@@ -167,7 +169,7 @@ function listGames(games) {
             // Only include active games (not finished)
             if (!isFinished) {
                 const lastPlayer = game.moves.length ? game.moves[game.moves.length - 1].username : null;
-                const turn = game.players.find(p => p !== lastPlayer) || game.players[0];
+                const turn = game.players.find((p) => p !== lastPlayer) || game.players[0];
                 const status = game.players.length >= 2 ? 'ready' : 'waiting';
 
                 publicGames.push({
@@ -177,7 +179,7 @@ function listGames(games) {
                     moves: game.moves.length,
                     turn,
                     status,
-                    creation: game.creation || now
+                    creation: game.creation || now,
                 });
             }
         }
@@ -189,7 +191,7 @@ function listGames(games) {
     return {
         message: 'Public games available',
         count: publicGames.length,
-        games: publicGames
+        games: publicGames,
     };
 }
 
@@ -198,14 +200,18 @@ function listGames(games) {
  */
 function generateGameId() {
     const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-    return Array.from(randomBytes(5)).map(b => chars[b % chars.length]).join('');
+    return Array.from(randomBytes(5))
+        .map((b) => chars[b % chars.length])
+        .join('');
 }
 
 /**
  * Check the game result
  */
 function checkGame(moves) {
-    let board = Array(3).fill().map(() => Array(3).fill(null));
+    let board = Array(3)
+        .fill()
+        .map(() => Array(3).fill(null));
     let playerSymbols = {};
     let playersOrder = [];
 
@@ -228,9 +234,9 @@ function checkGame(moves) {
         return false;
     };
 
-    let winner = Object.keys(playerSymbols).find(player => checkWinner(playerSymbols[player]));
+    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;
+    let loser = winner && playersOrder.length === 2 ? playersOrder.find((player) => player !== winner) : null;
 
     return { winner, loser, tie: isTie };
-}
+}