@guayaba/workflow-piece-google-drive 0.7.5

package/src/lib/auth.ts

@@ -0,0 +1,80 @@
+import { AppConnectionValueForAuthProperty, PieceAuth, Property } from '@guayaba/workflows-framework';
+import { AppConnectionType } from '@guayaba/workflows-shared';
+import { google } from 'googleapis';
+import { OAuth2Client } from 'googleapis-common';
+
+export const googleDriveScopes = ['https://www.googleapis.com/auth/drive'];
+
+export const googleDriveAuth = [PieceAuth.OAuth2({
+  description: '',
+  authUrl: 'https://accounts.google.com/o/oauth2/auth',
+  tokenUrl: 'https://oauth2.googleapis.com/token',
+  required: true,
+  scope: googleDriveScopes,
+}), PieceAuth.CustomAuth({
+  displayName: 'Service Account (Advanced)',
+  description: 'Authenticate via service account from https://console.cloud.google.com/ > IAM & Admin > Service Accounts > Create Service Account > Keys > Add key.  <br> <br> You can optionally use domain-wide delegation (https://support.google.com/a/answer/162106?hl=en#zippy=%2Cset-up-domain-wide-delegation-for-a-client) to access files without adding the service account to each one. <br> <br> **Note:** Without a user email, the service account only has access to files/folders you explicitly share with it.',
+  required: true,
+  props: {
+    serviceAccount: Property.LongText({
+      displayName: 'Service Account JSON Key',
+      required: true,
+    }),
+    userEmail: Property.ShortText({
+      displayName: 'User Email',
+      required: false,
+      description: 'Email address of the user to impersonate for domain-wide delegation.',
+    }),
+  },
+  validate: async ({ auth }) => {
+    try {
+      await getAccessToken({
+        type: AppConnectionType.CUSTOM_AUTH,
+        props: { ...auth },
+      });
+    } catch (e) {
+      return {
+        valid: false,
+        error: (e as Error).message,
+      };
+    }
+    return {
+      valid: true,
+    };
+  },
+})];
+
+export type GoogleDriveAuthValue = AppConnectionValueForAuthProperty<typeof googleDriveAuth>;
+
+export async function createGoogleClient(auth: GoogleDriveAuthValue): Promise<OAuth2Client> {
+  if (auth.type === AppConnectionType.CUSTOM_AUTH) {
+    let serviceAccount;
+    try {
+      serviceAccount = JSON.parse(auth.props.serviceAccount);
+    } catch {
+      throw new Error('Invalid Service Account JSON Key. Please provide a valid JSON string.');
+    }
+    return new google.auth.JWT({
+      email: serviceAccount.client_email,
+      key: serviceAccount.private_key,
+      scopes: googleDriveScopes,
+      subject: auth.props.userEmail,
+    });
+  }
+  const authClient = new OAuth2Client();
+  authClient.setCredentials(auth);
+  return authClient;
+}
+
+export const getAccessToken = async (auth: GoogleDriveAuthValue): Promise<string> => {
+  if (auth.type === AppConnectionType.CUSTOM_AUTH) {
+    const googleClient = await createGoogleClient(auth);
+    const response = await googleClient.getAccessToken();
+    if (response.token) {
+      return response.token;
+    } else {
+      throw new Error('Could not retrieve access token from service account json');
+    }
+  }
+  return auth.access_token;
+};

package/src/lib/common/get-file-content.ts

