data-primals-engine 1.0.0

package/src/modules/file.js

@@ -0,0 +1,192 @@
+
+// Nouvelle fonction pour ajouter un fichier privé
+import {maxPrivateFileSize, megabytes} from "../constants.js";
+import {isLocalUser} from "../data.js";
+import i18n from "../../../data-primals-engine/src/i18n.js";
+import {getUserStorageLimit} from "../user.js";
+import {getCollection} from "./mongodb.js";
+import {getFileExtension, isGUID, uuidv4} from "../core.js";
+import path from "node:path";
+import process from "node:process";
+import fs from "node:fs";
+import { checkServerCapacity} from "./data.js";
+import crypto from "node:crypto";
+import * as tar from "tar";
+import {promisify} from "node:util";
+import {calculateTotalUserStorageUsage, hasPermission} from "./user.js";
+
+const pbkdf2Async = promisify(crypto.pbkdf2);
+
+const fsPromises = fs.promises;
+
+// Encryption settings
+const algorithm = 'aes-256-cbc'; // Algorithm to use
+const iterations = 100000; // Number of iterations for PBKDF2
+const keyLength = 32; // Key length for AES-256
+const ivLength = 16; // IV length for AES
+
+// Function to derive a key and IV from a passphrase and salt
+async function deriveKeyAndIV(password, salt) {
+    const key = await pbkdf2Async(password, salt, iterations, keyLength, 'sha256');
+    // L'IV n'est plus dérivé ici.
+    return { key };
+}
+
+
+export const unzip = async (file) => {
+    await tar.extract({ file: file, gzip: true, sync: true });
+}
+
+export const zip = async (filename) => {
+    await tar.create({ gzip: true, sync: true, file: filename+'.gz' }, [filename])
+}
+export const addFile = async (file, user) => {
+    if (!file) throw new Error("Le fichier est requis");
+
+    if (file.size > maxPrivateFileSize) {
+        throw new Error(`La taille du fichier dépasse la limite autorisée (${maxPrivateFileSize / megabytes} Mo).`);
+    }
+
+    if (user.username !== 'demo' && isLocalUser(user) && !await hasPermission(["API_ADMIN", "API_UPLOAD_FILE"], user)) {
+        throw new Error(i18n.t("api.permission.uploadFile"));
+    }
+
+    const incomingDataSize = file.size;
+
+    const userStorageLimit = getUserStorageLimit(user);
+    const currentStorageUsage = await calculateTotalUserStorageUsage(user);
+
+    if (currentStorageUsage + incomingDataSize > userStorageLimit) {
+        throw new Error(i18n.t("api.data.storageLimitExceeded", { limit: Math.round(userStorageLimit / megabytes) }));
+    }
+
+    const serverCapacity = await checkServerCapacity(incomingDataSize);
+    if (!serverCapacity.isSufficient) {
+        throw new Error(i18n.t("api.data.serverStorageFull", "Le serveur a atteint sa capacité de stockage maximale. Veuillez réessayer plus tard."));
+    }
+
+    const collection = getCollection("files");
+
+    // Générer un GUID pour le fichier
+    const guid = uuidv4();
+    const filename = guid + path.extname(file.originalname || file.name); // Préserver l'extension
+    const filepath = path.join(process.cwd(), 'uploads', 'private', filename);
+
+    try {
+        // Enregistrer le fichier sur le serveur
+        await fsPromises.mkdir(path.join(process.cwd(), 'uploads', 'private'), {recursive: true});
+        await fsPromises.writeFile(filepath, file.buffer || fs.readFileSync(file.path)); // Utiliser buffer si disponible
+        if( file.path && fs.existsSync(file.path) ){
+            fs.unlinkSync(file.path);
+        }
+
+        // Enregistrer les métadonnées du fichier
+        const fileMetadata = {
+            guid,
+            filename: file.originalname || file.name, // Conserver le nom original
+            mimeType: file.type,
+            size: file.size,
+            mainUser: user._user,
+            user: user.username,
+            timestamp: new Date()
+        };
+
+        // Insérer le fichier dans une collection dédiée (par exemple, "privateFiles")
+        const result = await collection.insertOne({...fileMetadata, _model: "privateFile"});
+        if (!result.insertedId) throw new Error("Échec de l'indexation du fichier.");
+
+        return guid;
+
+    } catch (error) {
+        // Nettoyage en cas d'erreur
+        if (fs.existsSync(filepath)) {
+            fs.unlinkSync(filepath);
+        }
+        throw new Error(`Erreur lors de l'ajout du fichier: ${error.message}`);
+    }
+};
+
+export const removeFile = async (guid, user) => {
+    if (!guid) return false;
+    if (!isGUID(guid)) throw new Error("Le GUID du fichier n'est pas valide.");
+
+    const collection = getCollection("files");
+
+    // Trouver le fichier et vérifier l'autorisation (propriétaire ou admin)
+    const file = await collection.findOne({ guid });
+    if (!file) throw new Error("Fichier non trouvé (" + guid + ")");
+
+    if (user.username !== 'demo' && isLocalUser(user) && !await hasPermission(["API_ADMIN", "API_EDIT_DATA", "API_EDIT_DATA_privateFile", `API_EDIT_DATA_privateFile_${guid}`], user) ) {
+        if (file._user !== (user._user || user.username)) {
+            throw new Error("Vous n'êtes pas autorisé à supprimer ce fichier.");
+        }
+    }
+
+    try {
+        // Supprimer le fichier de la base de données
+        const deleteResult = await collection.deleteOne({ _model: "privateFile", guid });
+        if (deleteResult.deletedCount !== 1) throw new Error("Échec de la suppression de l'indexation du fichier.");
+
+        // Supprimer le fichier du serveur
+        const filepath = path.join(process.cwd(), 'uploads', 'private', guid)+'.'+getFileExtension(file.filename);
+        if (fs.existsSync(filepath)) {
+            fs.unlinkSync(filepath);
+        }
+
+        return { success: true, message: "Fichier supprimé avec succès." };
+    } catch (error) {
+        throw new Error(`Erreur lors de la suppression du fichier: ${error.message}`);
+    }
+};
+
+
+
+
+// Function to encrypt the file content
+export async function encryptFile(filePath, password) {
+    try {
+        const salt = crypto.randomBytes(16);
+        const iv = crypto.randomBytes(ivLength);
+
+        // On ne dérive que la clé
+        const { key } = await deriveKeyAndIV(password, salt);
+
+        const fileData = await fs.promises.readFile(filePath);
+        const cipher = crypto.createCipheriv(algorithm, key, iv);
+        const encryptedData = Buffer.concat([cipher.update(fileData), cipher.final()]);
+
+        // On it : [salt][iv][données chiffrées]
+        await fs.promises.writeFile(filePath, Buffer.concat([salt, iv, encryptedData]));
+
+        console.log('File encrypted successfully.', filePath);
+    } catch (error) {
+        console.error('Error during encryption:', error.message);
+    }
+}
+// Function to decrypt the file content
+export async function decryptFile(filePath, password) {
+    try {
+        const fileData = await fs.promises.readFile(filePath);
+
+        // Extraire le sel, l'IV et les données
+        const salt = fileData.slice(0, 16);
+        // NOUVEAU: Extraire l'IV qui suit le sel
+        const iv = fileData.slice(16, 16 + ivLength);
+        const encryptedData = fileData.slice(16 + ivLength);
+
+        // On dérive la même clé en utilisant le sel extrait
+        const { key } = await deriveKeyAndIV(password, salt);
+
+        // On utilise l'IV extrait pour le déchiffrement
+        const decipher = crypto.createDecipheriv(algorithm, key, iv);
+        const decryptedData = Buffer.concat([decipher.update(encryptedData), decipher.final()]);
+
+        await fs.promises.writeFile(filePath, decryptedData);
+
+        console.log('File decrypted successfully.');
+    } catch (error) {
+        console.error('Error during decryption:', error.message);
+        // Relancer l'erreur peut être utile pour que l'appelant sache que ça a échoué
+        throw new Error(`Decryption failed: ${error.message}`);
+    }
+}

