@guayaba/workflow-piece-google-sheets 0.14.6

package/src/lib/common/props.ts

@@ -0,0 +1,274 @@
+import { DropdownOption, Property } from '@guayaba/workflows-framework';
+import { google, drive_v3 } from 'googleapis';
+import {
+	columnToLabel,
+	createGoogleClient,
+	getHeaderRow,
+	googleSheetsAuth,
+	GoogleSheetsAuthValue,
+	googleSheetsCommon,
+} from './common';
+import { isNil } from '@guayaba/workflows-shared';
+
+const createEmptyOptionList = (message: string) => {
+	return {
+		disabled: true,
+		placeholder: message,
+		options: [],
+	};
+};
+
+export const includeTeamDrivesProp = () =>
+	Property.Checkbox({
+		displayName: 'Include Shared Drive Sheets ?',
+		description: 'Turn this on to also see spreadsheets from Shared Drives.',
+		defaultValue: false,
+		required: false,
+	});
+
+export const spreadsheetIdProp = (displayName: string, description: string, required = true) =>
+	Property.Dropdown({
+		displayName,
+		description,
+		auth: googleSheetsAuth,
+		required,
+		refreshers: ['includeTeamDrives'],
+		options: async ({ auth, includeTeamDrives }, { searchValue }) => {
+			if (!auth) {
+				return createEmptyOptionList('please connect your account first.');
+			}
+
+			const authValue = auth;
+
+			const authClient = await createGoogleClient(authValue);
+
+			const drive = google.drive({ version: 'v3', auth: authClient });
+
+			const q = ["mimeType='application/vnd.google-apps.spreadsheet'", 'trashed = false'];
+
+			if (searchValue) {
+				q.push(`name contains '${searchValue}'`);
+			}
+
+			let nextPageToken;
+			const options: DropdownOption<string>[] = [];
+			do {
+				const response: any = await drive.files.list({
+					q: q.join(' and '),
+					pageToken: nextPageToken,
+					orderBy: 'createdTime desc',
+					fields: 'nextPageToken, files(id, name)',
+					supportsAllDrives: true,
+					includeItemsFromAllDrives: includeTeamDrives ? true : false,
+				});
+				const fileList: drive_v3.Schema$FileList = response.data;
+
+				if (fileList.files) {
+					for (const file of fileList.files) {
+						options.push({
+							label: file.name!,
+							value: file.id!,
+						});
+					}
+				}
+				nextPageToken = response.data.nextPageToken;
+			} while (nextPageToken);
+
+			return {
+				disabled: false,
+				options,
+			};
+		},
+	});
+
+export const sheetIdProp = (displayName: string, description: string, required = true) =>
+	Property.Dropdown({
+		displayName,
+		description,
+		auth: googleSheetsAuth,
+		required,
+		refreshers: ['spreadsheetId'],
+		options: async ({ auth, spreadsheetId }) => {
+			if (!auth) {
+				return createEmptyOptionList('please connect your account first.');
+			}
+
+			if ((spreadsheetId ?? '').toString().length === 0) {
+				return createEmptyOptionList('please select a spreadsheet first.');
+			}
+
+			const authValue = auth as GoogleSheetsAuthValue;
+
+			const authClient = await createGoogleClient(authValue);
+
+			const sheets = google.sheets({ version: 'v4', auth: authClient });
+
+			const response = await sheets.spreadsheets.get({
+				spreadsheetId: spreadsheetId as unknown as string,
+			});
+
+			const sheetsData = response.data.sheets ?? [];
+
+			const options: DropdownOption<number>[] = [];
+
+			for (const sheet of sheetsData) {
+				const title = sheet.properties?.title;
+				const sheetId = sheet.properties?.sheetId;
+				if (isNil(title) || isNil(sheetId)) {
+					continue;
+				}
+				options.push({
+					label: title,
+					value: sheetId,
+				});
+			}
+
+			return {
+				disabled: false,
+				options,
+			};
+		},
+	});
+
+export const commonProps = {
+	includeTeamDrives: includeTeamDrivesProp(),
+	spreadsheetId: spreadsheetIdProp('Spreadsheet', 'The ID of the spreadsheet to use.'),
+	sheetId: sheetIdProp('Worksheet', 'The ID of the worksheet to use.'),
+};
+
+export const rowValuesProp = () =>
+	Property.DynamicProperties({
+		displayName: 'Values',
+		description: 'The values to add',
+		required: true,
+		auth: googleSheetsAuth,
+		refreshers: ['sheetId', 'spreadsheetId', 'first_row_headers'],
+		props: async ({ auth, spreadsheetId, sheetId, first_row_headers }) => {
+			if (
+				!auth ||
+				(spreadsheetId ?? '').toString().length === 0 ||
+				(sheetId ?? '').toString().length === 0
+			) {
+				return {};
+			}
+			const sheet_id = Number(sheetId);
+			const authValue = auth as GoogleSheetsAuthValue;
+
+			const headers = await googleSheetsCommon.getHeaderRow({
+				spreadsheetId: spreadsheetId as unknown as string,
+				auth: authValue,
+				sheetId: sheet_id,
+			});
+
+			if (!first_row_headers) {
+				return {
+					values: Property.Array({
+						displayName: 'Row Values',
+						required: true,
+					}),
+				};
+			}
+			const firstRow = headers ?? [];
+			const properties: {
+				[key: string]: any;
+			} = {};
+
+			for (let i = 0; i < firstRow.length; i++) {
+				const label = columnToLabel(i);
+				properties[label] = Property.ShortText({
+					displayName: firstRow[i].toString(),
+					// description: firstRow[i].toString(),
+					required: false,
+					defaultValue: '',
+				});
+			}
+			return properties;
+		},
+	});
+
+export const columnNameProp = () =>
+	Property.Dropdown<string, true, typeof googleSheetsAuth>({
+		displayName: 'Column Name',
+		description: 'The name of the column to search in',
+		required: true,
+		auth: googleSheetsAuth,
+		refreshers: ['sheetId', 'spreadsheetId'],
+		options: async ({ auth, spreadsheetId, sheetId }) => {
+			const spreadsheet_id = spreadsheetId as string;
+			const sheet_id = Number(sheetId) as number;
+			if (
+				!auth ||
+				(spreadsheet_id ?? '').toString().length === 0 ||
+				(sheet_id ?? '').toString().length === 0
+			) {
+				return {
+					disabled: true,
+					options: [],
+					placeholder: 'Please select a sheet first',
+				};
+			}
+
+			const sheetName = await googleSheetsCommon.findSheetName(auth, spreadsheet_id, sheet_id);
+
+			if (!sheetName) {
+				throw Error('Sheet not found in spreadsheet');
+			}
+
+			const headers = await getHeaderRow({
+				spreadsheetId: spreadsheet_id,
+				auth,
+				sheetId: sheet_id,
+			});
+
+			const ret = [];
+
+			const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+			if (isNil(headers)) {
+				return {
+					options: [],
+					disabled: false,
+				};
+			}
+			if (headers.length === 0) {
+				const columnSize = headers.length;
+
+				for (let i = 0; i < columnSize; i++) {
+					ret.push({
+						label: alphabet[i].toUpperCase(),
+						value: alphabet[i],
+					});
+				}
+			} else {
+				let index = 0;
+				for (let i = 0; i < headers.length; i++) {
+					let value = 'A';
+					if (index >= alphabet.length) {
+						// if the index is greater than the length of the alphabet, we need to add another letter
+						const firstLetter = alphabet[Math.floor(index / alphabet.length) - 1];
+						const secondLetter = alphabet[index % alphabet.length];
+						value = firstLetter + secondLetter;
+					} else {
+						value = alphabet[index];
+					}
+
+					ret.push({
+						label: headers[i].toString(),
+						value: value,
+					});
+					index++;
+				}
+			}
+			return {
+				options: ret,
+				disabled: false,
+			};
+		},
+	});
+
+export const isFirstRowHeaderProp = () =>
+	Property.Checkbox({
+		displayName: 'First Row Contains Headers ?',
+		required: true,
+		defaultValue: false,
+	});

