@guayaba/workflow-piece-google-sheets 0.14.6

package/src/index.ts

@@ -0,0 +1,93 @@
+import { createCustomApiCallAction } from '@guayaba/workflows-common';
+import { createPiece } from '@guayaba/workflows-framework';
+import { PieceCategory } from '@guayaba/workflows-shared';
+import { clearSheetAction } from './lib/actions/clear-sheet';
+import { deleteRowAction } from './lib/actions/delete-row.action';
+import { findRowByNumAction } from './lib/actions/find-row-by-num';
+import { findRowsAction } from './lib/actions/find-rows';
+import { getRowsAction } from './lib/actions/get-rows';
+import { insertRowAction } from './lib/actions/insert-row.action';
+import { updateRowAction } from './lib/actions/update-row';
+import {
+	getAccessToken,
+	googleSheetsAuth,
+	GoogleSheetsAuthValue,
+	googleSheetsCommon,
+} from './lib/common/common';
+import { newRowAddedTrigger } from './lib/triggers/new-row-added-webhook';
+import { newOrUpdatedRowTrigger } from './lib/triggers/new-or-updated-row.trigger';
+import { insertMultipleRowsAction } from './lib/actions/insert-multiple-rows.action';
+import { createWorksheetAction } from './lib/actions/create-worksheet';
+import { createSpreadsheetAction } from './lib/actions/create-spreadsheet';
+import { findSpreadsheets } from './lib/actions/find-spreadsheets';
+import { newSpreadsheetTrigger } from './lib/triggers/new-spreadsheet';
+import { newWorksheetTrigger } from './lib/triggers/new-worksheet';
+import { findWorksheetAction } from './lib/actions/find-worksheet';
+import { copyWorksheetAction } from './lib/actions/copy-worksheet';
+import { updateMultipleRowsAction } from './lib/actions/update-multiple-rows';
+import { createColumnAction } from './lib/actions/create-column';
+import { exportSheetAction } from './lib/actions/export-sheet';
+import { getManyRowsAction } from './lib/actions/get-many-rows';
+import { renameWorksheetAction } from './lib/actions/rename-worksheet';
+import { deleteWorksheetAction } from './lib/actions/delete-worksheet';
+import { formatRowAction } from './lib/actions/format-spreadsheet-row';
+
+export const googleSheets = createPiece({
+	minimumSupportedRelease: '0.71.4',
+	logoUrl: 'https://cdn.activepieces.com/pieces/google-sheets.png',
+	categories: [PieceCategory.PRODUCTIVITY],
+	authors: [
+		'ShayPunter',
+		'Ozak93',
+		'Abdallah-Alwarawreh',
+		'Salem-Alaa',
+		'kishanprmr',
+		'MoShizzle',
+		'AbdulTheActivePiecer',
+		'khaledmashaly',
+		'abuaboud',
+		'geekyme',
+	],
+	actions: [
+		insertRowAction,
+		insertMultipleRowsAction,
+		updateRowAction,
+		updateMultipleRowsAction,
+		deleteRowAction,
+		findRowsAction,
+		createSpreadsheetAction,
+		createWorksheetAction,
+		clearSheetAction,
+		deleteWorksheetAction,
+		renameWorksheetAction,
+		formatRowAction,
+		findRowByNumAction,
+		getRowsAction,
+		getManyRowsAction,
+		findSpreadsheets,
+		findWorksheetAction,
+		copyWorksheetAction,
+		createColumnAction,
+		exportSheetAction,
+		createCustomApiCallAction({
+			auth: googleSheetsAuth,
+			baseUrl: () => {
+				return googleSheetsCommon.baseUrl;
+			},
+			authMapping: async (auth) => {
+				return {
+					Authorization: `Bearer ${await getAccessToken(auth as GoogleSheetsAuthValue)}`,
+				};
+			},
+		}),
+	],
+	displayName: 'Google Sheets',
+	description: 'Create, edit, and collaborate on spreadsheets online',
+	triggers: [
+		newOrUpdatedRowTrigger,
+		newRowAddedTrigger,
+		newSpreadsheetTrigger,
+		newWorksheetTrigger,
+	],
+	auth: googleSheetsAuth,
+});

