drapi 1.8.51 → 1.8.53

package/api/basecontrollers/restcontroller.js

@@ -36,8 +36,9 @@ class RestController extends BaseController  {
   }
 
   async search(ctx) {
-    let query = this.ctx.request.body;
+    let query = ctx.request.body;
     ctx.query = query;
+    delete ctx.query.modifiedBy;
 
     return await this.list(ctx);
   }

package/lib/trigger.js

@@ -30,7 +30,19 @@ module.exports.executeTriggers = async function(ctx,modelName,when,event,data){
                 await axios.post(url, {data: data},{headers: headers})
             break;
             case 'after':
-                axios.post(url, {data: data},{headers: headers});//.then(response => {}).catch(error => {console.log("error",error.response)});
+                // Sin await a propósito: la respuesta no espera al trigger. Sin el catch, un
+                // endpoint caído deja la promesa sin manejar y Node termina el proceso (EPCMS-10295).
+                // No se registra data ni headers: llevan datos personales y la apikey.
+                axios.post(url, {data: data},{headers: headers}).catch(error => {
+                    console.error('[drapi] trigger after falló', {
+                        model: modelName,
+                        event: event,
+                        url: url,
+                        wp: ctx.headers.wp,
+                        status: error.response ? error.response.status : undefined,
+                        message: error.message
+                    });
+                });
             break;
         }
         } 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "drapi",
