data-primals-engine 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-primals-engine",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "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",

package/server.js

@@ -13,11 +13,20 @@ const bench = GameObject.Create("Benchmark");
 const timer = bench.addComponent(BenchmarkTool);
 timer.start();
 
-const engine = Engine.Create();
+
+const engine = await Engine.Create();
+
+if (process.argv.length === 3) {
+    let arg = process.argv[2];
+    if( arg === 'reset-models'){
+        console.log("resetting models");
+        await engine.resetModels();
+    }
+}
 
 const port = process.env.PORT || 7633;
 engine.start(port, async (r) => {
     const logger = engine.getComponent(Logger);
-
+    console.log("Server started on port" + port);
     timer.stop();
 });

package/src/constants.js

@@ -2,24 +2,6 @@ export const dbName = "engine";
 
 export const cookiesSecret = 'hoaivuymzovyoznllmafivpzaovphlejvalwjvelfhqochakfesv';
 
-
-export const langs = {
-    fr: "Français",
-    en: "English",
-    ar: "عربي",
-    fa: "فارسی",
-    it: "Italiano",
-    es: "Español",
-    el: "Ελληνικά",
-    de: "Deutsch",
-    cs: "Čeština",
-    sv: "Svenska",
-    pt: "Português",
-    ja: "日本語",
-    zh: "简体中文",
-    ru: "Русский",
-};
-
 export const availableLangs = [
     "en",
     "fa",
@@ -138,7 +120,7 @@ metaModels['common'] = { load: ['contact', 'location', 'request'] };
 metaModels['personal'] = { load: ['budget', 'imageGallery'] };
 metaModels['users'] = { load: ['permission', 'role', 'user', 'token'], 'require': ['i18n', 'common'] };
 metaModels['i18n'] = { load: ['translation','lang']};
-metaModels['website'] = { load: ['webpage', 'content', 'taxonomy', 'contact', 'resource'], 'require': ['i18n'] };
+metaModels['website'] = { load: ['webpage', 'content', 'taxonomy', 'contact', 'event', 'resource'], 'require': ['i18n'] };
 metaModels['messaging'] = { load: ['alert','ticket', 'message', 'channel'], 'require': ['i18n'] };
 metaModels['eshopping'] = { load: [
         'order', 'currency', 'product', 'productVariant', 'discount', 'cart', 'cartItem',
@@ -148,67 +130,7 @@ metaModels['eshopping'] = { load: [
 metaModels['workflow'] = { load: ['env', 'workflow', 'workflowRun', 'workflowAction', 'workflowStep', 'workflowTrigger']};
 metaModels['erp'] = { load: [ 'accountingExercise', 'accountingLineItem', 'accountingEntry', 'employee', 'dashboard', 'kpi'] };
 
-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']
-}
-
-// 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 allowedFields = ['locked', 'hiddenable', 'anonymized', 'condition', 'color', 'index', 'type', 'required', 'hint', 'default', 'validate', 'unique', 'name', 'placeholder', 'asMain'];
 
 
-
-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 OPERAND_TYPES = {
-    FIELD: 'field',
-    CONSTANT: 'constant',
-    PREVIOUS_STEP: 'previousStep',
-};
-

package/src/data.js

@@ -29,8 +29,12 @@ export const isLocalUser = (user) => {
     return user && user._model === 'user' && typeof(user._user) === 'string' && user._user.trim() !== '';
 };
 
+export const isDemoUser = (user) => {
+    return /^demo[0-9]{1,2}$/.test(user?.username);
+}
+
 export function getUserHash(user) {
-    if( /^demo[0-9]{1,2}$/.test(user?.username) ){
+    if( isDemoUser(user) ){
         return user.username;
     }
     return user ? (
@@ -419,8 +423,9 @@ export const getFieldValueHash = (model, data) => {
  * @param {array} allModels - Un tableau contenant les définitions de TOUS les modèles du système.
  * @returns {string} - La chaîne de caractères représentant la donnée.
  */
-export const getDataAsString = (model, data, t, allModels, extended=false) => {
-
+export const getDataAsString = (model, data, tr, allModels, extended=false) => {
+    const { t, i18n} = tr;
+    const lang = (i18n.resolvedLanguage || i18n.language).split(/[-_]/)?.[0];
     // Cas de base : si le modèle ou les données sont manquants, on ne peut rien faire.
     if (!model || !data) {
         return '';
@@ -464,7 +469,6 @@ export const getDataAsString = (model, data, t, allModels, extended=false) => {
             const relatedModel = allModels?.find(m => m.name === fieldDef.relation);
             if (!relatedModel) return `[${fieldDef.relation}]`; // Modnon trouvé
 
-            console.log({relatedModel, value});
             // Si la relation est multiple (un tableau d'objets)
             if (Array.isArray(value)) {
                 return value
@@ -474,10 +478,16 @@ export const getDataAsString = (model, data, t, allModels, extended=false) => {
             }
             // Si la relation est simple (un seul objet)
             else if (typeof value === 'object') {
-                console.log({relatedModel, value});
                 return getDataAsString(relatedModel, value, t, allModels); // Appel récursif
             }
         }
+
+        if(fieldDef.type === 'datetime'){
+            return new Date(value).toLocaleDateString(lang, {year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric'});
+        }
+        if(fieldDef.type === 'date'){
+            return new Date(value).toLocaleDateString(lang, {year: 'numeric', month: 'numeric', day: 'numeric'});
+        }
         // --- FIN DE LA NOUVELLE LOGIQUE ---
 
         // Logique existante pour les autres types de champs

package/src/defaultModels.js

@@ -106,11 +106,11 @@ export const defaultModels = {
             { name: 'subject', type: 'string' }, // Sujet de la notification (ex: titre de l'email)
             { name: 'content', type: 'richtext', required: true }, // Contenu du message (localisable)
             { name: 'channels', type: 'relation', multiple: true, relation: 'channel' }, // Canaux de diffusion (email, SMS, forum, etc.)
-            { name: 'status', type: 'enum', items: ['en attente', 'envoyée', 'lue', 'échouée'] },
+            { name: 'status', type: 'enum', items: ['pending', 'sent', 'read', 'failed'] },
             { name: 'sentAt', type: 'datetime' },
             { name: 'readAt', type: 'datetime' },
             { name: 'type', type: 'string' }, // Type de notification (ex: "commande.miseAJour", "messageForum")
-            { name: 'priority', type: 'enum', items: ['basse', 'moyenne', 'haute'] },
+            { name: 'priority', type: 'enum', items: ['low', 'medium', 'high']},
         ],
     },
     alert: {
@@ -404,7 +404,7 @@ export const defaultModels = {
             { name: 'invoiceId', type: 'string', required: true, unique: true },
             { name: 'invoiceDate', type: 'datetime', required: true },
             { name: 'dueDate', type: 'datetime' },
-            { name: 'status', type: 'enum', items: ['payée', 'non payée', 'partiellement payée', 'annulée'] },
+            { name: 'status', type: 'enum', items: ['paid', 'unpaid', 'partially_paid', 'cancelled'] },
         ],
     },
     userSubscription: {
@@ -418,8 +418,8 @@ export const defaultModels = {
             { name: 'endDate', type: 'datetime' },
             { name: 'price', type: 'number', required: true },
             { name: 'currency', type: 'relation', relation: 'currency', required: true },
-            { name: 'paymentMethod', type: 'enum', items: ['carte bancaire', 'mandat SEPA'] },
-            { name: 'status', type: 'enum', items: ['actif', 'inactif', 'annulé', 'expiré', 'en attente'] },
+            { name: 'paymentMethod', type: 'enum', items: ['bank_card', 'SEPA_mandate', 'cash', 'check', 'other'] },
+            { name: 'status', type: 'enum', items: ['active', 'inactive', 'cancelled', 'expired', 'pending'] },
             { name: 'billingCycleAnchor', type: 'datetime' },
             { name: 'nextBillingDate', type: 'datetime' },
             { name: 'lastBillingDate', type: 'datetime' },
@@ -455,7 +455,7 @@ export const defaultModels = {
             { name: 'order', type: 'relation', relation: 'order', required: true },
             { name: 'trackingNumber', type: 'string' },
             { name: 'carrier', type: 'string' },
-            { name: 'status', type: 'enum', items: ['en attente', 'en transit', 'livrée', 'problème'] },
+            { name: 'status', type: 'enum', items: ['pending', 'in_transit', 'delivered', 'issue'] },
             { name: 'estimatedDeliveryDate', type: 'datetime' },
             { name: 'actualDeliveryDate', type: 'datetime' }
         ],
@@ -476,7 +476,7 @@ export const defaultModels = {
             { "name": "user", "type": "relation", relation: "user" },
             { "name": "reason", "type": "string", maxlength: 2048, required: true },
             { "name": "channel", "type": "relation", relation: 'channel' },
-            { "name": "status", "type": "enum", items: ["en attente", "approuvé", "remboursé", "refusé"] },
+            { "name": "status", "type": "enum", items: ["pending", "approved", "refunded", "refused"] },
             { name: 'amount', type: 'number', min: 0 },
             { name: 'currency', type: 'relation', relation: 'currency' },
             { name: 'refundDate', type: 'datetime' },
@@ -490,7 +490,7 @@ export const defaultModels = {
             { name: 'product', type: 'relation', relation: 'product', required: true },
             { name: 'variant', type: 'relation', relation: 'productVariant' },
             { name: 'quantity', type: 'number', required: true, min: 1 },
-            { name: 'condition', type: 'enum', items: ['neuf', 'très bon état', 'bon état', 'dégradé', 'endommagé', 'inutilisable'] }
+            { name: 'condition', type: 'enum', items: ['new', 'very_good', 'good', 'degraded', 'damaged', 'unusable'] }
         ],
     },
     ticket: {
@@ -504,8 +504,8 @@ export const defaultModels = {
             { name: 'parent', type: 'relation', relation: 'ticket' },
             { name: 'subject', type: 'string', required: true },
             { name: 'message', type: 'richtext', required: true },
-            { name: 'status', type: 'enum', items: ['ouvert', 'en cours', 'fermé'] },
-            { name: 'priority', type: 'enum', items: ['basse', 'moyenne', 'haute'] },
+            { name: 'status', type: 'enum', items: ['opened', 'in_progress', 'closed'] },
+            { name: 'priority', type: 'enum', items: ['low', 'medium', 'high', 'urgent'] },
             { name: 'assignedTo', type: 'relation', relation: 'user' },
             { name: 'createdAt', type: 'datetime', required: true }
         ],
@@ -518,8 +518,8 @@ export const defaultModels = {
             { name: 'description', type: 'richtext' },
             { name: 'startDate', type: 'datetime' },
             { name: 'endDate', type: 'datetime' },
-            { name: 'type', type: 'enum', items: ['email', 'SMS', 'publicité', 'promotion'] },
-            { name: 'status', type: 'enum', items: ['planifiée', 'en cours', 'terminée', 'annulée'] },
+            { name: 'type', type: 'enum', items: ['email', 'sms', 'advertisement', 'promotion'] },
+            { name: 'status', type: 'enum', items: ['planified', 'in_progress', 'finished', 'cancelled'] },
             { name: 'budget', type: 'number' }
         ],
     },
@@ -631,7 +631,7 @@ export const defaultModels = {
             {
                 "name": "status",
                 "type": "enum",
-                "items": ["brouillon", "validée", "annulée"],
+                "items": ["draft", "validated", "cancelled"],
                 "default": "brouillon"
             },
             {
@@ -1283,5 +1283,117 @@ export const defaultModels = {
                 hint: "Pièces jointes (reçus, factures)."
             },
         ]
+    },
+    event: {
+        "name": "event",
+        "description": "A model for managing events, conferences, meetups, and gatherings.",
+        "fields": [
+            {
+                "name": "title",
+                "type": "string",
+                "required": true,
+                "asMain": true,
+                "hint": "The title of the event"
+            },
+            {
+                "name": "description",
+                "type": "richtext_t",
+                "hint": "A detailed description of the event, including agenda, speakers, and other relevant information."
+            },
+            {
+                "name": "startDate",
+                "type": "datetime",
+                "required": true,
+                "hint": "The starting date and time of the event"
+            },
+            {
+                "name": "endDate",
+                "type": "datetime",
+                "required": true,
+                "hint": "The ending date and time of the event"
+            },
+            {
+                "name": "location",
+                "type": "relation",
+                "relation": "location",
+                "hint": "The venue or location where the event will be held. This could be a physical address or an online meeting link."
+            },
+            {
+                "name": "categories",
+                "type": "relation",
+                "relation": "taxonomy",
+                "multiple": true,
+                "hint": "Categories or tags associated with the event (e.g., \"conference\", \"workshop\", \"music\", \"technology\")."
+            },
+            {
+                "name": "organizer",
+                "type": "relation",
+                "relation": "contact",
+                "hint": "The name of the organization or individual hosting the event."
+            },
+            {
+                "name": "isOnline",
+                "type": "boolean",
+                "default": false,
+                "hint": "Whether the event is online or in-person."
+            },
+            {
+                "name": "eventUrl",
+                "type": "url",
+                "hint": "A link to the official event webpage or registration page."
+            },
+            {
+                "name": "imageUrl",
+                "type": "file",
+                "hint": "URL of the event image or banner."
+            },
+            {
+                "name": "status",
+                "type": "enum",
+                "items": [
+                    "scheduled",
+                    "ongoing",
+                    "completed",
+                    "cancelled",
+                    "postponed"
+                ],
+                "hint": "The current status of the event."
+            },
+            {
+                "name": "capacity",
+                "type": "number",
+                "hint": "The maximum number of attendees allowed for the event."
+            },
+            {
+                "name": "price",
+                "type": "number",
+                "hint": "The price of admission, if applicable."
+            },
+            {
+                "name": "currency",
+                "type": "relation",
+                "relation": "currency",
+                "hint": "The currency for the price (e.g., USD, EUR)."
+            },
+            {
+                "name": "registrationDeadline",
+                "type": "datetime",
+                "hint": "The date by which attendees must register for the event."
+            },
+            {
+                "name": "attendees",
+                "type": "relation",
+                "relation": "contact",
+                "multiple": true,
+                "hint": "A relation to the contacts attending the event"
+            },
+            {
+                "name": "sponsors",
+                "type": "relation",
+                "relation": "contact",
+                "multiple": true,
+                "hint": "List of sponsors or partners involved in the event."
+            }
+        ]
     }
 };

package/src/email.js

@@ -2,6 +2,8 @@ import { translations } from "data-primals-engine/i18n";
 import process from "node:process";
 import nodemailer from "nodemailer";
 import juice from "juice";
+import {event_trigger} from "./core.js";
+import {emailDefaultConfig} from "./constants.js";
 
 // Le transporteur par défaut, utilisé si aucune config spécifique n'est fournie.
 const defaultTransporter = nodemailer.createTransport({

package/src/engine.js

@@ -4,14 +4,11 @@ import fs from 'node:fs'
 import express from 'express'
 import {MongoClient as InternalMongoClient} from 'mongodb'
 import process from "process";
-import multipart from 'connect-multiparty';
-import path from 'node:path';
-import bodyParser from "body-parser";
-import {cookiesSecret, dbName, install, maxDataSize} from "./constants.js";
+import {cookiesSecret, dbName} from "./constants.js";
 import http from "http";
 import cookieParser from "cookie-parser";
 import requestIp from 'request-ip';
-import {createModel, getModels, installAllPacks, validateModelStructure} from "./modules/data.js";
+import {createModel, deleteModels, getModels, validateModelStructure} from "./modules/data.js";
 import {defaultModels} from "./defaultModels.js";
 import {DefaultUserProvider} from "./providers.js";
 import formidableMiddleware from 'express-formidable';
@@ -28,9 +25,10 @@ export const MongoDatabase = MongoClient.db(dbName);
 
 
 export const Engine = {
-    Create:  (options) => {
+    Create: async (options) => {
         const engine = GameObject.Create("Engine");
         console.log("Creating engine", Config.Get('modules'));
+        engine.addComponent(Logger);
 
         engine.userProvider = new DefaultUserProvider(engine);
 
@@ -39,9 +37,8 @@ export const Engine = {
             engine.getComponent(Logger).info(`Custom UserProvider '${providerInstance.constructor.name}' has been set.`);
         };
 
-        var app = express();
-
-// Allows you to set port in the project properties.
+        const app = express();
+        // Allows you to set port in the project properties.
         app.set('port', process.env.PORT || 3000);
         app.set('engine', engine);
 
@@ -50,7 +47,7 @@ export const Engine = {
             uploadDir: process.cwd()+'/uploads/tmp',
             multiples: true, // req.files to be arrays of files
         }));
-        app.use(cookieParser(isProduction ? cookiesSecret : 'secret'));
+        app.use(cookieParser(process.env.COOKIES_SECRET || cookiesSecret));
         app.use(requestIp.mw())
 
         engine.use = (...args) => {
@@ -75,10 +72,38 @@ export const Engine = {
             return engine._modules.find(m => m.module === module);
         };
 
+
+        const logger = engine.getComponent(Logger);
+
+        const importModule = async (module) => {
+            const moduleA = await import(module);
+            if (moduleA.onInit){
+                await moduleA.onInit(engine);
+                return {...moduleA, module};
+            }else {
+                const mod = moduleA.default();
+                await mod?.onInit(engine);
+                return { ...mod, module};
+            }
+        };
+
+        await Promise.all(Config.Get('modules').map(async module => {
+            try {
+                if( fs.existsSync(module)){
+                    return await importModule(module);
+                }else {
+                    return await importModule('./modules/' + module + ".js");
+                }
+            } catch (e){
+                console.log('ERROR at loading module '+ module + ' in /modules dir.'+ e);
+            }
+        })).then(async e => {
+            engine._modules = e;
+            return Promise.resolve();
+        });
         let server;
         engine.start = async (port, cb) =>{
     // Use connect method to connect to the server
-            await MongoClient.connect();
 
             // Start http server
             server = http.createServer(app);
@@ -91,37 +116,11 @@ export const Engine = {
 
             server.listen(port);
 
-            const importModule = async (module) => {
-                const moduleA = await import(module);
-                if (moduleA.onInit){
-                    await moduleA.onInit(engine);
-                    return {...moduleA, module};
-                }else {
-                    const mod = moduleA.default();
-                    await mod?.onInit(engine);
-                    return { ...mod, module};
-                }
-            };
-
-            await Promise.all(Config.Get('modules').map(async module => {
-                try {
-                    if( fs.existsSync(module)){
-                        return await importModule(module);
-                    }else {
-                        return await importModule('./modules/' + module + ".js");
-                    }
-                } catch (e){
-                    console.log('ERROR at loading module '+ module + ' in /modules dir.'+ e);
-                }
-            })).then(async e => {
-                engine._modules = e;
-                if (cb)
-                    return await cb();
-                return Promise.resolve();
-            });
-
             await setupInitialModels();
 
+            if (cb)
+                await cb();
+
             process.on('uncaughtException', function (exception) {
                 console.error(exception);
                 fs.appendFile('issues.txt', JSON.stringify({ code: exception.code, message: exception.message, stack: exception.stack }), function (err) {
@@ -132,17 +131,14 @@ export const Engine = {
                 process.exit(0);
             });
         }
-        engine.addComponent(Logger);
 
         engine.stop = async () => {
             await server.close();
         };
 
-        const logger = engine.getComponent(Logger);
-
         async function setupInitialModels() {
-            logger.info("Validation des structures de modèles et insertion");
-            const ms = Object.values(Config.Get('defaultModels', []));
+            logger.info("Validating structures of default models...");
+            const ms = Object.values(Config.Get('defaultModels', defaultModels));
 
             let dbModels = await getModels();
 
@@ -155,13 +151,15 @@ export const Engine = {
                     model.locked = true;
                     const r = await createModel(model);
                     dbModels.push({...model, _id: r.insertedId });
-                }
-                else
-                    logger.info('Model loaded (' + model.name + ')', {});
+                    logger.info('Model inserted (' + model.name + ')');
+                }else
+                logger.info('Model loaded (' + model.name + ')');
             }
             logger.info("All models loaded.");
         }
-
+        engine.resetModels = async () => {
+            await deleteModels();
+        };
        return engine;
     }
 }

package/src/gameObject.js

@@ -70,23 +70,21 @@ export class UsableBehaviour extends Behaviour {
 
     use() {
         Event.Trigger("GameObject.UsableBehavior.use",  "system", "calls", this);
-        // Logique d'utilisation (exemple)
-        console.log(this.gameObject.name + " a été utilisé !");
     }
 }
 
-const pilote = GameObject.Create("Pilote");
+const mainDriver = GameObject.Create("MainDrivers");
 
 // Exemple d'attachement de comportements
-pilote.addComponent(MovableBehaviour, 10);
-pilote.addComponent(UsableBehaviour);
+mainDriver.addComponent(MovableBehaviour, 10);
+mainDriver.addComponent(UsableBehaviour);
 
 // Accéder et utiliser les composants
-const movable = pilote.getComponent(MovableBehaviour);
+const movable = mainDriver.getComponent(MovableBehaviour);
 if (movable) {
     movable.update();
 }
-const usable = pilote.getComponent(UsableBehaviour);
+const usable = mainDriver.getComponent(UsableBehaviour);
 if (usable) {
     usable.use();
 }