data-primals-engine 1.4.3 → 1.5.1

package/src/providers.js

@@ -2,6 +2,7 @@ import {compare, hash} from "bcrypt";
 import {maxTotalPrivateFilesSize} from "./constants.js";
 import {getCollection, ObjectId} from "./modules/mongodb.js";
 import {Logger} from "./gameObject.js";
+import {Config} from "./config.js";
 
 /**
  * @class UserProvider
@@ -73,7 +74,7 @@ export class UserProvider {
      * @returns {Promise<number>}
      */
     async getUserStorageLimit(user) {
-        return maxTotalPrivateFilesSize;
+        return Config.Get('maxTotalPrivateFilesSize', maxTotalPrivateFilesSize);
     }
 
     /**
@@ -112,23 +113,23 @@ export class UserProvider {
 
 export class DefaultUserProvider extends UserProvider {
 
-    users= [{ username: "demo", password: "demo" }];
+    users= [{ username: "demo", password: "demo", temporary: true }];
 
     /**
      * Trouve un utilisateur. Gère spécifiquement les utilisateurs de démo.
      */
     async findUserByUsername(username) {
         // Si le nom d'utilisateur commence par "demo", on le considère comme un utilisateur de démo valide et volatile.
-        if (typeof username === 'string' && username.startsWith('demo')) {
+        if (this.isDemoUser(username)){
             // On retourne un objet utilisateur de démo avec la structure attendue.
-            return { username: username, password: "demo", userPlan: 'free' }; // Ajout de userPlan pour la cohérence
+            return { username: username, password: "demo", userPlan: 'free', temporary: true }; // Ajout de userPlan pour la cohérence
         }
         // Logique pour les vrais utilisateurs (si vous en ajoutez plus tard)
         return this.users.find(user => user.username === username);
     }
 
     async getUserStorageLimit(user) {
-        return maxTotalPrivateFilesSize;
+        return Config.Get('maxTotalPrivateFilesSize', maxTotalPrivateFilesSize);
     }
 
     async getBackupFrequency(user){
@@ -139,9 +140,13 @@ export class DefaultUserProvider extends UserProvider {
         return []
     }
 
+    isDemoUser(user) {
+        return (typeof (user) === 'string' && (/^demo[0-9]{0,2}$/.test(user) || /^perf[0-9]{1,8}$/.test(user)))
+    }
+
     async validatePassword(user, password) {
         // Pour un utilisateur de démo, le mot de passe est toujours valide.
-        if (user.username.startsWith('demo')) {
+        if (this.isDemoUser(user)){
             return true;
         }
         // Logique pour les vrais utilisateurs
@@ -166,7 +171,7 @@ export class DefaultUserProvider extends UserProvider {
 
         // Priorité 2: PasF de session, mais on vérifie la présence d'un cookie "username" pour la démo.
         const demoUsername = req.cookies?.username;
-        if (demoUsername && typeof demoUsername === 'string' && demoUsername.startsWith('demo')) {
+        if (demoUsername && typeof demoUsername === 'string' && this.isDemoUser(demoUsername)) {
             // On a trouvé un cookie de démo. On crée l'objet utilisateur correspondant.
             const demoUser = await this.findUserByUsername(demoUsername);
             if (demoUser) {
@@ -174,6 +179,16 @@ export class DefaultUserProvider extends UserProvider {
                 return;
             }
         }
+
+        // Priorité 2: PasF de session, mais on vérifie la présence d'un cookie "username" pour la démo.
+        const user = req.query._user;
+        if (user && typeof user === 'string' && this.isDemoUser(user)) {
+            const demoUser = await this.findUserByUsername(user);
+            if (demoUser) {
+                req.me = demoUser;
+                return;
+            }
+        }
     }
 
     getUserPlans(){

package/test/data.integration.test.js

@@ -1,6 +1,9 @@
 // __tests__/data.integration.test.js
 import { ObjectId } from 'mongodb';
 import {vi, expect, describe, it, afterEach,beforeEach, beforeAll, afterAll} from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
 import { Config } from '../src/config.js';
 import {
     insertData,
@@ -17,6 +20,7 @@ import {
 import {getRandom} from "../src/core.js";
 import {generateUniqueName, initEngine} from "../src/setenv.js";
 import {purgeData} from "../src/modules/data/data.history.js";
+import {removeFile} from "../src/modules/file.js";
 
 let testModelsColInstance;
 let testDatasColInstance;
@@ -88,7 +92,7 @@ async function setupTestContext() {
             {name: 'relationSingle', type: 'relation', relation: currentRelatedModelName},
             {name: 'relationMultiple', type: 'relation', relation: currentRelatedModelName, multiple: true},
             // File (metadata validation)
-            {name: 'fileField', type: 'file', mimeTypes: ['image/png', 'application/pdf'], maxSize: 1024 * 10}, // 10KB
+            {name: 'fileField', type: 'file', mimeTypes: ['image/png', 'application/pdf', 'text/plain'], maxSize: 1024 * 10}, // 10KB
             // Color
             {name: 'colorField', type: 'color'},
             // Code
@@ -285,7 +289,7 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             // --- FILE VALIDATIONS (metadata) ---
             it('devrait rejeter un file avec un mimeType non autorisé', async () => {
                 const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await setupTestContext();
-                const mockFile = { name: 'test.txt', type: 'text/plain', size: 1024, guid: 'dummy-txt' };
+                const mockFile = { name: 'test.txt', type: 'text/csv', size: 1024, guid: 'dummy-txt' };
                 const result = await insertData(comprehensiveTestModelDefinition.name, { stringRequired: 'req', fileField: mockFile }, {}, currentTestUser, false);
                 expect(result.success).toBe(false);
                 expect(result.error).toContain('image/png'); // Ou un message plus spécifique sur mimeTypes
@@ -414,6 +418,57 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
 
             await purge();
         }, 10000); // Augmenter le timeout si nécessaire
+
+        it('devrait insérer des données avec un nouveau fichier et le sauvegarder', async () => {
+            const { currentTestUser, comprehensiveTestModelDefinition, purge } = await setupTestContext();
+
+            // --- Simuler un vrai fichier uploadé comme le ferait formidable/multer ---
+            const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'data-primals-test-'));
+            const filePath = path.join(tmpDir, 'test-upload.txt');
+            const fileContent = 'Ceci est un vrai test de fichier binaire.';
+            await fs.writeFile(filePath, fileContent);
+            const stats = await fs.stat(filePath);
+
+            const uploadedFile = {
+                filepath: filePath,
+                originalFilename: 'test-upload-on-insert.txt',
+                mimetype: 'text/plain',
+                size: stats.size,
+                lastModifiedDate: new Date(),
+                hash: 'test-hash' // Optionnel, mais souvent présent
+            };
+            // --- Fin de la simulation ---
+
+            const dataWithFile = {
+                stringRequired: 'DocWithNewFile',
+                stringUnique: 'UniqueFileValueForInsert',
+                passwordField: 'filePass',
+                enumField: 'gamma',
+                number: 123
+                // Le champ 'fileField' est absent ici, il sera fourni dans l'objet 'files'
+            };
+
+            const result = await insertData(comprehensiveTestModelDefinition.name, dataWithFile, { 'fileField[0]': uploadedFile }, currentTestUser, false);
+
+            expect(result.success, `L'insertion avec un nouveau fichier a échoué: ${result.error}`).toBe(true);
+            expect(result.insertedIds).toHaveLength(1);
+
+            const query = await searchData( { model: comprehensiveTestModelDefinition.name, filter: { _id: new ObjectId(result.insertedIds[0])}}, currentTestUser);
+            const insertedDoc = query.data[0];
+            expect(insertedDoc).not.toBeNull();
+            console.log(insertedDoc.fileField)
+            expect(insertedDoc.fileField).toBeInstanceOf(Object);
+            expect(insertedDoc.fileField.newFile).toBeUndefined(); // La propriété 'newFile' était une hallucination
+            expect(insertedDoc.fileField._id).toBeDefined();
+            expect(insertedDoc.fileField.name).toBe('test-upload-on-insert.txt');
+            expect(insertedDoc.fileField.guid).toBeDefined();
+
+            await removeFile(insertedDoc.fileField.guid, currentTestUser);
+
+            // Nettoyage du répertoire et fichier temporaire
+            await fs.rm(tmpDir, { recursive: true, force: true });
+            await purge();
+        });
     });
 
     describe('editData avec comprehensiveTestModel', async () => {
@@ -679,6 +734,85 @@ describe('Intégration des fonctions CRUD de données avec validation complète'
             await purge();
         });
 
+        // --- NOUVEAUX TESTS POUR LE SHORTHAND $find ---
+
+        it('devrait trouver un document en utilisant un filtre $find simple (shorthand)', async () => {
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
+            const searchParams = {
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    relationSingle: {
+                        "$find": { "relatedValue": 101 } // Utilisation du shorthand { champ: valeur }
+                    }
+                },
+                depth: 1
+            };
+            const { data, count } = await searchData(searchParams, currentTestUser);
+            expect(count).toBe(1);
+            expect(data).toHaveLength(1);
+            expect(data[0]._id.toString()).toBe(docId1.toString());
+            await purge();
+        });
+
+        it('devrait trouver un document en utilisant un filtre $find simple avec plusieurs conditions (AND implicite)', async () => {
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
+            const searchParams = {
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    relationSingle: {
+                        "$find": {
+                            "relatedName": "Rel_Search_A1",
+                            "relatedValue": 101
+                        }
+                    }
+                },
+                depth: 1
+            };
+            const { data, count } = await searchData(searchParams, currentTestUser);
+            expect(count).toBe(1);
+            expect(data).toHaveLength(1);
+            expect(data[0]._id.toString()).toBe(docId1.toString());
+            await purge();
+        });
+
+        it('ne devrait pas trouver de document si une des conditions du $find simple échoue', async () => {
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
+            const searchParams = {
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    relationSingle: {
+                        "$find": {
+                            "relatedName": "Rel_Search_A1", // Correspond
+                            "relatedValue": 999 // Ne correspond pas
+                        }
+                    }
+                },
+                depth: 1
+            };
+            const { data, count } = await searchData(searchParams, currentTestUser);
+            expect(count).toBe(0);
+            expect(data).toHaveLength(0);
+            await purge();
+        });
+
+        it('devrait trouver un document via une relation multiple en utilisant un filtre $find simple', async () => {
+            const { currentTestUser, comprehensiveTestModelDefinition, relatedModelDefinition, purge } = await initTest();
+            const searchParams = {
+                model: comprehensiveTestModelDefinition.name,
+                filter: {
+                    relationMultiple: {
+                        "$find": { "relatedValue": 102 } // Devrait trouver docId1 car il a une relation vers relA2
+                    }
+                },
+                depth: 1
+            };
+            const { data, count } = await searchData(searchParams, currentTestUser);
+            expect(count).toBe(1);
+            expect(data).toHaveLength(1);
+            expect(data[0]._id.toString()).toBe(docId1.toString());
+            await purge();
+        });
+
     });
 
     describe('installPack', () => {

package/test/import_export.integration.test.js

@@ -11,7 +11,7 @@ import {
     modelsCollection as getAppModelsCollection,
     getCollectionForUser as getAppUserCollection, getCollectionForUser
 } from '../src/modules/mongodb.js';
-import {sleep} from "data-primals-engine/core";
+import {sleep} from "../src/core.js";
 import fs from "node:fs";
 import {initEngine} from "../src/setenv.js";
 import {Config} from "../src/index.js";