package/src/lib/actions/clear-sheet.ts

@@ -0,0 +1,60 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { areSheetIdsValid, googleSheetsCommon } from '../common/common';
+import { googleSheetsAuth } from '../common/common';
+import { commonProps, isFirstRowHeaderProp } from '../common/props';
+
+export const clearSheetAction = createAction({
+	auth: googleSheetsAuth,
+	name: 'clear_sheet',
+	description: 'Clears all rows on an existing sheet.',
+	displayName: 'Clear Sheet',
+	props: {
+		...commonProps,
+		is_first_row_headers: isFirstRowHeaderProp(),
+		headerRow: Property.Number({
+			displayName: 'Header Row Number',
+			description: 'Enter the row number where your column headers are located (usually row 1).',
+			required: true,
+			defaultValue: 1,
+		}),
+	},
+	async run({ propsValue, auth }) {
+		const {
+			spreadsheetId,
+			sheetId,
+			is_first_row_headers: isFirstRowHeaders,
+			headerRow,
+		} = propsValue;
+
+		if (!areSheetIdsValid(spreadsheetId, sheetId)) {
+			throw new Error('Please select a spreadsheet and sheet first.');
+		}
+		await googleSheetsCommon.findSheetName(auth, spreadsheetId as string, sheetId as number);
+
+		const rowsToDelete: number[] = [];
+		const values = await googleSheetsCommon.getGoogleSheetRows({
+			spreadsheetId: spreadsheetId as string,
+			auth: auth,
+			sheetId: sheetId as number,
+			rowIndex_s: 1,
+			rowIndex_e: undefined,
+			headerRow: headerRow,
+		});
+		for (const key in values) {
+			if (key === '0' && isFirstRowHeaders) {
+				continue;
+			}
+			rowsToDelete.push(parseInt(key) + 1);
+		}
+
+		const response = await googleSheetsCommon.clearSheet(
+			spreadsheetId as string,
+			sheetId as number,
+			auth,
+			isFirstRowHeaders ? 1 : 0,
+			rowsToDelete.length,
+		);
+
+		return response.body;
+	},
+});

package/src/lib/actions/copy-worksheet.ts

@@ -0,0 +1,32 @@
+import { googleSheetsAuth } from '../common/common';
+import { createAction } from '@guayaba/workflows-framework';
+import { includeTeamDrivesProp, sheetIdProp, spreadsheetIdProp } from '../common/props';
+import { google } from 'googleapis';
+import { createGoogleClient } from '../common/common';
+
+export const copyWorksheetAction = createAction({
+	auth: googleSheetsAuth,
+	name: 'copy-worksheet',
+	displayName: 'Copy Worksheet',
+	description: 'Creates a new worksheet by copying an existing one.',
+	props: {
+		includeTeamDrives: includeTeamDrivesProp(),
+		spreadsheetId: spreadsheetIdProp('Spreadsheet Containing the Worksheet to Copy', ''),
+		sheetId: sheetIdProp('Worksheet to Copy', ''),
+		desinationSpeadsheetId: spreadsheetIdProp('Spreadsheet to paste in', ''),
+	},
+	async run(context) {
+		const authClient = await createGoogleClient(context.auth);
+		const sheets = google.sheets({ version: 'v4', auth: authClient });
+
+		const response = await sheets.spreadsheets.sheets.copyTo({
+			spreadsheetId: context.propsValue.spreadsheetId,
+			sheetId: context.propsValue.sheetId,
+			requestBody: {
+				destinationSpreadsheetId: context.propsValue.desinationSpeadsheetId,
+			},
+		});
+
+		return response.data;
+	},
+});

package/src/lib/actions/create-column.ts

