@guayaba/workflow-piece-google-sheets 0.14.6

package/src/lib/triggers/new-or-updated-row.trigger.ts

@@ -0,0 +1,299 @@
+import { isNil } from '@guayaba/workflows-shared';
+import { googleSheetsAuth } from '../common/common';
+import { areSheetIdsValid, columnToLabel, GoogleSheetsAuthValue, labelToColumn } from '../common/common';
+import {
+	createFileNotification,
+	deleteFileNotification,
+	getWorkSheetName,
+	getWorkSheetValues,
+	hashObject,
+	isChangeContentMessage,
+	isSyncMessage,
+	mapRowsToColumnLabels,
+	WebhookInformation,
+} from './helpers';
+
+import {
+	createTrigger,
+	TriggerStrategy,
+	DEDUPE_KEY_PROPERTY,
+	WebhookRenewStrategy,
+	Property,
+	DropdownOption,
+} from '@guayaba/workflows-framework';
+
+import crypto from 'crypto';
+import { commonProps } from '../common/props';
+
+const ALL_COLUMNS = 'all_columns';
+
+export const newOrUpdatedRowTrigger = createTrigger({
+	auth: googleSheetsAuth,
+	name: 'google-sheets-new-or-updated-row',
+	displayName: 'New or Updated Row',
+	description: 'Triggers when a new row is added or modified in a spreadsheet.',
+	props: {
+		info: Property.MarkDown({
+			value:
+				'Please note that there might be a delay of up to 3 minutes for the trigger to be fired, due to a delay from Google.',
+		}),
+		...commonProps,
+		trigger_column: Property.Dropdown({
+			auth: googleSheetsAuth,
+			displayName: 'Trigger Column',
+			description: `Trigger on changes to cells in this column only. \nSelect **Any Column** if you want the flow to trigger on changes to any cell within the row.`,
+			required: false,
+			refreshers: ['spreadsheetId', 'sheetId'],
+			defaultValue: ALL_COLUMNS,
+			options: async ({ auth, spreadsheetId, sheetId }) => {
+				if (!auth || !spreadsheetId || isNil(sheetId)) {
+					return {
+						disabled: true,
+						options: [],
+						placeholder: `Please select sheet first`,
+					};
+				}
+
+				const spreadsheet_id = spreadsheetId as string;
+				const sheet_id = sheetId as number;
+
+				const sheetName = await getWorkSheetName(auth, spreadsheet_id, sheet_id);
+
+				const firstRowValues = await getWorkSheetValues(
+					auth,
+					spreadsheet_id,
+					`${sheetName}!1:1`,
+				);
+
+				const headers = firstRowValues[0] ?? [];
+				const headerCount = headers.length;
+				const labeledRowValues = mapRowsToColumnLabels(firstRowValues, 0, headerCount);
+                const labledHeaders = labeledRowValues.length > 0 ? labeledRowValues[0].values : {};
+				
+				const options = Object.entries(labledHeaders).reduce((accumlator:DropdownOption<string>[],[key,value]) => {
+					accumlator.push({ label: value as string, value: key });
+					return accumlator;
+				}, [{ label: 'Any Column', value: ALL_COLUMNS }]);
+
+				return {
+					disabled: options.length === 0,
+    				options,
+				};
+			},
+		}),
+	},
+
+	renewConfiguration: {
+		strategy: WebhookRenewStrategy.CRON,
+		cronExpression: '0 */12 * * *',
+	},
+
+	type: TriggerStrategy.WEBHOOK,
+
+	async onEnable(context) {
+		const inputSpreadsheetId = context.propsValue.spreadsheetId;
+		const inputSheetId = context.propsValue.sheetId;
+		const triggerColumn = context.propsValue.trigger_column ?? ALL_COLUMNS;
+
+		if (!areSheetIdsValid(inputSpreadsheetId, inputSheetId)) {
+					throw new Error('Please select a spreadsheet and sheet first.');
+				}
+		const sheetId = Number(inputSheetId);
+		const spreadsheetId = inputSpreadsheetId as string;
+
+		const sheetName = await getWorkSheetName(context.auth, spreadsheetId, sheetId);
+
+		const sheetValues = await getWorkSheetValues(context.auth, spreadsheetId, sheetName);
+
+		const rowHashes = [];
+
+		// create initial row level hashes and used it to check updated row
+		for (const row of sheetValues) {
+			let targetValue;
+			if (triggerColumn === ALL_COLUMNS) {
+				targetValue = row;
+			} else {
+				const currentTriggerColumnValue = row[labelToColumn(triggerColumn)];
+
+				targetValue =
+					currentTriggerColumnValue !== undefined && currentTriggerColumnValue !== '' // if column value is empty
+						? [currentTriggerColumnValue]
+						: [];
+			}
+
+			const rowHash = crypto.createHash('md5').update(JSON.stringify(targetValue)).digest('hex');
+			rowHashes.push(rowHash);
+		}
+
+		// store compressed values
+		await context.store.put(`${sheetId}`, rowHashes);
+
+		// create file watch notification
+		const fileNotificationRes = await createFileNotification(
+			context.auth,
+			spreadsheetId,
+			context.webhookUrl,
+			context.propsValue.includeTeamDrives,
+		);
+
+		await context.store.put<WebhookInformation>(
+			'google-sheets-new-or-updated-row',
+			fileNotificationRes.data,
+		);
+	},
+
+	async onDisable(context) {
+		const webhook = await context.store.get<WebhookInformation>('google-sheets-new-or-updated-row');
+
+		if (webhook != null && webhook.id != null && webhook.resourceId != null) {
+			try
+			{
+			await deleteFileNotification(context.auth, webhook.id, webhook.resourceId);
+			}
+			catch(err){
+  				console.debug("deleteFileNotification failed :",JSON.stringify(err));
+			}
+		}
+	},
+
+	async run(context) {
+		if (isSyncMessage(context.payload.headers)) {
+			return [];
+		}
+
+		if (!isChangeContentMessage(context.payload.headers)) {
+			return [];
+		}
+
+		const inputSpreadsheetId = context.propsValue.spreadsheetId;
+    	const inputSheetId = context.propsValue.sheetId;
+		const triggerColumn = context.propsValue.trigger_column ?? ALL_COLUMNS;
+
+		if (!areSheetIdsValid(inputSpreadsheetId, inputSheetId)) {
+			throw new Error('Please select a spreadsheet and sheet first.');
+		}
+
+		const sheetId = Number(inputSheetId);
+		const spreadsheetId = inputSpreadsheetId as string;
+
+		const sheetName = await getWorkSheetName(context.auth, spreadsheetId, sheetId);
+
+		const oldValuesHashes = (await context.store.get(`${sheetId}`)) as any[];
+
+		/* Fetch rows values with all columns as this will be used on returning updated/new row data
+		 */
+		const currentValues = await getWorkSheetValues(context.auth, spreadsheetId, sheetName);
+
+		const headers = currentValues[0] ?? [];
+		const headerCount = headers.length;
+
+		// const rowCount = Math.max(oldValuesHashes.length, currentValues.length);
+
+		const changedValues = [];
+		const newRowHashes = [];
+
+		for (let row = 0; row < currentValues.length; row++) {
+			const currentRowValue = currentValues[row];
+
+			/**
+			 * This variable store value based on trigger column.
+			 * If trigger column is all_columns then store entry row as target value, else store only column value.
+			 */
+			let targetValue;
+			if (triggerColumn === ALL_COLUMNS) {
+				targetValue = currentRowValue;
+			} else {
+				const currentTriggerColumnValue = currentRowValue[labelToColumn(triggerColumn)];
+
+				targetValue =
+					currentTriggerColumnValue !== undefined && currentTriggerColumnValue !== ''
+						? [currentTriggerColumnValue]
+						: [];
+			}
+
+			// create hash for new row values
+			const currentRowHash = crypto
+				.createHash('md5')
+				.update(JSON.stringify(targetValue))
+				.digest('hex');
+			newRowHashes.push(currentRowHash);
+
+			// If row is empty then skip
+			if (currentRowValue === undefined || currentRowValue.length === 0) {
+				continue;
+			}
+
+			const oldRowHash =
+				!isNil(oldValuesHashes) && row < oldValuesHashes.length ? oldValuesHashes[row] : undefined;
+
+			if (oldRowHash === undefined || oldRowHash != currentRowHash) {
+				const formattedValues: any = {};
+
+				for (let column = 0; column < headerCount; column++) {
+					formattedValues[columnToLabel(column)] = currentValues[row][column] ?? '';
+				}
+
+				changedValues.push({
+					row: row + 1,
+					values: formattedValues,
+				});
+			}
+		}
+
+		// update the row hashes
+		await context.store.put(`${sheetId}`, newRowHashes);
+
+		return changedValues.map((row) => {
+			return {
+				...row,
+				[DEDUPE_KEY_PROPERTY]: hashObject(row),
+			};
+		});
+	},
+
+	async test(context) {
+		const inputSpreadsheetId = context.propsValue.spreadsheetId;
+		const inputSheetId = context.propsValue.sheetId;
+
+		if (!areSheetIdsValid(inputSpreadsheetId, inputSheetId)) {
+			throw new Error('Please select a spreadsheet and sheet first.');
+		}
+
+    	const sheetId = Number(inputSheetId);
+		const spreadsheetId = inputSpreadsheetId as string;
+
+		const sheetName = await getWorkSheetName(context.auth, spreadsheetId, sheetId);
+		const currentSheetValues = await getWorkSheetValues(context.auth, spreadsheetId, sheetName);
+
+		const headers = currentSheetValues[0] ?? [];
+		const headerCount = headers.length;
+
+		const transformedRowValues = mapRowsToColumnLabels(currentSheetValues, 0, headerCount)
+			.slice(-5)
+			.reverse();
+
+		return transformedRowValues;
+	},
+
+	async onRenew(context) {
+		// get current channel ID & resource ID
+		const webhook = await context.store.get<WebhookInformation>(`google-sheets-new-or-updated-row`);
+		if (webhook != null && webhook.id != null && webhook.resourceId != null) {
+			// delete current channel
+			await deleteFileNotification(context.auth, webhook.id, webhook.resourceId);
+			const fileNotificationRes = await createFileNotification(
+				context.auth,
+				context.propsValue.spreadsheetId!,
+				context.webhookUrl,
+				context.propsValue.includeTeamDrives,
+			);
+			// store channel response
+			await context.store.put<WebhookInformation>(
+				'google-sheets-new-or-updated-row',
+				fileNotificationRes.data,
+			);
+		}
+	},
+
+	sampleData: {},
+});

