data-primals-engine 1.0.11 → 1.1.0

package/client/src/constants.js

@@ -0,0 +1,68 @@
+
+export const seoTitle = '';
+
+
+// Dans ConditionBuilder.jsx ou un fichier de constantes partagé
+export const mongoOperators = [
+    { value: '$eq', label: '==', inputType: 'text' }, // Égal (pour string, number, boolean...)
+    { value: '$ne', label: '!=', inputType: 'text' }, // Différent
+    { value: '$gt', label: '>', inputType: 'number' }, // Supérieur (nombre, date)
+    { value: '$gte', label: '>=', inputType: 'number' }, // Supérieur ou égal à
+    { value: '$lt', label: '<', inputType: 'number' }, // Inférieur à
+    { value: '$lte', label: '<=', inputType: 'number' }, // Inférieur ou égal à
+    { value: '$regex', label: 'contient (regex)', inputType: 'text' }, // Correspondance Regex (pour string)
+    { value: '$in', label: 'est dans (liste)', inputType: 'csv' }, // Dans un tableau (valeurs séparées par des virgules)
+    { value: '$nin', label: "n'est pas dans (liste)", inputType: 'csv' }, // Pas dans un tableau
+    { value: '$exists', label: 'existe', inputType: 'boolean' } // Le champ existe (true/false)
+    // { value: '$not', label: 'NON (condition)', inputType: 'condition' }, // Pourrait encapsuler une autre condition
+    // Ajoutez d'autres opérateurs MongoDB pertinents si besoin ($size, $type, $elemMatch...)
+];
+
+export const MONGO_OPERATORS = {
+    ADD: { mongo: '$add', label: '+', type: 'numeric', multi: true },
+    SUBTRACT: { mongo: '$subtract', label: '-', type: 'numeric', multi: false },
+    MULTIPLY: { mongo: '$multiply', label: '*', type: 'numeric', multi: true },
+    DIVIDE: { mongo: '$divide', label: '/', type: 'numeric', multi: false },
+    MODULO: { mongo: '$mod', label: '%', type: 'numeric', multi: false },
+    POW: { mongo: '$pow', label: 'pow', type: 'numeric', multi: false },
+    SQRT: { mongo: '$sqrt', label: '√', type: 'numeric', multi: false, unary: true },
+    ABS: { mongo: '$abs', label: 'abs', type: 'numeric', multi: false, unary: true },
+    CEIL: { mongo: '$ceil', label: 'ceil', type: 'numeric', multi: false, unary: true },
+    FLOOR: { mongo: '$floor', label: 'floor', type: 'numeric', multi: false, unary: true },
+    COS: { mongo: '$cos', label: 'cos', type: 'numeric', multi: false, unary: true },
+    ACOS: { mongo: '$acos', label: 'acos', type: 'numeric', multi: false, unary: true },
+    SIN: { mongo: '$sin', label: 'sin', type: 'numeric', multi: false, unary: true },
+    ASIN: { mongo: '$asin', label: 'asin', type: 'numeric', multi: false, unary: true },
+    TAN: { mongo: '$tan', label: 'tan', type: 'numeric', multi: false, unary: true },
+    ATAN: { mongo: '$atan', label: 'atan', type: 'numeric', multi: false, unary: true },
+    LN: { mongo: '$ln', label: 'ln', type: 'numeric', multi: false, unary: true },
+    LOG: { mongo: '$log10', label: 'log', type: 'numeric', multi: false, unary: true },
+
+    CONCAT: { mongo: '$concat', label: 'concat', type: 'string', multi: true },
+
+    YEAR: { mongo: '$year', label: 'year', type: 'date', unary: true },
+    MONTH: { mongo: '$month', label: 'month', type: 'date', unary: true },
+    WEEK: { mongo: '$week', label: 'week', type: 'date', unary: true },
+    DAY_OF_MONTH: { mongo: '$dayOfMonth', label: 'day', type: 'date', unary: true },
+    HOUR: { mongo: '$hour', label: 'hour', type: 'date', unary: true },
+    MINUTE: { mongo: '$minute', label: 'min', type: 'date', unary: true },
+    SECOND: { mongo: '$second', label: 'sec', type: 'date', unary: true }
+};
+
+export const profiles = {
+    'personal': ['contact', 'location', 'imageGallery', 'budget', 'currency', 'taxonomy'], // budget,
+    'developer': ['alert','request','webpage', 'content', 'taxonomy', 'resource', 'translation', 'contact', 'location', 'channel', 'lang', 'token', 'message', 'ticket', 'user', 'permission', 'role'],
+    'company': ['alert','request','location', 'campaign', 'order', 'currency', 'product', 'cart', 'cartItem', 'invoice', 'messaging', 'user', 'role', 'permission', 'token','translation', 'lang', 'webpage', 'content', 'taxonomy', 'contact', 'resource', 'accountingExercise', 'accountingLineItem', 'accountingEntry', 'employee', 'kpi', 'dashboard'],
+    'engineer': ['alert','request','dashboard', 'kpi', 'user', 'role', 'token', 'permission', 'workflow', 'workflowRun', 'workflowStep', "channel", "message", 'workflowAction', 'workflowTrigger']
+}
+
+export const OPERAND_TYPES = {
+    FIELD: 'field',
+    CONSTANT: 'constant',
+    PREVIOUS_STEP: 'previousStep'
+};
+
+
+export const getHost = () => {
+    return process.env.HOST || 'localhost';
+}

