@hostwebhook/node-sdk 0.2.0 → 0.4.0

package/dist/acceso-al-workspace.d.ts

@@ -0,0 +1,51 @@
+import { Connection, Types } from 'mongoose';
+/**
+ * Corta si `userId` no está en la lista del workspace al que pertenece el
+ * recurso.
+ *
+ * Las tres salidas por arriba son deliberadas y copian, una a una, las que ya
+ * tomaba el guardia — el objetivo es aplicar la MISMA regla en más sitios, no
+ * una regla nueva:
+ *
+ *   - sin workspace, no hay lista que aplicar (un nodo suelto);
+ *   - sin `userId` no hay contra qué comparar. Ojo con lo que ESO no es: una
+ *     API key SÍ trae identidad. Las dos rutas que la validan
+ *     —`api-key.strategy.ts` y `api-key-validator.service.ts`— cargan el
+ *     usuario dueño de la llave con `userModel.findById(apiKey.userId)`, así
+ *     que `req.user._id` viene puesto y la lista se aplica igual que en una
+ *     sesión. Esta salida cubre a un llamante interno sin usuario resuelto,
+ *     no a las API keys;
+ *   - lista vacía sigue significando «toda la organización».
+ *
+ * Y una que el guardia no tenía: si el workspace ya no existe, se deja pasar.
+ * El recurso se buscó con el `organizationId` de quien llama, así que es suyo;
+ * negarle su propio nodo porque el workspace se borró debajo sería romperlo
+ * por un dato que falta, no cerrar un agujero.
+ */
+export declare function asegurarAccesoAlWorkspace(connection: Connection, workspaceId: string | Types.ObjectId | null | undefined, userId: string | undefined): Promise<void>;
+/**
+ * Corta si el workspace no es de esta organización.
+ *
+ * Al crear un nodo, `workspaceId` llega del cuerpo y se escribía tal cual. El
+ * guardia tampoco lo frenaba: un id de OTRA organización no aparece en su
+ * consulta —que filtra por organización— y su regla para «no encontrado» es
+ * dejar contestar al manejador, para que un id equivocado siga dando 404 en
+ * vez de delatar su existencia con un 403. Sólo que el manejador tampoco
+ * miraba, así que el nodo acababa guardado apuntando al workspace de otro.
+ *
+ * Aquí «no encontrado» sí puede negar sin delatar nada: quien crea el nodo
+ * escribió ese id, y de un id que no es de su organización no aprende nada
+ * nuevo al recibir un 403.
+ */
+export declare function asegurarWorkspaceDeLaOrganizacion(connection: Connection, workspaceId: string | Types.ObjectId | null | undefined, orgId: string): Promise<void>;
+/**
+ * Los workspaces de la organización que este usuario puede ver.
+ *
+ * Devuelve `null` cuando NO hay nada que recortar —ningún workspace de la
+ * organización tiene lista, o no hay usuario resuelto—, y ese `null` importa: significa «no filtres», así que la consulta
+ * y su clave de caché salen exactamente como salían. Sin eso, una lectura
+ * filtrada por usuario compartiría entrada de caché con una sin filtrar y
+ * acabaría sirviéndole a alguien la vista de otro, que es un agujero peor que
+ * el que se está cerrando.
+ */
+export declare function workspacesVisibles(connection: Connection, orgId: string, userId: string | undefined): Promise<Types.ObjectId[] | null>;