@@ -0,0 +1,109 @@
+import {
+  FilesService,
+} from '@guayaba/workflows-framework';
+import { extension } from 'mime-types';
+import { GoogleDriveAuthValue, getAccessToken } from '../auth';
+
+async function getMimeType(
+  auth: GoogleDriveAuthValue,
+  fileId: string
+): Promise<string> {
+  const accessToken = await getAccessToken(auth);
+  const mimeType = (
+    await fetch(
+      `https://www.googleapis.com/drive/v3/files/${fileId}?fields=mimeType&supportsAllDrives=true`,
+      {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+        },
+      }
+    ).then((res) => res.json())
+  )['mimeType'] as string;
+  return mimeType;
+}
+
+const googledlCall = async (
+  url: string,
+  auth: GoogleDriveAuthValue,
+  fileId: string,
+  files: FilesService,
+  fileName: string | undefined
+) => {
+  const mimeType = await getMimeType(auth, fileId);
+  const accessToken = await getAccessToken(auth);
+
+  const download = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+  })
+    .then((response) =>
+      response.ok ? response.blob() : Promise.reject(response)
+    )
+    .catch((error) =>
+      Promise.reject(
+        new Error(
+          `Error when download file:\n\tDownload file response: ${
+            (error as Error).message ?? error
+          }`
+        )
+      )
+    );
+
+  const extensionResult = extension(mimeType);
+  const fileExtension = extensionResult ? '.' + extensionResult : '';
+  const srcFileName = fileName ?? fileId + fileExtension;
+
+  return files.write({
+    fileName: srcFileName,
+    data: Buffer.from(await download.arrayBuffer()),
+  });
+};
+
+export async function downloadFileFromDrive(
+  auth: GoogleDriveAuthValue,
+  files: FilesService,
+  fileId: string,
+  fileName: string | undefined
+): Promise<string> {
+  let mimeType = await getMimeType(auth, fileId);
+
+  // the google drive API doesn't allowed downloading google documents but we can export them to office formats
+  if (
+    [
+      'application/vnd.google-apps.document',
+      'application/vnd.google-apps.spreadsheet',
+      'application/vnd.google-apps.presentation',
+    ].includes(mimeType)
+  ) {
+    switch (mimeType) {
+      case 'application/vnd.google-apps.document':
+        mimeType =
+          'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+        break;
+      case 'application/vnd.google-apps.spreadsheet':
+        mimeType =
+          'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+        break;
+      case 'application/vnd.google-apps.presentation':
+        mimeType =
+          'application/vnd.openxmlformats-officedocument.presentationml.presentation';
+        break;
+    }
+    return await googledlCall(
+      `https://www.googleapis.com/drive/v3/files/${fileId}/export?mimeType=${mimeType}&supportsAllDrives=true`,
+      auth,
+      fileId,
+      files,
+      fileName
+    );
+  } else {
+    return await googledlCall(
+      `https://www.googleapis.com/drive/v3/files/${fileId}?alt=media&supportsAllDrives=true`,
+      auth,
+      fileId,
+      files,
+      fileName
+    );
+  }
+}

package/src/lib/common/index.ts

