data-primals-engine 1.2.1 → 1.2.3

package/README.md

@@ -18,15 +18,18 @@
 
 ## 🚀 Key Features
 
-- **Dynamic data modeling**: Define and update schemas using JSON, no migrations required.
-- **Robust REST API**: Advanced CRUD operations, filtering, and querying.
-- **Modular architecture**: Load or extend modules dynamically.
-- **Automation workflows**: Trigger actions on events or schedules.
-- **Authentication & authorization**: Role-based access control, pluggable providers.
-- **📦 Starter Packs**: CRM, e-commerce, showcase websites, etc.
-- **🧠 AI Integration**: Supports OpenAI, Google Gemini via LangChain.
-- **🌐 i18n support**: Multilingual interfaces, translated validations.
-- **📄 Auto Documentation**: Swagger available at `/api-docs`.
+- **Dynamic Data Modeling**: Define and update schemas using JSON, no migrations required.
+- **Custom API Endpoints**: Create server-side logic and new API endpoints directly from the UI in a secure, sandboxed environment.
+- **Automation Workflows**: Trigger complex actions based on data events (create, update, delete) or schedules (cron).
+- **Advanced Querying & Aggregation**: Go beyond simple filters with deep relation expansion, complex lookups, and dynamic calculated fields.
+- **Integrated Backup & Restore**: Secure, encrypted user data backups with rotation policies, supporting both local and AWS S3 storage.
+- **Event-Driven & Extensible**: A core event system allows for deep customization and the easy creation of new modules or plugins.
+- **Authentication & Authorization**: Robust role-based access control (RBAC) and pluggable user providers.
+- **Built-in File Management**: Handle file uploads seamlessly with integrated support for AWS S3 storage.
+- **🧠 AI Integration**: Natively supports OpenAI and Google Gemini models via LangChain for content generation, analysis, and more.
+- **🌐 Internationalization (i18n)**: Fully supports multilingual interfaces and user-specific translated data.
+- **📦 Starter Packs**: Quickly bootstrap applications with pre-built data packs for CRM, e-commerce, and more.
+- **📄Auto-Generated API Documentation**: Interactive API documentation available via the interface or at `/api-docs`.
 
 
 ## 🌟 Why Choose data-primals-engine?
@@ -603,11 +606,68 @@ Expected response :
   },
   "publishedPosts": 15
 }
