data-primals-engine 1.4.0 → 1.4.2

package/src/modules/data/data.scheduling.js

@@ -0,0 +1,274 @@
+import {getCollection} from "../mongodb.js";
+import schedule from "node-schedule";
+import {maxAlertsPerUser} from "../../constants.js";
+import {ObjectId} from "mongodb";
+import {getSmtpConfig} from "../user.js";
+import {runScheduledJobWithDbLock, substituteVariables} from "../workflow.js";
+import i18n from "../../i18n.js";
+import {sendEmail} from "../../email.js";
+import {sendSseToUser} from "./data.routes.js";
+
+import {searchData} from "./data.operations.js";
+import {Logger} from "../../gameObject.js";
+
+
+let engine, logger;
+export function onInit(defaultEngine) {
+    engine = defaultEngine;
+    logger = engine.getComponent(Logger);
+}
+
+export const cancelAlerts = async (user) => {
+
+    const datasCollection = getCollection('datas'); // Alerts are in the global collection
+
+    // 1. Fetch the latest state of the alert
+    const alertDocs = await datasCollection.find({_user: user.username, _model: 'alert'}).toArray();
+    alertDocs.forEach(doc => {
+        const jobId = `alert_${doc._id}`;
+        schedule.scheduledJobs[jobId]?.cancel();
+    });
+}
+
+/**
+ * Executes a stateful alert job. It checks if a notification for an alert
+ * has already been sent and only sends one if the condition is met and no
+ * recent notification exists. The state is tracked via the 'lastNotifiedAt'
+ * field in the alert document.
+ * @param {string|ObjectId} alertId - The ID of the alert to process.
+ */
+export async function runStatefulAlertJob(alertId) {
+    const jobId = `alert_${alertId}`;
+    logger.info(`[Scheduled Job] Cron triggered for stateful alert job ${jobId}.`);
+
+    try {
+        const datasCollection = getCollection('datas'); // Alerts are in the global collection
+
+        // 1. Fetch the latest state of the alert
+        const alertDoc = await datasCollection.findOne({_id: new ObjectId(alertId)});
+
+        // Safety checks
+        if (!alertDoc) {
+            logger.warn(`[Scheduled Job] Alert ${alertId} not found. Cancelling job.`);
+            schedule.scheduledJobs[jobId]?.cancel();
+            return;
+        }
+
+        if (!alertDoc.isActive || !alertDoc.frequency) {
+            logger.info(`[Scheduled Job] Alert ${alertId} is no longer active or has no frequency. Cancelling job.`);
+            schedule.scheduledJobs[jobId]?.cancel();
+            return;
+        }
+
+        // 2. Check if a notification has already been sent for this state
+        if (alertDoc.lastNotifiedAt) {
+            logger.debug(`[Scheduled Job] Notification for alert ${alertId} has already been sent. Skipping evaluation.`);
+            return;
+        }
+
+        // 3. Evaluate the trigger condition
+        const apiFilter = (alertDoc.triggerCondition);
+        const {count} = await searchData({
+            model: alertDoc.targetModel,
+            filter: apiFilter,
+            limit: 1
+        }, {username: alertDoc._user});
+
+        // 4. If condition is met, send notification and update state
+        if (count > 0) {
+            logger.info(`[Scheduled Job] Condition met for alert ${alertDoc.name} (ID: ${alertId}). Sending notification and updating state.`);
+
+            let emailSent = false;
+            try {
+                const user = await engine.userProvider.findUserByUsername(alertDoc._user);
+                if (user && user.email) {
+                    const smtpConfig = await getSmtpConfig(user);
+                    if (alertDoc.sendEmail && smtpConfig) {
+                        const userLang = user.lang || 'en';
+                        let emailContent, msg;
+                        if (alertDoc.message) {
+                            if (alertDoc.message[userLang])
+                                msg = alertDoc.message[userLang];
+                            else
+                                msg = alertDoc.message[Object.keys(alertDoc.message)[0]];
+                            emailContent = await substituteVariables(msg, {count, alert: alertDoc});
+                        } else {
+                            // Sinon, utiliser le message par défaut
+                            emailContent = i18n.t('alert.email.content', `L'alerte '${alertDoc.name}' s'est déclenchée. ${count} élément(s) correspondent à votre condition.`, {
+                                name: alertDoc.name,
+                                count: count
+                            });
+                        }
+
+                        await sendEmail(
+                            user.email,
+                            {
+                                title: i18n.t('alert.email.title', `Alerte: ${alertDoc.name}`),
+                                content: emailContent
+                            },
+                            smtpConfig,
+                            userLang
+                        );
+                        emailSent = true;
+                        logger.info(`[Scheduled Job] Email notification sent for alert ${alertId} to ${user.email}.`);
+                    } else if (alertDoc.sendEmail) {
+                        logger.warn(`[Scheduled Job] Could not send email for alert ${alertId}. SMTP config is missing or incomplete for user ${user.username}.`);
+                    }
+                } else {
+                    logger.warn(`[Scheduled Job] Could not send email for alert ${alertId}. User ${alertDoc._user} not found or has no email address.`);
+                }
+            } catch (emailError) {
+                logger.error(`[Scheduled Job] Failed to send email for alert ${alertId}:`, emailError);
+            }
+
+            // Send notification
+            const alertPayload = {
+                type: 'cron_alert',
+                triggerId: alertDoc._id.toString(),
+                triggerName: alertDoc.name,
+                timestamp: new Date().toISOString(),
+                message: `Alerte '${alertDoc.name}': ${count} élément(s) correspondent à votre condition.`,
+                emailSent
+            };
+            sendSseToUser(alertDoc._user, alertPayload);
+
+            // Update state in DB to prevent re-notification
+            await datasCollection.updateOne(
+                {_id: new ObjectId(alertId)},
+                {$set: {lastNotifiedAt: new Date()}}
+            );
+        } else {
+            logger.debug(`[Scheduled Job] Condition not met for alert ${alertId}. No notification sent.`);
+        }
+
+    } catch (error) {
+        logger.error(`[Scheduled Job] Error processing stateful alert job ${jobId}:`, error);
+    }
+}
+
+export async function scheduleAlerts() {
+    logger.info('[scheduleAlerts] Starting scheduling of oldest active alerts per user...');
+    try {
+        const datasCollection = getCollection('datas');
+
+        // --- NOUVELLE LOGIQUE AVEC AGRÉGATION ---
+        const aggregationPipeline = [
+            // 1. Match: Ne sélectionner que les alertes actives avec une fréquence définie.
+            {
+                $match: {
+                    _model: 'alert',
+                    isActive: true,
+                    frequency: {$exists: true, $ne: ""}
+                }
+            },
+            // 2. Sort: Trier les alertes par utilisateur, puis par date de création (les plus anciennes en premier).
+            // L'ObjectId contient un timestamp, donc trier par _id est équivalent à trier par date de création.
+            {
+                $sort: {
+                    _user: 1, // Grouper par utilisateur
+                    _id: 1    // Trier par date de création (ascendant)
+                }
+            },
+            // 3. Group: Regrouper toutes les alertes par utilisateur dans un tableau.
+            {
+                $group: {
+                    _id: "$_user", // La clé de groupement est le nom de l'utilisateur
+                    alerts: {$push: "$$ROOT"} // $$ROOT pousse le document entier dans le tableau 'alerts'
+                }
+            },
+            // 4. Project (Slice): Pour chaque utilisateur, ne garder que les X premières alertes du tableau trié.
+            {
+                $project: {
+                    oldestAlerts: {$slice: ["$alerts", maxAlertsPerUser]}
+                }
+            },
+            // 5. Unwind: Déconstruire le tableau 'oldestAlerts' pour obtenir un flux de documents, un par alerte.
+            {
+                $unwind: "$oldestAlerts"
+            },
+            // 6. ReplaceRoot: Remplacer la structure du document par le contenu de l'alerte elle-même.
+            {
+                $replaceRoot: {newRoot: "$oldestAlerts"}
+            }
+        ];
+
+        const alertsToSchedule = await datasCollection.aggregate(aggregationPipeline).toArray();
+        // --- FIN DE LA NOUVELLE LOGIQUE ---
+
+        logger.info(`[scheduleAlerts] Found ${alertsToSchedule.length} oldest active alerts across all users to schedule.`);
+
+        for (const alertDoc of alertsToSchedule) {
+            const jobId = `alert_${alertDoc._id}`;
+            try {
+                // Annuler une tâche existante pour la même alerte si elle existe (logique de sécurité)
+                if (schedule.scheduledJobs[jobId]) {
+                    schedule.scheduledJobs[jobId].cancel();
+                }
+                // Planifier la tâche avec la nouvelle logique stateful
+                schedule.scheduleJob(jobId, alertDoc.frequency, () => runStatefulAlertJob(alertDoc._id));
+            } catch (scheduleError) {
+                logger.error(`[scheduleAlerts] Failed to schedule job ${jobId} for alert ${alertDoc._id}. Error: ${scheduleError.message}`);
+            }
+        }
+        logger.info('[scheduleAlerts] Finished scheduling alerts.');
+    } catch (error) {
+        logger.error('[scheduleAlerts] A critical error occurred during alert scheduling:', error);
+    }
+}
+
+
+/**
+ * Applique un masque et des valeurs par défaut à une expression cron.
+ * @param {string} cronString - L'expression cron d'entrbooléens. `false` pour désactiver et appliquer la valeur par défaut.
+ * @param {string[]} defaults - Un tableau de 5 chaînes de caractères pour les valeurs par défaut.
+ * @returns {string} - L'expression cron modifiée.
+ */
+export function applyCronMask(cronString, mask, defaults) {
+    if (typeof cronString !== 'string' || cronString.trim() === '' || !mask || !defaults) {
+        return cronString;
+    }
+    const parts = cronString.split(' ');
+    if (parts.length < 5) {
+        return cronString; // Laisse la validation standard gérer les formats incorrects
+    }
+
+    const newParts = parts.slice(0, 5).map((part, index) => {
+        // Si le masque à cet index est `false`, on force la valeur par défaut.
+        if (mask[index] === false) {
+            return defaults[index];
+        }
+        // Sinon, on garde la valeur de l'utilisateur.
+        return part;
+    });
+
+    return newParts.join(' ');
+}
+
+export async function handleScheduledJobs(modelName, existingDocs, collection, updateData) {
+    for (const doc of existingDocs) {
+        const jobId = `${modelName}_${doc._id}`;
+        const existingJob = schedule.scheduledJobs[jobId];
+        if (existingJob) existingJob.cancel();
+
+        const updatedDoc = {...doc, ...updateData};
+        if (modelName === 'workflowTrigger' && updatedDoc.isActive && updatedDoc.cronExpression) {
+            schedule.scheduleJob(jobId, updatedDoc.cronExpression, async () => {
+                logger.info(`[Scheduled Job] Cron triggered for job ${jobId}`);
+                await runScheduledJobWithDbLock(jobId, async () => {
+                    sendSseToUser(updatedDoc._user, {
+                        type: 'cron_alert',
+                        triggerId: updatedDoc._id.toString(),
+                        triggerName: updatedDoc.name,
+                        timestamp: new Date().toISOString(),
+                        message: `L'alerte planifiée '${updatedDoc.name || 'Sans nom'}' a été déclenchée.`
+                    });
+                }, updatedDoc.lockDurationMinutes || 5);
+            });
+        }
+
+        if (modelName === 'alert' && updatedDoc.isActive && updatedDoc.frequency) {
+            await collection.updateOne({_id: updatedDoc._id}, {$set: {lastNotifiedAt: null}});
+            schedule.scheduleJob(jobId, updatedDoc.frequency, () => runStatefulAlertJob(updatedDoc._id));
+        }
+    }
+}

