@hostwebhook/platform-node 0.1.0 → 0.2.0

package/dist/busqueda-literal.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Lo que se teclea en un buscador es TEXTO, no una expresión regular.
+ *
+ * ## El fallo que cierra
+ *
+ * `GET /api/credentials?search=` y `GET /api/signing-secrets?search=` metían la
+ * cadena de la query directamente en un `$regex` de MongoDB. O sea que quien
+ * llamaba elegía la expresión regular que ejecuta el motor de la base.
+ *
+ * Y el motor de Mongo resuelve por retroceso, igual que el de JavaScript:
+ *
+ *     1. se crea una credencial con `name` = 100 000 letras 'a'
+ *        (ni el DTO ni el esquema ponían tope a la longitud);
+ *     2. `GET /api/credentials?search=(a%2B)%2Bb`
+ *
+ * y `(a+)+b` contra esa cadena es exponencial. Una petición barata deja un
+ * worker de mongod girando, y la base es la MISMA para todos los inquilinos del
+ * clúster. Repitiendo hasta el tope de peticiones —que además se esquiva
+ * variando `X-Forwarded-For`, cosa que el propio `client-ip.ts` avisa de que es
+ * falsificable— la CPU no baja.
+ *
+ * Lo más llamativo es que el escape correcto ya estaba escrito noventa líneas
+ * más abajo en el mismo fichero, para el buscador de etiquetas. Estaba resuelto
+ * y copiado a medias.
+ *
+ * ## Lo que hace
+ *
+ * Escapa los metacaracteres —para que el patrón case LITERALMENTE lo que se
+ * escribió— y acota la longitud. Lo segundo importa aparte: el coste de una
+ * búsqueda crece con el patrón además de con el texto, y un buscador no
+ * necesita mil caracteres.
+ *
+ * ⚠️ El escape en sí NO vive aquí: es `escaparRegex`, en el módulo de al
+ * lado. Esta función es «escapar Y acotar»; hay un puñado de sitios que
+ * incrustan un valor interno en un patrón y no pueden recortarlo sin cambiar
+ * lo que significa, y ésos usan el primitivo pelado. Una sola expresión de
+ * escape en todo el repositorio, y dos maneras de pedirla.
+ *
+ * No se usa `$text`: exigiría un índice de texto por colección y cambiaría la
+ * semántica de «contiene» a «palabras completas», que no es lo que el panel
+ * ofrece hoy.
+ */
+/** Un buscador no necesita más. Por encima, se recorta. */
+export declare const MAX_BUSQUEDA = 200;
+/**
+ * Devuelve la cadena lista para meter en un `$regex`, casando literalmente.
+ *
+ * Se exporta también `MAX_BUSQUEDA` para que quien quiera pueda rechazar en vez
+ * de recortar; aquí se recorta porque un buscador que devuelve un error por
+ * escribir de más es peor que uno que busca por los primeros 200 caracteres.
+ */
+export declare function busquedaLiteral(bruto: unknown): string;

