@20syldev/api 4.0.0 → 4.2.0

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://api.sylvain.sh"><img src="https://api.sylvain.sh/favicon.ico" alt="Logo" width="25%" height="auto"/></a>
 
   # API Personnelle
-  [![Version](https://custom-icon-badges.demolab.com/badge/Version%20:-v4.0.0-6479ee?logo=api.sylvain.sh&labelColor=23272A)](https://github.com/20syldev/api/releases/latest)
+  [![Version](https://custom-icon-badges.demolab.com/badge/Version%20:-v4.2.0-6479ee?logo=api.sylvain.sh&labelColor=23272A)](https://github.com/20syldev/api/releases/latest)
 </div>
 
 ---
@@ -32,10 +32,10 @@ Pour démarrer un serveur local avec tous les endpoints :
 $ npm run build && npm start
 ```
 ```console
-> @20syldev/api@4.0.0 build
+> @20syldev/api@4.2.0 build
 > tsc
 
-> @20syldev/api@4.0.0 start
+> @20syldev/api@4.2.0 start
 > node dist/app.js
 
 API is running on
@@ -93,16 +93,21 @@ import {
     chat,              // Système de chat temporaire
     color,             // Génération de couleurs aléatoires
     convert,           // Conversions d'unités
+    dice,              // Lanceur de dés RPG
     domain,            // Informations de domaine aléatoires
+    encode,            // Encodage / décodage (base64, morse, rot13, caesar, binaire)
     hash,              // Hachage de texte
     hyperplanning,     // Analyse de calendriers
     levenshtein,       // Distance entre chaînes
     personal,          // Informations personnelles aléatoires
     qrcode,            // Génération de QR codes
+    statistics,        // Statistiques descriptives
     tic_tac_toe,       // Jeu de morpion
     time,              // Informations temporelles
+    text,              // Utilitaires texte (slug, stats, lorem, nombre en lettres)
     token,             // Génération de jetons sécurisés
-    username           // Génération de noms d'utilisateur
+    username,          // Génération de noms d'utilisateur
+    validate           // Validation (Luhn, IBAN, email)
 } from '@20syldev/api/v4';
 ```
 

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "4.0.0",
+    "version": "4.2.0",
     "name": "@20syldev/api",
     "description": "Node.js API with multiple features. Check the documentation at https://docs.sylvain.sh",
     "main": "dist/app.js",
@@ -8,8 +8,9 @@
         "dev": "tsx watch src/app.ts",
         "start": "node dist/app.js",
         "build": "tsc",
-        "check": "tsc --noEmit && eslint src/",
-        "format": "prettier --write src/ && eslint --fix src/",
+        "check": "tsc --noEmit -p tsconfig.test.json && eslint src/ tests/",
+        "format": "prettier --write src/ tests/ && eslint --fix src/ tests/",
+        "test": "NODE_ENV=test node --import tsx --test --test-force-exit tests/unit/*.test.ts tests/integration/*.test.ts",
         "upgrade:minor": "npm upgrade",
         "upgrade:major": "npx npm-check-updates -u && npm install"
     },
@@ -37,7 +38,7 @@
         "@eslint/js": "^9.24.0",
         "@types/cors": "^2.8.17",
         "@types/express": "^5.0.0",
-        "@types/node": "^22.0.0",
+        "@types/node": "^22.19.17",
         "@types/qrcode": "^1.5.6",
         "@types/uuid": "^10.0.0",
         "eslint": "^9.24.0",

package/src/app.ts

@@ -39,6 +39,10 @@ app.use(getRoutes);
 app.use(postRoutes);
 
 // Start server
-app.listen(env.PORT, () =>
-    console.log(`API is running on\n    - http://127.0.0.1:${env.PORT}\n    - http://localhost:${env.PORT}`),
-);
+if (process.env.NODE_ENV !== 'test') {
+    app.listen(env.PORT, () =>
+        console.log(`API is running on\n    - http://127.0.0.1:${env.PORT}\n    - http://localhost:${env.PORT}`),
+    );
+}
+
+export default app;

package/src/config/versions.ts

@@ -11,10 +11,22 @@ export interface VersionConfig {
     endpoints: {
         get: Endpoint[];
         post: Endpoint[];
+        patch?: Endpoint[];
+        delete?: Endpoint[];
     };
     modules: typeof apiv3 | typeof apiv4;
 }
 
+/**
+ * Merges a base list of endpoints with additions, deduplicating by `name`.
+ * If an addition has the same name as a base entry, it overrides it.
+ */
+const merge = (base: Endpoint[], additions: Endpoint[]): Endpoint[] => {
+    const map = new Map(base.map((e) => [e.name, e]));
+    for (const e of additions) map.set(e.name, e);
+    return [...map.values()];
+};
+
 const v1 = {
     get: [
         { name: 'algorithms', path: '/algorithms?method={algorithm}&value={value}(&value2={value2})' },
@@ -32,9 +44,8 @@ const v1 = {
 };
 
 const v2 = {
-    get: [...v1.get, { name: 'chat', path: '/chat' }],
-    post: [
-        ...v1.post,
+    get: merge(v1.get, [{ name: 'chat', path: '/chat' }]),
+    post: merge(v1.post, [
         {
             name: 'chat',
             children: {
@@ -51,24 +62,28 @@ const v2 = {
                 list: '/tic-tac-toe/list',
             } as Record<string, string>,
         },
-        { name: 'token', path: '/token' },
-    ],
+    ]),
 };
 
 const v3 = {
-    get: [
-        ...v2.get,
+    get: merge(v2.get, [
         { name: 'levenshtein', path: '/levenshtein?str1={string}&str2={string}' },
         {
             name: 'time',
             path: '/time(?type={type}&start={timestamp}&end={timestamp}&format={format}&timezone={timezone})',
         },
-    ],
-    post: [...v2.post, { name: 'hyperplanning', path: '/hyperplanning' }],
+    ]),
+    post: merge(v2.post, [{ name: 'hyperplanning', path: '/hyperplanning' }]),
 };
 
 const v4 = {
-    get: [...v3.get],
+    get: merge(v3.get, [
+        { name: 'dice', path: '/dice?roll={NdX+M}' },
+        { name: 'encode', path: '/encode?method={method}&text={text}(&shift={shift})' },
+        { name: 'statistics', path: '/statistics?values={n1,n2,n3,...}' },
+        { name: 'text', path: '/text?method={method}(&value={value}&type={type}&count={count}&lang={lang})' },
+        { name: 'validate', path: '/validate?type={type}&value={value}' },
+    ]),
     post: [...v3.post],
 };
 

package/src/constants.ts

@@ -1,3 +1,6 @@
+import pkg from '../package.json' with { type: 'json' };
+
+export const APP_VERSION = pkg.version;
 export const MAX_LOG_ENTRIES = 1000;
 export const RATE_LIMIT_WINDOW = 10_000;
 export const RATE_LIMIT_MAX = 50;
@@ -26,3 +29,19 @@ export const STATUS_MESSAGES: Record<number, string> = {
 };
 
 export const START_TIME = Date.now();
+
+export const ROMAN_VALUES: [number, string][] = [
+    [1000, 'M'],
+    [900, 'CM'],
+    [500, 'D'],
+    [400, 'CD'],
+    [100, 'C'],
+    [90, 'XC'],
+    [50, 'L'],
+    [40, 'XL'],
+    [10, 'X'],
+    [9, 'IX'],
+    [5, 'V'],
+    [4, 'IV'],
+    [1, 'I'],
+];

package/src/modules/v4/algorithms.ts

@@ -1,4 +1,4 @@
-import { MAX_FACTORIAL, MAX_GCD_VALUE, MAX_PRIME_LIST, MAX_STRING_LENGTH } from '../../constants.js';
+import { MAX_FACTORIAL, MAX_GCD_VALUE, MAX_PRIME_LIST, MAX_STRING_LENGTH, ROMAN_VALUES } from '../../constants.js';
 
 export function anagram(value: string, value2: string): boolean {
     if (!value) throw new Error('First value is required');
@@ -153,3 +153,45 @@ export function reverse(value: string): string {
 
     return value.split('').reverse().join('');
 }
+
+export function roman(value: string): number | string {
+    if (!value) throw new Error('A value is required');
+
+    const num = Number(value);
+    if (!isNaN(num)) {
+        if (!Number.isInteger(num)) throw new Error('Value must be an integer');
+        if (num < 1 || num > 3999) throw new Error('Number must be between 1 and 3999');
+
+        let result = '';
+        let n = num;
+        for (const [val, sym] of ROMAN_VALUES) {
+            while (n >= val) {
+                result += sym;
+                n -= val;
+            }
+        }
+        return result;
+    }
+
+    if (typeof value !== 'string') throw new Error('Value must be a number or a Roman numeral');
+    const upper = value.toUpperCase();
+    if (!/^[MDCLXVI]+$/.test(upper)) throw new Error('Invalid Roman numeral');
+
+    let result = 0;
+    let i = 0;
+    while (i < upper.length) {
+        const two = upper.slice(i, i + 2);
+        const match = ROMAN_VALUES.find(([, sym]) => sym === two);
+        if (match) {
+            result += match[0];
+            i += 2;
+        } else {
+            const one = ROMAN_VALUES.find(([, sym]) => sym === upper[i]);
+            if (!one) throw new Error('Invalid Roman numeral');
+            result += one[0];
+            i += 1;
+        }
+    }
+
+    return result;
+}

package/src/modules/v4/dice.ts

@@ -0,0 +1,39 @@
+export interface DiceResult {
+    roll: string;
+    count: number;
+    sides: number;
+    modifier: number;
+    results: number[];
+    total: number;
+}
+
+export default function dice(roll: string): DiceResult {
+    if (!roll) throw new Error('A roll notation is required (e.g. 2d6+3)');
+    if (typeof roll !== 'string') throw new Error('Roll must be a string');
+
+    const match = /^(\d*)d(\d+)([+-]\d+)?$/i.exec(roll.trim().replace(/\s+/g, '+'));
+    if (!match) throw new Error('Invalid notation. Use NdX or NdX+M (e.g. 2d6+3)');
+
+    const count = match[1] ? parseInt(match[1], 10) : 1;
+    const sides = parseInt(match[2]!, 10);
+    const modifier = match[3] ? parseInt(match[3], 10) : 0;
+
+    if (count < 1 || count > 100) throw new Error('Number of dice must be between 1 and 100');
+    if (sides < 2 || sides > 1000) throw new Error('Number of sides must be between 2 and 1000');
+
+    const results: number[] = [];
+    for (let i = 0; i < count; i++) {
+        results.push(1 + Math.floor(Math.random() * sides));
+    }
+
+    const total = results.reduce((a, b) => a + b, 0) + modifier;
+
+    return {
+        roll: `${count}d${sides}${modifier ? (modifier > 0 ? `+${modifier}` : modifier) : ''}`,
+        count,
+        sides,
+        modifier,
+        results,
+        total,
+    };
+}

package/src/modules/v4/encode.ts

@@ -0,0 +1,170 @@
+import { MAX_STRING_LENGTH } from '../../constants.js';
+
+const MORSE_TABLE: Record<string, string> = {
+    A: '.-',
+    B: '-...',
+    C: '-.-.',
+    D: '-..',
+    E: '.',
+    F: '..-.',
+    G: '--.',
+    H: '....',
+    I: '..',
+    J: '.---',
+    K: '-.-',
+    L: '.-..',
+    M: '--',
+    N: '-.',
+    O: '---',
+    P: '.--.',
+    Q: '--.-',
+    R: '.-.',
+    S: '...',
+    T: '-',
+    U: '..-',
+    V: '...-',
+    W: '.--',
+    X: '-..-',
+    Y: '-.--',
+    Z: '--..',
+    '0': '-----',
+    '1': '.----',
+    '2': '..---',
+    '3': '...--',
+    '4': '....-',
+    '5': '.....',
+    '6': '-....',
+    '7': '--...',
+    '8': '---..',
+    '9': '----.',
+    '.': '.-.-.-',
+    ',': '--..--',
+    '?': '..--..',
+    "'": '.----.',
+    '!': '-.-.--',
+    '/': '-..-.',
+    '(': '-.--.',
+    ')': '-.--.-',
+    '&': '.-...',
+    ':': '---...',
+    ';': '-.-.-.',
+    '=': '-...-',
+    '+': '.-.-.',
+    '-': '-....-',
+    _: '..--.-',
+    '"': '.-..-.',
+    $: '...-..-',
+    '@': '.--.-.',
+};
+
+const MORSE_REVERSE: Record<string, string> = Object.fromEntries(Object.entries(MORSE_TABLE).map(([k, v]) => [v, k]));
+
+function checkText(value: string): void {
+    if (!value) throw new Error('A value is required');
+    if (typeof value !== 'string') throw new Error('Value must be a string');
+    if (value.length > MAX_STRING_LENGTH)
+        throw new Error(`Value must be less than ${MAX_STRING_LENGTH} characters long`);
+}
+
+export function base64encode(value: string): string {
+    checkText(value);
+    return Buffer.from(value, 'utf-8').toString('base64');
+}
+
+export function base64decode(value: string): string {
+    checkText(value);
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value)) throw new Error('Invalid Base64 string');
+    return Buffer.from(value, 'base64').toString('utf-8');
+}
+
+export function urlencode(value: string): string {
+    checkText(value);
+    return encodeURIComponent(value);
+}
+
+export function urldecode(value: string): string {
+    checkText(value);
+    try {
+        return decodeURIComponent(value);
+    } catch {
+        throw new Error('Invalid URL-encoded string');
+    }
+}
+
+export function morse(value: string): string {
+    checkText(value);
+    return value
+        .toUpperCase()
+        .split(' ')
+        .map((word) =>
+            word
+                .split('')
+                .map((c) => {
+                    if (c === '\n' || c === '\t') return '';
+                    const code = MORSE_TABLE[c];
+                    if (!code) throw new Error(`Unsupported character in Morse code: '${c}'`);
+                    return code;
+                })
+                .filter(Boolean)
+                .join(' '),
+        )
+        .join(' / ');
+}
+
+export function unmorse(value: string): string {
+    checkText(value);
+    return value
+        .split(' / ')
+        .map((word) =>
+            word
+                .split(' ')
+                .map((code) => {
+                    if (!code) return '';
+                    const char = MORSE_REVERSE[code];
+                    if (!char) throw new Error(`Unsupported Morse sequence: '${code}'`);
+                    return char;
+                })
+                .join(''),
+        )
+        .join(' ');
+}
+
+export function rot13(value: string): string {
+    checkText(value);
+    return value.replace(/[a-zA-Z]/g, (c) => {
+        const base = c <= 'Z' ? 65 : 97;
+        return String.fromCharCode(((c.charCodeAt(0) - base + 13) % 26) + base);
+    });
+}
+
+export function caesar(value: string, shift: string): string {
+    checkText(value);
+    const n = Number(shift);
+    if (isNaN(n)) throw new Error('Shift must be a number');
+    const s = ((n % 26) + 26) % 26;
+    return value.replace(/[a-zA-Z]/g, (c) => {
+        const base = c <= 'Z' ? 65 : 97;
+        return String.fromCharCode(((c.charCodeAt(0) - base + s) % 26) + base);
+    });
+}
+
+export function binary(value: string): string {
+    checkText(value);
+    return value
+        .split('')
+        .map((c) => c.charCodeAt(0).toString(2).padStart(8, '0'))
+        .join(' ');
+}
+
+export function unbinary(value: string): string {
+    checkText(value);
+    if (!/^[01\s]+$/.test(value)) throw new Error('Invalid binary string');
+    return value
+        .trim()
+        .split(/\s+/)
+        .map((b) => {
+            if (b.length !== 8) throw new Error('Each binary group must contain 8 bits');
+            return String.fromCharCode(parseInt(b, 2));
+        })
+        .join('');
+}

package/src/modules/v4/statistics.ts

@@ -0,0 +1,55 @@
+import { MAX_STRING_LENGTH } from '../../constants.js';
+
+export interface StatisticsResult {
+    count: number;
+    sum: number;
+    min: number;
+    max: number;
+    range: number;
+    mean: number;
+    median: number;
+    mode: number[];
+    variance: number;
+    stddev: number;
+}
+
+export default function statistics(values: string): StatisticsResult {
+    if (!values) throw new Error('A list of values is required');
+    if (typeof values !== 'string') throw new Error('Values must be a comma-separated string');
+
+    const arr = values.split(',').map((v) => Number(v.trim()));
+
+    if (arr.some(isNaN)) throw new Error('Values must contain only numbers');
+    if (arr.length < 1) throw new Error('At least one value is required');
+    if (arr.length > MAX_STRING_LENGTH) throw new Error(`Cannot process more than ${MAX_STRING_LENGTH} values`);
+
+    const count = arr.length;
+    const sum = arr.reduce((a, b) => a + b, 0);
+    const min = Math.min(...arr);
+    const max = Math.max(...arr);
+    const mean = sum / count;
+
+    const sorted = [...arr].sort((a, b) => a - b);
+    const median = count % 2 === 0 ? (sorted[count / 2 - 1]! + sorted[count / 2]!) / 2 : sorted[Math.floor(count / 2)]!;
+
+    const counts = new Map<number, number>();
+    for (const n of arr) counts.set(n, (counts.get(n) ?? 0) + 1);
+    const maxCount = Math.max(...counts.values());
+    const mode = maxCount === 1 ? [] : [...counts.entries()].filter(([, c]) => c === maxCount).map(([n]) => n);
+
+    const variance = arr.reduce((acc, n) => acc + (n - mean) ** 2, 0) / count;
+    const stddev = Math.sqrt(variance);
+
+    return {
+        count,
+        sum: +sum.toFixed(6),
+        min,
+        max,
+        range: max - min,
+        mean: +mean.toFixed(6),
+        median: +median.toFixed(6),
+        mode,
+        variance: +variance.toFixed(6),
+        stddev: +stddev.toFixed(6),
+    };
+}