vortez 5.0.0-dev.19 → 5.0.1

package/tests/schema/schema.js

@@ -1,368 +0,0 @@
-// @ts-check
-import { strict as assert } from 'assert';
-
-import { Logger } from '../../build/Vortez.js';
-import { Schema } from '../../build/utilities/schema/Schema.js';
-import { SchemaError } from '../../build/utilities/schema/SchemaError.js';
-
-const logger = new Logger({ prefix: 'SCHEMA' });
-
-let testsPassed = 0;
-let testsFailed = 0;
-
-const x = new Schema({
-    host: { type: 'string', required: true, minLength: 1 },
-    port: { type: 'number', minimum: 0, maximum: 65535, default: 80 },
-    ssl: {
-        type: 'object',
-        nullable: true,
-        default: null,
-        schema: {
-            pubKey: { type: 'string', required: true },
-            privKey: { type: 'string', required: true }
-        }
-    }
-});
-const y = x.processData({ host: 'localhost' });
-
-/**
- * Logs test results.
- * @param { string } testName The test name.
- * @param { boolean } passed Whether the test passed.
- * @param { unknown | null } error Optional error object for failures.
- */
-function logTestResult(testName, passed, error = null) {
-    if (passed) {
-        logger.log(`&C2✓ ${testName}`);
-        testsPassed++;
-    } else {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.error(`&C1✗ ${testName}${error ? ': ' + message : ''}`);
-        testsFailed++;
-    }
-}
-
-/**
- * Ensures processData applies defaults and keeps valid values.
- */
-function testProcessDataWithDefaults() {
-    try {
-        const schema = new Schema({
-            host: { type: 'string', required: true, minLength: 1 },
-            port: { type: 'number', minimum: 0, maximum: 65535, default: 80 },
-            ssl: {
-                type: 'object',
-                nullable: true,
-                default: null,
-                schema: {
-                    pubKey: { type: 'string', required: true },
-                    privKey: { type: 'string', required: true }
-                }
-            }
-        });
-
-        const data = schema.processData({ host: 'localhost' });
-        assert.equal(data.host, 'localhost');
-        assert.equal(data.port, 80);
-        assert.equal(data.ssl, null);
-
-        logTestResult('processData - Applies defaults', true);
-    } catch (error) {
-        logTestResult('processData - Applies defaults', false, error);
-    }
-}
-
-/**
- * Ensures required keys fail when not provided.
- */
-function testRequiredFieldFailure() {
-    try {
-        const schema = new Schema({
-            host: { type: 'string', required: true }
-        });
-
-        try {
-            // @ts-expect-error Runtime validation test with missing required key on purpose.
-            schema.processData({});
-            logTestResult('required - Missing required key fails', false, new Error('Should have thrown'));
-        } catch (error) {
-            assert.ok(error instanceof SchemaError);
-            logTestResult('required - Missing required key fails', true);
-        }
-    } catch (error) {
-        logTestResult('required - Missing required key fails', false, error);
-    }
-}
-
-/**
- * Covers edge cases where numeric/string limits are 0.
- */
-function testZeroBoundaries() {
-    try {
-        const stringSchema = new Schema({
-            emptyOnly: { type: 'string', required: true, maxLength: 0, minLength: 0 }
-        });
-        const numberSchema = new Schema({
-            count: { type: 'number', required: true, minimum: 0, maximum: 0 }
-        });
-
-        const validString = stringSchema.processData({ emptyOnly: '' });
-        const validNumber = numberSchema.processData({ count: 0 });
-
-        assert.equal(validString.emptyOnly, '');
-        assert.equal(validNumber.count, 0);
-
-        assert.throws(() => stringSchema.processData({ emptyOnly: 'x' }), SchemaError);
-        assert.throws(() => numberSchema.processData({ count: -1 }), SchemaError);
-
-        logTestResult('limits - Zero boundaries enforced', true);
-    } catch (error) {
-        logTestResult('limits - Zero boundaries enforced', false, error);
-    }
-}
-
-/**
- * Ensures array size validation and element validation work together.
- */
-function testArrayValidation() {
-    try {
-        const schema = new Schema({
-            tags: {
-                type: 'array',
-                required: true,
-                minimum: 0,
-                maximum: 2,
-                property: { type: 'string', minLength: 1 }
-            }
-        });
-
-        const valid = schema.processData({ tags: [] });
-        assert.deepEqual(valid.tags, []);
-
-        assert.throws(() => schema.processData({ tags: ['a', 'b', 'c'] }), SchemaError);
-        assert.throws(() => schema.processData({ tags: [''] }), SchemaError);
-
-        logTestResult('array - Limits and item validation', true);
-    } catch (error) {
-        logTestResult('array - Limits and item validation', false, error);
-    }
-}
-
-/**
- * Ensures deep dot-path updates in processPartialData work.
- */
-function testDeepPartialProcessing() {
-    try {
-        const schema = new Schema({
-            profile: {
-                type: 'object',
-                required: true,
-                schema: {
-                    address: {
-                        type: 'object',
-                        required: true,
-                        schema: {
-                            zip: { type: 'number', required: true, minimum: 0 }
-                        }
-                    }
-                }
-            }
-        });
-
-        const partial = schema.processPartialData({ 'profile.address.zip': 1200 });
-        assert.equal(partial['profile.address.zip'], 1200);
-
-        assert.throws(() => schema.processPartialData({ 'profile.address.missing': 1 }), SchemaError);
-
-        logTestResult('partial - Deep object path validation', true);
-    } catch (error) {
-        logTestResult('partial - Deep object path validation', false, error);
-    }
-}
-
-/**
- * Ensures processData in partial mode rejects unknown root keys.
- */
-function testPartialUnknownRootKey() {
-    try {
-        const schema = new Schema({
-            host: { type: 'string', required: true }
-        });
-
-        assert.throws(
-            // @ts-expect-error Runtime validation test with unknown key on purpose.
-            () => schema.processData({ host: 'localhost', extra: 'x' }, true),
-            SchemaError
-        );
-
-        logTestResult('partial - Unknown root key rejected', true);
-    } catch (error) {
-        logTestResult('partial - Unknown root key rejected', false, error);
-    }
-}
-
-/**
- * Ensures object properties reject arrays as invalid object values.
- */
-function testObjectRejectsArrayValue() {
-    try {
-        const schema = new Schema({
-            profile: {
-                type: 'object',
-                required: true,
-                schema: {
-                    zip: { type: 'number', required: true }
-                }
-            }
-        });
-
-        assert.throws(
-            // @ts-expect-error Runtime validation test with invalid object value on purpose.
-            () => schema.processData({ profile: [] }),
-            SchemaError
-        );
-
-        logTestResult('object - Arrays are rejected', true);
-    } catch (error) {
-        logTestResult('object - Arrays are rejected', false, error);
-    }
-}
-
-/**
- * Ensures JSON Schema output maps arrays with items/minItems/maxItems.
- */
-function testJsonSchemaArrayMapping() {
-    try {
-        const schema = new Schema({
-            tags: {
-                type: 'array',
-                minimum: 1,
-                maximum: 3,
-                property: { type: 'string', minLength: 2 }
-            }
-        });
-
-        const json = schema.jsonSchema;
-        const tags = json.properties?.tags;
-        const tagsItems = tags?.items;
-
-        assert.equal(tags?.type, 'array');
-        assert.equal(tags?.minItems, 1);
-        assert.equal(tags?.maxItems, 3);
-        assert.ok(tagsItems && !Array.isArray(tagsItems));
-        assert.equal(tagsItems.type, 'string');
-        assert.equal(tagsItems.minLength, 2);
-
-        logTestResult('jsonSchema - Array mapping', true);
-    } catch (error) {
-        logTestResult('jsonSchema - Array mapping', false, error);
-    }
-}
-
-/**
- * Ensures string enum validation accepts only allowed values.
- */
-function testStringEnumValidation() {
-    try {
-        const schema = new Schema({
-            mode: { type: 'string', required: true, enum: ['A', 'B'] }
-        });
-
-        const valid = schema.processData({ mode: 'A' });
-        assert.equal(valid.mode, 'A');
-
-        assert.throws(() => schema.processData({ mode: 'C' }), SchemaError);
-
-        logTestResult('string - Enum validation', true);
-    } catch (error) {
-        logTestResult('string - Enum validation', false, error);
-    }
-}
-
-/**
- * Ensures JSON Schema output contains enum for string properties.
- */
-function testJsonSchemaStringEnumMapping() {
-    try {
-        const schema = new Schema({
-            mode: { type: 'string', enum: ['A', 'B'] }
-        });
-
-        const json = schema.jsonSchema;
-        const mode = json.properties?.mode;
-
-        assert.equal(mode?.type, 'string');
-        assert.deepEqual(mode?.enum, ['A', 'B']);
-
-        logTestResult('jsonSchema - String enum mapping', true);
-    } catch (error) {
-        logTestResult('jsonSchema - String enum mapping', false, error);
-    }
-}
-
-/**
- * Ensures nested unique keys are listed with dot notation.
- */
-function testUniqueKeyCollection() {
-    try {
-        const schema = new Schema({
-            username: { type: 'string', unique: true },
-            profile: {
-                type: 'object',
-                schema: {
-                    email: { type: 'string', unique: true },
-                    country: { type: 'string' }
-                }
-            }
-        });
-
-        const uniques = schema.uniques.sort();
-        assert.deepEqual(uniques, ['profile.email', 'username']);
-
-        logTestResult('uniques - Nested keys collected', true);
-    } catch (error) {
-        logTestResult('uniques - Nested keys collected', false, error);
-    }
-}
-
-/**
- * Ensures invalid schema definitions fail at construction time.
- */
-function testInvalidSchemaDefinition() {
-    try {
-        assert.throws(() => {
-            // @ts-ignore Runtime validation test with invalid shape on purpose.
-            new Schema({ name: { type: 'string', pattern: 'not-a-regexp' } });
-        }, SchemaError);
-
-        logTestResult('schema - Invalid definition rejected', true);
-    } catch (error) {
-        logTestResult('schema - Invalid definition rejected', false, error);
-    }
-}
-
-function runTests() {
-    logger.log('\n&C6=== Schema Test Suite ===\n');
-
-    testProcessDataWithDefaults();
-    testRequiredFieldFailure();
-    testZeroBoundaries();
-    testArrayValidation();
-    testDeepPartialProcessing();
-    testPartialUnknownRootKey();
-    testObjectRejectsArrayValue();
-    testJsonSchemaArrayMapping();
-    testStringEnumValidation();
-    testJsonSchemaStringEnumMapping();
-    testUniqueKeyCollection();
-    testInvalidSchemaDefinition();
-
-    logger.log('\n&C6=== Results ===');
-    logger.log(`&C2✓ Passed: ${testsPassed}`);
-    logger.log(`&C1✗ Failed: ${testsFailed}`);
-    logger.log(`&C3Total: ${testsPassed + testsFailed}\n`);
-
-    process.exit(testsFailed > 0 ? 1 : 0);
-}
-
-runTests();

