drapi 1.8.53 → 1.8.55

package/lib/db.js

@@ -23,8 +23,24 @@ exports.getDatabaseConnection = function(dbName) {
         //database connection already exist. Return connection object
         return connections[dbName];
     } else {
-        connections[dbName] = mongoose.createConnection(config.db.host + dbName);
-        return connections[dbName];
+        const connection = mongoose.createConnection(config.db.host + dbName);
+        connections[dbName] = connection;
+        //Si la conexion inicial falla (p. ej. un wp sin base ni usuario), su promesa rechazada
+        //sin manejar termina el proceso. Se registra sin la URI (lleva credenciales) ni la pila, y se saca
+        //de la cache para que la siguiente peticion vuelva a intentar. PE2-9756
+        if (typeof connection.catch === 'function') {
+            connection.catch(function(err) {
+                console.error('[drapi] conexión a la base falló', {
+                    db: dbName,
+                    name: err && err.name,
+                    message: err && String(err.message).split('\n')[0]
+                });
+                if (connections[dbName] === connection) {
+                    delete connections[dbName];
+                }
+            });
+        }
+        return connection;
     }       
 }
 

package/lib/models.js

@@ -7,7 +7,6 @@ const db = require('./db');
 const structure = require('../api/models/structure');
 const controllers = require('../api/models/model');
 const trigger = require('../api/models/trigger');
