@memberjunction/storage 3.1.0 → 3.2.0

package/dist/drivers/SharePointFileStorage.js

@@ -107,19 +107,19 @@ class ClientCredentialsAuthProvider {
             client_id: this.clientId,
             scope: 'https://graph.microsoft.com/.default',
             client_secret: this.clientSecret,
-            grant_type: 'client_credentials'
+            grant_type: 'client_credentials',
         });
         const response = await fetch(this.tokenEndpoint, {
             method: 'POST',
             headers: {
-                'Content-Type': 'application/x-www-form-urlencoded'
+                'Content-Type': 'application/x-www-form-urlencoded',
             },
-            body: data
+            body: data,
         });
         if (!response.ok) {
             throw new Error(`Failed to get access token: ${response.statusText}`);
         }
-        const json = await response.json();
+        const json = (await response.json());
         this.accessToken = json.access_token;
         // Set token expiration time (subtract 5 minutes as a buffer)
         const expiresIn = json.expires_in || 3600;
@@ -127,6 +127,121 @@ class ClientCredentialsAuthProvider {
         return this.accessToken;
     }
 }
+/**
+ * Implementation of the Microsoft Graph API AuthenticationProvider interface
+ * that uses the OAuth2 refresh token flow for per-user authentication.
+ *
+ * This provider handles token acquisition using a refresh token, enabling
+ * users to access their own OneDrive/SharePoint files rather than a shared
+ * service account.
+ *
+ * @remarks
+ * This class is designed for scenarios where each user authenticates with
+ * their own Microsoft account via OAuth. The refresh token is obtained
+ * through the OAuth authorization code flow and stored per-user.
+ */
+class RefreshTokenAuthProvider {
+    /**
+     * Azure AD application (client) ID
+     */
+    clientId;
+    /**
+     * Azure AD application client secret
+     */
+    clientSecret;
+    /**
+     * OAuth2 refresh token for obtaining new access tokens
+     */
+    refreshToken;
+    /**
+     * OAuth2 token endpoint URL
+     */
+    tokenEndpoint;
+    /**
+     * Cached access token
+     */
+    accessToken = null;
+    /**
+     * Expiration timestamp for the cached token
+     */
+    tokenExpiration = null;
+    /**
+     * Callback to persist new tokens when they are refreshed
+     */
+    onTokenRefresh;
+    /**
+     * Creates a new RefreshTokenAuthProvider instance
+     *
+     * @param clientId - The Azure AD application (client) ID
+     * @param clientSecret - The Azure AD application client secret
+     * @param refreshToken - The OAuth2 refresh token
+     * @param tenantId - The Azure AD tenant ID (use 'common' for multi-tenant)
+     * @param onTokenRefresh - Optional callback to persist new tokens
+     */
+    constructor(clientId, clientSecret, refreshToken, tenantId = 'common', onTokenRefresh) {
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+        this.refreshToken = refreshToken;
+        this.tokenEndpoint = `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`;
+        this.onTokenRefresh = onTokenRefresh;
+    }
+    /**
+     * Gets an access token for Microsoft Graph API using the refresh token.
+     *
+     * This method implements the AuthenticationProvider interface required by the
+     * Microsoft Graph client. It uses the refresh token to obtain a new access token
+     * when needed, and caches the token until it expires.
+     *
+     * @returns A Promise that resolves to the access token string
+     * @throws Error if token acquisition fails
+     */
+    async getAccessToken() {
+        if (this.accessToken && this.tokenExpiration && this.tokenExpiration > new Date()) {
+            return this.accessToken;
+        }
+        console.log('[SharePoint RefreshTokenAuth] Refreshing access token...');
+        const data = new URLSearchParams({
+            client_id: this.clientId,
+            client_secret: this.clientSecret,
+            refresh_token: this.refreshToken,
+            grant_type: 'refresh_token',
+            scope: 'https://graph.microsoft.com/Files.ReadWrite.All offline_access',
+        });
+        const response = await fetch(this.tokenEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            body: data,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error('[SharePoint RefreshTokenAuth] Token refresh failed:', errorText);
+            throw new Error(`Failed to refresh access token: ${response.statusText}`);
+        }
+        const json = (await response.json());
+        this.accessToken = json.access_token;
+        // Set token expiration time (subtract 5 minutes as a buffer)
+        const expiresIn = json.expires_in || 3600;
+        this.tokenExpiration = new Date(Date.now() + (expiresIn - 300) * 1000);
+        console.log('[SharePoint RefreshTokenAuth] Token refreshed successfully, expires:', this.tokenExpiration);
+        // Microsoft may return a new refresh token - if so, persist it
+        if (json.refresh_token && json.refresh_token !== this.refreshToken) {
+            console.log('[SharePoint RefreshTokenAuth] New refresh token received, persisting...');
+            this.refreshToken = json.refresh_token;
+            if (this.onTokenRefresh) {
+                try {
+                    await this.onTokenRefresh(json.refresh_token, json.access_token);
+                    console.log('[SharePoint RefreshTokenAuth] New tokens persisted successfully');
+                }
+                catch (callbackError) {
+                    console.error('[SharePoint RefreshTokenAuth] Failed to persist new tokens:', callbackError);
+                }
+            }
+        }
+        return this.accessToken;
+    }
+}
 /**
  * FileStorageBase implementation for Microsoft SharePoint using the Microsoft Graph API
  *
@@ -194,38 +309,123 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
      * Optional ID of a subfolder to use as the root folder (if specified)
      */
     _rootFolderId;
