data-primals-engine 1.0.0

package/src/index.js

@@ -0,0 +1,15 @@
+// data-primals-engine/src/index.js
+
+// --- Core Engine & Utilities ---
+export { Engine } from './engine.js';
+export { GameObject, Logger, BenchmarkTool } from './gameObject.js';
+export { Config } from './config.js';
+export { event_on, event_trigger, event_off } from './core.js';
+
+export { UserProvider } from './providers.js';
+
+// --- Database & Data Modules ---
+export { datasCollection, filesCollection, modelsCollection, packsCollection } from './modules/mongodb.js';
+export { searchData, insertData, editData, loadFromDump, dumpUserData, validateRestoreRequest, patchData, deleteData, createModel, getModel, getModels } from './modules/data.js';
+
+

package/src/middlewares/middleware-mongodb.js

@@ -0,0 +1,131 @@
+import {isIsoDate} from "../core.js";
+
+const TEST_REGEX = /^\$|\./;
+const TEST_REGEX_WITHOUT_DOT = /^\$/;
+const REPLACE_REGEX = /^\$|\./g;
+
+function isPlainObject(obj) {
+  return typeof obj === 'object' && obj !== null;
+}
+
+function getTestRegex(allowDots) {
+  return allowDots ? TEST_REGEX_WITHOUT_DOT : TEST_REGEX;
+}
+
+function withEach(target, cb) {
+  (function act(obj) {
+    if (Array.isArray(obj)) {
+      obj.forEach(act);
+    } else if (isPlainObject(obj)) {
+      Object.keys(obj).forEach(function (key) {
+        const val = obj[key];
+        const resp = cb(obj, val, key);
+        if (resp.shouldRecurse) {
+          act(obj[resp.key || key]);
+        }
+      });
+    }
+  })(target);
+}
+
+function has(target, allowDots) {
+  const regex = getTestRegex(allowDots);
+
+  let hasProhibited = false;
+  withEach(target, function (obj, val, key) {
+    if (regex.test(key)) {
+      hasProhibited = true;
+      return { shouldRecurse: false };
+    } else {
+      return { shouldRecurse: true };
+    }
+  });
+
+  return hasProhibited;
+}
+
+function _sanitize(target, options) {
+  const regex = getTestRegex(options.allowDots);
+
+  let isSanitized = false;
+  let replaceWith = null;
+  const dryRun = Boolean(options.dryRun);
+  if (!regex.test(options.replaceWith) && options.replaceWith !== '.') {
+    replaceWith = options.replaceWith;
+  }
+
+  const wl = options.whitelist || [];
+  RegExp.prototype.toJSON = RegExp.prototype.toString;
+
+  withEach(target, function (obj, val, key) {
+    let shouldRecurse = true;
+
+    if( (key === 'regex' && obj.input) || key === '$regex' ){
+      obj[key] = new RegExp(val, "ui");
+      console.log('regex san', obj[key]);
+    }
+    else if (!wl.includes(key) && regex.test(key)) {
+      isSanitized = true;
+      // if dryRun is enabled, do not modify the target
+      if (dryRun) {
+        return {
+          shouldRecurse: shouldRecurse,
+          key: key,
+        };
+      }
+      delete obj[key];
+      if (replaceWith) {
+        key = key.replace(REPLACE_REGEX, replaceWith);
+        // Avoid to set __proto__ and constructor.prototype
+        // https://portswigger.net/daily-swig/prototype-pollution-the-dangerous-and-underrated-vulnerability-impacting-javascript-applications
+        // https://snyk.io/vuln/SNYK-JS-LODASH-73638
+        if (
+          key !== '__proto__' &&
+          key !== 'constructor' &&
+          key !== 'prototype'
+        ) {
+          obj[key] = val;
+        }
+      } else {
+        shouldRecurse = false;
+      }
+    }
+
+    return {
+      shouldRecurse: shouldRecurse,
+      key: key,
+    };
+  });
+
+  return {
+    isSanitized,
+    target,
+  };
+}
+
+function sanitize(target, options = {}) {
+  return _sanitize(target, options).target;
+}
+
+/**
+ * @param {{replaceWith?: string, onSanitize?: function, dryRun?: boolean}} options
+ * @returns {function}
+ */
+export function middleware(options = {}) {
+  const hasOnSanitize = typeof options.onSanitize === 'function';
+  return function (req, res, next) {
+    ['body', 'params', 'headers', 'query'].forEach(function (key) {
+      if (req[key]) {
+        const { target, isSanitized } = _sanitize(req[key], options);
+        req[key] = target;
+        if (isSanitized && hasOnSanitize) {
+          options.onSanitize({
+            req,
+            key,
+          });
+        }
+      }
+    });
+    next();
+  };
+}