package/dist/acceso-al-workspace.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asegurarAccesoAlWorkspace = asegurarAccesoAlWorkspace;
+exports.asegurarWorkspaceDeLaOrganizacion = asegurarWorkspaceDeLaOrganizacion;
+exports.workspacesVisibles = workspacesVisibles;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("mongoose");
+async function leerWorkspace(connection, workspaceId) {
+    if (!mongoose_1.Types.ObjectId.isValid(workspaceId))
+        return null;
+    return connection
+        .collection('workspaces')
+        .findOne({ _id: new mongoose_1.Types.ObjectId(workspaceId) }, { projection: { allowedUserIds: 1, organizationId: 1, name: 1 } });
+}
+/**
+ * Corta si `userId` no está en la lista del workspace al que pertenece el
+ * recurso.
+ *
+ * Las tres salidas por arriba son deliberadas y copian, una a una, las que ya
+ * tomaba el guardia — el objetivo es aplicar la MISMA regla en más sitios, no
+ * una regla nueva:
+ *
+ *   - sin workspace, no hay lista que aplicar (un nodo suelto);
+ *   - sin `userId` no hay contra qué comparar. Ojo con lo que ESO no es: una
+ *     API key SÍ trae identidad. Las dos rutas que la validan
+ *     —`api-key.strategy.ts` y `api-key-validator.service.ts`— cargan el
+ *     usuario dueño de la llave con `userModel.findById(apiKey.userId)`, así
+ *     que `req.user._id` viene puesto y la lista se aplica igual que en una
+ *     sesión. Esta salida cubre a un llamante interno sin usuario resuelto,
+ *     no a las API keys;
+ *   - lista vacía sigue significando «toda la organización».
+ *
+ * Y una que el guardia no tenía: si el workspace ya no existe, se deja pasar.
+ * El recurso se buscó con el `organizationId` de quien llama, así que es suyo;
+ * negarle su propio nodo porque el workspace se borró debajo sería romperlo
+ * por un dato que falta, no cerrar un agujero.
+ */
+async function asegurarAccesoAlWorkspace(connection, workspaceId, userId) {
+    if (!workspaceId || !userId)
+        return;
+    const workspace = await leerWorkspace(connection, workspaceId);
+    if (!workspace)
+        return;
+    const permitidos = workspace.allowedUserIds ?? [];
+    if (permitidos.length === 0)
+        return;
+    if (permitidos.some((id) => id.toString() === userId))
+        return;
+    throw new common_1.ForbiddenException('You do not have access to this workspace.');
+}
+/**
+ * Corta si el workspace no es de esta organización.
+ *
+ * Al crear un nodo, `workspaceId` llega del cuerpo y se escribía tal cual. El
+ * guardia tampoco lo frenaba: un id de OTRA organización no aparece en su
+ * consulta —que filtra por organización— y su regla para «no encontrado» es
+ * dejar contestar al manejador, para que un id equivocado siga dando 404 en
+ * vez de delatar su existencia con un 403. Sólo que el manejador tampoco
+ * miraba, así que el nodo acababa guardado apuntando al workspace de otro.
+ *
+ * Aquí «no encontrado» sí puede negar sin delatar nada: quien crea el nodo
+ * escribió ese id, y de un id que no es de su organización no aprende nada
+ * nuevo al recibir un 403.
+ */
+async function asegurarWorkspaceDeLaOrganizacion(connection, workspaceId, orgId) {
+    if (!workspaceId)
+        return;
+    const workspace = await leerWorkspace(connection, workspaceId);
+    if (workspace && workspace.organizationId?.toString() === orgId)
+        return;
+    throw new common_1.ForbiddenException('That workspace does not belong to your organization.');
+}
+/**
+ * Los workspaces de la organización que este usuario puede ver.
+ *
+ * Devuelve `null` cuando NO hay nada que recortar —ningún workspace de la
+ * organización tiene lista, o no hay usuario resuelto—, y ese `null` importa: significa «no filtres», así que la consulta
+ * y su clave de caché salen exactamente como salían. Sin eso, una lectura
+ * filtrada por usuario compartiría entrada de caché con una sin filtrar y
+ * acabaría sirviéndole a alguien la vista de otro, que es un agujero peor que
+ * el que se está cerrando.
+ */
+async function workspacesVisibles(connection, orgId, userId) {
+    if (!userId)
+        return null;
+    const todos = await connection
+        .collection('workspaces')
+        .find({ organizationId: new mongoose_1.Types.ObjectId(orgId) }, { projection: { allowedUserIds: 1 } })
+        .toArray();
+    const restringidos = todos.filter((w) => (w.allowedUserIds ?? []).length > 0);
+    if (restringidos.length === 0)
+        return null;
+    const fuera = restringidos.filter((w) => !(w.allowedUserIds ?? []).some((id) => id.toString() === userId));
+    if (fuera.length === 0)
+        return null;
+    return todos
+        .filter((w) => !fuera.some((f) => f._id.toString() === w._id.toString()))
+        .map((w) => w._id);
+}

package/dist/base-node.service.d.ts

