n8n-nodes-steyi-ss 1.0.0

package/dist/nodes/SteyiSmartsheet/executors/Rows.js

@@ -0,0 +1,845 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeRowOperation = void 0;
+const SteyiGenericFunction_1 = require("../SteyiGenericFunction");
+const SteyiSmartsheetApi_1 = require("../SteyiSmartsheetApi");
+// Helper function to handle attachment uploads
+async function handleAttachment(att, sheetId, rowId, itemIndex) {
+    if (att.attachmentType === 'FILE') {
+        // For FILE type, upload binary data
+        let binaryData;
+        let fileName = att.name;
+        let mimeType = 'application/octet-stream';
+        // Check if URL is a binary data reference
+        if (att.url && att.url !== '') {
+            // Get binary data by property name (similar to HTTP Request node's "Input Data Field Name")
+            const binaryPropertyName = att.url.trim(); // Trim whitespace
+            // Use n8n's helper to get binary data buffer - this handles all conversion automatically
+            // Similar to how HTTP Request node handles "n8n Binary File" body content type
+            try {
+                const binaryDataBuffer = await this.helpers.getBinaryDataBuffer(itemIndex, binaryPropertyName);
+                const BufferClass = eval('Buffer');
+                // Check the structure - it might be the buffer directly or wrapped in an object
+                if (BufferClass && BufferClass.isBuffer && BufferClass.isBuffer(binaryDataBuffer)) {
+                    // It's a Buffer directly
+                    binaryData = binaryDataBuffer;
+                    // Get metadata from the item
+                    const items = this.getInputData();
+                    const item = items[itemIndex];
+                    const binary = item.binary?.[binaryPropertyName];
+                    fileName = att.name || binary?.fileName || 'attachment';
+                    mimeType = binary?.mimeType || 'application/octet-stream';
+                }
+                else if (binaryDataBuffer && binaryDataBuffer.data) {
+                    // It's wrapped in an object with data property
+                    binaryData = binaryDataBuffer.data;
+                    fileName = att.name || binaryDataBuffer.fileName || 'attachment';
+                    mimeType = binaryDataBuffer.mimeType || 'application/octet-stream';
+                }
+                else {
+                    throw new Error(`Unexpected binary data structure: ${typeof binaryDataBuffer}. Expected Buffer or object with data property.`);
+                }
+                // Validate the buffer
+                if (!binaryData) {
+                    throw new Error(`Invalid buffer returned. Type: ${typeof binaryData}`);
+                }
+                if (!BufferClass || !BufferClass.isBuffer || !BufferClass.isBuffer(binaryData)) {
+                    throw new Error(`Data is not a Buffer. Type: ${typeof binaryData}`);
+                }
+                if (binaryData.length === 0) {
+                    throw new Error(`Buffer is empty. Binary property "${binaryPropertyName}" may not contain valid data.`);
+                }
+            }
+            catch (error) {
+                // Fallback: manually get binary data from item
+                const items = this.getInputData();
+                const item = items[itemIndex];
+                if (!item.binary) {
+                    const availableProps = 'none';
+                    throw new Error(`No binary data found in input item. Available binary properties: ${availableProps}. Make sure the previous node outputs binary data.`);
+                }
+                if (!item.binary[binaryPropertyName]) {
+                    // List available binary property names to help user
+                    const availableProps = Object.keys(item.binary).join(', ');
+                    throw new Error(`Binary property "${binaryPropertyName}" not found. Available binary properties: ${availableProps || 'none'}. Make sure you're using the correct property name from the previous node.`);
+                }
+                const binary = item.binary[binaryPropertyName];
+                // Get the base64 data
+                let base64Data = binary.data;
+                // Remove data URL prefix if present (e.g., "data:application/pdf;base64,")
+                if (base64Data.includes(',')) {
+                    base64Data = base64Data.split(',')[1];
+                }
+                // Clean the base64 string - remove whitespace and newlines
+                const base64String = base64Data.replace(/\s/g, '');
+                // Convert base64 to Buffer - this is critical for proper file upload
+                const BufferClass = eval('Buffer');
+                if (!BufferClass || typeof BufferClass.from !== 'function') {
+                    throw new Error('Buffer is not available. Cannot convert base64 to binary data.');
+                }
+                // Create Buffer from base64 string
+                binaryData = BufferClass.from(base64String, 'base64');
+                // Verify we have valid binary data
+                if (!binaryData || !BufferClass.isBuffer(binaryData)) {
+                    throw new Error(`Failed to create Buffer from base64 data. Base64 length: ${base64String.length}`);
+                }
+                // Get file metadata
+                fileName = att.name || binary.fileName || 'attachment';
+                mimeType = binary.mimeType || 'application/octet-stream';
+            }
+            // Additional validation - check buffer size
+            if (!binaryData || binaryData.length === 0) {
+                throw new Error('Binary data buffer is empty. Cannot upload file.');
+            }
+            // Upload file using raw binary data
+            // Ensure rowId is a number
+            const rowIdNum = typeof rowId === 'number' ? rowId : parseInt(String(rowId), 10);
+            if (isNaN(rowIdNum)) {
+                throw new Error(`Invalid row ID: ${rowId}`);
+            }
+            // Check if this should be added to a proof (use /proofs endpoint) or regular attachment (use /attachments endpoint)
+            const isProof = att.attachmentCategory === 'proof';
+            const endpoint = isProof
+                ? `/sheets/${sheetId}/rows/${rowIdNum}/proofs`
+                : `/sheets/${sheetId}/rows/${rowIdNum}/attachments`;
+            await SteyiGenericFunction_1.smartsheetFileUpload.call(this, endpoint, fileName, binaryData, mimeType, itemIndex);
+        }
+        else {
+            throw new Error('File attachment requires binary data. Please specify a binary property name (e.g., "data") in the URL field.');
+        }
+    }
+    else {
+        // For LINK type, use JSON API
+        // Ensure rowId is a number
+        const rowIdNum = typeof rowId === 'number' ? rowId : parseInt(String(rowId), 10);
+        if (isNaN(rowIdNum)) {
+            throw new Error(`Invalid row ID: ${rowId}`);
+        }
+        await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'POST', `/sheets/${sheetId}/rows/${rowIdNum}/attachments`, {
+            name: att.name,
+            url: att.url,
+            attachmentType: 'LINK',
+        }, itemIndex);
+    }
+}
+async function executeRowOperation(operation, itemIndex) {
+    let responseData;
+    // Helper function to get sheetId
+    const getSheetId = (index) => {
+        return this.getNodeParameter('sheetId', index);
+    };
+    const sheetId = getSheetId(itemIndex);
+    switch (operation) {
+        case 'addRow': {
+            const cellsData = this.getNodeParameter('cells', itemIndex, {});
+            const specialOptions = this.getNodeParameter('specialOptions', itemIndex, []);
+            let toTop = false;
+            let parentId = '';
+            if (specialOptions.includes('location')) {
+                const location = this.getNodeParameter('location', itemIndex, 'bottom');
+                if (location === 'top') {
+                    toTop = true;
+                }
+                else if (location === 'parent') {
+                    parentId = this.getNodeParameter('parentId', itemIndex);
+                }
+            }
+            const discussionsData = specialOptions.includes('discussions')
+                ? this.getNodeParameter('discussions', itemIndex, {})
+                : { discussion: undefined };
+            const attachmentsData = specialOptions.includes('attachments')
+                ? this.getNodeParameter('attachments', itemIndex, {})
+                : { attachment: undefined };
+            // Get column information to determine column types
+            let columnsMap = new Map();
+            try {
+                const columnsResponse = await SteyiSmartsheetApi_1.listColumns.call(this, parseInt(sheetId));
+                if (columnsResponse && columnsResponse.data && Array.isArray(columnsResponse.data)) {
+                    columnsResponse.data.forEach((col) => {
+                        columnsMap.set(col.id, col);
+                    });
+                }
+            }
+            catch (error) {
+                // If we can't get columns, continue without column type info
+            }
+            // Helper function to check if a string looks like comma-separated emails
+            const looksLikeEmailList = (str) => {
+                if (typeof str !== 'string')
+                    return false;
+                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                const parts = str.split(',').map(p => p.trim());
+                return parts.length > 1 && parts.every(part => emailRegex.test(part));
+            };
+            const cells = (cellsData.cell || []).map((cell) => {
+                let columnId;
+                if (cell.columnInputMethod === 'id') {
+                    columnId = cell.columnIdManual || '';
+                }
+                else {
+                    columnId = cell.columnId || '';
+                }
+                const colIdNum = parseInt(columnId, 10);
+                const column = columnsMap.get(colIdNum);
+                const columnType = column?.type;
+                // Clean up the value - remove surrounding quotes if present
+                let cellValue = cell.value;
+                if (typeof cellValue === 'string') {
+                    // Remove surrounding quotes (both single and double)
+                    cellValue = cellValue.trim();
+                    if ((cellValue.startsWith('"') && cellValue.endsWith('"')) ||
+                        (cellValue.startsWith("'") && cellValue.endsWith("'"))) {
+                        cellValue = cellValue.slice(1, -1);
+                    }
+                }
+                // Handle MULTI_CONTACT_LIST and MULTI_PICKLIST columns with objectValue
+                // Also handle if value looks like comma-separated emails (fallback for when column type isn't detected)
+                if (columnType === 'MULTI_CONTACT_LIST' || columnType === 'MULTI_PICKLIST' ||
+                    (columnType === undefined && typeof cellValue === 'string' && looksLikeEmailList(cellValue))) {
+                    // Try to parse the value as JSON if it's a string
+                    let parsedValue;
+                    try {
+                        if (typeof cellValue === 'string') {
+                            parsedValue = JSON.parse(cellValue);
+                        }
+                        else {
+                            parsedValue = cellValue;
+                        }
+                    }
+                    catch (error) {
+                        // If parsing fails, treat as regular value (comma-separated string)
+                        parsedValue = cellValue;
+                    }
+                    // If it's already in the correct MULTI_CONTACT format, use it directly
+                    if (parsedValue && typeof parsedValue === 'object' && parsedValue.objectType === 'MULTI_CONTACT' && parsedValue.values) {
+                        return {
+                            columnId: colIdNum,
+                            objectValue: parsedValue,
+                            strict: false,
+                        };
+                    }
+                    // If it's an array of contacts (old format), wrap it in MULTI_CONTACT structure
+                    if (parsedValue && Array.isArray(parsedValue) && parsedValue.length > 0) {
+                        return {
+                            columnId: colIdNum,
+                            objectValue: {
+                                objectType: 'MULTI_CONTACT',
+                                values: parsedValue.map((contact) => {
+                                    if (typeof contact === 'string') {
+                                        return { email: contact.trim() };
+                                    }
+                                    if (contact.objectType === 'CONTACT') {
+                                        // Remove objectType from contact objects
+                                        const contactObj = { email: contact.email || contact };
+                                        if (contact.name && contact.name !== contact.email) {
+                                            contactObj.name = contact.name;
+                                        }
+                                        return contactObj;
+                                    }
+                                    return contact;
+                                }),
+                            },
+                            strict: false,
+                        };
+                    }
+                    // Otherwise, format it properly based on column type
+                    // If columnType is undefined but value looks like emails, treat as MULTI_CONTACT_LIST
+                    if (columnType === 'MULTI_CONTACT_LIST' ||
+                        (columnType === undefined && typeof cellValue === 'string' && looksLikeEmailList(cellValue))) {
+                        // Format for MULTI_CONTACT_LIST
+                        let contacts = [];
+                        if (Array.isArray(parsedValue)) {
+                            contacts = parsedValue;
+                        }
+                        else if (typeof parsedValue === 'string') {
+                            // Try to parse as JSON array first
+                            try {
+                                contacts = JSON.parse(parsedValue);
+                            }
+                            catch {
+                                // If JSON parsing fails, check if it's comma-separated
+                                if (parsedValue.includes(',')) {
+                                    // Split by comma and trim each email
+                                    contacts = parsedValue.split(',').map((email) => email.trim());
+                                }
+                                else {
+                                    // If it's a single email, wrap it
+                                    contacts = [parsedValue.trim()];
+                                }
+                            }
+                        }
+                        // For MULTI_CONTACT_LIST, objectValue should be an object with objectType and values array
+                        return {
+                            columnId: colIdNum,
+                            objectValue: {
+                                objectType: 'MULTI_CONTACT',
+                                values: contacts.map((contact) => {
+                                    if (typeof contact === 'string') {
+                                        // For comma-separated emails, return only email field
+                                        return {
+                                            email: contact.trim(),
+                                        };
+                                    }
+                                    // For object format, include email and optionally name
+                                    const contactObj = {
+                                        email: contact.email || contact,
+                                    };
+                                    // Only include name if it's different from email
+                                    if (contact.name && contact.name !== contact.email) {
+                                        contactObj.name = contact.name;
+                                    }
+                                    return contactObj;
+                                }),
+                            },
+                            strict: false,
+                        };
+                    }
+                    else if (columnType === 'MULTI_PICKLIST') {
+                        // Format for MULTI_PICKLIST
+                        let options = [];
+                        if (Array.isArray(parsedValue)) {
+                            options = parsedValue;
+                        }
+                        else if (typeof parsedValue === 'string') {
+                            try {
+                                options = JSON.parse(parsedValue);
+                            }
+                            catch {
+                                options = parsedValue.split(',').map((s) => s.trim());
+                            }
+                        }
+                        return {
+                            columnId: colIdNum,
+                            objectValue: {
+                                objectType: 'MULTI_PICKLIST',
+                                values: options,
+                            },
+                        };
+                    }
+                }
+                // For regular columns, use value (use cleaned cellValue)
+                return {
+                    columnId: colIdNum,
+                    value: cellValue,
+                };
+            });
+            const body = {
+                cells,
+            };
+            if (toTop) {
+                body.toTop = true;
+            }
+            if (parentId && parentId !== '') {
+                body.parentId = parseInt(parentId, 10);
+            }
+            // Don't include discussions in the initial row creation body
+            // They need to be added separately after row creation
+            // Don't include FILE attachments in the initial row creation body
+            // They need to be uploaded separately after row creation
+            if (attachmentsData.attachment && attachmentsData.attachment.length > 0) {
+                const linkAttachments = attachmentsData.attachment.filter(att => att.attachmentType !== 'FILE');
+                if (linkAttachments.length > 0) {
+                    body.attachments = linkAttachments.map((att) => ({
+                        name: att.name,
+                        url: att.url,
+                        attachmentType: 'LINK',
+                    }));
+                }
+            }
+            // Check if any cells use objectValue (complex column types) - if so, add level=2 parameter
+            const hasComplexColumns = body.cells && body.cells.some((cell) => cell.objectValue);
+            const endpoint = hasComplexColumns
+                ? `/sheets/${sheetId}/rows?level=2`
+                : `/sheets/${sheetId}/rows`;
+            try {
+                responseData = await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'POST', endpoint, body, itemIndex);
+            }
+            catch (error) {
+                // Include request body in error for debugging
+                const errorMessage = error.response?.data
+                    ? `Smartsheet API Error: ${JSON.stringify(error.response.data)}. Request body: ${JSON.stringify(body)}`
+                    : error.message;
+                throw new Error(errorMessage);
+            }
+            // Add discussion/comment/attachments separately if needed
+            // Smartsheet API returns: { result: { id: ... } } or { result: [{ id: ... }] }
+            let rowId;
+            if (responseData.result) {
+                if (Array.isArray(responseData.result)) {
+                    rowId = responseData.result[0]?.id;
+                }
+                else {
+                    rowId = responseData.result.id;
+                }
+            }
+            else if (responseData.id) {
+                rowId = responseData.id;
+            }
+            else if (Array.isArray(responseData) && responseData[0]?.id) {
+                rowId = responseData[0].id;
+            }
+            if (!rowId) {
+                throw new Error('Failed to get row ID from response. Response: ' + JSON.stringify(responseData));
+            }
+            // Handle discussions separately (after row creation)
+            if (discussionsData.discussion && discussionsData.discussion.length > 0) {
+                for (const disc of discussionsData.discussion) {
+                    try {
+                        if (disc.action === 'addToExisting') {
+                            // Use discussionId from dropdown or manual entry
+                            const discussionId = disc.discussionId || disc.discussionIdManual;
+                            if (!discussionId) {
+                                throw new Error('Discussion ID is required when adding to existing discussion');
+                            }
+                            // Add comment to existing discussion
+                            await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'POST', `/sheets/${sheetId}/discussions/${discussionId}/comments`, {
+                                text: disc.commentText,
+                            }, itemIndex);
+                        }
+                        else if (disc.action === 'createNew') {
+                            // Create new discussion
+                            await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'POST', `/sheets/${sheetId}/rows/${rowId}/discussions`, {
+                                comment: {
+                                    text: disc.commentText,
+                                },
+                            }, itemIndex);
+                        }
+                    }
+                    catch (error) {
+                        throw new Error(`Error adding discussion: ${error.message}`);
+                    }
+                }
+            }
+            // Handle attachments separately (after row creation)
+            if (attachmentsData.attachment && attachmentsData.attachment.length > 0) {
+                for (const att of attachmentsData.attachment) {
+                    try {
+                        await handleAttachment.call(this, att, sheetId, rowId, itemIndex);
+                    }
+                    catch (error) {
+                        throw new Error(`Error adding attachment "${att.name}": ${error.message}`);
+                    }
+                }
+            }
+            break;
+        }
+        case 'getRow': {
+            const rowId = this.getNodeParameter('rowId', itemIndex);
+            const include = this.getNodeParameter('include', itemIndex, []);
+            const exclude = this.getNodeParameter('exclude', itemIndex, []);
+            const queryParams = [];
+            if (include.length > 0) {
+                queryParams.push(`include=${include.join(',')}`);
+            }
+            if (exclude.length > 0) {
+                queryParams.push(`exclude=${exclude.join(',')}`);
+            }
+            const queryString = queryParams.length > 0 ? `?${queryParams.join('&')}` : '';
+            responseData = await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', `/sheets/${sheetId}/rows/${rowId}${queryString}`, {}, itemIndex);
+            break;
+        }
+        case 'getRowMapped': {
+            const rowId = this.getNodeParameter('rowId', itemIndex);
+            const include = this.getNodeParameter('include', itemIndex, []);
+            const exclude = this.getNodeParameter('exclude', itemIndex, []);
+            const mappingType = this.getNodeParameter('mappingType', itemIndex, 'columnTitle');
+            const queryParams = [];
+            if (include.length > 0) {
+                queryParams.push(`include=${include.join(',')}`);
+            }
+            if (exclude.length > 0) {
+                queryParams.push(`exclude=${exclude.join(',')}`);
+            }
+            const queryString = queryParams.length > 0 ? `?${queryParams.join('&')}` : '';
+            // Get the row
+            const rowResponse = await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', `/sheets/${sheetId}/rows/${rowId}${queryString}`, {}, itemIndex);
+            // Get columns for the sheet (needed for both columnTitle and columnId mapping to include title)
+            const columnsResponse = await SteyiSmartsheetApi_1.listColumns.call(this, parseInt(sheetId, 10));
+            // Helper function to extract columns from various response shapes
+            function getColumns(itemJson) {
+                if (Array.isArray(itemJson.columns))
+                    return itemJson.columns;
+                if (Array.isArray(itemJson.data) && itemJson.data[0]?.title && itemJson.data[0]?.id) {
+                    return itemJson.data; // columns in data[]
+                }
+                if (Array.isArray(itemJson.sheet?.columns))
+                    return itemJson.sheet.columns;
+                return [];
+            }
+            const columns = getColumns(columnsResponse);
+            // Helper function to extract row from various response shapes
+            function getRow(itemJson) {
+                if (itemJson.row?.cells)
+                    return itemJson.row;
+                if (Array.isArray(itemJson.cells))
+                    return itemJson;
+                if (Array.isArray(itemJson.data) && itemJson.data[0]?.cells)
+                    return itemJson.data[0];
+                return null;
+            }
+            const row = getRow(rowResponse);
+            if (!row) {
+                throw new Error('No row found in response');
+            }
+            // Build mapped object based on mapping type
+            let mapped = {};
+            // Build lookup: columnId -> column meta (needed for both mapping types)
+            const colById = {};
+            columns.forEach((col) => {
+                colById[String(col.id)] = col;
+            });
+            if (mappingType === 'columnId') {
+                // Map by column ID, but include column title
+                for (const cell of row.cells || []) {
+                    const col = colById[String(cell.columnId)];
+                    const title = col?.title ?? `column_${cell.columnId}`;
+                    mapped[String(cell.columnId)] = {
+                        columnId: cell.columnId,
+                        title,
+                        value: cell.value ?? null,
+                        displayValue: cell.displayValue ?? null,
+                        objectValue: cell.objectValue ?? null,
+                    };
+                }
+            }
+            else {
+                // Map by column title (default)
+                for (const cell of row.cells || []) {
+                    const col = colById[String(cell.columnId)];
+                    const title = col?.title ?? `column_${cell.columnId}`;
+                    mapped[title] = {
+                        columnId: cell.columnId,
+                        title,
+                        value: cell.value ?? null,
+                        displayValue: cell.displayValue ?? null,
+                        objectValue: cell.objectValue ?? null,
+                        // keep useful column metadata too
+                        columnType: col?.type,
+                        columnIndex: col?.index,
+                        primary: col?.primary ?? false,
+                    };
+                }
+            }
+            // Include all fields from the row response, not just mapped fields
+            responseData = {
+                ...rowResponse, // Include all original response data (attachments, discussions, etc. if included)
+                rowId: row.id,
+                rowNumber: row.rowNumber,
+                sheetId: row.sheetId ?? parseInt(sheetId, 10),
+                mappingType,
+                mapped, // Add the mapped fields as a convenience
+            };
+            break;
+        }
+        case 'updateRow': {
+            const rowId = this.getNodeParameter('rowId', itemIndex);
+            const specialOptions = this.getNodeParameter('specialOptions', itemIndex, []);
+            let parentId = '';
+            if (specialOptions.includes('location')) {
+                const location = this.getNodeParameter('location', itemIndex, 'bottom');
+                if (location === 'parent') {
+                    parentId = this.getNodeParameter('parentId', itemIndex);
+                }
+            }
+            const cellsData = this.getNodeParameter('cells', itemIndex, {});
+            const discussionsData = specialOptions.includes('discussions')
+                ? this.getNodeParameter('discussions', itemIndex, {})
+                : { discussion: undefined };
+            const attachmentsData = specialOptions.includes('attachments')
+                ? this.getNodeParameter('attachments', itemIndex, {})
+                : { attachment: undefined };
+            // First, get discussions for the row to show in response
+            let existingDiscussions = [];
+            try {
+                const discussionsResponse = await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', `/sheets/${sheetId}/rows/${rowId}/discussions?include=comments`, {}, itemIndex);
+                if (discussionsResponse.data && Array.isArray(discussionsResponse.data)) {
+                    existingDiscussions = discussionsResponse.data;
+                }
+                else if (Array.isArray(discussionsResponse)) {
+                    existingDiscussions = discussionsResponse;
+                }
+            }
+            catch (error) {
+                // If we can't get discussions, continue without existing discussions
+            }
+            // Get column information to determine column types
+            let columnsMap = new Map();
+            try {
+                const columnsResponse = await SteyiSmartsheetApi_1.listColumns.call(this, parseInt(sheetId));
+                if (columnsResponse && columnsResponse.data && Array.isArray(columnsResponse.data)) {
+                    columnsResponse.data.forEach((col) => {
+                        columnsMap.set(col.id, col);
+                    });
+                }
+            }
+            catch (error) {
+                // If we can't get columns, continue without column type info
+            }
+            // Helper function to check if a string looks like comma-separated emails
+            const looksLikeEmailList = (str) => {
+                if (typeof str !== 'string')
+                    return false;
+                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                const parts = str.split(',').map(p => p.trim());
+                return parts.length > 1 && parts.every(part => emailRegex.test(part));
+            };
+            const cells = (cellsData.cell || []).map((cell) => {
+                let columnId;
+                if (cell.columnInputMethod === 'id') {
+                    columnId = cell.columnIdManual || '';
+                }
+                else {
+                    columnId = cell.columnId || '';
+                }
+                const colIdNum = parseInt(columnId, 10);
+                const column = columnsMap.get(colIdNum);
+                const columnType = column?.type;
+                // Clean up the value - remove surrounding quotes if present
+                let cellValue = cell.value;
+                if (typeof cellValue === 'string') {
+                    // Remove surrounding quotes (both single and double)
+                    cellValue = cellValue.trim();
+                    if ((cellValue.startsWith('"') && cellValue.endsWith('"')) ||
+                        (cellValue.startsWith("'") && cellValue.endsWith("'"))) {
+                        cellValue = cellValue.slice(1, -1);
+                    }
+                }
+                // Handle MULTI_CONTACT_LIST and MULTI_PICKLIST columns with objectValue
+                // Also handle if value looks like comma-separated emails (fallback for when column type isn't detected)
+                if (columnType === 'MULTI_CONTACT_LIST' || columnType === 'MULTI_PICKLIST' ||
+                    (columnType === undefined && typeof cellValue === 'string' && looksLikeEmailList(cellValue))) {
+                    // Try to parse the value as JSON if it's a string
+                    let parsedValue;
+                    try {
+                        if (typeof cellValue === 'string') {
+                            parsedValue = JSON.parse(cellValue);
+                        }
+                        else {
+                            parsedValue = cellValue;
+                        }
+                    }
+                    catch (error) {
+                        // If parsing fails, treat as regular value (comma-separated string)
+                        parsedValue = cellValue;
+                    }
+                    // If it's already in the correct MULTI_CONTACT format, use it directly
+                    if (parsedValue && typeof parsedValue === 'object' && parsedValue.objectType === 'MULTI_CONTACT' && parsedValue.values) {
+                        return {
+                            columnId: colIdNum,
+                            objectValue: parsedValue,
+                            strict: false,
+                        };
+                    }
+                    // If it's an array of contacts (old format), wrap it in MULTI_CONTACT structure
+                    if (parsedValue && Array.isArray(parsedValue) && parsedValue.length > 0) {
+                        return {
+                            columnId: colIdNum,
+                            objectValue: {
+                                objectType: 'MULTI_CONTACT',
+                                values: parsedValue.map((contact) => {
+                                    if (typeof contact === 'string') {
+                                        return { email: contact.trim() };
+                                    }
+                                    if (contact.objectType === 'CONTACT') {
+                                        // Remove objectType from contact objects
+                                        const contactObj = { email: contact.email || contact };
+                                        if (contact.name && contact.name !== contact.email) {
+                                            contactObj.name = contact.name;
+                                        }
+                                        return contactObj;
+                                    }
+                                    return contact;
+                                }),
+                            },
+                            strict: false,
+                        };
+                    }
+                    // Otherwise, format it properly based on column type
+                    // If columnType is undefined but value looks like emails, treat as MULTI_CONTACT_LIST
+                    if (columnType === 'MULTI_CONTACT_LIST' ||
+                        (columnType === undefined && typeof cellValue === 'string' && looksLikeEmailList(cellValue))) {
+                        // Format for MULTI_CONTACT_LIST
+                        let contacts = [];
+                        if (Array.isArray(parsedValue)) {
+                            contacts = parsedValue;
+                        }
+                        else if (typeof parsedValue === 'string') {
+                            // Try to parse as JSON array first
+                            try {
+                                contacts = JSON.parse(parsedValue);
+                            }
+                            catch {
+                                // If JSON parsing fails, check if it's comma-separated
+                                if (parsedValue.includes(',')) {
+                                    // Split by comma and trim each email
+                                    contacts = parsedValue.split(',').map((email) => email.trim());
+                                }
+                                else {
+                                    // If it's a single email, wrap it
+                                    contacts = [parsedValue.trim()];
+                                }
+                            }
+                        }
+                        // For MULTI_CONTACT_LIST, objectValue should be an object with objectType and values array
+                        return {
+                            columnId: colIdNum,
+                            objectValue: {
+                                objectType: 'MULTI_CONTACT',
+                                values: contacts.map((contact) => {
+                                    if (typeof contact === 'string') {
+                                        // For comma-separated emails, return only email field
+                                        return {
+                                            email: contact.trim(),
+                                        };
+                                    }
+                                    // For object format, include email and optionally name
+                                    const contactObj = {
+                                        email: contact.email || contact,
+                                    };
+                                    // Only include name if it's different from email
+                                    if (contact.name && contact.name !== contact.email) {
+                                        contactObj.name = contact.name;
+                                    }
+                                    return contactObj;
+                                }),
+                            },
+                            strict: false,
+                        };
+                    }
+                    else if (columnType === 'MULTI_PICKLIST') {
+                        // Format for MULTI_PICKLIST
+                        let options = [];
+                        if (Array.isArray(parsedValue)) {
+                            options = parsedValue;
+                        }
+                        else if (typeof parsedValue === 'string') {
+                            try {
+                                options = JSON.parse(parsedValue);
+                            }
+                            catch {
+                                options = parsedValue.split(',').map((s) => s.trim());
+                            }
+                        }
+                        return {
+                            columnId: colIdNum,
+                            objectValue: {
+                                objectType: 'MULTI_PICKLIST',
+                                values: options,
+                            },
+                        };
+                    }
+                }
+                // For regular columns, use value (use cleaned cellValue)
+                return {
+                    columnId: colIdNum,
+                    value: cellValue,
+                };
+            });
+            const body = {
+                id: parseInt(rowId, 10),
+                cells,
+            };
+            if (parentId && parentId !== '') {
+                body.parentId = parseInt(parentId, 10);
+            }
+            // Don't include FILE attachments in the row update body
+            // They need to be uploaded separately
+            if (attachmentsData.attachment && attachmentsData.attachment.length > 0) {
+                const linkAttachments = attachmentsData.attachment.filter(att => att.attachmentType !== 'FILE');
+                if (linkAttachments.length > 0) {
+                    body.attachments = linkAttachments.map((att) => ({
+                        name: att.name,
+                        url: att.url,
+                        attachmentType: 'LINK',
+                    }));
+                }
+            }
+            // Check if any cells use objectValue (complex column types) - if so, add level=2 parameter
+            const hasComplexColumns = cells.some((cell) => cell.objectValue);
+            const endpoint = hasComplexColumns
+                ? `/sheets/${sheetId}/rows?level=2`
+                : `/sheets/${sheetId}/rows`;
+            try {
+                responseData = await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'PUT', endpoint, [body], itemIndex);
+            }
+            catch (error) {
+                // Include request body in error for debugging
+                const errorMessage = error.response?.data
+                    ? `Smartsheet API Error: ${JSON.stringify(error.response.data)}. Request body: ${JSON.stringify([body])}`
+                    : error.message;
+                throw new Error(errorMessage);
+            }
+            // Include existing discussions in response
+            if (existingDiscussions.length > 0) {
+                responseData.discussions = existingDiscussions;
+            }
+            // Handle discussions separately (after row update)
+            if (discussionsData.discussion && discussionsData.discussion.length > 0) {
+                for (const disc of discussionsData.discussion) {
+                    try {
+                        if (disc.action === 'addToExisting') {
+                            // Use discussionId from dropdown or manual entry
+                            const discussionId = disc.discussionId || disc.discussionIdManual;
+                            if (!discussionId) {
+                                throw new Error('Discussion ID is required when adding to existing discussion');
+                            }
+                            // Add comment to existing discussion
+                            await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'POST', `/sheets/${sheetId}/discussions/${discussionId}/comments`, {
+                                text: disc.commentText,
+                            }, itemIndex);
+                        }
+                        else if (disc.action === 'createNew') {
+                            // Create new discussion
+                            await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'POST', `/sheets/${sheetId}/rows/${rowId}/discussions`, {
+                                comment: {
+                                    text: disc.commentText,
+                                },
+                            }, itemIndex);
+                        }
+                    }
+                    catch (error) {
+                        throw new Error(`Error adding discussion: ${error.message}`);
+                    }
+                }
+                // Refresh discussions in response after adding new ones
+                try {
+                    const updatedDiscussions = await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', `/sheets/${sheetId}/rows/${rowId}/discussions?include=comments`, {}, itemIndex);
+                    if (updatedDiscussions.data && Array.isArray(updatedDiscussions.data)) {
+                        responseData.discussions = updatedDiscussions.data;
+                    }
+                    else if (Array.isArray(updatedDiscussions)) {
+                        responseData.discussions = updatedDiscussions;
+                    }
+                }
+                catch (error) {
+                    // Continue if we can't refresh discussions
+                }
+            }
+            // Handle attachments separately (after row update)
+            if (attachmentsData.attachment && attachmentsData.attachment.length > 0) {
+                for (const att of attachmentsData.attachment) {
+                    try {
+                        await handleAttachment.call(this, att, sheetId, parseInt(rowId, 10), itemIndex);
+                    }
+                    catch (error) {
+                        throw new Error(`Error adding attachment "${att.name}": ${error.message}`);
+                    }
+                }
+            }
+            break;
+        }
+        case 'deleteRow': {
+            const rowId = this.getNodeParameter('rowId', itemIndex);
+            await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'DELETE', `/sheets/${sheetId}/rows?ids=${rowId}`, {}, itemIndex);
+            responseData = { success: true, message: 'Row deleted successfully' };
+            break;
+        }
+        default:
+            throw new Error(`Unknown row operation: ${operation}`);
+    }
+    return {
+        json: responseData,
+        pairedItem: { item: itemIndex },
+    };
+}
+exports.executeRowOperation = executeRowOperation;