data-primals-engine 1.4.3 → 1.5.0

package/client/src/FlexDataRenderer.jsx

@@ -33,8 +33,10 @@ const formatDate = (value, type, t) => {
 
 const FlexDataRenderer = ({ value, fieldDefinition,data }) => {
     const { t, i18n } = useTranslation();
+    const lang = (i18n.resolvedLanguage || i18n.language).split(/[-_]/)?.[0];
     const {models} = useModelContext()
     const {me} = useAuthContext()
+
     // 'translatedLabel' is added by getFieldDefinitionByPath
     const field = fieldDefinition;
     const translatedLabel = t('model_'+field.name, field.name);

package/client/src/FlexTreeUtils.js

@@ -36,7 +36,7 @@ export const createNewNode = (type) => {
         return {
             ...baseNode,
             type: 'item',
-            itemStyle: { width: '100px', height: '50px' },
+            itemStyle: {  },
             content: { type: 'placeholder' }
         };
     }

package/client/src/KPIDialog.jsx

@@ -1,11 +1,16 @@
 import React, { useState } from 'react';
 import { Dialog } from './Dialog.jsx'; // Assure-toi que Dialog est importé
 import { useTranslation } from 'react-i18next';
+import {FaAd, FaPlus} from "react-icons/fa";
+import {getUserHash} from "../../src/data.js";
+import {useNavigate} from "react-router-dom";
+import {useAuthContext} from "./contexts/AuthContext.jsx";
 
 function KPIDialog({ availableKpis = [], onAddKpi, onClose }) {
     const { t } = useTranslation();
     const [searchTerm, setSearchTerm] = useState('');
-
+    const nav = useNavigate()
+    const {me} = useAuthContext()
     const filteredKpis = (availableKpis || []).filter(kpi =>
         kpi.name.value.toLowerCase().includes(searchTerm.toLowerCase())
     );
@@ -32,6 +37,11 @@ function KPIDialog({ availableKpis = [], onAddKpi, onClose }) {
                     <li>{t('dashboards.no_kpi_found', 'Aucun KPI disponible ou correspondant.')}</li>
                 )}
             </ul>
+            <div className={"flex mg-2"}>
+                <button onClick={() => {
+                    nav(`/user/${getUserHash(me)}/?model=kpi`);
+                }} className={"btn"}><FaPlus />{t('dashboards.addKpi', 'Nouvel indicateur KPI')}</button>
+            </div>
         </Dialog>
     );
 }

package/client/src/ModelCreator.jsx

@@ -660,11 +660,10 @@ const ModelCreator = forwardRef(({ initialPrompt = '', onModelGenerated, autoGen
                 {/* Boutons d'action, visibles si un modèle est affiché ou en mode manuel */}
                 {(showModel || !useAI || initialModel) && (
                     <div className="actions flex">
-                        {initialModel && (
+                        
                             <Button type="button" onClick={handleAddField}>
                                 <FaPlus /> <Trans i18nKey={"btns.addField"}>Ajouter un champ</Trans>
                             </Button>
-                        )}
 
                         <Button type="submit">
                             <FaSave />

package/client/src/ModelCreatorField.jsx

@@ -72,7 +72,6 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                 newFields[index].name = e.target.value;
                                 setFields(newFields);
                             }}
-                            help={t('modelcreator.name.hint')}
                             required
                             after={!(!modelLocked && isLocalUser(me) && field.locked) && !field._isNewField && (
                                 <Button type={"button"} className={"btn-form btn-last"}
@@ -212,10 +211,10 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
 
                         <div className="flex flex-no-wrap">
                             {hint('modelcreator.relationFilter.hint')}
-                            <label className="checkbox-label flex flex-1"><Trans
-                                i18nKey={"modelcreator.relationFilter"}>Filtre</Trans> :
-                                <input
-                                    type="checkbox"
+                            <div className="checkbox-label flex flex-1">
+                                <CheckboxField
+                                    label={<Trans
+                                        i18nKey={"modelcreator.relationFilter"}>Filtre</Trans>}
                                     disabled={modelLocked || (isLocalUser(me) && field.locked)}
                                     checked={field.relationFilter !== undefined}
                                     onChange={(e) => {
@@ -228,7 +227,7 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                         setFields(newFields);
                                     }}
                                 />
-                            </label>
+                            </div>
                         </div>)}
 
 
@@ -286,7 +285,6 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                             newFields[index].multiline = e;
                                             setFields(newFields);
                                         }}
-                                        help={field.multiline && t('modelcreator.multiline.hint')}
                                     />
                                 </div>
                             </div>
@@ -295,28 +293,26 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
 
                     {['string', 'string_t', 'richtext', 'richtext_t', 'email', 'phone', 'url', 'password', 'code'].includes(field.itemsType || field.type) && (
                         <>
-                            <div className={"flex flex-no-wrap"}>
+                            <div className={"flex flex-no-wrap field-bg"}>
                                 {hint('modelcreator.maxlength.hint')}
-                                <label className={"flex flex-1"}>
-                                    <Trans i18nKey={"modelcreator.maxlength"}>Longueur
-                                        maximale :</Trans>
-                                    <NumberField
+                                <div className={"flex-1"}><NumberField
                                         disabled={modelLocked || (isLocalUser(me) && field.locked)}
                                         step={1}
                                         min={0}
+                                        label={<Trans i18nKey={"modelcreator.maxlength"}>Longueur
+                                            maximale :</Trans>}
                                         className={"flex-1"}
                                         value={field.maxlength}
                                         onChange={(e) => {
                                             const newFields = [...fields];
-                                            const val = parseInt(e, 10);
-                                            if (!val)
+                                            const val = parseInt(e.target.value, 10);
+                                            if (isNaN(val))
                                                 newFields[index].maxlength = undefined;
                                             else
                                                 newFields[index].maxlength = val;
                                             setFields(newFields);
                                         }}
-                                    />
-                                </label>
+                                    /></div>
                             </div>
                         </>
                     )}
@@ -438,7 +434,6 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                             newFields[index].required = e;
                                             setFields(newFields);
                                         }}