+    /**
+     * OAuth2 Client ID (for per-user OAuth flow)
+     */
+    _clientID;
+    /**
+     * OAuth2 Client Secret (for per-user OAuth flow)
+     */
+    _clientSecret;
+    /**
+     * OAuth2 Refresh Token (for per-user OAuth flow)
+     */
+    _refreshToken;
+    /**
+     * Azure AD Tenant ID
+     */
+    _tenantID;
+    /**
+     * Callback for persisting refreshed tokens
+     */
+    _onTokenRefresh;
     /**
      * Creates a new SharePointFileStorage instance
      *
-     * This constructor reads required configuration from environment variables
-     * and initializes the Microsoft Graph client.
-     *
-     * @throws Error if required environment variables are missing
+     * This constructor reads configuration from environment variables if available.
+     * If no environment variables are set, the provider can be initialized later
+     * via the initialize() method with OAuth credentials from the database.
      */
     constructor() {
         super();
         // Try to get config from centralized configuration
         const config = (0, config_1.getProviderConfig)('sharePoint');
-        // Extract values from config, fall back to env vars
-        const clientId = config?.clientID || env.get('STORAGE_SHAREPOINT_CLIENT_ID').required().asString();
-        const clientSecret = config?.clientSecret || env.get('STORAGE_SHAREPOINT_CLIENT_SECRET').required().asString();
-        const tenantId = config?.tenantID || env.get('STORAGE_SHAREPOINT_TENANT_ID').required().asString();
-        this._siteId = config?.siteID || env.get('STORAGE_SHAREPOINT_SITE_ID').required().asString();
-        this._driveId = config?.driveID || env.get('STORAGE_SHAREPOINT_DRIVE_ID').required().asString();
-        // Optionally set a root folder within the SharePoint drive
-        this._rootFolderId = config?.rootFolderID || env.get('STORAGE_SHAREPOINT_ROOT_FOLDER_ID').asString();
-        // Initialize Graph client with auth provider
-        const authProvider = new ClientCredentialsAuthProvider(clientId, clientSecret, tenantId);
-        this._client = microsoft_graph_client_1.Client.initWithMiddleware({
-            authProvider: authProvider
-        });
+        // Extract values from config, fall back to env vars (don't require them - initialize() may be called later)
+        const clientId = config?.clientID || env.get('STORAGE_SHAREPOINT_CLIENT_ID').asString();
+        const clientSecret = config?.clientSecret || env.get('STORAGE_SHAREPOINT_CLIENT_SECRET').asString();
+        const tenantId = config?.tenantID || env.get('STORAGE_SHAREPOINT_TENANT_ID').asString();
+        const siteId = config?.siteID || env.get('STORAGE_SHAREPOINT_SITE_ID').asString();
+        const driveId = config?.driveID || env.get('STORAGE_SHAREPOINT_DRIVE_ID').asString();
+        // Store OAuth credentials for IsConfigured check
+        this._clientID = clientId;
+        this._clientSecret = clientSecret;
+        this._tenantID = tenantId;
+        // Only initialize if we have all required credentials (env/config-based setup)
+        if (clientId && clientSecret && tenantId && siteId && driveId) {
+            this._siteId = siteId;
+            this._driveId = driveId;
+            // Optionally set a root folder within the SharePoint drive
+            this._rootFolderId = config?.rootFolderID || env.get('STORAGE_SHAREPOINT_ROOT_FOLDER_ID').asString();
+            // Initialize Graph client with client credentials auth provider (service account)
+            const authProvider = new ClientCredentialsAuthProvider(clientId, clientSecret, tenantId);
+            this._client = microsoft_graph_client_1.Client.initWithMiddleware({
+                authProvider: authProvider,
+            });
+        }
+        // If credentials not available, initialize() must be called with OAuth config
     }
     /**
      * Checks if SharePoint provider is properly configured.
-     * Returns true if all required Microsoft Graph credentials are present.
+     * Returns true if the Graph client is initialized and has required IDs.
      */
     get IsConfigured() {
-        return !!(this._siteId && this._driveId && this._client);
+        return !!(this._client && this._driveId);
+    }
+    /**
+     * Initializes the SharePoint storage provider with OAuth configuration from the database.
+     * This method is called by the FileStorageProviderEngine when loading per-user provider configurations.
+     *
+     * For per-user OAuth, this sets up the RefreshTokenAuthProvider which uses the user's
+     * refresh token to obtain access tokens for their OneDrive/SharePoint files.
+     *
+     * @param config - Configuration object containing OAuth2 credentials
+     */
+    async initialize(config) {
+        // Always call super to store accountId and accountName
+        await super.initialize(config);
+        if (!config) {
+            return; // Nothing to do, constructor already handled config from env/file
+        }
+        console.log('[SharePoint] Initializing with OAuth config...');
+        // Update OAuth2 credentials
+        this._clientID = config.clientID || this._clientID;
+        this._clientSecret = config.clientSecret || this._clientSecret;
+        this._refreshToken = config.refreshToken || this._refreshToken;
+        this._tenantID = config.tenantID || this._tenantID || 'common';
+        this._onTokenRefresh = config.onTokenRefresh;
+        // Update site/drive IDs if provided
+        if (config.siteID) {
+            this._siteId = config.siteID;
+        }
+        if (config.driveID) {
+            this._driveId = config.driveID;
+        }
+        if (config.rootFolderID) {
+            this._rootFolderId = config.rootFolderID;
+        }
+        // Validate we have required OAuth credentials
+        if (!this._clientID || !this._clientSecret || !this._refreshToken) {
+            throw new Error('SharePoint OAuth requires clientID, clientSecret, and refreshToken');
+        }
+        // Initialize the Graph client with refresh token auth provider (per-user OAuth)
+        const authProvider = new RefreshTokenAuthProvider(this._clientID, this._clientSecret, this._refreshToken, this._tenantID, this._onTokenRefresh);
+        this._client = microsoft_graph_client_1.Client.initWithMiddleware({
+            authProvider: authProvider,
+        });
+        // If no driveID provided, get the user's default OneDrive
+        if (!this._driveId) {
+            console.log("[SharePoint] No driveID provided, getting user's OneDrive...");
+            try {
+                const driveResponse = await this._client.api('/me/drive').get();
+                this._driveId = driveResponse.id;
+                console.log("[SharePoint] Using user's OneDrive:", this._driveId);
+            }
+            catch (error) {
+                console.error("[SharePoint] Failed to get user's OneDrive:", error);
+                throw new Error("Failed to get user's OneDrive. Ensure the refresh token has Files.ReadWrite.All scope.");
+            }
+        }
+        console.log('[SharePoint] Initialized successfully with driveId:', this._driveId);
     }
     /**
      * Gets the SharePoint item ID for a folder at the specified path
@@ -242,11 +442,12 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
         if (!path || path === '/' || path === '') {
             return this._rootFolderId || 'root';
         }
-        const pathParts = path.split('/').filter(p => p);
+        const pathParts = path.split('/').filter((p) => p);
         let currentFolderId = this._rootFolderId || 'root';
         for (let i = 0; i < pathParts.length; i++) {
             const folderName = pathParts[i];
-            const result = await this._client.api(`/drives/${this._driveId}/items/${currentFolderId}/children`)
+            const result = await this._client
+                .api(`/drives/${this._driveId}/items/${currentFolderId}/children`)
                 .filter(`name eq '${folderName}' and folder ne null`)
                 .get();
             if (!result.value || result.value.length === 0) {
@@ -276,9 +477,7 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
         const normalizedPath = path.startsWith('/') ? path.substring(1) : path;
         try {
             // Try to get the item directly by path
-            const driveRoot = this._rootFolderId ?
-                `/drives/${this._driveId}/items/${this._rootFolderId}` :
-                `/drives/${this._driveId}/root`;
+            const driveRoot = this._rootFolderId ? `/drives/${this._driveId}/items/${this._rootFolderId}` : `/drives/${this._driveId}/root`;
             return await this._client.api(`${driveRoot}:/${normalizedPath}`).get();
         }
         catch (error) {
@@ -317,7 +516,7 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
             lastModified: new Date(item.lastModifiedDateTime),
             isDirectory,
             etag: item.eTag,
-            customMetadata: {}
+            customMetadata: {},
         };
     }
     /**
@@ -372,11 +571,10 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
         try {
             const item = await this._getItemByPath(objectName);
             // Request a download URL - this is a time-limited URL
-            const downloadUrl = await this._client.api(`/drives/${this._driveId}/items/${item.id}/createLink`)
-                .post({
+            const downloadUrl = await this._client.api(`/drives/${this._driveId}/items/${item.id}/createLink`).post({
                 type: 'view',
                 scope: 'anonymous',
-                expirationDateTime: new Date(Date.now() + 10 * 60 * 1000).toISOString() // 10 minutes
+                expirationDateTime: new Date(Date.now() + 10 * 60 * 1000).toISOString(), // 10 minutes
             });
             return downloadUrl.link.webUrl;
         }
@@ -421,12 +619,11 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
             // Get the new parent folder ID
             const parentFolderId = await this._getParentFolderIdByPath(newParentPath);
             // Move the item
-            await this._client.api(`/drives/${this._driveId}/items/${item.id}`)
-                .update({
+            await this._client.api(`/drives/${this._driveId}/items/${item.id}`).update({
                 name: newName,
                 parentReference: {
-                    id: parentFolderId
-                }
+                    id: parentFolderId,
+                },
             });
             return true;
         }
@@ -465,8 +662,7 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
         try {
             const item = await this._getItemByPath(objectName);
             // Delete the item
-            await this._client.api(`/drives/${this._driveId}/items/${item.id}`)
-                .delete();
+            await this._client.api(`/drives/${this._driveId}/items/${item.id}`).delete();
             return true;
         }
         catch (error) {
@@ -520,9 +716,7 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
             for (const item of children.value) {
                 if (item.folder) {
                     // This is a folder/directory
-                    const folderPath = prefix ?
-                        (prefix.endsWith('/') ? `${prefix}${item.name}` : `${prefix}/${item.name}`) :
-                        item.name;
+                    const folderPath = prefix ? (prefix.endsWith('/') ? `${prefix}${item.name}` : `${prefix}/${item.name}`) : item.name;
                     prefixes.push(`${folderPath}/`);
                 }
                 // Add all items as objects (including folders)
@@ -571,9 +765,7 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
     async CreateDirectory(directoryPath) {
         try {
             // Remove trailing slash if present
-            const normalizedPath = directoryPath.endsWith('/') ?
-                directoryPath.substring(0, directoryPath.length - 1) :
-                directoryPath;
+            const normalizedPath = directoryPath.endsWith('/') ? directoryPath.substring(0, directoryPath.length - 1) : directoryPath;
             // Parse the path to get the parent folder and new folder name
             const pathParts = normalizedPath.split('/');
             const folderName = pathParts.pop() || '';
@@ -581,11 +773,10 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
             // Get the parent folder ID
             const parentFolderId = await this._getParentFolderIdByPath(parentPath);
             // Create the folder
-            await this._client.api(`/drives/${this._driveId}/items/${parentFolderId}/children`)
-                .post({
+            await this._client.api(`/drives/${this._driveId}/items/${parentFolderId}/children`).post({
                 name: folderName,
                 folder: {},
-                '@microsoft.graph.conflictBehavior': 'fail'
+                '@microsoft.graph.conflictBehavior': 'fail',
             });
             return true;
         }
@@ -627,9 +818,7 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
     async DeleteDirectory(directoryPath, recursive = false) {
         try {
             // Remove trailing slash if present
-            const normalizedPath = directoryPath.endsWith('/') ?
-                directoryPath.substring(0, directoryPath.length - 1) :
-                directoryPath;
+            const normalizedPath = directoryPath.endsWith('/') ? directoryPath.substring(0, directoryPath.length - 1) : directoryPath;
             const folder = await this._getItemByPath(normalizedPath);
             if (!recursive) {
                 // Check if folder is empty
@@ -639,8 +828,7 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
                 }
             }
             // Delete the folder (SharePoint will delete recursively by default)
-            await this._client.api(`/drives/${this._driveId}/items/${folder.id}`)
-                .delete();
+            await this._client.api(`/drives/${this._driveId}/items/${folder.id}`).delete();
             return true;
         }
         catch (error) {
@@ -821,17 +1009,15 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
             const effectiveContentType = contentType || mime.lookup(objectName) || 'application/octet-stream';
             if (data.length < 4 * 1024 * 1024) {
                 // For small files (< 4MB), use simple upload
-                await this._client.api(`/drives/${this._driveId}/items/${parentFolderId}:/${fileName}:/content`)
-                    .put(data);
+                await this._client.api(`/drives/${this._driveId}/items/${parentFolderId}:/${fileName}:/content`).put(data);
             }
             else {
                 // For larger files, use upload session
                 // Create upload session
-                const uploadSession = await this._client.api(`/drives/${this._driveId}/items/${parentFolderId}:/${fileName}:/createUploadSession`)
-                    .post({
+                const uploadSession = await this._client.api(`/drives/${this._driveId}/items/${parentFolderId}:/${fileName}:/createUploadSession`).post({
                     item: {
-                        '@microsoft.graph.conflictBehavior': 'replace'
-                    }
+                        '@microsoft.graph.conflictBehavior': 'replace',
+                    },
                 });
                 // Upload the file in chunks (could be improved with parallel uploads)
                 const maxChunkSize = 60 * 1024 * 1024; // 60 MB chunks
@@ -842,9 +1028,9 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
                         method: 'PUT',
                         headers: {
                             'Content-Length': chunk.length.toString(),
-                            'Content-Range': contentRange
+                            'Content-Range': contentRange,
                         },
-                        body: chunk
+                        body: chunk,
                     });
                 }
             }
@@ -896,12 +1082,11 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
             // Get destination parent folder ID
             const destParentId = await this._getParentFolderIdByPath(destParentPath);
             // Create a copy
-            await this._client.api(`/drives/${this._driveId}/items/${sourceItem.id}/copy`)
-                .post({
+            await this._client.api(`/drives/${this._driveId}/items/${sourceItem.id}/copy`).post({
                 parentReference: {
-                    id: destParentId
+                    id: destParentId,
                 },
-                name: destName
+                name: destName,
             });
             return true;
         }
@@ -975,9 +1160,7 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
     async DirectoryExists(directoryPath) {
         try {
             // Remove trailing slash if present
-            const normalizedPath = directoryPath.endsWith('/') ?
-                directoryPath.substring(0, directoryPath.length - 1) :
-                directoryPath;
+            const normalizedPath = directoryPath.endsWith('/') ? directoryPath.substring(0, directoryPath.length - 1) : directoryPath;
             const item = await this._getItemByPath(normalizedPath);
             return !!item.folder;
         }
@@ -1061,26 +1244,16 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
                     {
                         entityTypes: ['driveItem'],
                         query: {
-                            queryString: kqlQuery
+                            queryString: kqlQuery,
                         },
                         from: 0,
                         size: maxResults,
-                        fields: [
-                            'name',
-                            'path',
-                            'size',
-                            'lastModifiedDateTime',
-                            'fileSystemInfo',
-                            'webUrl',
-                            'id',
-                            'contentType'
-                        ]
-                    }
-                ]
+                        fields: ['name', 'path', 'size', 'lastModifiedDateTime', 'fileSystemInfo', 'webUrl', 'id', 'contentType'],
+                    },
+                ],
             };
             // Execute the search
-            const response = await this._client.api('/search/query')
-                .post(searchRequest);
+            const response = await this._client.api('/search/query').post(searchRequest);
             // Transform results
             return this.transformSearchResults(response, maxResults);
         }
@@ -1112,14 +1285,13 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
         queryParts.push(`(Path:"${this._siteId}/${this._driveId}")`);
         // Add path prefix filter if specified
         if (options?.pathPrefix) {
-            const normalizedPrefix = options.pathPrefix.startsWith('/')
-                ? options.pathPrefix.substring(1)
-                : options.pathPrefix;
+            const normalizedPrefix = options.pathPrefix.startsWith('/') ? options.pathPrefix.substring(1) : options.pathPrefix;
             queryParts.push(`(Path:"${this._siteId}/${this._driveId}/${normalizedPrefix}*")`);
         }
         // Add file type filters if specified
         if (options?.fileTypes && options.fileTypes.length > 0) {
-            const fileTypeFilters = options.fileTypes.map(fileType => {
+            const fileTypeFilters = options.fileTypes
+                .map((fileType) => {
                 // Handle both extensions (pdf) and MIME types (application/pdf)
                 if (fileType.includes('/')) {
                     // It's a MIME type
@@ -1130,7 +1302,8 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
                     const extension = fileType.startsWith('.') ? fileType.substring(1) : fileType;
                     return `FileType:${extension}`;
                 }
-            }).join(' OR ');
+            })
+                .join(' OR ');
             queryParts.push(`(${fileTypeFilters})`);
         }
         // Add date filters if specified
@@ -1187,19 +1360,17 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
                             name: resource.name || '',
                             size: resource.size || 0,
                             contentType: resource.file?.mimeType || mime.lookup(resource.name) || 'application/octet-stream',
-                            lastModified: resource.lastModifiedDateTime
-                                ? new Date(resource.lastModifiedDateTime)
-                                : new Date(),
+                            lastModified: resource.lastModifiedDateTime ? new Date(resource.lastModifiedDateTime) : new Date(),
                             objectId: resource.id || '', // SharePoint item ID for direct access
-                            relevance: hit.rank ? (hit.rank / 100.0) : undefined,
+                            relevance: hit.rank ? hit.rank / 100.0 : undefined,
                             excerpt: hit.summary || undefined,
                             matchInFilename: this.determineMatchLocation(hit),
                             providerData: {
                                 id: resource.id,
                                 webUrl: resource.webUrl,
                                 driveId: this._driveId,
-                                siteId: this._siteId
-                            }
+                                siteId: this._siteId,
+                            },
                         };
                         results.push(result);
                     }
@@ -1209,7 +1380,7 @@ let SharePointFileStorage = class SharePointFileStorage extends FileStorageBase_
         return {
             results,
             totalMatches,
-            hasMore
+            hasMore,
         };
     }
     /**