@memberjunction/storage 3.1.1 → 3.2.0

package/dist/drivers/DropboxFileStorage.js

@@ -115,19 +115,28 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
         if (accessToken) {
             // Use access token directly
             this._accessToken = accessToken;
-            this._client = new dropbox_1.Dropbox({ accessToken });
+            const dropboxConfig = { accessToken };
+            // For Dropbox Business/Team accounts, specify the team member
+            if (config && 'selectUser' in config && config.selectUser) {
+                dropboxConfig.selectUser = config.selectUser;
+            }
+            this._client = new dropbox_1.Dropbox(dropboxConfig);
         }
         else if (refreshToken && appKey && appSecret) {
             // Use refresh token with app credentials
-            this._client = new dropbox_1.Dropbox({
+            const dropboxConfig = {
                 refreshToken,
                 clientId: appKey,
-                clientSecret: appSecret
-            });
-        }
-        else {
-            throw new Error('Dropbox storage requires either STORAGE_DROPBOX_ACCESS_TOKEN or STORAGE_DROPBOX_REFRESH_TOKEN with APP_KEY and APP_SECRET');
+                clientSecret: appSecret,
+            };
+            // For Dropbox Business/Team accounts, specify the team member
+            if (config && 'selectUser' in config && config.selectUser) {
+                dropboxConfig.selectUser = config.selectUser;
+            }
+            this._client = new dropbox_1.Dropbox(dropboxConfig);
         }
+        // Note: If no credentials are available, client will be initialized in initialize() method
+        // This allows for database-driven configuration to be passed after construction
         // Root path, optional (defaults to empty which is root)
         this._rootPath = config?.rootPath || env.get('STORAGE_DROPBOX_ROOT_PATH').default('').asString();
         // Ensure root path starts with / if not empty
@@ -135,12 +144,67 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
             this._rootPath = '/' + this._rootPath;
         }
     }
