@hostwebhook/node-sdk 0.3.0 → 0.4.0

package/dist/sync-connections.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNoSelfConnection = assertNoSelfConnection;
+exports.assertConnectableTypes = assertConnectableTypes;
+exports.validateConnectionWorkspaces = validateConnectionWorkspaces;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("mongoose");
+const node_types_1 = require("@hostwebhook/node-types");
+const node_dispatch_registry_1 = require("./node-dispatch.registry");
+const output_node_dto_1 = require("./dto/output-node.dto");
+/** Map nodeType → MongoDB collection name */
+const TYPE_TO_COLLECTION = {};
+for (const entry of node_dispatch_registry_1.NODE_DISPATCH_REGISTRY) {
+    TYPE_TO_COLLECTION[entry.type] = entry.collection;
+}
+/**
+ * Reject a node wired to itself.
+ *
+ * A canvas drag from a node's own output dot to its own input dot produced a
+ * real, persisted edge: source and target were the same id. Nothing stopped it
+ * — the dashboard assumed the registry prevented invalid connections, and the
+ * registry answers a different question. `canReceiveFrom('transform',
+ * 'transform')` is TRUE, and correctly so: chaining two different Transform
+ * nodes is ordinary. What the type pair cannot express is "not this same
+ * instance", because ids are not types.
+ *
+ * The one legitimate self-edge is the Loop node's loop-back, and the registry
+ * already declares it as `special.hasLoopBack`. So the exception is read from
+ * there rather than hardcoded here — a future node that needs to re-enter
+ * itself declares the flag and both the canvas and this check follow.
+ */
+function assertNoSelfConnection(nodeType, nodeId, nodes) {
+    if (node_types_1.NODE_CONNECTIONS[nodeType]?.special?.hasLoopBack)
+        return;
+    const selfId = nodeId.toString();
+    for (const node of nodes) {
+        if (node.nodeType === nodeType && node.nodeId?.toString() === selfId) {
+            throw new common_1.BadRequestException(`A ${nodeType} node cannot connect to itself`);
+        }
+    }
+}
+/**
+ * Rechaza una conexión entre tipos que no pueden conectarse.
+ *
+ * Hasta ahora la compatibilidad de tipos era cosa del lienzo, y estaba escrito
+ * aquí al lado: *"Type compatibility is the registry's job and is checked on
+ * the canvas"*. Eso valía mientras el lienzo fuera el único que escribe, y no
+ * lo es: `/agent-context` le explica a un agente, con ejemplos, que meta
+ * `{ nodeType, nodeId }` a mano en `inputNodes`/`outputNodes`, y cualquier
+ * cliente con la clave y el scope puede hacer lo mismo.
+ *
+ * Lo que se colaba por ahí no revienta: **desaparece**. `dispatchOutputNodes`
+ * cae en su rama por defecto, `getNodeHandler('trigger')` no devuelve nada y
+ * suelta un `logger.warn` —sin evento de telemetría, porque el `telemetry.emit`
+ * está en el `catch` y esto no lanza—. O sea una arista dibujada en el lienzo
+ * que no dispara nunca y que no aparece en ningún sitio donde mirarla.
+ *
+ * ⚠️ **La regla es `fromNodes`/`toNodes` de `NODE_UI`, y no las listas de
+ * `NODE_CONNECTIONS`.** La tentación es usar `acceptsInputFrom`/`canOutputTo`,
+ * que están ahí mismo, las declaran los 43 tipos y parecen más precisas. Están
+ * podridas: medidas contra producción el 2026-08-19 rechazaban **111 de 364**
+ * conexiones que funcionan hoy — `trigger → ai`, `ai → telegramAction`,
+ * `sheetsAction → filter`. `fromNodes`/`toNodes` rechazaba **0**, porque es el
+ * mismo dato que decide qué puntos pinta la tarjeta. Endurecer con eso no
+ * puede romper nada que el usuario haya podido crear desde el lienzo, que es
+ * justo la propiedad que se busca: la api no debe ser más estricta que la
+ * pantalla, sólo igual de estricta en los caminos que la pantalla no cubre.
+ *
+ * De un tipo que el registro no conoce no se opina. Un alias viejo se
+ * normaliza primero (`voiceCall` → `voiceAgent`); lo que ni así aparezca se
+ * deja pasar, porque un 400 sobre datos heredados con autoguardado deja la
+ * página sin poder guardar nunca más.
+ */
+function assertConnectableTypes(ownType, refs) {
+    // En `outputNodes` yo soy el origen y la referencia es el destino.
+    for (const ref of refs.outputNodes ?? [])
+        assertPar(ownType, (0, output_node_dto_1.normalizeNodeType)(ref.nodeType));
+    // En `inputNodes` es al revés.
+    for (const ref of refs.inputNodes ?? [])
+        assertPar((0, output_node_dto_1.normalizeNodeType)(ref.nodeType), ownType);
+}
+function assertPar(origen, destino) {
+    const uiOrigen = node_types_1.NODE_UI[origen];
+    const uiDestino = node_types_1.NODE_UI[destino];
+    if (!uiOrigen || !uiDestino)
+        return;
+    if (uiOrigen.toNodes !== true) {
+        throw new common_1.BadRequestException(`A ${origen} node has no output — nothing can start from it`);
+    }
+    if (uiDestino.fromNodes !== true) {
+        throw new common_1.BadRequestException(`A ${destino} node has no input — it can only start a flow`);
+    }
+}
+/**
+ * Validate that all target nodes belong to the same workspace as the source node.
+ * Throws BadRequestException if any cross-workspace connection is detected.
+ *
+ * This is the ONLY backend connection logic. The frontend owns connection
+ * creation/deletion — it updates both sides (source.outputNodes + target.inputNodes).
+ * The backend just saves what it receives and validates workspace boundaries.
+ */
+async function validateConnectionWorkspaces(connection, sourceWorkspaceId, nodes) {
+    if (!sourceWorkspaceId)
+        return;
+    const srcWsStr = sourceWorkspaceId.toString();
+    for (const node of nodes) {
+        const col = TYPE_TO_COLLECTION[node.nodeType];
+        if (!col)
+            continue;
+        const doc = await connection
+            .collection(col)
+            .findOne({ _id: new mongoose_1.Types.ObjectId(node.nodeId) }, { projection: { workspaceId: 1 } });
+        if (!doc)
+            continue;
+        const targetWs = doc.workspaceId?.toString() ?? null;
+        if (targetWs && targetWs !== srcWsStr) {
+            throw new common_1.BadRequestException(`Cannot connect nodes across workspaces (source workspace: ${srcWsStr}, target workspace: ${targetWs})`);
+        }
+    }
+}

