@20syldev/api 3.5.0 → 4.1.0

package/src/app.ts

@@ -0,0 +1,48 @@
+import express from 'express';
+import { env } from './config/env.js';
+import { setupCors } from './middleware/cors.js';
+import { jsonResponseMiddleware } from './middleware/json.js';
+import { rateLimitMiddleware } from './middleware/ratelimit.js';
+import { loggerMiddleware } from './middleware/logger.js';
+import { errorHandler } from './middleware/error.js';
+import { versionCheckMiddleware, endpointCheckMiddleware } from './middleware/version.js';
+import indexRoutes from './routes/index.js';
+import getRoutes from './routes/get.js';
+import postRoutes from './routes/post.js';
+
+const app = express();
+
+// Setup CORS, body parsing, static files
+setupCors(app);
+
+// Custom JSON response
+app.use(jsonResponseMiddleware);
+
+// Rate limiting
+app.use(rateLimitMiddleware);
+
+// Request logging
+app.use(loggerMiddleware);
+
+// Error handling
+app.use(errorHandler);
+
+// Root routes (before version check)
+app.use(indexRoutes);
+
+// Version & endpoint validation
+app.use('/:version', versionCheckMiddleware);
+app.use('/:version/:endpoint', endpointCheckMiddleware);
+
+// Versioned routes
+app.use(getRoutes);
+app.use(postRoutes);
+
+// Start server
+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/env.ts

@@ -0,0 +1,81 @@
+import dotenv from 'dotenv';
+import { DEFAULT_PORT } from '../constants.js';
+
+dotenv.config();
+
+function envList(key: string): string[] | null {
+    const v = process.env[key];
+    return v && v !== 'undefined' ? v.split(' ') : null;
+}
+
+function envNumber(key: string, fallback: number): number {
+    const v = parseInt(process.env[key] ?? '', 10);
+    return isNaN(v) ? fallback : v;
+}
+
+export const env = {
+    PORT: envNumber('PORT', DEFAULT_PORT),
+    GITHUB_TOKEN: process.env.GITHUB_TOKEN ?? '',
+
+    DEFAULT_LIMIT: envNumber('DEFAULT_LIMIT', 2000),
+    PRO_LIMIT: envNumber('PRO_LIMIT', 6000),
+    ADVANCED_LIMIT: envNumber('ADVANCED_LIMIT', 4000),
+    BUSINESS_LIMIT: envNumber('BUSINESS_LIMIT', 10000),
+    GLOBAL_LIMIT: envNumber('GLOBAL_LIMIT', 50000),
+
+    BUSINESS_TOKEN_LIST: envList('BUSINESS_TOKEN_LIST') ?? [],
+    PRO_TOKEN_LIST: envList('PRO_TOKEN_LIST') ?? [],
+    ADVANCED_TOKEN_LIST: envList('ADVANCED_TOKEN_LIST') ?? [],
+
+    // Website endpoint env vars
+    G_2048: process.env.G_2048,
+    API: process.env.API,
+    CDN: process.env.CDN,
+    COOP_API: process.env.COOP_API,
+    COOP_STATUS: process.env.COOP_STATUS,
+    CHAT: process.env.CHAT,
+    DIGIT: process.env.DIGIT,
+    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,
+    GFT: process.env.GFT,
+    GITSITE: process.env.GITSITE,
+    LEBONCHAR: process.env.LEBONCHAR,
+    LOGGER: process.env.LOGGER,
+    LOGS: process.env.LOGS,
+    LOGVAULT: process.env.LOGVAULT,
+    LYAH: process.env.LYAH,
+    MINIFY: process.env.MINIFY,
+    MN: process.env.MN,
+    MONITORING: process.env.MONITORING,
+    MORPION: process.env.MORPION,
+    NITROGEN: process.env.NITROGEN,
+    OLD_DATABASE: process.env.OLD_DATABASE,
+    PASSWORD: process.env.PASSWORD,
+    PHP: process.env.PHP,
+    PLANNING: process.env.PLANNING,
+    PING: process.env.PING,
+    PORTFOLIO: process.env.PORTFOLIO,
+    PYTHON_API: process.env.PYTHON_API,
+    README: process.env.README,
+    TIMESTAMP: process.env.TIMESTAMP,
+    TERMINAL: process.env.TERMINAL,
+    VALENTINE: process.env.VALENTINE,
+    WRKIT: process.env.WRKIT,
+    ZPKI: process.env.ZPKI,
+
+    PATCH: envList('PATCH'),
+    RECENT: envList('RECENT'),
+    NEW: envList('NEW'),
+    DOMAINS: envList('DOMAINS'),
+
+    STATS1: process.env.STATS1,
+    STATS2: process.env.STATS2,
+    STATS3: process.env.STATS3,
+    STATS4: process.env.STATS4,
+    TAG: process.env.TAG,
+    ACTIVE: process.env.ACTIVE === 'true',
+};

package/src/config/versions.ts