-const sizeof = require('object-sizeof')
 
 /**
  * connectionschema = {
@@ -65,7 +64,6 @@ let models = {
                 modelSchema.plugin(mongooseLogs, {schemaName:model,createAction:"Creó",updateAction:"Actualizó",deleteAction:"Eliminó"});
             // }
             connectionschema[dbname][model] = modelSchema;
-            console.log("tamaño de schemas almacenados en memoria: ", sizeof(connectionschema));
         }
         
         return connection.model(model, connectionschema[dbname][model]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drapi",
-  "version": "1.8.53",
+  "version": "1.8.55",
   "description": "Dynamic rest api using mongoDb",
   "main": "index.js",
   "scripts": {

package/test/db.test.js

@@ -0,0 +1,145 @@
+// Pruebas de lib/db.js getDatabaseConnection (PE2-9756). Sin dependencias: node:test y assert.
+// mongoose.createConnection se sustituye sobre el módulo cacheado, que es el mismo
+// objeto que db.js obtiene con require("mongoose").
+const nodeTest = require('node:test');
+
+// Los casos corren en serie dentro de un solo test: los dobles son globales
+// (mongoose.createConnection, 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 mongoose = require('mongoose');
+const db = require('../lib/db');
+
+const HOST = 'mongodb://persona:secreta@mongo-interno:27017/';
+
+// Una conexión falsa con el mismo contrato que la de mongoose 5: then/catch sobre la
+// conexión inicial, que rechaza o resuelve cuando el caso lo decide.
+const conexionFalsa = () => {
+    let resolver, rechazar;
+    const inicial = new Promise((resolve, reject) => { resolver = resolve; rechazar = reject; });
+    const conexion = {
+        catch: (fn) => inicial.catch(fn),
+        then: (ok, ko) => inicial.then(() => ok && ok(conexion), ko)
+    };
+    return { conexion, resolver: () => resolver(conexion), rechazar: (err) => rechazar(err) };
+};
+
+const errorAuth = () => {
+    const error = new Error('failed to connect to server [172.31.9.99:27017] on first connect [MongoError: Authentication failed.]');
+    error.name = 'MongoNetworkError';
+    return error;
+};
+
+const conDobles = (fn) => async () => {
+    const originalCreate = mongoose.createConnection;
+    const originalError = console.error;
+    const originalConfig = global.drapiConfig;
+    const creadas = [];
+    const urls = [];
+    const errores = [];
+    const rechazos = [];
+    const alRechazo = (razon) => rechazos.push(razon);
+    global.drapiConfig = { db: { host: HOST } };
+    mongoose.createConnection = (url) => {
+        urls.push(url);
+        const falsa = conexionFalsa();
+        creadas.push(falsa);
+        return falsa.conexion;
+    };
+    console.error = (...args) => (String(args[0]).startsWith('[drapi]') ? errores.push(args) : originalError(...args));
+    process.on('unhandledRejection', alRechazo);
+    try {
+        await fn({ creadas, urls, errores, rechazos });
+    } finally {
+        mongoose.createConnection = originalCreate;
+        console.error = originalError;
+        global.drapiConfig = originalConfig;
+        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));
+
+// Cada caso usa su propia base: la caché de conexiones es del módulo.
+test('una base sin usuario se registra y no queda rechazo sin manejar', conDobles(
+    async ({ creadas, urls, errores, rechazos }) => {
+        const conexion = db.getDatabaseConnection('Error');
+        assert.strictEqual(conexion, creadas[0].conexion);
+        assert.deepStrictEqual(urls, [HOST + 'Error']);
+        creadas[0].rechazar(errorAuth());
+        await esperar();
+        assert.strictEqual(rechazos.length, 0);
+        assert.strictEqual(errores.length, 1);
+        const [mensaje, detalle] = errores[0];
+        assert.strictEqual(mensaje, '[drapi] conexión a la base falló');
+        assert.deepStrictEqual(detalle, {
+            db: 'Error',
+            name: 'MongoNetworkError',
+            message: errorAuth().message
+        });
+    }
+));
+
+test('el log no lleva la pila: solo la primera línea del mensaje', conDobles(
+    async ({ creadas, errores }) => {
+        db.getDatabaseConnection('cuadra-sin-base');
+        const error = errorAuth();
+        error.message = error.message + '\n    at Connection.messageHandler (connection.js:364:19)';
+        creadas[0].rechazar(error);
+        await esperar();
+        assert.strictEqual(errores[0][1].message, errorAuth().message);
+    }
+));
+
+test('el log no lleva la URI ni la contraseña', conDobles(
+    async ({ creadas, errores }) => {
+        db.getDatabaseConnection('fancap');
+        creadas[0].rechazar(errorAuth());
+        await esperar();
+        const texto = JSON.stringify(errores);
+        assert.ok(!texto.includes('secreta'));
+        assert.ok(!texto.includes('mongo-interno'));
+    }
+));
+
+test('tras el fallo, la siguiente llamada abre una conexión nueva', conDobles(
+    async ({ creadas }) => {
+        const primera = db.getDatabaseConnection('capitolio');
+        creadas[0].rechazar(errorAuth());
+        await esperar();
+        const segunda = db.getDatabaseConnection('capitolio');
+        assert.strictEqual(creadas.length, 2);
+        assert.notStrictEqual(segunda, primera);
+    }
+));
+
+test('una conexión que resuelve se queda en caché y no registra nada', conDobles(
+    async ({ creadas, errores }) => {
+        const primera = db.getDatabaseConnection('demo');
+        creadas[0].resolver();
+        await esperar();
+        const segunda = db.getDatabaseConnection('demo');
+        assert.strictEqual(segunda, primera);
+        assert.strictEqual(creadas.length, 1);
+        assert.strictEqual(errores.length, 0);
+    }
+));
+
+test('mientras conecta, las llamadas comparten la misma conexión', conDobles(
+    async ({ creadas }) => {
+        const primera = db.getDatabaseConnection('panavision');
+        const segunda = db.getDatabaseConnection('panavision');
+        assert.strictEqual(segunda, primera);
+        assert.strictEqual(creadas.length, 1);
+        creadas[0].resolver();
+    }
+));
+
+nodeTest('lib/db.js getDatabaseConnection', async (t) => {
+    for (const [nombre, fn] of casos) {
+        await t.test(nombre, fn);
+    }
+});