data-primals-engine 1.4.1 → 1.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-primals-engine",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "data-primals-engine is a package responsible from handling large amount of data using MongoDB in a practical and performant way. It can also get workflow models working (for automation), and fully supports internationalisation. It also has integrated AI assistant.",
   "main": "src/engine.js",
   "type": "module",
@@ -35,7 +35,15 @@
     "xml2js": ">=0.5.0"
   },
   "overrides": {
-    "prismjs": "1.30.0"
+    "react-syntax-highlighter": {
+      "prismjs": "1.30.0"
+    },
+    "react-code-blocks": {
+      "prismjs": "1.30.0"
+    },
+    "refractor": {
+      "prismjs": "1.30.0"
+    }
   },
   "repository": {
     "type": "git",

package/src/config.js

@@ -1,4 +1,4 @@
-
+import {safeAssignObject} from "./core.js";
 
 
 const config = [];
@@ -11,6 +11,6 @@ export const Config = {
         return config[name];
     },
     Set: (name, value) => {
-        config[name] = value;
+        safeAssignObject(config, name, value);
     }
 }

package/src/constants.js

@@ -1,5 +1,3 @@
-import {event_trigger} from "./core.js";
-
 /**
  * Enables auto-installation at startup
  * @type {boolean}
@@ -300,10 +298,270 @@ metaModels['erp'] = { load: [ 'accountingExercise', 'accountingLineItem', 'accou
  * Available model field attributes
  * @type {string[]}
  */