+    /**
+     * Initialize the Dropbox client with configuration from database or other runtime source.
+     * This allows configuration to be passed after construction, overriding environment variables.
+     *
+     * @param config - Optional configuration object with accessToken, refreshToken, etc.
+     */
+    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
+        }
+        // If config is provided, reinitialize the client with it
+        const accessToken = config.accessToken;
+        const refreshToken = config.refreshToken;
+        // Support both naming conventions: clientID/clientSecret (standard) and appKey/appSecret (Dropbox terminology)
+        const appKey = config.clientID || config.appKey;
+        const appSecret = config.clientSecret || config.appSecret;
+        // Prefer refresh token over access token when both are available
+        // Access tokens expire (4 hours), refresh tokens are long-lived and auto-refresh
+        if (refreshToken && appKey && appSecret) {
+            // Use refresh token with app credentials - this is the preferred method
+            const dropboxConfig = {
+                refreshToken,
+                clientId: appKey,
+                clientSecret: appSecret,
+            };
+            // For Dropbox Business/Team accounts, specify the team member
+            if (config.selectUser) {
+                dropboxConfig.selectUser = config.selectUser;
+            }
+            this._client = new dropbox_1.Dropbox(dropboxConfig);
+            // Set a placeholder for IsConfigured check - the SDK will get a real token on first API call
+            this._accessToken = 'refresh-token-mode';
+        }
+        else if (accessToken) {
+            // Fall back to access token if no refresh token available
+            // Note: This will fail when the access token expires (typically 4 hours)
+            this._accessToken = accessToken;
+            const dropboxConfig = { accessToken };
+            // For Dropbox Business/Team accounts, specify the team member
+            if (config.selectUser) {
+                dropboxConfig.selectUser = config.selectUser;
+            }
+            this._client = new dropbox_1.Dropbox(dropboxConfig);
+        }
+        // Update root path if provided
+        if (config.rootPath) {
+            this._rootPath = config.rootPath;
+            // Ensure root path starts with / if not empty
+            if (this._rootPath && !this._rootPath.startsWith('/')) {
+                this._rootPath = '/' + this._rootPath;
+            }
+        }
+    }
     /**
      * Checks if Dropbox provider is properly configured.
      * Returns true if access token is present.
      */
     get IsConfigured() {
-        return !!(this._accessToken);
+        return !!this._accessToken;
     }
     /**
      * Normalizes a path to be compatible with Dropbox API
@@ -153,20 +217,25 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
      * @returns A normalized path string suitable for Dropbox API calls
      */
     _normalizePath(path) {
+        console.log('[DropboxFileStorage._normalizePath] Input:', {
+            path,
+            rootPath: this._rootPath,
+        });
         // Combine root path with the given path
         let fullPath = path;
         if (this._rootPath) {
-            fullPath = path ?
-                (path.startsWith('/') ? this._rootPath + path : this._rootPath + '/' + path) :
-                this._rootPath;
+            fullPath = path ? (path.startsWith('/') ? this._rootPath + path : this._rootPath + '/' + path) : this._rootPath;
         }
         else if (!fullPath.startsWith('/') && fullPath !== '') {
             fullPath = '/' + fullPath;
         }
+        console.log('[DropboxFileStorage._normalizePath] After combining root path:', { fullPath });
         // For root, Dropbox uses empty string instead of "/"
         if (fullPath === '/') {
+            console.log('[DropboxFileStorage._normalizePath] Converted root "/" to empty string');
             return '';
         }
+        console.log('[DropboxFileStorage._normalizePath] Final result:', { fullPath });
         return fullPath;
     }
     /**
@@ -184,7 +253,7 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
         try {
             const response = await this._client.filesGetMetadata({
                 path: normalizedPath,
-                include_media_info: false
+                include_media_info: false,
             });
             return response.result;
         }
@@ -206,6 +275,12 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
     _convertToMetadata(item, parentPath = '') {
         const isDirectory = item['.tag'] === 'folder';
         const name = item.name;
+        console.log('[DropboxFileStorage._convertToMetadata] Processing item:', {
+            name,
+            path_display: item.path_display,
+            rootPath: this._rootPath,
+            parentPath,
+        });
         // Extract path from item.path_display
         let path = '';
         if (item.path_display) {
@@ -213,35 +288,53 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
             const pathParts = item.path_display.split('/');
             pathParts.pop();
             path = pathParts.join('/');
+            console.log('[DropboxFileStorage._convertToMetadata] After extracting directory:', { path });
             // Remove root path if present
             if (this._rootPath && path.startsWith(this._rootPath)) {
+                const oldPath = path;
                 path = path.substring(this._rootPath.length);
+                console.log('[DropboxFileStorage._convertToMetadata] Removed root path:', {
+                    oldPath,
+                    newPath: path,
+                    rootPath: this._rootPath,
+                });
             }
             // Remove leading slash
             if (path.startsWith('/')) {
                 path = path.substring(1);
+                console.log('[DropboxFileStorage._convertToMetadata] Removed leading slash:', { path });
             }
         }
         // Use parentPath if provided
         if (parentPath) {
+            console.log('[DropboxFileStorage._convertToMetadata] Using parentPath:', { parentPath });
             path = parentPath;
         }
-        // Construct full path
-        const fullPath = path ? `${path}/${name}` : name;
+        // Construct full path - ensure no double slashes
+        let fullPath = name;
+        if (path) {
+            // Remove trailing slash from path and leading slash from name
+            const cleanPath = path.endsWith('/') ? path.slice(0, -1) : path;
+            const cleanName = name.startsWith('/') ? name.slice(1) : name;
+            fullPath = `${cleanPath}/${cleanName}`;
+        }
+        console.log('[DropboxFileStorage._convertToMetadata] Final result:', {
+            name,
+            path,
+            fullPath,
+        });
         return {
             name,
             path,
             fullPath,
-            size: isDirectory ? 0 : (item.size || 0),
-            contentType: isDirectory ?
-                'application/x-directory' :
-                (mime.lookup(name) || 'application/octet-stream'),
+            size: isDirectory ? 0 : item.size || 0,
+            contentType: isDirectory ? 'application/x-directory' : mime.lookup(name) || 'application/octet-stream',
             lastModified: isDirectory ? new Date() : new Date(item.server_modified || Date.now()),
             isDirectory,
             customMetadata: {
                 id: item.id,
-                rev: item.rev
-            }
+                rev: isDirectory ? undefined : item.rev,
+            },
         };
     }
     /**
@@ -267,10 +360,77 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
      * }
      * ```
      */