@@ -0,0 +1,120 @@
+import { Model, Connection, Types } from 'mongoose';
+/**
+ * Base service for node entities (HTTP Actions, Transform Nodes, Filter Nodes, Sheets Actions, etc.).
+ * Provides standard CRUD, saveLastPayload, findActiveByInput, and connection validation.
+ *
+ * Subclasses must define:
+ * - `entityName`: human-readable name for error messages (e.g. 'HTTP action')
+ * - `cascadeNodeType`: type key for cascadeCleanupNodeReferences (e.g. 'httpAction')
+ */
+export declare abstract class BaseNodeService<TDoc extends {
+    id?: string;
+    _id?: any;
+    workspaceId?: any;
+}> {
+    protected readonly model: Model<TDoc>;
+    protected readonly connection: Connection;
+    protected abstract readonly entityName: string;
+    protected abstract readonly cascadeNodeType: string;
+    constructor(model: Model<TDoc>, connection: Connection);
+    findAll(orgId: string, workspaceId?: string, visibles?: Types.ObjectId[] | null): Promise<TDoc[]>;
+    findOne(id: string, orgId: string): Promise<TDoc>;
+    /**
+     * Devuelve el `organizationId` del nodo, que ya se busca aquí dentro.
+     *
+     * Lo necesita quien quiera avisar por socket de que el payload cambió: sin
+     * esto tendría que repetir la misma consulta justo después. Los llamantes
+     * que no lo usen no se enteran — antes devolvía `void`.
+     */
+    saveLastPayload(id: string, payload: any, 
+    /**
+     * De dónde sale este payload.
+     *
+     * `example: true` sólo cuando el usuario promueve una PLANTILLA desde el
+     * Test push: datos inventados, con la forma exacta que el nodo va a
+     * despachar, para poder montar el flujo antes del primer evento real.
+     *
+     * ⚠️ Va FUERA del payload a propósito. Meter la marca dentro cambiaría la
+     * forma —y el sprint entero fue sobre que la plantilla sea la forma
+     * EXACTA—, así que quien copiara `{{payload.x}}` desde ahí acabaría con
+     * una ruta que no existe en la entrega de verdad.
+     */
+    meta?: {
+        example?: boolean;
+    }): Promise<{
+        organizationId: string;
+    } | undefined>;
+    remove(id: string, orgId: string): Promise<void>;
+    /** Override for custom cascade cleanup (e.g. router rules). Default is no-op. */
+    protected onCascadeDelete(_id: string): Promise<void>;
+    /** Sugar for the one lookup event-pipeline does often enough to name. */
+    findActiveByInputWebhook(webhookId: string): Promise<TDoc[]>;
+    /** Find active nodes where the given node is an input source */
+    findActiveByInput(nodeType: string, nodeId: string): Promise<TDoc[]>;
+    /**
+     * Standard create: assertUniqueNodeName → model.create → normalizeAndValidateConnections.
+     * Pass node-specific fields via `fields` — userId, orgId, workspaceId, inputNodes,
+     * outputNodes, isActive, and name are handled automatically.
+     */
+    protected createNode(dto: {
+        name?: string;
+        isActive?: boolean;
+        inputNodes?: any[];
+        outputNodes?: any[];
+        workspaceId?: string;
+        [key: string]: any;
+    }, userId: string, orgId: string, extraFields?: Record<string, any>): Promise<TDoc>;
+    /**
+     * Normalize inputNodes/outputNodes and validate the structural rules.
+     *
+     * Tres reglas. Dos son sobre la forma del grafo y necesitan ids —no se puede
+     * cruzar de workspace, y un nodo no se conecta a sí mismo—, y por eso viven
+     * aquí y no en el registro.
+     *
+     * La tercera sí es de tipos. Aquí ponía que la compatibilidad «es cosa del
+     * registro y se comprueba en el lienzo», y eso sólo vale si el lienzo es el
+     * único que escribe. No lo es: `/agent-context` le explica a un agente que
+     * meta las referencias a mano, y cualquier cliente con la clave puede. Lo
+     * que entra por ahí no falla, desaparece — ver `assertConnectableTypes`.
+     */
+    protected normalizeAndValidateConnections(dto: {
+        inputNodes?: any[];
+        outputNodes?: any[];
+    }, workspaceId: any, selfId?: any): Promise<void>;
+    /** Build update payload with normalized nodes */
+    protected buildUpdatePayload(dto: Record<string, any>): Record<string, any>;
+    /**
+     * Walk the entity's schema and convert any field declared as
+     * `Types.ObjectId` (or `[Types.ObjectId]`) from a string back to a
+     * proper ObjectId before the value enters a `findOneAndUpdate` $set.
+     *
+     * **Why this exists:** Mongoose does NOT auto-cast nested $set paths to
+     * the schema's declared types — the cast only fires for full-document
+     * `save()` and `Document.set()`. So a dashboard PATCH that lands a
+     * `credentialId: "69fe70…"` string in the dto would persist a String
+     * even though the schema says `Types.ObjectId`. That's invisible to
+     * `_id`-keyed lookups (Mongoose casts query filters), but breaks any
+     * downstream query using `field: { $in: [ObjectId(…)] }` because
+     * MongoDB is strict-typed: String !== ObjectId.
+     *
+     * The Slack-trigger `processSlackCommand` was the canary: it routes
+     * inbound pushes by `team_id → credentials → triggers $in [ObjectId]`
+     * and silently dropped every `/joke` invocation as `no-trigger-opted-in`
+     * even though the toggle was correctly true on the entity. Fix landed
+     * 2026-05-09 — see `feedback_basenode_objectid_cast.md` for the full
+     * forensics. Lifting the cast here means every node service inherits
+     * the protection without repeating per-subclass logic.
+     *
+     * Schema-driven so adding a new ObjectId field on any entity
+     * (including Array<ObjectId> like `[{type: ObjectId, ref: 'Foo'}]`)
+     * gets covered automatically — no maintenance needed.
+     *
+     * Skips `_id` (Mongoose handles it explicitly in query casting),
+     * skips `null`/`undefined` (preserves "clear the relationship"
+     * semantics), skips non-hex strings (throwing here would mask
+     * real validation errors).
+     */
+    private castSchemaObjectIdFields;
+    /** Standard update with node normalization and workspace validation */
+    update(id: string, dto: Record<string, any>, orgId: string): Promise<TDoc>;
+}