package/src/modules/data/data.validation.js

@@ -0,0 +1,245 @@
+import {Event} from "../../events.js";
+import i18n from "../../i18n.js";
+import {allowedFields, maxFileSize, maxModelNameLength, maxStringLength} from "../../constants.js";
+import {getDefaultForType} from "../../data.js";
+
+import {dataTypes} from "./data.operations.js";
+import {Logger} from "../../gameObject.js";
+
+
+let engine, logger;
+export function onInit(defaultEngine) {
+    engine = defaultEngine;
+    logger = engine.getComponent(Logger);
+}
+
+export async function validateModelStructure(modelStructure) {
+    return await Event.Trigger("OnValidateModelStructure", "event", "system", modelStructure);
+}
+
+export const validateField = (field) => {
+
+    const allowedFieldTest = (fields) => {
+        // Check for unknown fields
+        const unknownFields = Object.keys(field).filter(f => ![...allowedFields, ...fields].includes(f));
+
+        if (unknownFields.length > 0) {
+            throw new Error(i18n.t('api.validate.unknowField', `Propriété(s) non reconnue(s): '{{0}}' pour le champ '{{1}}'`, [unknownFields.join(', '), field.name]));
+        }
+
+        const fieldInvalid = Object.keys(fields).find(f => JSON.stringify(field[f] || '').length > maxStringLength);
+        if (fieldInvalid) {
+            throw new Error(i18n.t('api.validate.invalidField', `Champ(s) non valide(s): '{{0}}'`, [fieldInvalid.name]));
+        }
+    }
+
+    // Check for required fields
+    if (!field.name || typeof field.name !== 'string') {
+        throw new Error(i18n.t('api.validate.requiredFieldString', "Le champ '{{0}}' est requis et doit être une chaîne de caractères.", ["name"]));
+    }
+    if (!field.type || typeof field.type !== 'string') {
+        throw new Error(i18n.t('api.validate.requiredFieldString', "Le champ '{{0}}' est requis et doit être une chaîne de caractères.", ["type"]));
+    }
+
+    // Check for specific field types
+    switch (field.type) {
+    case 'relation':
+        allowedFieldTest(['relation', 'multiple', 'relationFilter']);
+        if (!field.relation || typeof field.relation !== 'string' || field.relation.length > maxModelNameLength) {
+            throw new Error(i18n.t('api.validate.requiredFieldString', "Le champ '{{0}}' est requis et doit être une chaîne de caractères.", ["relation"]));
+        }
+        if (field.multiple !== undefined && typeof field.multiple !== 'boolean') {
+            throw new Error(i18n.t('api.validate.fieldBoolean', "L'attribut '{{0}}' doit être un booléen.", ["multiple"]));
+        }
+        if (field.relationFilter && typeof field.relationFilter !== 'object') {
+            throw new Error(i18n.t('api.validate.fieldObject', "L'attribut '{{0}}' doit être un objet.", ["relationFilter"]));
+        }
+        break;
+    case 'enum': {
+        allowedFieldTest(['items']);
+        if (!field.items || !Array.isArray(field.items) || field.items.length === 0) {
+            throw new Error(i18n.t('api.validate.fieldStringArray', "L'attribut '{{0}}' doit être un tableau de chaines de caractères.", ["items"]));
+        }
+        let id = field.items.findIndex(item => typeof item !== 'string');
+        if (id !== -1) {
+            throw new Error(i18n.t('api.validate.fieldString', "Le champ '{{0}}' doit être une chaîne de caractères.", ["items[" + id + "]"]));
+        }
+        break;
+    }
+    case 'number':
+        allowedFieldTest(['min', 'max', 'step', 'unit', 'delay', 'gauge', 'percent']);
+        if (field.min !== undefined && typeof field.min !== 'number') {
+            throw new Error(i18n.t('api.validate.fieldNumber', "L'attribut '{{0}}' doit être un nombre.", ["min"]));
+        }
+        if (field.max !== undefined && typeof field.max !== 'number') {
+            throw new Error(i18n.t('api.validate.fieldNumber', "L'attribut '{{0}}' doit être un nombre.", ["max"]));
+        }
+        if (field.max < field.min) {
+            throw new Error(i18n.t('api.validate.inferiorTo', "L'attribut '{{0}}' doit être inférieur à l'attribut '{{1}}'.", ["min", "max"]));
+        }
+        if (field.step !== undefined && typeof field.step !== 'number') {
+            throw new Error(i18n.t('api.validate.fieldNumber', "L'attribut '{{0}}' doit être un nombre.", ["step"]));
+        }
+        if (field.unit !== undefined && typeof field.unit !== 'string') {
+            throw new Error(i18n.t('api.validate.fieldString', "Le champ '{{0}}' doit être une chaîne de caractères.", ["unit"]));
+        }
+        if (field.delay !== undefined && typeof field.delay !== 'boolean') {
+            throw new Error(i18n.t('api.validate.fieldBoolean', "Le champ '{{0}}' doit être un booléen.", ["unit"]));
+        }
+        if (field.gauge !== undefined && typeof field.gauge !== 'boolean') {
+            throw new Error(i18n.t('api.validate.fieldBoolean', "L'attribut '{{0}}' doit être un booléen.", ["gauge"]));
+        }
+        if (field.percent !== undefined && typeof field.percent !== 'boolean') {
+            throw new Error(i18n.t('api.validate.fieldBoolean', "L'attribut '{{0}}' doit être un booléen.", ["percent"]));
+        }
+        break;
+    case 'string':
+    case 'string_t':
+    case 'richtext':
+    case 'richtext_t':
+    case 'url':
+    case 'email':
+    case 'phone':
+    case 'password':
+    case 'code':
+        if (field.type === 'code')
+            allowedFieldTest(['maxlength', 'language', 'conditionBuilder', 'targetModel']);
+        else if (['string_t', 'string'].includes(field.type))
+            allowedFieldTest(['maxlength', 'multiline']);
+        else
+            allowedFieldTest(['maxlength']);
+        if (field.maxlength !== undefined && typeof field.maxlength !== 'number') {
+            throw new Error(i18n.t('api.validate.fieldNumber', "L'attribut '{{0}}' doit être un nombre.", ["maxlength"]));
+        }
+        break;
+    case 'model':
+    case 'modelField':
+        allowedFieldTest([]);
+        break;
+    case 'object':
+        allowedFieldTest([]);
+        break;
+    case 'boolean':
+        allowedFieldTest([]);
+        break;
+    case 'date':
+    case 'datetime': {
+        allowedFieldTest(['min', 'max']);
+        if (field.min !== undefined && typeof field.min !== 'string') {
+            throw new Error(i18n.t('api.validate.fieldString', "Le champ '{{0}}' doit être une chaîne de caractères.", ["min"]));
+        }
+        if (field.max !== undefined && typeof field.max !== 'string') {
+            throw new Error(i18n.t('api.validate.fieldString', "Le champ '{{0}}' doit être une chaîne de caractères.", ["max"]));
+        }
+        const dtMin = field.min ? new Date(field.min) : null;
+        const dtMax = field.max ? new Date(field.max) : null;
+        if (dtMin && dtMax && dtMin > dtMax) {
+            throw new Error(i18n.t('api.validate.inferiorTo', "L'attribut '{{0}}' doit être inférieur à l'attribut '{{1}}'.", ["min", "max"]));
+        }
+        break;
+    }
+    case 'image':
+    case 'file': {
+        allowedFieldTest(['mimeTypes', 'maxSize']);
+        if (field.mimeTypes !== undefined && !Array.isArray(field.mimeTypes)) {
+            throw new Error(i18n.t('api.validate.fieldStringArray', "L'attribut '{{0}}' doit être un tableau de chaines de caractères.", ["mimeTypes"]));
+        }
+        let id;
+        if (field.mimeTypes !== undefined && (id = field.mimeTypes.findIndex(item => typeof item !== 'string')) !== -1) {
+            throw new Error(i18n.t('api.validate.fieldString', "Le champ '{{0}}' doit être une chaîne de caractères.", ["mimeTypes[" + id + "]"]));
+        }
+        if (field.maxSize !== undefined && typeof field.maxSize !== 'number') {
+            throw new Error(i18n.t('api.validate.fieldNumber', "L'attribut '{{0}}' doit être un nombre.", ["maxSize"]));
+        }
+        if (field.maxSize !== undefined && field.maxSize > maxFileSize) {
+            throw new Error(i18n.t('api.validate.fileSize', `L'attribut 'maxSize' ne doit pas dépasser {{0}} octets.`, [maxFileSize]));
+        }
+        break;
+    }
+    case 'color':
+        allowedFieldTest([]);
+        return true;
+    case 'cronSchedule':
+        allowedFieldTest(['cronMask']);
+        return true;
+    case 'calculated':
+        allowedFieldTest(['calculation']);
+        return true;
+    case 'array':
+        if (!field.itemsType || typeof field.itemsType !== 'string') {
+            throw new Error(i18n.t('api.validate.fieldString', "Le champ '{{0}}' doit être une chaîne de caractères.", ["itemsType"]));
+        }
+        if (!dataTypes[field.itemsType]) {
+            throw new Error(i18n.t('api.validate.invalidField', `Champ(s) non valide(s): '{{0}}'`, ["itemsType"]));
+        }
+        if (field.minItems !== undefined && typeof field.minItems !== 'number') {
+            throw new Error(i18n.t('api.validate.fieldNumber', "L'attribut '{{0}}' doit être un nombre.", ["minItems"]));
+        }
+        if (field.maxItems !== undefined && typeof field.maxItems !== 'number') {
+            throw new Error(i18n.t('api.validate.fieldNumber', "L'attribut '{{0}}' doit être un nombre.", ["maxItems"]));
+        }
+        break;
+    default:
+        throw new Error(i18n.t('api.validate.unknowType', `Le type '{{0}}' n'est pas reconnu.`, [field.type]));
+    }
+
+    // Check for optional fields
+    if (field.required !== undefined && typeof field.required !== 'boolean') {
+        throw new Error(i18n.t('api.validate.fieldBoolean', "L'attribut '{{0}}' doit être un booléen.", ["required"]));
+    }
+    if (field.hint !== undefined && typeof field.hint !== 'string') {
+        throw new Error(i18n.t('api.validate.fieldString', "Le champ '{{0}}' doit être une chaîne de caractères.", ["hint"]));
+    }
+    if (field.default !== undefined && field.default !== null && typeof field.default !== typeof getDefaultForType(field) && typeof field.default !== 'function') {
+        throw new Error(i18n.t('api.validate.sameType', `L'attribut '{{0}}' doit être du même type que l'attribut '{{0}}' (${field.type}).`, ['default', 'type']));
+    }
+    if (field.validate !== undefined && typeof field.validate !== 'function') {
+        throw new Error(i18n.t('api.validate.fieldFunction', "L'attribut '{{0}}' doit être une fonction.", ['validate']));
+    }
+    if (field.unique !== undefined && typeof field.unique !== 'boolean') {
+        throw new Error(i18n.t('api.validate.fieldBoolean', "L'attribut '{{0}}' doit être un booléen.", ["unique"]));
+    }
+    if (field.placeholder !== undefined && typeof field.placeholder !== 'string') {
+        throw new Error(i18n.t('api.validate.fieldString', "Le champ '{{0}}' doit être une chaîne de caractères.", ["placeholder"]));
+    }
+    if (field.asMain !== undefined && typeof field.asMain !== 'boolean') {
+        throw new Error(i18n.t('api.validate.fieldBoolean', "L'attribut '{{0}}' doit être un booléen.", ["asMain"]));
+    }
+    if (field.unit !== undefined && typeof field.unit !== 'string') {
+        throw new Error(i18n.t('api.validate.fieldString', "Le champ '{{0}}' doit être une chaîne de caractères.", ["unit"]));
+    }
+
+    return true;
+};
+
+/**
+ * Valide la structure et le contenu du document selon le modèle
+ */
+export async function validateModelData(doc, model, isPatch = false) {
+    if (!isPatch) {
+        model.fields.forEach(field => {
+            const value = doc[field.name];
+            if (field.required) {
+                if (value === undefined && !('default' in field)) {
+                    throw new Error(i18n.t('api.field.missingRequired', {field: field.name + " (" + model.name + ")"}));
+                }
+                if (value === '' || value === null) {
+                    throw new Error(i18n.t('api.field.requiredCannotBeEmpty', {field: field.name}));
+                }
+            }
+        });
+    }
+
+    // 2. Validation des types de champs (toujours exécutée pour les champs fournis)
+    for (const [fieldName, value] of Object.entries(doc)) {
+        const fieldDef = model.fields.find(f => f.name === fieldName);
+        if (!fieldDef) continue; // On ignore les champs supplémentaires
+
+        const validator = dataTypes[fieldDef.type]?.validate;
+        const valid = validator && validator(value, fieldDef);
+        const realValidation = await Event.Trigger('OnDataValidate', "event", "system", value, fieldDef, doc);
+        if (!(valid || realValidation)) {
+            throw new Error(i18n.t('api.field.validationFailed', {field: fieldName, value}));
+        }
+    }
+}