package/client/src/contexts/AuthContext.jsx

@@ -0,0 +1,28 @@
+// ModelContext.jsx
+import React, { createContext, useContext, useState } from 'react';
+
+const AuthContext = createContext(null);
+
+export const AuthProvider = ({ children }) => {
+    const [me, setMe] = useState(null);
+
+
+    const contextValue = {
+        me,
+        setMe
+    };
+
+    return (
+        <AuthContext.Provider value={contextValue}>
+            {children}
+        </AuthContext.Provider>
+    );
+};
+
+export const useAuthContext = () => {
+    const context = useContext(AuthContext);
+    if (context === null) {
+        throw new Error('useAuthContext doit être utilisé dans un AuthProvider');
+    }
+    return context;
+};

package/client/src/contexts/ModelContext.jsx

@@ -0,0 +1,328 @@
+// ModelContext.jsx
+import React, {createContext, useCallback, useContext, useEffect, useMemo, useState} from 'react';
+import { useQueries, useQuery } from 'react-query';
+import {elementsPerPage} from "data-primals-engine/constants";
+import {getObjectHash} from "data-primals-engine/core";
+import {useAuthContext} from "./AuthContext.jsx";
+import {getUserHash, getUserId} from "data-primals-engine/data";
+import {useTranslation} from "react-i18next";
+import useLocalStorage from "../hooks/useLocalStorage.js";
+
+const ModelContext = createContext(null);
+
+export const ModelProvider = ({ children }) => {
+    const [models, setModels] = useState([]);
+    const [datasToLoad, setDatasToLoad] = useState([]);
+    const [pagedFilters,setPagedFilters] = useState({});
+    const [pagedDepth,setPagedDepth] = useState({});
+    const [filteredDatasToLoad, setFilteredDatasToLoad] = useState([]);
+    const [onSuccessCallbacks, setOnSuccessCallbacks] = useState({});
+    const [selectedModel, setSelectedModel] = useState(null);
+    const [relationFilters, setRelationFilters] = useState({});
+    const [relationIds, setRelationIds] = useState({});
+    const [page, setPage] = useState(1);
+    const [elementsPerPage, setElementsPerPage] = useState(20);
+    const [relationModels, setRelationModels] = useState([]);
+    const [pagedSort, setPagedSort] = useState({})
+    const [lockedColumns, setLockedColumns] = useState([])
+    const [generatedModels, setGeneratedModels] = useLocalStorage('ai_generated_models', []);
+
+    const updateRelationIds = (modelName, ids, cb) => {
+        setRelationIds((prevIds) => {
+            cb?.();
+            return {
+                ...prevIds,
+                [modelName]: ids,
+            };
+        });
+    };
+
+
+    const { me } = useAuthContext();
+    const { t, i18n } = useTranslation()
+    const lang = (i18n.resolvedLanguage || i18n.language).split(/[-_]/)?.[0];
+
+    const { data: dataModels = [], isFetched } = useQuery(['api/models', me], () => {
+        if(!me)
+            return Promise.reject();
+        return fetch(`/api/models?lang=${lang}&_user=${encodeURIComponent(getUserId(me))}`).then((res) => {
+            if( !res.ok ){
+                return [];
+            }
+            return res.json();
+        })}, {
+            onSuccess: (data, d) => {
+                if( typeof(data) === 'object' && data.success === false) {
+                    return;
+                }
+                setModels(data);
+            }, onError: () => {
+                setModels([])
+        }, enabled: !!me});
+
+    const allModels = useMemo(() => {
+        // On filtre les modèles générés pour ne pas inclure ceux qui ont le même nom qu'un modèle déjà sauvegardé.
+        const uniqueGeneratedModels = generatedModels.filter(
+            genModel => !dataModels.some(apiModel => apiModel._user === genModel._user && apiModel.name === genModel.name)
+        );
+        return [...dataModels, ...uniqueGeneratedModels];
+    }, [dataModels, generatedModels]);
+
+    useEffect(() => {
+        if (selectedModel) {
+            const rels = selectedModel.fields
+                .filter((f) => f.type === 'relation')
+                .map((m) => m.relation);
+            setRelationModels(rels);
+        }
+    }, [selectedModel]);
+
+    let abortController = new AbortController();
+
+    const [relations, setRelations] = useState([]);
+
+    const rawQueries = models
+        ?.filter((f) => datasToLoad?.includes(f.name))
+        .map((model) => {
+            const rels = relationIds[model.name]?.filter(Boolean) || [];
+            if( rels.length === 0)
+                return Promise.resolve({data:[], count:0});
+            const params = new URLSearchParams();
+            params.append('model', model.name);
+            params.append('lang', lang);
+            params.append("_user", getUserId(me));
+            params.append("depth", '1')
+
+            let ids = [...new Set(rels.map(r => r._id || r))].join(',');
+            if (rels && rels.length > 0) {
+                // Cas des relations : requête par IDs, sans pagination
+                params.append('ids', ids);
+            }
+            return ({
+                queryKey: ['api/data', model.name, params.toString()], // Ajout de page et relationIds à la clé de requête
+                queryFn: ({signal}) => {
+                    if(!me)return Promise.reject();
+                    const rel = relations['api/data'+model.name+getObjectHash({ids})];
+                    if( rel){
+                        return Promise.resolve(rel);
+                    }
+                    return fetch(`/api/data/search?${params.toString()}`, { signal, method: 'POST', headers: { "Content-Type": "application/json"}})
+                        .then((res) => res.json())
+                        .then((e) => ({
+                            count: e.count,
+                            data: (e.data || []).map((m) => {
+
+                                const mod = {...m, _model: model.name};
+                                // Parcourir les champs pour normaliser les relations
+                                model.fields.forEach(field => {
+                                    if (field.type === 'relation') {
+                                        const relationValue = mod[field.name];
+
+                                        if (field.multiple) {
+                                            // Pour les relations multiples, on s'assure d'avoir un tableau d'IDs.
+                                            if (Array.isArray(relationValue)) {
+                                                // On extrait l'_id de chaque objet, ou on garde la valeur si c'est déjà un ID.
+                                                mod[field.name] = relationValue.map(item => item?._id || item);
+                                            } else {
+                                                // Si ce n'est pas un tableau, on met un tableau vide pour éviter les erreurs.
+                                                mod[field.name] = [];
+                                            }
+                                        } else {
+                                            // Pour une relation simple, on veut juste l'ID ou null.
+                                            if (typeof relationValue === 'object' && relationValue !== null) {
+                                                // Gère les cas où la relation est un objet { _id: "..." } ou un tableau [ { _id: "..." } ]
+                                                const item = Array.isArray(relationValue) ? relationValue[0] : relationValue;
+                                                mod[field.name] = item?._id || null;
+                                            } else {
+                                                // La valeur est déjà un ID (string) ou null/undefined. On la garde telle quelle.
+                                                mod[field.name] = relationValue || null;
+                                            }
+                                        }
+                                    }
+                                });
+                                return mod;
+                            })
+                        }))
+                },
+                enabled: !!selectedModel && !!me,
+                onSuccess: (data)=>{
+                },
+                onSettled: (data)=>{
+                    const dt = {...relations};
+                    dt['api/data'+model.name+getObjectHash({ids})] = data;
+                    setRelations(dt);
+                    try{
+                        if (onSuccessCallbacks?.['api/data/'+model.name])
+                            Object.keys(onSuccessCallbacks?.['api/data/'+model.name]).forEach(cb => onSuccessCallbacks?.['api/data/'+model.name][cb](data));
+                    } catch (e) {
+                        console.error(e);
+                    }
+                }
+            })
+        }) || [];
+
+    const rawQueriesPage = models
+        ?.filter((f) => filteredDatasToLoad?.includes(f.name))
+        .map((model) => ({
+            queryKey: ['api/data', model.name, 'page', page, elementsPerPage,pagedFilters[model.name], pagedSort[model.name], lang], // Ajout de page et relationIds à la clé de requête
+            queryFn: ({signal}) => {
+
+                const params = new URLSearchParams();
+                params.append('model', model.name);
+                params.append("_user", getUserId(me));
+
+                // Cas de la table de données : requête paginée
+                params.append('lang', lang);
+                params.append('limit', elementsPerPage+'');
+                params.append('page', page+'');
+                params.append("depth", '1');
+
+                const sortParam = [];
+
+                lockedColumns.forEach(s => {
+                    sortParam.push(s + ':' + (pagedSort[model.name]?.[s] > 0 ? 'ASC' : 'DESC'));
+                });
+                Object.keys(pagedSort[model.name] || {}).forEach(s => {
+                    if( !lockedColumns.includes(s))
+                        sortParam.push(s + ':' + (pagedSort[model.name]?.[s] > 0 ? 'ASC' : 'DESC'));
+                })
+                if( sortParam.length )
+                    params.append("sort", sortParam.join(','));
+
+                const c = [];
+                Object.keys(pagedFilters[model.name] || {}).filter(f=>typeof(pagedFilters[model.name][f]) === 'object' && Object.keys(pagedFilters[model.name][f]).length > 0).forEach(obj =>{
+                    const f = model.fields.find(f=>f.name===obj);
+                    if(f !== null && f !== undefined){
+                            c.push(pagedFilters[model.name][obj]);
+                    }
+                });
+                const filter= JSON.stringify({filter:{$and:c}});
+
+                return fetch(`/api/data/search?${params.toString()}`, { signal, method: 'POST', body: filter, headers: { "Content-Type": "application/json"}})
+                    .then((res) => res.json())
+                    .then((e) => {
+                        return {
+                            count: e.count || 0,
+                                data: (e.data || []).map((m) => {
+                                    const mod = {...m, _model: model.name};
+                                    return mod;
+                                }),
+                        }
+                    });
+            },
+            enabled: !!selectedModel,
+            onSettled: (data)=>{
+                try {
+                    Object.keys(onSuccessCallbacks?.['api/data/' + model.name + '/paged']).forEach(cb => {
+                        onSuccessCallbacks?.['api/data/' + model.name + '/paged'][cb](data)
+                    });
+                } catch (e){
+                    console.error(e)
+                }
+            },
+            onError: (e)=>{
+                console.error(e)
+            }
+        })) || [];
+
+    const modelQueries = useQueries(rawQueries);
+    const paginateQueries = useQueries(rawQueriesPage);
+    const countByModel = {};
+
+    const dataByModel = models.reduce((acc, model) => {
+        const query = modelQueries.find(
+            (q) => q.data?.data.length && q.data.data[0]._model === model.name
+        );
+        if (query?.isSuccess) {
+            acc[model.name] = query.data.data;
+        } else {
+            acc[model.name] = [];
+        }
+        return acc;
+    }, {});
+
+    const paginatedDataByModel = models.reduce((acc, model) => {
+        const query = paginateQueries.find(
+            (q) => q.data?.data.length && q.data.data[0]._model === model.name
+        );
+        if (query?.isSuccess) {
+            acc[model.name] = query.data.data;
+            countByModel[model.name] = query.data.count;
+        } else {
+            acc[model.name] = [];
+            countByModel[model.name] = 0;
+        }
+        return acc;
+    }, {});
+
+    const relatedData = {};
+    models.forEach((model) => {
+        model.fields.forEach((field) => {
+            if (field.type === 'relation') {
+                const relatedModelName = field.relation;
+                relatedData[relatedModelName] = dataByModel[relatedModelName];
+            }
+        });
+    });
+
+    const contextValue = {
+        models: allModels,
+        setModels,
+        page,
+        setPage,
+        countByModel,
+        selectedModel,
+        setSelectedModel,
+        datasToLoad,
+        setDatasToLoad,
+        pagedFilters,
+        setPagedFilters,
+        dataByModel,
+        paginatedDataByModel,
+        filteredDatasToLoad,
+        setFilteredDatasToLoad,
+        relatedData,
+        setRelationIds,
+        setRelationFilters,
+        relationIds,
+        updateRelationIds,
+        getObjectHash,
+        onSuccessCallbacks,
+        setOnSuccessCallbacks,
+        pagedSort,
+        setPagedSort,
+        lockedColumns,
+        setLockedColumns,
+        elementsPerPage,
+        setElementsPerPage,
+        relations,
+        setRelations,
+        generatedModels,
+        setGeneratedModels
+    };
+
+    const func = useCallback(() => {
+        setRelations({});
+    }, []);
+    useEffect(() => {
+        window.addEventListener('visibilitychange', func);
+        return () => window.removeEventListener('visibilitychanges', func);
+    }, []);
+    useEffect(() => {
+        if( selectedModel && page )
+            setRelations({});
+    }, [selectedModel, page, pagedFilters]);
+    return (
+        <ModelContext.Provider value={contextValue}>
+            {children}
+        </ModelContext.Provider>
+    );
+};
+
+export const useModelContext = () => {
+    const context = useContext(ModelContext);
+    if (context === null) {
+        throw new Error('useModelContext doit être utilisé dans un ModelProvider');
+    }
+    return context;
+};

