data-primals-engine 1.6.2-rc1 → 1.6.3

package/test/assistant.test.js

@@ -0,0 +1,207 @@
+// __tests__/assistant.test.js
+import { vi, expect, describe, it, beforeAll, afterAll, beforeEach } from 'vitest';
+import { Config } from '../src/config.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 { handleChatRequest } from '../src/modules/assistant/assistant.js';
+import { insertData } from '../src/index.js';
+import * as dataOperations from '../src/modules/data/data.operations.js';
+
+// --- CORRECTION ---
+// On mock le nouveau module 'providers.js' qui contient la fonction que l'on veut surcharger.
+vi.mock('../src/modules/assistant/providers.js', () => ({
+    getAIProvider: vi.fn(),
+}));
+
+// On importe la version mockée de getAIProvider
+import { getAIProvider } from '../src/modules/assistant/providers.js';
+
+let testUser;
+let modelsCollection;
+let datasCollection;
+
+const modelName = generateUniqueName('productAssistant');
+
+describe('Assistant Module Unit Tests', () => {
+
+    beforeAll(async () => {
+        Config.Set("modules", ["mongodb", "data", "user", "assistant"]);
+        await initEngine(); // Cette ligne ne devrait plus planter.
+        testUser = {
+            username: generateUniqueName('testUserAssistant'),
+            email: generateUniqueName('test') + '@example.com',
+            lang: 'fr'
+        };
+
+        modelsCollection = getCollection('models');
+        datasCollection = await getCollectionForUser(testUser);
+
+        // Create a model for testing
+        const productModelDef = {
+            name: modelName,
+            description: 'A model for testing',
+            _user: testUser.username,
+            fields: [
+                { name: 'name', type: 'string', required: true },
+                { name: 'price', type: 'number' }
+            ]
+        };
+        await modelsCollection.insertOne(productModelDef);
+    });
+
+    beforeEach(async () => {
+        // Clear mocks before each test
+        vi.clearAllMocks();
+        // Clean data, but keep the model
+        await datasCollection.deleteMany({ _user: testUser.username });
+    });
+
+    // Helper to create a mock LLM stream
+    const createMockStream = (content) => {
+        return (async function* () {
+            yield { content };
+        })();
+    };
+
+    it('should return a simple text message from the AI', async () => {
+        const mockLLM = {
+            stream: vi.fn().mockReturnValue(createMockStream('Bonjour, ceci est un test.')),
+        };
+        getAIProvider.mockResolvedValue(mockLLM);
+
+        const params = { message: 'Dis bonjour', history: [] };
+        const result = await handleChatRequest(params, testUser);
+
+        expect(getAIProvider).toHaveBeenCalled();
+        expect(mockLLM.stream).toHaveBeenCalled();
+        expect(result).toEqual({
+            success: true,
+            displayMessage: 'Bonjour, ceci est un test.'
+        });
+    });
+
+    it('should handle a search action', async () => {
+
+        // Configure le retour du mock pour ce test spécifique
+        const searchDataSpy = vi.spyOn(dataOperations, 'searchData').mockResolvedValue({ data: [{ name: 'Test Widget', price: 100 }], count: 1 });
+
+        const aiResponse = JSON.stringify([
+            { action: 'search_models', params: { query: modelName } },
+            { action: 'search', params: { model: modelName, filter: {} } }
+        ]);
+        const mockLLM = {
+            stream: vi.fn().mockReturnValue(createMockStream(aiResponse))
+        };
+        getAIProvider.mockResolvedValue(mockLLM);
+
+        const params = { message: `cherche les produits`, history: [] };
+        const result = await handleChatRequest(params, testUser);
+
+        expect(searchDataSpy).toHaveBeenCalled();
+
+        expect(result.success).toBe(true);
+        expect(result.dataResult).toBeDefined();
+        expect(result.dataResult.model).toBe(modelName);
+        expect(result.dataResult.data).toHaveLength(1);
+        expect(result.dataResult.data[0].name).toBe('Test Widget');
+    });
+
+    it('should request confirmation for a "post" action', async () => {
+        const aiResponse = JSON.stringify({
+            action: 'post',
+            params: {
+                model: modelName,
+                data: { name: 'New Gadget', price: 19.99 }
+            }
+        });
+        const mockLLM = {
+            stream: vi.fn().mockReturnValue(createMockStream(aiResponse)),
+        };
+        getAIProvider.mockResolvedValue(mockLLM);
+
+        const params = { message: 'Crée un produit', history: [] };
+        const result = await handleChatRequest(params, testUser);
+
+        expect(result.success).toBe(true);
+        expect(result.confirmationRequest).toBeDefined();
+        expect(result.confirmationRequest.action).toBe('post');
+        expect(result.confirmationRequest.params.model).toBe(modelName);
+        expect(result.confirmationRequest.params.data.name).toBe('New Gadget');
+    });
+
+    it('should execute a confirmed "post" action', async () => {
+        const confirmedAction = {
+            action: 'post',
+            params: {
+                model: modelName,
+                data: { name: 'Confirmed Gadget', price: 50 }
+            }
+        };
+
+        const params = { message: '', confirmedAction };
+        const result = await handleChatRequest(params, testUser);
+
+        expect(result.success).toBe(true);
+        // --- CORRECTION ---
+        // On vérifie le message de succès spécifique à la création, qui est plus informatif.
+        expect(result.displayMessage).toContain("Élément créé avec l'ID:");
+
+        // Verify the data was actually inserted
+        const dataInDb = await datasCollection.findOne({ name: 'Confirmed Gadget' });
+        expect(dataInDb).not.toBeNull();
+        expect(dataInDb.price).toBe(50);
+    });
+
+    it('should handle malformed JSON from AI by returning it as a text message', async () => {
+        const aiResponse = `{ "action": "search", "params": { "model": "${modelName}" }`; // Missing closing brace
+        const mockLLM = {
+            stream: vi.fn().mockReturnValue(createMockStream(aiResponse)),
+        };
+        getAIProvider.mockResolvedValue(mockLLM);
+
+        const params = { message: 'test', history: [] };
+        const result = await handleChatRequest(params, testUser);
+
+        expect(result.success).toBe(true);
+        expect(result.displayMessage).toBe(aiResponse);
+    });
+
+    it('should correct a malformed filter from the AI', async () => {
+        const aiResponse = JSON.stringify({
+            action: 'search',
+            params: {
+                model: modelName,
+                // This filter is malformed: multiple operators at the root level
+                filter: {
+                    "$gt": ["$price", 50],
+                    "$lt": ["$price", 200]
+                }
+            }
+        });
+        const mockLLM = {
+            stream: vi.fn().mockReturnValue(createMockStream(aiResponse)),
+        };
+        getAIProvider.mockResolvedValue(mockLLM);
+
+        // Configure le retour du mock pour ce test spécifique
+        const searchDataSpy = vi.spyOn(dataOperations, 'searchData').mockResolvedValue({ data: [], count: 0 });
+
+        const params = { message: 'cherche produits entre 50 et 200', history: [] };
+        // On peut maintenant utiliser la fonction handleChatRequest importée normalement
+        await handleChatRequest(params, testUser);
+
+        // On s'attend à ce que le filtre ait été encapsulé dans un $and
+        const expectedFilter = {
+            "$and": [
+                { "$gt": ["$price", 50] },
+                { "$lt": ["$price", 200] }
+            ]
+        };
+
+        expect(searchDataSpy).toHaveBeenCalledWith(expect.objectContaining({ filter: expectedFilter }), expect.anything());
+
+        // On nettoie l'espion après le test
+        searchDataSpy.mockRestore();
+    });
+});