package/src/lib/triggers/new-row-added-webhook.ts

@@ -0,0 +1,182 @@
+import {
+	DEDUPE_KEY_PROPERTY,
+	Property,
+	TriggerStrategy,
+	WebhookRenewStrategy,
+	createTrigger,
+} from '@guayaba/workflows-framework';
+
+import {
+	createFileNotification,
+	deleteFileNotification,
+	getWorkSheetName,
+	getWorkSheetValues,
+	hashObject,
+	isChangeContentMessage,
+	isSyncMessage,
+	mapRowsToColumnLabels,
+	WebhookInformation,
+} from './helpers';
+
+import { googleSheetsAuth } from '../common/common';
+import { commonProps } from '../common/props';
+import { areSheetIdsValid,  } from '../common/common';
+
+export const newRowAddedTrigger = createTrigger({
+	auth: googleSheetsAuth,
+	name: 'googlesheets_new_row_added',
+	displayName: 'New Row Added',
+	description: 'Triggers when a new row is added to bottom of a spreadsheet.',
+	props: {
+		info: Property.MarkDown({
+			value:
+				'Please note that there might be a delay of up to 3 minutes for the trigger to be fired, due to a delay from Google.',
+		}),
+		...commonProps,
+	},
+	renewConfiguration: {
+		strategy: WebhookRenewStrategy.CRON,
+		cronExpression: '0 */12 * * *',
+	},
+	type: TriggerStrategy.WEBHOOK,
+	async onEnable(context) {
+		const { spreadsheetId:inputSpreadsheetId, sheetId:inputSheetId } = context.propsValue;
+
+		 if (!areSheetIdsValid(inputSpreadsheetId, inputSheetId)) {
+					throw new Error('Please select a spreadsheet and sheet first.');
+				}
+		
+		const sheetId = Number(inputSheetId);
+		const spreadsheetId = inputSpreadsheetId as string;
+
+		const sheetName = await getWorkSheetName(context.auth, spreadsheetId, sheetId);
+		const currentSheetValues = await getWorkSheetValues(context.auth, spreadsheetId, sheetName);
+
+		await context.store.put(`${sheetId}`, currentSheetValues.length);
+
+		const fileNotificationRes = await createFileNotification(
+			context.auth,
+			spreadsheetId,
+			context.webhookUrl,
+			context.propsValue.includeTeamDrives,
+		);
+
+		await context.store.put<WebhookInformation>(
+			'googlesheets_new_row_added',
+			fileNotificationRes.data,
+		);
+	},
+	async onDisable(context) {
+		const webhook = await context.store.get<WebhookInformation>(`googlesheets_new_row_added`);
+		if (webhook != null && webhook.id != null && webhook.resourceId != null) {
+			try
+			{
+			await deleteFileNotification(context.auth, webhook.id, webhook.resourceId);
+			}
+			catch(err){
+  				console.debug("deleteFileNotification failed :",JSON.stringify(err));
+			}
+		}
+	},
+	async run(context) {
+		if (isSyncMessage(context.payload.headers)) {
+			return [];
+		}
+		if (!isChangeContentMessage(context.payload.headers)) {
+			return [];
+		}
+
+		const { spreadsheetId:inputSpreadsheetId, sheetId:inputSheetId } = context.propsValue;
+
+		 if (!areSheetIdsValid(inputSpreadsheetId, inputSheetId)) {
+					throw new Error('Please select a spreadsheet and sheet first.');
+				}
+		
+		const sheetId = Number(inputSheetId);
+		const spreadsheetId = inputSpreadsheetId as string;
+
+		const oldRowCount = (await context.store.get(`${sheetId}`)) as number;
+
+		const sheetName = await getWorkSheetName(context.auth, spreadsheetId, sheetId);
+		const currentRowValues = await getWorkSheetValues(context.auth, spreadsheetId, sheetName);
+		const currentRowCount = currentRowValues.length;
+
+		const headers =  currentRowValues[0] ?? [];
+		const headerCount = headers.length;
+
+		if (oldRowCount >= currentRowCount) {
+			if (oldRowCount > currentRowCount) {
+				await context.store.put(`${sheetId}`, currentRowCount);
+			}
+			return [];
+		}
+
+		// create A1 notation range for new rows
+		const range = `${sheetName}!${oldRowCount + 1}:${currentRowCount}`;
+
+		const newRowValues = await getWorkSheetValues(
+			context.auth,
+			spreadsheetId,
+			range,
+		);
+
+		await context.store.put(`${sheetId}`, currentRowCount);
+
+		const transformedRowValues = mapRowsToColumnLabels(newRowValues, oldRowCount,headerCount);
+		return transformedRowValues.map((row) => {
+			return {
+				...row,
+				[DEDUPE_KEY_PROPERTY]: hashObject(row),
+			};
+		});
+	},
+	async onRenew(context) {
+		// get current channel ID & resource ID
+		const webhook = await context.store.get<WebhookInformation>(`googlesheets_new_row_added`);
+
+		const { spreadsheetId:inputSpreadsheetId, sheetId:inputSheetId } = context.propsValue;
+
+		 if (!areSheetIdsValid(inputSpreadsheetId, inputSheetId)) {
+					throw new Error('Please select a spreadsheet and sheet first.');
+				}
+		
+		const spreadsheetId = inputSpreadsheetId as string;
+
+		if (webhook != null && webhook.id != null && webhook.resourceId != null) {
+			await deleteFileNotification(context.auth, webhook.id, webhook.resourceId);
+			const fileNotificationRes = await createFileNotification(
+				context.auth,
+				spreadsheetId,
+				context.webhookUrl,
+				context.propsValue.includeTeamDrives,
+			);
+			await context.store.put<WebhookInformation>(
+				'googlesheets_new_row_added',
+				fileNotificationRes.data,
+			);
+		}
+	},
+	async test(context) {
+		const { spreadsheetId:inputSpreadsheetId, sheetId:inputSheetId } = context.propsValue;
+
+		 if (!areSheetIdsValid(inputSpreadsheetId, inputSheetId)) {
+					throw new Error('Please select a spreadsheet and sheet first.');
+				}
+		
+		const sheetId = Number(inputSheetId);
+		const spreadsheetId = inputSpreadsheetId as string;
+		
+		const sheetName = await getWorkSheetName(context.auth, spreadsheetId, sheetId);
+		const currentSheetValues = await getWorkSheetValues(context.auth, spreadsheetId, sheetName);
+
+		const headers =  currentSheetValues[0] ?? [];
+		const headerCount = headers.length;
+
+		const transformedRowValues = mapRowsToColumnLabels(currentSheetValues, 0,headerCount)
+			.slice(-5)
+			.reverse();
+
+		return transformedRowValues;
+	},
+	sampleData: {},
+});

