data-primals-engine 1.5.1 → 1.5.2

package/src/engine.js

@@ -20,7 +20,7 @@ import sirv from "sirv";
 import * as tls from "node:tls";
 import {Event} from "./events.js";
 import path from "node:path";
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import {validateModelStructure} from "./modules/data/data.validation.js";
 import { setSafeRegex } from "./filter.js";
 import safeRegexCallback from "safe-regex";
@@ -106,6 +106,9 @@ export const Engine = {
         console.log("Creating engine", Config.Get('modules'));
         const logger = engine.addComponent(Logger);
 
+        // Expose the Event bus on the engine instance for dependency injection
+        engine.Event = Event;
+
         engine.userProvider = new DefaultUserProvider(engine);
 
         engine.setUserProvider = (providerInstance) => {
@@ -157,56 +160,93 @@ export const Engine = {
             return engine._modules.find(m => m.module === module);
         };
 
-        const importModule = async (module) => {
-            const moduleA = await import(module);
-            if (moduleA.onInit){
-                await moduleA.onInit(engine);
-                return {...moduleA, module};
-            }else {
-                const mod = moduleA.default();
-                await mod?.onInit(engine);
-                return { ...mod, module};
+        const importAndPrepareModule = async (moduleEntryPoint, moduleName) => {
+            const moduleA = await import(moduleEntryPoint);
+
+            let moduleInstance = null;
+            let onInitFunction = null;
+
+            // Cas 1: `export default { onInit }`
+            if (moduleA.default && typeof moduleA.default.onInit === 'function') {
+                moduleInstance = moduleA.default;
+                onInitFunction = moduleA.default.onInit;
             }
+            // Cas 2: `export async function onInit() {}`
+            else if (typeof moduleA.onInit === 'function') {
+                moduleInstance = moduleA;
+                onInitFunction = moduleA.onInit;
+            }
+
+            if (moduleInstance) {
+                // On stocke la fonction onInit pour plus tard et on retourne l'instance
+                // avec le nom court du module.
+                return { ...moduleInstance, onInit: onInitFunction, module: moduleName };
+            }
+
+            logger.warn(`Module loaded from ${moduleEntryPoint} does not export an onInit function or a default object with onInit.`);
+            return null;
         };
 
         engine._modules = [];
-        for (const moduleIdentifier of Config.Get('modules', [])) {
-            try {
-                let moduleDir;
-                const moduleName = path.basename(moduleIdentifier);
-
-                const directPath = path.resolve(moduleIdentifier);
-                let isDir = fs.existsSync(directPath) && fs.statSync(directPath).isDirectory();
 
-                if (isDir) {
-                    moduleDir = directPath;
+        // On charge uniquement les modules spécifiés dans la configuration.
+        const allModules = Config.Get('modules', []);
+        const loadedModules = []; // Liste temporaire pour la phase 1
+        for (const moduleIdentifier of allModules) {
+            let moduleEntryPoint = null;
+            const moduleName = path.basename(moduleIdentifier, '.js');
+            try {
+                // 1. Tenter de résoudre comme un chemin (relatif au projet ou absolu)
+                const externalPath = path.resolve(process.cwd(), moduleIdentifier);
+                if (fs.existsSync(externalPath)) {
+                    const stats = fs.statSync(externalPath);
+                    if (stats.isDirectory()) {
+                        // C'est un répertoire, on cherche le point d'entrée
+                        const indexJsPath = path.join(externalPath, 'index.js');
+                        const moduleJsPath = path.join(externalPath, `${moduleName}.js`);
+                        if (fs.existsSync(indexJsPath)) moduleEntryPoint = pathToFileURL(indexJsPath).href;
+                        else if (fs.existsSync(moduleJsPath)) moduleEntryPoint = pathToFileURL(moduleJsPath).href;
+                    } else {
+                        // C'est un fichier
+                        moduleEntryPoint = pathToFileURL(externalPath).href;
+                    }
                 } else {
-                    moduleDir = path.resolve(__dirname, 'modules', moduleIdentifier);
-                }
-
-                let moduleEntryPoint;
-                const jsPath = moduleDir + '.js';
-                const indexJsPath = path.join(moduleDir, 'index.js');
-                const moduleJsPath = path.join(moduleDir, `${moduleName}.js`);
-
-                if (fs.existsSync(jsPath)) {
-                    moduleEntryPoint = 'file://' + jsPath;
-                } else if (fs.existsSync(indexJsPath)) {
-                    moduleEntryPoint = 'file://' + indexJsPath;
-                } else if (fs.existsSync(moduleJsPath)) {
-                    moduleEntryPoint = 'file://' + moduleJsPath;
+                    // 2. Si ce n'est pas un chemin, tenter de résoudre comme un module interne
+                    const internalDir = path.resolve(__dirname, 'modules', moduleIdentifier);
+                    const internalFile = path.resolve(__dirname, 'modules', `${moduleIdentifier}.js`);
+
+                    if (fs.existsSync(internalDir) && fs.statSync(internalDir).isDirectory()) {
+                        // C'est un répertoire de module interne
+                        const indexJsPath = path.join(internalDir, 'index.js');
+                        const moduleJsPath = path.join(internalDir, `${moduleIdentifier}.js`);
+                        if (fs.existsSync(indexJsPath)) moduleEntryPoint = pathToFileURL(indexJsPath).href;
+                        else if (fs.existsSync(moduleJsPath)) moduleEntryPoint = pathToFileURL(moduleJsPath).href;
+                    } else if (fs.existsSync(internalFile)) {
+                        // C'est un fichier de module interne
+                        moduleEntryPoint = pathToFileURL(internalFile).href;
+                    }
                 }
 
                 if (moduleEntryPoint) {
-                    const loadedModule = await importModule(moduleEntryPoint);
+                    const loadedModule = await importAndPrepareModule(moduleEntryPoint, moduleName);
                     if (loadedModule) {
-                        engine._modules.push(loadedModule);
+                        loadedModules.push(loadedModule);
                     }
                 } else {
-                    logger.warn(`Aucun point d'entrée trouvé pour le module '${moduleIdentifier}'.`);
+                    logger.warn(`Could not resolve or find an entry point for module '${moduleIdentifier}'.`);
                 }
             } catch (e) {
-                logger.error(`Could not load module '${moduleIdentifier}':`, e.stack);
+                logger.error(`Could not load module '${moduleName}' (${moduleIdentifier}):`, e.stack);
+            }
+        }
+
+        // Phase 2: Enregistrer et Initialiser tous les modules chargés
+        engine._modules = loadedModules; // On enregistre tous les modules dans le moteur
+        for (const moduleInstance of engine._modules) {
+            if (typeof moduleInstance.onInit === 'function') {
+                logger.info(`Initializing module '${moduleInstance.module}'...`);
+                await moduleInstance.onInit(engine);
+                logger.info(`Module '${moduleInstance.module}' loaded and initialized.`);
             }
         }
 
@@ -239,10 +279,12 @@ export const Engine = {
                 });
             });
 
-            app.use(sirv('client/dist', {
-                single: true,
-                dev: process.env.NODE_ENV === 'development'
-            }));
+            if( fs.existsSync('client/dist') ){
+                app.use(sirv('client/dist', {
+                    single: true,
+                    dev: process.env.NODE_ENV === 'development'
+                }));
+            }
 
             process.on('uncaughtException', function (exception) {
                 console.error(exception);
@@ -277,9 +319,9 @@ export const Engine = {
                     model.locked = true;
                     const r = await createModel(model);
                     dbModels.push({...model, _id: r.insertedId });
-                    logger.info('Model inserted (' + model.name + ')');
+                    logger.info(`Model ${model.name} inserted.`);
                 }else
-                    logger.info('Model loaded (' + model.name + ')');
+                    logger.info(`Model ${model.name} loaded`);
             }
             logger.info("All models loaded.");
             await Event.Trigger("OnModelsLoaded", "event", "system", engine, dbModels);

package/src/events.js

@@ -1,113 +1,137 @@
-import {safeAssignObject} from "./core.js";
-
-const events = {};
-
-const eventLayerSystems = {
-    "priority": ["high", "medium", "low"],
-    "log": ["info", "debug", "warn", "error", "critical"],
-    "system": ["calls", "users"],
-    "event": ["system","user"],
-    "custom": ["data"]
-};
-
-
-
-export const Event = {
-    Trigger: async (name, system = "priority", layer = "medium", ...args) => {  // Ajout des arguments system et layer
-        if (!name || typeof name !== 'string') {
-            throw new Error('Event name must be a non-empty string');
-        }
-
-        if (!events[system] || !events[system][name] || (layer && !events[system][name][layer])) {
-            //console.warn(`No trigger found for ${name} in system ${system} layer ${layer}`);
-            return null;
-        }
-
-        const systemsToProcess = system ? [system] : Object.keys(events); // Si system est spécifié, on cible ce système uniquement, sinon tous les systèmes
-        console.log(`[Event] Triggering ${system}.${layer}.${name}`, {
-            callbacks: events[system]?.[name]?.[layer]?.length || 0
-        });
-        let ret = null;
-        for (const currentSystem of systemsToProcess) {
-            if (events[currentSystem] && events[currentSystem][name]) {
-                const layersToProcess = layer ? [layer] : eventLayerSystems[currentSystem] || Object.keys(events[currentSystem][name]); // Si layer est spécifié, on cible cette couche, sinon toutes les couches ou celles définies dans eventLayerSystems
-
-                if (layersToProcess) {
-                    for (const currentLayer of layersToProcess) {
-                        if (events[currentSystem][name][currentLayer]) {
-                            for (const callback of events[currentSystem][name][currentLayer]) {
-                                try {
-                                    const res = await callback(...args);
-                                    if (typeof res === "object" && !Array.isArray(res)) {
-                                        if (typeof ret !== "object") ret = {};
-                                        ret = {...ret, ...res};
-                                    } else if (Array.isArray(res)) {
-                                        if (!ret || !Array.isArray(ret)) ret = [];
-                                        ret = ret.concat(res);
-                                    } else if (typeof res === "string") {
-                                        if (typeof ret !== "string") ret = "";
-                                        ret += res;
-                                    } else if (typeof res === "number") {
-                                        if (typeof ret !== "number") ret = 0;
-                                        ret += res;
-                                    } else if (typeof res === "boolean") {
-                                        if (typeof ret !== "boolean") ret = true;
-                                        ret = res && ret;
-                                    } else {
-                                        ret = res || ret;
-                                    }
-                                } catch (error) {
-                                    const errorMsg = `Error in callback for event ${name} in system ${currentSystem} layer ${currentLayer}: ${error.message}`;
-                                    const newError = new Error(errorMsg);
-                                    newError.originalError = error; // Conserve l'erreur originale
-                                    newError.eventDetails = { name, system: currentSystem, layer: currentLayer };
-                                    throw newError;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return ret;
-    },
-    Listen: (name = "", callback, system = "priority", layer = "medium") => {
-        const validSystems = Object.keys(eventLayerSystems); // Récupération des clés pour une vérification plus performante
-        if (!validSystems.includes(system)) {
-            throw new Error(`System '${system}' does not exist. Valid systems are: ${validSystems.join(', ')}`); // Message d'erreur plus informatif
-        }
-
-        const validLayers = eventLayerSystems[system]; // Récupération des couches valides pour le système
-        if (!validLayers.includes(layer)) {
-            throw new Error(`Layer '${layer}' does not exist in system '${system}'. Valid layers are: ${validLayers.join(', ')}`); // Message d'erreur plus informatif
-        }
-
-        safeAssignObject(events, system, events[system] || {}); // Simplification de la création des objets
-        safeAssignObject(events[system], name, events[system][name] || {});
-        safeAssignObject(events[system][name], layer, events[system][name][layer] || []);
-        events[system][name][layer].push(callback);
-    },
-    RemoveCallback: (name, callback, layer="medium", system='priority') => {
-        if (!events[system] || !events[system][name] || !events[system][name][layer]) {
-            return; // Si l'événement, le système ou la couche n'existent pas, on ne fait rien
-        }
-
-        const index = events[system][name][layer].indexOf(callback);
-        if (index > -1) {
-            events[system][name][layer].splice(index, 1);
-        }
-    },
-    // Ajout d'une méthode pour supprimer tous les callbacks d'un événement (optionnel)
-    RemoveAllCallbacks: (name, system = 'priority') => {
-        if (events[system] && events[system][name]) {
-            delete events[system][name]; // Supprime l'objet contenant les couches et les callbacks
-        }
-    },
-
-    // Ajout d'une méthode pour supprimer tous les callbacks d'un système (optionnel)
-    RemoveSystemCallbacks: (system) => {
-        if (events[system]) {
-            delete events[system];
-        }
-    }
-}
+import {safeAssignObject} from "./core.js";
+
+const events = {};
+
+const eventLayerSystems = {
+    "priority": ["high", "medium", "low"],
+    "log": ["info", "debug", "warn", "error", "critical"],
+    "system": ["calls", "users"],
+    "event": ["system","user"],
+    "custom": ["data"]
+};
+
+
+
+export const Event = {
+    Trigger: async (name, system = "priority", layer = "medium", ...args) => {  // Ajout des arguments system et layer
+        if (!name || typeof name !== 'string') {
+            throw new Error('Event name must be a non-empty string');
+        }
+
+        if (!events[system] || !events[system][name] || (layer && !events[system][name][layer])) {
+            //console.warn(`No trigger found for ${name} in system ${system} layer ${layer}`);
+            return null;
+        }
+
+        const systemsToProcess = system ? [system] : Object.keys(events); // Si system est spécifié, on cible ce système uniquement, sinon tous les systèmes
+        console.log(`[Event] Triggering ${system}.${layer}.${name}`, {
+            callbacks: events[system]?.[name]?.[layer]?.length || 0
+        });
+        let ret = null;
+        for (const currentSystem of systemsToProcess) {
+            if (events[currentSystem] && events[currentSystem][name]) {
+                const layersToProcess = layer ? [layer] : eventLayerSystems[currentSystem] || Object.keys(events[currentSystem][name]); // Si layer est spécifié, on cible cette couche, sinon toutes les couches ou celles définies dans eventLayerSystems
+
+                if (layersToProcess) {
+                    for (const currentLayer of layersToProcess) {
+                        if (events[currentSystem][name][currentLayer]) {
+                            for (const callback of events[currentSystem][name][currentLayer]) {
+                                try {
+                                    const res = await callback(...args);
+                                    if (typeof res === "object" && !Array.isArray(res)) {
+                                        if (typeof ret !== "object") ret = {};
+                                        ret = {...ret, ...res};
+                                    } else if (Array.isArray(res)) {
+                                        if (!ret || !Array.isArray(ret)) ret = [];
+                                        ret = ret.concat(res);
+                                    } else if (typeof res === "string") {
+                                        if (typeof ret !== "string") ret = "";
+                                        ret += res;
+                                    } else if (typeof res === "number") {
+                                        if (typeof ret !== "number") ret = 0;
+                                        ret += res;
+                                    } else if (typeof res === "boolean") {
+                                        if (typeof ret !== "boolean") ret = true;
+                                        ret = res && ret;
+                                    } else {
+                                        ret = res || ret;
+                                    }
+                                } catch (error) {
+                                    const errorMsg = `Error in callback for event ${name} in system ${currentSystem} layer ${currentLayer}: ${error.message}`;
+                                    const newError = new Error(errorMsg);
+                                    newError.originalError = error; // Conserve l'erreur originale
+                                    newError.eventDetails = { name, system: currentSystem, layer: currentLayer };
+                                    throw newError;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return ret;
+    },
+    Listen: (name = "", callback, system = "priority", layer = "medium") => {
+        const validSystems = Object.keys(eventLayerSystems); // Récupération des clés pour une vérification plus performante
+        if (!validSystems.includes(system)) {
+            throw new Error(`System '${system}' does not exist. Valid systems are: ${validSystems.join(', ')}`); // Message d'erreur plus informatif
+        }
+
+        const validLayers = eventLayerSystems[system]; // Récupération des couches valides pour le système
+        if (!validLayers.includes(layer)) {
+            throw new Error(`Layer '${layer}' does not exist in system '${system}'. Valid layers are: ${validLayers.join(', ')}`); // Message d'erreur plus informatif
+        }
+
+        safeAssignObject(events, system, events[system] || {}); // Simplification de la création des objets
+        safeAssignObject(events[system], name, events[system][name] || {});
+        safeAssignObject(events[system][name], layer, events[system][name][layer] || []);
+        events[system][name][layer].push(callback);
+    },
+    addSystem: (system) => {
+        if (typeof system !== 'string' || system.trim() === '') {
+            throw new Error('Le nom du système doit être une chaîne de caractères non vide.');
+        }
+        if (!eventLayerSystems.hasOwnProperty(system)) {
+            eventLayerSystems[system] = [];
+        } else {
+            console.warn(`[Event] Le système '${system}' existe déjà.`);
+        }
+    },
+    addLayer: (system, layer) => {
+        if (typeof system !== 'string' || system.trim() === '') {
+            throw new Error('Le nom du système doit être une chaîne de caractères non vide.');
+        }
+        if (typeof layer !== 'string' || layer.trim() === '') {
+            throw new Error('Le nom de la couche doit être une chaîne de caractères non vide.');
+        }
+        if (!eventLayerSystems.hasOwnProperty(system)) {
+            throw new Error(`Le système '${system}' n'existe pas. Veuillez l'ajouter avec addSystem('${system}').`);
+        }
+        if (!eventLayerSystems[system].includes(layer)) {
+            eventLayerSystems[system].push(layer);
+        }
+    },
+    RemoveCallback: (name, callback, layer="medium", system='priority') => {
+        if (!events[system] || !events[system][name] || !events[system][name][layer]) {
+            return; // Si l'événement, le système ou la couche n'existent pas, on ne fait rien
+        }
+
+        const index = events[system][name][layer].indexOf(callback);
+        if (index > -1) {
+            events[system][name][layer].splice(index, 1);
+        }
+    },
+    // Ajout d'une méthode pour supprimer tous les callbacks d'un événement (optionnel)
+    RemoveAllCallbacks: (name, system = 'priority') => {
+        if (events[system] && events[system][name]) {
+            delete events[system][name]; // Supprime l'objet contenant les couches et les callbacks
+        }
+    },
+
+    // Ajout d'une méthode pour supprimer tous les callbacks d'un système (optionnel)
+    RemoveSystemCallbacks: (system) => {
+        if (events[system]) {
+            delete events[system];
+        }
+    }
+}

package/src/index.js

@@ -5,6 +5,9 @@ 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 { Event } from './events.js';
+
+export { sendSseToUser } from './modules/data/data.routes.js';
 
 export { UserProvider } from './providers.js';