package/src/modules/mongodb.js

@@ -0,0 +1,67 @@
+
+import process from "process";
+import {MongoClient as InternalMongoClient} from "mongodb";
+import {Logger} from "../gameObject.js";
+import {MongoDatabase} from "../engine.js";
+import * as tls from "node:tls";
+import fs from "node:fs";
+
+export let modelsCollection, datasCollection, filesCollection, packsCollection;
+
+let engine, logger;
+export async function onInit(defaultEngine) {
+    engine = defaultEngine;
+    logger = engine.getComponent(Logger);
+
+    const isProduction = process.env.NODE_ENV === 'production'
+
+    let ca, cert, key;
+    try {
+        ca = fs.readFileSync('certs/mongodb-cert.crt');
+        cert = fs.readFileSync('certs/mongodb.pem');
+        key = fs.readFileSync(`certs/mongodb-cert.key`);
+    } catch (e) {
+
+    }
+    // Create a SecureContext object
+    // Connection URL
+    const dbUrl = process.env.MONGO_DB_URL || 'mongodb://localhost:27017';
+    const MongoClient = new InternalMongoClient(dbUrl, {
+        tls: false, maxPoolSize: 20
+    });
+    await MongoClient.connect();
+
+    modelsCollection = MongoDatabase.collection("models");
+    datasCollection = MongoDatabase.collection("datas");
+    filesCollection = MongoDatabase.collection("files");
+    packsCollection = MongoDatabase.collection("packs");
+
+    logger.info("MongoDB collections loaded.");
+
+};
+
+
+export const isObjectId = (id) => {
+    return (typeof(id) === 'string' && id.match(/^[0-9a-fA-F]{24}$/));
+};
+
+
+export const getCollection = (str) => {
+    return MongoDatabase.collection(str);
+}
+
+
+
+// New function to determine the collection name for a user
+export const getUserCollectionName = (user) => {
+    return user?.userPlan === 'premium' ? `datas_${user.username}` : 'datas';
+};
+
+
+// Modify existing functions to use the correct collection
+export const getCollectionForUser = (user) => {
+    const collectionName = getUserCollectionName(user);
+    return getCollection(collectionName);
+};
+
+