+    /**
+     * Creates a pre-authenticated upload URL for a file
+     *
+     * This method generates a time-limited URL that can be used to upload
+     * a file directly to Dropbox without additional authentication.
+     *
+     * @param objectName - Path where the file should be uploaded (e.g., 'documents/report.pdf')
+     * @returns A Promise that resolves to an object containing the upload URL and provider key
+     * @throws Error if URL creation fails
+     *
+     * @remarks
+     * - Dropbox temporary upload links typically expire after 4 hours
+     * - Maximum file size for upload via temporary link is 150MB
+     * - The upload must use Content-Type: application/octet-stream
+     * - The URL is for one-time use only
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   // Generate a pre-authenticated upload URL
+     *   const uploadPayload = await storage.CreatePreAuthUploadUrl('documents/financial-report.pdf');
+     *
+     *   console.log(`Upload the file to this URL: ${uploadPayload.UploadUrl}`);
+     *
+     *   // Use the URL to upload file directly from client
+     *   // POST request with Content-Type: application/octet-stream
+     * } catch (error) {
+     *   console.error('Error creating upload URL:', error.message);
+     * }
+     * ```
+     */
     async CreatePreAuthUploadUrl(objectName) {
-        // Dropbox doesn't support pre-signed URLs for uploads in the same way as S3
-        // Use PutObject method for uploads instead
-        this.throwUnsupportedOperationError('CreatePreAuthUploadUrl');
+        try {
+            console.log('[DropboxFileStorage.CreatePreAuthUploadUrl] Input:', {
+                objectName,
+                rootPath: this._rootPath,
+            });
+            const normalizedPath = this._normalizePath(objectName);
+            console.log('[DropboxFileStorage.CreatePreAuthUploadUrl] After normalization:', {
+                normalizedPath,
+            });
+            // Create a temporary upload link
+            // Note: commit_info is optional, defaults to overwrite mode
+            const response = await this._client.filesGetTemporaryUploadLink({
+                commit_info: {
+                    path: normalizedPath,
+                    mode: { '.tag': 'overwrite' },
+                    autorename: false,
+                    mute: true,
+                },
+            });
+            console.log('[DropboxFileStorage.CreatePreAuthUploadUrl] Success:', {
+                link: response.result.link,
+            });
+            return {
+                UploadUrl: response.result.link,
+                ProviderKey: normalizedPath,
+            };
+        }
+        catch (error) {
+            console.error('[DropboxFileStorage.CreatePreAuthUploadUrl] Error:', {
+                objectName,
+                rootPath: this._rootPath,
+                error: error.message || error,
+                errorDetails: error.error || error,
+                errorStatus: error.status,
+                fullError: JSON.stringify(error, null, 2),
+            });
+            const errorMsg = error.error?.error_summary || error.message || JSON.stringify(error);
+            throw new Error(`Failed to create upload URL for: ${objectName} - ${errorMsg}`);
+        }
     }
     /**
      * Creates a pre-authenticated download URL for a file
@@ -303,15 +463,29 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
      */
     async CreatePreAuthDownloadUrl(objectName) {
         try {
+            console.log('[DropboxFileStorage.CreatePreAuthDownloadUrl] Input:', {
+                objectName,
+                rootPath: this._rootPath,
+            });
             const normalizedPath = this._normalizePath(objectName);
+            console.log('[DropboxFileStorage.CreatePreAuthDownloadUrl] After normalization:', {
+                normalizedPath,
+            });
             // Create a temporary download link
             const response = await this._client.filesGetTemporaryLink({
-                path: normalizedPath
+                path: normalizedPath,
+            });
+            console.log('[DropboxFileStorage.CreatePreAuthDownloadUrl] Success:', {
+                link: response.result.link,
             });
             return response.result.link;
         }
         catch (error) {
-            console.error('Error creating pre-auth download URL', { objectName, error });
+            console.error('[DropboxFileStorage.CreatePreAuthDownloadUrl] Error:', {
+                objectName,
+                rootPath: this._rootPath,
+                error: error.message || error,
+            });
             throw new Error(`Failed to create download URL for: ${objectName}`);
         }
     }
