data-primals-engine 1.4.2 → 1.5.0

package/client/src/hooks/useTutorials.jsx

@@ -4,7 +4,7 @@ import { useUI } from '../contexts/UIContext.jsx';
 import { useNotificationContext } from '../NotificationProvider.jsx';
 import { tutorialsConfig } from '../tutorials.js';
 import { useTranslation } from 'react-i18next';
-import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import useLocalStorage from "./useLocalStorage.js";
 import {Event} from "../../../src/events.js";
 
@@ -20,9 +20,9 @@ export const useTutorials = () => {
     const { allTourSteps, setCurrentTourSteps, setIsTourOpen } = useUI();
     const { addNotification } = useNotificationContext();
 
-    // Refs pour gérer la file d'attente des vérifications
-    const isCheckingRef = useRef(false);
-    const isCheckQueuedRef = useRef(false);
+    // Ref pour "verrouiller" la vérification d'une étape spécifique et éviter les notifications en double
+    // à cause des re-renders rapides (race condition).
+    const completingStepRef = useRef(null);
 
     const { data: tutorials, isLoading: isLoadingTutorials } = useQuery('tutorials', async () => {
         return tutorialsConfig.map(t => ({ ...t, _id: t.id }));
@@ -119,102 +119,99 @@ export const useTutorials = () => {
         updateActiveTutorial(newActiveState);
         launchTour(firstStage.tourName);
     };
-
+    
     const triggerTutorialCheck = useCallback(async () => {
-        if (isCheckingRef.current) {
-            console.log('[Tutoriels] Vérification déjà en cours, mise en file d\'attente.');
-            isCheckQueuedRef.current = true; // Mettre en attente
+        // S'il n'y a pas de tutoriel actif, on ne fait rien.
+        if (!me?.activeTutorial || !tutorials) {
+            return;
+        }
+
+        const { id: currentTutorialId, stage: currentStageNumber } = me.activeTutorial;
+        const stepIdentifier = `${currentTutorialId}-${currentStageNumber}`;
+
+        // --- VERROUILLAGE (LOCK) ---
+        // Si on est déjà en train de traiter cette étape exacte, on ignore les appels suivants
+        // pour éviter les notifications multiples.
+        if (completingStepRef.current === stepIdentifier) {
+            console.log(`[Tutoriels] Vérification pour l'étape ${stepIdentifier} déjà en cours. On ignore.`);
             return;
         }
-        if (!me?.activeTutorial || !tutorials) return;
 
-        isCheckingRef.current = true;
-        console.log('[Tutoriels] Démarrage de la vérification en chaîne...');
+        const tutorial = tutorials.find(t => t._id === currentTutorialId);
+        const stageConfig = tutorial?.stages.find(s => s.stage === currentStageNumber);
+
+        if (!stageConfig) return; // Pas d'étape active à vérifier
 
         try {
-            let currentActiveState = me.activeTutorial;
+            // On pose le verrou pour cette étape
+            completingStepRef.current = stepIdentifier;
+            console.log(`[Tutoriels] Verrouillage et vérification de l'étape ${stepIdentifier}`);
 
-            while (true) {
-                const tutorial = tutorials.find(t => t._id === currentActiveState.id);
-                if (!tutorial) break;
+            const { isCompleted } = await checkCompletionCondition(stageConfig.completionCondition);
 
-                const stageConfig = tutorial.stages.find(s => s.stage === currentActiveState.stage);
-                if (!stageConfig) {
-                    console.log('[Tutoriels] Fin du tutoriel, attribution des récompenses.');
-                    claimRewards(tutorial._id);
-                    updateActiveTutorial(null);
-                    setIsTourOpen(false);
-                    break;
-                }
+            if (isCompleted) {
+                console.log(`[Tutoriels] Étape ${currentStageNumber} complétée.`);
 
-                const { isCompleted } = await checkCompletionCondition(stageConfig.completionCondition);
+                const titleKey = `tutorial.${tutorial.id}.stage.${currentStageNumber}.name`;
+                const descriptionKey = `tutorial.${tutorial.id}.stage.${currentStageNumber}.description`;
 
-                if (isCompleted) {
-                    console.log(`[Tutoriels] Étape ${currentActiveState.stage} complétée, passage à la suivante.`);
+                addNotification({
+                    title: t(titleKey, stageConfig.name),
+                    message: t(descriptionKey, stageConfig.description),
+                    status: 'success',
+                    id: `tuto-step-${stepIdentifier}` // ID unique pour la notification
+                });
 
-                    // Clés de traduction structurées et robustes
-                    const titleKey = `tutorial.${tutorial.id}.stage.${currentActiveState.stage}.name`;
-                    const descriptionKey = `tutorial.${tutorial.id}.stage.${currentActiveState.stage}.description`;
+                // On passe à l'étape suivante (ou on termine le tutoriel)
+                const nextStageNumber = currentStageNumber + 1;
+                const nextStage = tutorial.stages.find(s => s.stage === nextStageNumber);
 
-                    addNotification({
-                        title: t(titleKey, stageConfig.name),
-                        message: t(descriptionKey, stageConfig.description),
-                        status: 'success'
-                    });
-                    currentActiveState = { id: currentActiveState.id, stage: currentActiveState.stage + 1 };
+                if (nextStage) {
+                    updateActiveTutorial({ id: currentTutorialId, stage: nextStageNumber });
+                    launchTour(nextStage.tourName);
                 } else {
-                    console.log(`[Tutoriels] Arrêt à l'étape ${currentActiveState.stage} (non complétée).`);
-                    if (currentActiveState.stage !== me.activeTutorial.stage) {
-                        updateActiveTutorial(currentActiveState);
-                        launchTour(stageConfig.tourName);
-                    }
-                    break;
+                    claimRewards(tutorial._id);
+                    updateActiveTutorial(null);
+                    setIsTourOpen(false);
                 }
+            } else {
+                console.log(`[Tutoriels] Étape ${currentStageNumber} non complétée.`);
             }
         } catch (error) {
-            console.error("[Tutoriels] Erreur lors de la vérification en chaîne :", error);
+            console.error("[Tutoriels] Erreur lors de la vérification de l'étape :", error);
         } finally {
-            isCheckingRef.current = false;
-            console.log('[Tutoriels] Vérification en chaîne terminée, verrou libéré.');
-
-            // Si une vérification a été mise en attente, on la lance maintenant.
-            if (isCheckQueuedRef.current) {
-                console.log('[Tutoriels] Lancement de la vérification mise en file d\'attente.');
-                isCheckQueuedRef.current = false;
-                triggerTutorialCheck();
-            }
+            // On libère le verrou
+            completingStepRef.current = null;
+            console.log(`[Tutoriels] Libération du verrou pour l'étape ${stepIdentifier}`);
         }
-    }, [
-        tutorials, checkCompletionCondition, claimRewards, updateActiveTutorial,
-        addNotification, launchTour, t, setIsTourOpen, me
-    ]);
+    }, [me, tutorials, checkCompletionCondition, updateActiveTutorial, claimRewards, addNotification, launchTour, t, setIsTourOpen]);
 
     useEffect(() => {
         setMe(prevMe => ({ ...prevMe, activeTutorial: activeTuto }));
     }, [activeTuto]);
 
+    const handleDataChange = useCallback(async (payload) => {
+        if (me?.activeTutorial) {
+            console.log(`[Tutoriels] Événement de données reçu, déclenchement de la vérification.`, payload);
+            triggerTutorialCheck();
+        }
+    }, [me?.activeTutorial, triggerTutorialCheck]);
+
     // Écoute les événements de modification de données pour vérifier la progression en arrière-plan.
     useEffect(() => {
-        const handleDataChange = async (payload) => {
-            console.log(`[Tutoriels] Événement de données reçu.`, payload);
-            if (me?.activeTutorial) {
-                triggerTutorialCheck();
-            }
-        };
-
-        console.log(me.activeTutorial + new Date().getMilliseconds());
         const eventTypes = ['API_ADD_DATA', 'API_EDIT_DATA', 'API_DELETE_DATA'];
         eventTypes.forEach(type => Event.Listen(type, handleDataChange, "custom", "data"));
 
         return () => {
             eventTypes.forEach(type => Event.RemoveCallback(type, handleDataChange, "custom", "data"));
         };
-    }, [me?.activeTutorial]);
+    }, [handleDataChange]);
 
     // Vérifie la progression lorsqu'un tutoriel devient actif ou que son étape change.
     useEffect(() => {
         triggerTutorialCheck();
-    },[]);
+    },[me?.activeTutorial]); // Se déclenche quand le tutoriel/étape change
+
     return {
         tutorials,
         isLoadingTutorials,

package/client/src/translations.js

@@ -2,6 +2,9 @@
 export const websiteTranslations = {
     fr: {
         translation: {
+            "dashboards.addKpi": "Ajouter un indicateur KPI",
+
+            "field.geolocation": "Géolocalisation",
             "time.minute": "Minute",
             "time.hour": "Heure",
             "time.day": "Jour",
@@ -55,8 +58,6 @@ export const websiteTranslations = {
             "history.revertSuccess": "Document restauré avec succès. L'historique va maintenant être mis à jour.",
             "history.revertError": "Erreur lors de la restauration : {{error}}",
 
-            "field_endpoint_isPublic": "Accès public",
-            "field_endpoint_isPublic_hint": "Si coché, ce point d'accès sera accessible sans authentification. Le script s'exécutera avec les droits du propriétaire du point d'accès.",
 
             "packs.manualInstall": "Importer",
             "packs.manualInstall.title": "Installation manuelle de pack",
@@ -606,6 +607,7 @@ export const websiteTranslations = {
     },
     en: {
         translation: {
+            "field.geolocation": "Geolocation",
             "time.minute":"Minute",
             "time.hour":"Hour",
             "time.day":"Day",
@@ -2084,6 +2086,7 @@ export const websiteTranslations = {
     },
     es: {
         translation: {
+            "field.geolocation": "Geolocalización",
             "time.minute": "Minuto",
             "time.hour": "Hora",
             "time.day": "Día",
@@ -3564,6 +3567,7 @@ export const websiteTranslations = {
     },
     pt: {
         translation: {
+            "field.geolocation": "Geolocalização",
             "time.minute":"Minuto",
             "time.hour":"Hora",
             "time.day":"Dia",
@@ -5039,6 +5043,7 @@ export const websiteTranslations = {
     },
     de: {
         translation: {
+            "field.geolocation": "Geolokalisierung",
             "time.minute":"Minute",
             "time.hour":"Stunde",
             "time.day":"Tag",
@@ -6499,6 +6504,7 @@ export const websiteTranslations = {
     },
     it: {
         translation: {
+            "field.geolocation": "Geolocalizzazione",
             "time.minute":"Minuto",
             "time.hour":"Ora",
             "time.day":"Giorno",
@@ -7972,6 +7978,7 @@ export const websiteTranslations = {
     },
     cs: {
         translation: {
+            "field.geolocation": "Geolokace",
             "time.minute":"Minuta",
             "time.hour":"Hodina",
             "time.day":"Den",
@@ -9439,6 +9446,7 @@ export const websiteTranslations = {
     },
     ru: {
         translation: {
+            "field.geolocation": "Геолокация",
             "time.minute":"Минута",
             "time.hour":"Час",
             "time.day":"День",
@@ -10918,6 +10926,7 @@ export const websiteTranslations = {
     },
     ar: {
         translation: {
+            "field.geolocation": "تحديد الموقع الجغرافي",
             "الدقيقة الزمنية": "الدقيقة", "الساعة الزمنية": "الساعة", "اليوم الزمني": "اليوم", "الأسبوع الزمني": "الأسبوع", "الشهر الزمني": "الشهر", "السنة الزمنية": "السنة",
             "packs.myPack": "حزمتي",
             "packs.public": "عامة",
@@ -12407,6 +12416,7 @@ export const websiteTranslations = {
     },
     sv: {
         translation: {
+            "field.geolocation": "Geolocation",
             "time.minute":"Minut",
             "time.hour":"Timme",
             "time.day":"Dag",
@@ -13874,6 +13884,7 @@ export const websiteTranslations = {
     },
     el: {
         translation: {
+            "field.geolocation": "Γεωγραφική τοποθεσία",
             "time.minute":"Λεπτό",
             "time.hour":"Ώρα",
             "time.day":"Ημέρα",
@@ -15350,6 +15361,7 @@ export const websiteTranslations = {
     },
     fa: {
         "translation": {
+            "field.geolocation": "موقعیت جغرافیایی",
             "time.minute":"دقیقه",
             "time.hour":"ساعت",
             "time.day":"روز",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-primals-engine",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "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",
@@ -101,6 +101,7 @@
     "stripe": "^18.4.0",
     "swagger-ui-express": "^5.0.1",
     "tar": "^7.4.3",
+    "tinycolor2": "^1.6.0",
     "uniqid": "^5.4.0",
     "vitest": "^3.2.4",
     "yaml": "^2.8.0"

package/perf/README.md

@@ -0,0 +1,147 @@
+## Performance Test Report 1
+
+### Test Environment
+- **Machine**: Laptop Intel Core i7 Lenovo Legion
+- **Concurrency**: Ramp-up to 50 virtual users/sec
+- Runs on `perf-shot-search.yml` ,that simulates user basic activity on API 
+
+### Summary of Results
+
+| Metric                     | Value      |
+ |----------------------------|------------|
+| Total HTTP Requests        | 1,475      |
+| Successful Responses (2xx) | 1,475      |
+| Average Request Rate       | 19/sec     |
+| Data Downloaded            | 13.5 MB    |
+| Failed Scenarios           | 0          |
+
+### Response Time Analysis (in milliseconds)
+
+| Percentile | Response Time (ms) |
+|------------|--------------------|
+| min        | 8                  |
+| median     | **36.2**           |
+| mean       | 253.9              |
+| p95        | 561.2              |
+| p99        | 608                |
+| max        | 805                |
+---
+
+### Analysis & Recommendations
+
+*   **Outstanding Performance & Stability**: The final test results are excellent. The server handled **1,475 requests with 0 failures**, demonstrating exceptional stability under sustained load.
+
+*   **Bottleneck Resolved**:
+    *   The **median response time is now just 36.2 milliseconds**. This is a dramatic improvement and indicates that the core API operations are extremely fast for the majority of users.
+    *   The **p95 (561.2 ms)** and **p99 (608 ms)** response times remain well under one second. This shows that the application performs consistently, with very few outliers, even during peak load phases.
+
+
+
+## Performance Test Report 2
+
+### Test Environment
+- **Machine**: Laptop Intel Core i7 Lenovo Legion
+- **Scenario**: `perf-shot-hardwork.yml` (Full user journey including model creation, data import, and pack installation)
+- **Concurrency**: Sustained load of 1 virtual user/sec for 60 seconds.
+
+### Summary of Results
+
+| Metric | Value |
+ |---|---|
+| Total HTTP Requests | 480 |
+| Successful Responses (2xx) | 480 |
+| Average Request Rate | 4/sec |
+| Data Downloaded | 0.88 MB |
+| **Failed Scenarios** | **0** |
+
+### Response Time Analysis (in milliseconds)
+
+| Percentile | Response Time (ms) |
+|------------|--------------------|
+| min | 7 |
+| median | **15** |
+| mean | 96.1 |
+| p95 | 368.8 |
+| p99 | 407.5 |
+| max | 474 |
+---
+
+### Analysis & Recommendations
+
+*   **Total Success & Stability**: The test is a complete success. With a 100% success rate (**0 failed scenarios** and **0 request errors**), it confirms that the previous fixes for race conditions and file upload issues are effective and robust.
+
+*   **Outstanding Performance**: The API's responsiveness is excellent.
+    *   A **median response time of just 15 milliseconds** shows that the core operations are extremely fast for the majority of users.
+    *   The **p99 is 407.5 ms**, meaning 99% of requests, even within a complex multi-step scenario, completed in well under half a second. This demonstrates consistent and reliable performance.
+
+*   **Conclusion**: The application is perfectly stable and highly performant under the tested load. The entire user journey, including complex operations, is handled efficiently. This provides a solid baseline for future, more intensive load tests.
+
+
+## Performance Test Report 3 (Scaling)
+
+### Test Environment
+- **Machine**: Laptop Intel Core i7 Lenovo Legion
+- **Scenario**: `perf-shot-hardwork.yml` (Full user journey)
+- **Concurrency**: Ramped load from 1 to 2 virtual users/sec for 60 seconds.
+
+### Summary of Results
+
+| Metric | Value |
+ |---|---|
+| Total HTTP Requests | 720 |
+| Successful Responses (2xx) | 720 |
+| Average Request Rate | 9/sec |
+| **Failed Scenarios** | **0** |
+
+### Response Time Analysis (in milliseconds)
+
+| Percentile | Response Time (ms) |
+|------------|--------------------|
+| min | 8 |
+| median | **32.1** |
+| mean | 141.4 |
+| p95 | 772.9 |
+| p99 | 854.2 |
+| max | 922 |
+---
+
+### Analysis & Recommendations
+
+*   **Excellent Linear Scaling**: This test confirms the application's ability to scale gracefully. When doubling the load from the previous test (1 user/sec to 2 users/sec), the median and p95 response times also roughly doubled. This linear behavior is ideal and indicates a robust architecture without major bottlenecks.
+*   **Continued Stability**: With **0 failed scenarios**, the application proves its stability even as concurrency increases.
+*   **Conclusion**: The application is ready for higher loads. The performance degradation is predictable and linear, which is a sign of a very healthy system.
+
+
+## Performance Test Report 4 (Bottleneck Identification)
+
+### Test Environment
+- **Machine**: Laptop Intel Core i7 Lenovo Legion
+- **Scenario**: `perf-shot-hardwork.yml` (Full user journey)
+- **Concurrency**: Ramped load from 1 to 4 virtual users/sec for 60 seconds.
+
+### Summary of Results
+
+| Metric | Value |
+ |---|---|
+| Total HTTP Requests | 1,200 |
+| Successful Responses (2xx) | 1,200 |
+| Average Request Rate | 12/sec |
+| **Failed Scenarios** | **0** |
+
+### Response Time Analysis (in milliseconds)
+
+| Percentile | Response Time (ms) |
+|------------|--------------------|
+| min | 3 |
+| median | **70.1** |
+| mean | 483.9 |
+| p95 | **2893.5** |
+| p99 | **8024.5** |
+| max | 8348 |
+---
+
+### Analysis & Recommendations
+
+*   **Bottleneck Identified**: This test successfully identified the application's first major performance bottleneck. While stability remains perfect (**0 failures**), the response times show non-linear degradation. The **p99 jumping to over 8 seconds** indicates that the system is struggling under this write-heavy load.
+*   **Database Contention**: The cause is almost certainly database contention (MongoDB). The scenario involves concurrent model creation, data import, and pack installation, which are highly resource-intensive operations.
+*   **Next Steps**: The immediate next step is to run a detailed analysis to pinpoint the exact slow queries. Monitoring server CPU/Disk I/O during the test and using MongoDB's profiler will be essential for optimization.

package/perf/artillery-hooks.js

@@ -0,0 +1,37 @@
+import {uuidv4} from "../src/core.js";
+
+
+export function setScenarioVariables(context, events, done) {
+    // context.vars is where we store variables for the virtual user's session
+    context.vars.vuId = uuidv4().replace(/-/g, '');
+    context.vars.demoUser = `perf${Math.floor(Math.random() * 9000000) + 1000000}`;
+    return done();
+}
+// Hook to name requests to aggregate metrics by endpoint
+export function metricsByEndpoint_beforeRequest(requestParams, context, ee, next) {
+    // Remove query parameters for the metric name
+    const urlPath = requestParams.url.split('?')[0];
+
+    // Replace unique IDs (ObjectId or UUID) in the URL with a placeholder for aggregation
+    // Example: /api/data/60d0fe4f5311236168a109ca -> /api/data/:id
+    const name = urlPath.replace(/([a-fA-F0-9]{24}|[a-fA-F0-9-]{36})/g, ':id');
+
+    // Emit an internal Artillery event to name the request
+    ee.emit('request:set_name', name);
+
+    return next();
+}
+
+// Hook pour logger les erreurs de manière détaillée
+export function metricsByEndpoint_afterResponse(requestParams, response, context, ee, next) {
+    // On vérifie si le statut est un code d'erreur (4xx ou 5xx)
+    if (response.statusCode >= 400) {
+        console.error(`\n[ERREUR] Requête ${requestParams.method} ${requestParams.url} a échoué avec le statut ${response.statusCode}`);
+        // On log le corps de la réponse, qui contient souvent le message d'erreur du serveur
+        if (response.body) {
+            console.error(` -> Réponse: ${response.body}\n`);
+        }
+    }
+    // On passe à la suite du scénario
+    return next();
+}

package/perf/perf-shot-hardwork.yml

@@ -0,0 +1,84 @@
+config:
+  # L'URL de base de votre API
+  processor: "./artillery-hooks.js" # Indique à Artillery d'utiliser notre fichier de hooks
+  target: "http://localhost:7633"
+  # Configuration des phases de test
+  phases:
+    # Phase 1: Montée en charge progressive pendant 30 secondes
+    - duration: 60
+      arrivalRate: 1  # 5 nouveaux utilisateurs virtuels par seconde
+      rampTo: 1      # pour atteindre 20 nouveaux utilisateurs virtuels par seconde à la fin de la phase
+      name: "Ramp-up"
+    # Phase 2: Maintien de la charge maximale pendant 60 secondes
+  # Paramètres par défaut pour toutes les requêtes HTTP
+  defaults:
+    headers:
+      # Utilisation du token statique de l'utilisateur 'demo'
+      Authorization: "Bearer demotoken"
+      Content-Type: 'application/json'
+    beforeRequest: "metricsByEndpoint_beforeRequest" # Groups metrics by endpoint
+    afterResponse: "metricsByEndpoint_afterResponse" # Logs errors
+scenarios:
+  - name: "Parcours Utilisateur Complet"
+    flow:
+      # Sets unique variables for EACH scenario run
+      - function: "setScenarioVariables"
+      - log: "--- Démarrage du scénario utilisateur 'developer' ---"
+      - post:
+          url: "/api/demo/initialize?_user={{demoUser}}"
+          json:
+            profile: "developer"
+            packs:
+              - "Multilingual starter pack"
+              - "Website Starter Pack"
+      - log: "--- Searching in translation table by lang relation ---"
+      - post:
+          url: "/api/data/search?_user={{demoUser}}"
+          json:
+            model: "translation"
+            filter: { "lang": { "$find": { "code": "en" } } }
+            limit: 250
+      - log: "---  Étape 2: Ajout d'une nouvelle donnée et capture de son ID ---"
+      - post:
+          url: "/api/data?_user={{demoUser}}"
+          json:
+            model: "translation"
+            data:
+              key: "perf.test.greeting.{{ $uuid }}"
+              value: "Hello from performance test!"
+              lang: { "$find": { "code": "en" } } # Syntaxe $find corrigée
+          capture:
+            - json: "$.insertedIds[0]"
+              as: "insertedId"
+      - log: "---  Étape 3: Import de données (nécessite un modèle et un fichier) ---"
+      # 3a. Création d'un modèle pour l'import (tolère l'erreur si le modèle existe déjà)
+      - post:
+          url: "/api/model?_user={{demoUser}}"
+          json:
+            name: "perf_import_items_{{ vuId }}" # Unique model name to avoid race conditions
+            description: "import model for perf test"
+            fields:
+              - { name: "name", type: "string" }
+              - { name: "value", type: "number" }
+          expect:
+            - statusCode: 201 # Succès de la création
+            - statusCode: 400 # Tolère l'erreur "le modèle existe déjà" pour rendre le test ré-exécutable
+      - log: "---  Étape 4: Installation d'un pack de données ---"
+      - post:
+          url: "/api/packs/install?_user={{demoUser}}&lang=en"
+          json:
+            packData:
+              name: "Perf Test Pack {{ $uuid }}"
+              description: "A pack for performance testing."
+              models: [{ name: "perf_pack_model_{{ vuId }}", description: "", fields: [{ name: "pack_field", type: "string" }] }] # Unique model name
+              data: { all: { "perf_pack_model_{{ vuId }}": [{ "pack_field": "Hello from a pack!" }] } }
+      - log: "--- Étape 5: Suppression des données ---"
+      - delete:
+          url: "/api/model?name=perf_import_items_{{ vuId }}&_user={{demoUser}}" # Delete the unique model
+      - delete:
+          url: "/api/model?name=perf_pack_model_{{ vuId }}&_user={{demoUser}}" # Delete the unique model
+      - delete:
+          url: "/api/data/{{ insertedId }}?_user={{demoUser}}"
+          json:
+            model: "translation"
+          ifTrue: "{{ insertedId !== undefined }}" # Ne s'exécute que si l'ID a été capturé

package/perf/perf-shot-search.yml

@@ -0,0 +1,45 @@
+config:
+  # L'URL de base de votre API
+  target: "http://localhost:7633"
+  # Configuration des phases de test
+  phases:
+    # Phase 1: Montée en charge progressive pendant 60 secondes
+    - duration: 10
+      arrivalRate: 5  # 5 nouveaux utilisateurs virtuels par seconde
+      rampTo: 50      # pour atteindre 50 nouveaux utilisateurs par seconde à la fin de la phase
+      name: "Ramp-up"
+    # Phase 2: Maintien de la charge maximale pendant 120 secondes
+    - duration: 120
+      arrivalRate: 10 # 50 nouveaux utilisateurs virtuels par seconde
+      name: "Sustained load"
+  # Paramètres par défaut pour toutes les requêtes HTTP
+  defaults:
+    headers:
+      # Utilisation du token statique de l'utilisateur 'demo'
+      Authorization: "Bearer demotoken"
+      Content-Type: 'application/json'
+
+scenarios:
+  - name: "Stress Test - Recherche de données"
+    flow:      # Envoi d'une requête POST à l'endpoint de recherche
+     - post:
+          url: "/api/data/search?_user=demo"
+          # Le corps de la requête en JSON
+          json:
+            # Le nom du modèle sur lequel effectuer la recherche
+            model: "translation"
+            filter: { "lang": { "$find": { "code": "en" } } }
+            limit: 250
+  - name: "Stress Test - Insertion de données"
+    flow:      # Envoi d'une requête POST à l'endpoint de recherche
+      - post:
+            url: "/api/data?_user=demo"
+            # Le corps de la requête en JSON
+            json:
+              # Le nom du modèle sur lequel effectuer la recherche
+              model: "translation"
+              # Le filtre de recherche (ici, vide pour récupérer tous les documents)
+              data: {
+                "key": "{{$randomNumber(1,10000)}}",
+                "value": "{{$randomNumber(1,10000)}}",
+              }

package/perf/setup.yml

@@ -0,0 +1,26 @@
+config:
+  target: "http://localhost:7633"
+  phases:
+    # Exécute ce scénario une seule fois avec un seul utilisateur virtuel
+    - duration: 1
+      arrivalCount: 1
+  defaults:
+    headers:
+      # Utilise le token statique de l'utilisateur 'demo' pour l'installation
+      Authorization: "Bearer demotoken"
+      Content-Type: 'application/json'
+
+scenarios:
+  - name: "Installation unique des packs de données"
+    flow:
+      - log: "Installation du 'Website Starter Pack'..."
+      - post:
+          url: "/api/packs/install?_user=demo"
+          json:
+            packName: "Website Starter Pack"
+      - log: "Installation du 'Multilingual starter pack'..."
+      - post:
+          url: "/api/packs/install?_user=demo"
+          json:
+            packName: "Multilingual starter pack"
+      - log: "Installation terminée."

package/server.js

@@ -29,7 +29,7 @@ if (process.argv.length === 3) {
 }
 
 
-const realPort = process.env.PORT || port;
+const realPort = Config.Get('port', process.env.PORT || port);
 engine.start(realPort, async (r) => {
     const logger = engine.getComponent(Logger);
     console.log("Server started on port " + realPort);