data-primals-engine 1.5.0 → 1.5.2

package/client/src/filter.js

@@ -1,213 +1,264 @@
-
-
-export const convertInputValue = (value) => {
-    if (typeof value !== 'string') return value;
-
-    if (value.startsWith('$')) {
-        // C'est une référence de champ
-        return value;
-    }
-
-    // Si la valeur est une chaîne entourée de guillemets, on la conserve telle quelle
-    if (/^['"].*['"]$/.test(value)) {
-        return value.slice(1, -1); // Retire les guillemets
-    }
-
-    // Conversion en nombre si possible
-    if (!isNaN(value) && value.trim() !== '') {
-        return Number(value);
-    }
-
-    if (value.toLowerCase() === 'null') return null;
-
-    // Conversion en booléen pour 'true' et 'false'
-    if (value.toLowerCase() === 'true') return true;
-    if (value.toLowerCase() === 'false') return false;
-
-    // Par défaut, retourne la chaîne telle quelle
-    return value;
-};
-
-const parseNode = (node, pathPrefix = '$') => {
-    if (node && node.path && Array.isArray(node.path)) {
-        return node;
-    }
-
-    if (!node || typeof node !== 'object' || Array.isArray(node)) {
-        return null;
-    }
-
-    const keys = Object.keys(node);
-    if (keys.length === 0) return null;
-
-    // Gestion des $find
-    if (keys.length === 1 && keys[0] === '$find') {
-        const findCondition = node.$find;
-        const parsedCondition = parseNode(findCondition, pathPrefix === '$' ? '$$this.' : pathPrefix);
-
-        if (parsedCondition) {
-            return {
-                ...parsedCondition,
-                path: parsedCondition.path || [],
-                op: '$find',
-                value: parsedCondition
-            };
-        }
-    }
-
-    // Gestion des opérateurs logiques
-    if (keys.length === 1 && (keys[0] === '$and' || keys[0] === '$or')) {
-        const children = node[keys[0]]
-            .map(childNode => parseNode(childNode, pathPrefix))
-            .filter(Boolean);
-        return { [keys[0]]: children };
-    }
-
-    // Gestion des opérateurs de comparaison
-    if (keys[0].startsWith('$')) {
-        const op = keys[0];
-        const args = node[op];
-
-        // Cas spécial pour regexMatch
-        if (op === '$regexMatch' && typeof args === 'object') {
-            const transformExpr = reverseTransformExpr(args.input, pathPrefix === '$$this.');
-            return {
-                path: transformExpr.path || [args.input.substring(pathPrefix.length).split('.')],
-                op: '$regex',
-                value: args.regex,
-                transform: transformExpr.transform
-            };
-        }
-
-        // Cas spécial pour exists
-        if ((op === '$ne' || op === '$eq') && Array.isArray(args) && args.length === 2 &&
-            typeof args[0] === 'object' && args[0].$type && args[1] === 'missing') {
-            const transformExpr = reverseTransformExpr(args[0].$type, pathPrefix === '$$this.');
-            return {
-                path: transformExpr.path || [args[0].$type.substring(pathPrefix.length).split('.')],
-                op: '$exists',
-                value: op === '$ne',
-                transform: transformExpr.transform
-            };
-        }
-
-        // Cas normal avec transformation
-        if (Array.isArray(args) && args.length === 2) {
-            const transformExpr = reverseTransformExpr(args[0], pathPrefix === '$$this.');
-            return {
-                path: transformExpr.path || [args[0].substring(pathPrefix.length).split('.')],
-                op,
-                value: args[1],
-                transform: transformExpr.transform
-            };
-        }
-
-        // Cas des transformations pures
-        const transformExpr = reverseTransformExpr(node, pathPrefix === '$$this.');
-        if (transformExpr && transformExpr.transform) {
-            return {
-                path: transformExpr.path || [keys[0].substring(1)],
-                transform: transformExpr.transform
-            };
-        }
-    }
-
-    // Gestion des champs simples
-    const path = keys[0];
-    if (typeof path === 'string' && !path.startsWith('$')) {
-        const condition = node[path];
-        if (typeof condition === 'object' && condition !== null && !Array.isArray(condition)) {
-            if (condition.$find) {
-                const parsedInnerNode = parseNode(condition.$find, '$$this.');
-                if (parsedInnerNode) {
-                    return {
-                        ...parsedInnerNode,
-                        path: [path, ...(parsedInnerNode.path || [])]
-                    };
-                }
-            } else {
-                const parsedCondition = parseNode(condition, pathPrefix);
-                if (parsedCondition) {
-                    return {
-                        ...parsedCondition,
-                        path: [path, ...(parsedCondition.path || [])]
-                    };
-                }
-            }
-        } else {
-            return {
-                path: [path],
-                op: '$eq',
-                value: condition
-            };
-        }
-    }
-
-    return null;
-};
-
-
-export const buildRootFromExpr = (query) => {
-    if (!query || typeof query !== 'object' || Array.isArray(query)) {
-        return { $and: [] };
-    }
-
-    const exprToParse = query.$expr || query;
-    const parsedRoot = parseNode(exprToParse);
-
-    if (!parsedRoot) return { $and: [] };
-    if (parsedRoot.$and || parsedRoot.$or) return parsedRoot;
-
-    return { $and: [parsedRoot] };
-};
-
-export const pagedFilterToMongoConds = (pagedFilters, model) => {
-    const modelFilter = pagedFilters?.[model.name] || {};
-    const filterKeys = Object.keys(modelFilter);
-
-    // Si le filtre est vide, on retourne un tableau vide.
-    if (filterKeys.length === 0) {
-        return [];
-    }
-
-    // Détecte si c'est un filtre avancé (contient des opérateurs logiques de haut niveau comme $and, $or, etc.)
-    const isAdvancedFilter = filterKeys.some(key => key.startsWith('$'));
-
-    if (isAdvancedFilter) {
-        // C'est un filtre avancé du ConditionBuilder.
-        // Il est déjà une condition MongoDB complète. On le met dans un tableau pour l'insérer dans le $and global.
-        // Si le filtre avancé est vide (ex: { $and: [] }), on le retourne quand même pour que le ConditionBuilder puisse s'initialiser correctement.
-        return [modelFilter];
-    } else {
-        // C'est un filtre simple (par colonne).
-        // On transforme { champ1: cond1, champ2: cond2 } en [{ champ1: cond1 }, { champ2: cond2 }]
-        const c = [];
-        filterKeys.forEach(fieldName => {
-            if (model.fields.some(f => f.name === fieldName)) {
-                const condition = modelFilter[fieldName];
-                if (condition && typeof condition === 'object' && Object.keys(condition).length > 0) {
-                    c.push(condition);
-                }
-            }
-        });
-        return c;
-    }
-};
-
-/**
- * Remplace les placeholders dans un objet filtre.
- * Gère {{userId}}.
- */
-export const processFilterPlaceholders = (filter, user) => {
-    const processedFilter = JSON.parse(JSON.stringify(filter));
-    for (const key in processedFilter) {
-        if (processedFilter[key] === '{{userId}}') {
-            // Dans le système Primals, le champ utilisateur est souvent `_user`
-            // et contient le nom d'utilisateur, pas l'ID. Adaptez si besoin.
-            processedFilter[key] = user.username;
-        } else if (typeof processedFilter[key] === 'object' && processedFilter[key] !== null) {
-            processedFilter[key] = processFilterPlaceholders(processedFilter[key], user);
-        }
-    }
-    return processedFilter;
+
+/**
+ * Finds the matching {{/each}} for a {{#each ...}} tag at a given position.
+ * It correctly handles nested {{#each}} blocks.
+ * @param {string} template - The template string.
+ * @param {number} startIndex - The starting position of the opening {{#each ...}} tag.
+ * @returns {number} The position of the start of the matching {{/each}} tag, or -1 if not found.
+ */
+function findMatchingEndEach(template, startIndex) {
+    const openTag = '{{#each';
+    const closeTag = '{{/each}}';
+    let level = 1;
+    let searchPos = startIndex + openTag.length;
+
+    while (level > 0 && searchPos < template.length) {
+        const nextClose = template.indexOf(closeTag, searchPos);
+        if (nextClose === -1) {
+            return -1; // Unmatched opening tag
+        }
+
+        const nextOpen = template.indexOf(openTag, searchPos);
+
+        if (nextOpen !== -1 && nextOpen < nextClose) {
+            level++;
+            searchPos = nextOpen + openTag.length;
+        } else {
+            level--;
+            searchPos = nextClose + closeTag.length;
+            if (level === 0) {
+                return nextClose; // Found the matching closing tag
+            }
+        }
+    }
+    return -1; // No matching closing tag found
+}
+
+/**
+ * Renders a simple HTML template by substituting placeholders.
+ * This is a robust version that correctly handles nested {{#each}} loops.
+ *
+ * @param {string} templateString The template with placeholders.
+ * @param {Array<object>|object} data The data to inject.
+ * @returns {string} The rendered HTML string.
+ */
+
+/**
+ * Renders a simple HTML template by substituting placeholders.
+ * This is a robust version that correctly handles nested {{#each}} loops.
+ *
+ * @param {string} templateString The template with placeholders.
+ * @param {Array<object>|object} data The data to inject.
+ * @returns {string} The rendered HTML string.
+ */
+export const convertInputValue = (value) => {
+    if (typeof value !== 'string') return value;
+
+    if (value.startsWith('$')) {
+        // C'est une référence de champ
+        return value;
+    }
+
+    // Si la valeur est une chaîne entourée de guillemets, on la conserve telle quelle
+    if (/^['"].*['"]$/.test(value)) {
+        return value.slice(1, -1); // Retire les guillemets
+    }
+
+    // Conversion en nombre si possible
+    if (!isNaN(value) && value.trim() !== '') {
+        return Number(value);
+    }
+
+    if (value.toLowerCase() === 'null') return null;
+
+    // Conversion en booléen pour 'true' et 'false'
+    if (value.toLowerCase() === 'true') return true;
+    if (value.toLowerCase() === 'false') return false;
+
+    // Par défaut, retourne la chaîne telle quelle
+    return value;
+};
+
+const parseNode = (node, pathPrefix = '$') => {
+    if (node && node.path && Array.isArray(node.path)) {
+        return node;
+    }
+
+    if (!node || typeof node !== 'object' || Array.isArray(node)) {
+        return null;
+    }
+
+    const keys = Object.keys(node);
+    if (keys.length === 0) return null;
+
+    // Gestion des $find
+    if (keys.length === 1 && keys[0] === '$find') {
+        const findCondition = node.$find;
+        const parsedCondition = parseNode(findCondition, pathPrefix === '$' ? '$$this.' : pathPrefix);
+
+        if (parsedCondition) {
+            return {
+                ...parsedCondition,
+                path: parsedCondition.path || [],
+                op: '$find',
+                value: parsedCondition
+            };
+        }
+    }
+
+    // Gestion des opérateurs logiques
+    if (keys.length === 1 && (keys[0] === '$and' || keys[0] === '$or')) {
+        const children = node[keys[0]]
+            .map(childNode => parseNode(childNode, pathPrefix))
+            .filter(Boolean);
+        return { [keys[0]]: children };
+    }
+
+    // Gestion des opérateurs de comparaison
+    if (keys[0].startsWith('$')) {
+        const op = keys[0];
+        const args = node[op];
+
+        // Cas spécial pour regexMatch
+        if (op === '$regexMatch' && typeof args === 'object') {
+            const transformExpr = reverseTransformExpr(args.input, pathPrefix === '$$this.');
+            return {
+                path: transformExpr.path || [args.input.substring(pathPrefix.length).split('.')],
+                op: '$regex',
+                value: args.regex,
+                transform: transformExpr.transform
+            };
+        }
+
+        // Cas spécial pour exists
+        if ((op === '$ne' || op === '$eq') && Array.isArray(args) && args.length === 2 &&
+            typeof args[0] === 'object' && args[0].$type && args[1] === 'missing') {
+            const transformExpr = reverseTransformExpr(args[0].$type, pathPrefix === '$$this.');
+            return {
+                path: transformExpr.path || [args[0].$type.substring(pathPrefix.length).split('.')],
+                op: '$exists',
+                value: op === '$ne',
+                transform: transformExpr.transform
+            };
+        }
+
+        // Cas normal avec transformation
+        if (Array.isArray(args) && args.length === 2) {
+            const transformExpr = reverseTransformExpr(args[0], pathPrefix === '$$this.');
+            return {
+                path: transformExpr.path || [args[0].substring(pathPrefix.length).split('.')],
+                op,
+                value: args[1],
+                transform: transformExpr.transform
+            };
+        }
+
+        // Cas des transformations pures
+        const transformExpr = reverseTransformExpr(node, pathPrefix === '$$this.');
+        if (transformExpr && transformExpr.transform) {
+            return {
+                path: transformExpr.path || [keys[0].substring(1)],
+                transform: transformExpr.transform
+            };
+        }
+    }
+
+    // Gestion des champs simples
+    const path = keys[0];
+    if (typeof path === 'string' && !path.startsWith('$')) {
+        const condition = node[path];
+        if (typeof condition === 'object' && condition !== null && !Array.isArray(condition)) {
+            if (condition.$find) {
+                const parsedInnerNode = parseNode(condition.$find, '$$this.');
+                if (parsedInnerNode) {
+                    return {
+                        ...parsedInnerNode,
+                        path: [path, ...(parsedInnerNode.path || [])]
+                    };
+                }
+            } else {
+                const parsedCondition = parseNode(condition, pathPrefix);
+                if (parsedCondition) {
+                    return {
+                        ...parsedCondition,
+                        path: [path, ...(parsedCondition.path || [])]
+                    };
+                }
+            }
+        } else {
+            return {
+                path: [path],
+                op: '$eq',
+                value: condition
+            };
+        }
+    }
+
+    return null;
+};
+
+
+export const buildRootFromExpr = (query) => {
+    if (!query || typeof query !== 'object' || Array.isArray(query)) {
+        return { $and: [] };
+    }
+
+    const exprToParse = query.$expr || query;
+    const parsedRoot = parseNode(exprToParse);
+
+    if (!parsedRoot) return { $and: [] };
+    if (parsedRoot.$and || parsedRoot.$or) return parsedRoot;
+
+    return { $and: [parsedRoot] };
+};
+
+export const pagedFilterToMongoConds = (pagedFilters, model) => {
+    const modelFilter = pagedFilters?.[model.name] || {};
+    const filterKeys = Object.keys(modelFilter);
+
+    // Si le filtre est vide, on retourne un tableau vide.
+    if (filterKeys.length === 0) {
+        return [];
+    }
+
+    // Détecte si c'est un filtre avancé (contient des opérateurs logiques de haut niveau comme $and, $or, etc.)
+    const isAdvancedFilter = filterKeys.some(key => key.startsWith('$'));
+
+    if (isAdvancedFilter) {
+        // C'est un filtre avancé du ConditionBuilder.
+        // Il est déjà une condition MongoDB complète. On le met dans un tableau pour l'insérer dans le $and global.
+        // Si le filtre avancé est vide (ex: { $and: [] }), on le retourne quand même pour que le ConditionBuilder puisse s'initialiser correctement.
+        return [modelFilter];
+    } else {
+        // C'est un filtre simple (par colonne).
+        // On transforme { champ1: cond1, champ2: cond2 } en [{ champ1: cond1 }, { champ2: cond2 }]
+        const c = [];
+        filterKeys.forEach(fieldName => {
+            if (model.fields.some(f => f.name === fieldName)) {
+                const condition = modelFilter[fieldName];
+                if (condition && typeof condition === 'object' && Object.keys(condition).length > 0) {
+                    c.push(condition);
+                }
+            }
+        });
+        return c;
+    }
+};
+
+/**
+ * Remplace les placeholders dans un objet filtre.
+ * Gère {{userId}}.
+ */
+export const processFilterPlaceholders = (filter, user) => {
+    const processedFilter = JSON.parse(JSON.stringify(filter));
+    for (const key in processedFilter) {
+        if (processedFilter[key] === '{{userId}}') {
+            // Dans le système Primals, le champ utilisateur est souvent `_user`
+            // et contient le nom d'utilisateur, pas l'ID. Adaptez si besoin.
+            processedFilter[key] = user.username;
+        } else if (typeof processedFilter[key] === 'object' && processedFilter[key] !== null) {
+            processedFilter[key] = processFilterPlaceholders(processedFilter[key], user);
+        }
+    }
+    return processedFilter;
 };

package/client/src/hooks/useValidation.js

@@ -0,0 +1,75 @@
+import {useMutation, useQuery} from 'react-query';
+import { debounce } from '../../../src/core.js';
+import { useState, useCallback, useMemo } from 'react';
+
+/**
+ * Validates a field on the server.
+ * @param {object} api - The API client instance.
+ * @param {object} payload - The validation payload.
+ * @param {string} payload.model - The model name.
+ * @param {object} payload.data - The field and value to validate, e.g., { email: '...' }.
+ * @param {string} [payload.contextId] - The ID of the document being edited.
+ * @returns {Promise<any>}
+ */
+const validateFieldOnServer = async (api, payload) => {
+    return fetch('/api/data/validate', { method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        }
+    });
+};
+
+export const useRealtimeValidation = (modelName, docId) => {
+
+    const [validationState, setValidationState] = useState({}); // { fieldName: { status, error } }
+
+    const mutation = useMutation(
+        (payload) => validateFieldOnServer(api, payload),
+        {
+            onSuccess: (data, variables) => {
+                const fieldName = Object.keys(variables.data)[0];
+                setValidationState(prev => ({
+                    ...prev,
+                    [fieldName]: { status: 'valid', error: null }
+                }));
+            },
+            onError: (error, variables) => {
+                const fieldName = Object.keys(variables.data)[0];
+                setValidationState(prev => ({
+                    ...prev,
+                    [fieldName]: { status: 'invalid', error: error.response?.data?.error || 'Validation failed' }
+                }));
+            }
+        }
+    );
+
+    const debouncedValidate = useMemo(
+        () => debounce((field, value) => {
+            if (value === '' || value === null || value === undefined) {
+                setValidationState(prev => ({ ...prev, [field]: { status: 'idle', error: null } }));
+                mutation.reset();
+                return;
+            }
+
+            setValidationState(prev => ({ ...prev, [field]: { status: 'validating', error: null } }));
+            mutation.mutate({
+                model: modelName,
+                contextId: docId,
+                data: { [field]: value }
+            });
+        }, 500),
+        [modelName, docId, mutation]
+    );
+
+    const validate = useCallback((field, value) => {
+        if (!modelName) return; // Don't validate if not configured
+        debouncedValidate(field, value);
+    }, [debouncedValidate, modelName]);
+
+    const resetValidation = useCallback(() => {
+        setValidationState({});
+        mutation.reset();
+    }, [mutation]);
+
+    return { validate, validationState, resetValidation };
+};