package/test/config.test.js

@@ -0,0 +1,41 @@
+// __tests__/config.test.js
+import { describe, it, expect, beforeAll } from 'vitest';
+import { Config } from '../src/config.js';
+import { initEngine } from '../src/setenv.js';
+
+describe('Configuration Module Tests', () => {
+
+    it('should correctly get and set a simple value', () => {
+        const key = 'testKey';
+        const value = 'testValue';
+
+        Config.Set(key, value);
+        const retrievedValue = Config.Get(key);
+
+        expect(retrievedValue).toBe(value);
+    });
+
+    it('should return the default value if a key is not set', () => {
+        const defaultValue = 'default';
+        const retrievedValue = Config.Get('nonExistentKey', defaultValue);
+
+        expect(retrievedValue).toBe(defaultValue);
+    });
+
+    it('should initialize the engine with only the modules specified in the config', async () => {
+        // 1. Définir une configuration de modules minimale.
+        const targetModules = ['mongodb', 'user'];
+        Config.Set("modules", targetModules);
+
+        // 2. Initialiser le moteur. initEngine devrait lire cette configuration.
+        const engine = await initEngine();
+
+        // 3. Vérifier que le moteur a chargé UNIQUEMENT les modules spécifiés.
+        // La propriété _modules de l'engine contient les instances des modules chargés.
+        const loadedModuleNames = engine._modules.map(m => m.module);
+
+        expect(engine._modules).toBeInstanceOf(Array);
+        expect(loadedModuleNames).toHaveLength(targetModules.length);
+        expect(loadedModuleNames).toEqual(expect.arrayContaining(targetModules));
+    });
+});

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

