@20syldev/api 3.5.0 → 4.0.0

package/src/modules/v4/token.ts

@@ -0,0 +1,43 @@
+import { randomBytes } from 'crypto';
+import { v4 } from 'uuid';
+import { MIN_TOKEN_LENGTH, MAX_TOKEN_LENGTH } from '../../constants.js';
+
+export default function token(len: number, type: string = 'alphanum'): string {
+    if (isNaN(len) || len < MIN_TOKEN_LENGTH) {
+        throw new Error('Length must be a number greater than or equal to 12');
+    }
+
+    if (len > MAX_TOKEN_LENGTH) {
+        throw new Error('Length cannot exceed 4096');
+    }
+
+    const genToken = (chars: string, length: number): string => {
+        return Array.from({ length }, () => {
+            return chars[Math.floor(Math.random() * chars.length)];
+        }).join('');
+    };
+
+    const tokenTypes: Record<string, () => string> = {
+        alpha: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', len),
+        alphanum: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', len),
+        base64: () =>
+            randomBytes(Math.ceil(len * 0.75))
+                .toString('base64')
+                .slice(0, len),
+        hex: () =>
+            randomBytes(Math.ceil(len * 0.5))
+                .toString('hex')
+                .slice(0, len),
+        num: () => genToken('0123456789', len),
+        punct: () => genToken('!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~', len),
+        urlsafe: () => genToken('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_', len),
+        uuid: () => v4().replace(/-/g, '').slice(0, len),
+    };
+
+    const lowerType = type.toLowerCase();
+    if (!tokenTypes[lowerType]) {
+        throw new Error(`Invalid token type. Valid types: ${Object.keys(tokenTypes).join(', ')}`);
+    }
+
+    return tokenTypes[lowerType]!();
+}

package/src/modules/v4/username.ts

@@ -0,0 +1,89 @@
+import { random, randomNumber } from './utils.js';
+
+export default function username(): Record<string, unknown> {
+    const adj = [
+        'Happy',
+        'Silly',
+        'Clever',
+        'Creative',
+        'Brave',
+        'Gentle',
+        'Kind',
+        'Funny',
+        'Wise',
+        'Charming',
+        'Sincere',
+        'Resourceful',
+        'Patient',
+        'Energetic',
+        'Adventurous',
+        'Ambitious',
+        'Courageous',
+        'Courteous',
+        'Determined',
+    ];
+    const ani = [
+        'Cat',
+        'Dog',
+        'Tiger',
+        'Elephant',
+        'Monkey',
+        'Penguin',
+        'Dolphin',
+        'Lion',
+        'Bear',
+        'Fox',
+        'Owl',
+        'Giraffe',
+        'Zebra',
+        'Koala',
+        'Rabbit',
+        'Squirrel',
+        'Panda',
+        'Horse',
+        'Wolf',
+        'Eagle',
+    ];
+    const job = [
+        'Writer',
+        'Artist',
+        'Musician',
+        'Explorer',
+        'Scientist',
+        'Engineer',
+        'Athlete',
+        'Chef',
+        'Doctor',
+        'Teacher',
+        'Lawyer',
+        'Entrepreneur',
+        'Actor',
+        'Dancer',
+        'Photographer',
+        'Architect',
+        'Pilot',
+        'Designer',
+        'Journalist',
+        'Veterinarian',
+    ];
+
+    const nombre = randomNumber(0, 99);
+    const choix: Record<string, () => string> = {
+        adj_num: () => random(adj) + nombre,
+        ani_num: () => random(ani) + nombre,
+        pro_num: () => random(job) + nombre,
+        adj_ani: () => random(adj) + random(ani),
+        adj_ani_num: () => random(adj) + random(ani) + nombre,
+        adj_pro: () => random(adj) + random(job),
+        pro_ani: () => random(job) + random(ani),
+        pro_ani_num: () => random(job) + random(ani) + nombre,
+    };
+
+    return {
+        username: choix[random(Object.keys(choix))]!(),
+        number: nombre,
+        adjective: random(adj),
+        animal: random(ani),
+        job: random(job),
+    };
+}