package/dist/busqueda-literal.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Lo que se teclea en un buscador es TEXTO, no una expresión regular.
+ *
+ * ## El fallo que cierra
+ *
+ * `GET /api/credentials?search=` y `GET /api/signing-secrets?search=` metían la
+ * cadena de la query directamente en un `$regex` de MongoDB. O sea que quien
+ * llamaba elegía la expresión regular que ejecuta el motor de la base.
+ *
+ * Y el motor de Mongo resuelve por retroceso, igual que el de JavaScript:
+ *
+ *     1. se crea una credencial con `name` = 100 000 letras 'a'
+ *        (ni el DTO ni el esquema ponían tope a la longitud);
+ *     2. `GET /api/credentials?search=(a%2B)%2Bb`
+ *
+ * y `(a+)+b` contra esa cadena es exponencial. Una petición barata deja un
+ * worker de mongod girando, y la base es la MISMA para todos los inquilinos del
+ * clúster. Repitiendo hasta el tope de peticiones —que además se esquiva
+ * variando `X-Forwarded-For`, cosa que el propio `client-ip.ts` avisa de que es
+ * falsificable— la CPU no baja.
+ *
+ * Lo más llamativo es que el escape correcto ya estaba escrito noventa líneas
+ * más abajo en el mismo fichero, para el buscador de etiquetas. Estaba resuelto
+ * y copiado a medias.
+ *
+ * ## Lo que hace
+ *
+ * Escapa los metacaracteres —para que el patrón case LITERALMENTE lo que se
+ * escribió— y acota la longitud. Lo segundo importa aparte: el coste de una
+ * búsqueda crece con el patrón además de con el texto, y un buscador no
+ * necesita mil caracteres.
+ *
+ * ⚠️ El escape en sí NO vive aquí: es `escaparRegex`, en el módulo de al
+ * lado. Esta función es «escapar Y acotar»; hay un puñado de sitios que
+ * incrustan un valor interno en un patrón y no pueden recortarlo sin cambiar
+ * lo que significa, y ésos usan el primitivo pelado. Una sola expresión de
+ * escape en todo el repositorio, y dos maneras de pedirla.
+ *
+ * No se usa `$text`: exigiría un índice de texto por colección y cambiaría la
+ * semántica de «contiene» a «palabras completas», que no es lo que el panel
+ * ofrece hoy.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_BUSQUEDA = void 0;
+exports.busquedaLiteral = busquedaLiteral;
+const escapar_regex_1 = require("./escapar-regex");
+/** Un buscador no necesita más. Por encima, se recorta. */
+exports.MAX_BUSQUEDA = 200;
+/**
+ * Devuelve la cadena lista para meter en un `$regex`, casando literalmente.
+ *
+ * Se exporta también `MAX_BUSQUEDA` para que quien quiera pueda rechazar en vez
+ * de recortar; aquí se recorta porque un buscador que devuelve un error por
+ * escribir de más es peor que uno que busca por los primeros 200 caracteres.
+ */
+function busquedaLiteral(bruto) {
+    if (typeof bruto !== 'string' || bruto.length === 0)
+        return '';
+    return (0, escapar_regex_1.escaparRegex)(bruto.slice(0, exports.MAX_BUSQUEDA));
+}

package/dist/escapar-regex.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Lo que escribe el usuario es TEXTO, no un patrón.
+ *
+ * Sin escapar pasan dos cosas, y ninguna es «no encuentra nada»: un
+ * paréntesis suelto hace que Mongo rechace la consulta entera con un error
+ * de sintaxis, y un patrón anidado del tipo «grupo repetido dentro de grupo
+ * repetido» se convierte en un ReDoS — el regex lo evalúa el servidor de
+ * base de datos, así que quien se queda colgado es él, no el proceso que
+ * recibió la petición.
+ *
+ * ⚠️ **Ésta es la única expresión regular de escape del repositorio.** No
+ * escribas otra: `busquedaLiteral` la usa, y todo lo demás usa una de las
+ * dos. Cuál de las dos:
+ *
+ *  - `busquedaLiteral` — texto que teclea alguien en un buscador. Escapa
+ *    **y acota** la longitud, porque el coste de la búsqueda crece con el
+ *    patrón además de con el texto. Es la que quieres casi siempre.
+ *  - `escaparRegex` (ésta) — un valor interno que se incrusta en un patrón
+ *    y que NO puede recortarse sin cambiar lo que significa.
+ *
+ * El 2026-08-27 este módulo decía que quedaban «tres copias literales» por
+ * migrar. Eran DOCE: se habían contado buscando los nombres `escapeRegex` y
+ * `escaparRegex`, y la mitad estaban escritas a pelo dentro de la consulta,
+ * sin función que buscar. Contar por el nombre no es inventariar — hay que
+ * contar por la clase de caracteres. `una-sola-copia-del-escape.spec.ts` lo
+ * cuenta ahora por ti y no deja aparecer la trece.
+ */
+export declare function escaparRegex(s: string): string;

