data-primals-engine 1.2.6 → 1.3.1

package/src/services/index.js

@@ -0,0 +1,11 @@
+import * as stripeService from './stripe.js';
+// Importez d'autres services ici à l'avenir
+// import * as anotherService from './anotherService.js';
+
+/**
+ * Registre central de tous les services exposés au moteur de workflow.
+ */
+export const services = {
+    stripe: stripeService,
+    // anotherService: anotherService,
+};

package/src/services/stripe.js

@@ -0,0 +1,195 @@
+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
+        const userRecord = await db.findOne('user', {_id: user._id});
+        if(!userRecord || !userRecord.contact || !userRecord.contact.email) {
+            throw new Error("User or user contact email is missing.");
+        }
+        user = userRecord;
+    }
+
+    const existingCustomer = await db.findOne('StripeCustomer', { user: user._id });
+
+    if (existingCustomer) {
+        return existingCustomer;
+    }
+
+    // Créer le client sur Stripe
+    const stripeCustomer = await stripe.customers.create({
+        email: user.contact.email,
+        name: user.username,
+        metadata: {
+            userId: user._id.toString() // Lien vers notre système
+        }
+    });
+
+    // Enregistrer le client dans notre BDD
+    const newCustomerData = {
+        user: user._id,
+        stripeCustomerId: stripeCustomer.id,
+        email: user.contact.email // Utiliser l'email de contact pour la cohérence
+    };
+    const { insertedIds } = await insertData('StripeCustomer', newCustomerData, {}, user);
+
+    // 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, 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: 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, 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 {
+            status: session.status,
+            payment_status: session.payment_status,
+            customer: session.customer,
+            subscription: session.subscription
+        };
+    } catch (error) {
+        console.error("Error verifying checkout session:", error);
+        throw new Error("Could not verify checkout session.");
+    }
+}
+
+/**
+ * Vérifie la signature d'un webhook Stripe pour s'assurer qu'il est authentique.
+ * C'est une étape de sécurité cruciale.
+ *
+ * @param {object} headers - Les en-têtes de la requête (notamment 'stripe-signature').
+ * @param {string} rawBody - Le corps brut de la requête.
+ * @returns {Stripe.Event} L'objet événement Stripe vérifié.
+ * @throws {Error} Si la signature est invalide ou si les en-têtes/body sont manquants.
+ */
+export async function verifyWebhookSignature(headers, rawBody, user) {
+    const stripeInfo = await getStripeClient(user);
+
+    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) {
+        throw new Error("Stripe webhook secret (STRIPE_WEBHOOK_SECRET) is not configured on the server.");
+    }
+
+    const signature = headers['stripe-signature'];
+    if (!signature) {
+        throw new Error("Missing 'stripe-signature' header.");
+    }
+
+    try {
+        return stripe.webhooks.constructEvent(rawBody, signature, webhookSecret);
+    } catch (err) {
+        console.error(`❌ Error verifying Stripe webhook signature: ${err.message}`);
+        throw new Error(`Webhook signature verification failed: ${err.message}`);
+    }
+}
+
+/**
+ * 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.");
+    }
+
+    // Trouver la commande et le paiement associés
+    const order = await db.findOne('order', { _id: returnRequest.order });
+    if (!order || !order.paymentIntentId) {
+        throw new Error("Associated order or its paymentIntentId not found.");
+    }
+
+    const refund = await stripe.refunds.create({
+        payment_intent: order.paymentIntentId,
+        amount: Math.round(returnRequest.amount * 100), // Stripe attend le montant en centimes
+        reason: 'requested_by_customer',
+        metadata: {
+            returnId: returnId.toString(),
+            orderId: order.orderId
+        }
+    });
+
+    // Mettre à jour le statut de la demande de retour dans notre BDD
+    await editData('return', { _id: returnId }, {
+        status: 'refunded',
+        refundDate: new Date()
+    }, {}, user);
+
+    return { refundId: refund.id, status: refund.status };
+}

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);
+    });
+});