@@ -0,0 +1,109 @@
+import { googleSheetsAuth } from '../common/common';
+import { createAction, Property } from '@guayaba/workflows-framework';
+import {
+	areSheetIdsValid,
+	columnToLabel,
+	createGoogleClient,
+	getHeaderRow,
+	ValueInputOption,
+} from '../common/common';
+import { google } from 'googleapis';
+import { getWorkSheetName } from '../triggers/helpers';
+import { commonProps } from '../common/props';
+
+export const createColumnAction = createAction({
+	auth: googleSheetsAuth,
+	name: 'create-column',
+	displayName: 'Create Spreadsheet Column',
+	description: 'Creates a new column in a specific spreadsheet.',
+	props: {
+		...commonProps,
+		columnName: Property.ShortText({
+			displayName: 'Column Name',
+			required: true,
+		}),
+		columnIndex: Property.Number({
+			displayName: 'Column Index',
+			description:
+				'The column index starts from 1.For example, if you want to add a column to the third column, enter 3.Ff the input is less than 1 the column will be added after the last current column.',
+			required: false,
+		}),
+	},
+	async run(context) {
+		const { spreadsheetId, sheetId, columnName, columnIndex } = context.propsValue;
+
+		if (!areSheetIdsValid(spreadsheetId, sheetId)) {
+			throw new Error('Please select a spreadsheet and sheet first.');
+		}
+
+		const authClient = await createGoogleClient(context.auth);
+		const sheets = google.sheets({ version: 'v4', auth: authClient });
+
+		let columnLabel;
+
+		if (columnIndex && columnIndex > 0) {
+			await sheets.spreadsheets.batchUpdate({
+				spreadsheetId,
+				requestBody: {
+					requests: [
+						{
+							insertDimension: {
+								range: {
+									sheetId,
+									dimension: 'COLUMNS',
+									startIndex: columnIndex - 1,
+									endIndex: columnIndex,
+								},
+							},
+						},
+					],
+				},
+			});
+			columnLabel = columnToLabel(columnIndex - 1);
+		} else {
+			const headers = await getHeaderRow({
+				spreadsheetId: spreadsheetId as string,
+				sheetId: sheetId as number,
+				auth: context.auth,
+			});
+
+			const newColumnIndex = headers === undefined ? 0 : headers.length;
+
+			await sheets.spreadsheets.batchUpdate({
+				spreadsheetId,
+				requestBody: {
+					requests: [
+						{
+							insertDimension: {
+								range: {
+									sheetId,
+									dimension: 'COLUMNS',
+									startIndex: newColumnIndex,
+									endIndex: newColumnIndex + 1,
+								},
+							},
+						},
+					],
+				},
+			});
+			columnLabel = columnToLabel(newColumnIndex);
+		}
+
+		const sheetName = await getWorkSheetName(
+			context.auth,
+			spreadsheetId as string,
+			sheetId as number,
+		);
+
+		const response = await sheets.spreadsheets.values.update({
+			range: `${sheetName}!${columnLabel}1`,
+			spreadsheetId,
+			valueInputOption: ValueInputOption.USER_ENTERED,
+			requestBody: {
+				values: [[columnName]],
+			},
+		});
+
+		return response.data;
+	},
+});

package/src/lib/actions/create-spreadsheet.ts