package/client/src/contexts/UIContext.jsx

@@ -0,0 +1,52 @@
+// ModelContext.jsx
+import React, {createContext, useContext, useEffect, useMemo, useState} from 'react';
+import useLocalStorage from "../hooks/useLocalStorage.js";
+
+const UIContext = createContext(null);
+
+export const UIProvider = ({ children }) => {
+
+    const [tourStepIndex, setTourStepIndex] = useState(0);
+    const [currentTourSteps, setCurrentTourSteps] = useState([]);
+    const [isTourOpen, setIsTourOpen] = useState(false);
+    const [allTourSteps, setAllTourSteps] = useState([]);
+    const [launchedTours, setLaunchedTours] = useState([]);
+
+    const [currentTour, setCurrentTour] = useLocalStorage("spotlight-tour", null);
+    const [finishedTours, setLSTours] = useLocalStorage('launchedTours', []);
+useEffect(() =>{
+    if( launchedTours)
+    setLSTours(launchedTours);
+}, [launchedTours])
+
+    const [isLocked, setLocked] = useState(false);
+    const contextValue = useMemo(() => ({
+        isLocked,
+        setLocked,
+        currentTourSteps, setCurrentTourSteps,
+        launchedTours,setLaunchedTours,
+        currentTour, setCurrentTour,
+        isTourOpen, setIsTourOpen, setAllTourSteps, allTourSteps,
+        tourStepIndex, setTourStepIndex
+    }), [isLocked,
+        setLocked,
+        currentTourSteps, setCurrentTourSteps,
+        launchedTours,setLaunchedTours,
+        currentTour, setCurrentTour,
+        isTourOpen, setIsTourOpen, setAllTourSteps, allTourSteps,
+        tourStepIndex, setTourStepIndex]);
+
+    return (
+        <UIContext.Provider value={contextValue}>
+            <div id={"ui"} className={`${isLocked ? 'ui-locked' : ''}`}>{children}</div>
+        </UIContext.Provider>
+    );
+};
+
+export const useUI = () => {
+    const context = useContext(UIContext);
+    if (context === null) {
+        throw new Error('useUI doit être utilisé dans un UIProvider');
+    }
+    return context;
+};