@@ -0,0 +1,92 @@
+import * as apiv3 from '../modules/v3.js';
+import * as apiv4 from '../modules/v4.js';
+
+export interface Endpoint {
+    name: string;
+    path?: string;
+    children?: Record<string, string>;
+}
+
+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})' },
+        { name: 'captcha', path: '/captcha?text={text}' },
+        { name: 'color', path: '/color' },
+        { name: 'convert', path: '/convert?value={value}&from={unit}&to={unit}' },
+        { name: 'domain', path: '/domain' },
+        { name: 'infos', path: '/infos' },
+        { name: 'personal', path: '/personal' },
+        { name: 'qrcode', path: '/qrcode?url={URL}' },
+        { name: 'username', path: '/username' },
+        { name: 'website', path: '/website' },
+    ],
+    post: [{ name: 'token', path: '/token' }],
+};
+
+const v2 = {
+    get: merge(v1.get, [{ name: 'chat', path: '/chat' }]),
+    post: merge(v1.post, [
+        {
+            name: 'chat',
+            children: {
+                chat: '/chat',
+                private: '/chat/private',
+            } as Record<string, string>,
+        },
+        { name: 'hash', path: '/hash' },
+        {
+            name: 'tic_tac_toe',
+            children: {
+                tic_tac_toe: '/tic-tac-toe',
+                fetch: '/tic-tac-toe/fetch',
+                list: '/tic-tac-toe/list',
+            } as Record<string, string>,
+        },
+    ]),
+};
+
+const v3 = {
+    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: merge(v2.post, [{ name: 'hyperplanning', path: '/hyperplanning' }]),
+};
+
+const v4 = {
+    get: merge(v3.get, [
+        { name: 'dice', path: '/dice?roll={NdX+M}' },
+        { name: 'statistics', path: '/statistics?values={n1,n2,n3,...}' },
+    ]),
+    post: [...v3.post],
+};
+
+export const versions: Record<string, VersionConfig> = {
+    v1: { endpoints: v1, modules: apiv3 },
+    v2: { endpoints: v2, modules: apiv3 },
+    v3: { endpoints: v3, modules: apiv3 },
+    v4: { endpoints: v4, modules: apiv4 },
+};

package/src/constants.ts

@@ -0,0 +1,47 @@
+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;
+export const SESSION_TTL = 3_600_000;
+export const GAME_CLEANUP_TTL = 600_000;
+export const GITHUB_CACHE_TTL = 600_000;
+export const MIN_TOKEN_LENGTH = 12;
+export const MAX_TOKEN_LENGTH = 4096;
+export const MAX_FACTORIAL = 170;
+export const MAX_GCD_VALUE = 100_000;
+export const MAX_PRIME_LIST = 10_000;
+export const MAX_LEVENSHTEIN_LENGTH = 1000;
+export const MAX_STRING_LENGTH = 1000;
+export const MIN_TEMPERATURE = -273.15;
+export const MAX_TEMPERATURE = 1_000_000;
+export const DOCS_URL = 'https://docs.sylvain.sh';
+export const DEFAULT_PORT = 3000;
+
+export const STATUS_MESSAGES: Record<number, string> = {
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    429: 'Too Many Requests',
+    500: 'Internal Server Error',
+};
+
+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/middleware/cors.ts

@@ -0,0 +1,17 @@
+import cors from 'cors';
+import express, { type Express } from 'express';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export function setupCors(app: Express): void {
+    app.set('trust proxy', 1);
+    app.use(cors({ methods: ['GET', 'POST', 'PATCH', 'DELETE', 'OPTIONS'] }));
+    app.use(express.urlencoded({ extended: true }));
+    app.use(express.json());
+
+    app.use('/favicon.ico', express.static(join(__dirname, '..', '..', 'src', 'favicon.ico')));
+    app.use('/robots.txt', express.static(join(__dirname, '..', '..', 'robots.txt')));
+}

package/src/middleware/error.ts

@@ -0,0 +1,7 @@
+import type { Request, Response, NextFunction } from 'express';
+import { error } from '../utils/response.js';
+
+export function errorHandler(err: Error, _req: Request, res: Response, _next: NextFunction): void {
+    console.error(err.stack);
+    error(res, 500, err.message);
+}

package/src/middleware/json.ts

@@ -0,0 +1,9 @@
+import type { Request, Response, NextFunction } from 'express';
+
+export function jsonResponseMiddleware(_req: Request, res: Response, next: NextFunction): void {
+    res.setHeader('Content-Type', 'application/json');
+    res.jsonResponse = (data: unknown) => {
+        res.send(JSON.stringify(data, null, 2));
+    };
+    next();
+}

package/src/middleware/logger.ts

@@ -0,0 +1,31 @@
+import { createLogger } from '@20syldev/logger.ts';
+import type { Request, Response, NextFunction } from 'express';
+import { MAX_LOG_ENTRIES } from '../constants.js';
+
+export const logger = createLogger({
+    maxEntries: MAX_LOG_ENTRIES,
+    console: true,
+    theme: 'colored',
+});
+
+export function loggerMiddleware(req: Request, res: Response, next: NextFunction): void {
+    if (req.method === 'HEAD') {
+        next();
+        return;
+    }
+    if (req.originalUrl === '/logs') {
+        next();
+        return;
+    }
+
+    const startTime = Date.now();
+    const platform = (req.headers['sec-ch-ua-platform'] as string)?.replace(/"/g, '');
+
+    res.on('finish', () => {
+        const status = res.statusCode === 304 ? 200 : res.statusCode;
+        const duration = `${Date.now() - startTime}ms`;
+
+        logger.log({ method: req.method, url: req.originalUrl, status, duration, platform });
+    });
+    next();
+}

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)),
     };
-}
+}