package/src/modules/data/index.js

@@ -1 +1,29 @@
-export * from './data.js';
+export * from './data.js';
+export {validateModelData} from "./data.validation.js";
+export {validateField} from "./data.validation.js";
+export {validateModelStructure} from "./data.validation.js";
+export {scheduleAlerts} from "./data.scheduling.js";
+export {runStatefulAlertJob} from "./data.scheduling.js";
+export {cancelAlerts} from "./data.scheduling.js";
+export {installAllPacks} from "./data.operations.js";
+export {installPack} from "./data.operations.js";
+export {exportData} from "./data.operations.js";
+export {importData} from "./data.operations.js";
+export {searchData} from "./data.operations.js";
+export {deleteData} from "./data.operations.js";
+export {editData} from "./data.operations.js";
+export {patchData} from "./data.operations.js";
+export {pushDataUnsecure} from "./data.operations.js";
+export {insertData} from "./data.operations.js";
+export {getModels} from "./data.operations.js";
+export {getModel} from "./data.operations.js";
+export {deleteModels} from "./data.operations.js";
+export {createModel} from "./data.operations.js";
+export {editModel} from "./data.operations.js";
+export {dataTypes} from "./data.operations.js";
+export {dumpUserData} from "./data.backup.js";
+export {loadFromDump} from "./data.backup.js";
+export {validateRestoreRequest} from "./data.backup.js";
+export {jobDumpUserData} from "./data.backup.js";
+export {handleCustomEndpointRequest} from "./data.routes.js";
+export {middlewareEndpointAuthenticator} from "./data.routes.js";

