@20syldev/api 3.5.0 → 4.0.0

package/src/routes/index.ts

@@ -0,0 +1,58 @@
+import { Router, type Request, type Response } from 'express';
+import { versions } from '../config/versions.js';
+import { ipLimits } from '../storage/index.js';
+import { logger } from '../middleware/logger.js';
+import { DOCS_URL, START_TIME } from '../constants.js';
+
+const router = Router();
+
+router.get('/', (req: Request, res: Response) => {
+    const base = `${req.protocol}://${req.get('host')}`;
+    const links = Object.keys(versions).reduce<Record<string, string>>((link, version) => {
+        link[version] = `${base}/${version}`;
+        return link;
+    }, {});
+
+    res.jsonResponse({
+        documentation: DOCS_URL,
+        latest: `${base}/latest`,
+        health: `${base}/health`,
+        logs: `${base}/logs`,
+        versions: links,
+    });
+});
+
+router.get('/health', (_req: Request, res: Response) => {
+    const mem = process.memoryUsage();
+
+    res.jsonResponse({
+        status: 'ok',
+        uptime: Math.floor((Date.now() - START_TIME) / 1000),
+        version: '4.0.0',
+        node: process.version,
+        memory: {
+            rss: `${(mem.rss / 1024 / 1024).toFixed(1)} MB`,
+            heap_used: `${(mem.heapUsed / 1024 / 1024).toFixed(1)} MB`,
+            heap_total: `${(mem.heapTotal / 1024 / 1024).toFixed(1)} MB`,
+        },
+        connections: Object.keys(ipLimits).length,
+        logs: logger.entries().length,
+    });
+});
+
+router.get('/logs', (_req: Request, res: Response) => {
+    res.jsonResponse(logger.entries());
+});
+
+router.get('/latest', (_req: Request, res: Response) => {
+    const latest = Object.keys(versions).pop()!;
+    res.redirect(`/${latest}`);
+});
+
+router.get('/latest/{*rest}', (req: Request, res: Response) => {
+    const latest = Object.keys(versions).pop()!;
+    const rest = (req.params as Record<string, string>).rest;
+    res.redirect(`/${latest}/${rest}`);
+});
+
+export default router;

package/src/routes/post.ts