-                                        help={field.required && t('modelcreator.required.hint')}
                                     />
                                 </div>
                             </div>
@@ -456,7 +451,6 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                             newFields[index].unique = e;
                                             setFields(newFields);
                                         }}
-                                        help={field.unique && t('modelcreator.unique.hint')}
                                     />
                                 </div>
                             </div>
@@ -555,7 +549,6 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                         disabled={modelLocked || (isLocalUser(me) && field.locked)}
                                         onChange={(e) => {
                                             const newFields = [...fields];
-
                                             newFields[index].default = e.value;
                                             setFields(newFields);
                                         }}
@@ -626,10 +619,12 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
 
                             {(['datetime', 'date'].includes(field.itemsType || field.type)) && (
                                 <>
-                                    <div className="flex flex-no-wrap mg-item">
+                                    <div
+                                        className="flex flex-no-wrap mg-item">
                                         {hint('modelcreator.min.hint')}
-                                        <label className={"flex-1"}><Trans i18nKey={"modelcreator.min"}>Valeur minimale :</Trans></label>
-                                        <div className="flex flex-1 field-bg "><input
+                                        <div className="flex field-bg flex-1">
+                                            <label className={"flex-1"}><Trans i18nKey={"modelcreator.min"}>Valeur minimale :</Trans></label>
+                                            <input
                                             className={"flex-1"}
                                             disabled={modelLocked || (isLocalUser(me) && field.locked)}
                                             type={field.type === 'datetime' ? 'datetime-local' : field.type}
@@ -643,13 +638,16 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                                 }
                                                 setFields(newFields);
                                             }}
-                                        /></div>
+                                            />
+                                        </div>
                                     </div>
 
                                     <div className="flex flex-no-wrap mg-item">
                                         {hint('modelcreator.max.hint')}
-                                        <label className={"flex-1"}><Trans i18nKey={"modelcreator.max"}>Valeur maximale :</Trans></label>
-                                        <div className="flex flex-1 field-bg "><input
+                                        <div className="flex field-bg flex-1">
+                                            <label className={"flex-1"}><Trans i18nKey={"modelcreator.max"}>Valeur maximale :</Trans></label>
+                                            <input
+                                                className={"flex-1"}
                                             disabled={modelLocked || (isLocalUser(me) && field.locked)}
                                             type={field.type === 'datetime' ? 'datetime-local' : field.type}
                                             value={field.type === "number" ? (field.max + '').replace('.', ',') : field.max}
@@ -807,7 +805,6 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                             newFields[index].asMain = e;
                                             setFields(newFields);
                                         }}
-                                        help={field.asMain && t('modelcreator.asMain.hint')}
                                     />
                                 </div>
                             </div>)}
@@ -858,7 +855,6 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                             newFields[index].hiddenable = e;
                                             setFields(newFields);
                                         }}
-                                        help={field.unique && t('modelcreator.hiddenable.hint')}
                                     />
                                 </div>
                             </div>

package/client/src/ModelList.jsx

@@ -190,7 +190,7 @@ export function ModelList({ onModelSelect, onCreateModel, onImportModel, onEditM
                                         key={'modelist' + model.name} onClick={() => generatedModels.some(g => g.name === model.name) ? onEditModel(model) : onModelSelect(model)}>
                                         <div className="flex flex-center flex-fw">
                                             <div
-                                                className="flex flex-1 flex-no-wrap break-word">
+                                                className="flex flex-1 flex-no-wrap break-word gap-2">
                                                 <div className={"icon"}>{IconComponent ? IconComponent : <></>}</div>
                                                 <div>{t(`model_${model.name}`, model.name)} {generatedModels.some(f => f.name === model.name) ? '(tmp)' : (mods.some(f => f.mod === model.name) ? `(${mods.find(f => f.mod === model.name).count})` : '')}</div></div>
                                             <div className="btns">

package/client/src/constants.js

@@ -57,7 +57,7 @@ export const profiles = {
     }, // budget,
     'developer': {
         "packs": ["Multilingual starter pack", "Website Starter Pack"],
-        "models": ['alert','endpoint','request','webpage', 'content', 'taxonomy', 'resource', 'translation', 'contact', 'location', 'channel', 'lang', 'token', 'message', 'ticket', 'user', 'permission', 'role']
+        "models": ['alert','endpoint','request','kpi','webpage', 'content', 'taxonomy', 'resource', 'translation', 'contact', 'location', 'channel', 'lang', 'token', 'message', 'ticket', 'user', 'permission', 'role']
     },
     'company': {
         "packs": ["Multilingual starter pack", "E-commerce Starter Kit"],

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,8 @@
 export const websiteTranslations = {
     fr: {
         translation: {
+            "dashboards.addKpi": "Ajouter un indicateur KPI",
+
             "field.geolocation": "Géolocalisation",
             "time.minute": "Minute",
             "time.hour": "Heure",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-primals-engine",
-  "version": "1.4.3",
+  "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();
+}