package/src/lib/triggers/new-spreadsheet.ts

@@ -0,0 +1,88 @@
+import {
+	AppConnectionValueForAuthProperty,
+	createTrigger,
+	TriggerStrategy,
+} from '@guayaba/workflows-framework';
+import { googleSheetsAuth } from '../common/common';
+import { DedupeStrategy, Polling, pollingHelper } from '@guayaba/workflows-common';
+
+import dayjs from 'dayjs';
+import { google, drive_v3 } from 'googleapis';
+import { includeTeamDrivesProp } from '../common/props';
+import { createGoogleClient, GoogleSheetsAuthValue } from '../common/common';
+
+type Props = {
+	includeTeamDrives?: boolean;
+};
+
+const polling: Polling<AppConnectionValueForAuthProperty<typeof googleSheetsAuth>, Props> = {
+	strategy: DedupeStrategy.TIMEBASED,
+	async items({ auth, propsValue, lastFetchEpochMS }) {
+		const authValue = auth as GoogleSheetsAuthValue;
+		const q = ["mimeType='application/vnd.google-apps.spreadsheet'", 'trashed = false'];
+		if (lastFetchEpochMS) {
+			q.push(`createdTime > '${dayjs(lastFetchEpochMS).toISOString()}'`);
+		}
+		const authClient = await createGoogleClient(authValue);
+		const drive = google.drive({ version: 'v3', auth: authClient });
+		let nextPageToken;
+		const items = [];
+		do {
+			const response: any = await drive.files.list({
+				q: q.join(' and '),
+				fields: '*',
+				orderBy: 'createdTime desc',
+				supportsAllDrives: true,
+				includeItemsFromAllDrives: propsValue.includeTeamDrives,
+				pageToken: nextPageToken,
+			});
+			const fileList: drive_v3.Schema$FileList = response.data;
+			if (fileList.files) {
+				items.push(...fileList.files);
+			}
+			if (lastFetchEpochMS === 0) break;
+			nextPageToken = response.data.nextPageToken;
+		} while (nextPageToken);
+		return items.map((item) => ({
+			epochMilliSeconds: dayjs(item.createdTime).valueOf(),
+			data: item,
+		}));
+	},
+};
+export const newSpreadsheetTrigger = createTrigger({
+	auth: googleSheetsAuth,
+	name: 'new-spreadsheet',
+	displayName: 'New Spreadsheet',
+	description: 'Triggers when a new spreadsheet is created.',
+	type: TriggerStrategy.POLLING,
+	props: {
+		includeTeamDrives: includeTeamDrivesProp(),
+	},
+	async onEnable(context) {
+		await pollingHelper.onEnable(polling, {
+			auth: context.auth,
+			store: context.store,
+			propsValue: context.propsValue,
+		});
+	},
+	async onDisable(context) {
+		await pollingHelper.onDisable(polling, {
+			auth: context.auth,
+			store: context.store,
+			propsValue: context.propsValue,
+		});
+	},
+	async test(context) {
+		return await pollingHelper.test(polling, context);
+	},
+	async run(context) {
+		return await pollingHelper.poll(polling, context);
+	},
+	sampleData: {
+		kind: 'drive#file',
+		mimeType: 'application/vnd.google-apps.spreadsheet',
+		webViewLink: 'https://docs.google.com/document/d/1_9xjsrYFgHVvgqYwAJ8KcsDcNU/edit?usp=drivesdk',
+		id: '1_9xjsrYFgHVvgqYwAJ8KcsDcN3AzPelsux',
+		name: 'Test Document',
+	},
+});

