@aiteza/n8n-nodes-aiteza 0.2.2 → 0.3.1

package/dist/nodes/Aiteza/AitezaProgress.node.d.ts

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class AitezaProgress implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Aiteza/AitezaProgress.node.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AitezaProgress = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+// ---------------------------------------------------------------------------
+// Helpers for reading the AITEZA Trigger's webhook body
+// ---------------------------------------------------------------------------
+function isAitezaTriggerType(type) {
+    return typeof type === 'string' && /(^|\.)aitezaTrigger$/i.test(type);
+}
+function findAitezaTriggerParentName(ef) {
+    try {
+        const parents = ef.getParentNodes(ef.getNode().name);
+        return parents.find((p) => isAitezaTriggerType(p.type) && !p.disabled)?.name;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Look up a value first on the current input item, then on the original
+ * AITEZA Trigger output (so intermediate Set/IF/SplitOut nodes that strip
+ * fields don't break callbacks).
+ */
+function readFromTrigger(ef, itemIndex, picker) {
+    try {
+        const items = ef.getInputData();
+        const direct = picker(items[itemIndex]?.json);
+        if (direct !== undefined && direct !== null && direct !== '')
+            return direct;
+    }
+    catch {
+        // ignore
+    }
+    const triggerName = findAitezaTriggerParentName(ef);
+    if (!triggerName)
+        return undefined;
+    try {
+        const proxy = ef.getWorkflowDataProxy(itemIndex);
+        const triggerItems = proxy.$items(triggerName) ?? [];
+        for (const item of triggerItems) {
+            const value = picker(item?.json);
+            if (value !== undefined && value !== null && value !== '')
+                return value;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}
+function readTriggerBodyField(ef, itemIndex, field) {
+    return readFromTrigger(ef, itemIndex, (json) => {
+        const body = json?.body ?? {};
+        const fromBody = body[field];
+        if (fromBody !== undefined && fromBody !== null && fromBody !== '') {
+            return String(fromBody);
+        }
+        // Also allow callers to put the value at the top level of an item
+        // (e.g. after a Set node).
+        const fromTop = json?.[field];
+        if (fromTop !== undefined && fromTop !== null && fromTop !== '') {
+            return String(fromTop);
+        }
+        return undefined;
+    });
+}
+// ---------------------------------------------------------------------------
+// Node
+// ---------------------------------------------------------------------------
+class AitezaProgress {
+    description = {
+        displayName: 'AITEZA Progress',
+        name: 'aitezaProgress',
+        icon: 'file:aiteza.svg',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["step"]}}',
+        description: 'Reports workflow progress back to the AITEZA backend that triggered ' +
+            'this workflow. Reads callbackUrl / executionId / callbackToken from ' +
+            'the upstream AITEZA Trigger webhook body and POSTs to ' +
+            '{callbackUrl}/api/internal/workflow/{executionId}/progress.',
+        defaults: { name: 'AITEZA Progress' },
+        inputs: ['main'],
+        outputs: ['main'],
+        credentials: [],
+        properties: [
+            {
+                displayName: 'Step',
+                name: 'step',
+                type: 'string',
+                default: '',
+                required: true,
+                placeholder: 'Fetching files',
+                description: 'Short, human-readable label for the current step',
+            },
+            {
+                displayName: 'Step Index',
+                name: 'stepIndex',
+                type: 'number',
+                default: 1,
+                typeOptions: { minValue: 0 },
+                description: '1-based index of the current step',
+            },
+            {
+                displayName: 'Total Steps',
+                name: 'totalSteps',
+                type: 'number',
+                default: 1,
+                typeOptions: { minValue: 0 },
+                description: 'Total number of steps in this workflow',
+            },
+            {
+                displayName: 'Detail',
+                name: 'detail',
+                type: 'string',
+                default: '',
+                typeOptions: { rows: 2 },
+                description: 'Optional longer description of what is happening right now',
+            },
+            {
+                displayName: 'Additional Fields (JSON)',
+                name: 'additionalFields',
+                type: 'json',
+                default: '',
+                placeholder: '{ "percent": 42 }',
+                description: 'Optional JSON object that will be merged into the progress payload (e.g. percent, items processed, etc.)',
+            },
+            {
+                displayName: 'Options',
+                name: 'options',
+                type: 'collection',
+                placeholder: 'Add Option',
+                default: {},
+                options: [
+                    {
+                        displayName: 'Callback URL Override',
+                        name: 'callbackUrlOverride',
+                        type: 'string',
+                        default: '',
+                        description: 'Override the callback URL from the AITEZA Trigger. Without trailing slash.',
+                    },
+                    {
+                        displayName: 'Execution ID Override',
+                        name: 'executionIdOverride',
+                        type: 'string',
+                        default: '',
+                        description: 'Override the execution ID from the AITEZA Trigger',
+                    },
+                    {
+                        displayName: 'Callback Token Override',
+                        name: 'callbackTokenOverride',
+                        type: 'string',
+                        typeOptions: { password: true },
+                        default: '',
+                        description: 'Override the callback token from the AITEZA Trigger',
+                    },
+                    {
+                        displayName: 'Timeout (ms)',
+                        name: 'timeout',
+                        type: 'number',
+                        default: 5000,
+                        typeOptions: { minValue: 100 },
+                    },
+                    {
+                        displayName: 'Fail Workflow on Error',
+                        name: 'failOnError',
+                        type: 'boolean',
+                        default: false,
+                        description: 'Whether to fail the workflow if the progress callback fails. Defaults to false so progress reports never break the main flow.',
+                    },
+                ],
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            const step = this.getNodeParameter('step', i);
+            const stepIndex = this.getNodeParameter('stepIndex', i, 0);
+            const totalSteps = this.getNodeParameter('totalSteps', i, 0);
+            const detail = this.getNodeParameter('detail', i, '');
+            const additionalFieldsRaw = this.getNodeParameter('additionalFields', i, '');
+            const options = this.getNodeParameter('options', i, {});
+            const callbackUrlOverride = options.callbackUrlOverride || '';
+            const executionIdOverride = options.executionIdOverride || '';
+            const callbackTokenOverride = options.callbackTokenOverride || '';
+            const timeout = options.timeout ?? 5000;
+            const failOnError = options.failOnError ?? false;
+            const callbackUrl = (callbackUrlOverride || readTriggerBodyField(this, i, 'callbackUrl') || '').replace(/\/+$/, '');
+            const executionId = executionIdOverride || readTriggerBodyField(this, i, 'executionId') || '';
+            const callbackToken = callbackTokenOverride || readTriggerBodyField(this, i, 'callbackToken') || '';
+            // Build payload
+            const payload = { step };
+            if (Number.isFinite(stepIndex) && stepIndex > 0)
+                payload.stepIndex = stepIndex;
+            if (Number.isFinite(totalSteps) && totalSteps > 0)
+                payload.totalSteps = totalSteps;
+            if (detail)
+                payload.detail = detail;
+            if (additionalFieldsRaw) {
+                let parsed;
+                if (typeof additionalFieldsRaw === 'string') {
+                    try {
+                        parsed = JSON.parse(additionalFieldsRaw);
+                    }
+                    catch (err) {
+                        if (failOnError) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `"Additional Fields" is not valid JSON: ${err.message}`, { itemIndex: i });
+                        }
+                    }
+                }
+                else if (typeof additionalFieldsRaw === 'object') {
+                    parsed = additionalFieldsRaw;
+                }
+                if (parsed && typeof parsed === 'object')
+                    Object.assign(payload, parsed);
+            }
+            const reportMeta = {
+                sent: false,
+                callbackUrl,
+                executionId,
+                payload,
+            };
+            if (!callbackUrl || !executionId) {
+                reportMeta.skipped = true;
+                reportMeta.reason = !callbackUrl
+                    ? 'No callbackUrl on AITEZA Trigger body'
+                    : 'No executionId on AITEZA Trigger body';
+                if (failOnError) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Cannot send progress: ${reportMeta.reason}`, { itemIndex: i });
+                }
+                returnData.push({
+                    json: { ...items[i].json, _progressReport: reportMeta },
+                    pairedItem: { item: i },
+                });
+                continue;
+            }
+            const requestOptions = {
+                method: 'POST',
+                url: `${callbackUrl}/api/internal/workflow/${encodeURIComponent(executionId)}/progress`,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(callbackToken ? { 'X-Callback-Token': callbackToken } : {}),
+                },
+                body: payload,
+                json: true,
+                timeout,
+            };
+            try {
+                await this.helpers.httpRequest(requestOptions);
+                reportMeta.sent = true;
+            }
+            catch (error) {
+                reportMeta.sent = false;
+                reportMeta.error =
+                    error?.message ?? error?.response?.statusText ?? 'Unknown error';
+                if (failOnError) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Progress callback failed: ${reportMeta.error}`, { itemIndex: i });
+                }
+            }
+            returnData.push({
+                json: { ...items[i].json, _progressReport: reportMeta },
+                pairedItem: { item: i },
+            });
+        }
+        return [returnData];
+    }
+}
+exports.AitezaProgress = AitezaProgress;