package/src/modules/user.js

@@ -14,6 +14,7 @@ import {Logger} from "../gameObject.js";
 import rateLimit from "express-rate-limit";
 import ivm from "isolated-vm";
 import {emailDefaultConfig} from "../constants.js";
+import {safeAssignObject} from "../core.js";
 
 export const userInitiator = async (req, res, next) => {
 
@@ -269,7 +270,7 @@ export async function calculateTotalUserStorageUsage(user) {
 export async function getEnv(user){
     const result = await searchData({ model: 'env' }, user);
     const envObject = result.data.reduce((acc, v) => {
-        acc[v.name] = v.value;
+        safeAssignObject(acc, v.name, v.value);
         return acc;
     }, {});
     return envObject;

package/src/modules/workflow.js

@@ -23,7 +23,7 @@ import {getHost} from "../constants.js";
 import {providers} from "./assistant/constants.js";
 import {ChatAnthropic} from "@langchain/anthropic";
 import {getAIProvider} from "./assistant/assistant.js";
-import {escapeRegex} from "../core.js";
+import {escapeRegex, safeAssignObject} from "../core.js";
 
 let logger = null;
 export async function onInit(defaultEngine) {
@@ -1143,7 +1143,8 @@ export async function substituteVariables(template, contextData, user) {
         const newObj = {};
         for (const key in template) {
             if (Object.prototype.hasOwnProperty.call(template, key)) {
-                newObj[key] = await substituteVariables(template[key], contextData, user);
+                const val = await substituteVariables(template[key], contextData, user);
+                safeAssignObject(newObj, key, val);
             }
         }
         return newObj;