@pipedream/google_drive 1.6.2 → 1.7.0

package/actions/common/google-workspace-default-export-formats.mjs

@@ -0,0 +1,53 @@
+// Per https://developers.google.com/workspace/drive/api/guides/ref-export-formats,
+// only six Google Workspace types have documented export MIME mappings.
+// The defaults below prefer Microsoft Office equivalents where one exists.
+export const defaultExportMimeBySource = {
+  "application/vnd.google-apps.document":
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.google-apps.spreadsheet":
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.google-apps.presentation":
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  "application/vnd.google-apps.drawing": "image/png",
+  "application/vnd.google-apps.script":
+    "application/vnd.google-apps.script+json",
+};
+
+// Workspace types with no export path via `files.export`.
+// Source: the absence of these types from
+// https://developers.google.com/workspace/drive/api/guides/ref-export-formats.
+export const unsupportedWorkspaceMimes = {
+  "application/vnd.google-apps.folder":
+    "Folders can't be downloaded as files. Use a folder-zip action or list the folder's contents instead.",
+  "application/vnd.google-apps.form":
+    "Google Forms can't be exported via the Drive API. Use the Google Forms API to fetch form content or responses.",
+  "application/vnd.google-apps.map":
+    "My Maps can't be exported via the Drive API. Export manually from the My Maps UI as KMZ if needed.",
+};
+
+// Used to append a file extension when deriving a default filePath from the
+// file's name. Covers every MIME in google-workspace-export-formats.mjs plus
+// the Office defaults above.
+export const extensionByMime = {
+  "application/epub+zip": "epub",
+  "application/pdf": "pdf",
+  "application/rtf": "rtf",
+  "application/vnd.google-apps.script+json": "json",
+  "application/vnd.oasis.opendocument.presentation": "odp",
+  "application/vnd.oasis.opendocument.spreadsheet": "ods",
+  "application/vnd.oasis.opendocument.text": "odt",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+  "application/x-vnd.oasis.opendocument.spreadsheet": "ods",
+  "application/zip": "zip",
+  "image/jpeg": "jpg",
+  "image/png": "png",
+  "image/svg+xml": "svg",
+  "text/csv": "csv",
+  "text/html": "html",
+  "text/markdown": "md",
+  "text/plain": "txt",
+  "text/tab-separated-values": "tsv",
+  "text/x-markdown": "md",
+};

package/actions/download-file/download-file.mjs

@@ -5,6 +5,13 @@ import { GOOGLE_DRIVE_MIME_TYPE_PREFIX } from "../../common/constants.mjs";
 import { toSingleLineString } from "../../common/utils.mjs";
 import googleDrive from "../../google_drive.app.mjs";
 import googleWorkspaceExportFormats from "../common/google-workspace-export-formats.mjs";