-  "version": "1.8.51",
+  "version": "1.8.53",
   "description": "Dynamic rest api using mongoDb",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --test test/"
   },
   "repository": {
     "type": "git",

package/test/trigger.test.js

@@ -0,0 +1,151 @@
+// Pruebas de lib/trigger.js (EPCMS-10295). Sin dependencias: node:test y assert.
+// axios se sustituye sobre el módulo cacheado, que es el mismo objeto que
+// trigger.js obtiene con require("axios").
+const nodeTest = require('node:test');
+
+// Los casos corren en serie dentro de un solo test: los dobles son globales
+// (axios, console.error) y en Node 16 los test() de primer nivel se solapan.
+const casos = [];
+const test = (nombre, fn) => casos.push([nombre, fn]);
+const assert = require('node:assert');
+const axios = require('axios');
+const trigger = require('../lib/trigger');
+
+const ctx = {
+    headers: { wp: 'demo', apikey: 'secreta' },
+    request: { origin: 'http://persona' }
+};
+const data = { _id: 'p1', nombres: 'Ana', numerodocumento: '1234' };
+
+const conTriggers = (triggers, fn) => async () => {
+    const originalGet = trigger.getTriggers;
+    const originalPost = axios.post;
+    const originalError = console.error;
+    const errores = [];
+    const rechazos = [];
+    const alRechazo = (razon) => rechazos.push(razon);
+    trigger.getTriggers = async () => triggers;
+    // Solo se capturan los mensajes de drapi: Node 16 escribe su ExperimentalWarning
+    // del test runner por console.error la primera vez.
+    console.error = (...args) => (String(args[0]).startsWith('[drapi]') ? errores.push(args) : originalError(...args));
+    process.on('unhandledRejection', alRechazo);
+    try {
+        await fn({ errores, rechazos });
+    } finally {
+        trigger.getTriggers = originalGet;
+        axios.post = originalPost;
+        console.error = originalError;
+        process.removeListener('unhandledRejection', alRechazo);
+    }
+};
+
+// Deja correr los microtasks y un ciclo del event loop para que un rechazo
+// sin manejar alcance a dispararse.
+const esperar = () => new Promise((resolve) => setImmediate(resolve));
+
+const errorHttp = (status) => {
+    const error = new Error(`Request failed with status code ${status}`);
+    error.response = { status, data: { error: 'Unauthorized' } };
+    return error;
+};
+
+test('after: un 401 del endpoint se registra y no queda rechazo sin manejar', conTriggers(
+    [{ endpoint: 'http://payroll-interno/colaborador/personaSyncUpdate' }],
+    async ({ errores, rechazos }) => {
+        axios.post = () => Promise.reject(errorHttp(401));
+        const resultado = await trigger.executeTriggers(ctx, 'persona', 'after', 'update', data);
+        await esperar();
+        assert.strictEqual(resultado, true);
+        assert.strictEqual(rechazos.length, 0);
+        assert.strictEqual(errores.length, 1);
+        const [mensaje, detalle] = errores[0];
+        assert.strictEqual(mensaje, '[drapi] trigger after falló');
+        assert.deepStrictEqual(detalle, {
+            model: 'persona',
+            event: 'update',
+            url: 'http://payroll-interno/colaborador/personaSyncUpdate',
+            wp: 'demo',
+            status: 401,
+            message: 'Request failed with status code 401'
+        });
+    }
+));
+
+test('after: un error de DNS (sin response) se registra sin status', conTriggers(
+    [{ endpoint: 'http://payroll/colaborador/personaSyncUpdate' }],
+    async ({ errores, rechazos }) => {
+        axios.post = () => Promise.reject(new Error('getaddrinfo ENOTFOUND payroll'));
+        await trigger.executeTriggers(ctx, 'persona', 'after', 'update', data);
+        await esperar();
+        assert.strictEqual(rechazos.length, 0);
+        assert.strictEqual(errores.length, 1);
+        assert.strictEqual(errores[0][1].status, undefined);
+        assert.strictEqual(errores[0][1].message, 'getaddrinfo ENOTFOUND payroll');
+    }
+));
+
+test('after: el log no lleva data ni apikey', conTriggers(
+    [{ endpoint: 'http://payroll-interno/x' }],
+    async ({ errores }) => {
+        axios.post = () => Promise.reject(errorHttp(500));
+        await trigger.executeTriggers(ctx, 'persona', 'after', 'update', data);
+        await esperar();
+        const texto = JSON.stringify(errores);
+        assert.ok(!texto.includes('secreta'));
+        assert.ok(!texto.includes('1234'));
+        assert.ok(!texto.includes('Ana'));
+    }
+));
+
+test('after: si el endpoint responde bien no se registra nada', conTriggers(
+    [{ endpoint: 'http://payroll-interno/x' }],
+    async ({ errores }) => {
+        axios.post = () => Promise.resolve({ status: 200 });
+        await trigger.executeTriggers(ctx, 'persona', 'after', 'update', data);
+        await esperar();
+        assert.strictEqual(errores.length, 0);
+    }
+));
+
+test('after: no espera al endpoint (la respuesta sigue sin bloquearse)', conTriggers(
+    [{ endpoint: 'http://payroll-interno/x' }],
+    async () => {
+        let resolver;
+        axios.post = () => new Promise((resolve) => { resolver = resolve; });
+        const resultado = await trigger.executeTriggers(ctx, 'persona', 'after', 'update', data);
+        assert.strictEqual(resultado, true);
+        resolver({ status: 200 });
+    }
+));
+
+test('after: envía data, wp y apikey al endpoint como hoy', conTriggers(
+    [{ endpoint: '/estudios/triggernivelestudios' }],
+    async () => {
+        let llamada;
+        axios.post = (...args) => { llamada = args; return Promise.resolve({}); };
+        await trigger.executeTriggers(ctx, 'estudios', 'after', 'update', data);
+        assert.deepStrictEqual(llamada, [
+            'http://persona/estudios/triggernivelestudios',
+            { data },
+            { headers: { wp: 'demo', apikey: 'secreta' } }
+        ]);
+    }
+));
+
+test('before: un endpoint que falla sigue haciendo fallar la operación', conTriggers(
+    [{ endpoint: 'http://payroll-interno/x' }],
+    async ({ errores }) => {
+        axios.post = () => Promise.reject(errorHttp(401));
+        await assert.rejects(
+            trigger.executeTriggers(ctx, 'persona', 'before', 'update', data),
+            /status code 401/
+        );
+        assert.strictEqual(errores.length, 0);
+    }
+));
+
+nodeTest('lib/trigger.js executeTriggers', async (t) => {
+    for (const [nombre, fn] of casos) {
+        await t.test(nombre, fn);
+    }
+});

package/.vscode-upload.json

@@ -1,21 +0,0 @@
-[{
-    "name":"",
-    "host": "",
-    "port": 22,
-    "username": "",
-    "password": "",
-    "remotePath": "",
-    "localPath": "",
-    "disable": false,
-    "private_key": "~/.ssh/id_rsa"
-},{
-    "name":"",
-    "host": "",
-    "port": 22,
-    "username": "",
-    "password": "",
-    "remotePath": "",
-    "localPath": "",
-    "disable": false,
-    "private_key": "~/.ssh/id_rsa"
-}]