package/tests/test.js

@@ -1,131 +0,0 @@
-/// @ts-check
-
-import Vortez, { Logger, Utilities } from "../build/Vortez.js";
-import "./debug.js";
-import "./utilities.js";
-
-/* | ENABLING ALL THE Vortez LOGS IN CONSOLE | */
-Logger.Debug.showAll = true;
-/* | CREATING DEBUG INSTANCE TO THE TESTS | */
-const debug = new Logger({ prefix: 'TEST' });
-
-/* | CREATING ENV VARIABLES FOR THE TESTS | */
-
-await Utilities.Env.load('tests/test.env');
-// Utilities.Env.loadSync('tests/test.env');
-
-/* | CREATING SERVER | */
-const server = new Vortez({ port: 8001 });
-
-/* | FILE RULE TEST | */
-server.router.addFile('/File', 'changes.md')
-server.router.addFile('/favicon.ico', 'global/Source/Logo_SM_960.png');
-
-/* | FILE RULE TEST USING AUTH EXEC | */
-server.router.addFile('/FileWA', 'changes.md')
-    .use(async (request, Response, next) => {
-        const { Auth } = request.searchParams;
-        if (Auth === 'AuthYes') return next();
-        throw new Vortez.ServerError('No authorized', 401);
-    });
-
-/* | CREATING RULES WITH THE RULE CONSTRUCTOR | */
-server.router.addRules(
-    new Vortez.Router.HttpRule('GET', '/MyFile/*', (Rq, Rs) => Rs.sendFile('Test/Test.js'))
-);
-
-/* | FOLDER RULES TEST | */
-server.router.addFolder('/Folder', '.debug');
-
-/* | ACTION RULES TEST | */
-server.router.addAction('ALL', '/', (Rq, Rs) => {
-    return Rs.sendTemplate('tests/test.vhtml', {
-        Tittle: '[NetFeez-Labs] · Tests',
-        Sources: {
-            File: '/File',
-            FileWithAuthFunction_NoAuth: '/FileWA',
-            FileWithAuthFunction_Auth: '/FileWA?Auth=AuthYes',
-            Folder: '/Folder',
-            RuleParams: '/RuleParams/param1/param2/param3/XD',
-            WebSocket: '/WebSocket'
-        }
-    });
-});
-
-/* | URL RULE PARAMS TEST | */
-server.router.addAction('ALL', '/RuleParams/$?param1/$?b/$?c/*', (Rq, Rs) => {
-    Rs.sendJson({
-        Url: Rq.url,
-        RuleParams: Rq.ruleParams
-    })
-});
-
-/* | WEBSOCKET RULE TEST | */
-/**
- * @typedef {import('../build/server/websocket/Websocket.js').Websocket} WebSocket
- */
-/** @type {Set<WebSocket>} */
-const clients = new Set();
-/** @type {Set<string>} */
-const usernames = new Set();
-
-/**
- * 
- * @param {string | Buffer} message 
- * @param {WebSocket | null | undefined} exclude 
- */
-function broadCast(message, exclude = null) {
-    clients.forEach(client => {
-        if (!exclude || client !== exclude) client.send(message)
-    })
-}
-
-server.router.addAction('ALL', 'WebSocket', (Rq, Rs) => {
-    return Rs.sendTemplate('tests/websocket.vhtml', {
-        Host: `/WebSocket`
-    });
-});
-
-server.router.addWebsocket('/WebSocket/$?username', (request, socket) => {
-    const username = request.ruleParams.username;
-    if (!username) {
-        socket.send('error: no username');
-        socket.end();
-        return;
-    }
-    if (usernames.has(username)) {
-        socket.send('error: username already in use');
-        socket.end();
-        return;
-    }
-    usernames.add(username)
-    clients.add(socket);
-    debug.log("[WebSocket]", "new client", username);
-    
-    socket.send("[server] hallo");
-    broadCast('[server] new client: ' + username, socket);
-
-    socket.on('message', (data, info) => {
-        if (info.opCode !== 0x1) return;
-        const message = username + ': ' + data.toString();
-        debug.log(['[WebSocket]', message]);
-        broadCast(message, socket);
-    });
-    socket.on('error', (Error) => {
-        debug.log('[WebSocket-Error]: ' + Error.message);
-    });
-    socket.on('finish', () => {
-        clients.delete(socket);
-        usernames.delete(username);
-        broadCast('[server] client disconnected: ' + username);
-        debug.log('[WebSocket-Finish]: client disconnected')
-    });
-}).use((request, client, next) => {
-    const { username } = request.ruleParams;
-    if (!username) return next(new Vortez.ServerError('no username', 400));
-    if (username === 'system') return next(new Vortez.ServerError('you cant use system as username', 400));
-    return next();
-});
-const cli = new Vortez.ServerDebug(server);
-cli.start();
-server.start();

