@pipedream/sharepoint 0.7.2 → 0.8.1

package/common/utils.mjs

@@ -7,6 +7,84 @@ export default {
     }
     return o;
   },
+
+  /**
+   * Internal helper to unwrap a potentially labeled value.
+   * Note: For most use cases, prefer using sharepoint.resolveWrappedValue() from the app.
+   * This is only for utility functions that don't have access to the app instance.
+   * @private
+   * @param {*} value - The value to unwrap
+   * @returns {*} The unwrapped value
+   */
+  _unwrapValue(value) {
+    return value?.value || value;
+  },
+
+  /**
+   * Parses a file or folder value from JSON string or returns wrapped object
+   * @param {*} value - The value to parse (JSON string or raw ID)
+   * @returns {{ id: string, name?: string, isFolder: boolean } | null}
+   */
+  parseFileOrFolder(value) {
+    if (!value) return null;
+    const resolved = this._unwrapValue(value);
+    try {
+      return JSON.parse(resolved);
+    } catch {
+      return {
+        id: resolved,
+        isFolder: false,
+      };
+    }
+  },
+
+  /**
+   * Parses a list of file or folder values
+   * @param {*} values - Single value or array of values
+   * @returns {Array<{ id: string, name?: string, isFolder: boolean }>}
+   */
+  parseFileOrFolderList(values) {
+    if (!values) return [];
+    const list = Array.isArray(values)
+      ? values
+      : [
+        values,
+      ];
+    return list.map((v) => this.parseFileOrFolder(v)).filter(Boolean);
+  },
+
+  /**
+   * Attempts to decode a base64 string (SharePoint encodes group names in base64)
+   * @param {string} str - String that may be base64 encoded
+   * @returns {string | null} Decoded string or null if not valid base64
+   */
+  tryDecodeBase64(str) {
+    try {
+      if (/^[A-Za-z0-9+/]+=*$/.test(str) && str.length > 10) {
+        const decoded = Buffer.from(str, "base64").toString("utf-8");
+        if (/^[\x20-\x7E\s]+$/.test(decoded)) {
+          return decoded;
+        }
+      }
+    } catch {
+      // Not valid base64
+    }
+    return null;
+  },
+
+  /**
+   * Determines access level from roles array
+   * @param {string[]} roles - Array of role strings
+   * @returns {"owner" | "write" | "read"}
+   */
+  getAccessLevel(roles) {
+    if (!Array.isArray(roles)) return "read";
+    if (roles.includes("owner")) return "owner";
+    if (roles.includes("write")) return "write";
+    if (roles.includes("read")) return "read";
+    return "read";
+  },
+
   parseObject(obj) {
     if (!obj) return undefined;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/sharepoint",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "description": "Pipedream Microsoft Sharepoint Online Components",
   "main": "sharepoint.app.mjs",
   "keywords": [
@@ -13,6 +13,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@pipedream/platform": "^3.1.1"
+    "@pipedream/platform": "^3.1.1",
+    "@microsoft/microsoft-graph-client": "^3.0.7",
+    "async-retry": "^1.3.3",
+    "isomorphic-fetch": "^3.0.0"
   }
 }

package/sharepoint.app.mjs

@@ -1,4 +1,8 @@
 import { axios } from "@pipedream/platform";
+import { Client } from "@microsoft/microsoft-graph-client";
+import retry from "async-retry";
+import "isomorphic-fetch";
+import { WEBHOOK_SUBSCRIPTION_EXPIRATION_TIME_MILLISECONDS } from "./common/constants.mjs";
 
 export default {
   type: "app",
@@ -136,6 +140,7 @@ export default {
         if (!siteId) {
           return [];
         }
+        siteId = this.resolveWrappedValue(siteId);
         const args = {
           siteId,
         };
@@ -235,6 +240,41 @@ export default {
           }));
       },
     },