package/dist/nodes/Aiteza/AitezaTrigger.node.js

@@ -9,7 +9,8 @@ class AitezaTrigger {
         group: ['trigger'],
         version: 1,
         description: 'Starts the workflow when an AITEZA event is received via webhook. ' +
-            'Passes the caller\'s auth token (and optionally the AITEZA Base URL) to all downstream AITEZA nodes so they act on behalf of the triggering user.',
+            'Forwards the calling user\'s bearer token (from body.user.bearerToken) to downstream AITEZA nodes ' +
+            'so they act on behalf of the triggering user. Falls back to the request\'s Authorization header if no user token is present.',
         defaults: { name: 'AITEZA Trigger' },
         inputs: [],
         outputs: ['main'],
@@ -47,21 +48,18 @@ class AitezaTrigger {
                     {
                         name: 'Immediately',
                         value: 'onReceived',
-                        description: 'Respond immediately with 200 OK as soon as the webhook is received',
+                        description: 'Respond immediately with 200 OK as soon as the webhook is received. ' +
+                            'Use the "AITEZA Workflow Result" node at the end of your workflow to send results back.',
                     },
                     {
                         name: 'When Last Node Finishes',
                         value: 'lastNode',
                         description: 'Respond with data from the last node in the workflow',
                     },
-                    {
-                        name: 'Using \'Respond to Webhook\' Node',
-                        value: 'responseNode',
-                        description: 'Respond using the data from a downstream "Respond to Webhook" node',
-                    },
                 ],
-                default: 'lastNode',
-                description: 'When and how to respond to the webhook',
+                default: 'onReceived',
+                description: 'When and how to respond to the webhook. Use "Immediately" together with the ' +
+                    '"AITEZA Workflow Result" node to send results asynchronously.',
             },
             {
                 displayName: 'AITEZA Base URL',
@@ -77,8 +75,17 @@ class AitezaTrigger {
         const body = this.getBodyData();
         const headers = this.getHeaderData();
         const query = this.getQueryData();
+        // AITEZA places the calling user's bearer token inside the body (body.user.bearerToken)
+        // so that downstream nodes can act on behalf of the user. The request's own
+        // Authorization header is typically the service-account token used by AITEZA to
+        // call the webhook itself – not what we want for delegated calls.
+        const user = body?.user ?? {};
+        const userBearer = user.bearerToken ?? '';
         const authHeader = headers.authorization || headers.Authorization || '';
-        const authToken = authHeader.replace(/^Bearer\s+/i, '');
+        const headerToken = authHeader.replace(/^Bearer\s+/i, '');
+        // Prefer the user-context token. Fall back to the header token (e.g. when the
+        // webhook is called by something other than AITEZA).
+        const authToken = userBearer || headerToken;
         const baseUrl = this.getNodeParameter('baseUrl', '').replace(/\/+$/, '');
         const outputData = {
             body,
@@ -87,6 +94,10 @@ class AitezaTrigger {
         };
         if (authToken)
             outputData._authToken = authToken;
+        // Expose the service-account token separately in case a workflow explicitly
+        // needs to call AITEZA with elevated/service privileges.
+        if (headerToken && headerToken !== authToken)
+            outputData._serviceAuthToken = headerToken;
         if (baseUrl)
             outputData._baseUrl = baseUrl;
         return {

package/dist/nodes/Aiteza/AitezaWorkflowResult.node.d.ts

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class AitezaWorkflowResult implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Aiteza/AitezaWorkflowResult.node.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AitezaWorkflowResult = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+// ---------------------------------------------------------------------------
+// Helpers for reading the AITEZA Trigger's webhook body
+// ---------------------------------------------------------------------------
+function isAitezaTriggerType(type) {
+    return typeof type === 'string' && /(^|\.)aitezaTrigger$/i.test(type);
+}
+function findAitezaTriggerParentName(ef) {
+    try {
+        const parents = ef.getParentNodes(ef.getNode().name);
+        return parents.find((p) => isAitezaTriggerType(p.type) && !p.disabled)?.name;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Look up a value first on the current input item, then on the original
+ * AITEZA Trigger output (so intermediate Set/IF/SplitOut nodes that strip
+ * fields don't break callbacks).
+ */
+function readFromTrigger(ef, itemIndex, picker) {
+    try {
+        const items = ef.getInputData();
+        const direct = picker(items[itemIndex]?.json);
+        if (direct !== undefined && direct !== null && direct !== '')
+            return direct;
+    }
+    catch {
+        // ignore
+    }
+    const triggerName = findAitezaTriggerParentName(ef);
+    if (!triggerName)
+        return undefined;
+    try {
+        const proxy = ef.getWorkflowDataProxy(itemIndex);
+        const triggerItems = proxy.$items(triggerName) ?? [];
+        for (const item of triggerItems) {
+            const value = picker(item?.json);
+            if (value !== undefined && value !== null && value !== '')
+                return value;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}
+function readTriggerBodyField(ef, itemIndex, field) {
+    return readFromTrigger(ef, itemIndex, (json) => {
+        const body = json?.body ?? {};
+        const fromBody = body[field];
+        if (fromBody !== undefined && fromBody !== null && fromBody !== '') {
+            return String(fromBody);
+        }
+        const fromTop = json?.[field];
+        if (fromTop !== undefined && fromTop !== null && fromTop !== '') {
+            return String(fromTop);
+        }
+        return undefined;
+    });
+}
+// ---------------------------------------------------------------------------
+// Node
+// ---------------------------------------------------------------------------
+class AitezaWorkflowResult {
+    description = {
+        displayName: 'AITEZA Workflow Result',
+        name: 'aitezaWorkflowResult',
+        icon: 'file:aiteza.svg',
+        group: ['output'],
+        version: 1,
+        subtitle: 'Send result to AITEZA',
+        description: 'Sends the final workflow result back to the AITEZA backend. ' +
+            'Reads callbackUrl / executionId / callbackToken from the upstream ' +
+            'AITEZA Trigger webhook body and POSTs to ' +
+            '{callbackUrl}/api/internal/workflow/{executionId}/result. ' +
+            'Use this instead of "Respond to Webhook" which is not compatible ' +
+            'with custom trigger nodes.',
+        defaults: { name: 'AITEZA Workflow Result' },
+        inputs: ['main'],
+        outputs: ['main'],
+        credentials: [],
+        properties: [
+            {
+                displayName: 'Result Data',
+                name: 'resultData',
+                type: 'json',
+                default: '',
+                placeholder: '={{ $json }}',
+                description: 'The result payload to send back to AITEZA. Can be a JSON object or an expression that resolves to one. If empty, the entire input item JSON is sent.',
+            },
+            {
+                displayName: 'Status',
+                name: 'status',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Success',
+                        value: 'success',
+                    },
+                    {
+                        name: 'Error',
+                        value: 'error',
+                    },
+                ],
+                default: 'success',
+                description: 'The result status to report back to AITEZA',
+            },
+            {
+                displayName: 'Message',
+                name: 'message',
+                type: 'string',
+                default: '',
+                placeholder: 'Workflow completed successfully',
+                description: 'Optional human-readable message to include with the result',
+            },
+            {
+                displayName: 'Options',
+                name: 'options',
+                type: 'collection',
+                placeholder: 'Add Option',
+                default: {},
+                options: [
+                    {
+                        displayName: 'Callback URL Override',
+                        name: 'callbackUrlOverride',
+                        type: 'string',
+                        default: '',
+                        description: 'Override the callback URL from the AITEZA Trigger. Without trailing slash.',
+                    },
+                    {
+                        displayName: 'Execution ID Override',
+                        name: 'executionIdOverride',
+                        type: 'string',
+                        default: '',
+                        description: 'Override the execution ID from the AITEZA Trigger',
+                    },
+                    {
+                        displayName: 'Callback Token Override',
+                        name: 'callbackTokenOverride',
+                        type: 'string',
+                        typeOptions: { password: true },
+                        default: '',
+                        description: 'Override the callback token from the AITEZA Trigger',
+                    },
+                    {
+                        displayName: 'Timeout (ms)',
+                        name: 'timeout',
+                        type: 'number',
+                        default: 10000,
+                        typeOptions: { minValue: 100 },
+                    },
+                    {
+                        displayName: 'Fail Workflow on Error',
+                        name: 'failOnError',
+                        type: 'boolean',
+                        default: true,
+                        description: 'Whether to fail the workflow if the result callback fails. Defaults to true since the result is typically critical.',
+                    },
+                ],
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            const resultDataRaw = this.getNodeParameter('resultData', i, '');
+            const status = this.getNodeParameter('status', i, 'success');
+            const message = this.getNodeParameter('message', i, '');
+            const options = this.getNodeParameter('options', i, {});
+            const callbackUrlOverride = options.callbackUrlOverride || '';
+            const executionIdOverride = options.executionIdOverride || '';
+            const callbackTokenOverride = options.callbackTokenOverride || '';
+            const timeout = options.timeout ?? 10000;
+            const failOnError = options.failOnError ?? true;
+            const callbackUrl = (callbackUrlOverride || readTriggerBodyField(this, i, 'callbackUrl') || '').replace(/\/+$/, '');
+            const executionId = executionIdOverride || readTriggerBodyField(this, i, 'executionId') || '';
+            const callbackToken = callbackTokenOverride || readTriggerBodyField(this, i, 'callbackToken') || '';
+            // Build result payload
+            let resultPayload;
+            if (!resultDataRaw || (typeof resultDataRaw === 'string' && resultDataRaw.trim() === '')) {
+                // Default: send the entire input item JSON as the result data
+                resultPayload = { ...items[i].json };
+            }
+            else if (typeof resultDataRaw === 'string') {
+                try {
+                    resultPayload = JSON.parse(resultDataRaw);
+                }
+                catch (err) {
+                    if (failOnError) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `"Result Data" is not valid JSON: ${err.message}`, { itemIndex: i });
+                    }
+                    resultPayload = { raw: resultDataRaw };
+                }
+            }
+            else {
+                resultPayload = resultDataRaw;
+            }
+            const payload = {
+                status,
+                data: resultPayload,
+            };
+            if (message)
+                payload.message = message;
+            const reportMeta = {
+                sent: false,
+                callbackUrl,
+                executionId,
+                payload,
+            };
+            if (!callbackUrl || !executionId) {
+                reportMeta.skipped = true;
+                reportMeta.reason = !callbackUrl
+                    ? 'No callbackUrl on AITEZA Trigger body'
+                    : 'No executionId on AITEZA Trigger body';
+                if (failOnError) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Cannot send workflow result: ${reportMeta.reason}`, { itemIndex: i });
+                }
+                returnData.push({
+                    json: { ...items[i].json, _workflowResult: reportMeta },
+                    pairedItem: { item: i },
+                });
+                continue;
+            }
+            const requestOptions = {
+                method: 'POST',
+                url: `${callbackUrl}/api/internal/workflow/${encodeURIComponent(executionId)}/result`,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(callbackToken ? { 'X-Callback-Token': callbackToken } : {}),
+                },
+                body: payload,
+                json: true,
+                timeout,
+            };
+            try {
+                await this.helpers.httpRequest(requestOptions);
+                reportMeta.sent = true;
+            }
+            catch (error) {
+                reportMeta.sent = false;
+                reportMeta.error =
+                    error?.message ?? error?.response?.statusText ?? 'Unknown error';
+                if (failOnError) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Workflow result callback failed: ${reportMeta.error}`, { itemIndex: i });
+                }
+            }
+            returnData.push({
+                json: { ...items[i].json, _workflowResult: reportMeta },
+                pairedItem: { item: i },
+            });
+        }
+        return [returnData];
+    }
+}
+exports.AitezaWorkflowResult = AitezaWorkflowResult;

package/dist/nodes/Aiteza/GenericFunctions.d.ts

@@ -5,6 +5,12 @@ export interface AitezaAuthContext {
 }
 export declare function getUpstreamAuthToken(ef: IExecuteFunctions): string | undefined;
 export declare function getUpstreamBaseUrl(ef: IExecuteFunctions): string | undefined;
+/**
+ * Returns true when the token is a JWT with an `exp` claim that is in the past
+ * (with a small skew). Returns false when the token is not a parsable JWT or
+ * has no `exp` (we assume valid in that case – the server is the source of truth).
+ */
+export declare function isJwtExpired(token: string | undefined, skewSeconds?: number): boolean;
 export declare function aitezaApiRequest(this: IExecuteFunctions | ILoadOptionsFunctions, method: IHttpRequestMethods, endpoint: string, body?: IDataObject | IDataObject[], qs?: IDataObject, extraOpts?: Partial<IHttpRequestOptions>, authCtx?: AitezaAuthContext): Promise<any>;
 export declare function aitezaApiRequestFullResponse(this: IExecuteFunctions, method: IHttpRequestMethods, endpoint: string, body?: IDataObject, qs?: IDataObject, extraOpts?: Partial<IHttpRequestOptions>, authCtx?: AitezaAuthContext): Promise<{
     body: any;