@@ -352,7 +526,7 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
             await this._client.filesMoveV2({
                 from_path: fromPath,
                 to_path: toPath,
-                autorename: false
+                autorename: false,
             });
             return true;
         }
@@ -388,18 +562,31 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
      */
     async DeleteObject(objectName) {
         try {
-            const normalizedPath = this._normalizePath(objectName);
-            await this._client.filesDeleteV2({
-                path: normalizedPath
+            // Remove trailing slash if present (Dropbox doesn't accept trailing slashes for folder deletion)
+            const normalizedPath = objectName.endsWith('/') ? this._normalizePath(objectName.substring(0, objectName.length - 1)) : this._normalizePath(objectName);
+            console.log('[DropboxFileStorage] DeleteObject called:', {
+                objectName,
+                normalizedPath,
+                rootPath: this._rootPath,
+                hadTrailingSlash: objectName.endsWith('/'),
+            });
+            const result = await this._client.filesDeleteV2({
+                path: normalizedPath,
             });
+            console.log('[DropboxFileStorage] filesDeleteV2 result:', result);
             return true;
         }
         catch (error) {
             // If the path doesn't exist, consider it success for idempotency
             if (error.status === 409 && error.error?.error?.['.tag'] === 'path_lookup') {
+                console.log('[DropboxFileStorage] Path not found (already deleted):', objectName);
                 return true;
             }
-            console.error('Error deleting object', { objectName, error });
+            console.error('[DropboxFileStorage] Error deleting object', {
+                objectName,
+                normalizedPath: objectName.endsWith('/') ? this._normalizePath(objectName.substring(0, objectName.length - 1)) : this._normalizePath(objectName),
+                error,
+            });
             return false;
         }
     }
@@ -440,30 +627,83 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
     async ListObjects(prefix, delimiter = '/') {
         try {
             const normalizedPath = this._normalizePath(prefix);
+            console.log('[DropboxFileStorage] ListObjects called:', {
+                prefix,
+                normalizedPath,
+                delimiter,
+                hasClient: !!this._client,
+                isConfigured: this.IsConfigured,
+                rootPath: this._rootPath,
+            });
+            // Debug: Try to get current account info to understand access type
+            try {
+                const accountInfo = await this._client.usersGetCurrentAccount();
+                console.log('[DropboxFileStorage] Account info:', {
+                    accountId: accountInfo.result.account_id,
+                    email: accountInfo.result.email,
+                    name: accountInfo.result.name.display_name,
+                });
+            }
+            catch (error) {
+                console.log('[DropboxFileStorage] Could not get account info:', error?.message);
+            }
             const response = await this._client.filesListFolder({
                 path: normalizedPath,
                 recursive: false,
                 include_media_info: false,
                 include_deleted: false,
-                include_has_explicit_shared_members: false
+                include_has_explicit_shared_members: false,
             });
+            console.log('[DropboxFileStorage] filesListFolder response:', {
+                entriesCount: response.result.entries.length,
+                entries: response.result.entries.map((e) => ({ name: e.name, tag: e['.tag'] })),
+                has_more: response.result.has_more,
+                cursor: response.result.cursor,
+            });
+            // Check if we're in an app folder scenario
+            if (response.result.entries.length === 0 && normalizedPath === '') {
+                console.log('[DropboxFileStorage] Empty root - this might be an app-folder-only token');
+                console.log('[DropboxFileStorage] Note: If using app folder access, files are in /Apps/[YourAppName]/');
+                console.log('[DropboxFileStorage] You can set rootPath in configuration to point to your app folder');
+                // Try to list a few common app folder paths to help diagnose
+                const testPaths = ['/Apps', '/Apps/MJ-Files-Test', '/MJ-FileTest'];
+                for (const testPath of testPaths) {
+                    try {
+                        console.log(`[DropboxFileStorage] Testing path: ${testPath}`);
+                        const testResponse = await this._client.filesListFolder({ path: testPath, recursive: false });
+                        console.log(`[DropboxFileStorage] Found ${testResponse.result.entries.length} items at ${testPath}:`, testResponse.result.entries.map((e) => ({ name: e.name, tag: e['.tag'] })));
+                    }
+                    catch (testError) {
+                        const errorMsg = testError.error?.error_summary || testError.message;
+                        console.log(`[DropboxFileStorage] Cannot access ${testPath}: ${errorMsg}`);
+                    }
+                }
+            }
             const objects = [];
             const prefixes = [];
             // Process entries
             for (const entry of response.result.entries) {
+                // Skip deleted entries
+                if (entry['.tag'] === 'deleted') {
+                    continue;
+                }
                 objects.push(this._convertToMetadata(entry, prefix));
                 // If it's a folder, add to prefixes
                 if (entry['.tag'] === 'folder') {
-                    const folderPath = prefix
-                        ? (prefix.endsWith('/') ? `${prefix}${entry.name}` : `${prefix}/${entry.name}`)
-                        : entry.name;
+                    const folderPath = prefix ? (prefix.endsWith('/') ? `${prefix}${entry.name}` : `${prefix}/${entry.name}`) : entry.name;
+                    console.log('[DropboxFileStorage] Adding folder prefix:', folderPath);
                     prefixes.push(`${folderPath}/`);
                 }
             }
+            console.log('[DropboxFileStorage] Final result:', {
+                objectsCount: objects.length,
+                prefixesCount: prefixes.length,
+                prefixes,
+            });
             return { objects, prefixes };
         }
         catch (error) {
-            console.error('Error listing objects', { prefix, error });
+            console.error('[DropboxFileStorage] Error listing objects:', { prefix, error, errorMessage: error?.message, errorStatus: error?.status });
             return { objects: [], prefixes: [] };
         }
     }
@@ -507,7 +747,7 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
                 : this._normalizePath(directoryPath);
             await this._client.filesCreateFolderV2({
                 path: normalizedPath,
-                autorename: false
+                autorename: false,
             });
             return true;
         }
@@ -564,14 +804,14 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
                 // Check if directory is empty first
                 const listing = await this._client.filesListFolder({
                     path: normalizedPath,
-                    recursive: false
+                    recursive: false,
                 });
                 if (listing.result.entries.length > 0) {
                     throw new Error('Directory is not empty');
                 }
             }
             await this._client.filesDeleteV2({
-                path: normalizedPath
+                path: normalizedPath,
             });
             return true;
         }
