n8n-nodes-microsoft-teams-bot 1.0.0

package/dist/nodes/TeamsBot/actions/cards.js

@@ -0,0 +1,731 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cardOperations = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const index_1 = require("../transport/index");
+const utils_1 = require("../utils");
+const ACData = __importStar(require("adaptivecards-templating"));
+/**
+ * Validates card operation parameters and card JSON format
+ * @param {CardOperationParams} params - Parameters to validate
+ * @param {string[]} requiredFields - List of required parameter fields
+ * @param {IExecuteFunctions} executeFunctions - n8n execution functions
+ * @param {number} itemIndex - Index of the current item being processed
+ * @throws {NodeOperationError} When validation fails
+ */
+function validateCardParams(params, requiredFields, executeFunctions, itemIndex) {
+    // Validate required fields
+    for (const field of requiredFields) {
+        if (!params[field]) {
+            throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), `Required parameter "${field}" is missing`, { itemIndex });
+        }
+    }
+    // Validate recipient type and related fields
+    if (params.recipientType === 'channel') {
+        if (!params.teamId) {
+            throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), 'Required parameter "teamId" is missing for channel messages', { itemIndex });
+        }
+        if (!params.channelId) {
+            throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), 'Required parameter "channelId" is missing for channel messages', { itemIndex });
+        }
+    }
+    else if (params.recipientType === 'chat') {
+        if (!params.userId) {
+            throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), 'Required parameter "userId" is missing for chat messages', { itemIndex });
+        }
+    }
+    else {
+        throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), `Invalid recipient type: ${params.recipientType}`, { itemIndex });
+    }
+}
+/**
+ * Parses JSON card string into an object
+ * @param {string} card - JSON string of the card
+ * @param {IExecuteFunctions} executeFunctions - n8n execution functions
+ * @param {number} itemIndex - Index of the current item being processed
+ * @returns {AdaptiveCard} Parsed card object
+ * @throws {NodeOperationError} When card parsing fails
+ */
+function parseCard(card, executeFunctions, itemIndex) {
+    try {
+        return typeof card === 'string' ? JSON.parse(card) : card;
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), `Invalid card format: ${error.message}`, { itemIndex });
+    }
+}
+/**
+ * Validates adaptive card structure with enhanced checks
+ * @param {AdaptiveCard} card - Card object to validate
+ * @param {IExecuteFunctions} executeFunctions - n8n execution functions
+ * @param {number} itemIndex - Index of the current item being processed
+ * @throws {NodeOperationError} When card validation fails
+ */
+function validateCard(card, executeFunctions, itemIndex) {
+    try {
+        // Basic structure validation
+        if (!card.type || card.type !== 'AdaptiveCard') {
+            throw new Error('Card must have a valid type "AdaptiveCard"');
+        }
+        if (!card.version) {
+            throw new Error('Card must have a version property');
+        }
+        // Schema is required but might be missing in user-provided cards
+        if (!card.$schema) {
+            // Add it automatically rather than throwing an error
+            card.$schema = 'http://adaptivecards.io/schemas/adaptive-card.json';
+        }
+        // Check for body property
+        if (!card.body || !Array.isArray(card.body)) {
+            throw new Error('Card must have a body array');
+        }
+        // Enhanced validations
+        // Check schema version
+        const version = card.version;
+        // Validate card body components
+        validateCardComponents(card.body);
+        // Validate actions if present
+        if (card.actions && Array.isArray(card.actions)) {
+            validateCardActions(card.actions);
+        }
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), `Invalid card: ${error.message}`, { itemIndex });
+    }
+}
+/**
+ * Validates card body components
+ * @param {unknown[]} components - Array of card components to validate
+ * @throws {Error} When validation fails
+ */
+function validateCardComponents(components) {
+    for (let i = 0; i < components.length; i++) {
+        const component = components[i];
+        // All components must have a type
+        if (!component.type) {
+            throw new Error(`Component at index ${i} is missing required 'type' property`);
+        }
+        // Validate specific component types
+        switch (component.type) {
+            case 'TextBlock':
+                if (component.text === undefined) {
+                    throw new Error(`TextBlock at index ${i} is missing required 'text' property`);
+                }
+                break;
+            case 'Image':
+                if (!component.url) {
+                    throw new Error(`Image at index ${i} is missing required 'url' property`);
+                }
+                break;
+            case 'Container':
+                if (!component.items || !Array.isArray(component.items)) {
+                    throw new Error(`Container at index ${i} must have an 'items' array`);
+                }
+                validateCardComponents(component.items);
+                break;
+            case 'ColumnSet':
+                if (!component.columns || !Array.isArray(component.columns)) {
+                    throw new Error(`ColumnSet at index ${i} must have a 'columns' array`);
+                }
+                // Validate each column in the column set
+                for (let j = 0; j < component.columns.length; j++) {
+                    const column = component.columns[j];
+                    if (!column.items || !Array.isArray(column.items)) {
+                        throw new Error(`Column at index ${j} in ColumnSet ${i} must have an 'items' array`);
+                    }
+                    validateCardComponents(column.items);
+                }
+                break;
+            case 'FactSet':
+                if (!component.facts || !Array.isArray(component.facts)) {
+                    throw new Error(`FactSet at index ${i} must have a 'facts' array`);
+                }
+                break;
+        }
+    }
+}
+/**
+ * Validates card actions
+ * @param {unknown[]} actions - Array of card actions to validate
+ * @throws {Error} When validation fails
+ */
+function validateCardActions(actions) {
+    for (let i = 0; i < actions.length; i++) {
+        const action = actions[i];
+        // All actions must have a type
+        if (!action.type) {
+            throw new Error(`Action at index ${i} is missing required 'type' property`);
+        }
+        // Validate specific action types
+        switch (action.type) {
+            case 'Action.OpenUrl':
+                if (!action.url) {
+                    throw new Error(`Action.OpenUrl at index ${i} is missing required 'url' property`);
+                }
+                if (!action.title) {
+                    throw new Error(`Action.OpenUrl at index ${i} is missing required 'title' property`);
+                }
+                break;
+            case 'Action.Submit':
+                if (!action.title) {
+                    throw new Error(`Action.Submit at index ${i} is missing required 'title' property`);
+                }
+                break;
+            case 'Action.ShowCard':
+                if (!action.title) {
+                    throw new Error(`Action.ShowCard at index ${i} is missing required 'title' property`);
+                }
+                if (!action.card) {
+                    throw new Error(`Action.ShowCard at index ${i} is missing required 'card' property`);
+                }
+                // Validate the nested card (but not recursively to avoid potential infinite loops)
+                {
+                    const nestedCard = action.card;
+                    if (!nestedCard.type || nestedCard.type !== 'AdaptiveCard') {
+                        throw new Error(`Nested card in Action.ShowCard at index ${i} must have a valid type "AdaptiveCard"`);
+                    }
+                    if (!nestedCard.body || !Array.isArray(nestedCard.body)) {
+                        throw new Error(`Nested card in Action.ShowCard at index ${i} must have a body array`);
+                    }
+                }
+                break;
+        }
+    }
+}
+/**
+ * Card operations for the Teams Bot node
+ */
+exports.cardOperations = {
+    /**
+     * Sends an adaptive card to a channel or chat
+     * @returns {Promise<INodeExecutionData[][]>} Promise resolving to output data
+     */
+    async send() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get operation parameters
+                const cardJson = this.getNodeParameter('card', i);
+                const recipientType = this.getNodeParameter('recipientType', i);
+                // Get options
+                const options = this.getNodeParameter('options', i, {});
+                // Get recipient-specific parameters
+                let teamId;
+                let channelId;
+                let userId;
+                if (recipientType === 'channel') {
+                    teamId = this.getNodeParameter('teamId', i);
+                    channelId = this.getNodeParameter('channelId', i);
+                }
+                else if (recipientType === 'chat') {
+                    userId = this.getNodeParameter('userId', i);
+                }
+                // Prepare parameters for validation
+                const params = {
+                    card: cardJson,
+                    recipientType,
+                    teamId,
+                    channelId,
+                    userId,
+                };
+                // Validate parameters
+                validateCardParams(params, ['card', 'recipientType'], this, i);
+                // Parse and validate card
+                const parsedCard = parseCard(cardJson, this, i);
+                validateCard(parsedCard, this, i);
+                // Convert to JSON string
+                const cardString = JSON.stringify(parsedCard);
+                // Send card based on recipient type
+                let response;
+                if (recipientType === 'channel') {
+                    // Always handle auto-installation for channel
+                    await (0, index_1.handleAutoInstall)(api, teamId, i, this);
+                    // Send card to channel
+                    response = await api.sendAdaptiveCardToChannel(teamId, channelId, cardString);
+                }
+                else {
+                    // Always handle auto-installation for user
+                    await (0, index_1.handleAutoInstall)(api, userId, i, this);
+                    // Use the BotFrameworkApi directly to send the card in one operation
+                    // This prevents sending an empty message followed by a card
+                    response = await api.sendAdaptiveCardToUser(userId, cardString);
+                    // Ensure we got a proper object response
+                    response = (0, utils_1.ensureObjectResponse)(response);
+                }
+                // Ensure response is properly parsed before returning
+                returnData.push({
+                    json: response,
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Sends a notification card to a channel or chat
+     * @returns {Promise<INodeExecutionData[][]>} Promise resolving to output data
+     */
+    async sendNotification() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get operation parameters
+                const title = this.getNodeParameter('title', i);
+                const message = this.getNodeParameter('message', i);
+                const recipientType = this.getNodeParameter('recipientType', i);
+                // Get options
+                const options = this.getNodeParameter('options', i, {});
+                const notificationType = options.notificationType || 'default';
+                const imageUrl = options.imageUrl;
+                const actionUrl = options.actionUrl;
+                const actionLabel = options.actionLabel || 'View Details';
+                // Get recipient-specific parameters
+                let teamId;
+                let channelId;
+                let userId;
+                if (recipientType === 'channel') {
+                    teamId = this.getNodeParameter('teamId', i);
+                    channelId = this.getNodeParameter('channelId', i);
+                }
+                else if (recipientType === 'chat') {
+                    userId = this.getNodeParameter('userId', i);
+                }
+                // Create notification card from template with data binding
+                const notificationTemplate = utils_1.CardTemplates.notification();
+                const templateEngine = new ACData.Template(notificationTemplate);
+                // Prepare data for template
+                const cardData = {
+                    title,
+                    message,
+                    notificationType,
+                    imageUrl: imageUrl || undefined,
+                    actionUrl: actionUrl || undefined,
+                    actionLabel,
+                };
+                // Apply data binding
+                const boundCard = templateEngine.expand({ $root: cardData });
+                const cardString = JSON.stringify(boundCard);
+                // Prepare parameters for validation
+                const params = {
+                    card: cardString,
+                    recipientType,
+                    teamId,
+                    channelId,
+                    userId,
+                };
+                // Validate parameters
+                validateCardParams(params, ['recipientType'], this, i);
+                // Send card based on recipient type
+                let response;
+                if (recipientType === 'channel') {
+                    // Always handle auto-installation for channel
+                    await (0, index_1.handleAutoInstall)(api, teamId, i, this);
+                    // Send card to channel
+                    response = await api.sendAdaptiveCardToChannel(teamId, channelId, cardString);
+                }
+                else {
+                    // Always handle auto-installation for user
+                    await (0, index_1.handleAutoInstall)(api, userId, i, this);
+                    // Use the BotFrameworkApi directly to send the card in one operation
+                    // This prevents sending an empty message followed by a card
+                    response = await api.sendAdaptiveCardToUser(userId, cardString);
+                    // Ensure we got a proper object response
+                    response = (0, utils_1.ensureObjectResponse)(response);
+                }
+                // Ensure response is properly parsed before returning
+                returnData.push({
+                    json: response,
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Sends an approval card to a channel or chat
+     * @returns {Promise<INodeExecutionData[][]>} Promise resolving to output data
+     */
+    async sendApproval() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get operation parameters
+                const title = this.getNodeParameter('title', i);
+                const description = this.getNodeParameter('description', i);
+                const requestId = this.getNodeParameter('requestId', i);
+                const recipientType = this.getNodeParameter('recipientType', i);
+                // Get options
+                const options = this.getNodeParameter('options', i, {});
+                const requestedBy = options.requestedBy;
+                const dueDate = options.dueDate;
+                const additionalInfo = options.additionalInfo;
+                const approveLabel = options.approveLabel || 'Approve';
+                const rejectLabel = options.rejectLabel || 'Reject';
+                // Get recipient-specific parameters
+                let teamId;
+                let channelId;
+                let userId;
+                if (recipientType === 'channel') {
+                    teamId = this.getNodeParameter('teamId', i);
+                    channelId = this.getNodeParameter('channelId', i);
+                }
+                else if (recipientType === 'chat') {
+                    userId = this.getNodeParameter('userId', i);
+                }
+                // Create approval card from template with data binding
+                const approvalTemplate = utils_1.CardTemplates.approval();
+                const templateEngine = new ACData.Template(approvalTemplate);
+                // Prepare data for template
+                const cardData = {
+                    title,
+                    description,
+                    requestId,
+                    requestedBy: requestedBy || undefined,
+                    dueDate: dueDate || undefined,
+                    additionalInfo: additionalInfo || undefined,
+                    approveLabel,
+                    rejectLabel,
+                };
+                // Apply data binding
+                const boundCard = templateEngine.expand({ $root: cardData });
+                const cardString = JSON.stringify(boundCard);
+                // Prepare parameters for validation
+                const params = {
+                    card: cardString,
+                    recipientType,
+                    teamId,
+                    channelId,
+                    userId,
+                };
+                // Validate parameters
+                validateCardParams(params, ['recipientType'], this, i);
+                // Send card based on recipient type
+                let response;
+                if (recipientType === 'channel') {
+                    // Always handle auto-installation for channel
+                    await (0, index_1.handleAutoInstall)(api, teamId, i, this);
+                    // Send card to channel
+                    response = await api.sendAdaptiveCardToChannel(teamId, channelId, cardString);
+                }
+                else {
+                    // Always handle auto-installation for user
+                    await (0, index_1.handleAutoInstall)(api, userId, i, this);
+                    // Use the BotFrameworkApi directly to send the card in one operation
+                    // This prevents sending an empty message followed by a card
+                    response = await api.sendAdaptiveCardToUser(userId, cardString);
+                    // Ensure we got a proper object response
+                    response = (0, utils_1.ensureObjectResponse)(response);
+                }
+                // Ensure response is properly parsed before returning
+                returnData.push({
+                    json: response,
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Updates an existing adaptive card in a conversation
+     */
+    async update() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get operation parameters
+                const conversationId = this.getNodeParameter('conversationId', i);
+                const activityId = this.getNodeParameter('activityId', i);
+                const cardJson = this.getNodeParameter('card', i);
+                // Validate parameters
+                validateCardParams({ card: cardJson }, ['card'], this, i);
+                // Update the card
+                const response = await api.updateCard(conversationId, activityId, cardJson);
+                // Ensure response is properly parsed before returning
+                returnData.push({
+                    json: (0, utils_1.ensureObjectResponse)(response),
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Updates an existing adaptive card in a channel
+     */
+    async updateInChannel() {
+        const items = this.getInputData();
+        const returnData = [];
+        const api = new index_1.TeamsApiClient(this);
+        await api.initialize();
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get operation parameters
+                const teamId = this.getNodeParameter('teamId', i);
+                const channelId = this.getNodeParameter('channelId', i);
+                const activityId = this.getNodeParameter('activityId', i);
+                const cardJson = this.getNodeParameter('card', i);
+                // Validate parameters
+                validateCardParams({ card: cardJson }, ['card'], this, i);
+                // Update the card in the channel
+                const response = await api.updateAdaptiveCardInChannel(teamId, channelId, activityId, cardJson);
+                // Ensure response is properly parsed before returning
+                returnData.push({
+                    json: (0, utils_1.ensureObjectResponse)(response),
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+    /**
+     * Processes card action data from user interactions
+     * Enhanced to extract user info, timestamp, and conversation context from trigger data
+     */
+    async processAction() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get action data from the trigger or input
+                const actionData = this.getNodeParameter('actionData', i, '');
+                if (!actionData) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No action data provided. This operation should be used with card action triggers.', { itemIndex: i });
+                }
+                let parsedActionData;
+                try {
+                    parsedActionData = JSON.parse(actionData);
+                }
+                catch (error) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid action data JSON: ${error instanceof Error ? error.message : String(error)}`, { itemIndex: i });
+                }
+                // Get input item data (from trigger node) to extract additional metadata
+                const inputItem = items[i];
+                const inputJson = (inputItem === null || inputItem === void 0 ? void 0 : inputItem.json) || {};
+                // Type guard helper for IDataObject
+                const isDataObject = (value) => {
+                    return typeof value === 'object' && value !== null && !Array.isArray(value);
+                };
+                // Extract user information from trigger data
+                // Teams Bot Framework sends user info in resourceData.from or activity.from
+                const userInfo = {};
+                const resourceData = isDataObject(inputJson.resourceData) ? inputJson.resourceData : {};
+                const from = isDataObject(resourceData.from) ? resourceData.from :
+                    isDataObject(inputJson.from) ? inputJson.from :
+                        isDataObject(parsedActionData.from) ? parsedActionData.from : {};
+                if (from.user || from.id) {
+                    // Extract from Teams message format
+                    const user = isDataObject(from.user) ? from.user : {};
+                    userInfo.id = user.id || from.id || user.userIdentity;
+                    userInfo.name = user.displayName || from.name || user.name;
+                    userInfo.email = user.userIdentity || user.email || from.email;
+                    userInfo.userPrincipalName = user.userPrincipalName || from.userPrincipalName;
+                }
+                else if (from.id) {
+                    // Extract from Bot Framework activity format
+                    userInfo.id = from.id;
+                    userInfo.name = from.name;
+                }
+                // Extract timestamp from trigger data
+                // Prefer timestamp from trigger (actual action time) over current time
+                let actionTimestamp;
+                if (typeof resourceData.lastModifiedDateTime === 'string') {
+                    actionTimestamp = resourceData.lastModifiedDateTime;
+                }
+                else if (typeof resourceData.createdDateTime === 'string') {
+                    actionTimestamp = resourceData.createdDateTime;
+                }
+                else if (typeof inputJson.timestamp === 'string') {
+                    actionTimestamp = inputJson.timestamp;
+                }
+                else if (typeof resourceData.timestamp === 'string') {
+                    actionTimestamp = resourceData.timestamp;
+                }
+                else if (typeof parsedActionData.timestamp === 'string') {
+                    actionTimestamp = parsedActionData.timestamp;
+                }
+                else {
+                    // Fallback to current time if no timestamp available
+                    actionTimestamp = new Date().toISOString();
+                }
+                // Extract conversation context from trigger data
+                const conversationContext = {};
+                const conversation = isDataObject(resourceData.conversation) ? resourceData.conversation :
+                    isDataObject(inputJson.conversation) ? inputJson.conversation :
+                        isDataObject(parsedActionData.conversation) ? parsedActionData.conversation : {};
+                if (conversation.id) {
+                    conversationContext.id = conversation.id;
+                    conversationContext.name = conversation.name;
+                    conversationContext.isGroup = conversation.isGroup;
+                    conversationContext.conversationType = conversation.conversationType;
+                }
+                // Extract message/activity context
+                const messageContext = {};
+                if (inputJson.messageId || resourceData.id) {
+                    messageContext.messageId = inputJson.messageId || resourceData.id;
+                }
+                if (inputJson.activityId || resourceData.id) {
+                    messageContext.activityId = inputJson.activityId || resourceData.id;
+                }
+                if (resourceData.replyToId || inputJson.replyToId) {
+                    messageContext.replyToId = resourceData.replyToId || inputJson.replyToId;
+                }
+                // Extract team/channel context if available
+                const contextInfo = {};
+                const channelIdentity = isDataObject(resourceData.channelIdentity) ? resourceData.channelIdentity : {};
+                if (inputJson.teamId || channelIdentity.teamId) {
+                    contextInfo.teamId = inputJson.teamId || channelIdentity.teamId;
+                }
+                if (inputJson.channelId || channelIdentity.channelId) {
+                    contextInfo.channelId = inputJson.channelId || channelIdentity.channelId;
+                }
+                if (inputJson.chatId || resourceData.chatId) {
+                    contextInfo.chatId = inputJson.chatId || resourceData.chatId;
+                }
+                // Process the action data and return structured information with enhanced metadata
+                const processedAction = {
+                    // Core action data
+                    actionType: parsedActionData.type || 'submit',
+                    actionId: parsedActionData.id || parsedActionData.actionId,
+                    actionData: parsedActionData.data || parsedActionData.value || {},
+                    // Enhanced metadata
+                    timestamp: actionTimestamp,
+                    // User information (if available from trigger)
+                    user: Object.keys(userInfo).length > 0 ? userInfo : undefined,
+                    // Conversation context (if available)
+                    conversation: Object.keys(conversationContext).length > 0 ? conversationContext : undefined,
+                    // Message context (if available)
+                    message: Object.keys(messageContext).length > 0 ? messageContext : undefined,
+                    // Team/channel context (if available)
+                    context: Object.keys(contextInfo).length > 0 ? contextInfo : undefined,
+                    // Original trigger event type (if available)
+                    eventType: inputJson.eventType || resourceData.eventType || undefined,
+                };
+                // Remove undefined fields to keep output clean
+                Object.keys(processedAction).forEach(key => {
+                    if (processedAction[key] === undefined) {
+                        delete processedAction[key];
+                    }
+                });
+                returnData.push({
+                    json: processedAction,
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    },
+};
+//# sourceMappingURL=cards.js.map