data-primals-engine 1.3.0 → 1.3.2

package/src/services/stripe.js

@@ -2,11 +2,38 @@ import Stripe from 'stripe';
 import {editData, insertData, searchData} from '../modules/data/index.js';
 import {getEnv} from "../modules/user.js";
 
+const stripeInstances = {};
+
+/**
+ * Retrieves a cached or creates a new Stripe client instance for a given user.
+ * This function centralizes API key retrieval and client initialization.
+ * @param {object} user - The user object.
+ * @returns {Promise<{client: Stripe, webhookSecret: string}|null>} The Stripe client and webhook secret, or null if not configured.
+ */
+async function getStripeClient(user) {
+    const userId = user._id.toString();
+    if (!stripeInstances[userId]) {
+        const env = await getEnv(user);
+        if (env.STRIPE_SECRET_KEY) {
+            stripeInstances[userId] = {
+                client: new Stripe(env.STRIPE_SECRET_KEY),
+                webhookSecret: env.STRIPE_WEBHOOK_SECRET
+            };
+        }
+    }
+    return stripeInstances[userId] || null;
+}
 
 /**
  * Crée ou récupère un client Stripe pour un utilisateur de notre système.
  */
 async function getOrCreateCustomer(user, db) {
+    const stripeInfo = await getStripeClient(user);
+    if (!stripeInfo?.client) {
+        throw new Error("Stripe is not configured for this user.");
+    }
+    const { client: stripe } = stripeInfo;
+
     // Vérifier que l'utilisateur et son email de contact sont valides
     if (!user || !user.contact || !user.contact.email) {
         // Dans un vrai scénario, il faudrait peut-être chercher l'email directement sur le modèle user
@@ -33,30 +60,50 @@ async function getOrCreateCustomer(user, db) {
     });
 
     // Enregistrer le client dans notre BDD
-    const { insertedIds } = await insertData('StripeCustomer', {
+    const newCustomerData = {
         user: user._id,
         stripeCustomerId: stripeCustomer.id,
-        email: user.email
-    }, {}, user);
+        email: user.contact.email // Utiliser l'email de contact pour la cohérence
+    };
+    const { insertedIds } = await insertData('StripeCustomer', newCustomerData, {}, user);
 
-    const newCustomer = await searchData({ model: 'StripeCustomer', filter: { _id: insertedIds[0] } });
-    return newCustomer.data[0];
+    // Pas besoin de refaire une recherche, on a déjà toutes les infos.
+    return { _id: insertedIds[0], ...newCustomerData };
 }
 /**
  * Crée une session de checkout Stripe.
  */