package/src/middlewares/throttle.js

@@ -0,0 +1,33 @@
+export const throttleMiddleware = (bps) => function(req, res, next) {
+    if (bps > 0) {
+        var total = 0;
+        var resume = req.socket.resume;
+
+        // make sure nothing else can resume
+        req.socket.resume = function() {};
+
+        var pulse = setInterval(function() {
+            total = total - bps / 100;
+            if (total < bps) {
+                resume.call(req.socket);
+            }
+        }, 10);
+
+        req.on('data', function(chunk) {
+            total += chunk.length;
+            if (total >= bps) {
+                req.socket.pause();
+            }
+        });
+
+        req.on('end', function() {
+            clearInterval(pulse);
+            // restore resume because socket could be reused
+            req.socket.resume = resume;
+            // future requests need the socket to be flowing
+            req.socket.resume();
+        });
+    }
+
+    next();
+};

package/src/middlewares/timeout.js

@@ -0,0 +1,47 @@
+
+/**
+ * Middleware to set a specific request timeout.
+ * If the timeout is reached, it sends a 408 Request Timeout response.
+ * @param {number} timeoutMs - The timeout in milliseconds.
+ * @returns {function(req, res, next): void}
+ */
+// Fichier: server/src/middlewares/timeout.js (suggestion)
+
+/**
+ * Middleware to set a specific request timeout.
+ * If the timeout is reached, it sends a 408 Request Timeout response.
+ * @param {number} timeoutMs - The timeout in milliseconds.
+ * @returns {function(req, res, next): void}
+ */
+export const setTimeoutMiddleware = (timeoutMs) => {
+    return (req, res, next) => {
+        // Set the timeout for this specific request's socket
+        req.setTimeout(timeoutMs);
+
+        const timeoutHandler = () => {
+            // Check if headers have already been sent
+            if (!res.headersSent) {
+                res.status(408).json({
+                    error: true,
+                    message: `Request Timeout: The server did not receive a complete request message within the time that it was prepared to wait (${timeoutMs}ms).`
+                });
+            }
+            // req.abort() n'est généralement pas nécessaire ici.
+            // La réponse envoyée ci-dessus signale la fin de la requête.
+            // Le serveur gérera la fermeture du socket.
+        };
+
+        const cleanupListeners = () => {
+            req.removeListener('timeout', timeoutHandler);
+        };
+
+        // Assign the timeout handler
+        req.on('timeout', timeoutHandler);
+
+        // Clean up the listener when the response finishes or the connection closes
+        res.on('finish', cleanupListeners);
+        res.on('close', cleanupListeners);
+
+        next();
+    };
+};

package/src/migrate.js