@@ -0,0 +1,122 @@
+import {
+	AppConnectionValueForAuthProperty,
+	createAction,
+	PiecePropValueSchema,
+	Property,
+} from '@guayaba/workflows-framework';
+import {
+	AuthenticationType,
+	httpClient,
+	HttpMethod,
+	HttpRequest,
+} from '@guayaba/workflows-common';
+import { google } from 'googleapis';
+import { includeTeamDrivesProp } from '../common/props';
+import { createGoogleClient, getAccessToken, googleSheetsAuth } from '../common/common';
+import { AppConnectionType, isNil } from '@guayaba/workflows-shared';
+
+export const createSpreadsheetAction = createAction({
+	auth: googleSheetsAuth,
+	name: 'create-spreadsheet',
+	displayName: 'Create Spreadsheet',
+	description: 'Creates a blank spreadsheet.',
+	props: {
+		title: Property.ShortText({
+			displayName: 'Title',
+			description: 'The title of the new spreadsheet.',
+			required: true,
+		}),
+		includeTeamDrives: includeTeamDrivesProp(),
+		folder: Property.Dropdown({
+			auth: googleSheetsAuth,
+			displayName: 'Parent Folder',
+			description:
+				'The folder to create the worksheet in.By default, the new worksheet is created in the root folder of drive.',
+			required: false,
+			refreshers: ['auth', 'includeTeamDrives'],
+			options: async ({ auth, includeTeamDrives }) => {
+				if (!auth) {
+					return {
+						disabled: true,
+						options: [],
+						placeholder: 'Please authenticate first',
+					};
+				}
+				const authProp = auth;
+				let folders: { id: string; name: string }[] = [];
+				const isServiceAccountWithoutImpersonation = authProp.type === AppConnectionType.CUSTOM_AUTH && authProp.props.userEmail?.length === 0;
+				let pageToken = null;
+				do {
+					const request: HttpRequest = {
+						method: HttpMethod.GET,
+						url: `https://www.googleapis.com/drive/v3/files`,
+						queryParams: {
+							q: "mimeType='application/vnd.google-apps.folder' and trashed = false",
+							includeItemsFromAllDrives: includeTeamDrives || isServiceAccountWithoutImpersonation ? 'true' : 'false',
+							supportsAllDrives: 'true',
+						},
+						authentication: {
+							type: AuthenticationType.BEARER_TOKEN,
+							token: await getAccessToken(authProp),
+						},
+					};
+					if (pageToken) {
+						if (request.queryParams !== undefined) {
+							request.queryParams['pageToken'] = pageToken;
+						}
+					}
+					try {
+						const response = await httpClient.sendRequest<{
+							files: { id: string; name: string,teamDriveId?: string }[];
+							nextPageToken: string;
+						}>(request);
+						folders = folders.concat(response.body.files.filter(file => !isNil(file.teamDriveId) || !isServiceAccountWithoutImpersonation));
+						pageToken = response.body.nextPageToken;
+					} catch (e) {
+						throw new Error(`Failed to get folders\nError:${e}`);
+					}
+				} while (pageToken);
+
+				return {
+					disabled: false,
+					options: folders.map((folder: { id: string; name: string }) => {
+						return {
+							label: folder.name,
+							value: folder.id,
+						};
+					}),
+				};
+			},
+		}),
+	},
+	async run(context) {
+		const { title, folder } = context.propsValue;
+		const response = await createSpreadsheet(context.auth, title, folder);
+		const newSpreadsheetId = response.id;
+
+	
+
+		return {
+			id: newSpreadsheetId,
+		};
+	},
+});
+
+async function createSpreadsheet(
+	auth: AppConnectionValueForAuthProperty<typeof googleSheetsAuth>,
+	title: string,
+	folderId?: string,
+) {
+	const googleClient = await createGoogleClient(auth);
+  const driveApi = google.drive({ version: 'v3', auth: googleClient });
+  const response = await driveApi.files.create({
+    requestBody: {
+      name: title,
+      mimeType: 'application/vnd.google-apps.spreadsheet',
+      parents: folderId ? [folderId] : undefined,
+    },
+    supportsAllDrives: true,
+  });
+  return response.data;
+}
+

package/src/lib/actions/create-worksheet.ts