package/src/lib/triggers/helpers.ts

@@ -0,0 +1,155 @@
+import { google } from 'googleapis';
+import { nanoid } from 'nanoid';
+import dayjs from 'dayjs';
+import crypto from 'crypto';
+import { columnToLabel, createGoogleClient, GoogleSheetsAuthValue } from '../common/common';
+import { isNil } from '@guayaba/workflows-shared';
+
+export async function getWorkSheetName(
+	auth: GoogleSheetsAuthValue,
+	spreadSheetId: string,
+	sheetId: number,
+) {
+	const authClient = await createGoogleClient(auth);
+
+	const sheets = google.sheets({ version: 'v4', auth: authClient });
+
+	const res = await sheets.spreadsheets.get({ spreadsheetId: spreadSheetId });
+	const sheetName = res.data.sheets?.find((f) => f.properties?.sheetId == sheetId)?.properties
+		?.title;
+
+	if (!sheetName) {
+		throw Error(`Sheet with ID ${sheetId} not found in spreadsheet ${spreadSheetId}`);
+	}
+
+	return sheetName;
+}
+
+export async function getWorkSheetGridSize(
+	auth: GoogleSheetsAuthValue,
+	spreadSheetId: string,
+	sheetId: number,
+) {
+	const authClient = await createGoogleClient(auth);
+
+	const sheets = google.sheets({ version: 'v4', auth: authClient });
+
+	const res = await sheets.spreadsheets.get({ spreadsheetId: spreadSheetId, includeGridData: true, fields: 'sheets.properties(sheetId,title,sheetType,gridProperties)' });
+	const sheetRange = res.data.sheets?.find((f) => f.properties?.sheetId == sheetId)?.properties?.gridProperties;
+
+	if (!sheetRange) {
+		throw Error(`Unable to get grid size for sheet ${sheetId} in spreadsheet ${spreadSheetId}`);
+	}
+
+	return sheetRange
+}
+
+export async function getWorkSheetValues(
+	auth: GoogleSheetsAuthValue,
+	spreadsheetId: string,
+	range?: string,
+) {
+	const authClient = await createGoogleClient(auth);
+
+	const sheets = google.sheets({ version: 'v4', auth: authClient });
+
+	const res = await sheets.spreadsheets.values.get({
+		spreadsheetId: spreadsheetId,
+		range: range,
+	});
+
+	return res.data.values ?? [];
+}
+
+export async function createFileNotification(
+	auth: GoogleSheetsAuthValue,
+	fileId: string,
+	url: string,
+	includeTeamDrives?: boolean,
+) {
+	const authClient = await createGoogleClient(auth);
+
+	const drive = google.drive({ version: 'v3', auth: authClient });
+
+	// create unique UUID for channel
+	const channelId = nanoid();
+	return await drive.files.watch({
+		fileId: fileId,
+		supportsAllDrives: includeTeamDrives,
+		requestBody: {
+			id: channelId,
+			expiration: (dayjs().add(6, 'day').unix() * 1000).toString(),
+			type: 'web_hook',
+			address: url,
+		},
+	});
+}
+
+export async function deleteFileNotification(
+	auth: GoogleSheetsAuthValue,
+	channelId: string,
+	resourceId: string,
+) {
+	const authClient = await createGoogleClient(auth);
+
+	const drive = google.drive({ version: 'v3', auth: authClient });
+
+	return await drive.channels.stop({
+		requestBody: {
+			id: channelId,
+			resourceId: resourceId,
+		},
+	});
+}
+
+export function isSyncMessage(headers: Record<string, string>) {
+	return headers['x-goog-resource-state'] === 'sync';
+}
+
+export function isChangeContentMessage(headers: Record<string, string>) {
+	// https://developers.google.com/drive/api/guides/push#respond-to-notifications
+	return (
+		headers['x-goog-resource-state'] === 'update' &&
+		['content', 'properties', 'content,properties'].includes(headers['x-goog-changed'])
+	);
+}
+
+export function hashObject(obj: Record<string, unknown>): string {
+	const hash = crypto.createHash('sha256');
+	hash.update(JSON.stringify(obj));
+	return hash.digest('hex');
+}
+// returns an array of row number and cells values mapped to column labels
+export function mapRowsToColumnLabels(rowValues: any[][], oldRowCount: number, headerCount: number) {
+	const result = [];
+	for (let i = 0; i < rowValues.length; i++) {
+		const values: Record<string, string> = {};
+		for (let j = 0; j < Math.max(headerCount, rowValues[i].length); j++) {
+			const columnLabel = columnToLabel(j);
+			if (isNil(rowValues[i][j])) {
+				values[columnLabel] = "";
+			} else if (typeof rowValues[i][j] === "string") {
+				values[columnLabel] = rowValues[i][j];
+			}
+			else if ('toString' in rowValues[i][j]) {
+				values[columnLabel] = rowValues[i][j].toString();
+			}
+			else {
+				values[columnLabel] = `${rowValues[i][j]}`;
+			}
+		}
+		result.push({
+			row: oldRowCount + i + 1,
+			values,
+		});
+	}
+	return result;
+}
+
+export interface WebhookInformation {
+	kind?: string | null;
+	id?: string | null;
+	resourceId?: string | null;
+	resourceUri?: string | null;
+	expiration?: string | null;
+}