@hostwebhook/node-sdk 0.1.0

package/dist/node-executors.js

@@ -0,0 +1,555 @@
+"use strict";
+/**
+ * Shared node execution functions.
+ *
+ * Both pipeline-run.service.ts (Run Pipeline / test) and event-pipeline.service.ts
+ * (real events) call these functions so that "how to execute node type X" lives in
+ * exactly ONE place.  Callers still own Delivery records, child events, telemetry,
+ * and output-routing — only core execution logic is here.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HANDLERLESS_NODE_TYPES = void 0;
+exports.executeFilter = executeFilter;
+exports.executeTransform = executeTransform;
+exports.executeHttpAction = executeHttpAction;
+exports.executeEmailAction = executeEmailAction;
+exports.executeSheetsAction = executeSheetsAction;
+exports.executeDriveAction = executeDriveAction;
+exports.executeVectorStoreNode = executeVectorStoreNode;
+exports.executeFileTransformNode = executeFileTransformNode;
+exports.executePostgresAction = executePostgresAction;
+exports.executeCalendarAction = executeCalendarAction;
+exports.executeDocsAction = executeDocsAction;
+exports.executeMarkdownNode = executeMarkdownNode;
+exports.executeAiNode = executeAiNode;
+exports.executeMongoAction = executeMongoAction;
+exports.executeAggregator = executeAggregator;
+exports.executeCache = executeCache;
+exports.executeRateLimiter = executeRateLimiter;
+exports.executeConditional = executeConditional;
+exports.executeSchemaValidator = executeSchemaValidator;
+exports.executeNotificationAction = executeNotificationAction;
+exports.executeSplit = executeSplit;
+exports.executeCode = executeCode;
+exports.executeLoopFanOut = executeLoopFanOut;
+exports.isHandlerless = isHandlerless;
+const common_1 = require("@nestjs/common");
+const template_engine_1 = require("@hostwebhook/template-engine");
+const schemaLogger = new common_1.Logger('SchemaValidator');
+const filterLogger = new common_1.Logger('Filter');
+const conditionalLogger = new common_1.Logger('Conditional');
+const filter_utils_1 = require("./filter-utils");
+const schema_validator_utils_1 = require("./schema-validator-utils");
+const try_parse_1 = require("./try-parse");
+const code_runner_1 = require("./code-runner");
+function executeFilter(entity, payload, context) {
+    const filterCount = (entity.filters ?? []).filter((f) => f.enabled !== false).length;
+    const meta = payload._meta;
+    filterLogger.log(`"${entity.name}" evaluating — ${filterCount} active filters, mode=${entity.filterMode}, iterable=${!!meta?.iterable}${meta?.count ? `, ${meta.count} items` : ''}`);
+    const filterOpts = context?.workspacePayloads
+        ? { workspacePayloads: context.workspacePayloads }
+        : undefined;
+    const start = Date.now();
+    let result;
+    try {
+        result = (0, filter_utils_1.evaluateFiltersIterable)(entity.filters, payload, entity.filterMode, entity.outputAsSingle, filterOpts);
+    }
+    catch (err) {
+        const ms = Date.now() - start;
+        common_1.Logger.error(`[Filter] "${entity.name}" CRASHED after ${ms}ms: ${err instanceof Error ? err.message : err}`, 'NodeExecutors');
+        return {
+            statusCode: 500,
+            responseBody: JSON.stringify({
+                error: err instanceof Error ? err.message : 'Filter evaluation failed',
+            }),
+            latencyMs: ms,
+            outputPayload: payload,
+            passed: false,
+            totalItems: 0,
+            passedItems: 0,
+        };
+    }
+    const { passed, resultPayload, totalItems, passedItems } = result;
+    const ms = Date.now() - start;
+    filterLogger.log(`"${entity.name}" ${passed ? 'PASSED' : 'BLOCKED'} — ${passedItems}/${totalItems} items in ${ms}ms`);
+    return {
+        statusCode: passed ? 200 : 403,
+        responseBody: JSON.stringify({
+            passed,
+            totalItems,
+            passedItems,
+            payload: resultPayload,
+        }),
+        latencyMs: ms,
+        outputPayload: resultPayload,
+        passed,
+        totalItems,
+        passedItems,
+    };
+}
+async function executeTransform(svc, entity, payload, context) {
+    return svc.executeSingle(entity, payload, {
+        headers: context?.headers,
+        meta: context?.eventMeta,
+        workspacePayloads: context?.workspacePayloads,
+    });
+}
+async function executeHttpAction(svc, entity, payload, context) {
+    return svc.executeSingle(entity, payload, {
+        eventMeta: context?.eventMeta,
+        workspacePayloads: context?.workspacePayloads,
+    });
+}
+async function executeEmailAction(svc, entity, payload) {
+    return svc.executeSingle(entity, payload);
+}
+async function executeSheetsAction(svc, entity, payload, context) {
+    const start = Date.now();
+    const result = await svc.executeForEvent(entity, payload, {
+        workspacePayloads: context?.workspacePayloads,
+    });
+    const statusCode = result?.statusCode ?? (result?.success ? 200 : 500);
+    const responseBody = typeof result?.responseBody === 'string'
+        ? result.responseBody
+        : JSON.stringify(result ?? {});
+    return {
+        statusCode,
+        responseBody,
+        latencyMs: result?.latencyMs ?? Date.now() - start,
+    };
+}
+async function executeDriveAction(svc, entity, payload, context) {
+    const start = Date.now();
+    const result = await svc.executeForEvent(entity, payload, {
+        workspacePayloads: context?.workspacePayloads,
+        eventMeta: context?.eventMeta,
+    });
+    const statusCode = result?.statusCode ?? (result?.success ? 200 : 500);
+    const responseBody = typeof result?.responseBody === 'string'
+        ? result.responseBody
+        : JSON.stringify(result ?? {});
+    return {
+        statusCode,
+        responseBody,
+        latencyMs: result?.latencyMs ?? Date.now() - start,
+    };
+}
+async function executeVectorStoreNode(svc, entity, payload, context) {
+    const start = Date.now();
+    // Wrapped-payload shape: the service builds ctx via { ...payload, meta }
+    // and renders templates against ctx.payload, so the iterated item must
+    // sit under `payload` — passing raw payload here would break {{payload.X}}.
+    const result = await svc.executeForEvent(entity, {
+        payload,
+        workspacePayloads: context?.workspacePayloads,
+        eventMeta: context?.eventMeta,
+    });
+    const statusCode = result?.statusCode ?? (result?.success ? 200 : 500);
+    const responseBody = typeof result?.responseBody === 'string'
+        ? result.responseBody
+        : JSON.stringify(result ?? {});
+    return {
+        statusCode,
+        responseBody,
+        latencyMs: result?.latencyMs ?? Date.now() - start,
+    };
+}
+async function executeFileTransformNode(svc, entity, payload, context) {
+    const start = Date.now();
+    const result = await svc.executeForEvent(entity, payload, {
+        workspacePayloads: context?.workspacePayloads,
+    });
+    const statusCode = result?.statusCode ?? (result?.success ? 200 : 500);
+    const responseBody = typeof result?.responseBody === 'string'
+        ? result.responseBody
+        : JSON.stringify(result ?? {});
+    return {
+        statusCode,
+        responseBody,
+        latencyMs: result?.latencyMs ?? Date.now() - start,
+    };
+}
+async function executePostgresAction(svc, entity, payload, context) {
+    const start = Date.now();
+    // Wrapped-payload shape — see executeVectorStoreNode for rationale.
+    const result = await svc.executeForEvent(entity, {
+        payload,
+        workspacePayloads: context?.workspacePayloads,
+        eventMeta: context?.eventMeta,
+    });
+    const statusCode = result?.statusCode ?? (result?.success ? 200 : 500);
+    const responseBody = typeof result?.responseBody === 'string'
+        ? result.responseBody
+        : JSON.stringify(result ?? {});
+    return {
+        statusCode,
+        responseBody,
+        latencyMs: result?.latencyMs ?? Date.now() - start,
+    };
+}
+async function executeCalendarAction(svc, entity, payload, context) {
+    const start = Date.now();
+    const result = await svc.executeForEvent(entity, payload, {
+        workspacePayloads: context?.workspacePayloads,
+    });
+    const statusCode = result?.statusCode ?? (result?.success ? 200 : 500);
+    const responseBody = typeof result?.responseBody === 'string'
+        ? result.responseBody
+        : JSON.stringify(result ?? {});
+    return {
+        statusCode,
+        responseBody,
+        latencyMs: result?.latencyMs ?? Date.now() - start,
+    };
+}
+async function executeDocsAction(svc, entity, payload, context) {
+    const start = Date.now();
+    const result = await svc.executeForEvent(entity, payload, {
+        workspacePayloads: context?.workspacePayloads,
+    });
+    const statusCode = result?.statusCode ?? (result?.success ? 200 : 500);
+    const responseBody = typeof result?.responseBody === 'string'
+        ? result.responseBody
+        : JSON.stringify(result ?? {});
+    return {
+        statusCode,
+        responseBody,
+        latencyMs: result?.latencyMs ?? Date.now() - start,
+    };
+}
+async function executeMarkdownNode(svc, entity, payload, context) {
+    const start = Date.now();
+    const result = await svc.executeForEvent(entity, payload, {
+        workspacePayloads: context?.workspacePayloads,
+    });
+    const statusCode = result?.statusCode ?? (result?.success ? 200 : 500);
+    const responseBody = typeof result?.responseBody === 'string'
+        ? result.responseBody
+        : JSON.stringify(result ?? {});
+    return {
+        statusCode,
+        responseBody,
+        latencyMs: result?.latencyMs ?? Date.now() - start,
+    };
+}
+async function executeAiNode(svc, entity, payload, context) {
+    const start = Date.now();
+    const result = await svc.executeForEvent(entity, payload, {
+        workspacePayloads: context?.workspacePayloads,
+        eventMeta: context?.eventMeta,
+    });
+    const statusCode = result?.statusCode ?? (result?.success ? 200 : 500);
+    const responseBody = typeof result?.responseBody === 'string'
+        ? result.responseBody
+        : JSON.stringify(result ?? {});
+    return {
+        statusCode,
+        responseBody,
+        latencyMs: result?.latencyMs ?? Date.now() - start,
+    };
+}
+async function executeMongoAction(svc, entity, payload, context) {
+    const res = await svc.executeForEvent(entity, {
+        payload,
+        workspacePayloads: context?.workspacePayloads,
+    });
+    return {
+        statusCode: 200,
+        responseBody: JSON.stringify(res.result ?? {}),
+        latencyMs: res.latencyMs,
+        outputPayload: res.result ?? {},
+    };
+}
+async function executeAggregator(svc, entity, payload) {
+    return svc.processBatchPayload(entity, payload);
+}
+function executeCache(svc, entity, payload) {
+    const start = Date.now();
+    const { action, outputPayload } = svc.processEvent(entity, payload);
+    return {
+        statusCode: action === 'blocked' ? 304 : 200,
+        responseBody: JSON.stringify({ action, payload: outputPayload }),
+        latencyMs: Date.now() - start,
+        outputPayload: outputPayload ?? undefined,
+    };
+}
+function executeRateLimiter(svc, entity) {
+    const start = Date.now();
+    const { allowed, delayMs } = svc.checkRate(entity);
+    return {
+        statusCode: allowed ? 200 : 429,
+        responseBody: JSON.stringify({ allowed, delayMs }),
+        latencyMs: Date.now() - start,
+    };
+}
+function executeConditional(entity, payload, context) {
+    const start = Date.now();
+    const meta = payload?._meta;
+    conditionalLogger.log(`"${entity.name}" _meta=${JSON.stringify(meta)} iterateField=${meta?.iterateField} items=${Array.isArray(payload?.[meta?.iterateField]) ? payload[meta.iterateField].length : 'N/A'}`);
+    for (const branch of entity.branches ?? []) {
+        conditionalLogger.debug(`"${entity.name}" branch="${branch.name}" filters=${JSON.stringify(branch.filters)}`);
+    }
+    const filterOpts = context?.workspacePayloads
+        ? { workspacePayloads: context.workspacePayloads }
+        : undefined;
+    let matched = null;
+    for (const branch of entity.branches ?? []) {
+        if ((branch.filters ?? []).length === 0)
+            continue;
+        const { passed } = (0, filter_utils_1.evaluateFiltersIterable)(branch.filters, payload, branch.filterMode ?? 'and', false, filterOpts);
+        conditionalLogger.log(`"${entity.name}" branch="${branch.name}" passed=${passed}`);
+        if (passed) {
+            matched = branch;
+            break;
+        }
+    }
+    return {
+        statusCode: 200,
+        responseBody: JSON.stringify({ matched: matched?.name ?? null }),
+        latencyMs: Date.now() - start,
+        outputPayload: payload,
+        matchedBranch: matched,
+    };
+}
+function executeSchemaValidator(entity, payload) {
+    const start = Date.now();
+    const result = (0, schema_validator_utils_1.validateSchema)(entity.fields, payload, entity.strictMode);
+    const latencyMs = Date.now() - start;
+    if (result.valid) {
+        schemaLogger.log(`Schema "${entity.name}" VALID — ${entity.fields?.length ?? 0} fields${entity.strictMode ? ' (strict)' : ''} (${latencyMs}ms)`);
+    }
+    else {
+        schemaLogger.warn(`Schema "${entity.name}" INVALID — ${result.errors.length} error(s): ${result.errors.map((e) => `${e.path}: ${e.message}`).join(', ')} (${latencyMs}ms)`);
+    }
+    return {
+        statusCode: 200, // Always 200 — validity is in responseBody.valid, routing via getOutputNodes
+        responseBody: JSON.stringify(result),
+        latencyMs,
+        outputPayload: payload,
+    };
+}
+async function executeNotificationAction(svc, entity, payload, notifCtx) {
+    const start = Date.now();
+    const result = await svc.sendForEvent(entity, notifCtx ?? {}, payload);
+    return {
+        statusCode: result.success ? 200 : (result.statusCode ?? 500),
+        responseBody: JSON.stringify(result),
+        latencyMs: Date.now() - start,
+    };
+}
+/** Resolve a dot-notation path (e.g. "data.orders") from an object */
+function getNestedValue(obj, path) {
+    let current = obj;
+    for (const key of path.split('.')) {
+        if (current == null || typeof current !== 'object')
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+// resolveFieldPath replaced by resolveFieldPath from @hostwebhook/template-engine
+function executeSplit(entity, payload) {
+    const start = Date.now();
+    // Unwrap iterable payload — split operates on the inner data, not the wrapper
+    let effective = payload;
+    const meta = payload._meta;
+    if (meta?.iterable && meta.iterateField) {
+        const arr = payload[meta.iterateField];
+        if (Array.isArray(arr) && arr.length > 0) {
+            effective =
+                typeof arr[0] === 'object' && arr[0] !== null
+                    ? { ...arr[0] }
+                    : { value: arr[0] };
+        }
+    }
+    const outputs = [];
+    const assignedFields = new Set();
+    for (const output of entity.outputs ?? []) {
+        const field = (0, template_engine_1.resolveFieldPath)(output.field);
+        const value = getNestedValue(effective, field);
+        assignedFields.add(field.split('.')[0]);
+        outputs.push({ name: output.name, field: output.field, payload: value });
+    }
+    // Build remainder: top-level fields not assigned to any output
+    const remainderEntries = Object.entries(effective).filter(([key]) => key !== '_meta' && !assignedFields.has(key));
+    const remainder = remainderEntries.length > 0 ? Object.fromEntries(remainderEntries) : null;
+    return {
+        statusCode: 200,
+        responseBody: JSON.stringify({ splitOutputs: outputs, remainder }),
+        latencyMs: Date.now() - start,
+        outputPayload: effective,
+        splitOutputs: outputs,
+        remainder,
+    };
+}
+/**
+ * Ejecutar el nodo de código.
+ *
+ * ## Por qué esto ya no corre aquí dentro
+ *
+ * Antes iba a `renderTemplate(..., { mode: 'code' })`, o sea a `node:vm` con
+ * una lista negra sobre el texto fuente. `vm` no es una frontera y una lista
+ * de expresiones regulares sobre el fuente no es un control: la concatenación
+ * de cadenas la cruza sin despeinarse, y el contexto se sembraba con los
+ * intrínsecos del propio realm, así que `Math.constructor.constructor` era el
+ * `Function` de la casa.
+ *
+ * Con eso, un `return Math["constr"+"uctor"]…("return this")()["proc"+"ess"].env`
+ * devolvía `process.env` — es decir `MONGO_URI` y `API_SECRET`, que es la
+ * entrada del PBKDF2 con el que se descifran las credenciales guardadas de
+ * TODOS los inquilinos. Y cambiando la pieza final, ejecución de comandos.
+ *
+ * Ahora corre en el mismo hijo desechable que los scripts pre-request: entorno
+ * vacío, sin ficheros ni spawn donde el runtime lo soporte, muerto tras cada
+ * ejecución. Salirse del vm sigue siendo fácil; lo que cambia es que ya no
+ * lleva a ningún sitio.
+ *
+ * El contrato hacia fuera no cambia — mismos códigos, mismo `outputPayload`,
+ * mismos logs— salvo que ahora es asíncrono, que es lo que cuesta un proceso.
+ */
+async function executeCode(entity, payload, workspacePayloads) {
+    const start = Date.now();
+    const timeout = entity.timeout || 5000;
+    let output;
+    let logs;
+    try {
+        const r = await (0, code_runner_1.runTenantCode)(entity.code, { payload, headers: {}, meta: {}, workspacePayloads }, timeout);
+        output = r.output;
+        logs = r.logs;
+    }
+    catch (err) {
+        // Los logs que alcanzó a emitir antes de reventar son justo los que el
+        // usuario necesita para entender por qué. `CodeNodeError` los trae del
+        // worker; el hijo los cuelga del Error igual, así que este camino no
+        // necesita saber cuál de los dos corrió.
+        const conLogs = err;
+        return {
+            statusCode: 500,
+            responseBody: JSON.stringify({
+                error: conLogs?.message ?? String(err),
+                logs: conLogs?.logs ?? [],
+            }),
+            latencyMs: Date.now() - start,
+            logs: conLogs?.logs ?? [],
+        };
+    }
+    if (output == null) {
+        return {
+            statusCode: 204,
+            responseBody: JSON.stringify({ blocked: true, logs }),
+            latencyMs: Date.now() - start,
+            outputPayload: undefined,
+            logs,
+        };
+    }
+    const outputPayload = typeof output === 'object' && !Array.isArray(output)
+        ? output
+        : { result: output };
+    return {
+        statusCode: 200,
+        responseBody: JSON.stringify(outputPayload),
+        latencyMs: Date.now() - start,
+        outputPayload,
+        logs,
+    };
+}
+/** If the executor didn't set outputPayload, try to parse it from responseBody. */
+function ensureOutputPayload(result) {
+    if (result.outputPayload !== undefined)
+        return result;
+    // tryParseJson rather than tryParseJsonObject: an array body is a legitimate
+    // payload here, and the object-only helper would quietly drop it.
+    const parsed = (0, try_parse_1.tryParseJson)(result.responseBody);
+    if (typeof parsed === 'object' && parsed !== null) {
+        return { ...result, outputPayload: parsed };
+    }
+    return result;
+}
+/**
+ * Loop fan-out: turn the iterable field into one payload per item, each
+ * stamped with its position. The loop node owns its own iteration and
+ * LoopState, which is why it has no registered handler — the caller drives
+ * the iterations from this list.
+ */
+function executeLoopFanOut(entity, payload) {
+    // Extract iterable array — use _meta.iterateField or entity.iterableField
+    const loopMeta = payload?._meta;
+    const loopField = loopMeta?.iterable && loopMeta.iterateField
+        ? loopMeta.iterateField
+        : (entity.iterableField ?? '').trim() || '';
+    const loopItems = loopField ? payload?.[loopField] : payload;
+    common_1.Logger.debug(`[Loop] loopField="${loopField}", iterableField="${entity.iterableField}", payloadKeys=${Object.keys(payload)}, isArray=${Array.isArray(loopItems)}`, 'NodeExecutors');
+    if (!Array.isArray(loopItems)) {
+        return {
+            statusCode: 400,
+            responseBody: JSON.stringify({
+                error: `Field "${loopField || 'payload'}" is not an array`,
+            }),
+            latencyMs: 0,
+        };
+    }
+    // Build per-iteration payloads
+    const perIteration = loopItems.map((item, i) => {
+        const base = typeof item === 'object' && item !== null && !Array.isArray(item)
+            ? { ...item }
+            : { value: item };
+        return {
+            _meta: {
+                loopIndex: i,
+                loopTotal: loopItems.length,
+                isFirst: i === 0,
+                isLast: i === loopItems.length - 1,
+            },
+            ...base,
+        };
+    });
+    const outputPayload = {
+        _meta: { iterable: true, iterateField: 'items', count: loopItems.length },
+        items: perIteration,
+    };
+    return {
+        statusCode: 200,
+        responseBody: JSON.stringify(outputPayload),
+        latencyMs: 0,
+        outputPayload,
+    };
+}
+/**
+ * The seven node types that do NOT call `registerNodeHandler`, and what
+ * Run Pipeline does for each. Everything else executes through its
+ * registered handler — the same object prod runs — so the two cycles
+ * cannot drift.
+ *
+ * This list is deliberately explicit rather than a `default:` arm. A
+ * `default` silently absorbs any node type nobody wired up, which is
+ * exactly how the Limit node came to return 15 of 15 items in Run
+ * Pipeline while prod limited correctly. A missing entry here is a
+ * loud `undefined`, and `architecture.spec.ts` asserts the set matches
+ * the types that actually lack a handler.
+ */
+exports.HANDLERLESS_NODE_TYPES = {
+    /** Annotation — never executes. */
+    stickyNote: { run: 'passthrough', telemetrySource: 'sticky_note' },
+    // Sources. They execute by being *called* (an HTTP request arrives, a cron
+    // fires, a call connects), not by being dispatched to, so the payload they
+    // hand downstream is the payload they received.
+    webhook: { run: 'passthrough', telemetrySource: 'entry_webhook' },
+    scheduledWorkflow: {
+        run: 'passthrough',
+        telemetrySource: 'scheduled_webhook',
+    },
+    voiceAgent: { run: 'passthrough', telemetrySource: 'voice_agent' },
+    /** Queue-based: prod enqueues, Run Pipeline has nothing to wait on. */
+    delay: { run: 'passthrough', telemetrySource: 'delay_node' },
+    /** Waits on a human. Run Pipeline cannot block on a click. */
+    approval: { run: 'passthrough', telemetrySource: 'approval_node' },
+    /** pipeline-run.service collects the inputs itself and merges them. */
+    merge: { run: 'passthrough', telemetrySource: 'merge_node' },
+    /** Owns its own iteration + LoopState; pipeline-run drives it directly. */
+    loop: { run: 'custom', telemetrySource: 'loop_node' },
+    /** Counter lives in Redis; prod dispatches it from event-pipeline. */
+    rateLimiter: { run: 'custom', telemetrySource: 'rate_limiter_node' },
+};
+function isHandlerless(nodeType) {
+    return nodeType in exports.HANDLERLESS_NODE_TYPES;
+}