data-primals-engine 1.6.3 → 1.7.0

package/test/assistant.test.js

@@ -168,7 +168,7 @@ describe('Assistant Module Unit Tests', () => {
     });
 
     it('should correct a malformed filter from the AI', async () => {
-        const aiResponse = JSON.stringify({
+        const aiResponse = JSON.stringify([{
             action: 'search',
             params: {
                 model: modelName,
@@ -178,7 +178,7 @@ describe('Assistant Module Unit Tests', () => {
                     "$lt": ["$price", 200]
                 }
             }
-        });
+        }]);
         const mockLLM = {
             stream: vi.fn().mockReturnValue(createMockStream(aiResponse)),
         };

package/test/core.test.js

@@ -0,0 +1,341 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+    sleep,
+    escapeRegex,
+    sequential,
+    isValidRegex,
+    escapeHtml,
+    isUnsecureKey,
+    parseSafeJSON,
+    isDate,
+    safeAssignObject,
+    debounce,
+    uuidv4,
+    cssProps,
+    removeDir,
+    wordWrap,
+    getObjectHash,
+    isPathRelativeTo,
+    isGUID,
+    isPlainObject,
+    escapeRegExp,
+    shuffle,
+    setSeed,
+    getRand,
+    getRandom,
+    randomDate,
+    isLightColor,
+    tryParseJson,
+    isIsoDate,
+    event_trigger,
+    event_on,
+    event_off,
+    slugify,
+    getFileExtension,
+    object_equals,
+    isValidPath,
+    stringToHslColor,
+    countKeys
+} from '../src/core.js';
+
+describe('Core Utility Functions', () => {
+
+    describe('isPlainObject', () => {
+        it('should return true for plain objects', () => {
+            expect(isPlainObject({})).toBe(true);
+            expect(isPlainObject({ a: 1 })).toBe(true);
+        });
+
+        it('should return false for non-plain objects or other types', () => {
+            expect(isPlainObject([])).toBe(false);
+            expect(isPlainObject(null)).toBe(false);
+            expect(isPlainObject(new Date())).toBe(false);
+            expect(isPlainObject("string")).toBe(false);
+            expect(isPlainObject(123)).toBe(false);
+        });
+    });
+
+    describe('slugify', () => {
+        it('should convert string to a slug', () => {
+            expect(slugify('Hello World!')).toBe('hello-world');
+            expect(slugify('  Test avec des espaces  ')).toBe('test-avec-des-espaces');
+            expect(slugify('CaractèresSpéciaux-123', '-', true)).toBe('caracteresspeciaux-123');
+        });
+    });
+    
+    describe('sleep', () => {
+        beforeEach(() => {
+            vi.useFakeTimers();
+        });
+        afterEach(() => {
+            vi.useRealTimers();
+        });
+
+        it('should resolve after the specified duration', async () => {
+            const sleepPromise = sleep(1000);
+            vi.advanceTimersByTime(1000);
+            await expect(sleepPromise).resolves.toBeUndefined();
+        });
+    });
+
+
+    describe('getObjectHash', () => {
+        it('should generate a consistent hash for the same object', () => {
+            const obj1 = { name: 'test', value: 1 };
+            const obj2 = { value: 1, name: 'test' }; // Ordre différent
+            expect(getObjectHash(obj1)).toBe(getObjectHash(obj2));
+        });
+
+        it('should generate a different hash for different objects', () => {
+            const obj1 = { name: 'test', value: 1 };
+            const obj2 = { name: 'test', value: 2 };
+            expect(getObjectHash(obj1)).not.toBe(getObjectHash(obj2));
+        });
+    });
+    
+    describe('escapeRegex and escapeRegExp', () => {
+        it('should escape special regex characters', () => {
+            const specialString = '.*+?^${}()|[]\\';
+            const expected = '\\.\\*\\+\\?\\^\\$\\{\\}\\(\\)\\|\\[\\]\\\\';
+            expect(escapeRegex(specialString)).toBe(expected);
+            expect(escapeRegExp(specialString)).toBe(expected);
+        });
+    });
+
+    describe('sequential', () => {
+        it('should execute async tasks sequentially', async () => {
+            const order = [];
+            const task1 = async () => { await sleep(20); order.push(1); return 'a'; };
+            const task2 = async () => { await sleep(10); order.push(2); return 'b'; };
+
+            const results = await sequential([task1, task2]);
+
+            expect(order).toEqual([1, 2]);
+            expect(results).toEqual(['a', 'b']);
+        });
+    });
+
+    describe('isValidRegex', () => {
+        it('should validate correct regex strings', () => {
+            expect(isValidRegex('/hello/g')).toBe(true);
+            expect(isValidRegex('#[0-9]+#')).toBe(true);
+        });
+
+        it('should invalidate incorrect regex strings', () => {
+            expect(isValidRegex('/[a-z/')).toBe(false); // Unmatched bracket
+            expect(isValidRegex('hello')).toBe(false); // No delimiters
+        });
+    });
+
+    describe('escapeHtml', () => {
+        it('should escape HTML tags and dangerous protocols', () => {
+            const input = '<script>alert("xss")</script><a href="javascript:void(0)">link</a>'; // Le protocole "javascript:" sera supprimé
+            const expected = '&#60;script&#62;alert&#40;&#34;xss&#34;&#41;&#60;&#47;script&#62;&#60;a href&#61;&#34;void&#40;0&#41;&#34;&#62;link&#60;&#47;a&#62;';
+            expect(escapeHtml(input)).toBe(expected);
+        });
+    });
+
+    describe('isUnsecureKey', () => {
+        it('should identify unsecure keys', () => {
+            expect(isUnsecureKey('__proto__')).toBe(true);
+            expect(isUnsecureKey('constructor')).toBe(true);
+            expect(isUnsecureKey('prototype')).toBe(true);
+            expect(isUnsecureKey('safeKey')).toBe(false);
+        });
+    });
+
+    describe('parseSafeJSON', () => {
+        it('should parse valid JSON', () => {
+            expect(parseSafeJSON('{"a":1}')).toEqual({ a: 1 });
+        });
+
+        it('should prevent prototype pollution', () => {
+            const polluted = parseSafeJSON('{"__proto__":{"polluted":true}}');
+            expect(polluted.polluted).toBeUndefined();
+            const obj = {};
+            expect(obj.polluted).toBeUndefined();
+        });
+    });
+
+    describe('isDate', () => {
+        it('should return true for valid date strings and objects', () => {
+            expect(isDate(new Date())).toBe(true);
+            expect(isDate('2023-01-01')).toBe(true);
+        });
+
+        it('should return false for invalid dates', () => {
+            expect(isDate('not a date')).toBe(false);
+            expect(isDate(null)).toBe(false);
+        });
+    });
+
+    describe('safeAssignObject', () => {
+        it('should assign property for a safe key', () => {
+            const obj = {};
+            safeAssignObject(obj, 'a', 1);
+            expect(obj.a).toBe(1);
+        });
+
+        it('should not assign property for an unsecure key', () => {
+            const obj = {};
+            safeAssignObject(obj, '__proto__', { polluted: true });
+            expect(obj.polluted).toBeUndefined();
+        });
+    });
+
+    describe('debounce', () => {
+        beforeEach(() => { vi.useFakeTimers(); });
+        afterEach(() => { vi.useRealTimers(); });
+
+        it('should call the function only once after the delay', () => {
+            const spy = vi.fn();
+            const debounced = debounce(spy, 500);
+
+            debounced();
+            debounced();
+            debounced();
+
+            vi.advanceTimersByTime(500);
+            expect(spy).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('uuidv4', () => {
+        it('should generate a valid v4 UUID', () => {
+            const uuid = uuidv4();
+            const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+            expect(uuid).toMatch(uuidV4Regex);
+        });
+    });
+
+    describe('cssProps', () => {
+        it('should convert a CSS string to a style object', () => {
+            const css = 'background-color: red; font-size: 16px;';
+            const expected = { backgroundColor: 'red', fontSize: '16px' };
+            expect(cssProps(css)).toEqual(expected);
+        });
+    });
+
+    describe('wordWrap', () => {
+        it('should wrap a long string at a specified width', () => {
+            const str = 'this is a long string to be wrapped';
+            const wrapped = wordWrap(str, 10);
+            expect(wrapped).toBe('this is a\nlong\nstring to\nbe wrapped');
+        });
+    });
+
+    describe('isPathRelativeTo', () => {
+        it('should correctly identify relative paths', () => {
+            expect(isPathRelativeTo('/a/b/c', '/a/b')).toBe(true);
+            expect(isPathRelativeTo('/a/d', '/a/b')).toBe(false);
+            expect(isPathRelativeTo('/a/b', '/a/b/c')).toBe(false);
+        });
+    });
+
+    describe('isGUID', () => {
+        it('should validate correct GUIDs', () => {
+            expect(isGUID('123e4567-e89b-12d3-a456-426614174000')).toBe(true);
+        });
+        it('should invalidate incorrect GUIDs', () => {
+            expect(isGUID('not-a-guid')).toBe(false);
+        });
+    });
+
+    describe('shuffle', () => {
+        it('should contain the same elements after shuffling', () => {
+            const original = [1, 2, 3, 4, 5];
+            const shuffled = [...original];
+            shuffle(shuffled);
+            expect(shuffled).toHaveLength(original.length);
+            expect(shuffled.sort()).toEqual(original.sort());
+        });
+    });
+
+    describe('Seeded Random', () => {
+        it('should produce consistent random numbers for the same seed', () => {
+            setSeed(12345);
+            const rand1 = getRand();
+            const rand2 = getRand();
+
+            setSeed(12345);
+            const rand3 = getRand();
+            const rand4 = getRand();
+
+            expect(rand1).toBe(rand3);
+            expect(rand2).toBe(rand4);
+            expect(rand1).not.toBe(rand2);
+        });
+    });
+
+    describe('isLightColor', () => {
+        it('should identify light and dark colors', () => {
+            expect(isLightColor('#FFFFFF')).toBe(true);
+            expect(isLightColor('#000000')).toBe(false);
+            expect(isLightColor('#f0f0f0')).toBe(true);
+            expect(isLightColor('#3498db')).toBe(false); // primary-color from scss
+        });
+    });
+
+    describe('tryParseJson', () => {
+        it('should parse valid JSON strings', () => {
+            expect(tryParseJson('{"a": 1}')).toEqual({ a: 1 });
+        });
+        it('should return null for invalid JSON strings', () => {
+            expect(tryParseJson('{"a": 1')).toBeNull();
+            expect(tryParseJson('not json')).toBeNull();
+        });
+    });
+
+    describe('isIsoDate', () => {
+        it('should validate correct ISO date strings', () => {
+            expect(isIsoDate('2023-10-26T10:00:00.000Z')).toBe(true);
+        });
+        it('should invalidate incorrect ISO date strings', () => {
+            expect(isIsoDate('2023-10-26')).toBe(false);
+            expect(isIsoDate(new Date().toString())).toBe(false);
+        });
+    });
+
+    describe('event system', () => {
+        beforeEach(() => {
+            event_off('test');
+        });
+        it('should trigger a registered event', () => {
+            const spy = vi.fn();
+            event_on('test', spy);
+            event_trigger('test', 'arg1');
+            expect(spy).toHaveBeenCalledWith('arg1');
+        });
+    });
+
+    describe('getFileExtension', () => {
+        it('should return the file extension', () => {
+            expect(getFileExtension('file.txt')).toBe('txt');
+            expect(getFileExtension('archive.tar.gz')).toBe('gz');
+            expect(getFileExtension('noextension')).toBe('');
+        });
+    });
+
+    describe('object_equals', () => {
+        it('should correctly compare objects', () => {
+            expect(object_equals({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } })).toBe(true);
+            expect(object_equals({ a: 1 }, { a: 2 })).toBe(false);
+        });
+    });
+
+    describe('stringToHslColor', () => {
+        it('should generate a consistent HSL color string', () => {
+            expect(stringToHslColor('test')).toBe('hsl(58, 70%, 55%)');
+        });
+    });
+
+    describe('countKeys', () => {
+        it('should count keys in nested objects and arrays', () => {
+            const obj = { a: 1, b: { c: 2, d: [1, { e: 3 }] } };
+            expect(countKeys(obj)).toBe(5);
+        });
+    });
+
+});

package/test/data.backup.integration.test.js

@@ -57,7 +57,7 @@ let engineInstance;
 let testDatasApi;
 
 const backupDir = path.resolve('./test-backups'); // Use an absolute path
-
+let engine;
 beforeAll(async () => {
 
     process.env.BACKUP_DIR = backupDir; // Set backup directory
@@ -66,6 +66,8 @@ beforeAll(async () => {
     if (!fs.existsSync(backupDir)) {
         fs.mkdirSync(backupDir, { recursive: true });
     }
+    Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow", "user", "assistant"]);
+    engine = await initEngine();
 
     // Delete any existing files in the backup directory
     fs.readdirSync(backupDir).forEach(file => {

package/test/data.history.integration.test.js

@@ -8,7 +8,6 @@ import { insertData, editData, deleteData } from '../src/index.js';
 import { getCollection, getCollectionForUser } from '../src/modules/mongodb.js';
 import { generateUniqueName, initEngine } from "../src/setenv.js";
 import {purgeData} from "../src/modules/data/data.history.js";
-import {MongoDatabase} from "../src/engine.js";
 
 let engine;
 let testUser;

package/test/data.integration.test.js

@@ -9,7 +9,7 @@ import {
     insertData,
     editData,
     deleteData,
-    searchData, installPack, deleteModels, createModel, patchData
+    searchData, installPack, deleteModels, createModel, patchData, datasCollection
 } from '../src/index.js';
 
 import {
@@ -17,7 +17,8 @@ import {
     getCollection,
     getCollectionForUser as getAppUserCollection, getCollectionForUser
 } from '../src/modules/mongodb.js';
-import {getRandom} from "../src/core.js";
+import { isConditionMet } from '../src/filter.js';
+import {getRandom, isPlainObject} 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";
@@ -1279,4 +1280,138 @@ describe('Data integration tests (CRUD, validation...)', () => {
             expect(data[0]._id.toString()).toBe(noEnvDocId.toString());
         });
     });
+
+    describe('Data operations with permission filters', () => {
+        let testUser, testSystemUser, permissionAdd, permissionEdit, permissionDelete, role;
+        let orderModelDef, pendingOrderId, shippedOrderId, otherUserOrderId;
+
+        beforeEach(async () => {
+            // Création d'un utilisateur de test isolé
+            const username = generateUniqueName('perm_filter_user');
+            testUser = { _id: new ObjectId(), username: username, _user: 'testSystemUser', _model: 'user', roles: [] };
+            testSystemUser = { _id: new ObjectId(), username: 'testSystemUser', roles: ['API_ADMIN'] }; // L'utilisateur système a tous les droits
+            const collection = await getCollectionForUser(testUser);
+
+            // 1. Créer les modèles nécessaires
+            await createModel({ name: 'permission', description:'t', _user: testSystemUser.username, fields: [{ name: 'name', type: 'string' }, { name: 'filter', type: 'code', language: 'json' }, { name: 'description', type: 'string' }] });
+            await createModel({ name: 'role',description:'t', _user: testSystemUser.username, fields: [{ name: 'name', type: 'string' }, { name: 'permissions', type: 'relation', relation: 'permission', multiple: true }] });
+            // Le modèle 'orderTest' doit exister pour les deux utilisateurs : testUser (pour les opérations de test) et testSystemUser (pour le setup)
+            orderModelDef = { name: 'orderTest',description:'t', _user: testSystemUser.username, fields: [{ name: 'status', type: 'string' }, { name: 'amount', type: 'number' }, { name: 'customer', type: 'string' }] };
+            const t = await createModel(orderModelDef);
+
+            // 2. Créer les permissions avec filtres pour les tests
+            const permissionsToCreate = [
+                // On a besoin de ces permissions pour que testUser puisse créer le rôle et les permissions
+                { name: 'API_ADD_DATA_permission', _user: testSystemUser.username },
+                { name: 'API_ADD_DATA_role', _user: testSystemUser.username },
+                // Permissions de l'application
+                { name: 'API_SEARCH_DATA_orderTest' }, // <-- AJOUTER CETTE LIGNE
+                { name: 'API_ADD_DATA_orderTest', filter: { "$lt" : ["$amount", 1000] }, description: "Filter for adding orders" },
+                { name: 'API_EDIT_DATA_orderTest', filter: { status: 'pending' } },
+                { name: 'API_DELETE_DATA_orderTest', filter: { customer: testUser._id.toString() } }
+            ];
+            // On insère les permissions pour les deux utilisateurs pour que le rôle soit valide pour testUser
+            let permResult = await insertData('permission', permissionsToCreate, {}, testSystemUser, false, false, false); // Pour le setup
+            expect(permResult.success, `La création des permissions a échoué: ${permResult.error}`).toBe(true);
+
+            // 3. Récupérer les IDs des permissions et créer le rôle
+            // On se base sur les permissions de l'utilisateur de test pour créer son rôle
+            const allPerms = await (await getCollectionForUser(testSystemUser)).find({ _model: 'permission' }).toArray();
+            const permIds = allPerms.map(p => p._id.toString());
+
+            // On insère le rôle pour les deux utilisateurs
+            let roleRes = await insertData('role', { name: 'OrderManager', permissions: permIds }, {}, testSystemUser, false, false, false);
+            expect(roleRes.success, `La création du rôle a échoué: ${roleRes.error}`).toBe(true);
+            role = roleRes.insertedIds[0];
+
+            // 4. Assigner le rôle à l'utilisateur de test
+            testUser.roles = [role.toString()];
+
+            // 5. Créer les données de test avec l'utilisateur de test lui-même.
+            // Pour cela, on lui donne temporairement les droits d'admin pour le setup.
+            const originalRoles = testUser.roles;
+            testUser.roles = ['API_ADMIN']; // Droits temporaires pour créer les données
+            const pendingOrder = await insertData('orderTest', { status: 'pending', amount: 100, customer: testUser._id.toString() }, {}, testUser, false, false, false);
+            pendingOrderId = pendingOrder.insertedIds[0];
+            const shippedOrder = await insertData('orderTest', { status: 'shipped', amount: 200, customer: testUser._id.toString() }, {}, testUser, false, false, false);
+            shippedOrderId = shippedOrder.insertedIds[0];
+            const otherOrder = await insertData('orderTest', { status: 'pending', amount: 300, customer: 'other_user_id' }, {}, testUser, false, false, false);
+            otherUserOrderId = otherOrder.insertedIds[0];
+            testUser.roles = originalRoles; // Restaurer les vrais rôles pour le test
+        });
+
+        afterEach(async () => {
+            await (await getCollectionForUser(testUser)).deleteMany({ _user: testUser.username });
+            await (await getCollectionForUser(testSystemUser)).deleteMany({ _user: testSystemUser.username });
+            await deleteModels({ _user: testUser.username });
+            await deleteModels({ _user: testSystemUser.username });
+        });
+
+        afterAll(async () =>{
+            await purgeData(testUser);
+            await purgeData(testSystemUser);
+            await datasCollection.drop();
+        })
+
+        // --- TEST POUR insertData ---
+        it('should REJECT inserting data that violates the permission filter', async () => {
+            // This should fail because the amount (1500) is not < 1000
+            const result = await insertData('orderTest', { status: 'new', amount: 1500, customer: 'new_customer' }, {}, testUser, false, false);
+            
+            expect(result.success).toBe(false);
+            
+        });
+
+        it('should ALLOW inserting data that respects the permission filter', async () => {
+            // This should succeed because the amount (500) is < 1000            
+            const result = await insertData('orderTest', { status: 'new', amount: 500, customer: 'new_customer' }, {}, testUser, false, false);
+
+            expect(result.success, `L'insertion aurait dû réussir: ${result.error}`).toBe(true);
+            expect(result.insertedIds).toHaveLength(1);
+        });
+
+        // --- TESTS POUR editData ---
+        it('should ALLOW editing a document that matches the permission filter', async () => {
+            // Le filtre de permission est { status: 'pending' }
+            const result = await editData('orderTest', { _id: pendingOrderId }, { amount: 150 }, {}, testUser, false, false);
+
+            expect(result.success, `editData failed with error: ${result.error}`).toBe(true);
+            expect(result.modifiedCount).toBeGreaterThanOrEqual(0); // Peut être 0 si le hash ne change pas
+
+            const coll = await getCollectionForUser(testUser);
+            const doc = await coll.findOne({ _id: new ObjectId(pendingOrderId)});
+            expect(doc.amount).toBe(150);
+        });
+
+        it('should REJECT editing a document that does NOT match the permission filter', async () => {
+            // On tente de modifier la commande 'shipped', mais la permission ne l'autorise que pour 'pending'
+            const result = await editData('orderTest', { $eq: ['$_id', new ObjectId(shippedOrderId)] }, { amount: 250 }, {}, testUser, false, false);
+
+            expect(result.success).toBe(false);
+        });
+
+        // --- TESTS POUR deleteData ---
+        it('should ALLOW deleting a document that matches the permission filter', async () => {
+            // La permission autorise la suppression des commandes où `customer` est l'ID de l'utilisateur
+            const result = await deleteData('orderTest', { _id: new ObjectId(pendingOrderId) }, testUser, false, false);
+
+            expect(result.success, `deleteData failed with error: ${result.error}`).toBe(true);
+            expect(result.deletedCount).toBe(1);
+
+            const doc = await (await getCollectionForUser(testUser)).findOne({ _id: new ObjectId(pendingOrderId) });
+            expect(doc).toBeNull();
+        });
+
+        it('should REJECT deleting a document that does NOT match the permission filter', async () => {
+            // On tente de supprimer une commande qui n'appartient pas à l'utilisateur
+            const result = await deleteData('orderTest', { _id: otherUserOrderId }, testUser, false, false);
+
+            // La fonction va trouver 0 document à supprimer après application du filtre de permission
+            expect(result.success).toBe(true); // La fonction réussit, mais ne supprime rien
+            expect(result.deletedCount).toBe(0);
+
+            const doc = await (await getCollectionForUser(testSystemUser)).findOne({ _id: new ObjectId(otherUserOrderId) });
+            expect(doc).not.toBeNull(); // Le document existe toujours
+        });
+    });
 });