package/tests/test.vhtml

@@ -1,14 +0,0 @@
-<!DOCTYPE html>
-<html lang="es-CO">
-    <head>
-        <meta charset="UTF-8">
-        <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <title>${Tittle}</title>
-    </head>
-    <body>
-        <h1>${Tittle}</h1>
-        $(Sources, text, url) {
-            <a href="%url%">%text%</a><br>
-        }
-    </body>
-</html>

package/tests/utilities.js

@@ -1,28 +0,0 @@
-//@ts-check
-import Utilities from "../build/utilities/Utilities.js";
-
-try {
-    const toFlatten = {
-        a: { b: {
-                c: "a.b.c",
-                d: "a.b.c.d",
-                f: {g:{h:{i:{j:{j:{k:{l:"a.b.c.d.f.g.h.i.j.j.k.l"}}}}}}},
-                z: {g:{h:{i:{j:{j:{k:{l2:"a.b.z.d.f.g.h.i.j.j.k.l2"}}}}}}}
-            },
-            null: null,
-            undefined: undefined
-        },
-        e: { f: "e.f" },
-        arr: [1,2,3,4]
-    }
-
-    const flattened = Utilities.flattenObject(toFlatten, 9);
-    const unFlattened = Utilities.unFlattenObject(flattened);
-    if (!Utilities.deepEqual(toFlatten, unFlattened)) {
-        throw new Error("Flatten test fail: toFlatten != unFlattened");
-    } else {
-        console.log("Flatten test success");
-    }
-} catch (error) {
-    console.error(error);
-}

