data-primals-engine 1.7.0 → 1.7.2

package/src/modules/mongodb.js

@@ -1,73 +1,76 @@
-
-import {Logger} from "../gameObject.js";
-import {MongoDatabase} from "../engine.js";
-import {ObjectId} from "mongodb";
-import {isLocalUser} from "../data.js";
-import {Event} from "../events.js";
-import {Config} from "../config.js";
-
-export let modelsCollection, datasCollection, filesCollection, packsCollection;
-
-export {ObjectId};
-
-let engine, logger, currentDb
-
-let colls= [];
-export async function onInit(defaultEngine) {
-    engine = defaultEngine;
-    logger = engine.getComponent(Logger);
-
-    currentDb = MongoDatabase();
-    modelsCollection = getCollection("models");
-    datasCollection = getCollection(Config.Get('dataCollection', 'datas'));
-    filesCollection = getCollection("files");
-    packsCollection = getCollection("packs");
-
-    colls = await currentDb.listCollections().toArray();
-
-    await Event.Trigger("OnDatabaseLoaded", "system", "calls", engine)
-    logger.info("MongoDB collections loaded.");
-}
-
-export const getCollections= async (forceRefresh)=>{
-    if( !forceRefresh )
-        return colls;
-    colls = await currentDb.listCollections().toArray();
-}
-
-export const createCollection = async (coll)=>{
-    const found =colls.find(f => f.name === coll);
-    if( found){
-        return getCollection(coll);
-    }
-    return await currentDb.createCollection(coll);
-}
-
-export const isObjectId = (id) => {
-    return (typeof(id) === 'string' && id.match(/^[0-9a-fA-F]{24}$/));
-};
-
-
-export const getCollection = (str) => {
-    return currentDb.collection(str);
-}
-
-export const getDatabase = () => {
-    return currentDb;
-}
-
-// New function to determine the collection name for a user
-export const getUserCollectionName = async (user) => {
-    const feat = await engine.userProvider.hasFeature(user, 'indexes');
-    const dataCollectionName = Config.Get('dataCollection', 'datas');
-    return feat ? (isLocalUser(user) ? `${dataCollectionName}_${user._user}` :`${dataCollectionName}_${user.username}` ) : dataCollectionName;
-};
-
-
-// Modify existing functions to use the correct collection
-export const getCollectionForUser = async (user) => {
-    const collectionName = await getUserCollectionName(user);
-    return getCollection(collectionName);
-};
-
-
+
+import {Logger} from "../gameObject.js";
+import {MongoDatabase} from "../engine.js";
+import {ObjectId} from "mongodb";
+import {isLocalUser} from "../data.js";
+import {Event} from "../events.js";
+import {Config} from "../config.js";
+
+export let modelsCollection, datasCollection, filesCollection, packsCollection;
+
+export {ObjectId};
+
+let engine, logger, currentDb
+
+let colls= [];
+export async function onInit(defaultEngine) {
+    engine = defaultEngine;
+    logger = engine.getComponent(Logger);
+
+    currentDb = MongoDatabase();
+    modelsCollection = getCollection("models");
+    datasCollection = getCollection(Config.Get('dataCollection', 'datas'));
+    filesCollection = getCollection("files");
+    packsCollection = getCollection("packs");
+
+
+    colls = await (currentDb.listCollections()).toArray();
+
+    await Event.Trigger("OnDatabaseLoaded", "system", "calls", engine)
+    logger.info("MongoDB collections loaded.");
+}
+
+export const getCollections= async (forceRefresh)=>{
+    if( !forceRefresh )
+        return colls;
+    colls = await currentDb.listCollections().toArray();
+}
+
+export const createCollection = async (coll)=>{
+    const found =colls.find(f => f.name === coll);
+    if( found){
+        return getCollection(coll);
+    }
+    return await currentDb.createCollection(coll);
+}
+
+export const isObjectId = (id) => {
+    return (typeof(id) === 'string' && id.match(/^[0-9a-fA-F]{24}$/));
+};
+
+
+export const getCollection = (str) => {
+    if (typeof str !== 'string') {
+        logger?.error(`[MongoDB] Tentative d'accès à une collection avec un type invalide: ${typeof str}`);
+        throw new Error("Le nom de la collection doit être une chaîne de caractères.");
+    }
+    return currentDb.collection(str);
+}
+
+export const getDatabase = () => {
+    return currentDb;
+}
+
+// New function to determine the collection name for a user
+export const getUserCollectionName = async (user) => {
+    const feat = await engine.userProvider.hasFeature(user, 'indexes');
+    const dataCollectionName = Config.Get('dataCollection', 'datas');
+    return feat ? (isLocalUser(user) ? `${dataCollectionName}_${user._user}` :`${dataCollectionName}_${user.username}` ) : dataCollectionName;
+};
+
+
+// Modify existing functions to use the correct collection
+export const getCollectionForUser = async (user) => {
+    const collectionName = await getUserCollectionName(user);
+    return getCollection(collectionName);
+};