@@ -643,8 +883,12 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
             }
             const response = await this._client.filesGetMetadata({
                 path: path,
-                include_media_info: false
+                include_media_info: false,
             });
+            // Check if the result is a deleted entry
+            if (response.result['.tag'] === 'deleted') {
+                throw new Error(`Object not found (deleted): ${params.objectId || params.fullPath}`);
+            }
             return this._convertToMetadata(response.result, parentPath);
         }
         catch (error) {
@@ -704,10 +948,11 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
                 console.log(`🐌 Slow path: Using path: ${path}`);
             }
             const response = await this._client.filesDownload({
-                path: path
+                path: path,
             });
             // Extract file content as Buffer
             // Note: In Dropbox SDK, the file content is in response.result.fileBinary
+            // The TypeScript definitions don't include fileBinary, but it's present in the actual response
             return Buffer.from(response.result.fileBinary);
         }
         catch (error) {
@@ -763,7 +1008,7 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
                     contents: data,
                     mode: { '.tag': 'overwrite' },
                     autorename: false,
-                    mute: true
+                    mute: true,
                 });
             }
             else {
@@ -772,7 +1017,7 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
                 // Start upload session
                 const sessionStart = await this._client.filesUploadSessionStart({
                     close: false,
-                    contents: data.slice(0, CHUNK_SIZE)
+                    contents: data.slice(0, CHUNK_SIZE),
                 });
                 const sessionId = sessionStart.result.session_id;
                 let offset = CHUNK_SIZE;
@@ -785,15 +1030,15 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
                         await this._client.filesUploadSessionFinish({
                             cursor: {
                                 session_id: sessionId,
-                                offset: offset
+                                offset: offset,
                             },
                             commit: {
                                 path: normalizedPath,
                                 mode: { '.tag': 'overwrite' },
                                 autorename: false,
-                                mute: true
+                                mute: true,
                             },
-                            contents: chunk
+                            contents: chunk,
                         });
                     }
                     else {
@@ -801,10 +1046,10 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
                         await this._client.filesUploadSessionAppendV2({
                             cursor: {
                                 session_id: sessionId,
-                                offset: offset
+                                offset: offset,
                             },
                             close: false,
-                            contents: chunk
+                            contents: chunk,
                         });
                     }
                     offset += chunk.length;
