applay-utils 1.8.17 → 1.8.19

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "applay-utils",
-  "version": "1.8.17",
+  "version": "1.8.19",
   "description": "Utilitary tools for Applay applications",
   "scripts": {
+    "postinstall": "node python-setup.js",
     "build": "npm version patch",
     "test": "echo \"Error: no test specified\" && exit 1"
   },

package/python-scripts/aggregate.py

@@ -0,0 +1,23 @@
+# aggregate.py
+import sys, json
+from pymongo import MongoClient
+
+def main():
+    data = json.loads(sys.stdin.read())
+
+    mongo_url = data["mongoUrl"]
+    db_name = data["db"]
+    collection_name = data["collection"]
+    pipeline = data["pipeline"]
+    options = data.get("options", {})
+
+    client = MongoClient(mongo_url, maxPoolSize=50)
+    col = client[db_name][collection_name]
+
+    cursor = col.aggregate(pipeline, { "allowDiskUse": True, **options })
+    result = list(cursor)
+
+    print(json.dumps(result, ensure_ascii=False))
+
+if __name__ == "__main__":
+    main()

package/python-setup.js

@@ -0,0 +1,41 @@
+const { spawnSync } = require("child_process");
+
+function findPython() {
+    for (const cmd of ["python3", "python", "py"]) {
+        const check = spawnSync(cmd, ["--version"]);
+        if (check.status === 0) return cmd;
+    }
+    return null;
+}
+
+function ensurePyMongo(python) {
+    const check = spawnSync(python, ["-c", "import pymongo"], { encoding: "utf8" });
+
+    if (check.status === 0) {
+        console.log("✔ PyMongo já instalado");
+        return;
+    }
+
+    console.log("📦 Instalando PyMongo...");
+    const install = spawnSync(python, ["-m", "pip", "install", "pymongo"], { stdio: "inherit" });
+
+    if (install.status !== 0) {
+        console.error("❌ Falha ao instalar PyMongo.");
+        process.exit(1);
+    }
+
+    console.log("✔ PyMongo instalado com sucesso");
+}
+
+const python = findPython();
+
+if (!python) {
+    console.error("❌ Python não encontrado. Instale Python 3.");
+    process.exit(1);
+}
+
+console.log("✔ Python encontrado em:", python);
+ensurePyMongo(python);
+
+// Export to package.json
+console.log(`PYTHON=${python}`);

package/utils/mdb.js

@@ -23,22 +23,6 @@ var connect = (alias, url, callback) => {
   });
 }
 
-// var connect = (alias, url, callback) => {
-//   if (MDB.status[alias]) { return callback(MDB.clients[alias]); }
-//   console.log('================================================>>>>>>> NOVO POOL DE CONEXÃO MDB ',alias, Object.keys(MDB.status).length)
-//   let uriparams = `?appName=${alias}&minPoolSize=10&maxPoolSize=100&maxIdleTimeMS=30000&serverSelectionTimeoutMS=5000`;
-//   MongoBase.MongoClient.connect(url+uriparams, { useUnifiedTopology: true }, (err, client) => {
-//     if (err) { return console.log('ERRO MDB -- TRACKING -- ', err); }
-//     MDB.status[alias] = true;
-//     MDB.clients[alias] = client;
-//     process.on('SIGTERM', internalStop(alias, true, 'SIGTERM'));
-//     process.on('SIGINT', internalStop(alias, true, 'SIGINT'));
-//     process.on('uncaughtException', internalStop(alias, true, 'uncaughtException'));
-//     // console.log('Conectado com ', alias);
-//     callback(client)
-//   });
-// }
-
 var connectAsync = (alias, url) => new Promise(resolve => connect(alias, url, (client) => resolve(client)));
 
 var internalStop = (alias, finish) => {

package/utils/pythonFuncs.js

@@ -0,0 +1,38 @@
+const { spawn } = require("child_process");
+
+function aggregatePython(db, collection, pipe, options = {}) {
+    return new Promise((resolve, reject) => {
+
+        const python = spawn("python3", ["aggregate.py"]);
+
+        const payload = JSON.stringify({
+            mongoUrl: db.client.s.url,  // usa a URL do próprio MongoClient do Node
+            db: db.databaseName,
+            collection,
+            pipeline: pipe,
+            options
+        });
+
+        let output = "";
+        let errorOut = "";
+
+        python.stdout.on("data", data => output += data.toString());
+        python.stderr.on("data", data => errorOut += data.toString());
+
+        python.on("close", code => {
+            if (code !== 0) {
+                return reject(new Error("Python error:\n" + errorOut));
+            }
+            try {
+                resolve(JSON.parse(output));
+            } catch (e) {
+                reject(e);
+            }
+        });
+
+        python.stdin.write(payload);
+        python.stdin.end();
+    });
+}
+
+module.exports = { aggregatePython };

package/utils/querys.js

@@ -1,22 +1,11 @@
 const mdb = require('./mdb');
 const fs = require('fs');
+const pythonFuncs = require("./pythonFuncs");
+
 var sizeof;
 
 var registerLogs = (db,collection,result,callback)=>{
-  // if(!db.logSize){return callback(result)}
-  // if(!sizeof){sizeof = require('object-sizeof')}
-  // let size = sizeof(result)
   callback(result);
-  // let line = [
-  //   db.rota,
-  //   new Date().toLocaleDateString('pt-br'),
-  //   new Date().toLocaleTimeString('pt-br'),
-  //   db?.s?.namespace?.db,
-  //   collection,
-  //   (size/1000/1000).toFixed(2)+'mb',
-  //   size
-  // ]
-  // fs.appendFileSync(`/home/${process.env.USER}/logs/mdb-size.csv`,`\n${line.join(';')}` );
 }
 
 var querys = {
@@ -70,6 +59,14 @@ var querys = {
   'updateSetAsync': (db, collection, itemId, itemSet) => new Promise(resolve => db.collection(collection).findOneAndUpdate(itemId, { $set: itemSet }, (err, result) => resolve(result))),
   'updateAllAsync': (db, collection, filter, itemSet) => new Promise(resolve => db.collection(collection).updateMany(filter, itemSet, (err, result) => resolve(err || result))),
   'aggregateAsync': (db, collection, pipe, options) => new Promise(resolve => db.collection(collection).aggregate(pipe, { allowDiskUse: true, ...options }).toArray((err, result) => resolve(result))),
+  'aggregatePython': async (db, collection, pipe, options) => {
+    const res = await pythonFuncs.aggregateAsync(
+        db,
+        collection,
+        pipe
+    );
+    return res
+  },
   'deleteMany': (db, collection, filter) => new Promise(resolve => db.collection(collection).deleteMany(filter, (err, result) => resolve(result))),
   'deleteOne': (db, collection, filter) => new Promise((resolve, reject) => { db.collection(collection).deleteOne(filter, (err, result) => { if (err) { reject(err); } else { resolve(result); } }); }),
   'saveAsync': (db, collection, dataOrItem, user) => new Promise(resolve => {