@@ -0,0 +1,216 @@
+// C:/Dev/hackersonline-engine/server/src/migrate.js
+
+import process from "node:process";
+import fs from "node:fs/promises";
+import path from "node:path";
+// FIX: Import 'pathToFileURL' instead of 'fileURLToPath'
+import { pathToFileURL } from 'node:url';
+import { Engine, MongoDatabase } from "./engine.js";
+import { Logger } from "./gameObject.js";
+import { Config } from "./config.js";
+import chalk from "chalk"; // Pour une sortie plus lisible. Assurez-vous que 'chalk' est dans vos dépendances.
+
+// Configuration de base
+Config.Set("modules", ["mongodb"]);
+const MIGRATIONS_DIR = path.resolve(process.cwd(), 'server', 'src', 'migrations');
+const MIGRATIONS_COLLECTION = 'migrations_log';
+
+const engine = Engine.Create();
+const port = process.env.MIGRATE_PORT || 7640;
+
+engine.start(port, async () => {
+    const logger = engine.getComponent(Logger);
+    logger.info("Migration Runner started on port " + port);
+
+    const command = process.argv[2]; // 'up', 'down', 'create', 'status', 'to', 'revert'
+    const target = process.argv[3]; // Le nom du fichier de migration cible
+
+    try {
+        const db = MongoDatabase;
+        const { executedNames, allMigrationFiles } = await getMigrationStatus(db);
+
+        switch (command) {
+            case 'create':
+                if (!target) throw new Error("Please provide a name for the migration.");
+                await createMigrationFile(target, logger);
+                break;
+            case 'status':
+                displayStatus(executedNames, allMigrationFiles, logger);
+                break;
+            case 'up':
+                await runMigrations('up', null, logger, db, executedNames, allMigrationFiles);
+                break;
+            case 'down':
+                // Annule la dernière migration
+                await runMigrations('down', 'last', logger, db, executedNames, allMigrationFiles);
+                break;
+            case 'to':
+                if (!target) throw new Error("Please specify a target migration file for the 'to' command.");
+                await runMigrations('up', target, logger, db, executedNames, allMigrationFiles);
+                break;
+            case 'revert':
+                if (!target) throw new Error("Please specify a target migration file for the 'revert' command. Use '0' to revert all.");
+                await runMigrations('down', target, logger, db, executedNames, allMigrationFiles);
+                break;
+            default:
+                throw new Error(`Unknown command: ${command}. Use 'up', 'down', 'create', 'status', 'to', 'revert'.`);
+        }
+    } catch (error) {
+        logger.error(chalk.red("Migration process failed:"), error.message);
+        if (error.stack) {
+            logger.error(error.stack);
+        }
+        process.exit(1); // Sortir avec un code d'erreur
+    } finally {
+        logger.info("Migration process finished. Shutting down.");
+        process.exit(0);
+    }
+});
+
+async function getMigrationStatus(db) {
+    const migrationLogCollection = db.collection(MIGRATIONS_COLLECTION);
+    const executedMigrations = await migrationLogCollection.find().sort({ name: 1 }).toArray();
+    const executedNames = new Set(executedMigrations.map(m => m.name));
+
+    let allMigrationFiles = [];
+    try {
+        allMigrationFiles = (await fs.readdir(MIGRATIONS_DIR))
+            .filter(file => file.endsWith('.js'))
+            .sort();
+    } catch (e) {
+        if (e.code !== 'ENOENT') throw e;
+        // Le dossier n'existe pas, c'est ok s'il n'y a aucune migration.
+    }
+
+    return { executedNames, allMigrationFiles };
+}
+
+function displayStatus(executedNames, allMigrationFiles, logger) {
+    logger.info(chalk.bold('Migration Status:'));
+    if (allMigrationFiles.length === 0) {
+        logger.info('No migration files found.');
+        return;
+    }
+    allMigrationFiles.forEach(file => {
+        if (executedNames.has(file)) {
+            logger.info(`${chalk.green('[Applied]')} ${file}`);
+        } else {
+            logger.info(`${chalk.yellow('[Pending]')} ${file}`);
+        }
+    });
+}
+
+async function runMigrations(direction, target, logger, db, executedNames, allMigrationFiles) {
+    const migrationLogCollection = db.collection(MIGRATIONS_COLLECTION);
+
+    if (direction === 'up') {
+        let pendingMigrations = allMigrationFiles.filter(file => !executedNames.has(file));
+
+        if (target) {
+            const targetIndex = pendingMigrations.findIndex(file => file.startsWith(target) || file === target);
+            if (targetIndex === -1) {
+                logger.info(`Target migration '${target}' not found or already applied.`);
+                return;
+            }
+            pendingMigrations = pendingMigrations.slice(0, targetIndex + 1);
+        }
+
+        if (pendingMigrations.length === 0) {
+            logger.info(chalk.green("Database is already up to date."));
+            return;
+        }
+
+        logger.info(`Applying ${pendingMigrations.length} new migration(s)...`);
+        for (const fileName of pendingMigrations) {
+            logger.info(`-> ${chalk.cyan('Running UP')}: ${fileName}`);
+            const migrationPath = path.resolve(MIGRATIONS_DIR, fileName);
+            // FIX: Convert the absolute path to a file URL for dynamic import
+            const migration = await import(pathToFileURL(migrationPath).href);
+            await migration.up(db);
+            await migrationLogCollection.insertOne({ name: fileName, executedAt: new Date() });
+            logger.info(`   ${chalk.green('OK')} - ${fileName} applied and logged.`);
+        }
+    }
+
+    if (direction === 'down') {
+        const executedFiles = allMigrationFiles
+            .filter(file => executedNames.has(file))
+            .sort((a, b) => b.localeCompare(a)); // Trier en ordre inverse pour la descente
+
+        if (executedFiles.length === 0) {
+            logger.info(chalk.yellow("No migrations to roll back."));
+            return;
+        }
+
+        let migrationsToRevert;
+
+        if (target === 'last') {
+            migrationsToRevert = [executedFiles[0]]; // Juste la dernière
+        } else if (target === '0') {
+            migrationsToRevert = executedFiles; // Toutes les migrations
+        } else {
+            const targetIndex = executedFiles.findIndex(file => file.startsWith(target) || file === target);
+            if (targetIndex === -1) {
+                logger.info(`Target migration '${target}' not found among applied migrations.`);
+                return;
+            }
+            migrationsToRevert = executedFiles.slice(0, targetIndex);
+        }
+
+        if (!migrationsToRevert || migrationsToRevert.length === 0) {
+            logger.info(chalk.green("Already at the target state. No migrations to revert."));
+            return;
+        }
+
+        logger.info(`Reverting ${migrationsToRevert.length} migration(s)...`);
+        for (const fileName of migrationsToRevert) {
+            logger.info(`-> ${chalk.cyan('Running DOWN')}: ${fileName}`);
+            const migrationPath = path.resolve(MIGRATIONS_DIR, fileName);
+            // FIX: Convert the absolute path to a file URL for dynamic import
+            const migration = await import(pathToFileURL(migrationPath).href);
+            await migration.down(db);
+            await migrationLogCollection.deleteOne({ name: fileName });
+            logger.info(`   ${chalk.green('OK')} - ${fileName} rolled back and removed from log.`);
+        }
+    }
+}
+
+// La fonction createMigrationFile reste la même
+async function createMigrationFile(name, logger) {
+    const timestamp = new Date().toISOString().replace(/[-:.]/g, '').slice(0, 14);
+    const sanitizedName = name.replace(/[^a-z0-9_]/gi, '-').toLowerCase();
+    const fileName = `${timestamp}-${sanitizedName}.js`;
+    const filePath = path.join(MIGRATIONS_DIR, fileName);
+
+    const template = `
+/**
+ * Migration: ${name}
+ * Created at: ${new Date().toISOString()}
+ */
+import { Db } from 'mongodb';
+
+/**
+ * La fonction 'up' est exécutée pour appliquer la migration.
+ * @param {Db} db - L'instance de la base de données MongoDB.
+ */
+export const up = async (db) => {
+  // Votre logique de migration ici. Exemple :
+  // await db.collection('users').updateMany({}, { $set: { newField: 'defaultValue' } });
+  console.log("Migration UP: ${fileName}");
+};
+
+/**
+ * La fonction 'down' est exécutée pour annuler la migration.
+ * @param {Db} db - L'instance de la base de données MongoDB.
+ */
+export const down = async (db) => {
+  // Votre logique pour annuler la migration ici. Exemple :
+  // await db.collection('users').updateMany({}, { $unset: { newField: '' } });
+  console.log("Migration DOWN: ${fileName}");
+};
+`;
+
+    await fs.mkdir(MIGRATIONS_DIR, { recursive: true });
+    await fs.writeFile(filePath, template.trim());
+    logger.info(`Created migration file: ${chalk.magenta(filePath)}`);
+}

package/src/migrations/20240522143000-content.js

@@ -0,0 +1,20 @@
+/**
+ * Migration: setting content field to 'fr' in 'content' model
+ * Created at: 2024-05-21T10:00:00.000Z
+ */
+
+export const up = async (db) => {
+    const datasCollection = db.collection("datas");
+    const content = await datasCollection.find({ _model:"content"}).toArray();
+    await Promise.all(content.map(async (doc) => {
+        if (typeof(doc.html)==='string') {
+            const c = { "fr" : doc.html };
+            await datasCollection.updateOne({_id: doc._id}, {$set: {html: c}});
+        }
+    }));
+    console.log("Migration UP: setting content field to 'fr' in 'content' model");
+};
+
+export const down = async (db) => {
+    console.log("Migration DOWN: noting to do");
+};