package/dist/unique-name.d.ts

@@ -0,0 +1,6 @@
+import { Connection } from 'mongoose';
+/**
+ * Ensures no other node in the workspace already uses this name.
+ * Searches across ALL node collections (cross-type uniqueness).
+ */
+export declare function assertUniqueNodeName(connection: Connection, workspaceId: any, name: string, excludeId?: string): Promise<void>;

package/dist/unique-name.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertUniqueNodeName = assertUniqueNodeName;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("mongoose");
+const node_types_1 = require("@hostwebhook/node-types");
+const SKIP_TYPES = new Set(['stickyNote']);
+const MAX_NODE_NAME_LENGTH = 50;
+/**
+ * Ensures no other node in the workspace already uses this name.
+ * Searches across ALL node collections (cross-type uniqueness).
+ */
+async function assertUniqueNodeName(connection, workspaceId, name, excludeId) {
+    if (!name)
+        return;
+    if (name.length > MAX_NODE_NAME_LENGTH) {
+        throw new common_1.BadRequestException(`Node name must be ${MAX_NODE_NAME_LENGTH} characters or less (got ${name.length}).`);
+    }
+    const wsId = workspaceId ? new mongoose_1.Types.ObjectId(workspaceId) : null;
+    for (const [type, config] of Object.entries(node_types_1.NODE_DISPATCH)) {
+        if (SKIP_TYPES.has(type))
+            continue;
+        const col = connection.collection(config.collection);
+        const filter = { name, workspaceId: wsId };
+        if (excludeId)
+            filter._id = { $ne: new mongoose_1.Types.ObjectId(excludeId) };
+        const existing = await col.findOne(filter, { projection: { _id: 1 } });
+        if (existing) {
+            throw new common_1.ConflictException(`A node named "${name}" already exists in this workspace. Please choose a different name.`);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hostwebhook/node-sdk",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "El SDK de un nodo de HostWebhook: ciclo de vida, ejecución con iteración, reintentos, filtros y validación de esquema — lo que comparten la api y el futuro servicio de nodos",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",