n8n-nodes-ca-google-sheets-style 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './nodes/GoogleSheetsStyle/GoogleSheetsStyle.node';

package/dist/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./nodes/GoogleSheetsStyle/GoogleSheetsStyle.node"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1GQUFpRSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbm9kZXMvR29vZ2xlU2hlZXRzU3R5bGUvR29vZ2xlU2hlZXRzU3R5bGUubm9kZSc7XG4iXX0=

package/dist/nodes/GoogleSheetsStyle/GoogleSheetsStyle.node.d.ts

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

package/dist/nodes/GoogleSheetsStyle/GoogleSheetsStyle.node.js

@@ -0,0 +1,393 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleSheetsStyle = void 0;
+// Utility functions
+function parseRange(range) {
+    const match = range.match(/([A-Z]+)(\d+):([A-Z]+)(\d+)/);
+    if (!match) {
+        throw new Error(`Invalid range format: ${range}`);
+    }
+    return {
+        startCol: letterToCol(match[1]),
+        startRow: parseInt(match[2], 10),
+        endCol: letterToCol(match[3]),
+        endRow: parseInt(match[4], 10),
+    };
+}
+function letterToCol(letter) {
+    let col = 0;
+    for (let i = 0; i < letter.length; i++) {
+        col = col * 26 + (letter.charCodeAt(i) - 64);
+    }
+    return col;
+}
+function colToLetter(col) {
+    let letter = '';
+    while (col > 0) {
+        const temp = (col - 1) % 26;
+        letter = String.fromCharCode(temp + 65) + letter;
+        col = Math.floor((col - temp) / 26);
+    }
+    return letter;
+}
+function hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    if (!result) {
+        return { red: 1, green: 1, blue: 1 };
+    }
+    return {
+        red: parseInt(result[1], 16) / 255,
+        green: parseInt(result[2], 16) / 255,
+        blue: parseInt(result[3], 16) / 255,
+    };
+}
+function rgbToHex(rgb) {
+    const r = Math.round((rgb.red || 0) * 255);
+    const g = Math.round((rgb.green || 0) * 255);
+    const b = Math.round((rgb.blue || 0) * 255);
+    return '#' + [r, g, b].map(x => x.toString(16).padStart(2, '0')).join('');
+}
+function extractFormat(format) {
+    const result = {};
+    if (format.backgroundColor) {
+        result.backgroundColor = rgbToHex(format.backgroundColor);
+    }
+    if (format.textFormat) {
+        result.textFormat = {
+            color: format.textFormat.foregroundColor
+                ? rgbToHex(format.textFormat.foregroundColor)
+                : undefined,
+            fontFamily: format.textFormat.fontFamily,
+            fontSize: format.textFormat.fontSize,
+            bold: format.textFormat.bold,
+            italic: format.textFormat.italic,
+            strikethrough: format.textFormat.strikethrough,
+            underline: format.textFormat.underline,
+        };
+    }
+    if (format.horizontalAlignment) {
+        result.horizontalAlignment = format.horizontalAlignment;
+    }
+    if (format.verticalAlignment) {
+        result.verticalAlignment = format.verticalAlignment;
+    }
+    return result;
+}
+class GoogleSheetsStyle {
+    constructor() {
+        this.description = {
+            displayName: 'Google Sheets Style',
+            name: 'googleSheetsStyle',
+            icon: 'file:googleSheets.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Read and write cell styles in Google Sheets',
+            defaults: {
+                name: 'Google Sheets Style',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'googleSheetsOAuth2Api',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Get Style',
+                            value: 'getStyle',
+                            description: 'Get cell formatting/style from a range',
+                            action: 'Get cell style',
+                        },
+                        {
+                            name: 'Set Style',
+                            value: 'setStyle',
+                            description: 'Set cell formatting/style for a range',
+                            action: 'Set cell style',
+                        },
+                    ],
+                    default: 'getStyle',
+                },
+                {
+                    displayName: 'Spreadsheet ID',
+                    name: 'spreadsheetId',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    description: 'The ID of the spreadsheet (from URL)',
+                    placeholder: '1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms',
+                },
+                {
+                    displayName: 'Sheet ID',
+                    name: 'sheetId',
+                    type: 'number',
+                    required: true,
+                    default: 0,
+                    description: 'The ID of the sheet (gid parameter from URL)',
+                },
+                {
+                    displayName: 'Range',
+                    name: 'range',
+                    type: 'string',
+                    required: true,
+                    default: 'A1:B2',
+                    description: 'The A1 notation of the range (e.g., A1:B2)',
+                    placeholder: 'A1:B2',
+                },
+                // Set Style options
+                {
+                    displayName: 'Background Color',
+                    name: 'backgroundColor',
+                    type: 'color',
+                    default: '#ffffff',
+                    displayOptions: {
+                        show: {
+                            operation: ['setStyle'],
+                        },
+                    },
+                    description: 'Background color of the cells',
+                },
+                {
+                    displayName: 'Text Color',
+                    name: 'textColor',
+                    type: 'color',
+                    default: '#000000',
+                    displayOptions: {
+                        show: {
+                            operation: ['setStyle'],
+                        },
+                    },
+                    description: 'Text/foreground color',
+                },
+                {
+                    displayName: 'Font Size',
+                    name: 'fontSize',
+                    type: 'number',
+                    default: 10,
+                    displayOptions: {
+                        show: {
+                            operation: ['setStyle'],
+                        },
+                    },
+                    description: 'Font size in points',
+                },
+                {
+                    displayName: 'Bold',
+                    name: 'bold',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            operation: ['setStyle'],
+                        },
+                    },
+                    description: 'Whether to make text bold',
+                },
+                {
+                    displayName: 'Italic',
+                    name: 'italic',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            operation: ['setStyle'],
+                        },
+                    },
+                    description: 'Whether to make text italic',
+                },
+                {
+                    displayName: 'Horizontal Alignment',
+                    name: 'horizontalAlignment',
+                    type: 'options',
+                    options: [
+                        { name: 'Left', value: 'LEFT' },
+                        { name: 'Center', value: 'CENTER' },
+                        { name: 'Right', value: 'RIGHT' },
+                    ],
+                    default: 'LEFT',
+                    displayOptions: {
+                        show: {
+                            operation: ['setStyle'],
+                        },
+                    },
+                    description: 'Horizontal text alignment',
+                },
+                {
+                    displayName: 'Fields to Update',
+                    name: 'fieldsToUpdate',
+                    type: 'multiOptions',
+                    options: [
+                        { name: 'Background Color', value: 'backgroundColor' },
+                        { name: 'Text Color', value: 'textColor' },
+                        { name: 'Font Size', value: 'fontSize' },
+                        { name: 'Bold', value: 'bold' },
+                        { name: 'Italic', value: 'italic' },
+                        { name: 'Horizontal Alignment', value: 'horizontalAlignment' },
+                    ],
+                    default: ['backgroundColor'],
+                    displayOptions: {
+                        show: {
+                            operation: ['setStyle'],
+                        },
+                    },
+                    description: 'Which style fields to update',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const spreadsheetId = this.getNodeParameter('spreadsheetId', i);
+                const sheetId = this.getNodeParameter('sheetId', i);
+                const range = this.getNodeParameter('range', i);
+                if (operation === 'getStyle') {
+                    const result = await getStyle.call(this, spreadsheetId, sheetId, range);
+                    returnData.push({ json: result });
+                }
+                else if (operation === 'setStyle') {
+                    const result = await setStyle.call(this, spreadsheetId, sheetId, range, i);
+                    returnData.push({ json: result });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.GoogleSheetsStyle = GoogleSheetsStyle;
+async function getStyle(spreadsheetId, sheetId, range) {
+    const { startRow, endRow, startCol, endCol } = parseRange(range);
+    const response = await this.helpers.requestOAuth2.call(this, 'googleSheetsOAuth2Api', {
+        method: 'GET',
+        uri: `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}`,
+        qs: {
+            ranges: range,
+            fields: 'sheets.data.rowData.values.effectiveFormat,sheets.properties',
+        },
+        json: true,
+    });
+    const sheets = response.sheets;
+    if (!sheets || sheets.length === 0) {
+        return { error: 'No sheet data found' };
+    }
+    const sheetData = sheets[0];
+    const data = sheetData.data || [];
+    if (data.length === 0) {
+        return { error: 'No data in range' };
+    }
+    const rowData = data[0].rowData || [];
+    const styles = [];
+    rowData.forEach((row, rowIndex) => {
+        const values = row.values || [];
+        values.forEach((cell, colIndex) => {
+            const format = cell.effectiveFormat || {};
+            styles.push({
+                row: startRow + rowIndex,
+                col: startCol + colIndex,
+                cell: colToLetter(startCol + colIndex) + (startRow + rowIndex),
+                format: extractFormat(format),
+            });
+        });
+    });
+    return {
+        spreadsheetId,
+        sheetId,
+        range,
+        styles,
+    };
+}
+async function setStyle(spreadsheetId, sheetId, range, itemIndex) {
+    const { startRow, endRow, startCol, endCol } = parseRange(range);
+    const fieldsToUpdate = this.getNodeParameter('fieldsToUpdate', itemIndex);
+    const cellFormat = {};
+    const fields = [];
+    if (fieldsToUpdate.includes('backgroundColor')) {
+        const bgColor = this.getNodeParameter('backgroundColor', itemIndex);
+        cellFormat.backgroundColor = hexToRgb(bgColor);
+        fields.push('userEnteredFormat.backgroundColor');
+    }
+    if (fieldsToUpdate.includes('textColor')) {
+        const textColor = this.getNodeParameter('textColor', itemIndex);
+        if (!cellFormat.textFormat)
+            cellFormat.textFormat = {};
+        cellFormat.textFormat.foregroundColor = hexToRgb(textColor);
+        fields.push('userEnteredFormat.textFormat.foregroundColor');
+    }
+    if (fieldsToUpdate.includes('fontSize')) {
+        const fontSize = this.getNodeParameter('fontSize', itemIndex);
+        if (!cellFormat.textFormat)
+            cellFormat.textFormat = {};
+        cellFormat.textFormat.fontSize = fontSize;
+        fields.push('userEnteredFormat.textFormat.fontSize');
+    }
+    if (fieldsToUpdate.includes('bold')) {
+        const bold = this.getNodeParameter('bold', itemIndex);
+        if (!cellFormat.textFormat)
+            cellFormat.textFormat = {};
+        cellFormat.textFormat.bold = bold;
+        fields.push('userEnteredFormat.textFormat.bold');
+    }
+    if (fieldsToUpdate.includes('italic')) {
+        const italic = this.getNodeParameter('italic', itemIndex);
+        if (!cellFormat.textFormat)
+            cellFormat.textFormat = {};
+        cellFormat.textFormat.italic = italic;
+        fields.push('userEnteredFormat.textFormat.italic');
+    }
+    if (fieldsToUpdate.includes('horizontalAlignment')) {
+        const alignment = this.getNodeParameter('horizontalAlignment', itemIndex);
+        cellFormat.horizontalAlignment = alignment;
+        fields.push('userEnteredFormat.horizontalAlignment');
+    }
+    const request = {
+        requests: [
+            {
+                repeatCell: {
+                    range: {
+                        sheetId,
+                        startRowIndex: startRow - 1,
+                        endRowIndex: endRow,
+                        startColumnIndex: startCol - 1,
+                        endColumnIndex: endCol,
+                    },
+                    cell: {
+                        userEnteredFormat: cellFormat,
+                    },
+                    fields: fields.join(','),
+                },
+            },
+        ],
+    };
+    await this.helpers.requestOAuth2.call(this, 'googleSheetsOAuth2Api', {
+        method: 'POST',
+        uri: `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}:batchUpdate`,
+        body: request,
+        json: true,
+    });
+    return {
+        success: true,
+        spreadsheetId,
+        sheetId,
+        range,
+        appliedFormat: cellFormat,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GoogleSheetsStyle.node.js","sourceRoot":"","sources":["../../../src/nodes/GoogleSheetsStyle/GoogleSheetsStyle.node.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tIExecuteFunctions,\n\tINodeExecutionData,\n\tINodeType,\n\tINodeTypeDescription,\n\tIDataObject,\n\tNodeOperationError,\n} from 'n8n-workflow';\n\ninterface CellFormat {\n\tbackgroundColor?: { red?: number; green?: number; blue?: number; alpha?: number };\n\ttextFormat?: {\n\t\tforegroundColor?: { red?: number; green?: number; blue?: number; alpha?: number };\n\t\tfontFamily?: string;\n\t\tfontSize?: number;\n\t\tbold?: boolean;\n\t\titalic?: boolean;\n\t\tstrikethrough?: boolean;\n\t\tunderline?: boolean;\n\t};\n\thorizontalAlignment?: string;\n\tverticalAlignment?: string;\n\twrapStrategy?: string;\n\tborders?: {\n\t\ttop?: BorderStyle;\n\t\tbottom?: BorderStyle;\n\t\tleft?: BorderStyle;\n\t\tright?: BorderStyle;\n\t};\n}\n\ninterface BorderStyle {\n\tstyle?: string;\n\tcolor?: { red?: number; green?: number; blue?: number; alpha?: number };\n}\n\n// Utility functions\nfunction parseRange(range: string): { startRow: number; endRow: number; startCol: number; endCol: number } {\n\tconst match = range.match(/([A-Z]+)(\\d+):([A-Z]+)(\\d+)/);\n\tif (!match) {\n\t\tthrow new Error(`Invalid range format: ${range}`);\n\t}\n\treturn {\n\t\tstartCol: letterToCol(match[1]),\n\t\tstartRow: parseInt(match[2], 10),\n\t\tendCol: letterToCol(match[3]),\n\t\tendRow: parseInt(match[4], 10),\n\t};\n}\n\nfunction letterToCol(letter: string): number {\n\tlet col = 0;\n\tfor (let i = 0; i < letter.length; i++) {\n\t\tcol = col * 26 + (letter.charCodeAt(i) - 64);\n\t}\n\treturn col;\n}\n\nfunction colToLetter(col: number): string {\n\tlet letter = '';\n\twhile (col > 0) {\n\t\tconst temp = (col - 1) % 26;\n\t\tletter = String.fromCharCode(temp + 65) + letter;\n\t\tcol = Math.floor((col - temp) / 26);\n\t}\n\treturn letter;\n}\n\nfunction hexToRgb(hex: string): { red: number; green: number; blue: number } {\n\tconst result = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(hex);\n\tif (!result) {\n\t\treturn { red: 1, green: 1, blue: 1 };\n\t}\n\treturn {\n\t\tred: parseInt(result[1], 16) / 255,\n\t\tgreen: parseInt(result[2], 16) / 255,\n\t\tblue: parseInt(result[3], 16) / 255,\n\t};\n}\n\nfunction rgbToHex(rgb: { red?: number; green?: number; blue?: number }): string {\n\tconst r = Math.round((rgb.red || 0) * 255);\n\tconst g = Math.round((rgb.green || 0) * 255);\n\tconst b = Math.round((rgb.blue || 0) * 255);\n\treturn '#' + [r, g, b].map(x => x.toString(16).padStart(2, '0')).join('');\n}\n\nfunction extractFormat(format: CellFormat): IDataObject {\n\tconst result: IDataObject = {};\n\n\tif (format.backgroundColor) {\n\t\tresult.backgroundColor = rgbToHex(format.backgroundColor);\n\t}\n\n\tif (format.textFormat) {\n\t\tresult.textFormat = {\n\t\t\tcolor: format.textFormat.foregroundColor\n\t\t\t\t? rgbToHex(format.textFormat.foregroundColor)\n\t\t\t\t: undefined,\n\t\t\tfontFamily: format.textFormat.fontFamily,\n\t\t\tfontSize: format.textFormat.fontSize,\n\t\t\tbold: format.textFormat.bold,\n\t\t\titalic: format.textFormat.italic,\n\t\t\tstrikethrough: format.textFormat.strikethrough,\n\t\t\tunderline: format.textFormat.underline,\n\t\t};\n\t}\n\n\tif (format.horizontalAlignment) {\n\t\tresult.horizontalAlignment = format.horizontalAlignment;\n\t}\n\n\tif (format.verticalAlignment) {\n\t\tresult.verticalAlignment = format.verticalAlignment;\n\t}\n\n\treturn result;\n}\n\nexport class GoogleSheetsStyle implements INodeType {\n\tdescription: INodeTypeDescription = {\n\t\tdisplayName: 'Google Sheets Style',\n\t\tname: 'googleSheetsStyle',\n\t\ticon: 'file:googleSheets.svg',\n\t\tgroup: ['transform'],\n\t\tversion: 1,\n\t\tsubtitle: '={{$parameter[\"operation\"]}}',\n\t\tdescription: 'Read and write cell styles in Google Sheets',\n\t\tdefaults: {\n\t\t\tname: 'Google Sheets Style',\n\t\t},\n\t\tinputs: ['main'],\n\t\toutputs: ['main'],\n\t\tcredentials: [\n\t\t\t{\n\t\t\t\tname: 'googleSheetsOAuth2Api',\n\t\t\t\trequired: true,\n\t\t\t},\n\t\t],\n\t\tproperties: [\n\t\t\t{\n\t\t\t\tdisplayName: 'Operation',\n\t\t\t\tname: 'operation',\n\t\t\t\ttype: 'options',\n\t\t\t\tnoDataExpression: true,\n\t\t\t\toptions: [\n\t\t\t\t\t{\n\t\t\t\t\t\tname: 'Get Style',\n\t\t\t\t\t\tvalue: 'getStyle',\n\t\t\t\t\t\tdescription: 'Get cell formatting/style from a range',\n\t\t\t\t\t\taction: 'Get cell style',\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tname: 'Set Style',\n\t\t\t\t\t\tvalue: 'setStyle',\n\t\t\t\t\t\tdescription: 'Set cell formatting/style for a range',\n\t\t\t\t\t\taction: 'Set cell style',\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t\tdefault: 'getStyle',\n\t\t\t},\n\t\t\t{\n\t\t\t\tdisplayName: 'Spreadsheet ID',\n\t\t\t\tname: 'spreadsheetId',\n\t\t\t\ttype: 'string',\n\t\t\t\trequired: true,\n\t\t\t\tdefault: '',\n\t\t\t\tdescription: 'The ID of the spreadsheet (from URL)',\n\t\t\t\tplaceholder: '1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms',\n\t\t\t},\n\t\t\t{\n\t\t\t\tdisplayName: 'Sheet ID',\n\t\t\t\tname: 'sheetId',\n\t\t\t\ttype: 'number',\n\t\t\t\trequired: true,\n\t\t\t\tdefault: 0,\n\t\t\t\tdescription: 'The ID of the sheet (gid parameter from URL)',\n\t\t\t},\n\t\t\t{\n\t\t\t\tdisplayName: 'Range',\n\t\t\t\tname: 'range',\n\t\t\t\ttype: 'string',\n\t\t\t\trequired: true,\n\t\t\t\tdefault: 'A1:B2',\n\t\t\t\tdescription: 'The A1 notation of the range (e.g., A1:B2)',\n\t\t\t\tplaceholder: 'A1:B2',\n\t\t\t},\n\t\t\t// Set Style options\n\t\t\t{\n\t\t\t\tdisplayName: 'Background Color',\n\t\t\t\tname: 'backgroundColor',\n\t\t\t\ttype: 'color',\n\t\t\t\tdefault: '#ffffff',\n\t\t\t\tdisplayOptions: {\n\t\t\t\t\tshow: {\n\t\t\t\t\t\toperation: ['setStyle'],\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tdescription: 'Background color of the cells',\n\t\t\t},\n\t\t\t{\n\t\t\t\tdisplayName: 'Text Color',\n\t\t\t\tname: 'textColor',\n\t\t\t\ttype: 'color',\n\t\t\t\tdefault: '#000000',\n\t\t\t\tdisplayOptions: {\n\t\t\t\t\tshow: {\n\t\t\t\t\t\toperation: ['setStyle'],\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tdescription: 'Text/foreground color',\n\t\t\t},\n\t\t\t{\n\t\t\t\tdisplayName: 'Font Size',\n\t\t\t\tname: 'fontSize',\n\t\t\t\ttype: 'number',\n\t\t\t\tdefault: 10,\n\t\t\t\tdisplayOptions: {\n\t\t\t\t\tshow: {\n\t\t\t\t\t\toperation: ['setStyle'],\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tdescription: 'Font size in points',\n\t\t\t},\n\t\t\t{\n\t\t\t\tdisplayName: 'Bold',\n\t\t\t\tname: 'bold',\n\t\t\t\ttype: 'boolean',\n\t\t\t\tdefault: false,\n\t\t\t\tdisplayOptions: {\n\t\t\t\t\tshow: {\n\t\t\t\t\t\toperation: ['setStyle'],\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tdescription: 'Whether to make text bold',\n\t\t\t},\n\t\t\t{\n\t\t\t\tdisplayName: 'Italic',\n\t\t\t\tname: 'italic',\n\t\t\t\ttype: 'boolean',\n\t\t\t\tdefault: false,\n\t\t\t\tdisplayOptions: {\n\t\t\t\t\tshow: {\n\t\t\t\t\t\toperation: ['setStyle'],\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tdescription: 'Whether to make text italic',\n\t\t\t},\n\t\t\t{\n\t\t\t\tdisplayName: 'Horizontal Alignment',\n\t\t\t\tname: 'horizontalAlignment',\n\t\t\t\ttype: 'options',\n\t\t\t\toptions: [\n\t\t\t\t\t{ name: 'Left', value: 'LEFT' },\n\t\t\t\t\t{ name: 'Center', value: 'CENTER' },\n\t\t\t\t\t{ name: 'Right', value: 'RIGHT' },\n\t\t\t\t],\n\t\t\t\tdefault: 'LEFT',\n\t\t\t\tdisplayOptions: {\n\t\t\t\t\tshow: {\n\t\t\t\t\t\toperation: ['setStyle'],\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tdescription: 'Horizontal text alignment',\n\t\t\t},\n\t\t\t{\n\t\t\t\tdisplayName: 'Fields to Update',\n\t\t\t\tname: 'fieldsToUpdate',\n\t\t\t\ttype: 'multiOptions',\n\t\t\t\toptions: [\n\t\t\t\t\t{ name: 'Background Color', value: 'backgroundColor' },\n\t\t\t\t\t{ name: 'Text Color', value: 'textColor' },\n\t\t\t\t\t{ name: 'Font Size', value: 'fontSize' },\n\t\t\t\t\t{ name: 'Bold', value: 'bold' },\n\t\t\t\t\t{ name: 'Italic', value: 'italic' },\n\t\t\t\t\t{ name: 'Horizontal Alignment', value: 'horizontalAlignment' },\n\t\t\t\t],\n\t\t\t\tdefault: ['backgroundColor'],\n\t\t\t\tdisplayOptions: {\n\t\t\t\t\tshow: {\n\t\t\t\t\t\toperation: ['setStyle'],\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tdescription: 'Which style fields to update',\n\t\t\t},\n\t\t],\n\t};\n\n\tasync execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {\n\t\tconst items = this.getInputData();\n\t\tconst returnData: INodeExecutionData[] = [];\n\t\tconst operation = this.getNodeParameter('operation', 0) as string;\n\n\t\tfor (let i = 0; i < items.length; i++) {\n\t\t\ttry {\n\t\t\t\tconst spreadsheetId = this.getNodeParameter('spreadsheetId', i) as string;\n\t\t\t\tconst sheetId = this.getNodeParameter('sheetId', i) as number;\n\t\t\t\tconst range = this.getNodeParameter('range', i) as string;\n\n\t\t\t\tif (operation === 'getStyle') {\n\t\t\t\t\tconst result = await getStyle.call(this, spreadsheetId, sheetId, range);\n\t\t\t\t\treturnData.push({ json: result });\n\t\t\t\t} else if (operation === 'setStyle') {\n\t\t\t\t\tconst result = await setStyle.call(this, spreadsheetId, sheetId, range, i);\n\t\t\t\t\treturnData.push({ json: result });\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\tif (this.continueOnFail()) {\n\t\t\t\t\treturnData.push({ json: { error: (error as Error).message } });\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tthrow error;\n\t\t\t}\n\t\t}\n\n\t\treturn [returnData];\n\t}\n}\n\nasync function getStyle(\n\tthis: IExecuteFunctions,\n\tspreadsheetId: string,\n\tsheetId: number,\n\trange: string,\n): Promise<IDataObject> {\n\tconst { startRow, endRow, startCol, endCol } = parseRange(range);\n\n\tconst response = await this.helpers.requestOAuth2.call(\n\t\tthis,\n\t\t'googleSheetsOAuth2Api',\n\t\t{\n\t\t\tmethod: 'GET',\n\t\t\turi: `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}`,\n\t\t\tqs: {\n\t\t\t\tranges: range,\n\t\t\t\tfields: 'sheets.data.rowData.values.effectiveFormat,sheets.properties',\n\t\t\t},\n\t\t\tjson: true,\n\t\t},\n\t);\n\n\tconst sheets = (response as IDataObject).sheets as IDataObject[];\n\tif (!sheets || sheets.length === 0) {\n\t\treturn { error: 'No sheet data found' };\n\t}\n\n\tconst sheetData = sheets[0] as IDataObject;\n\tconst data = (sheetData.data as IDataObject[]) || [];\n\tif (data.length === 0) {\n\t\treturn { error: 'No data in range' };\n\t}\n\n\tconst rowData = (data[0] as IDataObject).rowData as IDataObject[] || [];\n\tconst styles: IDataObject[] = [];\n\n\trowData.forEach((row, rowIndex) => {\n\t\tconst values = (row.values as IDataObject[]) || [];\n\t\tvalues.forEach((cell, colIndex) => {\n\t\t\tconst format = cell.effectiveFormat as CellFormat || {};\n\t\t\tstyles.push({\n\t\t\t\trow: startRow + rowIndex,\n\t\t\t\tcol: startCol + colIndex,\n\t\t\t\tcell: colToLetter(startCol + colIndex) + (startRow + rowIndex),\n\t\t\t\tformat: extractFormat(format),\n\t\t\t});\n\t\t});\n\t});\n\n\treturn {\n\t\tspreadsheetId,\n\t\tsheetId,\n\t\trange,\n\t\tstyles,\n\t};\n}\n\nasync function setStyle(\n\tthis: IExecuteFunctions,\n\tspreadsheetId: string,\n\tsheetId: number,\n\trange: string,\n\titemIndex: number,\n): Promise<IDataObject> {\n\tconst { startRow, endRow, startCol, endCol } = parseRange(range);\n\tconst fieldsToUpdate = this.getNodeParameter('fieldsToUpdate', itemIndex) as string[];\n\n\tconst cellFormat: IDataObject = {};\n\tconst fields: string[] = [];\n\n\tif (fieldsToUpdate.includes('backgroundColor')) {\n\t\tconst bgColor = this.getNodeParameter('backgroundColor', itemIndex) as string;\n\t\tcellFormat.backgroundColor = hexToRgb(bgColor);\n\t\tfields.push('userEnteredFormat.backgroundColor');\n\t}\n\n\tif (fieldsToUpdate.includes('textColor')) {\n\t\tconst textColor = this.getNodeParameter('textColor', itemIndex) as string;\n\t\tif (!cellFormat.textFormat) cellFormat.textFormat = {};\n\t\t(cellFormat.textFormat as IDataObject).foregroundColor = hexToRgb(textColor);\n\t\tfields.push('userEnteredFormat.textFormat.foregroundColor');\n\t}\n\n\tif (fieldsToUpdate.includes('fontSize')) {\n\t\tconst fontSize = this.getNodeParameter('fontSize', itemIndex) as number;\n\t\tif (!cellFormat.textFormat) cellFormat.textFormat = {};\n\t\t(cellFormat.textFormat as IDataObject).fontSize = fontSize;\n\t\tfields.push('userEnteredFormat.textFormat.fontSize');\n\t}\n\n\tif (fieldsToUpdate.includes('bold')) {\n\t\tconst bold = this.getNodeParameter('bold', itemIndex) as boolean;\n\t\tif (!cellFormat.textFormat) cellFormat.textFormat = {};\n\t\t(cellFormat.textFormat as IDataObject).bold = bold;\n\t\tfields.push('userEnteredFormat.textFormat.bold');\n\t}\n\n\tif (fieldsToUpdate.includes('italic')) {\n\t\tconst italic = this.getNodeParameter('italic', itemIndex) as boolean;\n\t\tif (!cellFormat.textFormat) cellFormat.textFormat = {};\n\t\t(cellFormat.textFormat as IDataObject).italic = italic;\n\t\tfields.push('userEnteredFormat.textFormat.italic');\n\t}\n\n\tif (fieldsToUpdate.includes('horizontalAlignment')) {\n\t\tconst alignment = this.getNodeParameter('horizontalAlignment', itemIndex) as string;\n\t\tcellFormat.horizontalAlignment = alignment;\n\t\tfields.push('userEnteredFormat.horizontalAlignment');\n\t}\n\n\tconst request = {\n\t\trequests: [\n\t\t\t{\n\t\t\t\trepeatCell: {\n\t\t\t\t\trange: {\n\t\t\t\t\t\tsheetId,\n\t\t\t\t\t\tstartRowIndex: startRow - 1,\n\t\t\t\t\t\tendRowIndex: endRow,\n\t\t\t\t\t\tstartColumnIndex: startCol - 1,\n\t\t\t\t\t\tendColumnIndex: endCol,\n\t\t\t\t\t},\n\t\t\t\t\tcell: {\n\t\t\t\t\t\tuserEnteredFormat: cellFormat,\n\t\t\t\t\t},\n\t\t\t\t\tfields: fields.join(','),\n\t\t\t\t},\n\t\t\t},\n\t\t],\n\t};\n\n\tawait this.helpers.requestOAuth2.call(\n\t\tthis,\n\t\t'googleSheetsOAuth2Api',\n\t\t{\n\t\t\tmethod: 'POST',\n\t\t\turi: `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}:batchUpdate`,\n\t\t\tbody: request,\n\t\t\tjson: true,\n\t\t},\n\t);\n\n\treturn {\n\t\tsuccess: true,\n\t\tspreadsheetId,\n\t\tsheetId,\n\t\trange,\n\t\tappliedFormat: cellFormat,\n\t};\n}\n"]}

package/dist/nodes/googleSheets.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="60" height="60"><g fill="none" fill-rule="evenodd" stroke-linecap="round" stroke-linejoin="round"><path fill="#28B446" d="M35.69 1 52 17.225v39.087a3.67 3.67 0 0 1-1.084 2.61A3.7 3.7 0 0 1 48.293 60H12.707a3.7 3.7 0 0 1-2.623-1.078A3.67 3.67 0 0 1 9 56.312V4.688a3.67 3.67 0 0 1 1.084-2.61A3.7 3.7 0 0 1 12.707 1z"/><path fill="#6ACE7C" d="M35.69 1 52 17.225H39.397c-2.054 0-3.707-1.829-3.707-3.872z"/><path fill="#219B38" d="M39.211 17.225 52 22.48v-5.255z"/><path fill="#FFF" d="M20.12 31.975c0-.817.662-1.475 1.483-1.475h17.794c.821 0 1.482.658 1.482 1.475v15.487c0 .818-.661 1.475-1.482 1.475H21.603a1.476 1.476 0 0 1-1.482-1.474V31.974zm2.225 1.475h6.672v2.212h-6.672zm0 5.162h6.672v2.213h-6.672zm0 5.163h6.672v2.212h-6.672zm9.638-10.325h6.672v2.212h-6.672zm0 5.162h6.672v2.213h-6.672zm0 5.163h6.672v2.212h-6.672z"/><path fill="#28B446" d="M34.69 0 51 16.225v39.087a3.67 3.67 0 0 1-1.084 2.61A3.7 3.7 0 0 1 47.293 59H11.707a3.7 3.7 0 0 1-2.623-1.078A3.67 3.67 0 0 1 8 55.312V3.688a3.67 3.67 0 0 1 1.084-2.61A3.7 3.7 0 0 1 11.707 0z"/><path fill="#6ACE7C" d="M34.69 0 51 16.225H38.397c-2.054 0-3.707-1.829-3.707-3.872z"/><path fill="#219B38" d="M38.211 16.225 51 21.48v-5.255z"/><path fill="#FFF" d="M19.12 30.975c0-.817.662-1.475 1.483-1.475h17.794c.821 0 1.482.658 1.482 1.475v15.487c0 .818-.661 1.475-1.482 1.475H20.603a1.476 1.476 0 0 1-1.482-1.474V30.974zm2.225 1.475h6.672v2.212h-6.672zm0 5.162h6.672v2.213h-6.672zm0 5.163h6.672v2.212h-6.672zm9.638-10.325h6.672v2.212h-6.672zm0 5.162h6.672v2.213h-6.672zm0 5.163h6.672v2.212h-6.672z"/></g></svg>

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "n8n-nodes-ca-google-sheets-style",
+  "version": "0.1.0",
+  "description": "n8n node for Google Sheets cell styling (read/write formatting)",
+  "keywords": [
+    "n8n-community-node-package",
+    "google-sheets",
+    "formatting",
+    "style"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "junwoobang"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mineclover/n8n-nodes-custom.git",
+    "directory": "packages/google-sheets-style"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc && cp -r src/nodes/**/*.svg dist/nodes/ 2>/dev/null || true",
+    "dev": "tsc --watch",
+    "lint": "eslint . --ext .ts",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [],
+    "nodes": [
+      "dist/nodes/GoogleSheetsStyle/GoogleSheetsStyle.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}