n8n-nodes-steyi-ss 1.0.1 → 1.0.3

package/README.md

@@ -199,17 +199,65 @@ Add a new row to a sheet:
     - Attachment category (Regular Attachment or Proof)
     - Custom filename
 
-**Multi-Contact List Formatting:**
-When adding or updating rows with `MULTI_CONTACT_LIST` columns, you can provide:
-- Comma-separated email string: `"email1@example.com, email2@example.com"`
-- JSON array: `["email1@example.com", "email2@example.com"]`
-
-The node automatically formats these for the Smartsheet API.
-
-**Multi-Picklist Formatting:**
-For `MULTI_PICKLIST` columns, provide:
-- Comma-separated options: `"Option 1, Option 2"`
-- JSON array: `["Option 1", "Option 2"]`
+## Column Value Formatting
+
+When adding or updating rows, different column types require specific value formats:
+
+### TEXT_NUMBER, DATE, DATETIME
+- **Format**: Plain text or number
+- **Example**: `"John Doe"`, `123`, `"2024-01-15"`
+
+### CHECKBOX
+- **Format**: String values that are auto-converted to boolean
+- **Accepted values**: `"true"`, `"false"`, `"1"`, `"0"`, `"yes"`, `"no"` (case-insensitive)
+- **Example**: `"true"` → `true`, `"false"` → `false`
+- The node automatically converts these strings to boolean values
+
+### PICKLIST
+- **Format**: Option text (must match exactly, case-sensitive)
+- **Example**: `"High Priority"` (must match an option defined in the column)
+
+### MULTI_CONTACT_LIST
+- **Format**: JSON object with `values` array containing email objects
+- **Example**:
+  ```json
+  {
+    "values": [
+      { "email": "john.smith@example.com" },
+      { "email": "jane.doe@example.com" }
+    ]
+  }
+  ```
+- The node automatically transforms this to the correct Smartsheet API format:
+  ```json
+  {
+    "objectType": "MULTI_CONTACT",
+    "values": [
+      { "objectType": "CONTACT", "email": "john.smith@example.com" },
+      { "objectType": "CONTACT", "email": "jane.doe@example.com" }
+    ]
+  }
+  ```
+
+### MULTI_PICKLIST
+- **Format**: JSON object with `values` array containing option strings
+- **Example**:
+  ```json
+  {
+    "values": [
+      "Option 1",
+      "Option 2"
+    ]
+  }
+  ```
+- **Important**: Option values must match exactly (case-sensitive) the options defined in the MULTI_PICKLIST column
+- The node automatically transforms this to the correct Smartsheet API format:
+  ```json
+  {
+    "objectType": "MULTI_PICKLIST",
+    "values": ["Option 1", "Option 2"]
+  }
+  ```
 
 #### Update Row
 Update an existing row with the same options as Add Row:
@@ -413,15 +461,23 @@ For the trigger node, n8n automatically generates the webhook URL, but it must b
 
 ### Multi-Contact List Support
 The node automatically handles `MULTI_CONTACT_LIST` columns by:
-- Parsing comma-separated email strings
-- Formatting as proper Smartsheet API `objectValue` structure
-- Supporting `strict: false` mode for flexible updates
+- Accepting JSON format: `{ "values": [{ "email": "..." }, ...] }`
+- Automatically adding `objectType: "MULTI_CONTACT"` to the objectValue
+- Wrapping each contact with `objectType: "CONTACT"` in the values array
+- Validating email format and structure
 
 ### Multi-Picklist Support
 The node handles `MULTI_PICKLIST` columns by:
-- Parsing comma-separated option strings
-- Formatting as proper Smartsheet API `objectValue` structure
-- Validating against column options
+- Accepting JSON format: `{ "values": ["Option 1", "Option 2"] }`
+- Automatically adding `objectType: "MULTI_PICKLIST"` to the objectValue
+- Keeping values as strings (not wrapped in objects)
+- Validating that option values match column options (case-sensitive)
+
+### Checkbox Support
+The node automatically handles `CHECKBOX` columns by:
+- Converting string values to boolean: `"true"`, `"false"`, `"1"`, `"0"`, `"yes"`, `"no"`
+- Case-insensitive conversion
+- Empty values default to `false`
 
 ### Attachment Handling
 - **File Uploads**: Supports binary data from n8n's binary data system