package/src/modules/user.js

@@ -358,8 +358,14 @@ export async function getSmtpConfig(user) {
         acc[variable.name.replace('SMTP_', '').toLowerCase()] = variable.value;
         return acc;
     }, {});
+
     if( !smtpConfig.port )
         smtpConfig.port = cfg.port;
-
+    if( !smtpConfig.host )
+        smtpConfig.host = cfg.host;
+    if( !smtpConfig.user )
+        smtpConfig.user = cfg.user;
+    if( !smtpConfig.pass )
+        smtpConfig.pass = cfg.pass;
     return smtpConfig;
 }

package/src/modules/worker-script-runner.js

@@ -0,0 +1,97 @@
+import { parentPort } from 'worker_threads';
+
+let callIdCounter = 0;
+const pendingCalls = new Map();
+
+/**
+ * Appelle une fonction sur le thread principal et attend la réponse.
+ * @param {string} service - Le nom du service (ex: 'db').
+ * @param {string} method - Le nom de la méthode (ex: 'find').
+ * @param  {...any} args - Les arguments de la méthode.
+ * @returns {Promise<any>}
+ */
+function callHost(service, method, ...args) {
+    return new Promise((resolve, reject) => {
+        const callId = callIdCounter++;
+        pendingCalls.set(callId, { resolve, reject });
+        parentPort.postMessage({ type: 'call', callId, service, method, args });
+    });
+}
+
+// API exposée au script de l'utilisateur
+const db = {
+    create: (model, data) => callHost('db', 'create', model, data),
+    find: (model, filter, options) => callHost('db', 'find', model, filter, options),
+    findOne: (model, filter) => callHost('db', 'findOne', model, filter),
+    update: (model, filter, update) => callHost('db', 'update', model, filter, update),
+    delete: (model, filter) => callHost('db', 'delete', model, filter),
+};
+
+const workflow = {
+    run: (name, context) => callHost('workflow', 'run', name, context),
+};
+
+const logger = {
+    info: (...args) => callHost('log', 'info', ...args),
+    warn: (...args) => callHost('log', 'warn', ...args),
+    error: (...args) => callHost('log', 'error', ...args),
+};
+
+const env = {
+    get: (name) => callHost('env', 'get', name),
+    getAll: () => callHost('env', 'getAll'),
+};
+
+const http = {
+    request: (method, url, options) => callHost('http', 'request', method, url, options),
+};
+
+/**
+ * Exécute le code utilisateur dans un scope sécurisé.
+ * @param {string} code - Le code à exécuter.
+ * @param {object} context - Le contexte du workflow.
+ */
+async function runUserCode(code, context) {
+    // Crée une fonction asynchrone avec le code utilisateur.
+    // Les variables `db`, `logger`, `context`, etc., sont disponibles dans son scope.
+    const userFunction = new Function('db', 'workflow', 'logger', 'env', 'http', 'context', `return (async () => { ${code} })();`);
+
+    // Appelle la fonction avec l'API sandboxed.
+    return userFunction(db, workflow, logger, env, http, context);
+}
+
+// Gestionnaire de messages unique pour le worker
+parentPort.on('message', (msg) => {
+    // Message initial pour démarrer l'exécution
+    if (msg.code) {
+        // Le worker ne doit pas se terminer tant que le code n'est pas fini.
+        parentPort.ref();
+        runUserCode(msg.code, msg.context)
+            .then(result => {
+                parentPort.postMessage({ type: 'done', result });
+            })
+            .catch(e => {
+                parentPort.postMessage({ type: 'error', error: e.message });
+            })
+            .finally(() => {
+                // Une fois terminé, le worker peut se fermer.
+                parentPort.unref();
+            });
+    }
+    // Message de réponse à un appel `callHost`
+    else if (msg.type === 'response') {
+        const { callId, result, error } = msg;
+        if (pendingCalls.has(callId)) {
+            const { resolve, reject } = pendingCalls.get(callId);
+            if (error) {
+                reject(new Error(error));
+            } else {
+                resolve(result);
+            }
+            pendingCalls.delete(callId);
+        }
+    } else if (msg.type === 'call') {
+        // Ce cas ne devrait pas arriver (le worker envoie 'call', il ne le reçoit pas),
+        // mais on le laisse pour la robustesse.
+    }
+});