@@ -0,0 +1,62 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { createGoogleClient } from '../common/common';
+import { googleSheetsAuth } from '../common/common';
+import { includeTeamDrivesProp, spreadsheetIdProp } from '../common/props';
+import { google } from 'googleapis';
+
+export const createWorksheetAction = createAction({
+  auth: googleSheetsAuth,
+  name: 'create-worksheet',
+  displayName: 'Create Worksheet',
+  description:'Create a new blank worksheet with a title.',
+  props: {
+    includeTeamDrives: includeTeamDrivesProp(),
+    spreadsheetId: spreadsheetIdProp('Spreadsheet',''),
+    title:Property.ShortText({
+        displayName:'Title',
+        description:'The title of the new worksheet.',
+        required:true
+    }),
+    headers:Property.Array({
+        displayName:'Headers',
+        required:false
+    })
+   
+  },
+  async run(context){
+    const {spreadsheetId,title} = context.propsValue;
+    const headers = context.propsValue.headers as string[] ?? [];
+	const client = await createGoogleClient(context.auth);
+    const sheetsApi = google.sheets({ version: 'v4', auth: client });
+    const sheet = await sheetsApi.spreadsheets.batchUpdate({
+        spreadsheetId:spreadsheetId,
+        requestBody:{
+            requests:[
+                {
+                    addSheet:{
+                        properties:{
+                            title:title
+                        },
+                    },
+                    
+                }
+            ]
+        }
+    });
+    const addHeadersResponse = await sheetsApi.spreadsheets.values.append({
+        spreadsheetId,
+        range:`${context.propsValue.title}!A1`,
+        valueInputOption:'RAW',
+        requestBody:{
+            majorDimension:'ROWS',
+            values:[headers]
+        }
+    });
+
+    return {
+        id: sheet.data?.replies?.[0]?.addSheet?.properties?.sheetId,
+        ...addHeadersResponse.data
+    }
+    
+
+  }})

package/src/lib/actions/delete-row.action.ts