@@ -0,0 +1,200 @@
+import { Router, type Request, type Response } from 'express';
+import { chatStorage, ticTacToeStorage } from '../storage/index.js';
+import { MIN_TOKEN_LENGTH, MAX_TOKEN_LENGTH } from '../constants.js';
+import { error } from '../utils/response.js';
+
+const router = Router();
+
+// Store chat messages
+router.post('/:version/chat', (req: Request, res: Response) => {
+    const { username, message, timestamp, session, token } = (req.body as Record<string, string>) || {};
+
+    if (!username) {
+        error(res, 400, 'Please provide a username (?username={username})');
+        return;
+    }
+    if (!message) {
+        error(res, 400, 'Please provide a message (&message={message})');
+        return;
+    }
+    if (!session) {
+        error(res, 400, 'Please provide a valid session ID (&session={ID})');
+        return;
+    }
+
+    try {
+        const result = req.module.chat('message', {
+            username,
+            message,
+            timestamp,
+            session,
+            token,
+            storage: chatStorage,
+        });
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message);
+    }
+});
+
+// Display a private chat with a token
+router.post('/:version/chat/private', (req: Request, res: Response) => {
+    const { username, token } = (req.body as Record<string, string>) || {};
+
+    if (!username) {
+        error(res, 400, 'Please provide a username (?username={username})');
+        return;
+    }
+    if (!token) {
+        error(res, 400, 'Please provide a valid token (&token={key}).');
+        return;
+    }
+
+    try {
+        const messages = req.module.chat('private', {
+            username,
+            token,
+            storage: chatStorage,
+        });
+        res.jsonResponse(messages);
+    } catch (err) {
+        error(res, 400, (err as Error).message);
+    }
+});
+
+// Generate hash
+router.post('/:version/hash', (req: Request, res: Response) => {
+    const { text, method } = (req.body as Record<string, string>) || {};
+
+    if (!text) {
+        error(res, 400, 'Please provide a text (?text={text})', `${req.version}/hash`);
+        return;
+    }
+    if (!method) {
+        error(res, 400, 'Please provide a valid hash algorithm (&method={algorithm})', `${req.version}/hash`);
+        return;
+    }
+
+    try {
+        const result = req.module.hash(text, method);
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/hash`);
+    }
+});
+
+// Display a planning from an ICS file
+router.post('/:version/hyperplanning', async (req: Request, res: Response) => {
+    const { url, detail } = (req.body as Record<string, string>) || {};
+
+    if (!url) {
+        error(res, 400, 'Please provide a valid ICS file URL (?url={URL})', `${req.version}/hyperplanning`);
+        return;
+    }
+
+    try {
+        const hyperplanning = await req.module.hyperplanning(url, detail);
+        res.jsonResponse(hyperplanning);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/hyperplanning`);
+    }
+});
+
+// Store tic tac toe games
+router.post('/:version/tic-tac-toe', (req: Request, res: Response) => {
+    const { username, move, session, game } = (req.body as Record<string, string>) || {};
+
+    if (!username) {
+        error(res, 400, 'Please provide a username (?username={username})');
+        return;
+    }
+    if (!move) {
+        error(res, 400, 'Please provide a valid move (&move={move})');
+        return;
+    }
+    if (!session) {
+        error(res, 400, 'Please provide a valid session ID (&session={ID})');
+        return;
+    }
+    if (!game) {
+        error(res, 400, 'Please provide a valid game ID (&game={ID})');
+        return;
+    }
+
+    try {
+        const result = req.module.tic_tac_toe('play', {
+            username,
+            move,
+            session,
+            game,
+            storage: ticTacToeStorage,
+        });
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message);
+    }
+});
+
+// Display a tic tac toe game with a token
+router.post('/:version/tic-tac-toe/fetch', (req: Request, res: Response) => {
+    const { username, game } = (req.body as Record<string, string>) || {};
+    const privateGame = ((req.body as Record<string, unknown>) || {}).private as boolean | undefined;
+
+    if (!username) {
+        error(res, 400, 'Please provide a username (?username={username})');
+        return;
+    }
+
+    try {
+        const result = req.module.tic_tac_toe('fetch', {
+            username,
+            game,
+            private: privateGame,
+            storage: ticTacToeStorage,
+        });
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message);
+    }
+});
+
+// List public tic tac toe games
+router.post('/:version/tic-tac-toe/list', (req: Request, res: Response) => {
+    try {
+        const result = req.module.tic_tac_toe('list', {
+            storage: ticTacToeStorage,
+        });
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message);
+    }
+});
+
+// Generate Token
+router.post('/:version/token', (req: Request, res: Response) => {
+    const body = (req.body as Record<string, unknown>) || {};
+    const len = parseInt(String(body.len || 24), 10);
+    const type = body.type ? String(body.type).toLowerCase() : 'alpha';
+
+    if (isNaN(len) || len < 0) {
+        error(res, 400, 'Invalid number.', `${req.version}/token`);
+        return;
+    }
+    if (len > MAX_TOKEN_LENGTH) {
+        error(res, 400, 'Length cannot exceed 4096.', `${req.version}/token`);
+        return;
+    }
+    if (len < MIN_TOKEN_LENGTH) {
+        error(res, 400, 'Length cannot be less than 12.', `${req.version}/token`);
+        return;
+    }
+
+    try {
+        const token = req.module.token(len, type);
+        res.jsonResponse({ token });
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/token`);
+    }
+});
+
+export default router;

package/src/storage/index.ts

@@ -0,0 +1,16 @@
+import type { ChatStorage, TicTacToeStorage, IpLimits } from '../types/storage.js';
+
+export const ipLimits: IpLimits = {};
+
+export const chatStorage: ChatStorage = {
+    messages: [],
+    privateChats: {},
+    sessions: {},
+    rateLimits: {},
+};
+
+export const ticTacToeStorage: TicTacToeStorage = {
+    games: {},
+    sessions: {},
+    rateLimits: {},
+};

package/src/types/express.d.ts

@@ -0,0 +1,17 @@
+import type * as apiv3 from '../modules/v3.js';
+import type * as apiv4 from '../modules/v4.js';
+
+declare global {
+    namespace Express {
+        interface Request {
+            version: string;
+            latest: string;
+            endpoint: string;
+            module: typeof apiv3 | typeof apiv4;
+        }
+
+        interface Response {
+            jsonResponse: (data: unknown) => void;
+        }
+    }
+}

package/src/types/storage.ts

@@ -0,0 +1,48 @@
+export interface LogEntry {
+    timestamp: string;
+    method: string;
+    url: string;
+    status: number;
+    duration: string;
+    platform: string | undefined;
+}
+
+export interface ChatMessage {
+    username: string;
+    message: string;
+    timestamp: string;
+}
+
+export interface ChatStorage {
+    messages: ChatMessage[];
+    privateChats: Record<string, ChatMessage[]>;
+    sessions: Record<string, { user: string; last: number }>;
+    rateLimits: Record<string, number[]>;
+}
+
+export interface TicTacToeMove {
+    username: string;
+    move: string;
+    session: string;
+}
+
+export interface TicTacToeGame {
+    moves: TicTacToeMove[];
+    players: string[];
+    private: boolean;
+    creation: number;
+}
+
+export interface TicTacToeStorage {
+    games: Record<string, TicTacToeGame>;
+    sessions: Record<string, { user: string; last: number }>;
+    rateLimits: Record<string, number[]>;
+}
+
+export interface IpLimits {
+    [ip: string]: {
+        [hour: string]: {
+            [minute: string]: number;
+        };
+    };
+}

package/src/utils/response.ts

@@ -0,0 +1,11 @@
+import type { Response } from 'express';
+import { DOCS_URL, STATUS_MESSAGES } from '../constants.js';
+
+export function error(res: Response, status: number, message: string, docPath?: string): void {
+    res.status(status).jsonResponse({
+        message: STATUS_MESSAGES[status] ?? 'Error',
+        error: message,
+        documentation: docPath ? `${DOCS_URL}/${docPath}` : DOCS_URL,
+        status: String(status),
+    });
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "allowJs": true,
+        "strict": true,
+        "noUncheckedIndexedAccess": true,
+        "outDir": "dist",
+        "rootDir": "src",
+        "declaration": false,
+        "sourceMap": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true
+    },
+    "include": ["src"]
+}