package/dist/escapar-regex.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escaparRegex = escaparRegex;
+/**
+ * Lo que escribe el usuario es TEXTO, no un patrón.
+ *
+ * Sin escapar pasan dos cosas, y ninguna es «no encuentra nada»: un
+ * paréntesis suelto hace que Mongo rechace la consulta entera con un error
+ * de sintaxis, y un patrón anidado del tipo «grupo repetido dentro de grupo
+ * repetido» se convierte en un ReDoS — el regex lo evalúa el servidor de
+ * base de datos, así que quien se queda colgado es él, no el proceso que
+ * recibió la petición.
+ *
+ * ⚠️ **Ésta es la única expresión regular de escape del repositorio.** No
+ * escribas otra: `busquedaLiteral` la usa, y todo lo demás usa una de las
+ * dos. Cuál de las dos:
+ *
+ *  - `busquedaLiteral` — texto que teclea alguien en un buscador. Escapa
+ *    **y acota** la longitud, porque el coste de la búsqueda crece con el
+ *    patrón además de con el texto. Es la que quieres casi siempre.
+ *  - `escaparRegex` (ésta) — un valor interno que se incrusta en un patrón
+ *    y que NO puede recortarse sin cambiar lo que significa.
+ *
+ * El 2026-08-27 este módulo decía que quedaban «tres copias literales» por
+ * migrar. Eran DOCE: se habían contado buscando los nombres `escapeRegex` y
+ * `escaparRegex`, y la mitad estaban escritas a pelo dentro de la consulta,
+ * sin función que buscar. Contar por el nombre no es inventariar — hay que
+ * contar por la clase de caracteres. `una-sola-copia-del-escape.spec.ts` lo
+ * cuenta ahora por ti y no deja aparecer la trece.
+ */
+function escaparRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/escape-html.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Escapar HTML, una sola vez y en un solo sitio.
+ *
+ * Había TRES copias de esta función en el repo —en `credentials.controller`,
+ * en `approval-nodes.controller` y en `send-and-wait.controller`— idénticas
+ * carácter por carácter. Que hoy coincidan no es garantía de nada: son tres
+ * sitios donde alguien puede añadir un caso, olvidarse de los otros dos, y
+ * dejar dos escapes peores que el tercero sin que nada lo señale.
+ *
+ * Y estaba a punto de haber una cuarta, para el email de invitación.
+ *
+ * Los cinco caracteres son los de siempre, y el orden importa: `&` va primero
+ * o acabaría escapando los `&` que introducen los demás reemplazos.
+ */
+export declare function escapeHtml(valor: unknown): string;

package/dist/escape-html.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeHtml = escapeHtml;
+/**
+ * Escapar HTML, una sola vez y en un solo sitio.
+ *
+ * Había TRES copias de esta función en el repo —en `credentials.controller`,
+ * en `approval-nodes.controller` y en `send-and-wait.controller`— idénticas
+ * carácter por carácter. Que hoy coincidan no es garantía de nada: son tres
+ * sitios donde alguien puede añadir un caso, olvidarse de los otros dos, y
+ * dejar dos escapes peores que el tercero sin que nada lo señale.
+ *
+ * Y estaba a punto de haber una cuarta, para el email de invitación.
+ *
+ * Los cinco caracteres son los de siempre, y el orden importa: `&` va primero
+ * o acabaría escapando los `&` que introducen los demás reemplazos.
+ */
+function escapeHtml(valor) {
+    return String(valor)
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}

package/dist/index.d.ts

@@ -1 +1,6 @@
 export { encrypt, decrypt, type Llaves } from './crypto';