package/tests/websocket.vhtml

@@ -1,86 +0,0 @@
-<!DOCTYPE html>
-<html lang="es-CO">
-    <head>
-        <meta charset="UTF-8">
-        <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <title>[NetFeez-Labs · WebSocket]</title>
-    </head>
-    <body>
-        <h1>[NetFeez-Labs · WebSocket]</h1>
-        <input  id="username" type="text" placeholder="Username"/>
-        <button id="Connect">Conectar</button>
-        <button id="Disconnect">Desconectar</button>
-        <br/>
-        <input  id="InMessage" type="text" placeholder="Message/Command"/>
-        <button id="Send">Enviar</button>
-        <div id="Log"></div>
-        <script>
-            window.host = "${Host}";
-            const BtnConnect    = document.querySelector('#Connect');
-            const BtnDisconnect = document.querySelector('#Disconnect');
-            const BtnSend       = document.querySelector('#Send');
-
-            const inUsername = document.querySelector('#username');
-            const InMessage  = document.querySelector('#InMessage');
-            const OutLog    =  document.querySelector('#Log');
-
-            let Connected = false;
-            /** @type {WebSocket} */
-            let Connection = null;
-
-            /** @param {string} Message */
-            const Log = (Message, Prefix = 'WS') => {
-                console.log(`[${Prefix}]:`, Message);
-                let Element = document.createElement('p');
-                Element.innerText = `[${Prefix}]: ` + Message;
-                if (OutLog.firstChild) {
-                    OutLog.insertBefore(Element, OutLog.firstChild);
-                } else {
-                    OutLog.appendChild(Element);
-                }
-            }
-
-            const Connect = () => {
-                if (Connected) {
-                    Log('Ya estas conectado');
-                } else {
-                    const username = inUsername.value;
-                    Log('Conectando...');
-                    Connection = new WebSocket(`${Host}/${username}`);
-                    Connection.onerror = () => {
-                        Log('fallo en la conexión', 'ER');
-                    }
-                    Connection.onclose = () => {
-                        Connected = false;
-                        Connection = null;
-                    }
-                    Connection.onopen = () => {
-                        Connected = true;
-                        Log('Conectado');
-                    }
-                    Connection.onmessage = (Ev) => {
-                        Log(Ev.data, '<');
-                        console.log(Ev.data);
-                    };
-                }
-            }
-            const Disconnect = () => {
-                Connection.close();
-            }
-            const Send = () => {
-                if (Connected) {
-                    let Message = InMessage.value;
-                    InMessage.value = '';
-                    Connection.send(Message);
-                    Log(Message, '>');
-                } else {
-                    Log('Debes conectarte primero');
-                }
-            }
-
-            BtnConnect.addEventListener('click', () => Connect());
-            BtnDisconnect.addEventListener('click', () => Disconnect());
-            BtnSend.addEventListener('click', () => Send());
-        </script>
-    </body>
-</html>