@@ -0,0 +1,179 @@
+import {
+  httpClient,
+  HttpMethod,
+  AuthenticationType,
+  HttpRequest,
+} from '@guayaba/workflows-common';
+import { Property } from '@guayaba/workflows-framework';
+import dayjs from 'dayjs';
+import { google } from 'googleapis';
+import { googleDriveAuth, GoogleDriveAuthValue, getAccessToken, createGoogleClient } from '../auth';
+
+const FOLDER_DROPDOWN_PAGE_SIZE = 1000;
+
+const escapeDriveQueryLiteral = (value: string): string =>
+  value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+
+export const common = {
+  properties: {
+    parentFolder: Property.Dropdown({
+      displayName: 'Parent Folder',
+      description:
+        "The Drive folder to target. Leave empty to use the root of My Drive. Type in the box to search your Drive by folder name. If the folder still isn't listed, switch this field to 'Dynamic value' (the toggle next to the field) and paste the folder ID — you can copy it from the folder's URL in Drive, after /folders/ (e.g. https://drive.google.com/drive/folders/<FOLDER_ID>).",
+      required: false,
+      auth: googleDriveAuth,
+      refreshers: ['include_team_drives'],
+      refreshOnSearch: true,
+      options: async ({ auth, include_team_drives }, ctx) => {
+        if (!auth) {
+          return {
+            disabled: true,
+            options: [],
+            placeholder: 'Please authenticate first',
+          };
+        }
+        const authValue = auth as GoogleDriveAuthValue;
+        const accessToken = await getAccessToken(authValue);
+        const searchValue = ctx?.searchValue?.trim() ?? '';
+        const qParts = [
+          "mimeType='application/vnd.google-apps.folder'",
+          'trashed = false',
+        ];
+        if (searchValue.length > 0) {
+          qParts.push(`name contains '${escapeDriveQueryLiteral(searchValue)}'`);
+        }
+        const request: HttpRequest = {
+          method: HttpMethod.GET,
+          url: `https://www.googleapis.com/drive/v3/files`,
+          queryParams: {
+            q: qParts.join(' and '),
+            includeItemsFromAllDrives: include_team_drives ? 'true' : 'false',
+            supportsAllDrives: 'true',
+            pageSize: String(FOLDER_DROPDOWN_PAGE_SIZE),
+            fields: 'nextPageToken, files(id, name)',
+          },
+          authentication: {
+            type: AuthenticationType.BEARER_TOKEN,
+            token: accessToken,
+          },
+        };
+        let folders: { id: string; name: string }[] = [];
+        let truncated = false;
+        try {
+          const response = await httpClient.sendRequest<{
+            files: { id: string; name: string }[];
+            nextPageToken?: string;
+          }>(request);
+          folders = response.body.files ?? [];
+          truncated = Boolean(response.body.nextPageToken);
+        } catch (e) {
+          throw new Error(`Failed to get folders\nError:${e}`);
+        }
+
+        return {
+          disabled: false,
+          placeholder: truncated
+            ? `Showing first ${folders.length} matches — type to narrow the list, or switch to Dynamic value to paste an ID.`
+            : undefined,
+          options: folders.map((folder: { id: string; name: string }) => {
+            return {
+              label: folder.name,
+              value: folder.id,
+            };
+          }),
+        };
+      },
+    }),
+    include_team_drives: Property.Checkbox({
+      displayName: 'Include Team Drives',
+      description:
+        'Determines if folders from Team Drives should be included in the results.',
+      defaultValue: false,
+      required: false,
+    }),
+  },
+
+  async getFiles(
+    auth: GoogleDriveAuthValue,
+    search?: {
+      parent?: string;
+      createdTime?: string | number | Date;
+      createdTimeOp?: string;
+      includeTeamDrive?: boolean;
+    },
+    order?: string
+  ) {
+    const authClient = await createGoogleClient(auth);
+
+    const drive = google.drive({ version: 'v3', auth: authClient });
+
+    const q: string[] = [];
+    if (search?.parent) q.push(`'${search.parent}' in parents`);
+    if (search?.createdTime)
+      q.push(
+        `createdTime ${search.createdTimeOp ?? '>'} '${dayjs(
+          search.createdTime
+        ).format()}'`
+      );
+    q.push(`trashed = false`);
+    const allFiles: any[] = [];
+    let pageToken: string | undefined = undefined;
+    do {
+      const listParams: Record<string, any> = {
+        q: q.concat("mimeType!='application/vnd.google-apps.folder'").join(' and '),
+        fields: 'nextPageToken, files(id, name, mimeType, webViewLink, kind, createdTime)',
+        orderBy: order ?? 'createdTime desc',
+        supportsAllDrives: true,
+        includeItemsFromAllDrives: search?.includeTeamDrive,
+      };
+      if (pageToken) listParams.pageToken = pageToken;
+      const response = await drive.files.list(listParams);
+      allFiles.push(...(response.data.files ?? []));
+      pageToken = response.data.nextPageToken ?? undefined;
+    } while (pageToken);
+
+    return allFiles;
+  },
+
+  async getFolders(
+    auth: GoogleDriveAuthValue,
+    search?: {
+      parent?: string;
+      createdTime?: string | number | Date;
+      createdTimeOp?: string;
+      includeTeamDrive?: boolean;
+    },
+    order?: string
+  ) {
+    const authClient = await createGoogleClient(auth);
+
+    const drive = google.drive({ version: 'v3', auth: authClient });
+
+    const q: string[] = [`mimeType='application/vnd.google-apps.folder'`];
+    if (search?.parent) q.push(`'${search.parent}' in parents`);
+    if (search?.createdTime)
+      q.push(
+        `createdTime ${search.createdTimeOp ?? '>'} '${dayjs(
+          search.createdTime
+        ).format()}'`
+      );
+    q.push(`trashed = false`);
+    const allFolders: any[] = [];
+    let pageToken: string | undefined = undefined;
+    do {
+      const listParams: Record<string, any> = {
+        q: q.join(' and '),
+        fields: 'nextPageToken, files(id, name, createdTime)',
+        orderBy: order ?? 'createdTime desc',
+        supportsAllDrives: true,
+        includeItemsFromAllDrives: search?.includeTeamDrive,
+      };
+      if (pageToken) listParams.pageToken = pageToken;
+      const response = await drive.files.list(listParams);
+      allFolders.push(...(response.data.files ?? []));
+      pageToken = response.data.nextPageToken ?? undefined;
+    } while (pageToken);
+
+    return allFolders;
+  },
+};

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

