@memberjunction/storage 3.1.0 → 3.2.0

package/dist/util.js

@@ -3,10 +3,193 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteObject = exports.moveObject = exports.createDownloadUrl = exports.createUploadUrl = void 0;
+exports.searchAcrossAccounts = exports.searchAcrossProviders = exports.copyObjectBetweenProviders = exports.listObjects = exports.deleteObject = exports.copyObject = exports.moveObject = exports.createDownloadUrl = exports.createUploadUrl = exports.initializeDriverWithAccountCredentials = exports.initializeDriverWithUserCredentials = void 0;
 const global_1 = require("@memberjunction/global");
+const core_1 = require("@memberjunction/core");
+const credentials_1 = require("@memberjunction/credentials");
 const mime_types_1 = __importDefault(require("mime-types"));
 const FileStorageBase_1 = require("./generic/FileStorageBase");
+/**
+ * @deprecated This function is being replaced by the enterprise file storage model.
+ * Use FileStorageAccount with Credential Engine instead.
+ *
+ * Initializes a storage driver with user-specific OAuth credentials.
+ * NOTE: This function currently only supports non-OAuth providers.
+ * OAuth provider support will be added via the Credential Engine integration.
+ *
+ * @param options - Configuration options including provider, user ID, and context
+ * @returns A promise resolving to an initialized FileStorageBase driver
+ * @throws Error if the provider requires OAuth (not yet supported in enterprise model)
+ */
+async function initializeDriverWithUserCredentials(options) {
+    const { providerEntity } = options;
+    // Create the driver instance
+    const driver = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(FileStorageBase_1.FileStorageBase, providerEntity.ServerDriverKey);
+    // Check if this provider requires OAuth authentication
+    if (providerEntity.RequiresOAuth) {
+        // TODO: Implement Credential Engine integration for OAuth providers
+        // This will load credentials from FileStorageAccount -> Credential
+        throw new Error(`Provider "${providerEntity.Name}" requires OAuth authentication. ` + `Enterprise OAuth support via Credential Engine is not yet implemented.`);
+    }
+    else {
+        // Provider doesn't require OAuth - use admin/global configuration
+        const configJson = providerEntity.Configuration;
+        if (configJson) {
+            const config = JSON.parse(configJson);
+            await driver.initialize(config);
+            console.log(`[initializeDriverWithUserCredentials] Initialized ${providerEntity.Name} with admin configuration`);
+        }
+    }
+    return driver;
+}
+exports.initializeDriverWithUserCredentials = initializeDriverWithUserCredentials;
+/**
+ * Initializes a storage driver using account-based credentials from the Credential Engine.
+ * This is the enterprise model where credentials are stored in the Credential entity
+ * and decrypted at runtime.
+ *
+ * For providers that issue new refresh tokens on each token refresh (like Box.com),
+ * this function automatically configures a callback to persist the new tokens back
+ * to the Credential entity in the database.
+ *
+ * @param options - Configuration options including account, provider, and context user
+ * @returns A promise resolving to an initialized FileStorageBase driver
+ *
+ * @example
+ * ```typescript
+ * const driver = await initializeDriverWithAccountCredentials({
+ *   accountEntity,
+ *   providerEntity,
+ *   contextUser
+ * });
+ *
+ * // Driver is now ready to use
+ * const objects = await driver.ListObjects('/');
+ * ```
+ */
+async function initializeDriverWithAccountCredentials(options) {
+    const { accountEntity, providerEntity, contextUser } = options;
+    // Create the driver instance using the provider's driver key
+    const driver = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(FileStorageBase_1.FileStorageBase, providerEntity.ServerDriverKey);
+    if (!driver) {
+        throw new Error(`Failed to create storage driver for provider "${providerEntity.Name}" ` + `with driver key "${providerEntity.ServerDriverKey}"`);
+    }
+    // Build the base config with account information (required in enterprise model)
+    const baseConfig = {
+        accountId: accountEntity.ID,
+        accountName: accountEntity.Name,
+    };
+    // Check if the account has a credential configured
+    if (accountEntity.CredentialID) {
+        // Initialize the Credential Engine if not already done
+        await credentials_1.CredentialEngine.Instance.Config(false, contextUser);
+        // Get the credential by ID and decrypt it
+        const credentialEntity = credentials_1.CredentialEngine.Instance.getCredentialById(accountEntity.CredentialID);
+        if (!credentialEntity) {
+            throw new Error(`Credential with ID ${accountEntity.CredentialID} not found for account "${accountEntity.Name}"`);
+        }
+        // Resolve the credential to get decrypted values
+        const resolved = await credentials_1.CredentialEngine.Instance.getCredential(credentialEntity.Name, {
+            credentialId: accountEntity.CredentialID,
+            contextUser,
+            subsystem: 'FileStorage',
+        });
+        (0, core_1.LogStatus)(`[initializeDriverWithAccountCredentials] Decrypted credential "${credentialEntity.Name}" for account "${accountEntity.Name}"`);
+        // Create a token refresh callback to persist new tokens back to the database
+        // This is critical for providers like Box.com that issue new refresh tokens on each refresh
+        const onTokenRefresh = async (newRefreshToken, newAccessToken) => {
+            try {
+                (0, core_1.LogStatus)(`[initializeDriverWithAccountCredentials] Token refresh callback invoked for account "${accountEntity.Name}"`);
+                // Get the current credential values and update with new tokens
+                const updatedValues = { ...resolved.values };
+                updatedValues.refreshToken = newRefreshToken;
+                if (newAccessToken) {
+                    updatedValues.accessToken = newAccessToken;
+                }
+                // Update the credential in the database using the Credential Engine
+                await credentials_1.CredentialEngine.Instance.updateCredential(accountEntity.CredentialID, updatedValues, contextUser);
+                (0, core_1.LogStatus)(`[initializeDriverWithAccountCredentials] Successfully persisted new tokens for account "${accountEntity.Name}"`);
+            }
+            catch (error) {
+                // Log the error but don't throw - the driver still has the tokens in memory
+                // and can continue operating. However, the next server restart will fail.
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.error(`[initializeDriverWithAccountCredentials] Failed to persist new tokens for account "${accountEntity.Name}": ${errorMessage}`);
+                console.error(`[initializeDriverWithAccountCredentials] WARNING: Authentication may fail after server restart!`);
+            }
+        };
+        // Add the token refresh callback to the config
+        baseConfig.onTokenRefresh = onTokenRefresh;
+        // Initialize the driver with account info + decrypted credential values + token refresh callback
+        await driver.initialize({
+            ...baseConfig,
+            ...resolved.values,
+        });
+    }
+    else {
+        // No credential configured - fall back to provider's static configuration
+        const configJson = providerEntity.Configuration;
+        if (configJson) {
+            const config = JSON.parse(configJson);
+            // Merge account info with provider configuration
+            await driver.initialize({
+                ...baseConfig,
+                ...config,
+            });
+            (0, core_1.LogStatus)(`[initializeDriverWithAccountCredentials] Initialized "${accountEntity.Name}" with provider configuration (no credential)`);
+        }
+        else {
+            // Initialize with just account info (driver may use env vars or other config)
+            await driver.initialize(baseConfig);
+            (0, core_1.LogStatus)(`[initializeDriverWithAccountCredentials] Warning: No credential or configuration for account "${accountEntity.Name}"`);
+        }
+    }
+    return driver;
+}
+exports.initializeDriverWithAccountCredentials = initializeDriverWithAccountCredentials;
+/**
+ * Internal helper to initialize a storage driver with appropriate credentials.
+ *
+ * Supports two modes:
+ * 1. Enterprise model (preferred): When accountEntity is provided in userContext,
+ *    uses the Credential Engine to decrypt credentials from the account's CredentialID.
+ * 2. Legacy model: Uses provider configuration or throws for OAuth providers.
+ *
+ * @param providerEntity - The file storage provider entity
+ * @param userContext - Optional user context, may include accountEntity for enterprise model
+ * @returns An initialized FileStorageBase driver
+ */
+async function initializeDriver(providerEntity, userContext) {
+    // Enterprise model: Use account-based credentials if accountEntity is provided
+    if (userContext?.accountEntity) {
+        return initializeDriverWithAccountCredentials({
+            accountEntity: userContext.accountEntity,
+            providerEntity,
+            contextUser: userContext.contextUser,
+        });
+    }
+    // Legacy model: Use the deprecated user credentials approach
+    if (userContext) {
+        return initializeDriverWithUserCredentials({
+            providerEntity,
+            userID: userContext.userID,
+            contextUser: userContext.contextUser,
+        });
+    }
+    // No user context - use admin/legacy initialization
+    const driver = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(FileStorageBase_1.FileStorageBase, providerEntity.ServerDriverKey);
+    // Check if this provider requires OAuth but no user context was provided
+    if (providerEntity.RequiresOAuth) {
+        throw new Error(`Provider "${providerEntity.Name}" requires OAuth authentication. ` + `Please provide userContext parameter with userID and contextUser.`);
+    }
+    // Initialize with admin configuration
+    const configJson = providerEntity.Get('Configuration');
+    if (configJson) {
+        const config = JSON.parse(configJson);
+        await driver.initialize(config);
+    }
+    return driver;
+}
 /**
  * Creates a pre-authenticated upload URL for a file in the specified file storage provider.
  *
@@ -27,6 +210,7 @@ const FileStorageBase_1 = require("./generic/FileStorageBase");
  *               - ProviderID: The ID of the storage provider to use
  *               - ContentType: (Optional) The MIME type of the file
  *               - ProviderKey: (Optional) Provider-specific key for the file
+ * @param userContext - Optional user context for OAuth providers (required if provider.RequiresOAuth is true)
  * @returns A promise that resolves to an object containing:
  *         - updatedInput: The input object with additional metadata (Status, ContentType, and possibly ProviderKey)
  *         - UploadUrl: The pre-authenticated URL for uploading the file
@@ -41,7 +225,8 @@ const FileStorageBase_1 = require("./generic/FileStorageBase");
  *     ID: '123',
  *     Name: 'report.pdf',
  *     ProviderID: fileStorageProvider.ID
- *   }
+ *   },
+ *   { userID: currentUser.ID, contextUser } // Required for OAuth providers
  * );
  *
  * // The content type is automatically determined from the file extension
@@ -54,12 +239,13 @@ const FileStorageBase_1 = require("./generic/FileStorageBase");
  * console.log(result.UploadUrl);
  * ```
  */