@@ -1,10 +1,10 @@
 // __tests__/data.history.integration.test.js
 import { ObjectId } from 'mongodb';
 import { expect, describe, it, beforeAll, afterAll, beforeEach } from 'vitest';
-import { handleGetHistoryRequest } from '../src/modules/data/data.history.js';
+import { handleGetHistoryRequest, handleGetRevisionRequest, handleRevertToRevisionRequest } from '../src/modules/data/data.history.js';
 import { Config } from '../src/config.js';
 import { sleep } from '../src/core.js';
-import { insertData, editData, deleteModels } from '../src/index.js';
+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";
@@ -16,6 +16,20 @@ let historyCollection;
 let datasCollection;
 let modelsCollection;
 
+// Mock Express req/res objects for testing API handlers
+const mockReq = (params = {}, query = {}, body = {}, user = testUser) => ({
+    params,
+    query,
+    body,
+    me: user
+});
+const mockRes = () => {
+    const res = {};
+    res.status = (code) => { res.statusCode = code; return res; };
+    res.json = (data) => { res.body = data; return res; };
+    return res;
+};
+
 describe('Data History Module Integration Tests', () => {
 
     beforeAll(async () => {
@@ -88,7 +102,7 @@ describe('Data History Module Integration Tests', () => {
         };
         const insertResult = await insertData(modelName, initialData, {}, testUser);
         expect(insertResult.success).toBe(true);
-        const docId = new ObjectId(insertResult.insertedIds[0]);
+        const docId = new ObjectId(insertResult.data._id);
 
         // 3. Verify the history record
         const historyRecord = await historyCollection.findOne({ documentId: new ObjectId(docId) });
@@ -136,7 +150,7 @@ describe('Data History Module Integration Tests', () => {
         // 2. Insert the initial document
         const initialData = { name: 'Selective Widget', price: 50, stock: 200, description: 'Initial description.' };
         const insertResult = await insertData(modelName, initialData, {}, testUser);
-        const docId = new ObjectId(insertResult.insertedIds[0]);
+        const docId = new ObjectId(insertResult.data._id);
 
         // 3. Edit the document: change one historized field and one non-historized field
         const updateData = { price: 55.5, description: 'Updated description.' };
@@ -179,7 +193,7 @@ describe('Data History Module Integration Tests', () => {
         // 2. Insert initial document
         const initialData = { name: 'No-Op Widget', price: 10, description: 'Initial.' };
         const insertResult = await insertData(modelName, initialData, {}, testUser);
-        const docId = new ObjectId(insertResult.insertedIds[0]);
+        const docId = new ObjectId(insertResult.data._id);
 
         // 3. Edit ONLY a non-historized field
         const updateData = { description: 'This change should not be recorded.' };
@@ -192,6 +206,126 @@ describe('Data History Module Integration Tests', () => {
         expect(historyCount).toBe(1);
     });
 
+    it('should create a snapshot history record on document deletion', async () => {
+        // 1. Setup model
+        const modelName = generateUniqueName('productHistoryDelete');
+        const productModelDef = {
+            name: modelName,
+            description:'',
+            _user: testUser.username,
+            history: { enabled: true },
+            fields: [{ name: 'name', type: 'string' }]
+        };
+        await modelsCollection.insertOne(productModelDef);
+
+        // 2. Insert a document
+        const insertResult = await insertData(modelName, { name: 'Document to be deleted' }, {}, testUser);
+        const docId = new ObjectId(insertResult.data._id);
+
+        // 3. Delete the document
+        await deleteData(modelName, [docId.toString()], testUser);
+
+        // 4. Verify the new history record (v2)
+        const historyRecord = await historyCollection.findOne({ documentId: docId, version: 2 });
+
+        expect(historyRecord).not.toBeNull();
+        expect(historyRecord.operation).toBe('delete');
+        expect(historyRecord.snapshot).not.toBeNull();
+        expect(historyRecord.snapshot.name).toBe('Document to be deleted');
+        expect(historyRecord.changes).toBeUndefined();
+    });
+
+    it('should correctly reconstruct a document at a specific version', async () => {
+        // 1. Setup model
+        const modelName = generateUniqueName('productHistoryReconstruct');
+        const productModelDef = {
+            name: modelName,
+            _user: testUser.username,
+            description:'',
+            history: { enabled: true },
+            fields: [
+                { name: 'name', type: 'string' },
+                { name: 'status', type: 'string' },
+                { name: 'count', type: 'number' }
+            ]
+        };
+        await modelsCollection.insertOne(productModelDef);
+
+        // 2. Create and update document to generate history
+        const insertResult = await insertData(modelName, { name: 'Reconstruct', status: 'initial', count: 0 }, {}, testUser); // v1
+        const docId = new ObjectId(insertResult.data._id);
+
+        await editData(modelName, { _id: docId }, { status: 'updated' }, {}, testUser); // v2
+        await editData(modelName, { _id: docId }, { count: 10 }, {}, testUser); // v3
+
+        // 3. Test reconstruction at each version via the API handler
+        // Version 1 (creation)
+        let req = mockReq({ modelName, recordId: docId.toString(), version: '1' });
+        let res = mockRes();
+        await handleGetRevisionRequest(req, res);
+        expect(res.body.success).toBe(true);
+        expect(res.body.data.name).toBe('Reconstruct');
+        expect(res.body.data.status).toBe('initial');
+        expect(res.body.data.count).toBe(0);
+
+        // Version 2 (status updated)
+        req = mockReq({ modelName, recordId: docId.toString(), version: '2' });
+        res = mockRes();
+        await handleGetRevisionRequest(req, res);
+        expect(res.body.success).toBe(true);
+        expect(res.body.data.status).toBe('updated');
+        expect(res.body.data.count).toBe(0); // count is still 0
+
+        // Version 3 (count updated)
+        req = mockReq({ modelName, recordId: docId.toString(), version: '3' });
+        res = mockRes();
+        await handleGetRevisionRequest(req, res);
+        expect(res.body.success).toBe(true);
+        expect(res.body.data.status).toBe('updated');
+        expect(res.body.data.count).toBe(10);
+    });
+
+    it('should revert a document to a previous version and create a new history entry', async () => {
+        // 1. Setup model
+        const modelName = generateUniqueName('productHistoryRevert');
+        const productModelDef = {
+            name: modelName,
+            _user: testUser.username,
+            description:'',
+            history: { enabled: true },
+            fields: [{ name: 'name', type: 'string' }, { name: 'status', type: 'string' }]
+        };
+        await modelsCollection.insertOne(productModelDef);
+
+        // 2. Create and update document
+        const insertResult = await insertData(modelName, { name: 'Revert Test', status: 'v1' }, {}, testUser); // v1
+        const docId = new ObjectId(insertResult.data._id);
+        await editData(modelName, { _id: docId }, { status: 'v2' }, {}, testUser); // v2
+
+        // 3. Revert the document to version 1
+        const req = mockReq({ modelName, recordId: docId.toString(), version: '1' });
+        const res = mockRes();
+        await handleRevertToRevisionRequest(req, res);
+
+        expect(res.body.success).toBe(true);
+        expect(res.body.message).toBe("Document successfully reverted.");
+
+        // 4. Verify the current state of the document
+        const revertedDoc = await datasCollection.findOne({ _id: docId });
+        expect(revertedDoc.status).toBe('v1');
+
+        // 5. Verify that a new history entry (v3) was created for the revert action
+        const historyRecords = await historyCollection.find({ documentId: docId }).sort({ version: 1 }).toArray();
+        expect(historyRecords).toHaveLength(3);
+
+        const revertHistoryEntry = historyRecords[2]; // v3
+        expect(revertHistoryEntry.version).toBe(3);
+        expect(revertHistoryEntry.operation).toBe('update'); // A revert is an update
+        expect(revertHistoryEntry.changes).not.toBeNull();
+        expect(revertHistoryEntry.changes.status.from).toBe('v2');
+        expect(revertHistoryEntry.changes.status.to).toBe('v1');
+    });
+
     it('should filter history records by date range', async () => {
         // 1. Setup model
         const modelName = generateUniqueName('productHistoryDateFilter');
@@ -206,7 +340,7 @@ describe('Data History Module Integration Tests', () => {
 
         // 2. Insert initial document
         const insertResult = await insertData(modelName, { name: 'Time-traveling Widget' }, {}, testUser);
-        const docId = new ObjectId(insertResult.insertedIds[0]);
+        const docId = new ObjectId(insertResult.data._id);
 
         // 3. Create history entries at different times
         // To simulate different timestamps, we'll manually insert history records
@@ -227,21 +361,11 @@ describe('Data History Module Integration Tests', () => {
         });
 
         // Mock Express req/res objects
-        const mockReq = (query) => ({
-            params: { modelName, recordId: docId.toString() },
-            query,
-            me: testUser
-        });
-        const mockRes = () => {
-            const res = {};
-            res.status = (code) => { res.statusCode = code; return res; };
-            res.json = (data) => { res.body = data; return res; };
-            return res;
-        };
+        // Using the global mockReq and mockRes helpers now
 
         // 4. Test cases
         // Case A: Filter for February
-        let req = mockReq({ startDate: '2023-02-01', endDate: '2023-02-28' });
+        let req = mockReq({ modelName, recordId: docId.toString() }, { startDate: '2023-02-01', endDate: '2023-02-28' });
         let res = mockRes();
         await handleGetHistoryRequest(req, res);
         expect(res.body.success).toBe(true);
@@ -249,14 +373,14 @@ describe('Data History Module Integration Tests', () => {
         expect(res.body.data.map(d => d._v).sort()).toEqual([2, 3]);
 
         // Case B: Filter starting from Feb 15th
-        req = mockReq({ startDate: '2023-02-15' });
+        req = mockReq({ modelName, recordId: docId.toString() }, { startDate: '2023-02-15' });
         res = mockRes();
         await handleGetHistoryRequest(req, res);
         expect(res.body.success).toBe(true);
         expect(res.body.count).toBe(3); // v2, v3, v4
 
         // Case C: Filter up to Feb 15th (inclusive)
-        req = mockReq({ endDate: '2023-02-15' });
+        req = mockReq({ modelName, recordId: docId.toString() }, { endDate: '2023-02-15' });
         res = mockRes();
         await handleGetHistoryRequest(req, res);
         expect(res.body.success).toBe(true);