-export const allowedFields = ['locked', 'hiddenable', 'anonymized', 'condition', 'color', 'index', 'type', 'required', 'hint', 'default', 'validate', 'unique', 'name', 'placeholder', 'asMain'];
+export const allowedFields = ['locked', 'hiddenable', 'anonymized', 'condition', 'color', 'index', 'indexType', 'type', 'required', 'hint', 'default', 'validate', 'unique', 'name', 'placeholder', 'asMain'];
 
 
 
 export const getHost = () => {
     return process.env.HOST || host || 'localhost';
-}
+}
+
+/**
+ * Configuration of MongoDB filters
+ */
+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
+    },
+    '$regexMatch': {
+        label: 'Find by regex',
+        description: 'Find a string matching a regular expression (Ecmascript)',
+        args: 2, // input et regex
+        specialStructure: true // Indique une structure spéciale
+    },
+    $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},
+
+    // Date-specific
+    $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},
+    // Date operators
+    $dateAdd: {
+        label: 'Add to date',
+        description: 'Adds a duration to a date',
+        isDate: true,
+        specialStructure: true,
+        args: [
+            {name: 'startDate', label: 'Start Date', type: 'date'},
+            {
+                name: 'unit',
+                label: 'Unit',
+                type: 'select',
+                options: ['year', 'month', 'day', 'hour', 'minute', 'second']
+            },
+            {name: 'amount', label: 'Amount', type: 'number'},
+            {name: 'timezone', label: 'Timezone', type: 'text', optional: true}
+        ]
+    },
+    $dateSubtract: {
+        label: 'Subtract from date',
+        description: 'Subtracts a duration from a date',
+        isDate: true,
+        specialStructure: true,
+        args: [
+            {name: 'startDate', label: 'Start Date', type: 'date'},
+            {
+                name: 'unit',
+                label: 'Unit',
+                type: 'select',
+                options: ['year', 'month', 'day', 'hour', 'minute', 'second']
+            },
+            {name: 'amount', label: 'Amount', type: 'number'},
+            {name: 'timezone', label: 'Timezone', type: 'text', optional: true}
+        ]
+    },
+    $dateDiff: {
+        label: 'Date Difference',
+        description: 'Calculates the difference between two dates in specified units',
+        isDate: true,
+        specialStructure: true,
+        args: [
+            {
+                name: 'startDate',
+                label: 'Start Date',
+                type: 'date',
+                description: 'The starting date (inclusive)'
+            },
+            {
+                name: 'endDate',
+                label: 'End Date',
+                type: 'date',
+                description: 'The ending date (exclusive)'
+            },
+            {
+                name: 'unit',
+                label: 'Unit',
+                type: 'select',
+                options: ['year', 'month', 'week', 'day', 'hour', 'minute', 'second'],
+                description: 'The unit for the result'
+            },
+            {
+                name: 'timezone',
+                label: 'Timezone',
+                type: 'text',
+                optional: true,
+                description: 'The timezone (e.g. "Europe/Paris")'
+            }
+        ]
+    },
+    $dateToString: {
+        label: 'Format date as string',
+        description: 'Formats a date as a string',
+        isDate: true,
+        specialStructure: true,
+        args: [
+            {
+                name: 'date',
+                label: 'Date',
+                type: 'date'
+            },
+            {
+                name: 'format',
+                label: 'Format',
+                optional: true,
+                type: 'text'
+            },
+            {
+                name: 'timezone',
+                label: 'Timezone',
+                type: 'text',
+                optional: true,
+                description: 'The timezone (e.g. "Europe/Paris")'
+            }
+        ]
+    },
+
+    // Converters
+    $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},
+
+    // --- Special Query Operators (not for $expr) ---
+    // These operators are handled by a standard $match stage, not inside $expr.
+    // The UI should use them to construct parts of the main filter object.
+    $regex: {
+        label: 'Regex',
+        description: 'Matches strings using a regular expression. Applied to a specific field.',
+        isQueryOperator: true,
+        specialStructure: true,
+        args: [
+            { name: 'pattern', label: 'Pattern', type: 'text', description: 'The regex pattern.' },
+            { name: 'options', label: 'Options', type: 'text', optional: true, description: 'Regex options (e.g., "i" for case-insensitivity).' }
+        ]
+    },
+
+    $text: {
+        label: 'Text Search',
+        description: 'Performs a full-text search on the collection. Must be a top-level filter condition.',
+        isQueryOperator: true,
+        isTopLevel: true, // Indicates it's a key in the root of the filter, not under a field name.
+        specialStructure: true,
+        args: [
+            { name: '$search', label: 'Search Terms', type: 'text' },
+            { name: '$language', label: 'Language', type: 'text', optional: true },
+            { name: '$caseSensitive', label: 'Case Sensitive', type: 'boolean', optional: true },
+            { name: '$diacriticSensitive', label: 'Diacritic Sensitive', type: 'boolean', optional: true }
+        ]
+    },
+
+    $nearSphere: {
+        label: 'Near Sphere',
+        description: 'Finds documents near a GeoJSON point on a sphere. Applied to a 2dsphere-indexed field.',
+        isQueryOperator: true,
+        specialStructure: true,
+        args: [
+            { name: 'geometry', label: 'Center Point (GeoJSON)', type: 'code', language: 'json', description: 'e.g., { "type": "Point", "coordinates": [ -73.93, 40.82 ] }' },
+            { name: 'maxDistance', label: 'Max Distance (meters)', type: 'number', optional: true },
+            { name: 'minDistance', label: 'Min Distance (meters)', type: 'number', optional: true }
+        ]
+    },
+
+    $geoWithin: {
+        label: 'Geo Within',
+        description: 'Selects documents with geospatial data that exists entirely within a specified shape.',
+        isQueryOperator: true,
+        specialStructure: true,
+        args: [
+            { name: '$geometry', label: 'Shape (GeoJSON)', type: 'code', language: 'json', description: 'A GeoJSON Polygon or MultiPolygon.' }
+        ]
+    },
+
+    $geoIntersects: {
+        label: 'Geo Intersects',
+        description: 'Selects documents whose geospatial data intersects with a specified GeoJSON object.',
+        isQueryOperator: true,
+        specialStructure: true,
+        args: [
+            { name: '$geometry', label: 'Geometry (GeoJSON)', type: 'code', language: 'json', description: 'A GeoJSON object to test for intersection.' }
+        ]
+    },
+
+    // This represents the $geoNear aggregation stage, which has special placement rules.
+    $geoNear: {
+        label: 'Geo Near (Stage)',
+        description: 'Finds and sorts documents by distance. Must be the first operation in a search.',
+        isQueryOperator: true,
+        isTopLevel: true, // Indicates it's a key in the root of the filter.
+        specialStructure: true,
+        args: [
+            { name: 'near', label: 'Near Point (GeoJSON)', type: 'code', language: 'json', description: 'The point to search near.' },
+            { name: 'distanceField', label: 'Distance Field Name', type: 'text', description: 'The output field to store the distance.' },
+            { name: 'spherical', label: 'Spherical', type: 'boolean', optional: true, default: true },
+            { name: 'query', label: 'Additional Query', type: 'code', language: 'json', optional: true, description: 'Filters documents before distance calculation.' },
+            { name: 'maxDistance', label: 'Max Distance (meters)', type: 'number', optional: true }
+        ]
+    }
+};

package/src/core.js