package/src/lib/triggers/new-worksheet.ts

@@ -0,0 +1,96 @@
+import { googleSheetsAuth } from '../common/common';
+import { createTrigger, TriggerStrategy } from '@guayaba/workflows-framework';
+import { google } from 'googleapis';
+import { isNil } from '@guayaba/workflows-shared';
+import { includeTeamDrivesProp, spreadsheetIdProp } from '../common/props';
+import { createGoogleClient } from '../common/common';
+
+export const newWorksheetTrigger = createTrigger({
+	auth: googleSheetsAuth,
+	name: 'new-worksheet',
+	displayName: 'New Worksheet',
+	description: 'Triggers when a worksheet is created in a spreadsheet.',
+	type: TriggerStrategy.POLLING,
+	props: {
+		includeTeamDrives: includeTeamDrivesProp(),
+		spreadsheetId: spreadsheetIdProp('Spreadsheet', '',true),
+	},
+	async onEnable(context) {
+		const ids: number[] = [];
+		const authClient = await createGoogleClient(context.auth);
+		const sheets = google.sheets({ version: 'v4', auth: authClient });
+		const response = await sheets.spreadsheets.get({
+			spreadsheetId: context.propsValue.spreadsheetId as string,
+		});
+		if (response.data.sheets) {
+			for (const sheet of response.data.sheets) {
+				const sheetId = sheet.properties?.sheetId;
+				if (sheetId) {
+					ids.push(sheetId);
+				}
+			}
+		}
+		await context.store.put('worksheets', JSON.stringify(ids));
+	},
+	async onDisable(context) {
+		await context.store.delete('worksheets');
+	},
+	async test(context) {
+		const worksheets = [];
+		const authClient = await createGoogleClient(context.auth);
+		const sheets = google.sheets({ version: 'v4', auth: authClient });
+		const response = await sheets.spreadsheets.get({
+			spreadsheetId: context.propsValue.spreadsheetId as string,
+		});
+
+		if (response.data.sheets) {
+			for (const sheet of response.data.sheets) {
+				worksheets.push(sheet);
+			}
+		}
+		return worksheets;
+	},
+	async run(context) {
+		const existingIds = (await context.store.get<string>('worksheets')) ?? '[]';
+		const parsedExistingIds = JSON.parse(existingIds) as number[];
+
+		const authClient = await createGoogleClient(context.auth);
+
+		const sheets = google.sheets({ version: 'v4', auth: authClient });
+
+		const response = await sheets.spreadsheets.get({
+			spreadsheetId: context.propsValue.spreadsheetId as string,
+		});
+		if (isNil(response.data.sheets) || response.data.sheets.length === 0) {
+			return [];
+		}
+		// Filter valid worksheetss
+		const newWorksheets = response.data.sheets.filter((sheet) => {
+			const sheetId = sheet.properties?.sheetId ?? undefined;
+			return sheetId !== undefined && !parsedExistingIds.includes(sheetId);
+		});
+
+		const newIds = newWorksheets
+			.map((sheet) => sheet.properties?.sheetId ?? undefined)
+			.filter((id): id is number => id !== undefined);
+
+		if (newIds.length === 0) {
+			return [];
+		}
+		// Store new IDs
+		await context.store.put('worksheets', JSON.stringify([...newIds, ...parsedExistingIds]));
+		return newWorksheets;
+	},
+	sampleData: {
+		properties: {
+			sheetId: 2077270595,
+			title: 'Sheet5',
+			index: 1,
+			sheetType: 'GRID',
+			gridProperties: {
+				rowCount: 1000,
+				columnCount: 26,
+			},
+		},
+	},
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ],
+  "compilerOptions": {
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "rootDir": ".",
+    "baseUrl": ".",
+    "paths": {},
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "types": ["node"]
+  },
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"],
+  "include": ["src/**/*.ts"]
+}