@20syldev/api 4.1.0 → 4.3.0

package/src/routes/get.ts

@@ -173,6 +173,52 @@ router.get('/:version/dice', (req: Request, res: Response) => {
     }
 });
 
+// Encode / decode text
+router.get('/:version/encode', (req: Request, res: Response) => {
+    const { method, text, shift } = req.query;
+    const { version } = req.params;
+
+    const encode = (req.module as { encode?: Record<string, (v: string, v2?: string) => string> }).encode;
+    if (!encode) {
+        error(res, 404, `Endpoint not available in ${version}.`, `${version}/encode`);
+        return;
+    }
+    if (!method || !encode[method as string]) {
+        error(res, 400, 'Please provide a valid method (?method={method})', `${version}/encode`);
+        return;
+    }
+
+    try {
+        const result = encode[method as string]!(text as string, shift as string);
+        res.jsonResponse({ method, result });
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/encode`);
+    }
+});
+
+// Geographic distance and bearing between two coordinates
+router.get('/:version/geo', (req: Request, res: Response) => {
+    const { lat1, lon1, lat2, lon2 } = req.query;
+    const { version } = req.params;
+
+    const geo = (req.module as { geo?: (a: string, b: string, c: string, d: string) => unknown }).geo;
+    if (!geo) {
+        error(res, 404, `Endpoint not available in ${version}.`, `${version}/geo`);
+        return;
+    }
+    if (lat1 === undefined || lon1 === undefined || lat2 === undefined || lon2 === undefined) {
+        error(res, 400, 'Please provide lat1, lon1, lat2 and lon2', `${version}/geo`);
+        return;
+    }
+
+    try {
+        const result = geo(lat1 as string, lon1 as string, lat2 as string, lon2 as string);
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/geo`);
+    }
+});
+
 // GET planning error
 router.get('/:version/hyperplanning', (_req: Request, res: Response) => {
     error(res, 405, 'This endpoint only supports POST requests.');
@@ -219,6 +265,33 @@ router.get('/:version/levenshtein', (req: Request, res: Response) => {
     }
 });
 
+// Generate a color palette from a base color
+router.get('/:version/palette', (req: Request, res: Response) => {
+    const { color, type } = req.query;
+    const { version } = req.params;
+
+    const palette = (req.module as { palette?: (c: string, t: string) => unknown }).palette;
+    if (!palette) {
+        error(res, 404, `Endpoint not available in ${version}.`, `${version}/palette`);
+        return;
+    }
+    if (!color) {
+        error(res, 400, 'Please provide a base color (?color=#ff6600)', `${version}/palette`);
+        return;
+    }
+    if (!type) {
+        error(res, 400, 'Please provide a palette type (&type=complementary)', `${version}/palette`);
+        return;
+    }
+
+    try {
+        const result = palette(color as string, type as string);
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/palette`);
+    }
+});
+
 // Generate personal data
 router.get('/:version/personal', (req: Request, res: Response) => {
     try {
@@ -229,6 +302,32 @@ router.get('/:version/personal', (req: Request, res: Response) => {
     }
 });
 
+// Generate a placeholder image or skeleton
+router.get('/:version/placeholder', (req: Request, res: Response) => {
+    const { type = 'image' } = req.query;
+    const { version } = req.params;
+
+    const placeholder = (
+        req.module as {
+            placeholder?: (
+                t: string,
+                q: Record<string, string | undefined>,
+            ) => { type: string; contentType: string; body: Buffer | string };
+        }
+    ).placeholder;
+    if (!placeholder) {
+        error(res, 404, `Endpoint not available in ${version}.`, `${version}/placeholder`);
+        return;
+    }
+
+    try {
+        const result = placeholder(type as string, req.query as Record<string, string | undefined>);
+        res.type(result.contentType).send(result.body);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/placeholder`);
+    }
+});
+
 // Generate QR Code
 router.get('/:version/qrcode', async (req: Request, res: Response) => {
     const { url } = req.query;
@@ -269,6 +368,70 @@ router.get('/:version/statistics', (req: Request, res: Response) => {
     }
 });
 
+// Text utilities (slug, stats, lorem, number)
+router.get('/:version/text', (req: Request, res: Response) => {
+    const { method, value, type, count, lang, text } = req.query;
+    const { version } = req.params;
+
+    const textMod = (req.module as { text?: Record<string, (...args: string[]) => unknown> }).text;
+    if (!textMod) {
+        error(res, 404, `Endpoint not available in ${version}.`, `${version}/text`);
+        return;
+    }
+    if (!method || !textMod[method as string]) {
+        error(res, 400, 'Please provide a valid method (?method={slug|stats|lorem|number})', `${version}/text`);
+        return;
+    }
+
+    try {
+        let result: unknown;
+        switch (method) {
+            case 'slug':
+            case 'stats':
+                result = textMod[method as string]!((value ?? text) as string);
+                break;
+            case 'lorem':
+                result = textMod.lorem!((type as string) || 'words', (count as string) || '5');
+                break;
+            case 'number':
+                result = textMod.number!(value as string, (lang as string) || 'en');
+                break;
+            default:
+                throw new Error('Unknown method');
+        }
+        res.jsonResponse({ method, result });
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/text`);
+    }
+});
+
+// Validate data (luhn, iban, email)
+router.get('/:version/validate', (req: Request, res: Response) => {
+    const { type, value } = req.query;
+    const { version } = req.params;
+
+    const validate = (req.module as { validate?: Record<string, (v: string) => unknown> }).validate;
+    if (!validate) {
+        error(res, 404, `Endpoint not available in ${version}.`, `${version}/validate`);
+        return;
+    }
+    if (!type || !validate[type as string]) {
+        error(res, 400, 'Please provide a valid type (?type={luhn|iban|email})', `${version}/validate`);
+        return;
+    }
+    if (!value) {
+        error(res, 400, 'Please provide a value (&value={value})', `${version}/validate`);
+        return;
+    }
+
+    try {
+        const result = validate[type as string]!(value as string);
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/validate`);
+    }
+});
+
 // GET tic-tac-toe errors
 router.get('/:version/tic-tac-toe', (_req: Request, res: Response) => {
     error(res, 405, 'This endpoint only supports POST requests.');

package/src/routes/patch.ts

@@ -1,13 +1,12 @@
 import { Router, type Request, type Response } from 'express';
 import { ticTacToeStorage } from '../storage/index.js';
 import { error } from '../utils/response.js';
-import { supportsRest } from '../utils/version.js';
 
 const router = Router();
 
-// Play a tic-tac-toe move (REST: PATCH /tic-tac-toe/:game)
+// Play a tic-tac-toe move
 router.patch('/:version/tic-tac-toe/:game', (req: Request, res: Response) => {
-    if (!supportsRest(req)) {
+    if (req.version !== 'v4') {
         error(res, 405, 'PATCH is only supported in v4+.', `${req.version}/tic-tac-toe`);
         return;
     }

package/tests/integration/api.test.ts

@@ -51,7 +51,13 @@ describe('GET / (version listing)', () => {
         assert.equal(body.version, 'v4');
         const endpoints = body.endpoints as Record<string, Record<string, string>>;
         assert.ok('dice' in endpoints.get!);
+        assert.ok('encode' in endpoints.get!);
+        assert.ok('geo' in endpoints.get!);
+        assert.ok('palette' in endpoints.get!);
+        assert.ok('placeholder' in endpoints.get!);
         assert.ok('statistics' in endpoints.get!);
+        assert.ok('text' in endpoints.get!);
+        assert.ok('validate' in endpoints.get!);
     });
 
     test('invalid version returns 404', async () => {
@@ -156,6 +162,37 @@ describe('GET /v4/domain', () => {
     });
 });
 
+describe('GET /v4/encode', () => {
+    test('base64 encode', async () => {
+        const { status, body } = await getJson('/v4/encode?method=base64encode&text=hello');
+        assert.equal(status, 200);
+        assert.equal(body.result, 'aGVsbG8=');
+    });
+
+    test('rot13', async () => {
+        const { body } = await getJson('/v4/encode?method=rot13&text=Hello');
+        assert.equal(body.result, 'Uryyb');
+    });
+
+    test('missing method returns 400', async () => {
+        const { status } = await getJson('/v4/encode?text=hello');
+        assert.equal(status, 400);
+    });
+});
+
+describe('GET /v4/geo', () => {
+    test('Paris-NYC distance', async () => {
+        const { body } = await getJson('/v4/geo?lat1=48.8566&lon1=2.3522&lat2=40.7128&lon2=-74.006');
+        const distance = body.distance as { km: number };
+        assert.ok(Math.abs(distance.km - 5837) < 50);
+    });
+
+    test('missing param returns 400', async () => {
+        const { status } = await getJson('/v4/geo?lat1=0&lon1=0');
+        assert.equal(status, 400);
+    });
+});
+
 describe('GET /v4/infos', () => {
     test('returns API infos', async () => {
         const { status, body } = await getJson('/v4/infos');
@@ -173,6 +210,18 @@ describe('GET /v4/levenshtein', () => {
     });
 });
 
+describe('GET /v4/palette', () => {
+    test('triadic returns 3 colors', async () => {
+        const { body } = await getJson('/v4/palette?color=%23ff6600&type=triadic');
+        assert.equal((body.colors as unknown[]).length, 3);
+    });
+
+    test('invalid type returns 400', async () => {
+        const { status } = await getJson('/v4/palette?color=%23ff6600&type=rainbow');
+        assert.equal(status, 400);
+    });
+});
+
 describe('GET /v4/personal', () => {
     test('returns generated identity', async () => {
         const { status, body } = await getJson('/v4/personal');
@@ -183,6 +232,22 @@ describe('GET /v4/personal', () => {
     });
 });
 
+describe('GET /v4/placeholder', () => {
+    test('image returns SVG', async () => {
+        const res = await fetch(`${baseUrl}/v4/placeholder?type=image&width=100&height=50`);
+        assert.equal(res.status, 200);
+        assert.match(res.headers.get('content-type') ?? '', /image\/svg\+xml/);
+    });
+
+    test('skeleton returns SVG', async () => {
+        const res = await fetch(`${baseUrl}/v4/placeholder?type=skeleton&width=200&height=100`);
+        assert.equal(res.status, 200);
+        assert.match(res.headers.get('content-type') ?? '', /image\/svg\+xml/);
+        const body = await res.text();
+        assert.match(body, /<svg/);
+    });
+});
+
 describe('GET /v4/qrcode', () => {
     test('returns data URL', async () => {
         const { status, body } = await getJson('/v4/qrcode?url=https%3A%2F%2Fexample.com');
@@ -205,6 +270,23 @@ describe('GET /v4/statistics', () => {
     });
 });
 
+describe('GET /v4/text', () => {
+    test('slug', async () => {
+        const { body } = await getJson('/v4/text?method=slug&value=Hello%20World');
+        assert.equal(body.result, 'hello-world');
+    });
+
+    test('number en', async () => {
+        const { body } = await getJson('/v4/text?method=number&value=42&lang=en');
+        assert.equal(body.result, 'forty-two');
+    });
+
+    test('lorem words', async () => {
+        const { body } = await getJson('/v4/text?method=lorem&type=words&count=5');
+        assert.equal((body.result as string).split(' ').length, 5);
+    });
+});
+
 describe('GET /v4/time', () => {
     test('live', async () => {
         const { status, body } = await getJson('/v4/time');
@@ -232,6 +314,23 @@ describe('GET /v4/username', () => {
     });
 });
 
+describe('GET /v4/validate', () => {
+    test('valid luhn', async () => {
+        const { body } = await getJson('/v4/validate?type=luhn&value=4111111111111111');
+        assert.equal(body.valid, true);
+    });
+
+    test('valid email', async () => {
+        const { body } = await getJson('/v4/validate?type=email&value=hello%40example.com');
+        assert.equal(body.valid, true);
+    });
+
+    test('invalid type returns 400', async () => {
+        const { status } = await getJson('/v4/validate?type=foo&value=bar');
+        assert.equal(status, 400);
+    });
+});
+
 describe('GET /v4/website', () => {
     const originalFetch = globalThis.fetch;
 
@@ -272,10 +371,10 @@ describe('GET /v4/website', () => {
         assert.ok('stats' in body);
     });
 
-    test('?key=stats.5 returns sub-key', async () => {
-        const { status, body } = await getJson('/v4/website?key=stats.5');
+    test('?key=active returns sub-key', async () => {
+        const { status, body } = await getJson('/v4/website?key=active');
         assert.equal(status, 200);
-        assert.ok('stats.5' in body);
+        assert.ok('active' in body);
     });
 
     test('?key=invalid.path returns 404', async () => {

package/tests/unit/captcha.test.ts

@@ -0,0 +1,23 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import captcha from '../../src/modules/v4/captcha.js';
+
+describe('captcha', () => {
+    test('returns a Buffer for valid text', () => {
+        const result = captcha('hello');
+        assert.ok(Buffer.isBuffer(result));
+        assert.ok(result.length > 0);
+    });
+
+    test('PNG starts with correct magic bytes', () => {
+        const result = captcha('test');
+        assert.equal(result[0], 0x89);
+        assert.equal(result[1], 0x50); // P
+        assert.equal(result[2], 0x4e); // N
+        assert.equal(result[3], 0x47); // G
+    });
+
+    test('throws on missing text', () => {
+        assert.throws(() => captcha(''));
+    });
+});

package/tests/unit/chat.test.ts

@@ -0,0 +1,50 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import chat from '../../src/modules/v4/chat.js';
+import type { ChatStorage } from '../../src/types/storage.js';
+
+function makeStorage(): ChatStorage {
+    return { messages: [], privateChats: {}, sessions: {}, rateLimits: {} };
+}
+
+describe('chat', () => {
+    test('sends a public message', () => {
+        const storage = makeStorage();
+        const result = chat('message', { username: 'alice', message: 'hello', session: 'a1', storage });
+        assert.ok((result as { message: string }).message.includes('sent'));
+    });
+
+    test('fetches public messages', () => {
+        const storage = makeStorage();
+        chat('message', { username: 'alice', message: 'test', session: 'a1', storage });
+        const result = chat('fetch', { username: 'bob', storage });
+        assert.ok(Array.isArray(result));
+        assert.equal((result as { message: string }[])[0]!.message, 'test');
+    });
+
+    test('sends and retrieves private messages', () => {
+        const storage = makeStorage();
+        chat('message', { username: 'alice', message: 'secret', session: 'a1', token: 'tok1', storage });
+        const result = chat('private', { username: 'bob', token: 'tok1', storage });
+        assert.ok(Array.isArray(result));
+    });
+
+    test('clears a private chat', () => {
+        const storage = makeStorage();
+        chat('message', { username: 'alice', message: 'secret', session: 'a1', token: 'tok2', storage });
+        const result = chat('clear', { username: 'alice', session: 'a1', token: 'tok2', storage });
+        assert.ok((result as { message: string }).message.includes('cleared'));
+    });
+
+    test('throws on missing username', () => {
+        assert.throws(() => chat('message', { username: '', message: 'hi', session: 's', storage: makeStorage() }), /username/);
+    });
+
+    test('throws on invalid action', () => {
+        assert.throws(() => chat('delete', { username: 'alice', storage: makeStorage() }), /Invalid action/);
+    });
+
+    test('throws on fetch with no messages', () => {
+        assert.throws(() => chat('fetch', { username: 'alice', storage: makeStorage() }), /No messages/);
+    });
+});

package/tests/unit/placeholder.test.ts

@@ -0,0 +1,57 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import placeholder from '../../src/modules/v4/placeholder.js';
+
+describe('placeholder', () => {
+    test('image returns SVG with text', () => {
+        const result = placeholder('image', { width: '200', height: '100', text: 'Hello' });
+        assert.equal(result.type, 'image');
+        assert.equal(result.contentType, 'image/svg+xml');
+        assert.match(result.body, /<svg/);
+        assert.match(result.body, /Hello/);
+    });
+
+    test('skeleton returns SVG with animation', () => {
+        const result = placeholder('skeleton', { width: '300', height: '200' });
+        assert.equal(result.type, 'skeleton');
+        assert.equal(result.contentType, 'image/svg+xml');
+        assert.match(result.body, /<svg/);
+    });
+
+    test('default dimensions 800x600', () => {
+        const result = placeholder('image', {});
+        assert.match(result.body, /width="800"/);
+        assert.match(result.body, /height="600"/);
+    });
+
+    test('skeleton with avatar', () => {
+        const result = placeholder('skeleton', { avatar: 'circle' });
+        assert.match(result.body, /<circle/);
+    });
+
+    test('skeleton with rows', () => {
+        const result = placeholder('skeleton', { rows: '5' });
+        assert.match(result.body, /<rect/);
+    });
+
+    test('animate none removes animation', () => {
+        const result = placeholder('skeleton', { animate: 'none' });
+        assert.ok(!result.body.includes('<animate'));
+    });
+
+    test('throws on invalid type', () => {
+        assert.throws(() => placeholder('video', {}), /Type must be one of/);
+    });
+
+    test('throws on invalid width', () => {
+        assert.throws(() => placeholder('image', { width: '5000' }), /width/);
+    });
+
+    test('throws on invalid avatar shape', () => {
+        assert.throws(() => placeholder('skeleton', { avatar: 'hexagon' }), /avatar/);
+    });
+
+    test('throws on invalid speed', () => {
+        assert.throws(() => placeholder('skeleton', { speed: '99' }), /speed/);
+    });
+});

package/tests/unit/qrcode.test.ts

@@ -0,0 +1,14 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import qrcode from '../../src/modules/v4/qrcode.js';
+
+describe('qrcode', () => {
+    test('returns data URL for valid url', async () => {
+        const result = await qrcode('https://example.com');
+        assert.match(result, /^data:image\/png;base64,/);
+    });
+
+    test('throws on missing url', async () => {
+        await assert.rejects(() => qrcode(''));
+    });
+});

package/tests/unit/tic_tac_toe.test.ts

@@ -0,0 +1,52 @@
+import { test, describe } from 'node:test';
+import { strict as assert } from 'node:assert';
+import tic_tac_toe from '../../src/modules/v4/tic_tac_toe.js';
+import type { TicTacToeStorage } from '../../src/types/storage.js';
+
+function makeStorage(): TicTacToeStorage {
+    return { games: {}, sessions: {}, rateLimits: {} };
+}
+
+describe('tic_tac_toe', () => {
+    test('list returns empty games array', () => {
+        const result = tic_tac_toe('list', { storage: makeStorage() });
+        assert.ok(Array.isArray(result.games));
+    });
+
+    test('play creates a game and makes a move', () => {
+        const storage = makeStorage();
+        const result = tic_tac_toe('play', { username: 'alice', move: '1-1', session: 'a1', game: 'TEST1', storage });
+        assert.ok((result.message as string).includes('Move sent'));
+    });
+
+    test('fetch returns game state', () => {
+        const storage = makeStorage();
+        tic_tac_toe('play', { username: 'alice', move: '1-1', session: 'a1', game: 'TEST2', storage });
+        const result = tic_tac_toe('fetch', { username: 'alice', game: 'TEST2', storage });
+        assert.equal(result.id, 'TEST2');
+    });
+
+    test('forfeit throws on non-player', () => {
+        const storage = makeStorage();
+        tic_tac_toe('play', { username: 'alice', move: '1-1', session: 'a1', game: 'TEST3', storage });
+        assert.throws(
+            () => tic_tac_toe('forfeit', { username: 'charlie', session: 'c1', game: 'TEST3', storage }),
+            /not a player/,
+        );
+    });
+
+    test('throws on missing username', () => {
+        assert.throws(() => tic_tac_toe('play', { move: '1-1', session: 's', game: 'G', storage: makeStorage() }), /username/);
+    });
+
+    test('throws on missing move', () => {
+        assert.throws(
+            () => tic_tac_toe('play', { username: 'alice', session: 's', game: 'G', storage: makeStorage() }),
+            /move/i,
+        );
+    });
+
+    test('throws on invalid action', () => {
+        assert.throws(() => tic_tac_toe('reset', { username: 'alice', storage: makeStorage() }), /Invalid action/);
+    });
+});