@guayaba/workflow-piece-google-drive 0.7.5

package/src/lib/action/list-files.action.ts

@@ -0,0 +1,209 @@
+import { HttpMethod, httpClient } from '@guayaba/workflows-common';
+import { googleDriveAuth, getAccessToken } from '../auth';
+import { Property, createAction } from "@guayaba/workflows-framework";
+import querystring from 'querystring';
+import { common } from '../common';
+import { downloadFileFromDrive } from '../common/get-file-content';
+
+interface ListFilesResult {
+  type: string;
+  incompleteSearch: boolean;
+  files: unknown[];
+  downloadedFiles?: string[];
+}
+
+interface FileWithLevel {
+  file: any;
+  level: number;
+  parentFolder?: string;
+}
+
+async function getFilesRecursively(
+  auth: any,
+  folderId: string,
+  maxLevel: number,
+  includeTrashed: boolean,
+  includeTeamDrives: boolean,
+  currentLevel = 0
+): Promise<FileWithLevel[]> {
+  const files: FileWithLevel[] = [];
+
+  if (currentLevel > maxLevel) {
+    return files;
+  }
+
+  const accessToken = await getAccessToken(auth);
+
+  let q = `'${folderId}' in parents`;
+  if (!includeTrashed) {
+    q += ' and trashed=false';
+  }
+
+  const params: Record<string, string> = {
+    q: q,
+    fields: 'nextPageToken,files(id,kind,mimeType,name,trashed,parents)',
+    supportsAllDrives: 'true',
+    includeItemsFromAllDrives: includeTeamDrives ? 'true' : 'false',
+    pageSize: '1000',
+  };
+
+  let response = await httpClient.sendRequest({
+    method: HttpMethod.GET,
+    url: `https://www.googleapis.com/drive/v3/files?${querystring.stringify(params)}`,
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+  });
+
+  // Add files from current level
+  for (const file of response.body.files) {
+    files.push({
+      file,
+      level: currentLevel,
+      parentFolder: folderId
+    });
+  }
+
+  // Handle pagination for current level
+  while (response.body.nextPageToken) {
+    params.pageToken = response.body.nextPageToken;
+    response = await httpClient.sendRequest({
+      method: HttpMethod.GET,
+      url: `https://www.googleapis.com/drive/v3/files?${querystring.stringify(params)}`,
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+
+    for (const file of response.body.files) {
+      files.push({
+        file,
+        level: currentLevel,
+        parentFolder: folderId
+      });
+    }
+  }
+
+  // If we haven't reached max level, recursively get files from subfolders
+  if (currentLevel + 1 < maxLevel) {
+    const subfolders = files.filter(f => f.file.mimeType === 'application/vnd.google-apps.folder');
+
+    for (const subfolder of subfolders) {
+      const subfolderFiles = await getFilesRecursively(
+        auth,
+        subfolder.file.id,
+        maxLevel,
+        includeTrashed,
+        includeTeamDrives,
+        currentLevel + 1
+      );
+      files.push(...subfolderFiles);
+    }
+  }
+
+  return files;
+}
+
+export const googleDriveListFiles = createAction({
+  auth: googleDriveAuth,
+  name: 'list-files',
+  displayName: 'List files',
+  description: 'List files from a Google Drive folder',
+  props: {
+    folderId: Property.ShortText({
+      displayName: 'Folder ID',
+      description: 'Folder ID coming from | New Folder -> id | (or any other source)',
+      required: true,
+    }),
+    include_team_drives: common.properties.include_team_drives,
+    
+    includeTrashed: Property.Checkbox({
+      displayName: 'Include Trashed',
+      description: 'Include new files that have been trashed.',
+      required: false,
+      defaultValue: false
+    }),
+
+    depthLevel: Property.Number({
+      displayName: 'Depth Level',
+      description: 'How many levels deep to search for files. 1 = current folder only, 2 = current + next level, etc.',
+      required: false,
+      defaultValue: 1
+    }),
+
+    downloadFiles: Property.Checkbox({
+      displayName: 'Download Files',
+      description: 'Download all file contents in a list',
+      required: false,
+      defaultValue: false
+    }),
+  },
+  async run(context) {
+    const result: ListFilesResult = {
+      type: 'drive#fileList',
+      incompleteSearch: false,
+      files: [],
+    }
+
+    const depthLevel = context.propsValue.depthLevel || 1;
+    
+    // Get files recursively based on depth level
+    const filesWithLevel = await getFilesRecursively(
+      context.auth,
+      context.propsValue.folderId,
+      depthLevel,
+      context.propsValue.includeTrashed ?? false,
+      context.propsValue.include_team_drives ?? false
+    );
+
+    // Extract just the file objects for backward compatibility
+    result.files = filesWithLevel.map(f => f.file);
+
+    // If downloadFiles is enabled, download each file and add URLs to array
+    if (context.propsValue.downloadFiles) {
+      const downloadedFiles: string[] = [];
+      const extensionMap: Record<string, string> = {
+        'application/pdf': '.pdf',
+        'image/jpeg': '.jpg',
+        'image/png': '.png',
+        'image/tiff': '.tiff',
+        'text/plain': '.txt',
+        'text/csv': '.csv',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx'
+      };
+
+      for (const fileWithLevel of filesWithLevel) {
+        const file = fileWithLevel.file;
+        // Skip folders when downloading
+        if (file.mimeType === 'application/vnd.google-apps.folder') {
+          continue;
+        }
+
+        let safeName = file.name;
+        const correctExtension = extensionMap[file.mimeType];
+        if (correctExtension && !safeName.toLowerCase().endsWith(correctExtension)) {
+            // Check for the .jpeg edge case before appending .jpg
+            if (!(file.mimeType === 'image/jpeg' && safeName.toLowerCase().endsWith('.jpeg'))) {
+                safeName = safeName + correctExtension;
+            }
+        }
+        
+        try {
+          const fileUrl = await downloadFileFromDrive(
+            context.auth,
+            context.files,
+            file.id,
+            safeName
+          );
+          downloadedFiles.push(fileUrl);
+        } catch (error) {
+          console.warn(`Failed to download file ${file.name}: ${error instanceof Error ? error.message : 'Download failed'}`);
+        }
+      }
+      result.downloadedFiles = downloadedFiles;
+    }
+
+    return result;
+  }
+});

package/src/lib/action/move-file.ts

@@ -0,0 +1,44 @@
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { common } from '../common';
+import { google } from 'googleapis';
+
+export const moveFileAction = createAction({
+  auth: googleDriveAuth,
+  name: 'google-drive-move-file',
+  displayName: 'Move File',
+  description: 'Moves a file from one folder to another.',
+  props: {
+    fileId: Property.ShortText({
+      displayName: 'File ID',
+      description: 'You can use **Search Folder/File** action to retrieve ID.',
+      required: true,
+    }),
+    include_team_drives: common.properties.include_team_drives,
+    folderId: common.properties.parentFolder,
+  },
+  async run(context) {
+    const fileId = context.propsValue.fileId;
+    const folderId = context.propsValue.folderId;
+
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = google.drive({ version: 'v3', auth: authClient });
+
+    const file = await drive.files.get({
+      fileId,
+      supportsAllDrives: context.propsValue.include_team_drives,
+      fields: 'id,parents',
+    });
+
+    const response = await drive.files.update({
+      fileId: fileId,
+      fields: '*',
+      removeParents: file.data.parents?.join(','),
+      addParents: folderId,
+      supportsAllDrives: context.propsValue.include_team_drives,
+    });
+
+    return response.data;
+  },
+});

package/src/lib/action/read-file.ts

@@ -0,0 +1,24 @@
+import { googleDriveAuth } from '../auth';
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { downloadFileFromDrive } from '../common/get-file-content';
+
+export const readFile = createAction({
+  auth: googleDriveAuth,
+  name: 'read-file',
+  displayName: 'Read File Content',
+  description: 'Read a selected file from google drive file',
+  props: {
+    fileId: Property.ShortText({
+      displayName: 'File ID',
+      description: 'File ID coming from | New File -> id |',
+      required: true,
+    }),
+    fileName: Property.ShortText({
+      displayName: 'Destination File name',
+      required: false,
+    }),
+  },
+  run: async ({ auth, propsValue, files }) => {
+    return downloadFileFromDrive(auth, files, propsValue.fileId, propsValue.fileName)
+  },
+});

package/src/lib/action/save-file-as-pdf.action.ts

@@ -0,0 +1,72 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { Property, createAction } from '@guayaba/workflows-framework';
+import { google } from 'googleapis';
+import { Stream } from 'stream';
+import { common } from '../common';
+
+export const saveFileAsPdf = createAction({
+  displayName: 'Save Document as PDF',
+  auth: googleDriveAuth,
+  name: 'save_file_as_pdf',
+  description: 'Save a document as PDF in a Google Drive folder',
+  props: {
+    documentId: Property.ShortText({
+      displayName: 'Document ID',
+      description: 'The ID of the document to export',
+      required: true,
+    }),
+    folderId: Property.ShortText({
+      displayName: 'Folder ID',
+      description: 'The ID of the folder where the file will be exported',
+      required: true,
+    }),
+    name: Property.ShortText({
+      displayName: 'Name',
+      description: 'The name of the new file (do not include the extension)',
+      required: true,
+    }),
+    include_team_drives: common.properties.include_team_drives,
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const documentId = context.propsValue.documentId;
+    const folderId = context.propsValue.folderId;
+    const nameForNewFile = context.propsValue.name;
+
+    const drive = google.drive({ version: 'v3', auth: authClient });
+
+    const result = await drive.files.export(
+      {
+        fileId: documentId,
+        mimeType: 'application/pdf',
+      },
+      {
+        responseType: 'arraybuffer',
+      }
+    );
+
+    const requestBody = {
+      name: nameForNewFile + '.pdf',
+      parents: [folderId],
+    };
+    const templateBuffer = Buffer.from(result.data as any, 'base64');
+
+    const stream = new Stream.PassThrough().end(templateBuffer);
+
+    const media = {
+      mimeType: 'application/pdf',
+      body: stream,
+    };
+
+    const file = await drive.files.create({
+      requestBody,
+      media: media,
+      supportsAllDrives: context.propsValue.include_team_drives,
+    });
+
+    return file.data;
+  },
+});

package/src/lib/action/search-folder-or-file.action.ts

@@ -0,0 +1,108 @@
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { Property, createAction } from '@guayaba/workflows-framework';
+import { google } from 'googleapis';
+import { common } from '../common';
+
+export const googleDriveSearchFolder = createAction({
+  auth: googleDriveAuth,
+  name: 'search-folder',
+  displayName: 'Search',
+  description: 'Search a Google Drive folder for files/sub-folders',
+  props: {
+    queryTerm: Property.StaticDropdown({
+      displayName: 'Query Term',
+      description: 'The Query term or field of file/folder to search upon.',
+      defaultValue: 'name',
+      options: {
+        options: [
+          { label: 'File name', value: 'name' },
+          { label: 'Full text search', value: 'fullText' },
+          { label: 'Content type', value: 'mimeType' },
+        ],
+      },
+      required: true,
+    }),
+    operator: Property.StaticDropdown({
+      displayName: 'Operator',
+      description: 'The operator to create criteria.',
+      required: true,
+      options: {
+        options: [
+          { label: 'Contains', value: 'contains' },
+          { label: 'Equals', value: '=' },
+        ],
+      },
+      defaultValue: 'contains',
+    }),
+    query: Property.ShortText({
+      displayName: 'Value',
+      description: 'Value of the field of file/folder to search for.',
+      required: true,
+    }),
+    type: Property.StaticDropdown({
+      displayName: 'File Type',
+      description: '(Optional) Choose between files and folders.',
+      required: false,
+      options: {
+        options: [
+          { label: 'All', value: 'all' },
+          { label: 'Files', value: 'file' },
+          { label: 'Folders', value: 'folder' },
+        ],
+      },
+      defaultValue: 'all',
+    }),
+    parentFolder: common.properties.parentFolder,
+    include_team_drives: common.properties.include_team_drives,
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = google.drive({ version: 'v3', auth: authClient });
+    const operator = context.propsValue.operator ?? 'contains';
+    const queryTerm = context.propsValue.queryTerm ?? 'name';
+    let finalQuery = `${queryTerm} ${operator} '${context.propsValue.query}'`;
+    if (context.propsValue.parentFolder) {
+      finalQuery = `${finalQuery} and '${context.propsValue.parentFolder}' in parents`;
+    }
+
+    const type = context.propsValue.type ?? 'all';
+    switch (type) {
+      case 'file':
+        finalQuery = `${finalQuery} and mimeType!='application/vnd.google-apps.folder'`;
+        break;
+      case 'folder':
+        finalQuery = `${finalQuery} and mimeType='application/vnd.google-apps.folder'`;
+        break;
+      default:
+        break;
+    }
+
+    const allFiles: any[] = [];
+    let pageToken: string | undefined = undefined;
+    do {
+      const listParams: Record<string, any> = {
+        q: finalQuery,
+        fields: 'nextPageToken, files(id, name, mimeType, createdTime, modifiedTime)',
+        includeItemsFromAllDrives: context.propsValue.include_team_drives,
+        supportsAllDrives: true,
+        pageSize: 1000,
+      };
+      if (pageToken) listParams.pageToken = pageToken;
+      const response = await drive.files.list(listParams);
+      if (response.status !== 200) {
+        console.error(response);
+        throw new Error('Error searching for the file/folder');
+      }
+      allFiles.push(...(response.data.files ?? []));
+      pageToken = response.data.nextPageToken ?? undefined;
+    } while (pageToken);
+
+    if (allFiles.length > 0) {
+      return allFiles;
+    } else {
+      console.log('Resource not found');
+      return [];
+    }
+  },
+});

package/src/lib/action/send-to-trash.ts

@@ -0,0 +1,34 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { common } from '../common';
+import { google } from 'googleapis';
+
+export const googleDriveTrashFile = createAction({
+  auth: googleDriveAuth,
+  name: 'trash_gdrive_file',
+  description: 'Move a file to the trash in your Google Drive',
+  displayName: 'Trash file',
+  props: {
+    fileId: Property.ShortText({
+      displayName: 'File ID',
+      description: 'The ID of the file to trash',
+      required: true,
+    }),
+    include_team_drives: common.properties.include_team_drives,
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const drive = google.drive({ version: 'v3', auth: authClient });
+    const body_value = {
+      trashed: true,
+    };
+    const response = await drive.files.update({
+      fileId: context.propsValue.fileId,
+      supportsAllDrives: context.propsValue.include_team_drives,
+      requestBody: body_value,
+    });
+
+    return response.data;
+  },
+});

package/src/lib/action/set-public-access.ts

@@ -0,0 +1,64 @@
+import { Property, createAction } from '@guayaba/workflows-framework';
+import { googleDriveAuth, createGoogleClient } from '../auth';
+import { google } from 'googleapis';
+import { downloadFileFromDrive } from '../common/get-file-content';
+
+export const setPublicAccess = createAction({
+  auth: googleDriveAuth,
+  name: 'set_public_access',
+  description: 'Set public access for a file or folder',
+  displayName: 'Set public access',
+  props: {
+    fileId: Property.ShortText({
+      displayName: 'File or Folder ID',
+      description: 'The ID of the file or folder to update permissions for',
+      required: true,
+    }),
+    role: Property.StaticDropdown({
+      displayName: 'Role',
+      description: 'The role to assign for public access',
+      options: {
+        options: [
+          { label: 'Reader', value: 'reader' },
+          { label: 'Commenter', value: 'commenter' },
+          { label: 'Editor', value: 'writer' },
+        ],
+      },
+      defaultValue: 'reader',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const fileId = context.propsValue.fileId;
+    const role = context.propsValue.role;
+
+    const drive = google.drive({ version: 'v3', auth: authClient });
+    const permission = {
+      role,
+      type: 'anyone',
+    };
+    const res = await drive.permissions.create({
+      fileId: fileId,
+      requestBody: permission,
+    });
+
+    const file = await drive.files.get({
+      fileId: fileId,
+      fields: 'name,mimeType,webContentLink,webViewLink',
+    });
+
+    if (file.data.mimeType === 'application/vnd.google-apps.folder') {
+      return { ...res.data, webViewLink: file.data.webViewLink, downloadUrl: null };
+    }
+
+    const content = await downloadFileFromDrive(
+      context.auth,
+      context.files,
+      fileId,
+      file.data.name!
+    );
+    return { ...res.data, downloadUrl: content };
+  },
+});

package/src/lib/action/upload-file.ts

@@ -0,0 +1,72 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import {
+  httpClient,
+  HttpMethod,
+  AuthenticationType,
+} from '@guayaba/workflows-common';
+import FormData from 'form-data';
+import { googleDriveAuth, getAccessToken } from '../auth';
+import mime from 'mime-types';
+import { common } from '../common';
+
+export const googleDriveUploadFile = createAction({
+  auth: googleDriveAuth,
+  name: 'upload_gdrive_file',
+  description: 'Upload a file in your Google Drive',
+  displayName: 'Upload file',
+  props: {
+    fileName: Property.ShortText({
+      displayName: 'File name',
+      description: 'The name of the file',
+      required: true,
+    }),
+    file: Property.File({
+      displayName: 'File',
+      description: 'The file URL or base64 to upload',
+      required: true,
+    }),
+    parentFolder: common.properties.parentFolder,
+    include_team_drives: common.properties.include_team_drives,
+  },
+  async run(context) {
+    const fileData = context.propsValue.file;
+    const mimeType = mime.lookup(fileData.extension ? fileData.extension : '');
+
+    const meta = {
+      mimeType: mimeType,
+      name: context.propsValue.fileName,
+      ...(context.propsValue.parentFolder
+        ? { parents: [context.propsValue.parentFolder] }
+        : {}),
+    };
+
+    const metaBuffer = Buffer.from(JSON.stringify(meta), 'utf-8');
+    const fileBuffer = Buffer.from(fileData.base64, 'base64');
+
+    const form = new FormData();
+    form.append('Metadata', metaBuffer, { contentType: 'application/json' });
+    form.append('Media', fileBuffer);
+
+    const result = await httpClient.sendRequest({
+      method: HttpMethod.POST,
+      url: `https://www.googleapis.com/upload/drive/v3/files`,
+      queryParams: {
+        uploadType: 'multipart',
+        supportsAllDrives: String(
+          context.propsValue.include_team_drives || false
+        ),
+      },
+      body: form,
+      headers: {
+        ...form.getHeaders(),
+      },
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: await getAccessToken(context.auth),
+      },
+    });
+
+    console.debug('File upload response', result);
+    return result.body;
+  },
+});