package/dist/nodes/SteyiSmartsheet/SteyiSmartsheet.node.js

@@ -1,4 +1,27 @@
 "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.SteyiSmartsheet = void 0;
 const Sheets_1 = require("./executors/Sheets");
@@ -571,7 +594,7 @@ class SteyiSmartsheet {
                                         },
                                     },
                                     default: '',
-                                    description: 'Select a column',
+                                    description: 'Select a column. The column type is shown in parentheses next to each column name (e.g., "Column Name (MULTI_CONTACT_LIST)")',
                                 },
                                 {
                                     displayName: 'Column ID',
@@ -590,7 +613,7 @@ class SteyiSmartsheet {
                                     name: 'value',
                                     type: 'string',
                                     default: '',
-                                    description: 'The value to set',
+                                    description: 'The value to set. Column type is shown in parentheses in the dropdown above. For format examples for each column type, see the <a href="https://www.npmjs.com/package/n8n-nodes-steyi-ss" target="_blank">npm package README</a>.',
                                 },
                             ],
                         },
@@ -1768,14 +1791,40 @@ class SteyiSmartsheet {
                     if (sheetId === undefined || sheetId === null || sheetId === '') {
                         return [];
                     }
-                    const columns = await SteyiSmartsheetApi_1.listColumns.call(this, parseInt(sheetId.toString()));
-                    if (!columns || !columns.data) {
+                    // Get columns with level=2 to ensure we get the correct column types
+                    let columns = [];
+                    try {
+                        const columnsResponse = await SteyiSmartsheetApi_1.listColumns.call(this, parseInt(sheetId.toString()));
+                        if (columnsResponse && columnsResponse.data && Array.isArray(columnsResponse.data)) {
+                            columns = columnsResponse.data;
+                        }
+                    }
+                    catch (error) {
+                        // If columns endpoint fails, try getting the sheet with columns included and level=2
+                        try {
+                            const { smartsheetApiRequest } = await Promise.resolve().then(() => __importStar(require('./SteyiGenericFunction')));
+                            const sheetResponse = await smartsheetApiRequest.call(this, 'GET', `/sheets/${sheetId}?include=columns&level=2`, {}, 0);
+                            if (sheetResponse && sheetResponse.columns && Array.isArray(sheetResponse.columns)) {
+                                columns = sheetResponse.columns;
+                            }
+                        }
+                        catch (sheetError) {
+                            // If both fail, return empty array
+                            return [];
+                        }
+                    }
+                    if (columns.length === 0) {
                         return [];
                     }
-                    return columns.data.map((column) => ({
-                        name: column.title,
-                        value: column.id.toString(),
-                    }));
+                    return columns.map((column) => {
+                        // The type field should be present in the API response with level=2
+                        const columnType = column.type || 'UNKNOWN';
+                        return {
+                            name: `${column.title} (${columnType})`,
+                            value: column.id.toString(),
+                            description: `Type: ${columnType}`,
+                        };
+                    });
                 },
                 async getDiscussions() {
                     const sheetId = this.getNodeParameter('sheetId', 0);

package/dist/nodes/SteyiSmartsheet/SteyiSmartsheetApi.js

@@ -24,7 +24,7 @@ async function listSheets(includeAll = true) {
 }
 exports.listSheets = listSheets;
 async function listColumns(sheetId) {
-    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', `/sheets/${sheetId}/columns`, {}, 0);
+    return await SteyiGenericFunction_1.smartsheetApiRequest.call(this, 'GET', `/sheets/${sheetId}/columns?level=2`, {}, 0);
 }
 exports.listColumns = listColumns;
 async function listWebhooks() {

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

@@ -163,15 +163,14 @@ async function executeRowOperation(operation, itemIndex) {
             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) => {
+            // Filter out any cells with empty columnId or invalid data
+            const validCells = (cellsData.cell || []).filter((cell) => {
+                const columnId = cell.columnInputMethod === 'id'
+                    ? cell.columnIdManual
+                    : cell.columnId;
+                return columnId && columnId !== '' && cell.value !== undefined;
+            });
+            const cells = validCells.map((cell) => {
                 let columnId;
                 if (cell.columnInputMethod === 'id') {
                     columnId = cell.columnIdManual || '';
@@ -179,7 +178,11 @@ async function executeRowOperation(operation, itemIndex) {
                 else {
                     columnId = cell.columnId || '';
                 }
+                // Parse columnId - keep as number for API, but ensure it's valid
                 const colIdNum = parseInt(columnId, 10);
+                if (isNaN(colIdNum)) {
+                    throw new Error(`Invalid column ID: ${columnId}`);
+                }
                 const column = columnsMap.get(colIdNum);
                 const columnType = column?.type;
                 // Clean up the value - remove surrounding quotes if present
@@ -193,10 +196,9 @@ async function executeRowOperation(operation, itemIndex) {
                     }
                 }
                 // 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
+                // User must provide a JSON block that will be used directly
+                if (columnType === 'MULTI_CONTACT_LIST') {
+                    // Parse the value as JSON
                     let parsedValue;
                     try {
                         if (typeof cellValue === 'string') {
@@ -207,119 +209,172 @@ async function executeRowOperation(operation, itemIndex) {
                         }
                     }
                     catch (error) {
-                        // If parsing fails, treat as regular value (comma-separated string)
-                        parsedValue = cellValue;
+                        throw new Error(`Invalid JSON for MULTI_CONTACT_LIST column (Column ID: ${colIdNum}). ` +
+                            `Please provide a valid JSON object with a "values" array. Error: ${error instanceof Error ? error.message : String(error)}`);
                     }
-                    // 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,
-                        };
+                    // Validate that it's an object with values array
+                    if (typeof parsedValue !== 'object' || parsedValue === null) {
+                        throw new Error(`Invalid objectValue for MULTI_CONTACT_LIST column (Column ID: ${colIdNum}). ` +
+                            `Expected a JSON object with "values" array, got ${typeof parsedValue}.`);
                     }
-                    // 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,
-                        };
+                    // Validate that it has a values array
+                    if (!Array.isArray(parsedValue.values)) {
+                        throw new Error(`Invalid objectValue for MULTI_CONTACT_LIST column (Column ID: ${colIdNum}). ` +
+                            `Expected a JSON object with "values" array property. Example: { "values": [{ "email": "user@example.com" }] }`);
                     }
-                    // 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()];
-                                }
-                            }
+                    // Validate that each value in the array has an email property
+                    // Transform values to include objectType: "CONTACT" for each contact
+                    const contactValues = parsedValue.values.map((value, i) => {
+                        if (typeof value !== 'object' || value === null || !value.email) {
+                            throw new Error(`Invalid objectValue for MULTI_CONTACT_LIST column (Column ID: ${colIdNum}). ` +
+                                `Each item in the "values" array must be an object with an "email" property. ` +
+                                `Example: { "values": [{ "email": "user@example.com" }] }`);
                         }
-                        // For MULTI_CONTACT_LIST, objectValue should be an object with objectType and values array
+                        // Ensure each contact has objectType: "CONTACT"
                         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,
+                            objectType: 'CONTACT',
+                            email: value.email,
                         };
+                    });
+                    // For MULTI_CONTACT_LIST, objectValue should have structure: 
+                    // { "objectType": "MULTI_CONTACT", "values": [{ "objectType": "CONTACT", "email": "..." }, ...] }
+                    // User provides the values array with emails, we add the objectType fields
+                    // Don't include "strict" for MULTI_CONTACT_LIST as it causes parsing errors
+                    // Ensure columnId is a number (not string) for the API
+                    return {
+                        columnId: Number(colIdNum),
+                        objectValue: {
+                            objectType: 'MULTI_CONTACT',
+                            values: contactValues,
+                        },
+                    };
+                }
+                else if (columnType === 'MULTI_PICKLIST') {
+                    // Parse the value as JSON
+                    // Expected format: { "values": ["Option 1", "Option 2", ...] }
+                    let parsedValue;
+                    try {
+                        if (typeof cellValue === 'string') {
+                            parsedValue = JSON.parse(cellValue);
+                        }
+                        else {
+                            parsedValue = cellValue;
+                        }
                     }
-                    else if (columnType === 'MULTI_PICKLIST') {
-                        // Format for MULTI_PICKLIST
-                        let options = [];
-                        if (Array.isArray(parsedValue)) {
-                            options = parsedValue;
+                    catch (error) {
+                        throw new Error(`Invalid JSON for MULTI_PICKLIST column (Column ID: ${colIdNum}). ` +
+                            `Please provide a valid JSON object with structure: { "values": ["Option 1", "Option 2"] }. ` +
+                            `Error: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    // Validate that it's an object with values array
+                    if (typeof parsedValue !== 'object' || parsedValue === null) {
+                        throw new Error(`Invalid objectValue for MULTI_PICKLIST column (Column ID: ${colIdNum}). ` +
+                            `Expected a JSON object with "values" array, got ${typeof parsedValue}.`);
+                    }
+                    // Validate that it has a values array
+                    if (!Array.isArray(parsedValue.values)) {
+                        throw new Error(`Invalid objectValue for MULTI_PICKLIST column (Column ID: ${colIdNum}). ` +
+                            `Expected a JSON object with "values" array property. Example: { "values": ["Option 1", "Option 2"] }`);
+                    }
+                    // For MULTI_PICKLIST, values should be an array of strings, not objects
+                    // Transform values to ensure they're all strings
+                    // Note: Picklist values must match exactly (case-sensitive) the options defined in the column
+                    const picklistValues = parsedValue.values.map((value) => {
+                        // Value should be a string (the option text)
+                        if (typeof value === 'string') {
+                            return value;
                         }
-                        else if (typeof parsedValue === 'string') {
-                            try {
-                                options = JSON.parse(parsedValue);
-                            }
-                            catch {
-                                options = parsedValue.split(',').map((s) => s.trim());
-                            }
+                        else if (typeof value === 'object' && value !== null && value.value) {
+                            // If it's an object with a value property, extract the string value
+                            return String(value.value);
                         }
-                        return {
-                            columnId: colIdNum,
-                            objectValue: {
-                                objectType: 'MULTI_PICKLIST',
-                                values: options,
-                            },
-                        };
+                        else {
+                            throw new Error(`Invalid value in MULTI_PICKLIST values array (Column ID: ${colIdNum}). ` +
+                                `Each value must be a string (option text). ` +
+                                `Note: Option values must match exactly (case-sensitive) the options defined in the MULTI_PICKLIST column.`);
+                        }
+                    });
+                    // For MULTI_PICKLIST, objectValue should have structure: 
+                    // { "objectType": "MULTI_PICKLIST", "values": ["Option 1", "Option 2", ...] }
+                    // User provides the values array with option strings, we use them directly (not wrapped in objects)
+                    // Don't include "strict" for MULTI_PICKLIST as it may cause parsing errors
+                    // Ensure columnId is a number (not string) for the API
+                    return {
+                        columnId: Number(colIdNum),
+                        objectValue: {
+                            objectType: 'MULTI_PICKLIST',
+                            values: picklistValues,
+                        },
+                    };
+                }
+                // For CHECKBOX columns, convert string "true"/"false" to boolean
+                if (columnType === 'CHECKBOX') {
+                    let boolValue;
+                    if (typeof cellValue === 'boolean') {
+                        boolValue = cellValue;
+                    }
+                    else if (typeof cellValue === 'string') {
+                        const lowerValue = cellValue.toLowerCase().trim();
+                        if (lowerValue === 'true' || lowerValue === '1' || lowerValue === 'yes') {
+                            boolValue = true;
+                        }
+                        else if (lowerValue === 'false' || lowerValue === '0' || lowerValue === 'no' || lowerValue === '') {
+                            boolValue = false;
+                        }
+                        else {
+                            // If it's not a recognized boolean string, try to parse it
+                            throw new Error(`Invalid value for CHECKBOX column (Column ID: ${colIdNum}). ` +
+                                `Expected boolean or string "true"/"false", got: ${cellValue}`);
+                        }
+                    }
+                    else if (cellValue === null || cellValue === undefined || cellValue === '') {
+                        boolValue = false;
                     }
+                    else {
+                        // Try to convert to boolean
+                        boolValue = Boolean(cellValue);
+                    }
+                    return {
+                        columnId: Number(colIdNum),
+                        value: boolValue,
+                    };
+                }
+                // For CHECKBOX columns, convert string "true"/"false" to boolean
+                if (columnType === 'CHECKBOX') {
+                    let boolValue;
+                    if (typeof cellValue === 'boolean') {
+                        boolValue = cellValue;
+                    }
+                    else if (typeof cellValue === 'string') {
+                        const lowerValue = cellValue.toLowerCase().trim();
+                        if (lowerValue === 'true' || lowerValue === '1' || lowerValue === 'yes') {
+                            boolValue = true;
+                        }
+                        else if (lowerValue === 'false' || lowerValue === '0' || lowerValue === 'no' || lowerValue === '') {
+                            boolValue = false;
+                        }
+                        else {
+                            // If it's not a recognized boolean string, try to parse it
+                            throw new Error(`Invalid value for CHECKBOX column (Column ID: ${colIdNum}). ` +
+                                `Expected boolean or string "true"/"false", got: ${cellValue}`);
+                        }
+                    }
+                    else if (cellValue === null || cellValue === undefined || cellValue === '') {
+                        boolValue = false;
+                    }
+                    else {
+                        // Try to convert to boolean
+                        boolValue = Boolean(cellValue);
+                    }
+                    return {
+                        columnId: Number(colIdNum),
+                        value: boolValue,
+                    };
                 }
                 // For regular columns, use value (use cleaned cellValue)
+                // Ensure columnId is a number (not string) for the API
                 return {
-                    columnId: colIdNum,
+                    columnId: Number(colIdNum),
                     value: cellValue,
                 };
             });
@@ -575,15 +630,14 @@ async function executeRowOperation(operation, itemIndex) {
             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) => {
+            // Filter out any cells with empty columnId or invalid data
+            const validCells = (cellsData.cell || []).filter((cell) => {
+                const columnId = cell.columnInputMethod === 'id'
+                    ? cell.columnIdManual
+                    : cell.columnId;
+                return columnId && columnId !== '' && cell.value !== undefined;
+            });
+            const cells = validCells.map((cell) => {
                 let columnId;
                 if (cell.columnInputMethod === 'id') {
                     columnId = cell.columnIdManual || '';
@@ -591,7 +645,11 @@ async function executeRowOperation(operation, itemIndex) {
                 else {
                     columnId = cell.columnId || '';
                 }
+                // Parse columnId - keep as number for API, but ensure it's valid
                 const colIdNum = parseInt(columnId, 10);
+                if (isNaN(colIdNum)) {
+                    throw new Error(`Invalid column ID: ${columnId}`);
+                }
                 const column = columnsMap.get(colIdNum);
                 const columnType = column?.type;
                 // Clean up the value - remove surrounding quotes if present
@@ -605,10 +663,9 @@ async function executeRowOperation(operation, itemIndex) {
                     }
                 }
                 // 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
+                // User must provide a JSON block that will be used directly
+                if (columnType === 'MULTI_CONTACT_LIST') {
+                    // Parse the value as JSON
                     let parsedValue;
                     try {
                         if (typeof cellValue === 'string') {
@@ -619,119 +676,172 @@ async function executeRowOperation(operation, itemIndex) {
                         }
                     }
                     catch (error) {
-                        // If parsing fails, treat as regular value (comma-separated string)
-                        parsedValue = cellValue;
+                        throw new Error(`Invalid JSON for MULTI_CONTACT_LIST column (Column ID: ${colIdNum}). ` +
+                            `Please provide a valid JSON object with a "values" array. Error: ${error instanceof Error ? error.message : String(error)}`);
                     }
-                    // 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,
-                        };
+                    // Validate that it's an object with values array
+                    if (typeof parsedValue !== 'object' || parsedValue === null) {
+                        throw new Error(`Invalid objectValue for MULTI_CONTACT_LIST column (Column ID: ${colIdNum}). ` +
+                            `Expected a JSON object with "values" array, got ${typeof parsedValue}.`);
                     }
-                    // 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,
-                        };
+                    // Validate that it has a values array
+                    if (!Array.isArray(parsedValue.values)) {
+                        throw new Error(`Invalid objectValue for MULTI_CONTACT_LIST column (Column ID: ${colIdNum}). ` +
+                            `Expected a JSON object with "values" array property. Example: { "values": [{ "email": "user@example.com" }] }`);
                     }
-                    // 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()];
-                                }
-                            }
+                    // Validate that each value in the array has an email property
+                    // Transform values to include objectType: "CONTACT" for each contact
+                    const contactValues = parsedValue.values.map((value, i) => {
+                        if (typeof value !== 'object' || value === null || !value.email) {
+                            throw new Error(`Invalid objectValue for MULTI_CONTACT_LIST column (Column ID: ${colIdNum}). ` +
+                                `Each item in the "values" array must be an object with an "email" property. ` +
+                                `Example: { "values": [{ "email": "user@example.com" }] }`);
                         }
-                        // For MULTI_CONTACT_LIST, objectValue should be an object with objectType and values array
+                        // Ensure each contact has objectType: "CONTACT"
                         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,
+                            objectType: 'CONTACT',
+                            email: value.email,
                         };
+                    });
+                    // For MULTI_CONTACT_LIST, objectValue should have structure: 
+                    // { "objectType": "MULTI_CONTACT", "values": [{ "objectType": "CONTACT", "email": "..." }, ...] }
+                    // User provides the values array with emails, we add the objectType fields
+                    // Don't include "strict" for MULTI_CONTACT_LIST as it causes parsing errors
+                    // Ensure columnId is a number (not string) for the API
+                    return {
+                        columnId: Number(colIdNum),
+                        objectValue: {
+                            objectType: 'MULTI_CONTACT',
+                            values: contactValues,
+                        },
+                    };
+                }
+                else if (columnType === 'MULTI_PICKLIST') {
+                    // Parse the value as JSON
+                    // Expected format: { "values": ["Option 1", "Option 2", ...] }
+                    let parsedValue;
+                    try {
+                        if (typeof cellValue === 'string') {
+                            parsedValue = JSON.parse(cellValue);
+                        }
+                        else {
+                            parsedValue = cellValue;
+                        }
                     }
-                    else if (columnType === 'MULTI_PICKLIST') {
-                        // Format for MULTI_PICKLIST
-                        let options = [];
-                        if (Array.isArray(parsedValue)) {
-                            options = parsedValue;
+                    catch (error) {
+                        throw new Error(`Invalid JSON for MULTI_PICKLIST column (Column ID: ${colIdNum}). ` +
+                            `Please provide a valid JSON object with structure: { "values": ["Option 1", "Option 2"] }. ` +
+                            `Error: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    // Validate that it's an object with values array
+                    if (typeof parsedValue !== 'object' || parsedValue === null) {
+                        throw new Error(`Invalid objectValue for MULTI_PICKLIST column (Column ID: ${colIdNum}). ` +
+                            `Expected a JSON object with "values" array, got ${typeof parsedValue}.`);
+                    }
+                    // Validate that it has a values array
+                    if (!Array.isArray(parsedValue.values)) {
+                        throw new Error(`Invalid objectValue for MULTI_PICKLIST column (Column ID: ${colIdNum}). ` +
+                            `Expected a JSON object with "values" array property. Example: { "values": ["Option 1", "Option 2"] }`);
+                    }
+                    // For MULTI_PICKLIST, values should be an array of strings, not objects
+                    // Transform values to ensure they're all strings
+                    // Note: Picklist values must match exactly (case-sensitive) the options defined in the column
+                    const picklistValues = parsedValue.values.map((value) => {
+                        // Value should be a string (the option text)
+                        if (typeof value === 'string') {
+                            return value;
                         }
-                        else if (typeof parsedValue === 'string') {
-                            try {
-                                options = JSON.parse(parsedValue);
-                            }
-                            catch {
-                                options = parsedValue.split(',').map((s) => s.trim());
-                            }
+                        else if (typeof value === 'object' && value !== null && value.value) {
+                            // If it's an object with a value property, extract the string value
+                            return String(value.value);
                         }
-                        return {
-                            columnId: colIdNum,
-                            objectValue: {
-                                objectType: 'MULTI_PICKLIST',
-                                values: options,
-                            },
-                        };
+                        else {
+                            throw new Error(`Invalid value in MULTI_PICKLIST values array (Column ID: ${colIdNum}). ` +
+                                `Each value must be a string (option text). ` +
+                                `Note: Option values must match exactly (case-sensitive) the options defined in the MULTI_PICKLIST column.`);
+                        }
+                    });
+                    // For MULTI_PICKLIST, objectValue should have structure: 
+                    // { "objectType": "MULTI_PICKLIST", "values": ["Option 1", "Option 2", ...] }
+                    // User provides the values array with option strings, we use them directly (not wrapped in objects)
+                    // Don't include "strict" for MULTI_PICKLIST as it may cause parsing errors
+                    // Ensure columnId is a number (not string) for the API
+                    return {
+                        columnId: Number(colIdNum),
+                        objectValue: {
+                            objectType: 'MULTI_PICKLIST',
+                            values: picklistValues,
+                        },
+                    };
+                }
+                // For CHECKBOX columns, convert string "true"/"false" to boolean
+                if (columnType === 'CHECKBOX') {
+                    let boolValue;
+                    if (typeof cellValue === 'boolean') {
+                        boolValue = cellValue;
+                    }
+                    else if (typeof cellValue === 'string') {
+                        const lowerValue = cellValue.toLowerCase().trim();
+                        if (lowerValue === 'true' || lowerValue === '1' || lowerValue === 'yes') {
+                            boolValue = true;
+                        }
+                        else if (lowerValue === 'false' || lowerValue === '0' || lowerValue === 'no' || lowerValue === '') {
+                            boolValue = false;
+                        }
+                        else {
+                            // If it's not a recognized boolean string, try to parse it
+                            throw new Error(`Invalid value for CHECKBOX column (Column ID: ${colIdNum}). ` +
+                                `Expected boolean or string "true"/"false", got: ${cellValue}`);
+                        }
+                    }
+                    else if (cellValue === null || cellValue === undefined || cellValue === '') {
+                        boolValue = false;
                     }
+                    else {
+                        // Try to convert to boolean
+                        boolValue = Boolean(cellValue);
+                    }
+                    return {
+                        columnId: Number(colIdNum),
+                        value: boolValue,
+                    };
+                }
+                // For CHECKBOX columns, convert string "true"/"false" to boolean
+                if (columnType === 'CHECKBOX') {
+                    let boolValue;
+                    if (typeof cellValue === 'boolean') {
+                        boolValue = cellValue;
+                    }
+                    else if (typeof cellValue === 'string') {
+                        const lowerValue = cellValue.toLowerCase().trim();
+                        if (lowerValue === 'true' || lowerValue === '1' || lowerValue === 'yes') {
+                            boolValue = true;
+                        }
+                        else if (lowerValue === 'false' || lowerValue === '0' || lowerValue === 'no' || lowerValue === '') {
+                            boolValue = false;
+                        }
+                        else {
+                            // If it's not a recognized boolean string, try to parse it
+                            throw new Error(`Invalid value for CHECKBOX column (Column ID: ${colIdNum}). ` +
+                                `Expected boolean or string "true"/"false", got: ${cellValue}`);
+                        }
+                    }
+                    else if (cellValue === null || cellValue === undefined || cellValue === '') {
+                        boolValue = false;
+                    }
+                    else {
+                        // Try to convert to boolean
+                        boolValue = Boolean(cellValue);
+                    }
+                    return {
+                        columnId: Number(colIdNum),
+                        value: boolValue,
+                    };
                 }
                 // For regular columns, use value (use cleaned cellValue)
+                // Ensure columnId is a number (not string) for the API
                 return {
-                    columnId: colIdNum,
+                    columnId: Number(colIdNum),
                     value: cellValue,
                 };
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-steyi-ss",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "n8n node for Smartsheet API integration",
   "keywords": [
     "n8n-node-package",