data-primals-engine 1.7.2 → 1.7.3

package/src/email.js

@@ -1,155 +1,158 @@
-import process from "node:process";
-import nodemailer from "nodemailer";
-import juice from "juice";
-import {Event} from "./events.js";
-import {emailDefaultConfig} from "./constants.js";
-import {Config} from "./config.js";
-
-// Le transporteur par défaut, utilisé si aucune config spécifique n'est fournie.
-const defaultTransporter = nodemailer.createTransport({
-    host: process.env.SMTP_HOST,
-    port: process.env.SMTP_PORT || 587,
-    secure: false,
-    auth: {
-        user: process.env.SMTP_USER,
-        pass: process.env.SMTP_PASS
-    }
-});
-
-/**
- * Crn * @param {object} smtpConfig - L'objet de configuration SMTP.
- * @returns {import('nodemailer').Transporter} Un transporteur Nodemailer.
- */
-const createTransporter = (smtpConfig) => {
-    // Valider que les informations de base sont présentes
-    if (!smtpConfig.host || !smtpConfig.port || !smtpConfig.user || !smtpConfig.pass){
-        throw new Error("SMTP configuration incomplete ('SMTP_HOST', 'SMTP_PORT','SMTP_USER', and 'SMTP_PASS' keys need to be completed in env').");
-    }
-    return nodemailer.createTransport({
-        host: smtpConfig.host,
-        port: parseInt(smtpConfig.port, 10),
-        secure: smtpConfig.secure === true, // Par défaut à false si non défini
-        auth: {
-            user: smtpConfig.user,
-            pass: smtpConfig.pass
-        }
-    });
-};
-
-
-/**
- * Envoie un email en utilisant une configuration SMTP spécifique ou celle par défaut.
- * @param {string|string[]} email - Le ou les destinataires.
- * @param {object} data - Les données de l'email (title, content).
- * @param {object|null} smtpConfig - La configuration SMTP à utiliser. Si null, utilise la configuration par défaut.
- * @param {string} lang - La langue pour le template.
- * @param {string|null} tpl - Le template HTML à utiliser.
- */
-export const sendEmail = async (email = "", data, smtpConfig = null, lang, tpl = null) => {
-
-    const cfg = Config.Get('emailDefaultConfig', emailDefaultConfig);
-    const contactEmail = smtpConfig ? (smtpConfig.from || cfg.from) :"Our company <noreply@ourdomain.tld>";
-    const emails = Array.isArray(email) ? email : [email];
-    if (emails.length === 0) return false;
-
-    // Choisir le transporteur à utiliser
-    const transporter = smtpConfig ? createTransporter(smtpConfig||cfg) : defaultTransporter;
-
-    if (tpl === null) tpl = await Event.Trigger("OnEmailTemplate", "event", "system", data, lang);
-    let html = tpl;
-    try {
-        html = juice(tpl);
-    } catch (e) {
-        console.error("Erreur lors de l'inlining du CSS de l'email :", e);
-    }
-
-    // Utiliser Promise.all pour gérer les envois de manière asynchrone
-    const sendPromises = emails.map((e) => {
-        const mailOptions = {
-            from: contactEmail,
-            to: e,
-            subject: data.title,
-            html
-        };
-        return transporter.sendMail(mailOptions);
-    });
-
-    try {
-        await Promise.all(sendPromises);
-        console.log(`Email(s) sent successfully to : ${emails.join(', ')}`);
-        return true;
-    } catch (error) {
-        console.error("Error when sending to one ore more emails :", error);
-        // Vous pouvez relancer l'erreur si vous voulez que l'appelant la gère
-        throw error;
-    }
-};
-
-export const etag = (name, attrs, content = "") => {
-    return (
-        "<" +
-        name +
-        " " +
-        Object.keys(attrs)
-            .map((m) => m + '="' + attrs[m] + '" ')
-            .join("")
-            .trim() +
-        ">" +
-        content +
-        "</" +
-        name +
-        ">"
-    );
-};
-
-export const ebutton = (content = "", attrs = {}, style = {}) => {
-    return etable(
-        erow(
-            '<a href="' +
-            attrs["href"] +
-            '" style="' +
-            estyle(style) +
-            '">' +
-            content +
-            "</a>"
-        )
-    );
-};
-
-export const etable = (content = "", style = {}) => {
-    return (
-        '<table border="0" cellPadding="0" cellSpacing="0" style="border-collapse: separate; mso-table-lspace: 0pt; mso-table-rspace: 0pt; box-sizing: border-box; ' +
-        (style.width === "100%" ? "min-width: 100%;" : "") +
-        " !important; " +
-        estyle(style) +
-        '" width="' +
-        (style.width || "100%") +
-        '">' +
-        content +
-        "</table>"
-    );
-};
-
-export const erow = (content = "", style = {}) => {
-    const contents = !Array.isArray(content) ? [content] : content;
-    return (
-        "<tr>" +
-        contents
-            .map(
-                (c) =>
-                    '<td align="center" style="' +
-                    estyle(style) +
-                    '" valign="top">' +
-                    c +
-                    "</td>"
-            )
-            .join("") +
-        "</tr>"
-    );
-};
-
-export const estyle = (options) => {
-    return Object.keys(options)
-        .map((m) => m + ": " + options[m] + ";")
-        .join("");
+import nodemailer from "nodemailer";
+import juice from "juice";
+import {Event} from "./events.js";
+import {emailDefaultConfig} from "./constants.js";
+import {Config} from "./config.js";
+import i18n from "./i18n.js";
+import {websiteTranslations} from "../client/src/translations.js";
+import i18next from "i18next";
+
+/**
+ * Crn * @param {object} smtpConfig - L'objet de configuration SMTP.
+ * @returns {import('nodemailer').Transporter} Un transporteur Nodemailer.
+ */
+const createTransporter = (smtpConfig) => {
+    // Valider que les informations de base sont présentes
+    if (!smtpConfig.host || !smtpConfig.port || !smtpConfig.user || !smtpConfig.pass){
+        throw new Error("SMTP configuration incomplete ('SMTP_HOST', 'SMTP_PORT','SMTP_USER', and 'SMTP_PASS' keys need to be completed in env').");
+    }
+    return nodemailer.createTransport({
+        host: smtpConfig.host,
+        port: parseInt(smtpConfig.port, 10),
+        secure: smtpConfig.secure === true, // Par défaut à false si non défini
+        auth: {
+            user: smtpConfig.user,
+            pass: smtpConfig.pass
+        }
+    });
+};
+
+
+
+export  const changeLanguage = async (lang) => {
+    // --- NOUVELLE LOGIQUE DE GESTION DE LANGUE ---
+    await i18n.changeLanguage(lang, (err) => {
+        if (err) return console.error('something went wrong loading', err);
+        const trs = {...websiteTranslations[lang]?.['translation']};
+        i18next.addResourceBundle(lang, 'translation', trs, true);
+    });
+}
+
+/**
+ * Envoie un email en utilisant une configuration SMTP spécifique ou celle par défaut.
+ * @param {string|string[]} email - Le ou les destinataires.
+ * @param {object} data - Les données de l'email (title, content).
+ * @param {object|null} smtpConfig - La configuration SMTP à utiliser. Si null, utilise la configuration par défaut.
+ * @param {string} lang - La langue pour le template.
+ * @param {string|null} tpl - Le template HTML à utiliser.
+ */
+export const sendEmail = async (email = "", data, smtpConfig = null, lang, tpl = null) => {
+
+    const cfg = Config.Get('emailDefaultConfig', emailDefaultConfig);
+    const contactEmail = smtpConfig ? (smtpConfig.from || cfg.from) :"Our company <noreply@ourdomain.tld>";
+    const emails = Array.isArray(email) ? email : [email];
+    if (emails.length === 0) return false;
+
+    // Choisir le transporteur à utiliser
+    const transporter = createTransporter(smtpConfig || cfg); // Always create transporter dynamically
+
+    if (tpl === null) tpl = await Event.Trigger("OnEmailTemplate", "event", "system", data, lang);
+    let html = tpl;
+    try {
+        html = juice(tpl);
+    } catch (e) {
+        console.error("Erreur lors de l'inlining du CSS de l'email :", e);
+    }
+
+    // Utiliser Promise.all pour gérer les envois de manière asynchrone
+    const sendPromises = emails.map((e) => {
+        const mailOptions = {
+            from: contactEmail,
+            to: e,
+            subject: data.title,
+            html
+        };
+        return transporter.sendMail(mailOptions);
+    });
+
+    try {
+        await Promise.all(sendPromises);
+        console.log(`Email(s) sent successfully to : ${emails.join(', ')}`);
+        return true;
+    } catch (error) {
+        console.error("Error when sending to one ore more emails :", error);
+        // Vous pouvez relancer l'erreur si vous voulez que l'appelant la gère
+        throw error;
+    } finally {
+
+    }
+};
+
+export const etag = (name, attrs, content = "") => {
+    return (
+        "<" +
+        name +
+        " " +
+        Object.keys(attrs)
+            .map((m) => m + '="' + attrs[m] + '" ')
+            .join("")
+            .trim() +
+        ">" +
+        content +
+        "</" +
+        name +
+        ">"
+    );
+};
+
+export const ebutton = (content = "", attrs = {}, style = {}) => {
+    return etable(
+        erow(
+            '<a href="' +
+            attrs["href"] +
+            '" style="' +
+            estyle(style) +
+            '">' +
+            content +
+            "</a>"
+        )
+    );
+};
+
+export const etable = (content = "", style = {}) => {
+    return (
+        '<table border="0" cellPadding="0" cellSpacing="0" style="border-collapse: separate; mso-table-lspace: 0pt; mso-table-rspace: 0pt; box-sizing: border-box; ' +
+        (style.width === "100%" ? "min-width: 100%;" : "") +
+        " !important; " +
+        estyle(style) +
+        '" width="' +
+        (style.width || "100%") +
+        '">' +
+        content +
+        "</table>"
+    );
+};
+
+export const erow = (content = "", style = {}) => {
+    const contents = !Array.isArray(content) ? [content] : content;
+    return (
+        "<tr>" +
+        contents
+            .map(
+                (c) =>
+                    '<td align="center" style="' +
+                    estyle(style) +
+                    '" valign="top">' +
+                    c +
+                    "</td>"
+            )
+            .join("") +
+        "</tr>"
+    );
+};
+
+export const estyle = (options) => {
+    return Object.keys(options)
+        .map((m) => m + ": " + options[m] + ";")
+        .join("");
 };

package/src/engine.js

@@ -172,6 +172,111 @@ export const Engine = {
             return engine._modules.find(m => m.module === module);
         };
 
+        /**
+         * Envoie une requête à un pair spécifique du cluster.
+         * Cette fonction gère la recherche du pair, la construction de l'URL,
+         * et l'ajout du header 'X-Target-Peer-Id' nécessaire pour le reverse proxy.
+         * @param {string} peerId - L'ID du pair cible (ex: "vox-main-1").
+         * @param {string} path - Le chemin de l'API à appeler sur le pair (ex: "/api/internal/replicate").
+         * @param {object} payload - Le corps de la requête (sera converti en JSON).
+         * @param {object} [options={}] - Options supplémentaires pour la requête fetch (method, headers, etc.).
+         * @returns {Promise<Response>} La promesse retournée par fetch.
+         */
+        engine.sendToPeer = async (peerId, path, payload, options = {}) => {
+            const targetPeer = engine.peers.find(p => p.id === peerId);
+
+            if (!targetPeer) {
+                const errorMessage = `[sendToPeer] Cannot send request: Peer '${peerId}' is not in the list of online peers.`;
+                logger.error(errorMessage);
+                return Promise.reject(new Error(errorMessage));
+            }
+
+            // Utilise le protocole défini dans les données du pair, ou https par défaut.
+            const protocol = targetPeer.protocol || 'https';
+            const apiPath = path.startsWith('/') ? path : `/${path}`;
+            const url = `${protocol}://${targetPeer.public_domain}${apiPath}`;
+
+            const fetchOptions = {
+                method: 'POST', // POST par défaut
+                ...options,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Target-Peer-Id': peerId, // Le header crucial pour le routage
+                    ...(options.headers || {})
+                },
+                body: JSON.stringify(payload)
+            };
+
+            try {
+                logger.info(`[sendToPeer] Sending request to peer '${peerId}' at ${url}`);
+                return await fetch(url, fetchOptions);
+            } catch (error) {
+                logger.error(`[sendToPeer] Network error while sending to peer '${peerId}':`, error.message);
+                throw error; // Relancer l'erreur pour que l'appelant puisse la gérer
+            }
+        };
+
+        engine.peers = []; // Initialise la liste des pairs
+
+        const discoverPeers = async () => {
+            const endpoint = process.env.PEERS_ENDPOINT;
+            if (!endpoint) {
+                logger.info("PEERS_ENDPOINT not set. Skipping peer discovery.");
+                return;
+            }
+
+            try {
+                logger.info(`Discovering peers from ${endpoint}...`);
+                // Ajout d'un AbortController pour gérer le timeout
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 30000); // Timeout de 30 secondes
+
+                const response = await fetch(endpoint, { signal: controller.signal });
+                clearTimeout(timeoutId); // Annuler le timeout si la requête réussit
+
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch peers: ${response.status} ${response.statusText}`);
+                }
+                const data = await response.json(); // Parser en JSON
+
+                if (!data || !Array.isArray(data.peers)) { // Valider la structure
+                    throw new Error("Invalid peer discovery response: 'peers' array not found.");
+                }
+
+                const allOnlinePeers = data.peers.filter(p => (p.status === 'online' || p.public_domain.startsWith(process.env.PEER_DOMAIN)));
+
+                // --- NOUVELLE LOGIQUE DE FILTRAGE PAR PRÉFIXE ---
+                // On se base sur le nom de domaine public de l'instance pour plus de robustesse.
+                if (process.env.PEER_DOMAIN) {
+                    engine.selfUrl = process.env.PEER_DOMAIN;
+                    const selfHostname = process.env.PEER_DOMAIN; // ex: data-api-shard-1.primals.net
+                    logger.info(`[Cluster] Self hostname identified as '${selfHostname}'.`);
+                    // --- CORRECTION DE LA LOGIQUE DE PRÉFIXE ---
+                    // Extrait le préfixe du nom de domaine (ex: "data-api-shard" de "data-api-shard-1.primals.net" ou "data" de "data.primals.net")
+                    // La regex capture tout jusqu'au premier point.
+                    const selfPrefixMatch = selfHostname.match(/^([^.]+)/);
+                    if (selfPrefixMatch) {
+                        const selfPrefix = selfPrefixMatch[1].replace(/-[0-9]+$/, ''); // Supprime le suffixe numérique s'il existe
+                        logger.info(`[Cluster] Detected prefix: '${selfPrefix}'. Filtering peers...`);
+
+                        // Ne garder que les pairs qui ont le même préfixe
+                        engine.peers = allOnlinePeers.filter(p => {
+                            return (p.public_domain || '').startsWith(selfPrefix);
+                        });
+                    } else {
+                        engine.peers = allOnlinePeers; // Pas de préfixe, on garde tout
+                    }
+                } else {
+                    engine.peers = allOnlinePeers; // Pas de selfUrl, on garde tout pour éviter une erreur
+                }
+
+                logger.info(`[Cluster] Final peer list: [${engine.peers.map(p => p.id).join(', ')}]`);
+            } catch (error) {
+                logger.error(`Could not discover peers from endpoint ${endpoint}:`, error.message);
+                engine.peers = []; // En cas d'erreur, on s'assure que la liste est vide.
+            }
+        };
+
         const importAndPrepareModule = async (moduleEntryPoint, moduleName) => {
             const moduleA = await import(moduleEntryPoint);
 
@@ -273,27 +378,30 @@ export const Engine = {
             // Start http server
             server = http.createServer(app);
 
+            await discoverPeers();
+
             // Server Timeout Settings
             server.timeout = 120000;
             server.headersTimeout = 20000;
             server.requestTimeout = 30000;
             server.keepAliveTimeout = 5000;
-
             server.listen(port);
 
             await setupInitialModels();
             await installAllPacks();
 
-            if (cb)
-                await cb();
-
             engine.get('/api/health', (req, res) => {
                 res.status(200).json({
                     status: 'ok',
                     timestamp: new Date().toISOString()
                 });
             });
-
+            
+            // --- CORRECTION DE L'ORDRE DES MIDDLEWARES ---
+            // Les routes API doivent être enregistrées AVANT le serveur de fichiers statiques.
+            await Event.Trigger("OnServerStart", "event", "system", engine);
+            
+            // Le serveur de fichiers statiques doit être le DERNIER middleware "catch-all".
             if( fs.existsSync('client/dist') ){
                 app.use(sirv('client/dist', {
                     single: true,
@@ -301,6 +409,10 @@ export const Engine = {
                 }));
             }
 
+            if (cb) {
+                await cb();
+            }
+
             process.on('uncaughtException', function (exception) {
                 console.error(exception);
                 fs.appendFile('issues.txt', JSON.stringify({ code: exception.code, message: exception.message, stack: exception.stack }), function (err) {
@@ -310,8 +422,6 @@ export const Engine = {
                 });
                 process.exit(1);
             });
-
-            await Event.Trigger("OnServerStart", "event", "system", engine);
         }
 
         engine.stop = async () => {

package/src/gameObject.js

@@ -48,6 +48,12 @@ export class Behaviour {
         // Logique de nettoyage du comportement
     }
 }
+export class DataHandler extends Behaviour {
+    constructor(gameObject) {
+        super(gameObject);
+    }
+}
+
 // MovableBehavior.js
 export class MovableBehaviour extends Behaviour {
     constructor(gameObject, speed = 5) {

package/src/i18n.js

@@ -328,7 +328,6 @@ export const translations = {
             "field_workflowRun_startedAt": "Démarré le",
             "field_workflowRun_completedAt": "Terminé le",
 
-
             "model_budget": "Budget",
             "model_request": "Requêtes",
             "model_imageGallery": "Galerie d'images",

package/src/modules/auth-google/index.js

@@ -1,51 +1,54 @@
-import { Strategy as GoogleStrategy } from 'passport-google-oauth20';
-import { Sso, SSOUserProvider } from '../../sso.js';
-import {Logger} from "../../gameObject.js";
-
-let logger;
-
-export async function onInit(engine) {
-    logger = engine.getComponent(Logger);
-
-    // Le SSOUserProvider est nécessaire pour l'initialisation et pour la stratégie.
-    // On le crée donc en premier.
-    const ssoUserProvider = new SSOUserProvider(engine);
-
-    // 1. Récupérer le composant PassportAuth central.
-    let passportAuth = engine.getComponent(Sso);
-    if (!passportAuth) {
-        passportAuth = engine.addComponent(Sso);
-        // C'EST ICI QUE L'INITIALISATION DOIT AVOIR LIEU, UNE SEULE FOIS.
-        passportAuth.initialize({ ssoUserProvider });
-        passportAuth.addLogoutRoute();
-        logger.info("[auth-google] Sso component was not found, created and initialized a new one.");
-    }
-
-    // 2. Vérifier que les variables d'environnement nécessaires sont présentes.
-    if (!process.env.GOOGLE_CLIENT_ID || !process.env.GOOGLE_CLIENT_SECRET) {
-        logger.warn("[auth-google] GOOGLE_CLIENT_ID or GOOGLE_CLIENT_SECRET are not set. Google SSO will be disabled.");
-        return;
-    }
-
-    // 3. Créer l'instance de la stratégie Google.
-    const googleStrategy = new GoogleStrategy({
-        clientID: process.env.GOOGLE_CLIENT_ID,
-        clientSecret: process.env.GOOGLE_CLIENT_SECRET,
-        callbackURL: "/api/auth/google/callback"
-    },
-    async (accessToken, refreshToken, profile, done) => {
-        try {
-            // On utilise le SSOUserProvider pour trouver ou créer l'utilisateur.
-            const user = await ssoUserProvider.findOrCreate(profile);
-            return done(null, user);
-        } catch (err) {
-            return done(err);
-        }
-    });
-
-    // 4. Enregistrer la stratégie auprès du composant PassportAuth.
-    passportAuth.addStrategy('google', googleStrategy,
-        { authPath: '/api/auth/google', callbackPath: '/api/auth/google/callback' },
-        { scope: ['profile', 'email'] }
-    );
+import { Strategy as GoogleStrategy } from 'passport-google-oauth20';
+import { Sso, SSOUserProvider } from '../../sso.js';
+import {Logger} from "../../gameObject.js";
+import passport from "passport";
+
+let logger;
+
+export async function onInit(engine) {
+    logger = engine.getComponent(Logger);
+
+    // Le SSOUserProvider est nécessaire pour l'initialisation et pour la stratégie.
+    // On le crée donc en premier.
+    const ssoUserProvider = new SSOUserProvider(engine);
+
+    // 1. Récupérer le composant PassportAuth central.
+    let ssoComponent = engine.getComponent(Sso);
+    if (!ssoComponent) {
+        ssoComponent = engine.addComponent(Sso);
+        // C'EST ICI QUE L'INITIALISATION DOIT AVOIR LIEU, UNE SEULE FOIS.
+        ssoComponent.initialize({ ssoUserProvider });
+        ssoComponent.addLogoutRoute();
+        logger.info("[auth-google] Sso component was not found, created and initialized a new one.");
+    }
+
+    // 2. Vérifier que les variables d'environnement nécessaires sont présentes.
+    if (!process.env.GOOGLE_CLIENT_ID || !process.env.GOOGLE_CLIENT_SECRET) {
+        logger.warn("[auth-google] GOOGLE_CLIENT_ID or GOOGLE_CLIENT_SECRET are not set. Google SSO will be disabled.");
+        return;
+    }
+
+    // 3. Créer l'instance de la stratégie Google.
+    const googleStrategy = new GoogleStrategy({
+        clientID: process.env.GOOGLE_CLIENT_ID,
+        clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+        callbackURL: "/api/auth/google/callback"
+    },
+    async (accessToken, refreshToken, profile, done) => {
+        try {
+            const user = await ssoUserProvider.findOrCreate(profile);
+            // On passe le profil brut dans le 3ème argument pour le récupérer dans le callback de `authenticate`
+            // et le passer à l'événement OnSsoLogin.
+            return done(null, user, { profile });
+        } catch (err) {
+            return done(err);
+        }
+    });
+
+    // 4. Enregistrer la stratégie auprès du composant SSO.
+    // Le composant Sso gère lui-même les routes, le callback, req.logIn() et le déclenchement de l'événement.
+    ssoComponent.addStrategy('google', googleStrategy,
+        { authPath: '/api/auth/google', callbackPath: '/api/auth/google/callback' },
+        { scope: ['profile', 'email'] }
+    );
 }