data-primals-engine 1.0.10 → 1.1.0

package/client/src/filter.js

@@ -0,0 +1,222 @@
+
+export const MONGO_CALC_OPERATORS = {
+    $find: {
+        label: 'Find in relation',
+        description: 'Recherche dans une relation/tableau',
+        supportsNesting: true,
+        multi: false,
+        isFindOperator: true // Nouvelle propriété pour identifier les opérateurs $find
+    },
+    $and: { label: 'Et (and)', description: 'Renvoie vrai si toutes les conditions sont vérifiées', args: 1, multi: true },
+    $or: { label: 'Ou (or)', description: 'Renvoie vrai si au moins une des conditions est vérifiée.', args: 1, multi: true },
+    $not: { label: 'Non (not)', description: 'Inverse la condition (ex: non égal à).', args: 1, multi: true },
+    $nor: { label: 'Ou Non (nor)', description: 'Renvoie vrai si aucune des conditions n\'est vérifiée', args: 1, multi: true },
+    $eq: { label: '=', multi: false, args: 2 },
+    $ne: { label: '!=', multi: false, args: 2 },
+    $gt: { label: '>', multi: false, args: 2 },
+    $gte: { label: '>=', multi: false, args: 2 },
+    $lt: { label: '<', multi: false, args: 2 },
+    $lte: { label: '<=', multi: false, args: 2 },
+    $in: { label: 'in', multi: true, args: 2 },
+    $nin: { label: 'nin', multi: true, args: 2 },
+    $all: { label: 'afll', multi: true },
+    $size: {
+        label: 'size',
+        multi: false,
+        description: 'Renvoie le nombre d\'éléments dans un tableau',
+        disableAdvancedValue: true
+    },
+    $elemMatch: { label: 'elemMatch', multi: true },
+    $type: {
+        label: 'type',
+        description: 'Renvoie le type BSON de l\'élément',
+        multi: false,
+        disableAdvancedValue: true
+    },
+    $add: { label: '+', multi: true },
+    $subtract: { label: '-', multi: false, args: 2 },
+    $multiply: { label: '*', multi: true },
+    $divide: { label: '/', multi: false, args: 2 },
+    $mod: { label: '%', multi: false, args: 2 },
+    $pow: { label: 'pow', multi: false },
+    $sqrt: { label: 'sqrt', multi: false },
+    $exp: { label: 'exp', multi: false },
+    $abs: { label: 'abs', multi: false },
+    $ceil: { label: 'ceil', multi: false },
+    $floor: { label: 'floor', multi: false },
+    $ln: { label: 'ln', multi: false },
+    $log10: { label: 'log', multi: false },
+    $concat: { label: 'concat', multi: true },
+    $year: { label: 'year', multi: false, isDate: true },
+    $month: { label: 'month', multi: false, isDate: true },
+    $dayOfMonth: { label: 'dayOfMonth', multi: false, isDate: true },
+    $hour: { label: 'hour', multi: false, isDate: true },
+    $minute: { label: 'minute', multi: false, isDate: true },
+    $second: { label: 'second', multi: false, isDate: true },
+    $millisecond: { label: 'ms', multi: false, isDate: true },
+    $toBool: { label: 'toBool', multi: false, converter: true },
+    $toString: { label: 'toString', multi: false, converter: true },
+    $toInt: { label: 'toInt', multi: false, converter: true },
+    $toDouble: { label: 'toDouble', multi: false, converter: true },
+};
+
+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] };
+};

package/client/src/hooks/data.js