@@ -0,0 +1,40 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { areSheetIdsValid, googleSheetsCommon } from '../common/common';
+import { googleSheetsAuth } from '../common/common';
+import { commonProps } from '../common/props';
+
+export const deleteRowAction = createAction({
+  auth: googleSheetsAuth,
+  name: 'delete_row',
+  description: 'Delete a specific row from the selected sheet.',
+  displayName: 'Delete Row',
+  props: {
+    ...commonProps,
+    rowId: Property.Number({
+      displayName: 'Row Number',
+      description: 'The number of the row you want to delete.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { spreadsheetId, sheetId, rowId } = context.propsValue;
+
+    if (!areSheetIdsValid(spreadsheetId,sheetId)) {
+			throw new Error('Please select a spreadsheet and sheet first.');
+		}
+
+    // Subtract 1 from the row_id to convert it to 0-indexed
+    const adjustedRowIndex = rowId - 1;
+    const response = await googleSheetsCommon.deleteRow(
+      spreadsheetId as string,
+      sheetId as number,
+      adjustedRowIndex,
+      context.auth,
+    );
+
+    return {
+      success: true,
+      body: response,
+    };
+  },
+});

package/src/lib/actions/delete-worksheet.ts

@@ -0,0 +1,36 @@
+import { googleSheetsAuth } from '../common/common';
+import { createAction } from '@guayaba/workflows-framework';
+import { includeTeamDrivesProp, sheetIdProp, spreadsheetIdProp } from '../common/props';
+import { google } from 'googleapis';
+import { createGoogleClient } from '../common/common';
+
+export const deleteWorksheetAction = createAction({
+    auth: googleSheetsAuth,
+    name: 'delete-worksheet',
+    displayName: 'Delete Worksheet',
+    description: 'Permanently delete a specific worksheet.',
+    props: {
+        includeTeamDrives: includeTeamDrivesProp(),
+        spreadsheetId: spreadsheetIdProp('Spreadsheet', 'The ID of the spreadsheet to use.'),
+        sheetId: sheetIdProp('Worksheet', 'The ID of the worksheet to delete.'),
+    },
+    async run(context) {
+        const authClient = await createGoogleClient(context.auth);
+        const sheets = google.sheets({ version: 'v4', auth: authClient });
+
+        const response = await sheets.spreadsheets.batchUpdate({
+            spreadsheetId: context.propsValue.spreadsheetId,
+            requestBody: {
+                requests:[
+                    {
+                       deleteSheet:{
+                        sheetId:context.propsValue.sheetId
+                       }
+                    }
+                ]
+            },
+        });
+
+        return response.data;
+    },
+});

package/src/lib/actions/export-sheet.ts

@@ -0,0 +1,86 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import {
+  httpClient,
+  HttpMethod,
+  AuthenticationType,
+} from '@guayaba/workflows-common';
+import { googleSheetsAuth } from '../common/common';
+import { commonProps } from '../common/props';
+import { areSheetIdsValid, getAccessToken } from '../common/common';
+
+export const exportSheetAction = createAction({
+  name: 'export_sheet',
+  displayName: 'Export Worksheet',
+  description: 'Download a worksheet as a CSV or TSV file.',
+  auth: googleSheetsAuth,
+  props: {
+    ...commonProps,
+    format: Property.StaticDropdown({
+      displayName: 'Export Format',
+      description: 'Select the file type to export the sheet as.',
+      required: true,
+      defaultValue: 'csv',
+      options: {
+        disabled: false,
+        options: [
+          { label: 'Comma Separated Values (.csv)', value: 'csv' },
+          { label: 'Tab Separated Values (.tsv)', value: 'tsv' },
+        ],
+      },
+    }),
+    returnAsText: Property.Checkbox({
+      displayName: 'Return as Text',
+      description: 'Return the exported data as text instead of a file.',
+      required: false,
+      defaultValue: false,
+    }),
+  },
+  async run({ propsValue, auth, files }) {
+    const { spreadsheetId, sheetId, format, returnAsText } = propsValue;
+
+    if (!areSheetIdsValid(spreadsheetId, sheetId)) {
+      throw new Error('Please select a spreadsheet and sheet first.');
+    }
+
+    const spreadsheet_id = spreadsheetId as string;
+    const sheet_id = sheetId as number;
+
+    const exportUrl = `https://docs.google.com/spreadsheets/d/${spreadsheet_id}/export?format=${format}&id=${spreadsheet_id}&gid=${sheet_id}`;
+
+    try {
+      const response = await httpClient.sendRequest({
+        method: HttpMethod.GET,
+        url: exportUrl,
+        authentication: {
+          type: AuthenticationType.BEARER_TOKEN,
+          token: await getAccessToken(auth),
+        },
+        responseType: 'arraybuffer',
+        followRedirects: true,
+      });
+
+      if (returnAsText) {
+        const textData = Buffer.from(response.body).toString('utf-8');
+        return {
+          text: textData,
+          format,
+        };
+      } else {
+        const filename = `exported_sheet.${format}`;
+
+        const file = await files.write({
+          fileName: filename,
+          data: Buffer.from(response.body),
+        });
+
+        return {
+          file,
+          filename,
+          format,
+        };
+      }
+    } catch (error) {
+      throw new Error(`Failed to export sheet: ${error}`);
+    }
+  },
+});

package/src/lib/actions/find-row-by-num.ts

@@ -0,0 +1,42 @@
+import { Property, createAction } from '@guayaba/workflows-framework';
+import { areSheetIdsValid, googleSheetsCommon } from '../common/common';
+import { googleSheetsAuth } from '../common/common';
+import { commonProps } from '../common/props';
+
+export const findRowByNumAction = createAction({
+	auth: googleSheetsAuth,
+	name: 'find_row_by_num',
+	displayName: 'Get Single Row by ID',
+	description: 'Retrieve a specific row using its unique ID.',
+	props: {
+		...commonProps,
+		rowNumber: Property.Number({
+			displayName: 'Row Number',
+			description: 'Enter the row number you want to retrieve',
+			required: true,
+		}),
+		headerRow: Property.Number({
+			displayName: 'Header Row Number',
+			description: 'Enter the row number where your column headers are located (usually row 1).',
+			required: true,
+			defaultValue: 1,
+		}),
+	},
+	async run(context) {
+		const { spreadsheetId, sheetId, rowNumber, headerRow } = context.propsValue;
+
+		if (!areSheetIdsValid(spreadsheetId, sheetId)) {
+			throw new Error('Please select a spreadsheet and sheet first.');
+		}
+
+		const row = await googleSheetsCommon.getGoogleSheetRows({
+			auth: context.auth,
+			sheetId: sheetId as number,
+			spreadsheetId: spreadsheetId as string,
+			rowIndex_s: rowNumber,
+			rowIndex_e: rowNumber,
+			headerRow: headerRow,
+		});
+		return row[0];
+	},
+});