data-primals-engine 1.2.0 → 1.2.1

package/README.md

@@ -9,6 +9,11 @@
 
 > Whether you're building a CRM, e-commerce site, CMS, or SaaS platform, **data-primals-engine** provides the strong foundations so you can focus on what makes your application unique.
 
+<p align="center">
+  <a href="https://data.primals.net/prez1.jpg" target="_blank"><img alt="Light" src="https://data.primals.net/prez1.jpg" width="35%"></a>
+  <a href="https://data.primals.net/prez6.jpg" target="_blank"><img alt="Light" src="https://data.primals.net/prez6.jpg" width="35%"></a>
+  <a href="https://data.primals.net/api-docs" target="_blank"><img alt="Dark" src="https://data.primals.net/prez5.jpg" width="25%"></a>
+</p>
 ---
 
 ## 🚀 Key Features
@@ -85,8 +90,8 @@ MONGO_DB_URL=mongodb://127.0.0.1:27017
 | SMTP_USER             | 	Username for SMTP authentication.                                      | 	user@example.com                        |
 | SMTP_PASS             | 	Password for SMTP authentication.                                      | 	password                                |
 | TLS                   | 	Encrypted connection (TLS) mode. Disabled by default                   | 	0/1 false/true                          |
-| CERT                  | 	Path to cert file.                                                     | 	certs/ca.crt                            |
-| CA_CERT               | 	Path to CA cert file.                                                  | 	certs/cert.pem                          |
+| CA_CERT               | 	Path to CA cert file.                                                  | 	certs/ca.crt                            |
+| CERT                  | 	Path to cert file.                                                     | 	certs/cert.pem                          |
 | CERT_KEY              | Path to the key file for your certificate.                              | 	certs/key.pem                           |
 
 ### Start the server
@@ -168,12 +173,11 @@ Activatable features:
 ### 🎫 Support Ticket System
 - Create ticket model with [open, pending, resolved] statuses
 - Configure notification workflows
-- Add custom endpoints for analytics
+- Add custom endpoints or dashboards/kpi for analytics
 
 ### 🤖 AI Chatbot 
 - Define your model
 - Set up workflow: "When new entry → generate AI content"
-- Connect to frontend chat interface
 
 ---
 
@@ -617,4 +621,4 @@ Distributed under the **MIT License**. See `LICENSE` file.
 
 ---
 
-## [🔼](#) Back to Top
+## [🔼](https://github.com/anonympins/data-primals-engine?tab=readme-ov-file#data-primals-engine) Back to Top

package/client/src/App.scss

@@ -1083,11 +1083,15 @@ h2.shadow {
 }
 
 .condition-details {
-  padding-left: 20px; // Indentation
+  padding-left: 4px;
+  margin-left:2px;
+  @media only screen and (min-width: 480px) {
+    padding-left: 20px; // Indentation
+    margin-left: 10px;
+    margin-top: 5px;
+    margin-bottom: 10px;
+  }
   border-left: 2px solid #eee; // Ligne visuelle
-  margin-left: 10px;
-  margin-top: 5px;
-  margin-bottom: 10px;
   gap: 5px; // Espacement entre les éléments de condition
 }
 
@@ -1290,9 +1294,10 @@ select[multiple]{
 }
 
 .datalayout {
-  padding: 0 16px;
+  @media only screen and (min-width: 480px) {
+    padding: 0 16px;
+  }
 }