@@ -0,0 +1,101 @@
+import {useQuery} from "react-query";
+import {getObjectHash} from "data-primals-engine/core";
+import {useAuthContext} from "../contexts/AuthContext.jsx";
+import {getUserHash, getUserId} from "data-primals-engine/data";
+import {useTranslation} from "react-i18next";
+import {useEffect, useState} from "react";
+import {useUI} from "../contexts/UIContext.jsx";
+import {useNotificationContext} from "../NotificationProvider.jsx";
+
+export const useData = (model, filter, options) => {
+    const { me } = useAuthContext();
+    const { i18n, t } = useTranslation();
+    const lang = (i18n.resolvedLanguage || i18n.language).split(/[-_]/)?.[0];
+    return useQuery([options.queryKey || model, filter, me], () => {
+        return fetch('/api/data/search?limit='+(options.limit||1)+'&lang='+(options.lang||lang)+'&_user=' + encodeURIComponent(getUserId(me)) + '&model='+model, {
+            method: 'POST',
+            body: JSON.stringify({filter}),
+            headers: { "Content-Type": "application/json"}}
+        )
+            .then(e => e.json())
+            .then(e => e.data);
+    }, {...options, enabled: typeof(options.enabled) === "undefined" ? !!getUserId(me) : options.enabled });
+}
+
+
+export const useAlerts = () => {
+    // 2. Supprimer l'état local 'alerts', il sera géré par le UIContext
+    // const [alerts, setAlerts] = useState([]);
+    const [isConnected, setIsConnected] = useState(false);
+    const { me } = useAuthContext();
+    const { addNotification } = useNotificationContext(); // 3. Récupérer la fonction addNotification du contexte
+
+    useEffect(() => {
+        if (!me?.username || !addNotification) { // S'assurer que addNotification est disponible
+            if (isConnected) setIsConnected(false);
+            return;
+        }
+
+        console.log("Attempting to connect to SSE for alerts...");
+        const eventSource = new EventSource('/api/alerts/subscribe');
+
+        eventSource.onopen = () => {
+            console.log('SSE connection established for alerts.');
+            setIsConnected(true);
+        };
+
+        eventSource.onmessage = (event) => {
+            try {
+                const newAlert = JSON.parse(event.data);
+
+                if (newAlert.type === 'connection_established') {
+                    console.log(`SSE Status: ${newAlert.message}`);
+                    return;
+                }
+
+                // 4. Remplacer setAlerts par addNotification
+                // On crée un objet notification standard que votre système peut afficher.
+                if (newAlert.type === 'cron_alert') {
+                    addNotification({
+                        type: 'info', // ou 'success', 'warning' selon ce que votre système supporte
+                        title: 'Alerte planifiée',
+                        message: newAlert.message,
+                        duration: 10000 // Durée d'affichage en ms (10 secondes)
+                    });
+                }
+
+                // La notification native du navigateur peut rester si vous le souhaitez
+                /*if (Notification.permission === "granted") {
+                    new Notification("Nouvelle Alerte", {
+                        body: newAlert.message,
+                        icon: "/logo.png"
+                    });
+                }*/
+
+            } catch (error) {
+                console.error("Failed to parse SSE data:", error);
+            }
+        };
+
+        eventSource.onerror = (error) => {
+            console.error('SSE Error:', error);
+            setIsConnected(false);
+            eventSource.close();
+        };
+
+        return () => {
+            console.log("Closing SSE connection.");
+            eventSource.close();
+            setIsConnected(false);
+        };
+    }, [me?.username, addNotification]); // Ajouter addNotification aux dépendances
+
+    useEffect(() => {
+        /*if ("Notification" in window && Notification.permission !== "denied") {
+            Notification.requestPermission();
+        }*/
+    }, []);
+
+    // 5. Mettre à jour la valeur de retour. Le hook n'a plus besoin de retourner la liste des alertes.
+    return { isConnected };
+};

package/client/src/hooks/useDebounce.js

@@ -0,0 +1,20 @@
+// src/hooks/useDebounce.js
+import { useState, useEffect } from 'react';
+
+function useDebounce(value, delay) {
+    const [debouncedValue, setDebouncedValue] = useState(value);
+
+    useEffect(() => {
+        const handler = setTimeout(() => {
+            setDebouncedValue(value);
+        }, delay);
+
+        return () => {
+            clearTimeout(handler);
+        };
+    }, [value, delay]);
+
+    return debouncedValue;
+}
+
+export default useDebounce;

package/client/src/hooks/useDragAndDrop.js

@@ -0,0 +1,59 @@
+// C:/Dev/hackersonline-engine/client/src/hooks/useDragAndDrop.js
+import { useState, useRef, useCallback } from 'react';
+
+const useDragAndDrop = () => {
+    const [isDragging, setIsDragging] = useState(false);
+    const draggedItemRef = useRef(null); // Changed name for clarity
+    const [dragOverContainerId, setDragOverContainerId] = useState(null);
+    // dropPosition might not be needed if we simplify
+
+    const handleNodeDragStart = useCallback((nodeId) => {
+        setIsDragging(true);
+        draggedItemRef.current = nodeId;
+        console.log("useDragAndDrop: Dragging node with ID:", nodeId);
+    }, []);
+
+    const handleContainerDragEnter = useCallback((containerId) => {
+        setDragOverContainerId(containerId);
+    }, []);
+
+    const handleContainerDragLeave = useCallback(() => {
+        setDragOverContainerId(null);
+    }, []);
+
+    // This is for the draggable item's onDragEnd
+    const handleItemDragEnd = useCallback(() => {
+        setIsDragging(false);
+        // Do NOT reset draggedItemRef.current here.
+        // It's needed by the onDrop handler of the container.
+        console.log("useDragAndDrop: Item drag ended. Current draggedItemRef:", draggedItemRef.current);
+    }, []);
+
+    // This is for the droppable container's onDrop
+    const finalizeDropAndGetData = useCallback(() => {
+        const droppedItemId = draggedItemRef.current;
+
+        // Reset state after retrieving the ID
+        setIsDragging(false);
+        draggedItemRef.current = null;
+        setDragOverContainerId(null);
+        // setDropPosition(null); // if you were using it
+
+        console.log("useDragAndDrop: Finalized drop. Dropped ID:", droppedItemId);
+        return droppedItemId; // Return the ID of the item that was dropped
+    }, []);
+
+    return {
+        isDragging,
+        draggedItemRef, // Expose the ref object
+        dragOverContainerId,
+        // dropPosition,
+        handleNodeDragStart,
+        handleContainerDragEnter,
+        handleContainerDragLeave,
+        handleItemDragEnd,    // For draggable's onDragEnd
+        finalizeDropAndGetData // For droppable's onDrop
+    };
+};
+
+export default useDragAndDrop;