-export async function createCheckoutSession(priceId, user, db) {
+export async function createCheckoutSession(priceId, user, db, mode = 'subscription') {
+    const stripeInfo = await getStripeClient(user);
+    if (!stripeInfo?.client) {
+        throw new Error("Stripe is not configured for this user.");
+    }
+    const { client: stripe } = stripeInfo;
+
+    const env = await getEnv(user);
+    const appBaseUrl = env.APP_BASE_URL || 'https://your-domain.com'; // Fallback
+
     const customer = await getOrCreateCustomer(user, db);
     const session = await stripe.checkout.sessions.create({
         payment_method_types: ['card'],
-        mode: 'subscription' // ou 'payment' pour un paiement unique
+        mode: mode, // 'subscription' or 'payment'
+        customer: customer.stripeCustomerId,
+        line_items: [{ price: priceId, quantity: 1 }],
+        success_url: `${appBaseUrl}/success?session_id={CHECKOUT_SESSION_ID}`,
+        cancel_url: `${appBaseUrl}/cancel`
     });
+    return session;
 }
 
 /**
  * Vérifie le statut d'une session de checkout.
  */
-export async function verifyCheckoutSession(sessionId) {
+export async function verifyCheckoutSession(sessionId, user) {
+    const stripeInfo = await getStripeClient(user);
+    if (!stripeInfo?.client) {
+        throw new Error("Stripe is not configured for this user.");
+    }
+    const { client: stripe } = stripeInfo;
     try {
         const session = await stripe.checkout.sessions.retrieve(sessionId);
         return {
@@ -81,12 +128,13 @@ export async function verifyCheckoutSession(sessionId) {
  * @throws {Error} Si la signature est invalide ou si les en-têtes/body sont manquants.
  */
 export async function verifyWebhookSignature(headers, rawBody, user) {
-    // Initialisation de Stripe avec la clé secrète (à charger depuis une config sécurisée)
-    const env = await getEnv(user);
-    const stripe = env.STRIPE_SECRET_KEY ? new Stripe(env.STRIPE_SECRET_KEY) : null;
-    const webhookSecret = env.STRIPE_WEBHOOK_SECRET;
+    const stripeInfo = await getStripeClient(user);
 
-    if( !stripe ){
+    if (!stripeInfo) {
+        throw new Error("Stripe is not configured for this user.");
+    }
+    const { client: stripe, webhookSecret } = stripeInfo;
+    if (!stripe) {
         throw new Error("Stripe unknown API key.");
     }
     if (!webhookSecret) {
@@ -110,6 +158,12 @@ export async function verifyWebhookSignature(headers, rawBody, user) {
  * Crée un remboursement pour une commande spécifique.
  */
 export async function createRefund(returnId, db, user) {
+    const stripeInfo = await getStripeClient(user);
+    if (!stripeInfo?.client) {
+        throw new Error("Stripe is not configured for this user.");
+    }
+    const { client: stripe } = stripeInfo;
+
     const returnRequest = await db.findOne('return', { _id: returnId });
     if (!returnRequest) {
         throw new Error("Return request not found.");

package/src/workers/crypto-worker.js

@@ -46,20 +46,20 @@ parentPort.on('message', async ({ action, payload }) => {
         let result;
         switch (action) {
         case 'encrypt':
-            console.log(`[Worker] Received action: ${action} for file: ${payload.filePath}`);
+            //console.log(`[Worker] Received action: ${action} for file: ${payload.filePath}`);
             await encryptFile(payload.filePath, payload.password);
             parentPort.postMessage({ success: true }); // Pas de données à retourner
             break;
 
         case 'decrypt':
-            console.log(`[Worker] Received action: ${action} for file: ${payload.filePath}`);
+            //console.log(`[Worker] Received action: ${action} for file: ${payload.filePath}`);
             await decryptFile(payload.filePath, payload.password);
             parentPort.postMessage({ success: true }); // Pas de données à retourner
             break;
                 
 
         case 'hash':
-            console.log(`[Worker] Received action: hash`);
+            //console.log(`[Worker] Received action: hash`);
             if (!payload.data) throw new Error('Data to hash is missing in payload.');
             // Le worker gère à la fois la génération du "salt" et le hachage
             const salt = await bcrypt.genSalt(10);

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

@@ -21,6 +21,7 @@ import process from "node:process";
 import { dumpUserData, loadFromDump } from '../src/index.js';
 import fs from "node:fs";
 import {initEngine} from "../src/setenv.js";
+import {purgeData} from "../src/modules/data/data.history.js";
 
 vi.mock('../src/engine', async(importOriginal) => {
     const mod = await importOriginal() // type is inferred
@@ -78,6 +79,8 @@ beforeAll(async () => {
 
 afterAll(async () => {
 
+    await purgeData(mockUser, testModelDefinition.name);
+
     delete process.env.DB_URL;
     delete process.env.DB_NAME;
 
@@ -95,10 +98,12 @@ afterAll(async () => {
 beforeAll(async () =>{
     Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow","user", "assistant"]);
     await initEngine();
+
 })
 beforeEach(async () => {
     testModelsColInstance = getAppModelsCollection;
     testDatasColInstance = await getAppUserCollection(mockUser);
+
 });
 
 describe('Data Backup and Restore Integration', () => {

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

@@ -0,0 +1,193 @@
+// __tests__/data.history.integration.test.js
+import { ObjectId } from 'mongodb';
+import { expect, describe, it, beforeAll, afterAll, beforeEach } from 'vitest';
+import { Config } from '../src/config.js';
+import { sleep } from '../src/core.js';
+import { insertData, editData, deleteModels } 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;
+let historyCollection;
+let datasCollection;
+let modelsCollection;
+
+describe('Data History Module Integration Tests', () => {
+
+    beforeAll(async () => {
+        // IMPORTANT: Add the history module to the engine configuration for tests
+        Config.Set("modules", ["mongodb", "data", "file", "bucket", "workflow", "user", "assistant"]);
+        engine = await initEngine();
+
+        // Setup a single user for all tests in this suite
+        testUser = {
+            username: generateUniqueName('testUserHistory'),
+            userPlan: 'free',
+            email: generateUniqueName('test') + '@example.com'
+        };
+
+        // Initialize collection instances
+        historyCollection = getCollection('history');
+        datasCollection = await getCollectionForUser(testUser);
+        modelsCollection = getCollection('models');
+    });
+
+    afterAll(async () =>{
+        await purgeData(testUser);
+        await datasCollection.drop();
+    })
+
+    // Clean up collections before each test to ensure isolation
+    beforeEach(async () => {
+        await historyCollection.deleteMany({ 'user.username': testUser.username });
+        await datasCollection.deleteMany({ _user: testUser.username });
+        await modelsCollection.deleteMany({ _user: testUser.username });
+    });
+
+    afterAll(async () => {
+        // Final cleanup
+        await historyCollection.deleteMany({ 'user.username': testUser.username });
+        await datasCollection.deleteMany({ _user: testUser.username });
+        await modelsCollection.deleteMany({ _user: testUser.username });
+    });
+
+    it('should create a full snapshot history record on document creation', async () => {
+        // 1. Define and create a model with history enabled
+        const modelName = generateUniqueName('productHistory');
+        const productModelDef = {
+            name: modelName,
+            description:"",
+            _user: testUser.username,
+            history: {
+                enabled: true,
+                // For creation, all fields are snapshotted regardless of this config
+                fields: {
+                    price: true,
+                    stock: true
+                }
+            },
+            fields: [
+                { name: 'name', type: 'string', required: true },
+                { name: 'price', type: 'number' },
+                { name: 'stock', type: 'number' },
+                { name: 'description', type: 'string' }
+            ]
+        };
+        await modelsCollection.insertOne(productModelDef);
+
+        // 2. Insert a new document
+        const initialData = {
+            name: 'Super Widget',
+            price: 99.99,
+            stock: 100,
+            description: 'A very super widget.'
+        };
+        const insertResult = await insertData(modelName, initialData, {}, testUser);
+        expect(insertResult.success).toBe(true);
+        const docId = new ObjectId(insertResult.insertedIds[0]);
+
+        // 3. Verify the history record
+        const historyRecord = await historyCollection.findOne({ documentId: new ObjectId(docId) });
+
+        expect(historyRecord).not.toBeNull();
+        expect(historyRecord.documentId.toString()).toBe(docId.toString());
+        expect(historyRecord.model).toBe(modelName);
+        expect(historyRecord.version).toBe(1);
+        expect(historyRecord.operation).toBe('create');
+        expect(historyRecord.user.username).toBe(testUser.username);
+
+        // 4. Verify the snapshot
+        expect(historyRecord.snapshot).not.toBeNull();
+        expect(historyRecord.snapshot.name).toBe('Super Widget');
+        expect(historyRecord.snapshot.price).toBe(99.99);
+        expect(historyRecord.snapshot.stock).toBe(100);
+        expect(historyRecord.snapshot.description).toBe('A very super widget.');
+        expect(historyRecord.changes).toBeUndefined(); // No 'changes' field on creation
+    });
+
+    it('should create a diff history record on document update for historized fields only', async () => {
+        // 1. Define and create a model with specific history fields
+        const modelName = generateUniqueName('productHistorySelective');
+        const productModelDef = {
+            name: modelName,
+            description:"",
+            _user: testUser.username,
+            history: {
+                enabled: true,
+                fields: {
+                    price: true, // Track this
+                    stock: true  // Track this
+                    // 'description' is NOT tracked
+                }
+            },
+            fields: [
+                { name: 'name', type: 'string', required: true },
+                { name: 'price', type: 'number' },
+                { name: 'stock', type: 'number' },
+                { name: 'description', type: 'string' }
+            ]
+        };
+        await modelsCollection.insertOne(productModelDef);
+
+        // 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]);
+
+        // 3. Edit the document: change one historized field and one non-historized field
+        const updateData = { price: 55.5, description: 'Updated description.' };
+        const editResult = await editData(modelName, { _id: docId }, updateData, {}, testUser);
+        expect(editResult.success).toBe(true);
+
+        // 4. Verify the new history record (v2)
+        const historyRecord = await historyCollection.findOne({ documentId: docId, version: 2 });
+
+        expect(historyRecord).not.toBeNull();
+        expect(historyRecord.operation).toBe('update');
+        expect(historyRecord.snapshot).toBeUndefined(); // No 'snapshot' on update
+
+        // 5. Verify the 'changes' object
+        const changes = historyRecord.changes;
+        expect(changes).not.toBeNull();
+        expect(changes.price).toBeDefined();
+        expect(changes.price.from).toBe(50);
+        expect(changes.price.to).toBe(55.5);
+        expect(changes.description).toBeUndefined();
+        expect(changes.stock).toBeUndefined();
+    });
+
+    it('should NOT create a history record if only non-historized fields are updated', async () => {
+        // 1. Setup model
+        const modelName = generateUniqueName('productHistoryNoOp');
+        const productModelDef = {
+            name: modelName,
+            description:"",
+            _user: testUser.username,
+            history: { enabled: true, fields: { price: true } },
+            fields: [
+                { name: 'name', type: 'string', required: true },
+                { name: 'price', type: 'number' },
+                { name: 'description', type: 'string' }
+            ]
+        };
+        await modelsCollection.insertOne(productModelDef);
+
+        // 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]);
+
+        // 3. Edit ONLY a non-historized field
+        const updateData = { description: 'This change should not be recorded.' };
+        await editData(modelName, { _id: docId }, updateData, {}, testUser);
+
+        await sleep(2000);
+
+        // 4. Verify that NO new history record was created (only the 'create' record exists)
+        const historyCount = await historyCollection.countDocuments({ documentId: docId });
+        expect(historyCount).toBe(1);
+    });
+});