@@ -0,0 +1,115 @@
+import {
+  AppConnectionValueForAuthProperty,
+  PiecePropValueSchema,
+  Property,
+  createTrigger,
+} from '@guayaba/workflows-framework';
+import { TriggerStrategy } from '@guayaba/workflows-framework';
+import {
+  DedupeStrategy,
+  Polling,
+  pollingHelper,
+} from '@guayaba/workflows-common';
+
+import dayjs from 'dayjs';
+import { googleDriveAuth } from '../auth';
+import { common } from '../common';
+import { downloadFileFromDrive } from '../common/get-file-content';
+
+const polling: Polling<
+  AppConnectionValueForAuthProperty<typeof googleDriveAuth>,
+  { parentFolder?: any; include_team_drives?: boolean }
+> = {
+  strategy: DedupeStrategy.TIMEBASED,
+  items: async ({ auth, propsValue, lastFetchEpochMS }) => {
+    const currentValues =
+      (await common.getFiles(auth, {
+        parent: propsValue.parentFolder,
+        createdTime: lastFetchEpochMS,
+        includeTeamDrive: propsValue.include_team_drives,
+      })) ?? [];
+    const items = currentValues.map((item: any) => ({
+      epochMilliSeconds: dayjs(item.createdTime).valueOf(),
+      data: item,
+    }));
+    return items;
+  },
+};
+
+export const newFile = createTrigger({
+  auth: googleDriveAuth,
+  name: 'new_file',
+  displayName: 'New File',
+  description: 'Trigger when a new file is uploaded.',
+  props: {
+    parentFolder: common.properties.parentFolder,
+    include_team_drives: common.properties.include_team_drives,
+    include_file_content: Property.Checkbox({
+      displayName: 'Include File Content',
+      description: 'Include the file content in the output. This will increase the time taken to fetch the files and might cause issues with large files.',
+      required: false,
+      defaultValue: false
+    }),
+  },
+  type: TriggerStrategy.POLLING,
+  onEnable: async (context) => {
+    await pollingHelper.onEnable(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+    });
+  },
+  onDisable: async (context) => {
+    await pollingHelper.onDisable(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+    });
+  },
+  run: async (context) => {
+    const newFiles = await pollingHelper.poll(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+      files: context.files,
+    });
+
+    return await handleFileContent(newFiles, context)
+  },
+  test: async (context) => {
+    const newFiles = await pollingHelper.test(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+      files: context.files,
+    });
+
+    return await handleFileContent(newFiles, context)
+  },
+
+  sampleData: {
+    kind: 'drive#file',
+    mimeType: 'image/png',
+    id: '1dpv4-sKJfKRwI9qx1vWqQhEGEn3EpbI5',
+    name: 'google-drive.png',
+    link: 'https://cdn.activepieces.com/pieces/google-drive.png'
+  },
+});
+
+async function handleFileContent(newFiles: unknown[], context: any) {
+  const newFilesObj = JSON.parse(JSON.stringify(newFiles))
+
+  if (context.propsValue.include_file_content) {
+    const fileContentPromises: Promise<string>[] = []
+    for (const file of newFilesObj) {
+      fileContentPromises.push(downloadFileFromDrive(context.auth, context.files, file["id"], file["name"]));
+    }
+
+    const filesContent = await Promise.all(fileContentPromises)
+
+    for (let i = 0; i < newFilesObj.length; i++) {
+      newFilesObj[i].content = filesContent[i]
+    }
+  }
+  return newFilesObj
+}

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

@@ -0,0 +1,74 @@
+import {
+  AppConnectionValueForAuthProperty,
+  PiecePropValueSchema,
+  createTrigger,
+} from '@guayaba/workflows-framework';
+import { TriggerStrategy } from '@guayaba/workflows-framework';
+import {
+  DedupeStrategy,
+  Polling,
+  pollingHelper,
+} from '@guayaba/workflows-common';
+
+import dayjs from 'dayjs';
+import { googleDriveAuth } from '../auth';
+import { common } from '../common';
+
+const polling: Polling<
+  AppConnectionValueForAuthProperty<typeof googleDriveAuth>,
+  { parentFolder?: any,include_team_drives?:boolean }
+> = {
+  strategy: DedupeStrategy.TIMEBASED,
+  items: async ({ auth, propsValue, lastFetchEpochMS }) => {
+    const currentValues =
+      (await common.getFolders(auth, {
+        parent: propsValue.parentFolder,
+        createdTime: lastFetchEpochMS,
+        includeTeamDrive:propsValue.include_team_drives
+      })) ?? [];
+    const items = currentValues.map((item: any) => ({
+      epochMilliSeconds: dayjs(item.createdTime).valueOf(),
+      data: item,
+    }));
+    return items;
+  },
+};
+
+export const newFolder = createTrigger({
+  auth: googleDriveAuth,
+  name: 'new_folder',
+  displayName: 'New Folder',
+  description: 'Trigger when a new folder is created or uploaded.',
+  props: {
+    parentFolder: common.properties.parentFolder,
+    include_team_drives: common.properties.include_team_drives,
+  },
+  type: TriggerStrategy.POLLING,
+  onEnable: async (context) => {
+    await pollingHelper.onEnable(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+    });
+  },
+  onDisable: async (context) => {
+    await pollingHelper.onDisable(polling, {
+      auth: context.auth,
+      store: context.store,
+      propsValue: context.propsValue,
+    });
+  },
+  run: async (context) => {
+    return await pollingHelper.poll(polling, context);
+  },
+  test: async (context) => {
+    return await pollingHelper.test(polling, context);
+  },
+
+  sampleData: {
+    kind: 'drive#file',
+    mimeType: 'application/vnd.google-apps.folder',
+    id: '1aMEtTqIYn5651wdK7WLxaK_SDim4mvXW',
+    name: 'New Folder WOOOO',
+  },
+});

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"]
+}