package/client/src/core/data.js

@@ -0,0 +1,35 @@
+import {getHost, MONGO_OPERATORS} from "../constants.js";
+
+const isProd = import.meta.env.MODE === 'production';
+export const urlData = isProd ? 'https://'+getHost()+'/' : 'http://localhost:7633/';
+
+
+// Fonction pour vérifier si un opérateur est "atomique" (date, 1 seul opérande)
+export const isAtomicDateOperator = (operator) => {
+    return Object.keys(MONGO_OPERATORS).some(f => MONGO_OPERATORS[f].mongo === operator && (MONGO_OPERATORS[f].isDate || MONGO_OPERATORS[f].isAtomic));
+};
+
+// --- Helper to get the definition of a field, possibly nested ---
+export const getFieldDefinitionFromPath = (fieldPath, startModelName, allModels) => {
+    if (!fieldPath || !startModelName || !allModels) return null;
+    const parts = fieldPath.split('.');
+    let currentModel = allModels.find(m => m.name === startModelName);
+    if (!currentModel) return null;
+
+    let fieldDef = null;
+    for (let i = 0; i < parts.length; i++) {
+        const partName = parts[i];
+        if (!currentModel || !currentModel.fields) return null;
+        fieldDef = currentModel.fields.find(f => f.name === partName);
+        if (!fieldDef) return null;
+
+        if (i < parts.length - 1) { // This is a relation part
+            if (fieldDef.type === 'relation' && fieldDef.relation) {
+                currentModel = allModels.find(m => m.name === fieldDef.relation);
+            } else {
+                return null; // Path broken, intermediate part is not a valid relation
+            }
+        }
+    }
+    return fieldDef; // Definition of the final field in the path
+};

package/client/src/entry-client.jsx

@@ -0,0 +1,15 @@
+import './index.css'
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App'
+import {BrowserRouter} from "react-router-dom";
+import dns from "dns";
+
+dns.setDefaultResultOrder("verbatim");
+
+ReactDOM.hydrateRoot(
+    document.getElementById('root'),
+        <BrowserRouter>
+            <App />
+        </BrowserRouter>
+)

package/client/src/entry-server.jsx

@@ -0,0 +1,13 @@
+import React from 'react'
+import ReactDOMServer from 'react-dom/server'
+import App from './App'
+import {StaticRouter} from "react-router";
+
+export function render() {
+    const html = ReactDOMServer.renderToString(
+            <StaticRouter location={"/"}>
+                <App />
+            </StaticRouter>
+    )
+    return { html }
+}