+import {
+  defaultExportMimeBySource,
+  extensionByMime,
+  unsupportedWorkspaceMimes,
+} from "../common/google-workspace-default-export-formats.mjs";
+
+const SHORTCUT_MIME_TYPE = "application/vnd.google-apps.shortcut";
 
 /**
  * Uses Google Drive API to download files to a `filePath` in the /tmp
@@ -17,8 +24,14 @@ import googleWorkspaceExportFormats from "../common/google-workspace-export-form
 export default {
   key: "google_drive-download-file",
   name: "Download File",
-  description: "Download a file. [See the documentation](https://developers.google.com/drive/api/v3/manage-downloads) for more information",
-  version: "0.1.23",
+  description: "Download a file from Google Drive to the `/tmp` directory or return its contents as a buffer."
+    + " Use to fetch a file's contents for processing in downstream steps — e.g., parsing a CSV, extracting text from a PDF, or re-uploading to another service."
+    + " For Google Workspace files (Docs, Sheets, Slides, Drawings, Apps Script), exports to an Office-compatible format by default:"
+    + " Docs → `.docx`, Sheets → `.xlsx`, Slides → `.pptx`, Drawings → PNG, Apps Script → JSON."
+    + " Pass `mimeType` to force a specific format. Shortcuts are resolved to their target automatically."
+    + " Folders, Forms, and My Maps cannot be downloaded via this action."
+    + " [See the documentation](https://developers.google.com/drive/api/v3/manage-downloads)",
+  version: "0.1.24",
   annotations: {
     destructiveHint: false,
     openWorldHint: true,
@@ -32,6 +45,7 @@ export default {
         googleDrive,
         "watchedDrive",
       ],
+      description: "The shared drive the file is in, if any. Leave empty for files in My Drive.",
       optional: true,
     },
     fileId: {
@@ -42,7 +56,7 @@ export default {
           drive: c.drive,
         }),
       ],
-      description: "The file to download",
+      description: "The Google Drive file to download. Accepts a file ID (opaque Drive identifier). If a shortcut is passed, the target file is resolved and downloaded automatically.",
     },
     filePath: {
       type: "string",
@@ -50,7 +64,10 @@ export default {
       description: toSingleLineString(`
         The destination file name or path [in the \`/tmp\`
         directory](https://pipedream.com/docs/workflows/steps/code/nodejs/working-with-files/#the-tmp-directory)
-        (e.g., \`/tmp/myFile.csv\`)
+        (e.g., \`/tmp/myFile.csv\`). Defaults to \`/tmp/<file name>\` if omitted.
+        **Note:** if you set this for a Google Workspace file, the extension you
+        choose should match the Conversion Format; otherwise the file contents
+        may not match the extension.
       `),
       optional: true,
     },
@@ -59,7 +76,9 @@ export default {
       label: "Conversion Format",
       description: toSingleLineString(`
         The format to which to convert the downloaded file if it is a [Google Workspace
-        document](https://developers.google.com/drive/api/v3/ref-export-formats)
+        document](https://developers.google.com/drive/api/v3/ref-export-formats).
+        If omitted, defaults per source type: Docs → \`.docx\`, Sheets → \`.xlsx\`,
+        Slides → \`.pptx\`, Drawings → PNG, Apps Script → JSON.
       `),
       optional: true,
       async options() {
@@ -98,47 +117,76 @@ export default {
       type: "dir",
       accessMode: "write",
       sync: true,
+      optional: true,
     },
     getBufferResponse: {
       type: "boolean",
       label: "Get Buffer Response",
-      description: "Whether to return the file content as a buffer instead of writing to a file path",
+      description: "If true, returns the file content as a buffer in the output (useful for passing directly to another step) instead of writing it to `/tmp`. Defaults to false.",
       optional: true,
     },
   },
   async run({ $ }) {
-    // Validate that filePath is provided when not getting raw response
-    if (!this.getBufferResponse && !this.filePath) {
-      throw new Error("File Path is required when not using Get Buffer Response");
+    let fileMetadata = await this.googleDrive.getFile(this.fileId, {
+      fields: "name,mimeType,shortcutDetails,webViewLink",
+    });
+
+    // Shortcuts point at a target file; resolve and download the target instead.
+    let downloadFileId = this.fileId;
+    let resolvedFromShortcut = false;
+    if (fileMetadata.mimeType === SHORTCUT_MIME_TYPE) {
+      const targetId = fileMetadata.shortcutDetails?.targetId;
+      if (!targetId) {
+        throw new Error(`Shortcut "${fileMetadata.name}" has no target file and cannot be downloaded.`);
+      }
+      downloadFileId = targetId;
+      resolvedFromShortcut = true;
+      fileMetadata = await this.googleDrive.getFile(targetId, {
+        fields: "name,mimeType,webViewLink",
+      });
     }
 
-    // Get file metadata to get file's MIME type
-    const fileMetadata = await this.googleDrive.getFile(this.fileId, {
-      fields: "name,mimeType",
-    });
-    const mimeType = fileMetadata.mimeType;
+    const sourceMimeType = fileMetadata.mimeType;
+
+    if (unsupportedWorkspaceMimes[sourceMimeType]) {
+      throw new Error(
+        `Cannot download file of type "${sourceMimeType}": ${unsupportedWorkspaceMimes[sourceMimeType]}`,
+      );
+    }
 
-    const isWorkspaceDocument = mimeType.includes(GOOGLE_DRIVE_MIME_TYPE_PREFIX);
-    if (isWorkspaceDocument && !this.mimeType) {
-      throw new Error("Conversion Format is required when File is a Google Workspace Document");
+    const isWorkspaceDocument = sourceMimeType.includes(GOOGLE_DRIVE_MIME_TYPE_PREFIX);
+
+    // Fallback: user value -> static default -> runtime getExportFormats().
+    let effectiveMimeType = this.mimeType;
+    if (isWorkspaceDocument && !effectiveMimeType) {
+      effectiveMimeType = defaultExportMimeBySource[sourceMimeType];
+      if (!effectiveMimeType) {
+        const exportFormats = await this.googleDrive.getExportFormats();
+        effectiveMimeType = exportFormats[sourceMimeType]?.[0];
+      }
+      if (!effectiveMimeType) {
+        throw new Error(
+          `No export format available for "${sourceMimeType}". Set Conversion Format explicitly.`,
+        );
+      }
     }
-    // Download file
-    // If `mimeType` is a Google MIME type, use `downloadWorkspaceFile`. Otherwise, use `getFile`.
-    // See https://developers.google.com/drive/api/v3/mime-types for a list of Google MIME types.
-    // Google Workspace format to MIME type map:
-    // https://developers.google.com/drive/api/v3/ref-export-formats
+
+    // See https://developers.google.com/drive/api/v3/mime-types for Google MIME types.
     const file = isWorkspaceDocument
-      ? await this.googleDrive.downloadWorkspaceFile(this.fileId, {
-        mimeType: this.mimeType,
+      ? await this.googleDrive.downloadWorkspaceFile(downloadFileId, {
+        mimeType: effectiveMimeType,
       })
-      : await this.googleDrive.getFile(this.fileId, {
+      : await this.googleDrive.getFile(downloadFileId, {
         alt: "media",
       });
 
+    const summaryPrefix = resolvedFromShortcut
+      ? "Resolved shortcut and downloaded"
+      : "Successfully downloaded";
+
     if (this.getBufferResponse) {
-      $.export("$summary", `Successfully retrieved raw content for file "${fileMetadata.name}"`);
+      $.export("$summary", `${summaryPrefix} raw content for file "${fileMetadata.name}"`);
 
-      // Convert stream to buffer
       const chunks = [];
       for await (const chunk of file) {
         chunks.push(chunk);
@@ -148,20 +196,34 @@ export default {
       return {
         fileId: this.fileId,
         fileMetadata,
+        webViewLink: fileMetadata.webViewLink,
         content: buffer,
       };
     }
 
-    // Stream file to `filePath`
+    let filePath;
+    if (this.filePath) {
+      filePath = this.filePath.includes("tmp/")
+        ? this.filePath
+        : `/tmp/${this.filePath}`;
+    } else {
+      let defaultName = fileMetadata.name;
+      if (isWorkspaceDocument) {
+        const ext = extensionByMime[effectiveMimeType];
+        if (ext && !defaultName.toLowerCase().endsWith(`.${ext.toLowerCase()}`)) {
+          defaultName = `${defaultName}.${ext}`;
+        }
+      }
+      filePath = `/tmp/${defaultName}`;
+    }
+
     const pipeline = promisify(stream.pipeline);
-    const filePath = this.filePath.includes("tmp/")
-      ? this.filePath
-      : `/tmp/${this.filePath}`;
     await pipeline(file, fs.createWriteStream(filePath));
-    $.export("$summary", `Successfully downloaded the file, "${fileMetadata.name}"`);
+    $.export("$summary", `${summaryPrefix} the file, "${fileMetadata.name}"`);
     return {
       fileId: this.fileId,
       fileMetadata,
+      webViewLink: fileMetadata.webViewLink,
       filePath,
     };
   },

package/actions/is-folder-ancestor/is-folder-ancestor.mjs

@@ -0,0 +1,121 @@
+import googleDrive from "../../google_drive.app.mjs";
+
+export default {
+  key: "google_drive-is-folder-ancestor",
+  name: "Is Folder Ancestor",
+  description: "Check if a specific folder is anywhere in the parent hierarchy of a file or folder. [See the documentation](https://developers.google.com/workspace/drive/api/reference/rest/v3/files/get)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    googleDrive,
+    fileId: {
+      propDefinition: [
+        googleDrive,
+        "fileOrFolderId",
+      ],
+      description: "The ID of the file or folder to check",
+    },
+    ancestorFolderId: {
+      propDefinition: [
+        googleDrive,
+        "folderId",
+      ],
+      label: "Ancestor Folder ID",
+      description: "The folder ID to check for in the parent hierarchy",
+    },
+  },
+  async run({ $ }) {
+    const {
+      fileId, ancestorFolderId,
+    } = this;
+
+    // Get the initial file's parents to start traversal from parent (not the file itself)
+    let file;
+    try {
+      file = await this.googleDrive.getFile(fileId, {
+        fields: "id,name,parents",
+      });
+    } catch (err) {
+      throw new Error(`Failed to retrieve file "${fileId}": ${err.message}`);
+    }
+
+    const initialParents = file.parents || [];
+    if (initialParents.length === 0) {
+      $.export("$summary", `Folder "${ancestorFolderId}" is NOT an ancestor of file "${fileId}"`);
+      return {
+        isAncestor: false,
+        fileId,
+        ancestorFolderId,
+        reason: "not_in_hierarchy",
+      };
+    }
+
+    // BFS traversal to check all parent paths (files can have multiple parents in Drive)
+    const queue = [
+      ...initialParents,
+    ];
+    const visitedIds = new Set([
+      fileId,
+    ]);
+
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+
+      // Skip if already visited (prevents cycles)
+      if (visitedIds.has(currentId)) {
+        continue;
+      }
+      visitedIds.add(currentId);
+
+      // Check if current parent matches the ancestor folder ID
+      if (currentId === ancestorFolderId) {
+        let ancestorFile;
+        try {
+          ancestorFile = await this.googleDrive.getFile(currentId, {
+            fields: "id,name",
+          });
+        } catch (err) {
+          throw new Error(`Failed to retrieve ancestor folder "${currentId}": ${err.message}`);
+        }
+        $.export("$summary", `Folder "${ancestorFolderId}" is an ancestor of file "${fileId}"`);
+        return {
+          isAncestor: true,
+          fileId,
+          ancestorFolderId,
+          ancestorName: ancestorFile.name,
+        };
+      }
+
+      // Get file metadata including parents to continue traversal
+      let parentFile;
+      try {
+        parentFile = await this.googleDrive.getFile(currentId, {
+          fields: "id,name,parents",
+        });
+      } catch (err) {
+        throw new Error(`Failed to retrieve file "${currentId}": ${err.message}`);
+      }
+
+      // Enqueue all parents for traversal
+      const parents = parentFile.parents || [];
+      for (const parentId of parents) {
+        if (!visitedIds.has(parentId)) {
+          queue.push(parentId);
+        }
+      }
+    }
+
+    $.export("$summary", `Folder "${ancestorFolderId}" is NOT an ancestor of file "${fileId}"`);
+    return {
+      isAncestor: false,
+      fileId,
+      ancestorFolderId,
+      reason: "not_in_hierarchy",
+    };
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/google_drive",
-  "version": "1.6.2",
+  "version": "1.7.0",
   "description": "Pipedream Google_drive Components",
   "main": "google_drive.app.mjs",
   "keywords": [