package/client/src/hooks/useLocalStorage.js

@@ -0,0 +1,100 @@
+import {useEffect, useMemo, useRef, useState} from "react";
+
+function useLocalStorage(
+    key,
+    defaultValue,
+    options
+) {
+    const opts = useMemo(() => {
+        return {
+            serializer: JSON.stringify,
+            parser: JSON.parse,
+            logger: console.log,
+            syncData: true,
+            ...options,
+        };
+    }, [options]);
+
+    const { serializer, parser, logger, syncData } = opts;
+
+    const rawValueRef = useRef(null);
+
+    const [value, setValue] = useState(() => {
+        if (typeof window === "undefined") return defaultValue;
+
+        try {
+            rawValueRef.current = window.localStorage.getItem(key);
+            return rawValueRef.current
+                ? parser(rawValueRef.current)
+                : defaultValue;
+        } catch (e) {
+            logger(e);
+            return defaultValue;
+        }
+    });
+
+    useEffect(() => {
+        if (typeof window === "undefined") return;
+
+        const updateLocalStorage = () => {
+            // Browser ONLY dispatch storage events to other tabs, NOT current tab.
+            // We need to manually dispatch storage event for current tab
+            if (value !== undefined) {
+                const newValue = serializer(value);
+                const oldValue = rawValueRef.current;
+                rawValueRef.current = newValue;
+                window.localStorage.setItem(key, newValue);
+                window.dispatchEvent(
+                    new StorageEvent("storage", {
+                        storageArea: window.localStorage,
+                        url: window.location.href,
+                        key,
+                        newValue,
+                        oldValue,
+                    })
+                );
+            } else {
+                window.localStorage.removeItem(key);
+                window.dispatchEvent(
+                    new StorageEvent("storage", {
+                        storageArea: window.localStorage,
+                        url: window.location.href,
+                        key,
+                    })
+                );
+            }
+        };
+
+        try {
+            updateLocalStorage();
+        } catch (e) {
+            logger(e);
+        }
+    }, [value]);
+
+    useEffect(() => {
+        if (!syncData) return;
+
+        const handleStorageChange = (e) => {
+            if (e.key !== key || e.storageArea !== window.localStorage) return;
+
+            try {
+                if (e.newValue !== rawValueRef.current) {
+                    rawValueRef.current = e.newValue;
+                    setValue(e.newValue ? parser(e.newValue) : undefined);
+                }
+            } catch (e) {
+                logger(e);
+            }
+        };
+
+        if (typeof window === "undefined") return;
+
+        window.addEventListener("storage", handleStorageChange);
+        return () => window.removeEventListener("storage", handleStorageChange);
+    }, [key, syncData]);
+
+    return [value, setValue];
+}
+
+export default useLocalStorage;

package/client/src/hooks/useMount.js

@@ -0,0 +1,42 @@
+import {useEffect, useRef} from "react";
+import {useMutation} from "react-query";
+
+export const useMount = (effect) => {
+    const mounted = useRef(false);
+
+    useEffect(() => {
+        if (mounted.current) {
+            return effect();
+        }
+
+        mounted.current = true;
+
+        return () => {};
+    }, [mounted, effect]);
+};
+
+export function useStrictModeMutation(options){
+
+    // `hasRun` tracks if the mutation has already been executed
+    const hasRun = useRef(false);
+
+    // Setting up the mutation with React Query
+    const mutation = useMutation(options);
+
+    // Conditional mutation function to prevent double execution
+    const strictModeMutate = (variables) => {
+        if (!hasRun.current) {
+            hasRun.current = true;
+            mutation.mutate(variables);
+        }
+    };
+
+    // Custom reset function to allow the mutation to be re-triggered
+    const reset = () => {
+        hasRun.current = false;
+        mutation.reset();
+    };
+
+    // Return the mutation with `strictModeMutate` instead of `mutate`
+    return { ...mutation, mutate: strictModeMutate, reset };
+}