@@ -36,7 +36,7 @@ export function escapeHtml(string){
 export const isDate = dt => String(new Date(dt)) !== 'Invalid Date'
 
 export const safeAssignObject = (obj, key, value) => {
-    if( !["__proto__", "constructor"].includes(key)){
+    if( !["__proto__", "constructor", "prototype"].includes(key)){
         obj[key] = value;
     }
 }
@@ -351,13 +351,13 @@ export const event_trigger = (name, ...params) => {
 };
 export const event_on = (name, callback) => {
     if (!Array.isArray(triggers[name])) {
-        triggers[name] = [];
+        safeAssignObject(triggers, name, []);
     }
     triggers[name].push({ callback });
 };
 export const event_off = (name, callback) => {
     if (callback && triggers[name]) {
-        triggers[name] = triggers[name].filter((f) => f.callback !== callback);
+        safeAssignObject(triggers, name, triggers[name].filter((f) => f.callback !== callback));
     } else {
         triggers[name] = undefined;
     }
@@ -418,3 +418,21 @@ export function object_equals( x, y ) {
 export const isValidPath = (path) =>{
     return /^(?:[a-z]:)?[\/\\]{0,2}(?:[.\/\\ ](?![.\/\\\n])|[^<>:"|?*.\/\\ \n])+$/gmi.test(path);
 }
+
+
+/**
+ * Génère une couleur de base cohérente à partir d'une chaîne de caractères.
+ * @param {string} str La chaîne à hasher (par exemple, le libellé d'une catégorie).
+ * @returns {string} Une couleur au format 'hsl(h, s, l)'.
+ */
+export const stringToHslColor = (str) => {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        hash = str.charCodeAt(i) + ((hash << 5) - hash);
+    }
+    // Utiliser HSL pour un meilleur contrôle sur la saturation et la luminosité
+    const h = hash % 360; // Teinte (0-359)
+    const s = 70;         // Saturation (fixe pour des couleurs vives mais pas criardes)
+    const l = 55;         // Luminosité (fixe pour une bonne lisibilité)
+    return `hsl(${h}, ${s}%, ${l}%)`;
+};

package/src/defaultModels.js

@@ -1486,6 +1486,12 @@ export const defaultModels = {
         "icon": "FaCode",
         description: "Defines custom API endpoints that execute a server-side script.",
         fields: [
+            {
+                name: "isActive",
+                type: "boolean",
+                default: true,
+                hint: "If checked, the endpoint is active and can be called."
+            },
             {
                 name: "name",
                 type: "string",
@@ -1493,12 +1499,6 @@ export const defaultModels = {
                 asMain: true,
                 hint: "A human-readable name to identify the endpoint."
             },
-            {
-                name: "isActive",
-                type: "boolean",
-                default: true,
-                hint: "If checked, the endpoint is active and can be called."
-            },
             {
                 name: "path",
                 type: "string",
@@ -1514,12 +1514,6 @@ export const defaultModels = {
                 default: "POST",
                 hint: "The HTTP method required to call this endpoint."
             },
-            {
-                name: 'isPublic',
-                type: 'boolean',
-                default: false,
-                hint: "Si coché, ce point d'accès sera accessible sans authentification."
-            },
             {
                 name: "code",
                 type: "code",
@@ -1534,6 +1528,12 @@ logger.info('Custom endpoint executed with body:', request.body);
 
 return { success: true, message: 'Endpoint executed!', received: request.body };
 `
+            },
+            {
+                name: 'isPublic',
+                type: 'boolean',
+                default: false,
+                hint: "Si coché, ce point d'accès sera accessible sans authentification."
             }
         ]
     }

package/src/engine.js

@@ -13,7 +13,6 @@ import {
 import http from "http";
 import cookieParser from "cookie-parser";
 import requestIp from 'request-ip';
-import {createModel, deleteModels, getModels, installAllPacks, validateModelStructure} from "./modules/data/data.js";
 import {defaultModels} from "./defaultModels.js";
 import {DefaultUserProvider} from "./providers.js";
 import formidableMiddleware from 'express-formidable';
@@ -22,6 +21,10 @@ import * as tls from "node:tls";
 import {Event} from "./events.js";
 import path from "node:path";
 import { fileURLToPath } from 'node:url';
+import {validateModelStructure} from "./modules/data/data.validation.js";
+import { setSafeRegex } from "./filter.js";
+import safeRegexCallback from "safe-regex";
+import {createModel, deleteModels, getModels, installAllPacks} from "./modules/data/data.operations.js";
 // Constants
 
 // On définit __dirname pour obtenir le chemin absolu du répertoire courant,
@@ -96,6 +99,9 @@ export const MongoDatabase = MongoClient.db(dbName);
 
 export const Engine = {
     Create: async (options = { app : null}) => {
+        // On injecte la dépendance safe-regex dans le module de filtrage au tout début.
+        setSafeRegex(safeRegexCallback);
+
         const engine = GameObject.Create("Engine");
         console.log("Creating engine", Config.Get('modules'));
         const logger = engine.addComponent(Logger);

package/src/events.js

@@ -1,3 +1,4 @@
+import {safeAssignObject} from "./core.js";
 
 const events = {};
 
@@ -81,9 +82,9 @@ export const Event = {
             throw new Error(`Layer '${layer}' does not exist in system '${system}'. Valid layers are: ${validLayers.join(', ')}`); // Message d'erreur plus informatif
         }
 
-        events[system] = events[system] || {}; // Simplification de la création des objets
-        events[system][name] = events[system][name] || {};
-        events[system][name][layer] = events[system][name][layer] || [];
+        safeAssignObject(events, system, events[system] || {}); // Simplification de la création des objets
+        safeAssignObject(events[system], name, events[system][name] || {});
+        safeAssignObject(events[system][name], layer, events[system][name][layer] || []);
         events[system][name][layer].push(callback);
     },
     RemoveCallback: (name, callback, layer="medium", system='priority') => {