@20syldev/api 4.7.0 → 4.9.0

package/src/modules/v4/token.ts

@@ -1,53 +0,0 @@
-import { randomBytes, randomInt } from 'crypto';
-import { v4 } from 'uuid';
-
-import { MAX_TOKEN_LENGTH, MIN_TOKEN_LENGTH } from '../../constants.js';
-
-/**
- * Generates a cryptographically random token of the specified length and type.
- *
- * @param len - Token length (must be between 12 and 4096)
- * @param type - Character set to use: "alpha", "alphanum", "base64", "hex", "num", "punct", "urlsafe", or "uuid"
- * @returns The generated token string
- * @throws Error if length is out of range or the type is not valid
- */
-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 =>
-        Array.from({ length }, () => chars[randomInt(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: () => {
-            let result = '';
-            while (result.length < len) result += v4().replace(/-/g, '');
-            return result.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

@@ -1,94 +0,0 @@
-import { random, randomNumber } from '../../utils/helpers.js';
-
-/**
- * Generates a random username combining adjectives, animals, and job titles.
- *
- * @returns Object containing the generated username, the number used, and the components (adjective, animal, job)
- */
-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/validate.ts

@@ -1,76 +0,0 @@
-import { MAX_STRING_LENGTH } from '../../constants.js';
-
-function checkValue(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`);
-}
-
-/**
- * Validates a credit/debit card number using the Luhn algorithm.
- *
- * @param value - Card number string (digits, spaces, or dashes allowed)
- * @returns Object containing the validity result and the sanitized digit string
- * @throws Error if value is missing, contains non-digit characters, or has an invalid length
- */
-export function luhn(value: string): { valid: boolean; value: string } {
-    checkValue(value);
-    const digits = value.replace(/\s|-/g, '');
-    if (!/^\d+$/.test(digits)) throw new Error('Value must contain only digits, spaces or dashes');
-    if (digits.length < 12 || digits.length > 19) throw new Error('Card number must have between 12 and 19 digits');
-
-    let sum = 0;
-    let alt = false;
-    for (let i = digits.length - 1; i >= 0; i--) {
-        let n = parseInt(digits[i]!, 10);
-        if (alt) {
-            n *= 2;
-            if (n > 9) n -= 9;
-        }
-        sum += n;
-        alt = !alt;
-    }
-
-    return { valid: sum % 10 === 0, value: digits };
-}
-
-/**
- * Validates an IBAN using the mod-97 checksum algorithm.
- *
- * @param value - IBAN string (spaces allowed)
- * @returns Object containing the validity result, sanitized IBAN, and country code
- * @throws Error if value is missing, has an invalid format, or is out of length bounds
- */
-export function iban(value: string): { valid: boolean; value: string; country?: string } {
-    checkValue(value);
-    const cleaned = value.replace(/\s/g, '').toUpperCase();
-    if (!/^[A-Z]{2}\d{2}[A-Z0-9]+$/.test(cleaned)) throw new Error('Invalid IBAN format');
-    if (cleaned.length < 15 || cleaned.length > 34) throw new Error('IBAN length must be between 15 and 34 characters');
-
-    const rearranged = cleaned.slice(4) + cleaned.slice(0, 4);
-    const numeric = rearranged
-        .split('')
-        .map((c) => (c >= 'A' && c <= 'Z' ? (c.charCodeAt(0) - 55).toString() : c))
-        .join('');
-
-    let remainder = 0;
-    for (const char of numeric) {
-        remainder = (remainder * 10 + parseInt(char, 10)) % 97;
-    }
-
-    return { valid: remainder === 1, value: cleaned, country: cleaned.slice(0, 2) };
-}
-
-/**
- * Validates an email address against a basic format check.
- *
- * @param value - The email address string to validate
- * @returns Object containing the validity result and the original value
- * @throws Error if value is missing, not a string, or too long
- */
-export function email(value: string): { valid: boolean; value: string } {
-    checkValue(value);
-    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    return { valid: regex.test(value), value };
-}

package/src/modules/v4.ts

@@ -1,27 +0,0 @@
-export { default as address } from './v4/address.js';
-export { default as agent } from './v4/agent.js';
-export * as algorithms from './v4/algorithms.js';
-export { default as captcha } from './v4/captcha.js';
-export { default as chat } from './v4/chat.js';
-export { default as color } from './v4/color.js';
-export { default as convert } from './v4/convert.js';
-export { default as dice } from './v4/dice.js';
-export { default as domain } from './v4/domain.js';
-export * as encode from './v4/encode.js';
-export { default as geo } from './v4/geo.js';
-export { default as hash } from './v4/hash.js';
-export { default as hyperplanning } from './v4/hyperplanning.js';
-export { default as ip } from './v4/ip.js';
-export { default as levenshtein } from './v4/levenshtein.js';
-export { default as palette } from './v4/palette.js';
-export { default as password } from './v4/password.js';
-export { default as personal } from './v4/personal.js';
-export { default as placeholder } from './v4/placeholder.js';
-export { default as qrcode } from './v4/qrcode.js';
-export { default as statistics } from './v4/statistics.js';
-export * as text from './v4/text.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';
-export * as validate from './v4/validate.js';

package/src/routes/delete.ts

@@ -1,72 +0,0 @@
-import { type Request, type Response, Router } from 'express';
-
-import { chatStorage, ticTacToeStorage } from '../storage/index.js';
-import { error } from '../utils/response.js';
-
-const router = Router();
-
-// Clear a private chat
-router.delete('/:version/chat/:token', (req: Request, res: Response) => {
-    if (req.version !== 'v4') {
-        error(res, 405, 'DELETE is only supported in v4+.', `${req.version}/chat`);
-        return;
-    }
-
-    const token = req.params.token as string;
-    const { username, session } = (req.body as Record<string, string>) || {};
-
-    if (!username) {
-        error(res, 400, 'Please provide a username (?username={username})');
-        return;
-    }
-    if (!session) {
-        error(res, 400, 'Please provide a valid session ID (&session={ID})');
-        return;
-    }
-
-    try {
-        const result = req.module.chat('clear', {
-            username,
-            token,
-            session,
-            storage: chatStorage,
-        });
-        res.jsonResponse(result);
-    } catch (err) {
-        error(res, 400, (err as Error).message);
-    }
-});
-
-// Forfeit a tic-tac-toe game
-router.delete('/:version/tic-tac-toe/:game', (req: Request, res: Response) => {
-    if (req.version !== 'v4') {
-        error(res, 405, 'DELETE is only supported in v4+.', `${req.version}/tic-tac-toe`);
-        return;
-    }
-
-    const game = req.params.game as string;
-    const { username, session } = (req.body as Record<string, string>) || {};
-
-    if (!username) {
-        error(res, 400, 'Please provide a username (?username={username})');
-        return;
-    }
-    if (!session) {
-        error(res, 400, 'Please provide a valid session ID (&session={ID})');
-        return;
-    }
-
-    try {
-        const result = req.module.tic_tac_toe('forfeit', {
-            username,
-            session,
-            game,
-            storage: ticTacToeStorage,
-        });
-        res.jsonResponse(result);
-    } catch (err) {
-        error(res, 400, (err as Error).message);
-    }
-});
-
-export default router;