+export * from './escape-html';
+export * from './mongo-databases';
+export * from './postgres-databases';
+export * from './busqueda-literal';
+export * from './escapar-regex';

package/dist/index.js

@@ -1,6 +1,25 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decrypt = exports.encrypt = void 0;
 var crypto_1 = require("./crypto");
 Object.defineProperty(exports, "encrypt", { enumerable: true, get: function () { return crypto_1.encrypt; } });
 Object.defineProperty(exports, "decrypt", { enumerable: true, get: function () { return crypto_1.decrypt; } });
+__exportStar(require("./escape-html"), exports);
+__exportStar(require("./mongo-databases"), exports);
+__exportStar(require("./postgres-databases"), exports);
+__exportStar(require("./busqueda-literal"), exports);
+__exportStar(require("./escapar-regex"), exports);

package/dist/mongo-databases.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Las bases que MongoDB trae siempre y que nadie elige como destino.
+ *
+ * Vive en `common` y no junto al nodo porque la usan los dos lados y en
+ * direcciones opuestas: el nodo de Mongo al listar las bases del servidor, y
+ * `CredentialsService` al comprobar que la base tecleada en el formulario
+ * existe. Importarla desde `nodes/` en `credentials/` invertiría la
+ * dependencia (los nodos importan credenciales, no al revés).
+ */
+export declare const BASES_INTERNAS: ReadonlySet<string>;
+/**
+ * Por qué rechazar la base que declara una credencial de Mongo, o `null` si
+ * no hay motivo.
+ *
+ * ⚠️ La distinción que lo es todo: `disponibles === undefined` significa **no
+ * se pudo mirar** (credencial acotada a una base, servidor caído), y eso
+ * **nunca** bloquea. Una lista vacía sí es una respuesta. Tratar los dos
+ * casos igual impediría guardar credenciales perfectamente buenas.
+ *
+ * Existe porque `client.db("no_existe")` no falla en Mongo —las bases se
+ * crean al escribir— así que un nombre mal tecleado se guarda tan campante y
+ * después toda lectura devuelve cero, sin error. Medido el 2026-08-12: una
+ * credencial decía `my_hostwebhook_testing_database` y el servidor sólo tenía
+ * `test`.
+ */
+export declare function motivoDeBaseInvalida(pedida: string | null | undefined, disponibles: string[] | undefined): string | null;

package/dist/mongo-databases.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASES_INTERNAS = void 0;
+exports.motivoDeBaseInvalida = motivoDeBaseInvalida;
+/**
+ * Las bases que MongoDB trae siempre y que nadie elige como destino.
+ *
+ * Vive en `common` y no junto al nodo porque la usan los dos lados y en
+ * direcciones opuestas: el nodo de Mongo al listar las bases del servidor, y
+ * `CredentialsService` al comprobar que la base tecleada en el formulario
+ * existe. Importarla desde `nodes/` en `credentials/` invertiría la
+ * dependencia (los nodos importan credenciales, no al revés).
+ */
+exports.BASES_INTERNAS = new Set([
+    'admin',
+    'local',
+    'config',
+]);
+/**
+ * Por qué rechazar la base que declara una credencial de Mongo, o `null` si
+ * no hay motivo.
+ *
+ * ⚠️ La distinción que lo es todo: `disponibles === undefined` significa **no
+ * se pudo mirar** (credencial acotada a una base, servidor caído), y eso
+ * **nunca** bloquea. Una lista vacía sí es una respuesta. Tratar los dos
+ * casos igual impediría guardar credenciales perfectamente buenas.
+ *
+ * Existe porque `client.db("no_existe")` no falla en Mongo —las bases se
+ * crean al escribir— así que un nombre mal tecleado se guarda tan campante y
+ * después toda lectura devuelve cero, sin error. Medido el 2026-08-12: una
+ * credencial decía `my_hostwebhook_testing_database` y el servidor sólo tenía
+ * `test`.
+ */
+function motivoDeBaseInvalida(pedida, disponibles) {
+    const nombre = (pedida ?? '').trim();
+    if (!nombre)
+        return null;
+    if (!disponibles)
+        return null;
+    if (disponibles.includes(nombre))
+        return null;
+    return disponibles.length > 0
+        ? `Database "${nombre}" doesn't exist on this server. Available: ${disponibles.join(', ')}`
+        : `Database "${nombre}" doesn't exist on this server, and the server has no databases yet`;
+}

