applay-utils 1.8.17 → 1.8.20

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "applay-utils",
-  "version": "1.8.17",
+  "version": "1.8.20",
   "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,51 @@
+const { spawnSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+function findPython() {
+    for (const cmd of ["python3", "python", "py"]) {
+        const check = spawnSync(cmd, ["--version"]);
+        if (check.status === 0) return cmd;
+    }
+    return null;
+}
+
+function run(cmd, args, opts = {}) {
+    const out = spawnSync(cmd, args, { stdio: "inherit", ...opts });
+    if (out.status !== 0) {
+        console.error(`❌ Falha ao rodar: ${cmd} ${args.join(" ")}`);
+        process.exit(1);
+    }
+}
+
+const python = findPython();
+if (!python) {
+    console.error("❌ Nenhum Python encontrado!");
+    process.exit(1);
+}
+
+console.log("✔ Python encontrado em:", python);
+
+// Caminho da venv
+const venvPath = path.join(__dirname, ".python-env");
+
+// Criar venv se não existir
+if (!fs.existsSync(venvPath)) {
+    console.log("📦 Criando ambiente virtual Python...");
+    run(python, ["-m", "venv", venvPath]);
+}
+
+const pyBin = path.join(venvPath, "bin", "python");
+const pipBin = path.join(venvPath, "bin", "pip");
+
+// Verifica PyMongo dentro da venv
+const check = spawnSync(pyBin, ["-c", "import pymongo"]);
+if (check.status !== 0) {
+    console.log("📦 Instalando PyMongo dentro da venv...");
+    run(pyBin, ["-m", "pip", "install", "pymongo"]);
+} else {
+    console.log("✔ PyMongo já instalado na venv.");
+}
+
+console.log("✔ Ambiente Python pronto.");
+console.log(`PYTHON=${pyBin}`);

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,37 @@
+const path = require("path");
+const { spawn } = require("child_process");
+
+function aggregateAsync(db, collection, pipe, options = {}) {
+    return new Promise((resolve, reject) => {
+
+        const python = path.join(__dirname, ".python-env/bin/python");
+        const script = path.join(__dirname, "aggregate.py");
+
+        const payload = JSON.stringify({
+            mongoUrl: db.client.s.url,
+            db: db.databaseName,
+            collection,
+            pipeline: pipe,
+            options
+        });
+
+        const proc = spawn(python, [script]);
+
+        let out = "";
+        let err = "";
+
+        proc.stdout.on("data", d => out += d.toString());
+        proc.stderr.on("data", d => err += d.toString());
+
+        proc.on("close", code => {
+            if (code !== 0) return reject(new Error(err));
+            try { resolve(JSON.parse(out)); }
+            catch (e) { reject(e); }
+        });
+
+        proc.stdin.write(payload);
+        proc.stdin.end();
+    });
+}
+
+module.exports = { aggregateAsync };

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 => {