+
+```
+
+---
+## Extensibility
+
+### Events (Triggers) Table
+> You can use the events below to access the engine and manipulate API responses.
+> It is useful for custom modules or middlewares for your application.
+
+Just use
+
+```javascript
+Event.Listen("OnDataAdded", (data) => {
+     my_callback()
+}, "event", "user");
+```
+
+or the system version
+```javascript
+Event.Listen("OnDataAdded", (engine, data) => {
+     my_callback()
+}, "event", "system");
+```
+
+| Event | Description                                                             | Scope | Triggered by | Arguments (Payload) | 
+| :--- |:------------------------------------------------------------------------| :--- | :--- | :--- |
+| OnServerStart | Triggered once the HTTP server is started and listening.                | System | engine.start() | engine | 
+| OnServerStop | Triggered right after the HTTP server is stopped.                       | System | engine.stop() | engine |
+| OnModelsLoaded | Triggered after the initial models are loaded and validated at startup. | System | setupInitialModels() | engine, dbModels |
+| OnModelsDeleted | Triggered after all models are deleted via the reset function.          | System | engine.resetModels() | engine | 
+| OnUserDataDumped | Triggered after a user's data has been backed up (dumped).              | System | jobDumpUserData() | engine | 
+| OnDataRestored | Triggered after a user's data has been restored from a backup.          | System | loadFromDump() | (none) |
+| OnPackInstalled | Triggered after a data pack has been successfully installed.            | System | installPack() | pack | 
+| OnModelEdited | Triggered after a model definition has been modified.                   | System & User | editModel() | System: engine, newModel (Pipeline*)<br>User: newModel (or the version modified by the system) | 
+| OnDataAdded | Triggered after new data has been inserted.                             | System & User | insertData() | System: engine, insertedIds (Pipeline*)<br>User: insertedIds (or the version modified by the system) | 
+| OnDataDeleted | Triggered just after data is actually deleted.                          | System & User | deleteData() | System: engine, {model, filter} (Pipeline*)<br>User: {model, filter} | 
+| OnDataSearched | Triggered after a data search.                                          | System & User | searchData() | System: engine, {data, count} (Pipeline*)<br>User: {data, count} (or the version modified by the system) | 
+| OnDataExported | Triggered after a data export.                                          | System & User | exportData() | System: engine, exportResults, modelsToExport (Pipeline*)<br>User: exportResults, modelsToExport (or the version modified by the system) |
+
+### Triggering events
+
+If you want to provide your own hooks, you can call :
+```javascript
+const result = Event.Trigger("OnMyCustomEvent", "event", "user", ...args);
 ```
+Results are merged together if multiple events are triggered.
+- strings are concatenated
+- numbers are added
+- booleans are ANDed
+- arrays are concatenated
+- objects are merged using spread operator
+
+---
+
 ## 🤝 Contributing
 
+Find the issues available for [contributions here](https://github.com/anonympins/data-primals-engine/issues?q=is%3Aissue%20state%3Aopen%20label%3A%22help%20wanted%22%20no%3Aassignee)
+
 1. Fork the repo
 2. Create your feature branch: `git checkout -b feature/your-feature`
+3. Launch ```npm run dev``` and make your changes with hot-reload on local port 
 3. Commit changes: `git commit -m "Add new feature"`
 4. Push to your branch: `git push origin feature/your-feature`
 5. Open a pull request

package/client/src/DataEditor.jsx

@@ -25,6 +25,7 @@ import Draggable from "./Draggable.jsx";
 import CronBuilder from "./CronBuilder.jsx";
 import RTETrans from "./RTETrans.jsx";
 import uniqid from "uniqid";
+import {isConditionMet} from "data-primals-engine/filter";
 
 // ... (fonction getInputType) ...
 // Fonction pour obtenir le type d'input HTML basé sur le type de champ du modèle
@@ -52,208 +53,6 @@ const getInputType = (fieldType) => {
     }
 };
 
-/**
- * Evaluates a single condition against form data.
- * @param {object} currentModelDef - The definition of the current model.
- * @param {object} condition - The condition to evaluate.
- * @param {object} formData - The form data.
- * @param {object[]} allModels - An array of all model definitions.
- * @param {object} user - The current user.
- * @returns {boolean} - True if the condition is met, false otherwise.
- */
-const evaluateSingleCondition = (currentModelDef, condition, formData, allModels, user) => {
-    // Condition est directement un filtre MongoDB, donc on l'applique
-    // en utilisant les opérateurs et les valeurs qu'il contient.
-
-    if (!condition || typeof condition !== 'object') {
-        console.warn("[Client Eval] Condition is not an object:", condition);
-        return true; // Permissive default
-    }
-
-    // Si la condition contient des opérateurs logiques, on les gère ici
-    if (condition.$and || condition.$or || condition.$not || condition.$nor) {
-        console.warn("[Client Eval] Condition logique détectée dans evaluateSingleCondition, ce n'est pas attendu. Devrait être géré par isConditionMet.");
-        return true; // Permissive default
-    }
-
-    if (condition.$find) {
-        const fieldName = Object.keys(condition)[0];
-        const fieldValue = formData[fieldName];
-        const findCondition = condition.$find;
-
-        if (!Array.isArray(fieldValue)) return false;
-
-        return fieldValue.some(item => {
-            // Gestion spéciale pour la syntaxe $eq: ["$$this.field", value]
-            if (findCondition.$eq && Array.isArray(findCondition.$eq)) {
-                const [fieldPath, value] = findCondition.$eq;
-                if (fieldPath.startsWith("$$this.")) {
-                    const fieldToCheck = fieldPath.replace("$$this.", "");
-                    return item[fieldToCheck] == value;
-                }
-            }
-
-            // Sinon, évaluation normale
-            const tempData = { ...item };
-            return evaluateSingleCondition(currentModelDef, findCondition, tempData, allModels, user);
-        });
-    }
-
-    // Si la condition contient un opérateur $exists, on le gère ici
-    if (condition.$exists !== undefined) {
-        const fieldName = Object.keys(condition)[0]; // Récupérer le nom du champ
-        const shouldExist = condition.$exists; // Récupérer la valeur de $exists (true ou false)
-        const exists = Object.prototype.hasOwnProperty.call(formData, fieldName) && formData[fieldName] !== undefined && formData[fieldName] !== null;
-        return exists === shouldExist;
-    }
-
-    // Si la condition contient un opérateur $find, on le gère ici
-    if (condition.$find) {
-        // Récupérer le nom du champ
-        const fieldName = Object.keys(condition)[0];
-        const fieldValue = formData[fieldName];
-        try {
-            // Assuming evaluateSingleCondition handles $find
-            return evaluateSingleCondition(currentModelDef, condition.$find, formData, allModels, user);
-        } catch (error) {
-            console.error("Error evaluating $find condition:", condition, error);
-            return false;
-        }
-    }
-
-    // Récupérer le nom du champ et la condition
-    const fieldName = Object.keys(condition)[0];
-    const fieldValue = condition[fieldName];
-
-    // Récupérer la définition du champ
-    const fieldDef = currentModelDef?.fields.find(f => f.name === fieldName);
-
-    // Si la définition du champ n'est pas trouvée, on retourne true
-    if (!fieldDef) {
-        console.warn(`[Client Eval] Field definition not found for field: ${fieldName}`);
-        return true; // Permissive default
-    }
-
-    let targetValue = formData[fieldName];
-    let processedConditionValue = fieldValue;
-
-    // 1. Handle $exists (on the first field)
-    // 2. Convert condition value based on operator's expected input type
-    const fieldType = fieldDef?.type; // Type of the first field
-
-    try {
-        processedConditionValue = convertValueType(fieldValue, fieldType);
-    } catch (e) {
-        logClientEvalWarning(`Error converting value type: ${e.message}`, condition);
-        return false;
-    }
-
-    return evaluateComparison(fieldValue, targetValue, processedConditionValue, condition);
-
-    function logClientEvalWarning(message, details) {
-        console.warn(`[Client Eval] ${message}:`, details);
-    }
-
-    function convertValueType(value, inputType) {
-        switch (inputType) {
-            case 'number':
-                const numValue = parseFloat(value);
-                if (isNaN(numValue)) {
-                    throw new Error(`Invalid number value: ${value}`);
-                }
-                return numValue;
-            case 'boolean':
-                return String(value).toLowerCase() === 'true';
-            case 'csv':
-                return String(value).split(',').map(item => item.trim()).filter(Boolean);
-            case 'text':
-            default:
-                return String(value);
-        }
-    }
-
-    function evaluateComparison(operator, targetValue, processedConditionValue, condition) {
-        try {
-            switch (typeof operator === 'object' ? Object.keys(operator)[0] : null) {
-                case '$eq': return targetValue == processedConditionValue;
-                case '$ne': return targetValue != processedConditionValue;
-                case '$gt': return targetValue > processedConditionValue;
-                case '$lt': return targetValue < processedConditionValue;
-                case '$gte': return targetValue >= processedConditionValue;
-                case '$lte': return targetValue <= processedConditionValue;
-                case '$regex':
-                    if (typeof targetValue !== 'string') return false;
-                    if (typeof processedConditionValue !== 'string') return false;
-                    try {
-                        const regex = new RegExp(processedConditionValue, 'i');
-                        return regex.test(targetValue);
-                    } catch (e) {
-                        logClientEvalWarning(`Invalid regex pattern: ${processedConditionValue}`, condition);
-                        return false;
-                    }
-                case '$in':
-                    return Array.isArray(processedConditionValue) && processedConditionValue.includes(String(targetValue));
-                case '$nin':
-                    return !Array.isArray(processedConditionValue) || !processedConditionValue.includes(String(targetValue));
-                default:
-                    logClientEvalWarning(`Unhandled operator in client evaluation logic: ${operator}`, condition);
-                    return true; // Permissive default
-            }
-        } catch (evalError) {
-            logClientEvalWarning(`Error during client condition evaluation: ${operator}, targetValue=${targetValue}, processedConditionValue=${processedConditionValue}`, condition);
-            return false;
-        }
-    }
-};
-
-export const isConditionMet = (model, cond, formData, allModels, user) => {
-    const isNode = (v) => typeof v === 'object' && v !== null;
-
-    const condition = cond;
-
-    if (!condition) return true;
-
-    if (condition.$and && Array.isArray(condition.$and)) {
-        if (condition.$and.length === 0) return true;
-        return condition.$and.every(sub => isConditionMet(model, sub, formData, allModels, user));
-    }
-
-    if (condition.$or && Array.isArray(condition.$or)) {
-        if (condition.$or.length === 0) return false;
-        return condition.$or.some(sub => isConditionMet(model, sub, formData, allModels, user));
-    }
-
-    if (condition.$not) {
-        return !isConditionMet(model, condition.$not, formData, allModels, user);
-    }
-
-    if (condition.$nor && Array.isArray(condition.$nor)) {
-        if (condition.$nor.length === 0) return true;
-        return !condition.$nor.some(sub => isConditionMet(model, sub, formData, allModels, user));
-    }
-
-    if (condition.$find) {
-        try {
-            // Assuming evaluateSingleCondition handles $find
-            return evaluateSingleCondition(model, condition, formData, allModels, user);
-        } catch (error) {
-            console.error("Error evaluating $find condition:", condition, error);
-            return false;
-        }
-    }
-
-    if (condition.path && condition.op) {
-        try {
-            return evaluateSingleCondition(model, condition, formData, allModels, user);
-        } catch (error) {
-            console.error("Error evaluating condition:", condition, error);
-            return false;
-        }
-    }
-
-    console.warn("Unknown condition format:", condition);
-    return true;
-};
 
 export const DataEditor = forwardRef(function MyDataEditor({
    isLoading,

package/client/src/DataLayout.jsx

@@ -2,35 +2,19 @@ import React, {forwardRef, useCallback, useEffect, useMemo, useReducer, useRef,
 
 import "./App.scss";
 import {useMutation, useQuery, useQueryClient} from "react-query";
-import {CheckboxField, FileField, NumberField, SelectField, TextField} from "./Field.jsx";
 import ModelCreator from "./ModelCreator.jsx";
 import {useModelContext} from "./contexts/ModelContext.jsx";
-import {FaMagnifyingGlass, FaPencil} from "react-icons/fa6";
 import {Dialog, DialogProvider} from "./Dialog.jsx";
 import {Pagination} from "./Pagination.jsx";
+import {Event} from "../../src/events.js";
+
 import {
-    elementsPerPage, kilobytes,
-    mainFieldsTypes,
-    maxBytesPerSecondThrottleData,
-    maxFileSize,
-    maxRequestData, metaModels
-} from "../../src/constants.js";
-import {
-    FaArrowDown,
-    FaArrowUp, FaBell,
-    FaBook, FaCopy,
-    FaEdit,
-    FaFileExport, FaFileImport,
     FaFilter, FaInfo,
-    FaLanguage,
-    FaLock,
-    FaPlus,
-    FaTrash
 } from "react-icons/fa";
 import {getDefaultForType, getUserId} from "../../src/data.js";
 import {Trans, useTranslation} from "react-i18next";
 
-import {debounce, escapeRegExp, event_trigger, getObjectHash, isGUID} from "../../src/core.js";
+import {getObjectHash} from "../../src/core.js";
 import Button from "./Button.jsx";
 import {useAuthContext} from "./contexts/AuthContext.jsx";
 import APIInfo from "./APIInfo.jsx";
@@ -49,7 +33,6 @@ import CalendarConfigModal from "./CalendarConfigModal.jsx";
 import KanbanView from "./KanbanView.jsx";
 
 
-// --- AJOUT : Composants Placeholders pour la démonstration ---
 const CalendarView = ({ settings, model }) => (
     <div className="p-4 border rounded-md mt-4 bg-gray-50">
         <h3 className="font-bold">Vue Calendrier</h3>
@@ -349,7 +332,7 @@ function DataLayout() {
 
             console.log('Données enregistrées:', data, selectedModel);
 
-            event_trigger(recordToEdit ? 'API_ADD_DATA' : 'API_ADD_DATA', {
+            Event.Trigger(recordToEdit ? 'API_ADD_DATA' : 'API_ADD_DATA', "custom", "data", {
                 model: selectedModel.name,
             });
 

package/client/src/DataTable.jsx

@@ -6,6 +6,8 @@ import {useAuthContext} from "./contexts/AuthContext.jsx";
 import React, {useEffect, useMemo, useRef, useState} from "react";
 import {getUserId} from "../../src/data.js";
 import cronstrue from 'cronstrue/i18n';
+import {Event} from "../../src/events.js";
+
 import {
     FaBook,
     FaCopy,
@@ -41,7 +43,6 @@ import RelationValue from "./RelationValue.jsx";
 import {FaGear, FaPencil, FaTriangleExclamation} from "react-icons/fa6";
 import RestoreConfirmationModal from "./RestoreConfirmationModal.jsx";
 import {event_trigger, isLightColor} from "../../src/core.js";
-import {isConditionMet} from "./DataEditor.jsx";
 import {Tooltip} from "react-tooltip";
 import ExportDialog from "./ExportDialog.jsx";
 import Captions from "yet-another-react-lightbox/plugins/captions";
@@ -56,6 +57,7 @@ import PackGallery from "./PackGallery.jsx";
 import {HiddenableCell} from "./HiddenableCell.jsx";
 import ConditionBuilder from "./ConditionBuilder.jsx";
 import {pagedFilterToMongoConds} from "./filter.js";
+import {isConditionMet} from "data-primals-engine/filter";
 
 // Ajoutez cette constante pour la clé de sessionStorage
 const SESSION_STORAGE_IMPORT_JOBS_KEY = 'activeImportJobs';
@@ -238,7 +240,7 @@ export function DataTable({
                         console.log('Données non trouvées');
                     }
 
-                    event_trigger('API_DELETE_DATA', { model: item._model, id: item._id });
+                    Event.Trigger('API_DELETE_DATA', "custom", "data",{ model: item._model, id: item._id });
                     queryClient.invalidateQueries(['api/data', item._model, 'page', page, elementsPerPage, pagedFilters[item._model], pagedSort[item._model]]);
 
                 } else {

package/client/src/RestoreConfirmationModal.jsx

@@ -15,80 +15,6 @@ const RestoreConfirmationModal = ({ isOpen, onClose, onConfirm, showS3Config = f
     const { me, fetchMe } = useAuthContext(); // fetchMe pour recharger les données utilisateur après sauvegarde
     const { addNotification } = useNotificationContext();
 
-    // États pour les champs de configuration S3
-    const [s3Config, setS3Config] = useState({
-        bucketName: '',
-        accessKeyId: '',
-        secretAccessKey: '', // Ne sera pas affiché directement mais envoyé
-        region: ''
-    });
-    const [isSavingS3Config, setIsSavingS3Config] = useState(false);
-    const [showConfig, setConfigVisible] = useState(false);
-
-    // Charger la configuration S3 existante de l'utilisateur au montage si me.s3Config existe
-    useEffect(() => {
-        if (me?.s3Config && showS3Config) {
-            setS3Config({
-                bucketName: me.s3Config.bucketName || '',
-                accessKeyId: me.s3Config.accessKeyId || '',
-                secretAccessKey: '', // Ne pas pré-remplir la clé secrète pour la sécurité
-                region: me.s3Config.region || '',
-                pathPrefix: me.s3Config.pathPrefix || ''
-            });
-        } else if (showS3Config) {
-            // Réinitialiser si pas de config ou si on quitte la section S3
-            setS3Config({ bucketName: '', accessKeyId: '', secretAccessKey: '', region: '', pathPrefix: '' });
-        }
-    }, [me, showS3Config, isOpen]); // Ajouter isOpen pour recharger si la modale est rouverte
-
-
-    const handleS3ConfigChange = (e) => {
-        const { name, value } = e.target;
-        setS3Config(prev => ({ ...prev, [name]: value }));
-    };
-
-    const handleSaveS3Config = async () => {
-        setIsSavingS3Config(true);
-        // Validation basique côté client
-        if (!s3Config.bucketName || !s3Config.accessKeyId || !s3Config.region) {
-            addNotification({ type: 'error', message: t('backup.s3config.validationError', 'Le nom du bucket, l\'Access Key ID et la Région sont requis.') });
-            setIsSavingS3Config(false);
-            return;
-        }
-
-        try {
-            const payload = { ...s3Config };
-            // N'envoyer la clé secrète que si elle a été modifiée
-            if (!payload.secretAccessKey) {
-                delete payload.secretAccessKey;
-            }
-
-            const response = await fetch('/api/user/s3-config', { // Endpoint pour sauvegarder la config S3
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    // Les en-têtes d'authentification (_user, Authorization) sont gérés globalement par le fetch wrapper si tu en as un, sinon ajoute-les ici
-                    // Exemple:
-                    // '_user': me?.username,
-                    // 'Authorization': `Bearer ${me?.token}`,
-                },
-                body: JSON.stringify(payload),
-            });
-            const result = await response.json();
-            if (response.ok && result.success) {
-                addNotification({ status: 'completed', title: t('backup.s3config.saveSuccess', 'Configuration S3 enregistrée avec succès.') });
-            } else {
-                addNotification({ status: 'error', title: result.error || t('backup.s3config.saveError', 'Erreur lors de l\'enregistrement de la configuration S3.') });
-            }
-        } catch (error) {
-            addNotification({ status: 'error', title: t('backup.s3config.saveError', 'Erreur lors de l\'enregistrement de la configuration S3.') });
-            console.error("Error saving S3 config:", error);
-        } finally {
-            setIsSavingS3Config(false);
-        }
-    };
-
-
     if (!isOpen) {
         return null;
     }
@@ -110,71 +36,8 @@ const RestoreConfirmationModal = ({ isOpen, onClose, onConfirm, showS3Config = f
                             <Trans i18nKey="btns.cancel">Annuler</Trans>
                         </Button>
                     </div>
-                    <div className={"flex flex-centered actions"}>
-                        {!showConfig && (<NavLink onClick={() => setConfigVisible(true)}><Trans i18nKey={"backup.s3config.title"}></Trans></NavLink>)}
-                    </div>
                 </>
 
-                {showConfig && (<>
-                    <h2>{t('backup.s3config.title', 'Configuration du stockage S3')}</h2>
-                    <p><Trans i18nKey="backup.prez"></Trans></p>
-                    <form className="s3-config-form space-y-4"> {/* Ajout de space-y pour l'espacement vertical */}
-                        <TextField
-                            name="bucketName"
-                            className={"flex flex-1"}
-                            label={t('backup.s3config.bucketName', 'Nom du Bucket S3')}
-                            value={s3Config.bucketName}
-                            onChange={handleS3ConfigChange}
-                            placeholder="my-bucket-name"
-                            required
-                        />
-                        <TextField
-                            name="accessKeyId"
-                            className={"flex flex-1"}
-                            label={t('backup.s3config.accessKeyId', 'Access Key ID AWS')}
-                            value={s3Config.accessKeyId}
-                            onChange={handleS3ConfigChange}
-                            placeholder="AKIAIOSFODNN7EXAMPLE"
-                            required
-                        />
-                        <TextField
-                            name="secretAccessKey"
-                            className={"flex flex-1"}
-                            label={t('backup.s3config.secretAccessKey', 'Secret Access Key AWS')}
-                            type="password" // Important pour masquer la clé
-                            value={s3Config.secretAccessKey}
-                            onChange={handleS3ConfigChange}
-                            placeholder={t('backup.s3config.secretPlaceholder', 'Laisser vide pour ne pas modifier')} />
-                        <TextField
-                            name="region"
-                            className={"flex flex-1"}
-                            label={t('backup.s3config.region', 'Région AWS')}
-                            value={s3Config.region}
-                            onChange={handleS3ConfigChange}
-                            placeholder="eu-west-3"
-                            required
-                        />
-                        <TextField
-                            name="pathPrefix"
-                            label={t('backup.s3config.pathPrefix', 'Préfixe de chemin (Optionnel)')}
-                            value={s3Config.pathPrefix}
-                            onChange={handleS3ConfigChange}
-                            placeholder="saves/my-app/"
-                            help={t('backup.s3config.pathPrefixHelp', 'Ex: "mon-dossier/". Laissez vide pour la racine du bucket.')}
-                        />
-                        <div
-                            className="modal-actions flex justify-end space-x-2 mt-4"> {/* Flex pour aligner les boutons */}
-                            <Button onClick={handleSaveS3Config} disabled={isSavingS3Config}
-                                    className="btn-primary"> {/* Classe btn-primary pour le bouton principal */}
-                                {isSavingS3Config ? t('btns.saving', 'Enregistrement...') : t('btns.save', 'Enregistrer la configuration S3')}
-                            </Button>
-                            <Button onClick={onClose} className="btn-secondary">
-                                <Trans i18nKey="btns.cancel">Annuler</Trans>
-                            </Button>
-                        </div>
-                    </form>
-                </>)}
-
             </div>
         </Dialog>
     );

package/client/src/constants.js

@@ -53,7 +53,7 @@ export const MONGO_OPERATORS = {
 export const profiles = {
     'personal': ['contact', 'location', 'imageGallery', 'budget', 'currency', 'taxonomy'], // budget,
     'developer': ['alert','endpoint','request','webpage', 'content', 'taxonomy', 'resource', 'translation', 'contact', 'location', 'channel', 'lang', 'token', 'message', 'ticket', 'user', 'permission', 'role'],
-    'company': ['alert','request','location', 'campaign', 'order', 'currency', 'product', 'cart', 'cartItem', 'invoice', 'message', 'user', 'role', 'permission', 'token','translation', 'lang', 'webpage', 'content', 'taxonomy', 'contact', 'resource', 'accountingExercise', 'accountingLineItem', 'accountingEntry', 'employee', 'kpi', 'dashboard'],
+    'company': ['alert','request','location', 'order', 'currency', 'product', 'cart', 'cartItem', 'invoice', 'message', 'user', 'role', 'permission', 'token','translation', 'lang', 'webpage', 'content', 'taxonomy', 'contact', 'resource', 'accountingExercise', 'accountingLineItem', 'accountingEntry', 'employee', 'kpi', 'dashboard'],
     'engineer': ['alert','endpoint','request','dashboard', 'kpi', 'user', 'role', 'token', 'permission', 'workflow', 'workflowRun', 'workflowStep', "channel", "message", 'workflowAction', 'workflowTrigger']
 }
 

package/client/src/hooks/useTutorials.jsx

@@ -6,7 +6,7 @@ import { tutorialsConfig } from '../tutorials.js';
 import { useTranslation } from 'react-i18next';
 import { useCallback, useEffect, useMemo, useRef } from 'react';
 import useLocalStorage from "./useLocalStorage.js";
-import { event_off, event_on } from "../../../src/core.js";
+import {Event} from "../../../src/events.js";
 
 /**
  * Hook pour gérer la logique des tutoriels multi-étapes.
@@ -205,10 +205,10 @@ export const useTutorials = () => {
 
         console.log(me.activeTutorial + new Date().getMilliseconds());
         const eventTypes = ['API_ADD_DATA', 'API_EDIT_DATA', 'API_DELETE_DATA'];
-        eventTypes.forEach(type => event_on(type, handleDataChange));
+        eventTypes.forEach(type => Event.Listen(type, handleDataChange, "custom", "data"));
 
         return () => {
-            eventTypes.forEach(type => event_off(type, handleDataChange));
+            eventTypes.forEach(type => Event.RemoveCallback(type, handleDataChange, "custom", "data"));
         };
     }, [me?.activeTutorial]);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "data-primals-engine",
-  "version": "1.2.1",
-  "description": "data-primals-engine is the package responsible from handling large amount of data in a practical and performant way. It can handle large amount of data in a practical and performant way. It can also get workflow models working (for automation), and fully supports internationalisation.",
+  "version": "1.2.3",
+  "description": "data-primals-engine is a package responsible from handling large amount of data using MongoDB in a practical and performant way. It can also get workflow models working (for automation), and fully supports internationalisation. It also has integrated AI assistant.",
   "main": "src/engine.js",
   "type": "module",
   "scripts": {

package/src/constants.js

@@ -66,7 +66,7 @@ export const awsDefaultConfig = {
 export const emailDefaultConfig = {
     from: "Support - data@primals.net <data@primals.net>",
     host: 'smtp.mydomain.tld',
-    port: 2500,
+    port: 587,
     secure: false,
     user: 'user',
     pass: 'password'
@@ -288,7 +288,7 @@ metaModels['messaging'] = { load: ['alert','ticket', 'message', 'channel'], 'req
 metaModels['eshopping'] = { load: [
     'order', 'currency', 'product', 'productVariant', 'discount', 'cart', 'cartItem',
     'brand', 'return', 'review', 'stock', 'returnItem', 'userSubscription',
-    'warehouse', 'shipment', 'campaign', 'stockAlert', 'invoice'],
+    'warehouse', 'shipment', 'stockAlert', 'invoice'],
 'require': ['i18n', 'users', 'messaging'] };
 metaModels['workflow'] = { load: ['env', 'workflow', 'workflowRun', 'workflowAction', 'workflowStep', 'workflowTrigger']};
 metaModels['erp'] = { load: [ 'accountingExercise', 'accountingLineItem', 'accountingEntry', 'employee', 'dashboard', 'kpi'] };

package/src/data.js

@@ -5,21 +5,21 @@ import {mainFieldsTypes} from "./constants.js";
 
 const IV_LENGTH = 16;
 export function encryptValue(text) {
-    if (!process.env.S3_CONFIG_ENCRYPTION_KEY) throw new Error("S3_CONFIG_ENCRYPTION_KEY is not set");
+    if (!process.env.ENCRYPTION_KEY) throw new Error("ENCRYPTION_KEY is not set");
     let iv = crypto.randomBytes(IV_LENGTH);
-    let cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(process.env.S3_CONFIG_ENCRYPTION_KEY), iv);
+    let cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(process.env.ENCRYPTION_KEY), iv);
     let encrypted = cipher.update(text);
     encrypted = Buffer.concat([encrypted, cipher.final()]);
     return iv.toString('hex') + ':' + encrypted.toString('hex');
 }
 
 export function decryptValue(text) {
-    if (!process.env.S3_CONFIG_ENCRYPTION_KEY) throw new Error("S3_CONFIG_ENCRYPTION_KEY is not set");
+    if (!process.env.ENCRYPTION_KEY) throw new Error("ENCRYPTION_KEY is not set");
     if (!text || typeof text !== 'string' || !text.includes(':')) return text; // ou throw error
     let textParts = text.split(':');
     let iv = Buffer.from(textParts.shift(), 'hex');
     let encryptedText = Buffer.from(textParts.join(':'), 'hex');
-    let decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(process.env.S3_CONFIG_ENCRYPTION_KEY), iv);
+    let decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(process.env.ENCRYPTION_KEY), iv);
     let decrypted = decipher.update(encryptedText);
     decrypted = Buffer.concat([decrypted, decipher.final()]);
     return decrypted.toString();