package/dist/postgres-databases.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Qué bases ofrece el selector del formulario de una credencial de Postgres.
+ *
+ * Aparte del servicio, como `mongo-databases.ts`, para que la consulta y el
+ * filtrado se puedan probar sin levantar un Postgres.
+ */
+/**
+ * Las bases a las que un cliente se puede conectar de verdad.
+ *
+ * Los dos filtros están por un motivo concreto, y quitarlos no rompe nada
+ * hasta que alguien elige la opción equivocada:
+ *
+ * - `datistemplate = false` deja fuera `template0` y `template1`, que son
+ *   plantillas y no destinos.
+ * - `datallowconn = true` es el que de verdad importa: **`template0` rechaza
+ *   conexiones por diseño**. Ofrecerla es ofrecer una opción que sólo puede
+ *   fallar, y el error (`FATAL: database "template0" is not currently
+ *   accepting connections`) no se parece en nada a «esa no la elijas».
+ */
+export declare const SQL_BASES_DE_POSTGRES = "SELECT datname FROM pg_database\n          WHERE datistemplate = false AND datallowconn = true\n          ORDER BY datname";
+/**
+ * Los nombres, de lo que devuelva el driver.
+ *
+ * Se valida el tipo en vez de castear: `pg` tipa las filas por lo que le
+ * digas, no por lo que llegue, así que una fila rara entraría como `undefined`
+ * y pintaría una opción vacía en el desplegable.
+ */
+export declare function nombresDeBases(filas: ReadonlyArray<{
+    datname?: unknown;
+}>): string[];

package/dist/postgres-databases.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Qué bases ofrece el selector del formulario de una credencial de Postgres.
+ *
+ * Aparte del servicio, como `mongo-databases.ts`, para que la consulta y el
+ * filtrado se puedan probar sin levantar un Postgres.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQL_BASES_DE_POSTGRES = void 0;
+exports.nombresDeBases = nombresDeBases;
+/**
+ * Las bases a las que un cliente se puede conectar de verdad.
+ *
+ * Los dos filtros están por un motivo concreto, y quitarlos no rompe nada
+ * hasta que alguien elige la opción equivocada:
+ *
+ * - `datistemplate = false` deja fuera `template0` y `template1`, que son
+ *   plantillas y no destinos.
+ * - `datallowconn = true` es el que de verdad importa: **`template0` rechaza
+ *   conexiones por diseño**. Ofrecerla es ofrecer una opción que sólo puede
+ *   fallar, y el error (`FATAL: database "template0" is not currently
+ *   accepting connections`) no se parece en nada a «esa no la elijas».
+ */
+exports.SQL_BASES_DE_POSTGRES = `SELECT datname FROM pg_database
+          WHERE datistemplate = false AND datallowconn = true
+          ORDER BY datname`;
+/**
+ * Los nombres, de lo que devuelva el driver.
+ *
+ * Se valida el tipo en vez de castear: `pg` tipa las filas por lo que le
+ * digas, no por lo que llegue, así que una fila rara entraría como `undefined`
+ * y pintaría una opción vacía en el desplegable.
+ */
+function nombresDeBases(filas) {
+    return filas
+        .map((f) => f.datname)
+        .filter((n) => typeof n === 'string' && n.trim() !== '');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hostwebhook/platform-node",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Lo que los servicios de HostWebhook comparten del lado de NODE: cifrado y utilidades que no pueden estar escritas dos veces",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",