@@ -854,7 +1099,7 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
             await this._client.filesCopyV2({
                 from_path: fromPath,
                 to_path: toPath,
-                autorename: false
+                autorename: false,
             });
             return true;
         }
@@ -924,9 +1169,7 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
     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._getMetadata(normalizedPath);
             return item['.tag'] === 'folder';
         }
@@ -976,13 +1219,13 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
             const maxResults = options?.maxResults || 100;
             // Build Dropbox search options
             const searchOptions = {
-                query: query,
+                query,
                 options: {
                     max_results: Math.min(maxResults, 1000), // Dropbox max is 1000
                     path: options?.pathPrefix ? this._normalizePath(options.pathPrefix) : undefined,
-                    file_status: 'active', // Exclude deleted files
-                    filename_only: !options?.searchContent // Search filename only or filename + content
-                }
+                    file_status: { '.tag': 'active' }, // Exclude deleted files
+                    filename_only: !options?.searchContent, // Search filename only or filename + content
+                },
             };
             // Add file extension filter if fileTypes provided
             if (options?.fileTypes && options.fileTypes.length > 0) {
@@ -996,10 +1239,19 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
             const results = [];
             // Process search results
             for (const match of response.result.matches || []) {
-                // The metadata field contains the actual file/folder metadata
-                const metadata = match.metadata.metadata;
+                // The metadata field is MetadataV2, which can be MetadataV2Metadata or MetadataV2Other
+                // We only want MetadataV2Metadata which has the actual file/folder metadata
+                if (match.metadata['.tag'] !== 'metadata') {
+                    continue;
+                }
+                const metadataV2 = match.metadata;
+                // Skip deleted entries
+                if (metadataV2.metadata['.tag'] === 'deleted') {
+                    continue;
+                }
+                const metadata = metadataV2.metadata;
                 // Skip if not a file (could be folder or other type)
-                if (!metadata || metadata['.tag'] !== 'file') {
+                if (metadata['.tag'] !== 'file') {
                     continue;
                 }
                 // Apply date filters client-side (Dropbox search doesn't support date filters directly)
@@ -1026,12 +1278,12 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
                     matchInFilename: this._checkFilenameMatch(fileName, query),
                     customMetadata: {
                         id: metadata.id,
-                        rev: metadata.rev
+                        rev: metadata.rev,
                     },
                     providerData: {
                         dropboxId: metadata.id,
-                        pathLower: metadata.path_lower
-                    }
+                        pathLower: metadata.path_lower,
+                    },
                 });
             }
             // Check if there are more results available
@@ -1040,7 +1292,7 @@ let DropboxFileStorage = class DropboxFileStorage extends FileStorageBase_1.File
                 results,
                 totalMatches: undefined, // Dropbox doesn't provide total count
                 hasMore,
-                nextPageToken: hasMore ? 'continue' : undefined // Dropbox uses continue endpoint for pagination
+                nextPageToken: hasMore ? 'continue' : undefined, // Dropbox uses continue endpoint for pagination
             };
         }
         catch (error) {