package/src/modules/swagger.js

@@ -0,0 +1,18 @@
+
+import swaggerUi from 'swagger-ui-express';
+
+import YAML from 'yaml';
+
+import {Logger} from "../gameObject.js";
+import fs from "node:fs";
+let engine, logger;
+
+export async function onInit(defaultEngine) {
+    engine = defaultEngine;
+    logger = engine.getComponent(Logger);
+
+    const swaggerDocument = YAML.parse(fs.readFileSync(process.cwd() + '/swagger-en.yml', 'utf8'));
+
+    engine.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument));
+
+};

package/src/modules/user.js

@@ -0,0 +1,226 @@
+import i18n from "../../../data-primals-engine/src/i18n.js";
+import {MongoClient, MongoDatabase} from "../engine.js";
+import {getCollection, getCollectionForUser, getUserCollectionName} from "./mongodb.js";
+import {dbName, plans} from "../constants.js";
+import {isLocalUser} from "../data.js";
+import {ObjectId} from "mongodb";
+import {getAPILang} from "./data.js";
+import {Logger} from "../gameObject.js";
+import rateLimit from "express-rate-limit";
+
+export const userInitiator = async (req, res, next) => {
+
+    const lang = getAPILang(req.query.lang || req.headers['Accept-Language']);
+
+    req.lang = lang;
+    if(req.me)
+        req.me.lang = lang;
+    res.setHeader('Content-Language', lang);
+
+    // set current lang for user
+    i18n.changeLanguage(lang);
+
+    if (req.me.userPlan === 'premium') {
+        const collections = await MongoDatabase.listCollections().toArray();
+        const collectionNames = collections.map(c => c.name);
+        const coll = getUserCollectionName(req.me);
+        if (collectionNames.includes(coll)) {
+            const collection = await MongoDatabase.createCollection(coll);
+            const indexes = await collection.indexes();
+            if (!indexes.find(i => i.name === 'genericPartialIndex')) {
+                await collection.createIndex({"$**": 1}, {
+                    name: 'genericPartialIndex',
+                    partialFilterExpression: {
+                        _model: 1,
+                        _user: 1
+                    }
+                });
+            }
+            if (!await collection.indexExists("_hash")) {
+                await collection.createIndex({_hash: 1});
+            }
+            if (!indexes.find(i => i.name === 'modelUserIndex')) {
+                await collection.createIndex({_model: 1, _user: 1}, {name: 'modelUserIndex'});
+            }
+        }
+    }
+    next();
+}
+
+
+export const middlewareAuthenticator = async (req, res, next) => {
+    const engine = req.app.get('engine');
+    if (!engine || !engine.userProvider) {
+        // Sécurité pour s'assurer que le moteur est bien configuré
+        return res.status(500).json({ error: "UserProvider not configured in engine." });
+    }
+
+    try {
+        // 1. On demande au provider (votre PrimalsUserProvider) d'identifier l'utilisateur
+        await engine.userProvider.initiateUser(req);
+
+        // 2. On vérifie simplement si le provider a attaché un utilisateur
+        if (req.me) {
+            // L'utilisateur est authentifié, on continue
+            return next();
+        } else {
+            // Le provider n'a trouvé aucun utilisateur valide
+            return res.status(401).json({ error: "Authentication required" });
+        }
+    } catch (e) {
+        // Le provider peut lever une erreur (ex: token invalide, compte non vérifié)
+        return res.status(401).json({ error: e.message || "Authentication failed" });
+    }
+};
+
+export const generateLimiter = rateLimit({
+    windowMs: 7000,
+    limit: 1,
+    standardHeaders: true,
+    legacyHeaders: false,
+    skip: (req) => {
+        return !!req.body?.confirmedAction;
+    }
+});
+
+const freeSearchLimiter = rateLimit({
+    windowMs: 1000 * 3600,
+    limit: plans.free.requestLimitPerHour,
+    standardHeaders: true,
+    legacyHeaders: false,
+});
+const premiumSearchLimiter = rateLimit({
+    windowMs: 1000 * 3600,
+    limit: plans.premium.requestLimitPerHour,
+    standardHeaders: true,
+    legacyHeaders: false,
+});
+
+export const myFreePremiumAnonymousLimiter = async function (req, res, next) {
+    const user = req.me;
+    if (user?.userPlan === "premium") {
+        return premiumSearchLimiter(req, res, next);
+    }
+    return freeSearchLimiter(req, res, next);
+};
+
+let logger,engine;
+export async function onInit(defaultEngine) {
+    engine = defaultEngine;
+    logger = engine.getComponent(Logger);
+
+
+}
+
+export async function hasPermission(permissionNames, user) {
+    if( !isLocalUser(user)){
+        return user.roles?.some(f => permissionNames.includes(f));
+    }
+    try {
+        // Si on a une string on le transforme en tableau.
+        const permissionNamesArray = Array.isArray(permissionNames) ? permissionNames : [permissionNames];
+        const collection = getCollectionForUser(user);
+
+        const job = [
+            {
+                $lookup: {
+                    from: 'datas',
+                    let: { rolesIds: (user.roles ||[]).map(m => new ObjectId(m)) },
+                    pipeline: [
+                        {
+                            $match: {
+                                $expr: {
+                                    $and: [
+                                        { $in: ['$_id', '$$rolesIds'] },
+                                    ],
+                                },
+                            },
+                        },
+                        {
+                            $lookup: {
+                                from: 'datas',
+                                let: { rolePermissions: {
+                                        "$map": {
+                                            "input": "$permissions",
+                                            "in": { "$toObjectId": "$$this" }
+                                        }
+                                    } },
+                                pipeline: [
+                                    {
+                                        $match: {
+                                            $expr: {
+                                                $and: [
+                                                    { $in: ['$_id', '$$rolePermissions'] },
+                                                ],
+                                            },
+                                        },
+                                    },
+                                    { $limit: 1 },
+                                ],
+                                as: 'permissions',
+                            },
+                        },
+                        { $unwind: { path: '$permissions', preserveNullAndEmptyArrays: true } },
+                    ],
+                    as: 'roles',
+                },
+            },
+            { $unwind: { path: '$roles', preserveNullAndEmptyArrays: true } },
+            { $match: { 'roles.permissions.name': { $in: permissionNamesArray } } }, // Match if permissions.name in array
+            { $limit: 1 },
+            { $project: { _id: 0, hasPermission: { $cond: [{ $in: ['$roles.permissions.name', permissionNamesArray] }, true, false] } } } //check the value
+        ];
+        const result = await collection.aggregate(job).toArray();
+        return result.length === 1 && result[0].hasPermission;
+    } catch (e) {
+        logger.error(e);
+        return false;
+    }
+}
+
+/**
+ * Calcule l'utilisation totale de l'espace de stockage pour un utilisateur en octets.
+ * Cela inclut la taille des documents dans sa collection de données et la taille de ses fichiers uploadés.
+ * @param {object} user - L'objet utilisateur.
+ * @returns {Promise<number>} - L'utilisation totale en octets.
+ */
+export async function calculateTotalUserStorageUsage(user) {
+    const userId = user._user || user.username;
+    const datasCollection = getCollectionForUser(user);
+    const filesCollection = getCollection("files");
+
+    // Pipeline pour calculer la taille des documents de données
+    const dataSizePipeline = [
+        { $match: { _user: userId } },
+        {
+            $group: {
+                _id: null, // Grouper tous les documents ensemble
+                totalSize: { $sum: { $bsonSize: "$$ROOT" } } // Sommer la taille BSON de chaque document
+            }
+        }
+    ];
+
+    // Pipeline pour calculer la taille des fichiers
+    const fileSizePipeline = [
+        // Le champ est 'user' dans la collection 'files' selon votre fonction addFile
+        { $match: { user: userId, _model: "privateFile" } },
+        {
+            $group: {
+                _id: null,
+                totalSize: { $sum: "$size" }
+            }
+        }
+    ];
+
+    // Exécuter les deux calculs en parallèle pour plus d'efficacité
+    const [dataResult, fileResult] = await Promise.all([
+        datasCollection.aggregate(dataSizePipeline).toArray(),
+        filesCollection.aggregate(fileSizePipeline).toArray()
+    ]);
+
+    const dataSize = dataResult.length > 0 ? dataResult[0].totalSize : 0;
+    const filesSize = fileResult.length > 0 ? fileResult[0].totalSize : 0;
+
+    logger.debug(`[Storage] User ${userId}: Data size = ${dataSize} bytes, Files size = ${filesSize} bytes. Total = ${dataSize + filesSize} bytes.`);
+    return dataSize + filesSize;
+}