-
 .main-menu {
   padding: 16px 0;
   @media only screen and (max-width: 479px) {

package/client/src/ConditionBuilder2.jsx

@@ -8,6 +8,30 @@ import {FaRepeat} from "react-icons/fa6";
 import {useAuthContext} from "./contexts/AuthContext.jsx";
 
 
+// Déterminer si le champ doit être une date
+const isDateArg = (operator, argIndex) => {
+    if (!operator) return false;
+
+    const opConfig = MONGO_CALC_OPERATORS[operator];
+    if (!opConfig) {
+        console.warn(`Opérateur non trouvé: ${operator}`);
+        return false;
+    }
+
+    // Cas spécial pour les opérateurs de date
+    if (operator === '$dateAdd' || operator === '$dateSubtract') {
+        return argIndex === 0; // Seul le premier argument est une date
+    }
+
+    // Pour les autres opérateurs marqués isDate (comme $hour, $second, etc.)
+    if (opConfig.isDate) {
+        return true; // Tous les arguments sont des dates pour ces opérateurs
+    }
+
+    return false;
+};
+
+
 const OperatorSelector = ({ onSelect }) => {
     const [search, setSearch] = useState('');
 
@@ -117,10 +141,12 @@ const ExpressionField = ({ value, onChange, path = [], fieldNames, isRoot = fals
         setEditing(false);
     };
 
+    console.log(path);
+    console.log(isDateArg(path[path.length - 1]));
 
     const renderArgument = (arg, index, parentOperator, args) => {
         const isSimpleValue = typeof arg !== 'object' || arg === null || Array.isArray(arg);
-
+        const parentOpConfig = MONGO_CALC_OPERATORS[parentOperator];
         // Fonction pour mettre à jour cet argument spécifique
         const handleArgChange = (newArgValue) => {
             const updatedArgs = [...args];
@@ -148,8 +174,6 @@ const ExpressionField = ({ value, onChange, path = [], fieldNames, isRoot = fals
                 onChange({ [parentOperator]: updatedArgs }, path);
             }
         };
-        const parentOpConfig = MONGO_CALC_OPERATORS[parentOperator];
-
         return (
             <div key={`arg-${index}`} className="expression-arg">
                 <div className="arg-content">
@@ -163,10 +187,11 @@ const ExpressionField = ({ value, onChange, path = [], fieldNames, isRoot = fals
                                     updatedArgs[index] = newValue;
                                     onChange({ [parentOperator]: updatedArgs }, path);
                                 }}
+                                isDate={isDateArg(path[path.length - 1], 0)} // Utilis
                                 fieldNames={fieldNames}
                                 isInFindContext={isInFindContext}
                             />
-                            {!parentOpConfig?.disableAdvancedValue && (<button
+                            {!parentOpConfig?.disableAdvancedValue && !isDateArg(path[path.length -1]) && (<button
                                 type="button"
                                 className="switch-to-expr"
                                 onClick={() => handleArgChange({ $eq: [arg, ""] })}
@@ -281,6 +306,7 @@ const ExpressionField = ({ value, onChange, path = [], fieldNames, isRoot = fals
                                 onChange={handleFieldChange}
                                 fieldNames={fieldNames}
                                 isFieldName={true}
+                                isDate={isDateArg(path[path.length - 1])}
                                 currentModelFields={currentModelFields} // Passer les champs complets
                                 onlyRelations={true}
                             />
@@ -607,12 +633,13 @@ const ExpressionField = ({ value, onChange, path = [], fieldNames, isRoot = fals
                     }}
                     fieldNames={fieldNames}
                     isInFindContext={isInFindContext}
+                    isDate={isDateArg(path[path.length - 1])}
                     currentModelFields={currentModelFields} // On propage le contexte
                 />
 
                 {/* --- MODIFICATION --- */}
                 {/* On affiche le bouton de conversion uniquement si l'opérateur parent le permet */}
-                {parentOpConfig?.disableAdvancedValue !== true && (
+                {parentOpConfig?.disableAdvancedValue !== true && !isDateArg(path[path.length - 1]) && (
                     <button
                         type="button"
                         className="switch-to-expr"
@@ -637,11 +664,13 @@ const FieldInput = ({
                         isFieldName = false,
                         isInFindContext = false,
                         currentModelFields = [],
-                        onlyRelations = false
+                        onlyRelations = false,
+                        isDate = false
                     }) => {
     const [inputValue, setInputValue] = useState(value);
     const [suggestions, setSuggestions] = useState([]);
     const [showSuggestions, setShowSuggestions] = useState(false);
+    const [showDatePicker, setShowDatePicker] = useState(false);
 
     useEffect(() => {
         setInputValue(value);
@@ -685,6 +714,18 @@ const FieldInput = ({
         setShowSuggestions(false);
     };
 
+    // Si c'est un champ date, on affiche le datepicker
+    if (isDate) {
+        return (
+            <div className="date-input-container">
+                <input
+                    type="datetime-local"
+                    value={inputValue ? new Date(inputValue).toISOString().slice(0, 16) : ''}
+                    onChange={(e) => handleDateChange(e.target.value)}
+                />
+            </div>
+        );
+    }
     return (
         <div className="field-input-container">
             <input

package/client/src/Field.jsx

@@ -493,7 +493,7 @@ const CheckboxField = forwardRef(
     };
     return (
         <>
-            <div className={cn({field: true, "field-checkbox": true})}>
+            <div className={cn({field: true, "field-checkbox": true,"field-bg": true})}>
                 <div className="inline"><input
                     aria-required={required}
                     aria-readonly={readOnly}

package/client/src/ModelCreator.jsx

@@ -526,7 +526,7 @@ const ModelCreator = forwardRef(({ initialPrompt = '', onModelGenerated, autoGen
                                 {/* Colonne de droite: Formulaire du modèle sélectionné */}
                                 <div className="model-form-container">
                                     {/* Le formulaire existant est placé ici */}
-                                    <div className="flex">
+                                    <div className="flex field-bg">
                                         <label htmlFor="modelName"><Trans i18nKey={"modelcreator.name"}>Nom:</Trans></label>
                                     </div>
                                     <TextField
@@ -539,7 +539,7 @@ const ModelCreator = forwardRef(({ initialPrompt = '', onModelGenerated, autoGen
                                         required
                                     />
 
-                                    <div className="flex">
+                                    <div className="flex field-bg">
                                         <label htmlFor="modelDescription"><Trans i18nKey={"modelcreator.description"}>Description:</Trans></label>
                                     </div>
                                     <TextField
@@ -570,7 +570,7 @@ const ModelCreator = forwardRef(({ initialPrompt = '', onModelGenerated, autoGen
                 {/* Affichage du formulaire en mode manuel ou édition */}
                 {(!useAI || initialModel) && (
                     <div className="model-form-container">
-                        <div className="flex">
+                        <div className="flex field-bg">
                             <label htmlFor="modelName"><Trans i18nKey={"modelcreator.name"}>Nom:</Trans></label>
                         </div>
                         <TextField
@@ -583,7 +583,7 @@ const ModelCreator = forwardRef(({ initialPrompt = '', onModelGenerated, autoGen
                             required
                         />
 
-                        <div className="flex">
+                        <div className="flex field-bg">
                             <label htmlFor="modelDescription"><Trans i18nKey={"modelcreator.description"}>Description:</Trans></label>
                         </div>
                         <TextField

package/client/src/ModelCreator.scss

@@ -2,6 +2,7 @@
   flex: 1;
   max-width: 720px;
   form {
+    padding: 0;
     @media only screen and (min-width: 480px){
       padding: 16px;
     }
@@ -151,4 +152,13 @@
       }
     }
   }
+}
+
+.field-bg {
+  background: #fcfcfc;
+  background: linear-gradient(180deg, rgba(252, 252, 252, 1) 0%, rgba(242, 242, 242, 1) 55%, rgba(242, 242, 242, 1) 100%);
+}
+
+.mg-item{
+  margin: 10px 0;
 }

package/client/src/ModelCreatorField.jsx

@@ -61,7 +61,7 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
             </div>
             <div className="flex flex-row flex-stretch">
 
-                <div className="flex fieldName">{hint('modelcreator.name.hint')}
+                <div className="flex fieldName field-bg">{hint('modelcreator.name.hint')}
                     <div className="flex flex-no-gap flex-no-wrap flex-1">
                         <TextField
                             label={t('modelcreator.fieldName')}
@@ -88,7 +88,7 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
 
                 <div className="flex">
                     {hint('modelcreator.type.hint')}
-                    <div className="flex flex-1 flex-stretch flex-no-gap">
+                    <div className="flex flex-1 flex-stretch field-bg flex-no-gap">
 
                         <SelectField
                             label={t('modelcreator.type', 'Type de champ')}
@@ -453,16 +453,15 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                             </div>
 
                             {!['file', 'relation', 'array', 'calculated'].includes(field.type) && (<div
-                                className="flex flex-no-wrap">
-                                {hint('modelcreator.default.hint')}
+                                className="flex flex-no-wrap field-bg mg-item">
 
                                 {['string_t', 'string', 'richtext', 'password', 'url', 'phone', 'email'].includes(field.type) && (<>
-                                    <label className="flex flex-1">
-                                        <Trans i18nKey={"modelcreator.default"}>Valeur par défaut :</Trans>
-                                        <input
-                                            type="text"
+                                    {hint('modelcreator.default.hint')}
+                                    <div className="flex flex-1">
+                                        <TextField
                                             className="flex-1"
                                             value={field.default}
+                                            label={<Trans i18nKey={"modelcreator.default"}>Valeur par défaut :</Trans>}
                                             disabled={modelLocked || (isLocalUser(me) && field.locked)}
                                             onChange={(e) => {
                                                 const newFields = [...fields];
@@ -470,9 +469,10 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                                 setFields(newFields);
                                             }}
                                         />
-                                    </label>
+                                    </div>
                                 </>)}
                                 {['number'].includes(field.type) && (<>
+                                    {hint('modelcreator.default.hint')}
                                     <NumberField
                                         label={<Trans i18nKey={"modelcreator.default"}>Valeur par défaut :</Trans>}
                                         type="number"
@@ -491,6 +491,7 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                     />
                                 </>)}
                                 {['enum'].includes(field.type) && (<>
+                                    {hint('modelcreator.default.hint')}
                                     <SelectField
                                         label={<Trans i18nKey={"modelcreator.default"}>Valeur par défaut :</Trans>}
                                         value={field.default}
@@ -505,6 +506,7 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                     />
                                 </>)}
                                 {['code'].includes(field.type) && (<>
+                                    {hint('modelcreator.default.hint')}
                                     <CodeField
                                         label={<Trans i18nKey={"modelcreator.default"}>Valeur par défaut :</Trans>}
                                         value={field.language === 'json' ? JSON.stringify(field.default, 2, null) : field.default}
@@ -516,6 +518,7 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                     />
                                 </>)}
                                 {['boolean'].includes(field.type) && (<>
+                                    {hint('modelcreator.default.hint')}
                                     <div className="checkbox-label flex flex-1">
                                         <CheckboxField
                                             label={<Trans i18nKey={"modelcreator.default"}>Valeur par défaut :</Trans>}
@@ -530,6 +533,7 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                     </div>
                                 </>)}
                                 {['color'].includes(field.type) && (<>
+                                    {hint('modelcreator.default.hint')}
                                     <ColorField
                                         label={<Trans i18nKey={"modelcreator.default"}>Valeur par défaut :</Trans>}
                                         value={field.default || null} name={field.name}
@@ -543,6 +547,7 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                     />
                                 </>)}
                                 {['date', 'datetime'].includes(field.type) && (<>
+                                    {hint('modelcreator.default.hint')}
                                     <label className="flex flex-1">
                                         <Trans i18nKey={"modelcreator.default"}>Valeur par défaut :</Trans>
                                         <input
@@ -562,7 +567,7 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
 
 
                             {(['number', 'datetime', 'date'].includes(field.itemsType || field.type)) && (
-                                <><label className="flex">
+                                <><label className="flex field-bg mg-item">
                                     {hint('modelcreator.min.hint')}
                                     <span><Trans
                                         i18nKey={"modelcreator.min"}>Valeur minimale :</Trans></span>
@@ -581,7 +586,7 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                         }}
                                     /></div>
                                 </label>
-                                    <label className="flex">
+                                    <label className="flex field-bg mg-item">
                                         {hint('modelcreator.max.hint')}
                                         <span><Trans i18nKey={"modelcreator.max"}>Valeur maximale :</Trans></span>
                                         <div className="flex flex-1"><input
@@ -601,13 +606,12 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                     </label>
                                 </>
                             )}
-                            <div className="flex flex-no-wrap">
+                            <div className="flex flex-no-wrap mg-item">
                                 {hint('modelcreator.condition.hint')}
 
-                                <label className="checkbox-label flex flex-1"><Trans
-                                    i18nKey={"modelcreator.condition"}>Condition</Trans> :
-                                    <input
-                                        type="checkbox"
+                                    <CheckboxField
+                                        label={<Trans
+                                            i18nKey={"modelcreator.condition"}>Condition</Trans>}
                                         disabled={modelLocked || (isLocalUser(me) && field.locked)}
                                         checked={field.condition !== undefined}
                                         onChange={(e) => {
@@ -620,7 +624,6 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                             setFields(newFields);
                                         }}
                                     />
-                                </label>
                             </div>
                             {field.condition !== undefined && (
                                 <div className={"condition-details flex flex-start"}>
@@ -691,10 +694,10 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
 
 
                             {mainFieldsTypes.includes(field.itemsType || field.type) && (<div
-                                className="flex flex-no-wrap"
+                                className="flex flex-no-wrap mg-item"
                                 title={t("modelcreator.field.asMain", "Une information principale sera affichée dans le titre de l'enregistrement")}>
                                 {hint('modelcreator.asMain.hint')}
-                                <label className="checkbox-label flex flex-1">
+                                <div className="flex flex-1">
 
                                     <CheckboxField
                                         label={<Trans i18nKey={"modelcreator.asMain"}>Information principale :</Trans>}
@@ -707,7 +710,7 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                                         }}
                                         help={field.asMain && t('modelcreator.asMain.hint')}
                                     />
-                                </label>
+                                </div>
                             </div>)}
 
                             <div className="flex flex-row flex-stretch">
@@ -729,7 +732,7 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
                             </div>
 
 
-                            <label className="flex">
+                            <label className="flex mg-item ">
                                 {hint('modelcreator.color.hint')}
                                 <Trans i18nKey={"field.color"}>Color :</Trans>
                                 <ColorField
@@ -763,19 +766,16 @@ const ModelCreatorField = ({model, handleRenameField, handleRemoveField, handleU
 
                             <div className={"flex flex-no-wrap"}>
                                 {hint('modelcreator.anonymized.hint')}
-                                <label className={"checkbox-label flex flex-1"}>
-                                    <Trans i18nKey={"modelcreator.anonymized"}>Donnée anonymisée :</Trans>
-                                    <input
-                                        type="checkbox"
-                                        disabled={modelLocked || (isLocalUser(me) && field.locked)}
-                                        checked={field.anonymized}
-                                        onChange={(e) => {
-                                            const newFields = [...fields];
-                                            newFields[index].anonymized = e.target.checked;
-                                            setFields(newFields);
-                                        }}
-                                    />
-                                </label>
+                                <CheckboxField
+                                    label={<Trans i18nKey={"modelcreator.anonymized"}>Donnée anonymisée :</Trans>}
+                                    disabled={modelLocked || (isLocalUser(me) && field.locked)}
+                                    checked={field.anonymized}
+                                    onChange={(e) => {
+                                        const newFields = [...fields];
+                                        newFields[index].anonymized = e.target.checked;
+                                        setFields(newFields);
+                                    }}
+                                />
                             </div>
 
 

package/client/src/RTE.jsx

@@ -28,6 +28,7 @@ import css from 'highlight.js/lib/languages/css'
 import js from 'highlight.js/lib/languages/javascript'
 import ts from 'highlight.js/lib/languages/typescript'
 import html from 'highlight.js/lib/languages/xml'
+import {escapeHtml, escapeRegex} from "data-primals-engine/core";
 // create a lowlight instance
 const lowlight = createLowlight(all)
 
@@ -43,7 +44,7 @@ const code = (c) => {
     const doc = document.createElement('div');
     doc.innerHTML = c;
     doc.querySelectorAll('code').forEach(cc =>{
-        cc.innerHTML = cc.textContent
+        cc.innerHTML = escapeHtml(cc.textContent)
             .replace(/\r\n|\n/g, "<br />")
             .replace(/\t/g, "&nbsp;&nbsp;&nbsp;&nbsp;");
     })

package/client/src/filter.js

@@ -53,6 +53,8 @@ export const MONGO_CALC_OPERATORS = {
     $ln: { label: 'ln', multi: false },
     $log10: { label: 'log', multi: false },
     $concat: { label: 'concat', multi: true },
+
+    // Date-specific
     $year: { label: 'year', multi: false, isDate: true },
     $month: { label: 'month', multi: false, isDate: true },
     $dayOfMonth: { label: 'dayOfMonth', multi: false, isDate: true },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-primals-engine",
-  "version": "1.2.0",
+  "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.",
   "main": "src/engine.js",
   "type": "module",
@@ -30,7 +30,8 @@
   "resolutions": {
     "tar-fs": "3.0.9",
     "on-headers": "1.1.0",
-    "brace-expansion": "2.0.2"
+    "brace-expansion": "2.0.2",
+    "prismjs": "1.30.0"
   },
   "repository": {
     "type": "git",

package/src/core.js

@@ -9,6 +9,12 @@ export function escapeRegex(string) {
     return string.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&');
 }
 
+export function escapeHtml(string){
+    return string.replace(/(javascript|data|vbscript):/gi, '').replace(/[^\w-_. ]/gi, function (c) {
+        return `&#${c.charCodeAt(0)};`;
+    });
+}
+
 export const isDate = dt => String(new Date(dt)) !== 'Invalid Date'
 
 export const safeAssignObject = (obj, key, value) => {

package/src/defaultModels.js

@@ -46,6 +46,39 @@ export const defaultModels = {
             { name: 'tokens', type: 'relation', multiple: true, relation: 'token' }
         ]
     },
+    userPermission: {
+        "name": "userPermission",
+        "description": "Gère les exceptions aux permissions des rôles pour un utilisateur (ajouts ou retraits, permanents ou temporaires).",
+        "fields": [
+            {
+                "name": "user",
+                "type": "relation",
+                "relation": "user",
+                "required": true,
+                "index": true
+            },
+            {
+                "name": "permission",
+                "type": "relation",
+                "relation": "permission",
+                "required": true,
+                "index": true
+            },
+            {
+                "name": "isGranted",
+                "type": "boolean",
+                "required": true,
+                "hint": "True pour accorder la permission, False pour la révoquer explicitement."
+            },
+            {
+                "name": "expiresAt",
+                "type": "datetime",
+                "required": false,
+                "index": true,
+                "hint": "Si défini, l'exception (l'octroi ou la révocation) est temporaire."
+            }
+        ]
+    },
     token: {
         name: 'token',
         "description": "",

package/src/modules/user.js

@@ -88,73 +88,128 @@ export async function onInit(defaultEngine) {
     engine = defaultEngine;
     logger = engine.getComponent(Logger);
 }
+/**
+ * Calcule et retourne l'ensemble des permissions actives pour un utilisateur.
+ * Cette fonction interne est la pierre angulaire de la nouvelle logique de permission.
+ * 1. Elle récupère toutes les permissions de base issues des rôles de l'utilisateur.
+ * 2. Elle applique ensuite les "exceptions" (ajouts ou retraits de permissions) qui sont valides (non expirées).
+ * @param {object} user - L'objet utilisateur pour lequel calculer les permissions.
+ * @returns {Promise<Set<string>>} Un Set contenant les noms de toutes les permissions actives.
+ * @private
+ */
+export async function getUserActivePermissions(user) {
+    const datasCollection = await getCollectionForUser(user);
+    const now = new Date();
+    const activePermissions = new Set();
 
-export async function hasPermission(permissionNames, user) {
-    if( !isLocalUser(user)){
-        return user.roles?.some(f => permissionNames.includes(f));
-    }
-    try {
-        // Si on a une string on le transforme en tableau.
-        const permissionNamesArray = Array.isArray(permissionNames) ? permissionNames : [permissionNames];
-        const collection = await getCollectionForUser(user);
+    // --- ÉTAPE 1: Récupérer les permissions de base des rôles ---
+    if (user.roles && user.roles.length > 0) {
+        const roleIds = user.roles.map(id => new ObjectId(id));
 
-        const job = [
+        const rolePermissions = await datasCollection.aggregate([
+            { $match: { _id: { $in: roleIds }, _model: "role" } },
+            { $unwind: "$permissions" },
+            { $addFields: { "permissionId": { "$toObjectId": "$permissions" } } },
             {
                 $lookup: {
-                    from: 'datas',
-                    let: { rolesIds: (user.roles ||[]).map(m => new ObjectId(m)) },
-                    pipeline: [
-                        {
-                            $match: {
-                                $expr: {
-                                    $and: [
-                                        { $in: ['$_id', '$$rolesIds'] }
-                                    ]
-                                }
-                            }
-                        },
-                        {
-                            $lookup: {
-                                from: 'datas',
-                                let: { rolePermissions: {
-                                    "$map": {
-                                        "input": "$permissions",
-                                        "in": { "$toObjectId": "$$this" }
-                                    }
-                                } },
-                                pipeline: [
-                                    {
-                                        $match: {
-                                            $expr: {
-                                                $and: [
-                                                    { $in: ['$_id', '$$rolePermissions'] }
-                                                ]
-                                            }
-                                        }
-                                    },
-                                    { $limit: 1 }
-                                ],
-                                as: 'permissions'
-                            }
-                        },
-                        { $unwind: { path: '$permissions', preserveNullAndEmptyArrays: true } }
-                    ],
-                    as: 'roles'
+                    from: datasCollection.collectionName, // Utiliser la même collection
+                    localField: "permissionId",
+                    foreignField: "_id",
+                    as: "permissionDoc"
                 }
             },
-            { $unwind: { path: '$roles', preserveNullAndEmptyArrays: true } },
-            { $match: { 'roles.permissions.name': { $in: permissionNamesArray } } }, // Match if permissions.name in array
-            { $limit: 1 },
-            { $project: { _id: 0, hasPermission: { $cond: [{ $in: ['$roles.permissions.name', permissionNamesArray] }, true, false] } } } //check the value
-        ];
-        const result = await collection.aggregate(job).toArray();
-        return result.length === 1 && result[0].hasPermission;
+            { $unwind: "$permissionDoc" },
+            { $group: { _id: "$permissionDoc.name" } }
+        ]).toArray();
+
+        rolePermissions.forEach(p => p._id && activePermissions.add(p._id));
+    }
+
+    // --- ÉTAPE 2: Appliquer les exceptions de permission ---
+    const exceptions = await datasCollection.aggregate([
+        {
+            $match: {
+                _model: "userPermission",
+                user: user._id, // Pas besoin de convertir en ObjectId si c'est déjà une string
+                $or: [
+                    { expiresAt: { $exists: false } },
+                    { expiresAt: { $gt: now } }
+                ]
+            }
+        },
+        {
+            $lookup: {
+                from: datasCollection.collectionName,
+                let: { permissionId: "$permission" },
+                pipeline: [
+                    {
+                        $match: {
+                            $expr: {
+                                $eq: [
+                                    "$_id",
+                                    { $toObjectId: "$$permissionId" } // Conversion ici
+                                ]
+                            }
+                        }
+                    },
+                    { $project: { name: 1 } }
+                ],
+                as: 'permissionDoc'
+            }
+        },
+        { $unwind: '$permissionDoc' }
+    ]).toArray();
+
+    // Appliquer les exceptions
+    for (const exception of exceptions) {
+        const permissionName = exception.permissionDoc?.name;
+        if (!permissionName) continue;
+
+        if (exception.isGranted) {
+            activePermissions.add(permissionName);
+        } else {
+            activePermissions.delete(permissionName);
+        }
+    }
+
+    return activePermissions;
+}
+
+/**
+ * Vérifie si un utilisateur possède au moins une des permissions spécifiées.
+ * Cette fonction utilise la nouvelle logique basée sur les rôles et les exceptions de permission.
+ * @param {string|string[]} permissionNames - Le nom de la permission ou un tableau de noms.
+ * @param {object} user - L'objet utilisateur authentifié.
+ * @returns {Promise<boolean>} - True si l'utilisateur a la permission, sinon false.
+ */
+export async function hasPermission(permissionNames, user) {
+    // Garde la compatibilité pour les utilisateurs non-locaux (ex: système)
+    if (!isLocalUser(user)) {
+        const userRoles = new Set(user.roles || []);
+        const requiredPermissions = Array.isArray(permissionNames) ? permissionNames : [permissionNames];
+        return requiredPermissions.some(p => userRoles.has(p));
+    }
+
+    try {
+        const requiredPermissions = Array.isArray(permissionNames) ? permissionNames : [permissionNames];
+        // Si aucune permission n'est requise, on autorise
+        if (requiredPermissions.length === 0) {
+            return true;
+        }
+
+        // 1. Obtenir l'ensemble final et à jour des permissions de l'utilisateur
+        const activePermissions = await getUserActivePermissions(user);
+
+        // 2. Vérifier si au moins une des permissions requises est dans l'ensemble des permissions actives
+        return requiredPermissions.some(pName => activePermissions.has(pName));
+
     } catch (e) {
-        logger.error(e);
+        logger.error("Erreur lors de la vérification des permissions :", e);
         return false;
     }
 }
 
+
 /**
  * Calcule l'utilisation totale de l'espace de stockage pour un utilisateur en octets.
  * Cela inclut la taille des documents dans sa collection de données et la taille de ses fichiers uploadés.

package/test/user.test.js

@@ -0,0 +1,203 @@
+import { expect, describe, it, beforeEach, beforeAll, afterAll } from 'vitest';
+import { hasPermission, getUserActivePermissions } from '../src/modules/user.js';
+import {initEngine} from "data-primals-engine/setenv";
+import {generateUniqueName} from "../src/setenv.js";
+import {
+    getCollectionForUser as getAppUserCollection,
+    modelsCollection as getAppModelsCollection
+} from "data-primals-engine/modules/mongodb";
+import {Config} from "../src/index.js";
+let permRead, permWrite, permDelete, permManage;
+let roleEditor;
+let testUser, adminUser, roleViewer;
+let currentTestUser;
+let testModelsColInstance, testDatasColInstance;
+// Cette fonction va remplacer la logique de votre beforeEach pour la création de contexte
+async function setupTestContext() {
+
+
+    // Créer un utilisateur unique pour ce test
+    const username = generateUniqueName('testuserDataIntegration');
+    currentTestUser = {
+        username,
+        userPlan: 'free',
+        _model: 'user',
+        _user: username,
+        email: generateUniqueName('test') + '@example.com'
+    };
+
+    // Initialize collection instances after the engine is ready
+    testModelsColInstance = getAppModelsCollection;
+    testDatasColInstance = await getAppUserCollection(currentTestUser);
+
+    await testDatasColInstance.deleteMany({}); // Nettoyage de la base de test
+    // 1. Créer les permissions
+    const permissions = await testDatasColInstance.insertMany([
+        { _model: 'permission', name: 'post:read', description: 'Lire les articles' },
+        { _model: 'permission', name: 'post:write', description: 'Écrire des articles' },
+        { _model: 'permission', name: 'post:delete', description: 'Supprimer des articles' },
+        { _model: 'permission', name: 'user:manage', description: 'Gérer les utilisateurs' }
+    ]);
+    permRead = permissions.insertedIds[0];
+    permWrite = permissions.insertedIds[1];
+    permDelete = permissions.insertedIds[2];
+    permManage = permissions.insertedIds[3];
+
+    // 2. Créer les rôles
+    const roles = await testDatasColInstance.insertMany([
+        { _user: currentTestUser.username, _model: 'role', name: 'Viewer', permissions: [permRead.toString()] },
+        { _user: currentTestUser.username, _model: 'role', name: 'Editor', permissions: [permRead.toString(), permWrite.toString()] }
+    ]);
+    roleViewer = roles.insertedIds[0];
+    roleEditor = roles.insertedIds[1];
+
+    // 3. Créer les utilisateurs
+    const users = await testDatasColInstance.insertMany([
+        { _user: currentTestUser.username, _model: 'user', roles: [roleEditor.toString()] },
+        { _user: currentTestUser.username, _model: 'user', roles: [roleEditor.toString()] }
+    ]);
+    testUser = {...currentTestUser, _id: users.insertedIds[0].toString(), roles: [roleEditor.toString()] };
+    adminUser = {...currentTestUser,  _id: users.insertedIds[1].toString(), roles: [roleEditor.toString()] };
+};
+let engine;
+describe('User Permission Logic', () => {
+
+    // --- SETUP : Création des données de test avant tous les tests ---
+    beforeAll(async () => {
+        Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
+        engine = await initEngine();
+
+    });
+
+    // --- Tests pour la fonction principale de calcul ---
+    describe('getUserActivePermissions()', () => {
+
+
+        beforeEach(async () =>{
+            await setupTestContext();
+        })
+        it('should return base permissions from the user\'s role', async () => {
+            const permissions = await getUserActivePermissions(testUser);
+            expect(permissions).to.be.an.instanceOf(Set);
+            expect(permissions.size).to.equal(2);
+            expect(permissions.has('post:read')).to.be.true;
+            expect(permissions.has('post:write')).to.be.true;
+            expect(permissions.has('post:delete')).to.be.false;
+        });
+
+        it('should grant a temporary permission via an exception', async () => {
+
+            // Ajoute une exception qui donne la permission de supprimer, expirant demain
+            const futureDate = new Date();
+            futureDate.setDate(futureDate.getDate() + 1);
+
+            await testDatasColInstance.insertOne({
+                _model: 'userPermission',
+                user: testUser._id,
+                permission: permDelete,
+                isGranted: true,
+                expiresAt: futureDate
+            });
+
+            const permissions = await getUserActivePermissions(testUser);
+            expect(permissions.size).to.equal(3);
+            expect(permissions.has('post:delete')).to.be.true;
+
+            // Nettoyage de l'exception pour ne pas affecter les autres tests
+            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+        });
+
+        it('should NOT grant an expired temporary permission', async () => {
+            // Ajoute une exception qui a expiré hier
+            const pastDate = new Date();
+            pastDate.setDate(pastDate.getDate() - 1);
+
+            await testDatasColInstance.insertOne({
+                _model: 'userPermission',
+                user: testUser._id,
+                permission: permDelete,
+                isGranted: true,
+                expiresAt: pastDate
+            });
+
+            const permissions = await getUserActivePermissions(testUser);
+            expect(permissions.size).to.equal(2); // Revient la normale
+            expect(permissions.has('post:delete')).to.be.false;
+
+            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+        });
+
+        it('should revoke a base permission via an exception', async () => {
+            // L'utilisateur est "Editor", mais on lui retire le droit d'écriture temporairement
+            const futureDate = new Date();
+            futureDate.setDate(futureDate.getDate() + 1);
+
+            await testDatasColInstance.insertOne({
+                _model: 'userPermission',
+                user: testUser._id,
+                permission: permWrite,
+                isGranted: false, // Révocation
+                expiresAt: futureDate
+            });
+
+            const permissions = await getUserActivePermissions(testUser);
+            expect(permissions.size).to.equal(1);
+            expect(permissions.has('post:read')).to.be.true;
+            expect(permissions.has('post:write')).to.be.false; // La permission a été retirée
+
+            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+        });
+
+        it('should restore a revoked permission if the revocation has expired', async () => {
+            // La révocation a expiré, l'utilisateur devrait retrouver son droit d'écriture
+            const pastDate = new Date();
+            pastDate.setDate(pastDate.getDate() - 1);
+
+            await testDatasColInstance.insertOne({
+                _model: 'userPermission',
+                user: testUser._id,
+                permission: permWrite,
+                isGranted: false,
+                expiresAt: pastDate
+            });
+
+            const permissions = await getUserActivePermissions(testUser);
+            expect(permissions.size).to.equal(2);
+            expect(permissions.has('post:write')).to.be.true; // La permission est de retour
+
+            await testDatasColInstance.deleteOne({ _model: 'userPermission', user: testUser._id });
+        });
+    });
+
+    // --- Tests pour la fonction publique `hasPermission` ---
+    describe('hasPermission()', () => {
+        beforeEach(async () => {
+            await setupTestContext();
+        });
+        it('should return true for a permission the user has', async () => {
+
+
+            console.log(await testDatasColInstance.find({ _model: 'permission' }).toArray());
+            console.log(await testDatasColInstance.find({ _model: 'role' }).toArray());
+            console.log(await testDatasColInstance.find({ _model: 'user' }).toArray());
+            console.log(await testDatasColInstance.find({ _model: 'userPermission' }).toArray());
+            const result = await hasPermission('post:read', testUser);
+            expect(result).to.be.true;
+        });
+
+        it('should return false for a permission the user does not have', async () => {
+            const result = await hasPermission('user:manage', testUser);
+            expect(result).to.be.false;
+        });
+
+        it('should return true if user has at least one of the required permissions', async () => {
+            const result = await hasPermission(['user:manage', 'post:write'], testUser);
+            expect(result).to.be.true;
+        });
+
+        it('should return false if user has none of the required permissions', async () => {
+            const result = await hasPermission(['user:manage', 'post:delete'], testUser);
+            expect(result).to.be.false;
+        });
+    });
+});