@aiteza/n8n-nodes-aiteza 0.1.1 → 0.2.0

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

@@ -0,0 +1,5 @@
+import type { INodeType, INodeTypeDescription, IWebhookFunctions, IWebhookResponseData } from 'n8n-workflow';
+export declare class AitezaTrigger implements INodeType {
+    description: INodeTypeDescription;
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AitezaTrigger = void 0;
+class AitezaTrigger {
+    description = {
+        displayName: 'AITEZA Trigger',
+        name: 'aitezaTrigger',
+        icon: 'file:aiteza.svg',
+        group: ['trigger'],
+        version: 1,
+        description: 'Starts the workflow when an AITEZA event is received via webhook. ' +
+            'Passes the caller\'s auth token to all downstream AITEZA nodes so they act on behalf of the triggering user.',
+        defaults: { name: 'AITEZA Trigger' },
+        inputs: [],
+        outputs: ['main'],
+        // No credentials required – the trigger just receives webhooks.
+        // Downstream AITEZA nodes still need credentials (for baseUrl), but will
+        // use the token from this trigger for actual authentication.
+        credentials: [],
+        webhooks: [
+            {
+                name: 'default',
+                httpMethod: 'POST',
+                responseMode: '={{$parameter["responseMode"]}}',
+                path: '={{$parameter["path"]}}',
+                isFullPath: true,
+            },
+        ],
+        properties: [
+            {
+                displayName: 'Path',
+                name: 'path',
+                type: 'string',
+                default: 'aiteza',
+                placeholder: 'aiteza',
+                required: true,
+                description: 'The webhook path to listen on. The full URL will be /webhook/{path}.',
+            },
+            {
+                displayName: 'Response Mode',
+                name: 'responseMode',
+                type: 'options',
+                options: [
+                    {
+                        name: 'When Last Node Finishes',
+                        value: 'lastNode',
+                        description: 'Respond with data from the last node in the workflow',
+                    },
+                    {
+                        name: 'Immediately',
+                        value: 'onReceived',
+                        description: 'Respond immediately with 200 OK',
+                    },
+                ],
+                default: 'lastNode',
+                description: 'When and how to respond to the webhook',
+            },
+        ],
+    };
+    async webhook() {
+        const body = this.getBodyData();
+        const headers = this.getHeaderData();
+        const authHeader = headers.authorization || headers.Authorization || '';
+        const authToken = authHeader.replace(/^Bearer\s+/i, '');
+        const outputData = { ...body };
+        if (authToken)
+            outputData._authToken = authToken;
+        return {
+            workflowData: [this.helpers.returnJsonArray(outputData)],
+        };
+    }
+}
+exports.AitezaTrigger = AitezaTrigger;

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

@@ -1,11 +1,15 @@
 import type { IDataObject, IExecuteFunctions, IHttpRequestMethods, IHttpRequestOptions, ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
-export declare function aitezaApiRequest(this: IExecuteFunctions | ILoadOptionsFunctions, method: IHttpRequestMethods, endpoint: string, body?: IDataObject | IDataObject[], qs?: IDataObject, extraOpts?: Partial<IHttpRequestOptions>): Promise<any>;
-export declare function aitezaApiRequestFullResponse(this: IExecuteFunctions, method: IHttpRequestMethods, endpoint: string, body?: IDataObject, qs?: IDataObject, extraOpts?: Partial<IHttpRequestOptions>): Promise<{
+export interface AitezaAuthContext {
+    baseUrl: string;
+    triggerToken?: string;
+}
+export declare function getUpstreamAuthToken(ef: IExecuteFunctions): string | undefined;
+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;
     headers: Record<string, string>;
 }>;
 export declare function loadDatarooms(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
-/** Same as loadDatarooms but with a leading "None" option for optional fields. */
 export declare function loadDataroomsOptional(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
 export declare function loadModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
 export declare function loadChats(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;

package/dist/nodes/Aiteza/GenericFunctions.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUpstreamAuthToken = getUpstreamAuthToken;
 exports.aitezaApiRequest = aitezaApiRequest;
 exports.aitezaApiRequestFullResponse = aitezaApiRequestFullResponse;
 exports.loadDatarooms = loadDatarooms;
@@ -13,20 +14,62 @@ exports.loadStandaloneFiles = loadStandaloneFiles;
 exports.loadStandaloneImages = loadStandaloneImages;
 exports.validateRequiredField = validateRequiredField;
 const n8n_workflow_1 = require("n8n-workflow");
+function getUpstreamAuthToken(ef) {
+    try {
+        const items = ef.getInputData();
+        for (const item of items) {
+            const token = item.json?._authToken;
+            if (token)
+                return token;
+        }
+    }
+    catch {
+        // getInputData may not be available in every context
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+async function resolveBaseUrl(ctx, authCtx) {
+    if (authCtx?.baseUrl)
+        return authCtx.baseUrl;
+    const credentials = await ctx.getCredentials('aitezaOAuth2Api');
+    return credentials.baseUrl.replace(/\/+$/, '');
+}
+async function executeRequest(ctx, options, authCtx) {
+    if (authCtx?.triggerToken) {
+        options.headers = {
+            ...(options.headers ?? {}),
+            Authorization: `Bearer ${authCtx.triggerToken}`,
+        };
+        return ctx.helpers.httpRequest(options);
+    }
+    return ctx.helpers.httpRequestWithAuthentication.call(ctx, 'aitezaOAuth2Api', options);
+}
+/** Convert API response items to n8n dropdown options. */
+function toOptions(items, nameField = 'name') {
+    return items.map((item) => ({
+        name: item[nameField] ?? item.id,
+        value: item.id,
+    }));
+}
+/** Extract array from API response (handles both raw arrays and paginated `{ content: [...] }`). */
+function extractItems(data) {
+    return Array.isArray(data) ? data : data?.content ?? [];
+}
 // ---------------------------------------------------------------------------
 // Generic authenticated request helper
 // ---------------------------------------------------------------------------
-async function aitezaApiRequest(method, endpoint, body = {}, qs = {}, extraOpts = {}) {
-    const credentials = await this.getCredentials('aitezaOAuth2Api');
-    const baseUrl = credentials.baseUrl.replace(/\/+$/, '');
+async function aitezaApiRequest(method, endpoint, body = {}, qs = {}, extraOpts = {}, authCtx) {
+    const baseUrl = await resolveBaseUrl(this, authCtx);
     const options = {
         method,
         url: `${baseUrl}${endpoint}`,
         json: true,
         ...extraOpts,
     };
-    // Only set qs when there are actual query-string values.
-    // Setting qs: {} can cause n8n to strip query params already in the URL.
+    // Only set qs when there are actual values – empty qs can strip URL params.
     if (Object.keys(qs).length > 0) {
         options.qs = qs;
     }
@@ -34,33 +77,28 @@ async function aitezaApiRequest(method, endpoint, body = {}, qs = {}, extraOpts
         options.body = body;
     }
     else if (method === 'DELETE' && Object.keys(body).length > 0) {
-        // Some AITEZA DELETE endpoints accept a body
         options.body = body;
     }
     try {
-        return await this.helpers.httpRequestWithAuthentication.call(this, 'aitezaOAuth2Api', options);
+        return await executeRequest(this, options, authCtx);
     }
     catch (error) {
         const statusCode = error?.statusCode ?? error?.httpCode ?? error?.response?.status;
-        let message = error.message ?? 'Unknown error';
-        if (statusCode === 401) {
-            message = 'OAuth2 token expired or invalid – check your AITEZA credentials';
-        }
-        else if (statusCode === 403) {
-            message = 'Insufficient permissions for this resource';
-        }
-        else if (statusCode === 404) {
-            message = 'Resource not found';
-        }
-        throw new n8n_workflow_1.NodeApiError(this.getNode(), error, { message });
+        const messages = {
+            401: 'OAuth2 token expired or invalid – check your AITEZA credentials',
+            403: 'Insufficient permissions for this resource',
+            404: 'Resource not found',
+        };
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), error, {
+            message: messages[statusCode] ?? error.message ?? 'Unknown error',
+        });
     }
 }
 // ---------------------------------------------------------------------------
 // Full-response variant (gives access to response headers, e.g. X-Chat-Id)
 // ---------------------------------------------------------------------------
-async function aitezaApiRequestFullResponse(method, endpoint, body = {}, qs = {}, extraOpts = {}) {
-    const credentials = await this.getCredentials('aitezaOAuth2Api');
-    const baseUrl = credentials.baseUrl.replace(/\/+$/, '');
+async function aitezaApiRequestFullResponse(method, endpoint, body = {}, qs = {}, extraOpts = {}, authCtx) {
+    const baseUrl = await resolveBaseUrl(this, authCtx);
     const options = {
         method,
         url: `${baseUrl}${endpoint}`,
@@ -73,7 +111,7 @@ async function aitezaApiRequestFullResponse(method, endpoint, body = {}, qs = {}
         options.body = body;
     }
     try {
-        return (await this.helpers.httpRequestWithAuthentication.call(this, 'aitezaOAuth2Api', options));
+        return (await executeRequest(this, options, authCtx));
     }
     catch (error) {
         throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
@@ -84,94 +122,62 @@ async function aitezaApiRequestFullResponse(method, endpoint, body = {}, qs = {}
 // ---------------------------------------------------------------------------
 async function loadDatarooms() {
     try {
-        // Embed query params directly in the URL because empty-string qs values
-        // are silently stripped by n8n's HTTP library.
-        const data = await aitezaApiRequest.call(this, 'GET', '/api/dataroom/search?name=&sortBy=recentlyUsed');
-        const items = Array.isArray(data) ? data : data?.content ?? [];
-        if (items.length === 0) {
+        const data = await aitezaApiRequest.call(this, 'GET', '/api/dataroom/search?q=&sortBy=recentlyUsed');
+        const items = extractItems(data);
+        if (items.length === 0)
             return [{ name: '(No datarooms found)', value: '' }];
-        }
-        return items.map((d) => ({
-            name: d.name ?? d.id,
-            value: d.id,
-        }));
+        return toOptions(items);
     }
     catch (error) {
         return [{ name: `Error loading datarooms: ${error.message ?? 'unknown'}`, value: '' }];
     }
 }
-/** Same as loadDatarooms but with a leading "None" option for optional fields. */
 async function loadDataroomsOptional() {
     const options = await loadDatarooms.call(this);
     return [{ name: '— None —', value: '' }, ...options];
 }
 async function loadModels() {
     const data = await aitezaApiRequest.call(this, 'GET', '/api/models');
-    const items = Array.isArray(data) ? data : [];
-    return items.map((m) => ({
-        name: m.name ?? m.id,
-        value: m.id,
-    }));
+    return toOptions(extractItems(data));
 }
 async function loadChats() {
     const data = await aitezaApiRequest.call(this, 'GET', '/api/chat', {}, { size: 100 });
-    const items = Array.isArray(data) ? data : data?.content ?? [];
-    return items.map((c) => ({
-        name: c.name ?? c.id,
-        value: c.id,
-    }));
+    return toOptions(extractItems(data));
 }
 async function loadFilesInDataroom() {
     const dataroomId = this.getCurrentNodeParameter('dataroomId');
     if (!dataroomId)
         return [];
     const data = await aitezaApiRequest.call(this, 'GET', `/api/dataroom/${dataroomId}/files`, {}, { size: 100 });
-    const items = Array.isArray(data) ? data : data?.content ?? [];
-    return items.map((f) => ({
-        name: f.name ?? f.id,
-        value: f.id,
-    }));
+    return toOptions(extractItems(data));
 }
 async function loadImagesInDataroom() {
     const dataroomId = this.getCurrentNodeParameter('dataroomId');
     if (!dataroomId)
         return [];
     const data = await aitezaApiRequest.call(this, 'GET', `/api/dataroom/${dataroomId}/images`, {}, { size: 100 });
-    const items = Array.isArray(data) ? data : data?.content ?? [];
-    return items.map((img) => ({
-        name: img.name ?? img.id,
-        value: img.id,
-    }));
+    return toOptions(extractItems(data));
 }
 async function loadWebSourcesInDataroom() {
     const dataroomId = this.getCurrentNodeParameter('dataroomId');
     if (!dataroomId)
         return [];
     const data = await aitezaApiRequest.call(this, 'GET', `/api/dataroom/${dataroomId}/websites`, {}, { size: 100 });
-    const items = Array.isArray(data) ? data : data?.content ?? [];
-    return items.map((ws) => ({
+    return extractItems(data).map((ws) => ({
         name: (ws.name || ws.url) ?? ws.id,
         value: ws.id,
     }));
 }
 async function loadStandaloneFiles() {
     const data = await aitezaApiRequest.call(this, 'GET', '/api/files', {}, { size: 100 });
-    const items = Array.isArray(data) ? data : data?.content ?? [];
-    return items.map((f) => ({
-        name: f.name ?? f.id,
-        value: f.id,
-    }));
+    return toOptions(extractItems(data));
 }
 async function loadStandaloneImages() {
     const data = await aitezaApiRequest.call(this, 'GET', '/api/images', {}, { size: 100 });
-    const items = Array.isArray(data) ? data : data?.content ?? [];
-    return items.map((img) => ({
-        name: img.name ?? img.id,
-        value: img.id,
-    }));
+    return toOptions(extractItems(data));
 }
 // ---------------------------------------------------------------------------
-// Validation helpers
+// Validation helper
 // ---------------------------------------------------------------------------
 function validateRequiredField(ef, value, fieldName) {
     if (value === undefined || value === null || value === '') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiteza/n8n-nodes-aiteza",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "n8n Community Node for the AITEZA REST API (Datarooms, Files, Chat, Search, Workflows)",
   "keywords": [
     "n8n-community-node-package",
@@ -33,7 +33,8 @@
       "dist/credentials/AitezaOAuth2Api.credentials.js"
     ],
     "nodes": [
-      "dist/nodes/Aiteza/Aiteza.node.js"
+      "dist/nodes/Aiteza/Aiteza.node.js",
+      "dist/nodes/Aiteza/AitezaTrigger.node.js"
     ]
   },
   "devDependencies": {