-const createUploadUrl = async (providerEntity, input) => {
+const createUploadUrl = async (providerEntity, input, userContext) => {
     const { Name, ProviderID } = input;
     const ContentType = input.ContentType ?? mime_types_1.default.lookup(input.Name) ?? 'application/octet-stream';
     const Status = 'Uploading';
     await providerEntity.Load(ProviderID);
-    const driver = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(FileStorageBase_1.FileStorageBase, providerEntity.ServerDriverKey);
+    // Initialize driver with user credentials if available, otherwise use admin config
+    const driver = await initializeDriver(providerEntity, userContext);
     const { UploadUrl, ...maybeProviderKey } = await driver.CreatePreAuthUploadUrl(Name);
     const updatedInput = { ...input, ...maybeProviderKey, ContentType, Status };
     return { updatedInput, UploadUrl };
@@ -76,6 +262,7 @@ exports.createUploadUrl = createUploadUrl;
  * @param providerEntity - The file storage provider entity containing connection details
  * @param providerKeyOrName - The provider key or name of the file to download
  *                           (use the ProviderKey if it was returned during upload, otherwise use the file Name)
+ * @param userContext - Optional user context for OAuth providers (required if provider.RequiresOAuth is true)
  * @returns A promise that resolves to the pre-authenticated download URL as a string
  *
  * @example
@@ -84,17 +271,17 @@ exports.createUploadUrl = createUploadUrl;
  * const fileStorageProvider = await entityMgr.FindById('FileStorageProvider', 'azure-main');
  *
  * // Using the file name
- * const downloadUrl = await createDownloadUrl(fileStorageProvider, 'reports/annual-report.pdf');
+ * const downloadUrl = await createDownloadUrl(fileStorageProvider, 'reports/annual-report.pdf', userContext);
  *
  * // Or using the provider key if returned during upload
- * const downloadUrl = await createDownloadUrl(fileStorageProvider, file.ProviderKey);
+ * const downloadUrl = await createDownloadUrl(fileStorageProvider, file.ProviderKey, userContext);
  *
  * // The download URL can be provided to clients for direct download
  * console.log(downloadUrl);
  * ```
  */
-const createDownloadUrl = async (providerEntity, providerKeyOrName) => {
-    const driver = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(FileStorageBase_1.FileStorageBase, providerEntity.ServerDriverKey);
+const createDownloadUrl = async (providerEntity, providerKeyOrName, userContext) => {
+    const driver = await initializeDriver(providerEntity, userContext);
     return driver.CreatePreAuthDownloadUrl(providerKeyOrName);
 };
 exports.createDownloadUrl = createDownloadUrl;
@@ -109,6 +296,7 @@ exports.createDownloadUrl = createDownloadUrl;
  * @param oldProviderKeyOrName - The key or name of the object's current location
  *                              (use the ProviderKey if it was returned during upload, otherwise use the file Name)
  * @param newProviderKeyOrName - The key or name for the object's new location
+ * @param userContext - Optional user context for OAuth providers (required if provider.RequiresOAuth is true)
  * @returns A promise that resolves to a boolean indicating whether the move operation was successful
  *
  * @example
@@ -120,7 +308,8 @@ exports.createDownloadUrl = createDownloadUrl;
  * const success = await moveObject(
  *   fileStorageProvider,
  *   'drafts/report.docx',
- *   'published/final-report.docx'
+ *   'published/final-report.docx',
+ *   userContext
  * );
  *
  * if (success) {
@@ -130,11 +319,46 @@ exports.createDownloadUrl = createDownloadUrl;
  * }
  * ```
  */
-const moveObject = async (providerEntity, oldProviderKeyOrName, newProviderKeyOrName) => {
-    const driver = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(FileStorageBase_1.FileStorageBase, providerEntity.ServerDriverKey);
+const moveObject = async (providerEntity, oldProviderKeyOrName, newProviderKeyOrName, userContext) => {
+    const driver = await initializeDriver(providerEntity, userContext);
     return driver.MoveObject(oldProviderKeyOrName, newProviderKeyOrName);
 };
 exports.moveObject = moveObject;
+/**
+ * Copies an object from one location to another within the specified file storage provider.
+ *
+ * This utility function handles copying files by instantiating the appropriate storage
+ * provider driver and delegating to its CopyObject method. It can be used to duplicate files
+ * within the same storage provider, either in the same folder with a different name or to
+ * a different folder.
+ *
+ * @param providerEntity - The file storage provider entity containing connection details
+ * @param sourceProviderKeyOrName - The key or name of the source file to copy
+ * @param destinationProviderKeyOrName - The key or name for the destination copy
+ * @param userContext - Optional user context for OAuth providers (required if provider.RequiresOAuth is true)
+ * @returns A promise that resolves to a boolean indicating whether the copy was successful
+ *
+ * @example
+ * ```typescript
+ * const success = await copyObject(
+ *   providerEntity,
+ *   'documents/report.pdf',
+ *   'documents/archive/report-2024.pdf',
+ *   userContext
+ * );
+ *
+ * if (success) {
+ *   console.log('File successfully copied');
+ * } else {
+ *   console.log('Failed to copy file');
+ * }
+ * ```
+ */
+const copyObject = async (providerEntity, sourceProviderKeyOrName, destinationProviderKeyOrName, userContext) => {
+    const driver = await initializeDriver(providerEntity, userContext);
+    return driver.CopyObject(sourceProviderKeyOrName, destinationProviderKeyOrName);
+};
+exports.copyObject = copyObject;
 /**
  * Deletes a file from the specified file storage provider.
  *
@@ -145,6 +369,7 @@ exports.moveObject = moveObject;
  * @param providerEntity - The file storage provider entity containing connection details
  * @param providerKeyOrName - The key or name of the file to delete
  *                           (use the ProviderKey if it was returned during upload, otherwise use the file Name)
+ * @param userContext - Optional user context for OAuth providers (required if provider.RequiresOAuth is true)
  * @returns A promise that resolves to a boolean indicating whether the deletion was successful
  *
  * @example
@@ -153,10 +378,10 @@ exports.moveObject = moveObject;
  * const fileStorageProvider = await entityMgr.FindById('FileStorageProvider', 'azure-main');
  *
  * // Delete using the file name
- * const deleted = await deleteObject(fileStorageProvider, 'temp/obsolete-document.pdf');
+ * const deleted = await deleteObject(fileStorageProvider, 'temp/obsolete-document.pdf', userContext);
  *
  * // Or using the provider key if returned during upload
- * const deleted = await deleteObject(fileStorageProvider, file.ProviderKey);
+ * const deleted = await deleteObject(fileStorageProvider, file.ProviderKey, userContext);
  *
  * if (deleted) {
  *   console.log('File successfully deleted');
@@ -165,9 +390,445 @@ exports.moveObject = moveObject;
  * }
  * ```
  */
-const deleteObject = (providerEntity, providerKeyOrName) => {
-    const driver = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(FileStorageBase_1.FileStorageBase, providerEntity.ServerDriverKey);
-    return driver.DeleteObject(providerKeyOrName);
+const deleteObject = async (providerEntity, providerKeyOrName, userContext) => {
+    console.log('[deleteObject] Called with:', {
+        providerName: providerEntity.Name,
+        providerID: providerEntity.ID,
+        serverDriverKey: providerEntity.ServerDriverKey,
+        providerKeyOrName,
+    });
+    const driver = await initializeDriver(providerEntity, userContext);
+    console.log('[deleteObject] Driver initialized:', {
+        driverType: driver.constructor.name,
+        hasDeleteMethod: typeof driver.DeleteObject === 'function',
+    });
+    console.log('[deleteObject] Calling driver.DeleteObject...');
+    const result = await driver.DeleteObject(providerKeyOrName);
+    console.log('[deleteObject] Result:', result);
+    return result;
 };
 exports.deleteObject = deleteObject;
+/**
+ * Lists objects (files) and prefixes (directories) in a storage provider at the specified path.
+ *
+ * This utility function provides access to the storage provider's file and folder listing
+ * functionality. It returns both files and directories found at the specified path prefix,
+ * allowing for hierarchical navigation through the storage provider's contents.
+ *
+ * @param providerEntity - The file storage provider entity containing connection details
+ * @param prefix - The path prefix to list objects from (e.g., "/" for root, "documents/" for a specific folder)
+ * @param delimiter - The character used to group keys into a hierarchy (defaults to "/")
+ * @param userContext - Optional user context for OAuth providers (required if provider.RequiresOAuth is true)
+ * @returns A promise that resolves to a StorageListResult containing:
+ *          - objects: Array of file metadata (name, size, contentType, lastModified, etc.)
+ *          - prefixes: Array of directory/folder path strings
+ *
+ * @example
+ * ```typescript
+ * // List contents of the root directory
+ * const fileStorageProvider = await entityMgr.FindById('FileStorageProvider', 'aws-s3-main');
+ * const result = await listObjects(fileStorageProvider, '/', '/', userContext);
+ *
+ * // Display files
+ * for (const file of result.objects) {
+ *   console.log(`File: ${file.name} (${file.size} bytes)`);
+ * }
+ *
+ * // Display folders
+ * for (const folder of result.prefixes) {
+ *   console.log(`Folder: ${folder}`);
+ * }
+ *
+ * // List contents of a specific folder
+ * const docsResult = await listObjects(fileStorageProvider, 'documents/', '/', userContext);
+ * ```
+ */
+const listObjects = async (providerEntity, prefix, delimiter = '/', userContext) => {
+    console.log('[listObjects] Starting with:', {
+        providerName: providerEntity.Name,
+        serverDriverKey: providerEntity.ServerDriverKey,
+        prefix,
+        delimiter,
+        hasUserContext: !!userContext,
+    });
+    const driver = await initializeDriver(providerEntity, userContext);
+    console.log('[listObjects] Driver initialized:', {
+        driverType: driver.constructor.name,
+        isConfigured: driver.IsConfigured,
+    });
+    const result = await driver.ListObjects(prefix, delimiter);
+    console.log('[listObjects] Result:', {
+        objectsCount: result.objects.length,
+        prefixesCount: result.prefixes.length,
+    });
+    return result;
+};
+exports.listObjects = listObjects;
+/**
+ * Copies a file from one storage provider to another.
+ *
+ * This utility function enables transferring files between different storage providers
+ * (e.g., from Dropbox to Google Drive, or from S3 to Azure). The transfer happens
+ * server-side, so the file data flows: Source Provider → Server → Destination Provider.
+ *
+ * @param sourceProviderEntity - The source file storage provider entity
+ * @param destinationProviderEntity - The destination file storage provider entity
+ * @param sourcePath - The path to the file in the source provider
+ * @param destinationPath - The path where the file should be saved in the destination provider
+ * @param options - Optional user context for OAuth providers
+ * @returns A promise that resolves to a CopyBetweenProvidersResult
+ *
+ * @example
+ * ```typescript
+ * // Copy a file from Dropbox to Google Drive
+ * const sourceProvider = await entityMgr.FindById('FileStorageProvider', 'dropbox-id');
+ * const destProvider = await entityMgr.FindById('FileStorageProvider', 'gdrive-id');
+ *
+ * const result = await copyObjectBetweenProviders(
+ *   sourceProvider,
+ *   destProvider,
+ *   'documents/report.pdf',
+ *   'imported/report.pdf',
+ *   {
+ *     sourceUserContext: { userID: currentUser.ID, contextUser },
+ *     destinationUserContext: { userID: currentUser.ID, contextUser }
+ *   }
+ * );
+ *
+ * if (result.success) {
+ *   console.log(`Transferred ${result.bytesTransferred} bytes`);
+ * }
+ * ```
+ */
+const copyObjectBetweenProviders = async (sourceProviderEntity, destinationProviderEntity, sourcePath, destinationPath, options) => {
+    console.log('[copyObjectBetweenProviders] Starting transfer:', {
+        sourceProvider: sourceProviderEntity.Name,
+        destinationProvider: destinationProviderEntity.Name,
+        sourcePath,
+        destinationPath,
+    });
+    const result = {
+        success: false,
+        message: '',
+        sourceProvider: sourceProviderEntity.Name,
+        destinationProvider: destinationProviderEntity.Name,
+        sourcePath,
+        destinationPath,
+    };
+    try {
+        // Initialize source driver with user credentials if available
+        const sourceDriver = await initializeDriver(sourceProviderEntity, options?.sourceUserContext);
+        // Initialize destination driver with user credentials if available
+        const destDriver = await initializeDriver(destinationProviderEntity, options?.destinationUserContext);
+        console.log('[copyObjectBetweenProviders] Drivers initialized, fetching file from source...');
+        // Normalize source path: remove leading/trailing slashes and collapse multiple slashes
+        // This ensures consistent path handling across different storage providers
+        const normalizedSourcePath = sourcePath.replace(/^\/+|\/+$/g, '').replace(/\/+/g, '/');
+        console.log('[copyObjectBetweenProviders] Path normalization:', {
+            original: sourcePath,
+            normalized: normalizedSourcePath,
+        });
+        // Get the file from source provider
+        const fileData = await sourceDriver.GetObject({ fullPath: normalizedSourcePath });
+        if (!fileData || fileData.length === 0) {
+            result.message = `Failed to retrieve file from source: ${normalizedSourcePath}`;
+            console.error('[copyObjectBetweenProviders]', result.message);
+            return result;
+        }
+        console.log('[copyObjectBetweenProviders] File retrieved, size:', fileData.length, 'bytes');
+        // Get metadata for content type
+        let contentType = 'application/octet-stream';
+        try {
+            const metadata = await sourceDriver.GetObjectMetadata({ fullPath: normalizedSourcePath });
+            if (metadata.contentType) {
+                contentType = metadata.contentType;
+            }
+        }
+        catch {
+            // Use mime-types to guess content type from filename
+            const mimeType = mime_types_1.default.lookup(sourcePath);
+            if (mimeType) {
+                contentType = mimeType;
+            }
+        }
+        console.log('[copyObjectBetweenProviders] Uploading to destination with contentType:', contentType);
+        // Upload to destination provider
+        const uploadSuccess = await destDriver.PutObject(destinationPath, fileData, contentType);
+        if (uploadSuccess) {
+            result.success = true;
+            result.bytesTransferred = fileData.length;
+            result.message = `Successfully copied ${fileData.length} bytes from ${sourceProviderEntity.Name} to ${destinationProviderEntity.Name}`;
+            console.log('[copyObjectBetweenProviders]', result.message);
+        }
+        else {
+            result.message = `Failed to upload file to destination: ${destinationPath}`;
+            console.error('[copyObjectBetweenProviders]', result.message);
+        }
+        return result;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        result.message = `Transfer failed: ${errorMessage}`;
+        console.error('[copyObjectBetweenProviders] Error:', error);
+        return result;
+    }
+};
+exports.copyObjectBetweenProviders = copyObjectBetweenProviders;
+/**
+ * Searches for files across multiple storage providers in parallel.
+ *
+ * This utility function enables searching for files across multiple storage providers
+ * simultaneously. Each provider is queried in parallel using Promise.allSettled,
+ * ensuring that failures in one provider don't affect results from others.
+ *
+ * Providers that don't support search (SupportsSearch = false) will return a result
+ * with success=false and an appropriate error message rather than being silently skipped.
+ *
+ * @param providerEntities - Array of provider entities to search
+ * @param query - Search query string
+ * @param options - Optional search configuration including user contexts for OAuth providers
+ * @returns A promise that resolves to aggregated results grouped by provider
+ *
+ * @example
+ * ```typescript
+ * // Search across Google Drive and Dropbox
+ * const providers = [googleDriveProvider, dropboxProvider];
+ * const userContexts = new Map([
+ *   [googleDriveProvider.ID, { userID: currentUser.ID, contextUser }],
+ *   [dropboxProvider.ID, { userID: currentUser.ID, contextUser }]
+ * ]);
+ *
+ * const result = await searchAcrossProviders(providers, 'quarterly report', {
+ *   maxResultsPerProvider: 25,
+ *   fileTypes: ['pdf', 'docx'],
+ *   providerUserContexts: userContexts
+ * });
+ *
+ * // Process results by provider
+ * for (const providerResult of result.providerResults) {
+ *   if (providerResult.success) {
+ *     console.log(`${providerResult.providerName}: ${providerResult.results.length} results`);
+ *   } else {
+ *     console.log(`${providerResult.providerName}: ${providerResult.errorMessage}`);
+ *   }
+ * }
+ * ```
+ */
+const searchAcrossProviders = async (providerEntities, query, options) => {
+    console.log('[searchAcrossProviders] Starting search:', {
+        providerCount: providerEntities.length,
+        providers: providerEntities.map((p) => p.Name),
+        query,
+        options: { ...options, providerUserContexts: options?.providerUserContexts ? '[Map]' : undefined },
+    });
+    const maxResults = options?.maxResultsPerProvider ?? 50;
+    const searchOptions = {
+        maxResults,
+        fileTypes: options?.fileTypes,
+        searchContent: options?.searchContent ?? false,
+    };
+    // Create search promises for each provider
+    const searchPromises = providerEntities.map(async (providerEntity) => {
+        const providerResult = {
+            providerID: providerEntity.ID,
+            providerName: providerEntity.Name,
+            success: false,
+            results: [],
+            hasMore: false,
+        };
+        try {
+            // Check if provider supports search
+            if (!providerEntity.SupportsSearch) {
+                providerResult.errorMessage = 'This provider does not support search';
+                console.log(`[searchAcrossProviders] ${providerEntity.Name}: Does not support search`);
+                return providerResult;
+            }
+            // Get user context for this provider if available
+            const userContext = options?.providerUserContexts?.get(providerEntity.ID);
+            // Initialize driver with user credentials if available
+            const driver = await initializeDriver(providerEntity, userContext);
+            // Execute search
+            console.log(`[searchAcrossProviders] ${providerEntity.Name}: Executing search...`);
+            const searchResult = await driver.SearchFiles(query, searchOptions);
+            providerResult.success = true;
+            providerResult.results = searchResult.results;
+            providerResult.totalMatches = searchResult.totalMatches;
+            providerResult.hasMore = searchResult.hasMore;
+            providerResult.nextPageToken = searchResult.nextPageToken;
+            console.log(`[searchAcrossProviders] ${providerEntity.Name}: Found ${searchResult.results.length} results`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            providerResult.errorMessage = errorMessage;
+            console.error(`[searchAcrossProviders] ${providerEntity.Name}: Error -`, errorMessage);
+        }
+        return providerResult;
+    });
+    // Execute all searches in parallel
+    const settledResults = await Promise.allSettled(searchPromises);
+    // Aggregate results
+    const providerResults = [];
+    let totalResultsReturned = 0;
+    let successfulProviders = 0;
+    let failedProviders = 0;
+    for (const settled of settledResults) {
+        if (settled.status === 'fulfilled') {
+            const result = settled.value;
+            providerResults.push(result);
+            if (result.success) {
+                successfulProviders++;
+                totalResultsReturned += result.results.length;
+            }
+            else {
+                failedProviders++;
+            }
+        }
+        else {
+            // Promise rejected (shouldn't happen with our try/catch, but handle it)
+            failedProviders++;
+            console.error('[searchAcrossProviders] Promise rejected:', settled.reason);
+        }
+    }
+    const aggregatedResult = {
+        providerResults,
+        totalResultsReturned,
+        successfulProviders,
+        failedProviders,
+    };
+    console.log('[searchAcrossProviders] Search complete:', {
+        totalResultsReturned,
+        successfulProviders,
+        failedProviders,
+    });
+    return aggregatedResult;
+};
+exports.searchAcrossProviders = searchAcrossProviders;
+/**
+ * Searches for files across multiple storage accounts in parallel.
+ *
+ * This is the enterprise version of search that uses the account-based credential model.
+ * Each account is searched independently, allowing multiple accounts from the same
+ * provider type to be searched (e.g., two different Dropbox accounts).
+ *
+ * @param accounts - Array of account/provider pairs to search
+ * @param query - Search query string
+ * @param options - Search configuration including context user for credentials
+ * @returns A promise that resolves to aggregated results grouped by account
+ *
+ * @example
+ * ```typescript
+ * const accounts = [
+ *   { accountEntity: researchDropbox, providerEntity: dropboxProvider },
+ *   { accountEntity: marketingDropbox, providerEntity: dropboxProvider },
+ *   { accountEntity: engineeringGDrive, providerEntity: gdriveProvider }
+ * ];
+ *
+ * const result = await searchAcrossAccounts(accounts, 'quarterly report', {
+ *   maxResultsPerAccount: 25,
+ *   fileTypes: ['pdf', 'docx'],
+ *   contextUser: currentUser
+ * });
+ *
+ * for (const accountResult of result.accountResults) {
+ *   if (accountResult.success) {
+ *     console.log(`${accountResult.accountName}: ${accountResult.results.length} results`);
+ *   }
+ * }
+ * ```
+ */
+const searchAcrossAccounts = async (accounts, query, options) => {
+    console.log('[searchAcrossAccounts] Starting search:', {
+        accountCount: accounts.length,
+        accounts: accounts.map((a) => ({ account: a.accountEntity.Name, provider: a.providerEntity.Name })),
+        query,
+        maxResultsPerAccount: options.maxResultsPerAccount,
+        fileTypes: options.fileTypes,
+        searchContent: options.searchContent,
+    });
+    const maxResults = options.maxResultsPerAccount ?? 50;
+    const searchOptions = {
+        maxResults,
+        fileTypes: options.fileTypes,
+        searchContent: options.searchContent ?? false,
+    };
+    // Create search promises for each account
+    const searchPromises = accounts.map(async ({ accountEntity, providerEntity }) => {
+        const accountResult = {
+            accountID: accountEntity.ID,
+            accountName: accountEntity.Name,
+            providerID: providerEntity.ID,
+            providerName: providerEntity.Name,
+            success: false,
+            results: [],
+            hasMore: false,
+        };
+        try {
+            // Check if provider supports search
+            if (!providerEntity.SupportsSearch) {
+                accountResult.errorMessage = 'This provider does not support search';
+                console.log(`[searchAcrossAccounts] ${accountEntity.Name}: Provider does not support search`);
+                return accountResult;
+            }
+            // Initialize driver with account-based credentials
+            const driver = await initializeDriverWithAccountCredentials({
+                accountEntity,
+                providerEntity,
+                contextUser: options.contextUser,
+            });
+            // Execute search
+            console.log(`[searchAcrossAccounts] ${accountEntity.Name}: Executing search...`);
+            const searchResult = await driver.SearchFiles(query, searchOptions);
+            accountResult.success = true;
+            accountResult.results = searchResult.results;
+            accountResult.totalMatches = searchResult.totalMatches;
+            accountResult.hasMore = searchResult.hasMore;
+            accountResult.nextPageToken = searchResult.nextPageToken;
+            console.log(`[searchAcrossAccounts] ${accountEntity.Name}: Found ${searchResult.results.length} results`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            accountResult.errorMessage = errorMessage;
+            console.error(`[searchAcrossAccounts] ${accountEntity.Name}: Error -`, errorMessage);
+        }
+        return accountResult;
+    });
+    // Execute all searches in parallel
+    const settledResults = await Promise.allSettled(searchPromises);
+    // Aggregate results
+    const accountResults = [];
+    let totalResultsReturned = 0;
+    let successfulAccounts = 0;
+    let failedAccounts = 0;
+    for (const settled of settledResults) {
+        if (settled.status === 'fulfilled') {
+            const result = settled.value;
+            accountResults.push(result);
+            if (result.success) {
+                successfulAccounts++;
+                totalResultsReturned += result.results.length;
+            }
+            else {
+                failedAccounts++;
+            }
+        }
+        else {
+            // Promise rejected (shouldn't happen with our try/catch, but handle it)
+            failedAccounts++;
+            console.error('[searchAcrossAccounts] Promise rejected:', settled.reason);
+        }
+    }
+    const aggregatedResult = {
+        accountResults,
+        totalResultsReturned,
+        successfulAccounts,
+        failedAccounts,
+    };
+    console.log('[searchAcrossAccounts] Search complete:', {
+        totalResultsReturned,
+        successfulAccounts,
+        failedAccounts,
+    });
+    return aggregatedResult;
+};
+exports.searchAcrossAccounts = searchAcrossAccounts;
 //# sourceMappingURL=util.js.map