package/src/modules/v4/utils.ts

@@ -0,0 +1,38 @@
+export function random<T>(arr: T[]): T {
+    return arr[Math.floor(Math.random() * arr.length)]!;
+}
+
+export function randomNumber(min: number, max: number): number {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+export function genIP(): string {
+    return `${randomNumber(0, 255)}.${randomNumber(0, 255)}.${randomNumber(0, 255)}.${randomNumber(0, 255)}`;
+}
+
+export function formatDate(date: Date): string {
+    return new Date(date.getTime() - date.getTimezoneOffset() * 60000).toISOString().replace('Z', '');
+}
+
+export function envList(key: string): string[] | null {
+    const v = process.env[key];
+    return v && v !== 'undefined' ? v.split(' ') : null;
+}
+
+export function checkRateLimit(
+    rateLimits: Record<string, number[]>,
+    userId: string,
+    timestamp: number,
+    window = 10000,
+    limit = 50,
+): boolean {
+    rateLimits[userId] = (rateLimits[userId] ?? []).filter((ts) => timestamp - ts < window);
+
+    if (rateLimits[userId]!.length > limit) {
+        const remainingTime = Math.ceil((rateLimits[userId]![0]! + window - timestamp) / 1000);
+        throw new Error(`Rate limit exceeded. Try again in ${remainingTime} seconds.`);
+    }
+
+    rateLimits[userId]!.push(timestamp);
+    return false;
+}

package/src/modules/v4.ts

@@ -0,0 +1,15 @@
+export * as algorithms from './v4/algorithms.js';
+export { default as chat } from './v4/chat.js';
+export { default as captcha } from './v4/captcha.js';
+export { default as color } from './v4/color.js';
+export { default as convert } from './v4/convert.js';
+export { default as domain } from './v4/domain.js';
+export { default as hash } from './v4/hash.js';
+export { default as hyperplanning } from './v4/hyperplanning.js';
+export { default as levenshtein } from './v4/levenshtein.js';
+export { default as personal } from './v4/personal.js';
+export { default as qrcode } from './v4/qrcode.js';
+export { default as tic_tac_toe } from './v4/tic_tac_toe.js';
+export { default as time } from './v4/time.js';
+export { default as token } from './v4/token.js';
+export { default as username } from './v4/username.js';

package/src/routes/get.ts

@@ -0,0 +1,461 @@
+import { Router, type Request, type Response } from 'express';
+import { versions } from '../config/versions.js';
+import { env } from '../config/env.js';
+import { ipLimits } from '../storage/index.js';
+import { chatStorage } from '../storage/index.js';
+import { DOCS_URL, GITHUB_CACHE_TTL } from '../constants.js';
+import { error } from '../utils/response.js';
+
+const router = Router();
+
+let activity: Record<string, unknown>[] = [];
+let lastFetch = 0;
+
+// Display version information
+router.get('/:version', (req: Request, res: Response) => {
+    const version = req.params.version as string;
+    const versionConfig = versions[version]!;
+
+    const endpoints = Object.keys(versionConfig.endpoints).reduce<Record<string, unknown>>((acc, method) => {
+        const endpointList = versionConfig.endpoints[method as keyof typeof versionConfig.endpoints];
+        acc[method] = endpointList
+            .filter(({ name }: { name: string }) => name !== 'website')
+            .sort((a: { name: string }, b: { name: string }) => a.name.localeCompare(b.name))
+            .reduce<Record<string, unknown>>(
+                (
+                    group: Record<string, unknown>,
+                    endpoint: { name: string; path?: string; children?: Record<string, string> },
+                ) => {
+                    if (endpoint.children) {
+                        group[endpoint.name] = Object.keys(endpoint.children)
+                            .sort((a: string, b: string) => a.localeCompare(b))
+                            .reduce<Record<string, string>>((childGroup, childName) => {
+                                childGroup[childName] = `/${version}${endpoint.children![childName]}`;
+                                return childGroup;
+                            }, {});
+                    } else {
+                        group[endpoint.name] = `/${version}${endpoint.path}`;
+                    }
+                    return group;
+                },
+                {},
+            );
+        return acc;
+    }, {});
+
+    res.jsonResponse({
+        version,
+        documentation: `${DOCS_URL}/${version}`,
+        endpoints,
+    });
+});
+
+// Algorithms
+router.get('/:version/algorithms', (req: Request, res: Response) => {
+    const { method, value, value2 } = req.query;
+    const { version } = req.params;
+
+    const algorithms = req.module.algorithms as Record<string, (v: string, v2?: string) => unknown>;
+    if (!algorithms || !algorithms[method as string]) {
+        error(res, 400, 'Please provide a valid algorithm (?method={algorithm})', `${version}/algorithms`);
+        return;
+    }
+
+    try {
+        const answer = algorithms[method as string]!(value as string, value2 as string);
+        res.jsonResponse({ answer });
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/algorithms`);
+    }
+});
+
+// Generate captcha
+router.get('/:version/captcha', (req: Request, res: Response) => {
+    const text = req.query.text as string;
+
+    if (!text) {
+        error(res, 400, 'Please provide a valid argument (?text={text})', `${req.version}/captcha`);
+        return;
+    }
+
+    try {
+        const result = req.module.captcha(text);
+        res.type('png').send(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/captcha`);
+    }
+});
+
+// Display stored data
+router.get('/:version/chat', (req: Request, res: Response) => {
+    try {
+        const messages = req.module.chat('fetch', {
+            username: 'system',
+            storage: chatStorage,
+        });
+        res.jsonResponse(messages);
+    } catch (err) {
+        error(res, 400, (err as Error).message);
+    }
+});
+
+// GET private chat error
+router.get('/:version/chat/private', (_req: Request, res: Response) => {
+    error(res, 405, 'This endpoint only supports POST requests.');
+});
+
+// Generate color
+router.get('/:version/color', (req: Request, res: Response) => {
+    try {
+        const result = req.module.color();
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/color`);
+    }
+});
+
+// Convert units
+router.get('/:version/convert', (req: Request, res: Response) => {
+    const { value, from, to } = req.query;
+
+    if (!value || isNaN(Number(value))) {
+        error(res, 400, 'Please provide a valid value (?value={value})', `${req.version}/convert`);
+        return;
+    }
+    if (!from) {
+        error(res, 400, 'Please provide a valid source unit (&from={unit})', `${req.version}/convert`);
+        return;
+    }
+    if (!to) {
+        error(res, 400, 'Please provide a valid target unit (&to={unit})', `${req.version}/convert`);
+        return;
+    }
+
+    try {
+        const result = req.module.convert(value as string, from as string, to as string);
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/convert`);
+    }
+});
+
+// Generate domain informations
+router.get('/:version/domain', (req: Request, res: Response) => {
+    try {
+        const result = req.module.domain();
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/domain`);
+    }
+});
+
+// GET planning error
+router.get('/:version/hyperplanning', (_req: Request, res: Response) => {
+    error(res, 405, 'This endpoint only supports POST requests.');
+});
+
+// GET hash error
+router.get('/:version/hash', (_req: Request, res: Response) => {
+    error(res, 405, 'This endpoint only supports POST requests.');
+});
+
+// Display API informations
+router.get('/:version/infos', (req: Request, res: Response) => {
+    const endpoints = Object.values(versions[req.version]!.endpoints).flat();
+
+    const paths = endpoints.flatMap((e) => (e.children ? Object.values(e.children) : e.path ? [e.path] : []));
+
+    res.jsonResponse({
+        endpoints: new Set(paths).size,
+        last_version: Object.keys(versions).pop(),
+        documentation: DOCS_URL,
+        github: 'https://github.com/20syldev/api',
+        creation: 'November 25th 2024',
+    });
+});
+
+// Calculate Levenshtein distance
+router.get('/:version/levenshtein', (req: Request, res: Response) => {
+    const { str1, str2 } = req.query;
+
+    if (!str1 || typeof str1 !== 'string') {
+        error(res, 400, 'Please provide a first string (?str1={string})', `${req.version}/levenshtein`);
+        return;
+    }
+    if (!str2 || typeof str2 !== 'string') {
+        error(res, 400, 'Please provide a second string (&str2={string})', `${req.version}/levenshtein`);
+        return;
+    }
+
+    try {
+        const result = req.module.levenshtein(str1, str2);
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/levenshtein`);
+    }
+});
+
+// Generate personal data
+router.get('/:version/personal', (req: Request, res: Response) => {
+    try {
+        const result = req.module.personal();
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/personal`);
+    }
+});
+
+// Generate QR Code
+router.get('/:version/qrcode', async (req: Request, res: Response) => {
+    const { url } = req.query;
+
+    if (!url) {
+        error(res, 400, 'Please provide a valid url (?url={URL})', `${req.version}/qrcode`);
+        return;
+    }
+
+    try {
+        const result = await req.module.qrcode(url as string);
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/qrcode`);
+    }
+});
+
+// GET tic-tac-toe errors
+router.get('/:version/tic-tac-toe', (_req: Request, res: Response) => {
+    error(res, 405, 'This endpoint only supports POST requests.');
+});
+
+router.get('/:version/tic-tac-toe/fetch', (_req: Request, res: Response) => {
+    error(res, 405, 'This endpoint only supports POST requests.');
+});
+
+router.get('/:version/tic-tac-toe/list', (_req: Request, res: Response) => {
+    error(res, 405, 'This endpoint only supports POST requests.');
+});
+
+// Display or generate time informations
+router.get('/:version/time', (req: Request, res: Response) => {
+    const { type = 'live', start, end, format, timezone } = req.query;
+
+    const validFormats = [
+        'iso',
+        'utc',
+        'timestamp',
+        'locale',
+        'date',
+        'time',
+        'year',
+        'month',
+        'day',
+        'hour',
+        'minute',
+        'second',
+        'ms',
+        'dayOfWeek',
+        'dayOfYear',
+        'weekNumber',
+        'timezone',
+        'timezoneOffset',
+    ];
+    const validTimezones = ['UTC', 'America/New_York', 'Europe/Paris', 'Asia/Tokyo', 'Australia/Sydney'];
+
+    if (type !== 'live' && type !== 'random') {
+        error(res, 400, 'Please provide a valid type (?type={type})', `${req.version}/time`);
+        return;
+    }
+    if (start && !Date.parse(start as string)) {
+        error(res, 400, 'Please provide a valid start date (?start={YYYY-MM-DD})', `${req.version}/time`);
+        return;
+    }
+    if (end && !Date.parse(end as string)) {
+        error(res, 400, 'Please provide a valid end date (?end={YYYY-MM-DD})', `${req.version}/time`);
+        return;
+    }
+    if (format && !validFormats.includes(format as string)) {
+        error(res, 400, 'Please provide a valid format (?format={format})', `${req.version}/time`);
+        return;
+    }
+    if (timezone && !validTimezones.includes(timezone as string)) {
+        error(res, 400, 'Please provide a valid timezone (?timezone={timezone})', `${req.version}/time`);
+        return;
+    }
+
+    try {
+        const time = req.module.time(
+            type as string,
+            start as string,
+            end as string,
+            format as string,
+            timezone as string,
+        );
+        res.jsonResponse(time);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/time`);
+    }
+});
+
+// GET token error
+router.get('/:version/token', (_req: Request, res: Response) => {
+    error(res, 405, 'This endpoint only supports POST requests.');
+});
+
+// Generate username
+router.get('/:version/username', (req: Request, res: Response) => {
+    try {
+        const result = req.module.username();
+        res.jsonResponse(result);
+    } catch (err) {
+        error(res, 400, (err as Error).message, `${req.version}/username`);
+    }
+});
+
+// Display informations for owner's website
+router.get('/:version/website', async (req: Request, res: Response) => {
+    const currentTime = Date.now();
+
+    if (currentTime - lastFetch >= GITHUB_CACHE_TTL) {
+        try {
+            const username = '20syldev';
+            const token = env.GITHUB_TOKEN;
+            const lastYear = new Date(new Date().setFullYear(new Date().getFullYear() - 1)).toISOString().split('T')[0];
+
+            const query = `
+            {
+              user(login: "${username}") {
+                contributionsCollection(from: "${lastYear}T00:00:00Z") {
+                  contributionCalendar {
+                    totalContributions
+                    weeks {
+                      firstDay
+                      contributionDays {
+                        date
+                        contributionCount
+                      }
+                    }
+                  }
+                }
+              }
+            }`;
+
+            const apiResponse = await fetch('https://api.github.com/graphql', {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ query }),
+            });
+
+            if (!apiResponse.ok) throw new Error('Error fetching data.');
+
+            const data = (await apiResponse.json()) as {
+                data?: {
+                    user?: {
+                        contributionsCollection?: {
+                            contributionCalendar?: {
+                                weeks?: {
+                                    firstDay: string;
+                                    contributionDays: { date: string; contributionCount: number }[];
+                                }[];
+                            };
+                        };
+                    };
+                };
+            };
+            const user = data?.data?.user;
+
+            const weeks = user?.contributionsCollection?.contributionCalendar?.weeks || [];
+            activity = weeks.map((w) => ({
+                week: w.firstDay,
+                total: w.contributionDays.reduce((sum, d) => sum + d.contributionCount, 0),
+                days: w.contributionDays.map((d) => ({ date: d.date, count: d.contributionCount })),
+            }));
+
+            lastFetch = currentTime;
+        } catch {
+            activity = [];
+        }
+    }
+
+    const response: Record<string, unknown> = {
+        versions: {
+            2048: env.G_2048,
+            api: env.API,
+            cdn: env.CDN,
+            coop_api: env.COOP_API,
+            coop_status: env.COOP_STATUS,
+            chat: env.CHAT,
+            digit: env.DIGIT,
+            doc_coopbot: env.DOC_COOPBOT,
+            docs: env.DOCS,
+            donut: env.DONUT,
+            drawio_plugin: env.DRAWIO_PLUGIN,
+            flowers: env.FLOWERS,
+            gemsync: env.GEMSYNC,
+            gft: env.GFT,
+            gitsite: env.GITSITE,
+            lebonchar: env.LEBONCHAR,
+            logger: env.LOGGER,
+            logs: env.LOGS,
+            logvault: env.LOGVAULT,
+            lyah: env.LYAH,
+            minify: env.MINIFY,
+            mn: env.MN,
+            monitoring: env.MONITORING,
+            morpion: env.MORPION,
+            nitrogen: env.NITROGEN,
+            old_database: env.OLD_DATABASE,
+            password: env.PASSWORD,
+            php: env.PHP,
+            planning: env.PLANNING,
+            ping: env.PING,
+            portfolio: env.PORTFOLIO,
+            python_api: env.PYTHON_API,
+            readme: env.README,
+            timestamp: env.TIMESTAMP,
+            terminal: env.TERMINAL,
+            valentine: env.VALENTINE,
+            wrkit: env.WRKIT,
+            zpki: env.ZPKI,
+        },
+        patched_projects: env.PATCH,
+        updated_projects: env.RECENT,
+        new_projects: env.NEW,
+        sub_domains: env.DOMAINS,
+        stats: {
+            1: env.STATS1,
+            2: env.STATS2,
+            3: env.STATS3,
+            4: env.STATS4,
+            5: Object.keys(ipLimits).length,
+            activity,
+        },
+        tag: env.TAG,
+        active: env.ACTIVE,
+    };
+
+    const key = req.query.key as string | undefined;
+    if (key) {
+        if (['__proto__', 'constructor', 'prototype'].some((p) => key.includes(p))) {
+            error(res, 400, 'Invalid key.');
+            return;
+        }
+
+        const keys = key.split('.');
+        let result: unknown = response;
+
+        for (const k of keys) {
+            if (result == null || typeof result !== 'object' || !(k in result)) {
+                error(res, 404, `Key '${key}' not found.`);
+                return;
+            }
+            result = (result as Record<string, unknown>)[k];
+        }
+
+        res.jsonResponse({ [key]: result });
+        return;
+    }
+
+    res.jsonResponse(response);
+});
+
+export default router;