+    fileIds: {
+      type: "string[]",
+      label: "Files",
+      description: "Select files or enter custom file IDs.",
+      async options({
+        siteId, driveId, folderId,
+      }) {
+        const resolvedSiteId = this.resolveWrappedValue(siteId);
+        const resolvedDriveId = this.resolveWrappedValue(driveId);
+        const resolvedFolderId = this.resolveWrappedValue(folderId);
+
+        if (!resolvedSiteId || !resolvedDriveId) {
+          return [];
+        }
+
+        const response = resolvedFolderId
+          ? await this.listDriveItemsInFolder({
+            driveId: resolvedDriveId,
+            folderId: resolvedFolderId,
+          })
+          : await this.listDriveItems({
+            siteId: resolvedSiteId,
+            driveId: resolvedDriveId,
+          });
+
+        return response.value
+          ?.filter(({ folder }) => !folder)
+          .map(({
+            id, name,
+          }) => ({
+            label: name,
+            value: id,
+          })) || [];
+      },
+    },
     excelFileId: {
       type: "string",
       label: "Spreadsheet",
@@ -320,13 +360,15 @@ export default {
             driveId: resolvedDriveId,
           });
         return response.value?.map(({
-          id, name, folder, size,
+          id, name, folder, size, lastModifiedDateTime,
         }) => ({
           value: JSON.stringify({
             id,
             name,
             isFolder: !!folder,
             size,
+            childCount: folder?.childCount,
+            lastModifiedDateTime,
           }),
           label: folder
             ? `📁 ${name}`
@@ -336,12 +378,125 @@ export default {
     },
   },
   methods: {
+    _graphClient: null,
+    /**
+     * Resolves a potentially wrapped labeled value to its actual value.
+     * Pipedream props with withLabel: true wrap values in a special format.
+     *
+     * @param {*} value - The value to resolve (may be wrapped or plain)
+     * @returns {*} The unwrapped value, or the original value if not wrapped
+     * @example
+     * // Wrapped labeled value
+     * resolveWrappedValue({ __lv: { label: "My Site", value: "abc123" } }) // "abc123"
+     *
+     * // Plain value (not wrapped)
+     * resolveWrappedValue("abc123") // "abc123"
+     */
     resolveWrappedValue(value) {
-      return value?.__lv?.value || value;
+      return value?.value || value;
+    },
+    /**
+     * Resolves an array of potentially wrapped labeled values.
+     * Handles both Pipedream's labeled value array format and plain arrays.
+     *
+     * @param {Array|Object} arr
+     *   Array to resolve (may be wrapped or plain)
+     * @returns {Array} Array of unwrapped values
+     * @example
+     * // Wrapped array of labeled values
+     * resolveWrappedArrayValues({
+     *   __lv: [
+     *     { label: "File 1", value: "id1" },
+     *     { label: "File 2", value: "id2" }
+     *   ]
+     * }) // ["id1", "id2"]
+     *
+     * // Plain array
+     * resolveWrappedArrayValues(["id1", "id2"]) // ["id1", "id2"]
+     */
+    resolveWrappedArrayValues(arr) {
+      if (!arr) return [];
+      // Handle __lv wrapped array
+      const unwrapped = arr?.__lv || arr;
+      if (!Array.isArray(unwrapped)) return [];
+      // Extract value from each item if it's a labeled value object
+      return unwrapped.map((item) => item?.value ?? item);
     },
     _getAccessToken() {
       return this.$auth.oauth_access_token;
     },
+    /**
+     * Creates a Microsoft Graph SDK client with caching.
+     * This provides better consistency with other Microsoft components
+     * and includes built-in pagination and type safety.
+     */
+    client() {
+      if (!this._graphClient) {
+        this._graphClient = Client.initWithMiddleware({
+          authProvider: {
+            getAccessToken: () => Promise.resolve(this._getAccessToken()),
+          },
+        });
+      }
+      return this._graphClient;
+    },
+    /**
+     * Makes a request to Microsoft Graph API with automatic retry logic.
+     * Retries on transient errors (5xx, 429) but not on auth/client
+     * errors (4xx).
+     *
+     * @param {Object} options - Request options
+     * @param {string} options.path - API path (e.g., "/sites/{siteId}")
+     * @param {string} [options.method="GET"] - HTTP method
+     * @param {*} [options.content] - Request body for POST/PATCH
+     * @param {number} [options.retries=3] - Number of retry attempts
+     * @returns {Promise<*>} API response
+     */
+    async graphRequest({
+      path, method = "GET", content, retries = 3,
+    }) {
+      return retry(
+        async (bail) => {
+          try {
+            const api = this.client().api(path);
+
+            switch (method.toUpperCase()) {
+            case "GET":
+              return await api.get();
+            case "POST":
+              return await api.post(content);
+            case "PATCH":
+              return await api.patch(content);
+            case "DELETE":
+              return await api.delete();
+            default:
+              throw new Error(`Unsupported HTTP method: ${method}`);
+            }
+          } catch (error) {
+            // Don't retry on auth errors or client errors (4xx except 429)
+            const status = error.statusCode || error.response?.status;
+            if ([
+              400,
+              401,
+              403,
+              404,
+            ].includes(status)) {
+              bail(error); // Throw immediately, don't retry
+              return;
+            }
+            throw error; // Retry on other errors
+          }
+        },
+        {
+          retries,
+          minTimeout: 1000,
+          maxTimeout: 10000,
+          onRetry: (error, attempt) => {
+            console.log(`Retry attempt ${attempt} after error: ${error.message}`);
+          },
+        },
+      );
+    },
     _baseUrl() {
       return "https://graph.microsoft.com/v1.0";
     },
@@ -354,15 +509,52 @@ export default {
     _makeRequest({
       $ = this,
       path,
+      url,
       headers,
       ...args
     }) {
       return axios($, {
-        url: `${this._baseUrl()}${path}`,
+        url: url || `${this._baseUrl()}${path}`,
         headers: this._headers(headers),
         ...args,
       });
     },
+    /**
+     * Makes a request to SharePoint REST API (not Microsoft Graph).
+     * Use this for SharePoint-specific features not available in Graph API,
+     * such as native SharePoint site groups.
+     *
+     * @param {Object} options - Request options
+     * @param {string} options.siteWebUrl - Full site URL (e.g., "https://tenant.sharepoint.com/sites/MySite")
+     * @param {string} options.path - REST API path (e.g., "/web/sitegroups")
+     * @param {Object} [options.headers] - Additional headers
+     * @returns {Promise<Object>} API response
+     * @example
+     * // Get SharePoint site groups
+     * await this._makeSharePointRestRequest({
+     *   siteWebUrl: "https://contoso.sharepoint.com/sites/TeamSite",
+     *   path: "/web/sitegroups"
+     * })
+     */
+    _makeSharePointRestRequest({
+      $ = this,
+      siteWebUrl,
+      path,
+      headers,
+      ...args
+    }) {
+      // SharePoint REST API uses the site's webUrl as base
+      // e.g., https://tenant.sharepoint.com/sites/MySite/_api/web/sitegroups
+      const baseUrl = siteWebUrl.replace(/\/$/, ""); // Remove trailing slash if present
+      return axios($, {
+        url: `${baseUrl}/_api${path}`,
+        headers: this._headers({
+          Accept: "application/json;odata=verbose",
+          ...headers,
+        }),
+        ...args,
+      });
+    },
     getSite({
       siteId, ...args
     }) {
@@ -371,6 +563,52 @@ export default {
         ...args,
       });
     },
+    /**
+     * Lists SharePoint-native site groups using the SharePoint REST API.
+     * These are different from Microsoft 365 Groups and can only be accessed via REST API.
+     *
+     * @param {Object} options - Request options
+     * @param {string} options.siteWebUrl - Full site URL
+     * @returns {Promise<Object>} Response with groups in d.results array
+     * @example
+     * const groups = await this.listSharePointSiteGroups({
+     *   siteWebUrl: "https://contoso.sharepoint.com/sites/TeamSite"
+     * });
+     * // Returns: { d: { results: [{ Id: 5, Title: "Team Site Members" }, ...] } }
+     */
+    listSharePointSiteGroups({
+      siteWebUrl, ...args
+    }) {
+      return this._makeSharePointRestRequest({
+        siteWebUrl,
+        path: "/web/sitegroups",
+        ...args,
+      });
+    },
+    /**
+     * Gets members of a SharePoint-native site group using the SharePoint REST API.
+     * Returns user details including email, display name, and login name.
+     *
+     * @param {Object} options - Request options
+     * @param {string} options.siteWebUrl - Full site URL
+     * @param {number} options.groupId - SharePoint group ID
+     * @returns {Promise<Object>} Response with users in d.results array
+     * @example
+     * const members = await this.getSharePointSiteGroupMembers({
+     *   siteWebUrl: "https://contoso.sharepoint.com/sites/TeamSite",
+     *   groupId: 5
+     * });
+     * // Returns: { d: { results: [{ Email: "user@contoso.com", Title: "John Doe" }, ...] } }
+     */
+    getSharePointSiteGroupMembers({
+      siteWebUrl, groupId, ...args
+    }) {
+      return this._makeSharePointRestRequest({
+        siteWebUrl,
+        path: `/web/sitegroups/getbyid(${groupId})/users`,
+        ...args,
+      });
+    },
     listSites(args = {}) {
       return this._makeRequest({
         path: "/me/followedSites",
@@ -514,6 +752,14 @@ export default {
         ...args,
       });
     },
+    listDriveItemPermissions({
+      driveId, itemId, ...args
+    }) {
+      return this._makeRequest({
+        path: `/drives/${driveId}/items/${itemId}/permissions`,
+        ...args,
+      });
+    },
     searchDriveItems({
       siteId, query, ...args
     }) {
@@ -559,6 +805,62 @@ export default {
         ...args,
       });
     },
+    listGroups(args = {}) {
+      return this._makeRequest({
+        path: "/groups",
+        ...args,
+      });
+    },
+    listUsers(args = {}) {
+      return this._makeRequest({
+        path: "/users",
+        ...args,
+      });
+    },
+    listGroupMembers({
+      groupId, ...args
+    }) {
+      return this._makeRequest({
+        path: `/groups/${groupId}/members`,
+        ...args,
+      });
+    },
+    /**
+     * Get delta changes for a drive using Microsoft Graph delta query.
+     * Enables tracking changes to files and folders over time.
+     *
+     * @param {Object} options - Request options
+     * @param {string} options.driveId - Drive ID to track
+     * @param {string} [options.deltaLink]
+     *   Delta link from previous response (for pagination/continuation)
+     * @returns {Promise<Object>} Response with changed items and
+     *   @odata.deltaLink or @odata.nextLink
+     * @see https://learn.microsoft.com/en-us/graph/api/driveitem-delta
+     * @example
+     * // First call - get initial state
+     * const initial = await this.getDriveDelta({ driveId: "b!..." });
+     * const deltaLink = initial["@odata.deltaLink"];
+     *
+     * // Later - get changes since last call
+     * const changes = await this.getDriveDelta({
+     *   driveId: "b!...", deltaLink
+     * });
+     */
+    getDriveDelta({
+      driveId, deltaLink, ...args
+    }) {
+      // If we have a deltaLink/nextLink, use it as full URL; otherwise build path
+      if (deltaLink) {
+        return this._makeRequest({
+          url: deltaLink,
+          ...args,
+        });
+      }
+      return this._makeRequest({
+        path: `/drives/${driveId}/root/delta`,
+        ...args,
+      });
+    },
     searchQuery(args = {}) {
       return this._makeRequest({
         method: "POST",
@@ -586,5 +888,100 @@ export default {
         nextLink = response["@odata.nextLink"];
       } while (nextLink);
     },
+    /**
+     * Creates a Microsoft Graph subscription for change notifications
+     * (webhooks). Subscriptions expire after a set time and must be
+     * renewed periodically.
+     *
+     * @param {Object} options - Subscription options
+     * @param {string} options.resource
+     *   Resource to monitor (e.g., "drives/{driveId}/root")
+     * @param {string} options.notificationUrl - Webhook endpoint URL
+     * @param {string} [options.changeType="updated"]
+     *   Type of change to monitor (updated, created, deleted)
+     * @param {string} options.clientState
+     *   Secret string for webhook validation
+     * @returns {Promise<Object>}
+     *   Created subscription with id and expirationDateTime
+     * @see https://learn.microsoft.com/en-us/graph/api/subscription-post-subscriptions
+     * @example
+     * const subscription = await this.createSubscription({
+     *   resource: "drives/b!abc123.../root",
+     *   notificationUrl: "https://webhook.site/unique-id",
+     *   changeType: "updated",
+     *   clientState: "secret-validation-token"
+     * });
+     */
+    createSubscription({
+      resource, notificationUrl, changeType = "updated", clientState, ...args
+    }) {
+      const expirationDateTime = new Date(
+        Date.now() + WEBHOOK_SUBSCRIPTION_EXPIRATION_TIME_MILLISECONDS,
+      ).toISOString();
+
+      return this._makeRequest({
+        method: "POST",
+        path: "/subscriptions",
+        data: {
+          changeType,
+          notificationUrl,
+          resource,
+          expirationDateTime,
+          clientState,
+        },
+        ...args,
+      });
+    },
+    /**
+     * Updates a subscription's expiration time (renewal).
+     * Subscriptions must be renewed before they expire to maintain continuous monitoring.
+     *
+     * @param {Object} options - Update options
+     * @param {string} options.subscriptionId - ID of subscription to renew
+     * @returns {Promise<Object>} Updated subscription with new expirationDateTime
+     * @see https://learn.microsoft.com/en-us/graph/api/subscription-update
+     * @example
+     * await this.updateSubscription({
+     *   subscriptionId: "abc123-def456"
+     * });
+     */
+    updateSubscription({
+      subscriptionId, ...args
+    }) {
+      const expirationDateTime = new Date(
+        Date.now() + WEBHOOK_SUBSCRIPTION_EXPIRATION_TIME_MILLISECONDS,
+      ).toISOString();
+
+      return this._makeRequest({
+        method: "PATCH",
+        path: `/subscriptions/${subscriptionId}`,
+        data: {
+          expirationDateTime,
+        },
+        ...args,
+      });
+    },
+    /**
+     * Deletes a subscription. Call this when deactivating a webhook source
+     * to stop receiving notifications and clean up resources.
+     *
+     * @param {Object} options - Delete options
+     * @param {string} options.subscriptionId - ID of subscription to delete
+     * @returns {Promise<void>}
+     * @see https://learn.microsoft.com/en-us/graph/api/subscription-delete
+     * @example
+     * await this.deleteSubscription({
+     *   subscriptionId: "abc123-def456"
+     * });
+     */
+    deleteSubscription({
+      subscriptionId, ...args
+    }) {
+      return this._makeRequest({
+        method: "DELETE",
+        path: `/subscriptions/${subscriptionId}`,
+        ...args,
+      });
+    },
   },
 };

package/sources/new-file-created/new-file-created.mjs

@@ -5,7 +5,7 @@ export default {
   key: "sharepoint-new-file-created",
   name: "New File Created",
   description: "Emit new event when a new file is created in Microsoft Sharepoint.",
-  version: "0.0.4",
+  version: "0.0.5",
   type: "source",
   dedupe: "unique",
   props: {

package/sources/new-folder-created/new-folder-created.mjs

@@ -5,7 +5,7 @@ export default {
   key: "sharepoint-new-folder-created",
   name: "New Folder Created",
   description: "Emit new event when a new folder is created in Microsoft Sharepoint.",
-  version: "0.0.4",
+  version: "0.0.5",
   type: "source",
   dedupe: "unique",
   props: {

package/sources/new-list-item/new-list-item.mjs

@@ -5,7 +5,7 @@ export default {
   key: "sharepoint-new-list-item",
   name: "New List Item",
   description: "Emit new event when a new list item is created in Microsoft Sharepoint.",
-  version: "0.0.9",
+  version: "0.0.10",
   type: "source",
   dedupe: "unique",
   props: {