@memberjunction/storage 2.103.0 → 2.104.0

package/dist/drivers/BoxFileStorage.js

@@ -37,7 +37,9 @@ const global_1 = require("@memberjunction/global");
 const env = __importStar(require("env-var"));
 const mime = __importStar(require("mime-types"));
 const FileStorageBase_1 = require("../generic/FileStorageBase");
-const https = __importStar(require("https"));
+const box_node_sdk_1 = require("box-node-sdk");
+const stream_1 = require("stream");
+const config_1 = require("../config");
 /**
  * FileStorageBase implementation for Box.com cloud storage
  *
@@ -126,6 +128,10 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
      * Box enterprise ID for JWT auth
      */
     _enterpriseId;
+    /**
+     * Box SDK client for making API calls
+     */
+    _client;
     /**
      * Creates a new BoxFileStorage instance
      *
@@ -136,24 +142,25 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
      */
     constructor() {
         super();
+        // Try to get config from centralized configuration
+        const config = (0, config_1.getProviderConfig)('box');
         // Box auth can be via access token or refresh token
-        this._accessToken = env.get('STORAGE_BOX_ACCESS_TOKEN').asString();
-        this._refreshToken = env.get('STORAGE_BOX_REFRESH_TOKEN').asString();
-        this._clientId = env.get('STORAGE_BOX_CLIENT_ID').asString();
-        this._clientSecret = env.get('STORAGE_BOX_CLIENT_SECRET').asString();
-        this._enterpriseId = env.get('STORAGE_BOX_ENTERPRISE_ID').asString();
+        this._accessToken = config?.accessToken || env.get('STORAGE_BOX_ACCESS_TOKEN').asString();
+        this._refreshToken = config?.refreshToken || env.get('STORAGE_BOX_REFRESH_TOKEN').asString();
+        this._clientId = config?.clientID || env.get('STORAGE_BOX_CLIENT_ID').asString();
+        this._clientSecret = config?.clientSecret || env.get('STORAGE_BOX_CLIENT_SECRET').asString();
+        this._enterpriseId = config?.enterpriseID || env.get('STORAGE_BOX_ENTERPRISE_ID').asString();
         if (this._refreshToken && (!this._clientId || !this._clientSecret)) {
             throw new Error('Box storage with refresh token requires STORAGE_BOX_CLIENT_ID and STORAGE_BOX_CLIENT_SECRET');
         }
         // Root folder ID, optional (defaults to '0' which is root)
-        this._rootFolderId = env.get('STORAGE_BOX_ROOT_FOLDER_ID').default('0').asString();
+        this._rootFolderId = config?.rootFolderID || env.get('STORAGE_BOX_ROOT_FOLDER_ID').default('0').asString();
     }
     /**
      * Initializes the Box storage driver
      *
-     * This method must be called after creating a BoxFileStorage instance
-     * when using client credentials (JWT) authentication. It obtains the
-     * initial access token required for API calls.
+     * This method must be called after creating a BoxFileStorage instance.
+     * It initializes the Box SDK and creates the client for API calls.
      *
      * @returns A Promise that resolves when initialization is complete
      *
@@ -165,9 +172,24 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
      * ```
      */
     async initialize() {
-        if (!this._accessToken && this._clientId && this._clientSecret && this._enterpriseId) {
-            await this._setAccessToken();
+        // Get access token if not provided
+        if (!this._accessToken) {
+            if (this._clientId && this._clientSecret && this._enterpriseId) {
+                // Use client credentials to get token
+                this._accessToken = await this._getAccessToken();
+            }
+            else if (this._refreshToken) {
+                // Use refresh token to get access token
+                const tokenData = await this._refreshAccessToken();
+                this._accessToken = tokenData.access_token;
+            }
+            else {
+                throw new Error('Box storage requires either access token, refresh token, or client credentials');
+            }
         }
+        // Initialize Box client with developer token auth
+        const auth = new box_node_sdk_1.BoxDeveloperTokenAuth({ token: this._accessToken });
+        this._client = new box_node_sdk_1.BoxClient({ auth });
     }
     /**
      * Obtains an access token using client credentials flow
@@ -176,10 +198,10 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
      * flow (JWT) with the enterprise as the subject.
      *
      * @private
-     * @returns A Promise that resolves when the access token is obtained
+     * @returns A Promise that resolves with the access token
      * @throws Error if token acquisition fails
      */
-    async _setAccessToken() {
+    async _getAccessToken() {
         try {
             const response = await fetch('https://api.box.com/oauth2/token', {
                 method: 'POST',
@@ -198,15 +220,49 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
                 throw new Error(`Failed to get access token: ${response.status} ${response.statusText}`);
             }
             const tokenData = await response.json();
-            const { access_token, expires_in } = tokenData;
-            this._accessToken = access_token;
-            this._tokenExpiresAt = Date.now() + (expires_in * 1000) - 60000; // Subtract 1 minute for safety
+            this._accessToken = tokenData.access_token;
+            this._tokenExpiresAt = Date.now() + (tokenData.expires_in * 1000) - 60000;
+            return tokenData.access_token;
         }
         catch (error) {
             console.error('Error getting Box access token', error);
             throw new Error('Failed to authenticate with Box: ' + (error instanceof Error ? error.message : String(error)));
         }
     }
+    /**
+     * Refreshes the access token using the refresh token
+     *
+     * @private
+     * @returns A Promise that resolves with the token data
+     */
+    async _refreshAccessToken() {
+        try {
+            const response = await fetch('https://api.box.com/oauth2/token', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded'
+                },
+                body: new URLSearchParams({
+                    grant_type: 'refresh_token',
+                    refresh_token: this._refreshToken,
+                    client_id: this._clientId,
+                    client_secret: this._clientSecret
+                })
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to refresh token: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            this._accessToken = data.access_token;
+            this._refreshToken = data.refresh_token || this._refreshToken;
+            this._tokenExpiresAt = Date.now() + (data.expires_in * 1000) - 60000;
+            return data;
+        }
+        catch (error) {
+            console.error('Error refreshing Box access token', error);
+            throw new Error('Failed to refresh token: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
     /**
      * Returns the current Box API access token
      *
@@ -223,126 +279,20 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
      * ```
      */
     async AccessToken() {
-        await this._ensureValidToken();
-        return this._accessToken;
-    }
-    /**
-     * Ensures a valid access token is available for API requests
-     *
-     * This method checks if the current token is valid, and if not, attempts
-     * to refresh or obtain a new token using the configured authentication method.
-     *
-     * @private
-     * @returns A Promise that resolves to a valid access token
-     * @throws Error if no valid token can be obtained
-     */
-    async _ensureValidToken() {
-        // If we have a valid token, use it
+        // If we have a valid token, return it
         if (this._accessToken && Date.now() < this._tokenExpiresAt) {
             return this._accessToken;
         }
-        // If we have refresh token, try to get a new access token
+        // Otherwise refresh using SDK's built-in token management
         if (this._refreshToken && this._clientId && this._clientSecret) {
-            try {
-                const response = await fetch('https://api.box.com/oauth2/token', {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/x-www-form-urlencoded'
-                    },
-                    body: new URLSearchParams({
-                        grant_type: 'refresh_token',
-                        refresh_token: this._refreshToken,
-                        client_id: this._clientId,
-                        client_secret: this._clientSecret
-                    })
-                });
-                if (!response.ok) {
-                    throw new Error(`Failed to refresh token: ${response.status} ${response.statusText}`);
-                }
-                const data = await response.json();
-                this._accessToken = data.access_token;
-                this._refreshToken = data.refresh_token || this._refreshToken;
-                this._tokenExpiresAt = Date.now() + (data.expires_in * 1000) - 60000; // Subtract 1 minute for safety
-                return this._accessToken;
-            }
-            catch (error) {
-                console.error('Error refreshing Box access token', error);
-                // Fall through to client credentials if refresh fails
-            }
-        }
-        // If we have client credentials, try to get a new access token
-        if (this._clientId && this._clientSecret && this._enterpriseId) {
-            try {
-                await this._setAccessToken();
-                return this._accessToken;
-            }
-            catch (error) {
-                console.error('Error getting new access token via client credentials', error);
-                throw new Error('Failed to authenticate with Box: ' + (error instanceof Error ? error.message : String(error)));
-            }
-        }
-        // If we have an access token but it's expired and we can't refresh it
-        if (this._accessToken) {
-            console.warn('Using expired Box access token as no refresh mechanism is available');
-            return this._accessToken;
-        }
-        throw new Error('No valid Box access token available and no authentication method configured');
-    }
-    /**
-     * Makes an authenticated API request to the Box API
-     *
-     * This helper method handles authentication, request formatting, and
-     * response parsing for all Box API calls.
-     *
-     * @private
-     * @param endpoint - The API endpoint to call (e.g., '/files/123')
-     * @param method - The HTTP method to use (default: 'GET')
-     * @param body - Optional request body (will be serialized as JSON unless it's FormData)
-     * @param headers - Optional additional headers
-     * @param baseUrl - Base URL to use (defaults to standard API URL)
-     * @returns A Promise that resolves to the API response data
-     * @throws Error if the API request fails
-     */
-    async _apiRequest(endpoint, method = 'GET', body, headers = {}, baseUrl = this._baseApiUrl) {
-        const token = await this._ensureValidToken();
-        const requestHeaders = {
-            'Authorization': `Bearer ${token}`,
-            ...headers
-        };
-        if (body && typeof body !== 'string' && !(body instanceof FormData) && !(body instanceof URLSearchParams)) {
-            requestHeaders['Content-Type'] = 'application/json';
-            body = JSON.stringify(body);
-        }
-        const url = `${baseUrl}${endpoint}`;
-        const response = await fetch(url, {
-            method,
-            headers: requestHeaders,
-            body
-        });
-        if (response.status === 204 || response.status === 202) {
-            return null; // No content response
+            const tokenData = await this._refreshAccessToken();
+            this._accessToken = tokenData.access_token;
+            this._tokenExpiresAt = Date.now() + (tokenData.expires_in * 1000);
         }
-        // For downloading files, return the response directly
-        if (endpoint.startsWith('/files/') && endpoint.includes('/content') && response.ok) {
-            return response;
+        else if (this._clientId && this._clientSecret && this._enterpriseId) {
+            this._accessToken = await this._getAccessToken();
         }
-        // If the response is not JSON, handle it specially
-        const contentType = response.headers.get('content-type');
-        if (contentType && !contentType.includes('application/json')) {
-            if (response.ok) {
-                return response;
-            }
-            else {
-                throw new Error(`Box API error: ${response.status} - ${response.statusText}`);
-            }
-        }
-        const data = await response.json();
-        if (!response.ok) {
-            console.error('Box API error', { status: response.status, data });
-            const errorData = data;
-            throw new Error(`Box API error: ${response.status} - ${errorData.message || errorData.error_description || errorData.error || JSON.stringify(data)}`);
-        }
-        return data;
+        return this._accessToken;
     }
     /**
      * Parses a path string into Box API components
@@ -387,16 +337,43 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
      * @throws Error if the item does not exist
      */
     async _getIdFromPath(path) {
+        const itemInfo = await this._getItemInfoFromPath(path);
+        return itemInfo?.id || null;
+    }
+    /**
+     * Gets both ID and type information for an item at the given path
+     *
+     * @param path - Path to the item
+     * @returns Object with id and type, or null if not found
+     */
+    async _getItemInfoFromPath(path) {
         try {
             // Parse the path
             const parsedPath = this._parsePath(path);
-            // If the id is already in the path, return it
+            // If the id is already in the path, we need to determine type separately
             if (parsedPath.id) {
-                return parsedPath.id;
+                // Try as file first, then folder
+                try {
+                    const fileInfo = await this._client.files.getFileById(parsedPath.id, {
+                        queryParams: { fields: ['id', 'type'] }
+                    });
+                    return { id: fileInfo.id, type: fileInfo.type };
+                }
+                catch {
+                    try {
+                        const folderInfo = await this._client.folders.getFolderById(parsedPath.id, {
+                            queryParams: { fields: ['id', 'type'] }
+                        });
+                        return { id: folderInfo.id, type: folderInfo.type };
+                    }
+                    catch {
+                        return null;
+                    }
+                }
             }
             // If it's root, return root folder id
             if (!parsedPath.name) {
-                return this._rootFolderId;
+                return { id: this._rootFolderId, type: 'folder' };
             }
             // First, find the parent folder ID
             let parentFolderId = this._rootFolderId;
@@ -408,27 +385,29 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
             let hasMoreItems = true;
             const LIMIT = 1000;
             while (hasMoreItems) {
-                const folderItems = await this._apiRequest(`/folders/${parentFolderId}/items`, 'GET', null, {
-                    'fields': 'name,type,id',
-                    'limit': `${LIMIT}`,
-                    'offset': `${offset}`
+                const folderItems = await this._client.folders.getFolderItems(parentFolderId, {
+                    queryParams: {
+                        fields: ['name', 'type', 'id'],
+                        limit: LIMIT,
+                        offset: offset
+                    }
                 });
                 // Look for the item by name
-                const item = folderItems.entries.find((i) => i.name === parsedPath.name);
-                if (item) {
-                    return item.id;
+                const item = folderItems.entries?.find((i) => i.name === parsedPath.name);
+                if (item && item.id && item.type) {
+                    return { id: item.id, type: item.type };
                 }
                 // Update pagination variables
-                offset += folderItems.entries.length;
+                offset += folderItems.entries?.length || 0;
                 // Check if we've processed all items
-                hasMoreItems = folderItems.entries.length === LIMIT && offset < folderItems.total_count;
+                hasMoreItems = (folderItems.entries?.length || 0) === LIMIT && offset < (folderItems.totalCount || 0);
             }
             // If we get here, the item was not found
             console.log(`Item not found: ${parsedPath.name}`);
             return null;
         }
         catch (error) {
-            console.error('Error in _getIdFromPath', { path, error });
+            console.error('Error in _getItemInfoFromPath', { path, error });
             return null;
         }
     }
@@ -521,17 +500,11 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
                     }
                 }
             }
-            // Create a file upload session
-            const data = await this._apiRequest('/files/upload_sessions', 'POST', {
-                folder_id: parentId,
-                file_name: parsedPath.name,
-                file_size: 0 // We'll use this later for chunked uploads
-            }, {}, this._uploadApiUrl);
-            // Return the upload URL with the session ID as the provider key
-            return {
-                UploadUrl: data.session_endpoints.upload_part,
-                ProviderKey: `session:${data.id}:${objectName}`
-            };
+            // Box SDK v10 doesn't have a simple createUploadSession on files manager
+            // We need to use chunkedUploads manager instead
+            // For now, return a simplified URL structure
+            // TODO: Implement proper chunked upload session support
+            throw new Error('Pre-authenticated upload URLs are not currently supported with Box SDK v10. Use PutObject instead.');
         }
         catch (error) {
             console.error('Error creating pre-auth upload URL', { objectName, error });
@@ -576,12 +549,12 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
             }
             // Get the file ID
             const fileId = await this._getIdFromPath(objectName);
-            // Create a download URL that's good for 60 minutes
-            const data = await this._apiRequest(`/files/${fileId}?fields=download_url`, 'GET');
-            if (!data.download_url) {
+            // Get download URL using SDK
+            const downloadUrl = await this._client.downloads.getDownloadFileUrl(fileId);
+            if (!downloadUrl) {
                 throw new Error(`No download URL available for: ${objectName}`);
             }
-            return data.download_url;
+            return downloadUrl;
         }
         catch (error) {
             console.error('Error creating pre-auth download URL', { objectName, error });
@@ -621,8 +594,11 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
     async MoveObject(oldObjectName, newObjectName) {
         try {
             // Get source info
-            const sourceId = await this._getIdFromPath(oldObjectName);
-            const sourceInfo = await this._apiRequest(`/items/${sourceId}`);
+            const sourceInfo = await this._getItemInfoFromPath(oldObjectName);
+            if (!sourceInfo) {
+                console.log(`Item not found: ${oldObjectName}`);
+                return false;
+            }
             // Get destination info
             const destPath = this._parsePath(newObjectName);
             let destParentId = this._rootFolderId;
@@ -636,12 +612,23 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
                     destParentId = await this._getIdFromPath(destPath.parent);
                 }
             }
-            // Move the item
-            const endpoint = sourceInfo.type === 'folder' ? '/folders/' : '/files/';
-            await this._apiRequest(`${endpoint}${sourceId}`, 'PUT', {
-                parent: { id: destParentId },
-                name: destPath.name
-            });
+            // Move the item using SDK
+            if (sourceInfo.type === 'folder') {
+                await this._client.folders.updateFolderById(sourceInfo.id, {
+                    requestBody: {
+                        parent: { id: destParentId },
+                        name: destPath.name
+                    }
+                });
+            }
+            else {
+                await this._client.files.updateFileById(sourceInfo.id, {
+                    requestBody: {
+                        parent: { id: destParentId },
+                        name: destPath.name
+                    }
+                });
+            }
             return true;
         }
         catch (error) {
@@ -683,15 +670,22 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
         try {
             // Handle session objects specially
             if (objectName.startsWith('session:')) {
-                const [, sessionId] = objectName.split(':');
-                await this._apiRequest(`/files/upload_sessions/${sessionId}`, 'DELETE');
+                // Session support not implemented in SDK v10 migration
+                // Just return true for now
                 return true;
             }
-            const itemId = await this._getIdFromPath(objectName);
-            const itemInfo = await this._apiRequest(`/items/${itemId}`);
-            // Delete the item
-            const endpoint = itemInfo.type === 'folder' ? '/folders/' : '/files/';
-            await this._apiRequest(`${endpoint}${itemId}`, 'DELETE');
+            const itemInfo = await this._getItemInfoFromPath(objectName);
+            if (!itemInfo) {
+                console.log(`Item not found: ${objectName}`);
+                return true; // Already deleted/doesn't exist
+            }
+            // Delete the item using SDK
+            if (itemInfo.type === 'folder') {
+                await this._client.folders.deleteFolderById(itemInfo.id);
+            }
+            else {
+                await this._client.files.deleteFileById(itemInfo.id);
+            }
             return true;
         }
         catch (error) {
@@ -747,9 +741,11 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
                 // If folder doesn't exist, return empty result
                 return { objects: [], prefixes: [] };
             }
-            // Get folder contents
-            const result = await this._apiRequest(`/folders/${folderId}/items`, 'GET', null, {
-                'fields': 'id,name,type,size,content_type,modified_at,created_at,etag,sequence_id'
+            // Get folder contents using SDK
+            const result = await this._client.folders.getFolderItems(folderId, {
+                queryParams: {
+                    fields: ['id', 'name', 'type', 'size', 'content_type', 'modified_at', 'created_at', 'etag', 'sequence_id']
+                }
             });
             const objects = [];
             const prefixes = [];
@@ -845,9 +841,9 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
                     return false;
                 }
             }
-            // Create the folder
+            // Create the folder using SDK
             try {
-                await this._apiRequest('/folders', 'POST', {
+                await this._client.folders.createFolder({
                     name: folderName,
                     parent: { id: parentFolderId }
                 });
@@ -856,8 +852,8 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
             }
             catch (error) {
                 // Handle conflicts - if the folder already exists, that's a success
-                if (error.message && (error.message.includes('409') ||
-                    error.message.includes('item_name_in_use'))) {
+                if (error.statusCode === 409 ||
+                    (error.message && error.message.includes('item_name_in_use'))) {
                     console.log(`Folder already exists (conflict): ${normalizedPath}`);
                     return true;
                 }
@@ -906,20 +902,17 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
      */
     async GetFileRepresentations(fileId, repHints = 'png?dimensions=2048x2048') {
         try {
-            const token = await this._ensureValidToken();
-            const response = await fetch(`${this._baseApiUrl}/files/${fileId}?fields=representations`, {
-                method: 'GET',
+            // Get file with representations field - SDK handles auth automatically
+            const file = await this._client.files.getFileById(fileId, {
+                queryParams: {
+                    fields: ['representations']
+                },
                 headers: {
-                    'Authorization': `Bearer ${token}`,
-                    'Content-Type': 'application/json',
-                    'X-Rep-Hints': repHints
+                    xRepHints: repHints
                 }
             });
-            if (!response.ok) {
-                throw new Error(`Failed to get file representations: ${response.status} ${response.statusText}`);
-            }
-            const data = await response.json();
-            return data;
+            // Convert to plain JSON object
+            return JSON.parse(JSON.stringify(file));
         }
         catch (error) {
             console.error('Error getting file representations:', error);
@@ -927,43 +920,6 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
         }
     }
     ;
-    /**
-     * Helper function for making HTTP requests
-     *
-     * This method provides a Promise-based wrapper around Node.js https requests,
-     * simplifying the process of making API calls to the Box API.
-     *
-     * @private
-     * @param options - The HTTPS request options (URL, method, headers, etc.)
-     * @param data - Optional string data to send with the request
-     * @returns A Promise that resolves to the response data as a string
-     * @throws Error if the request fails or returns a non-2xx status code
-     */
-    async _makeRequest(options, data) {
-        return new Promise((resolve, reject) => {
-            const req = https.request(options, (res) => {
-                let responseData = '';
-                res.on('data', (chunk) => {
-                    responseData += chunk;
-                });
-                res.on('end', () => {
-                    if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-                        resolve(responseData);
-                    }
-                    else {
-                        reject(new Error(`Request failed with status code ${res.statusCode}: ${responseData}`));
-                    }
-                });
-            });
-            req.on('error', (error) => {
-                reject(error);
-            });
-            if (data) {
-                req.write(data);
-            }
-            req.end();
-        });
-    }
     /**
      * Deletes a directory from Box storage
      *
@@ -1012,17 +968,26 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
             }
             // Check if folder is empty if not recursive
             if (!recursive) {
-                const contents = await this._apiRequest(`/folders/${folderId}/items`, 'GET', null, {
-                    'limit': '1'
+                const contents = await this._client.folders.getFolderItems(folderId, {
+                    queryParams: {
+                        limit: 1
+                    }
                 });
                 if (contents.entries.length > 0) {
                     throw new Error('Directory is not empty');
                 }
             }
-            // Delete the folder
-            await this._apiRequest(`/folders/${folderId}`, 'DELETE', null, {
-                'recursive': recursive ? 'true' : 'false'
-            });
+            // Delete the folder using SDK
+            if (recursive) {
+                await this._client.folders.deleteFolderById(folderId, {
+                    queryParams: {
+                        recursive: true
+                    }
+                });
+            }
+            else {
+                await this._client.folders.deleteFolderById(folderId);
+            }
             return true;
         }
         catch (error) {
@@ -1066,14 +1031,19 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
      */
     async GetObjectMetadata(objectName) {
         try {
-            const itemId = await this._getIdFromPath(objectName);
-            // Determine if it's a file or folder
-            const itemInfo = await this._apiRequest(`/items/${itemId}`);
-            const fullEndpoint = itemInfo.type === 'folder' ? `/folders/${itemId}` : `/files/${itemId}`;
-            // Get full metadata
-            const metadata = await this._apiRequest(fullEndpoint, 'GET', null, {
-                'fields': 'id,name,type,size,content_type,modified_at,created_at,etag,sequence_id'
-            });
+            const itemInfo = await this._getItemInfoFromPath(objectName);
+            if (!itemInfo) {
+                throw new Error(`Object not found: ${objectName}`);
+            }
+            // Get full metadata using the SDK based on type
+            const options = {
+                queryParams: {
+                    fields: ['id', 'name', 'type', 'size', 'content_type', 'modified_at', 'created_at', 'etag', 'sequence_id']
+                }
+            };
+            const metadata = itemInfo.type === 'folder'
+                ? await this._client.folders.getFolderById(itemInfo.id, options)
+                : await this._client.files.getFileById(itemInfo.id, options);
             // Parse path to get parent path
             const parsedPath = this._parsePath(objectName);
             return this._convertToMetadata(metadata, parsedPath.parent);
@@ -1116,64 +1086,30 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
      */
     async GetObject(objectName) {
         try {
-            // Extract directory path and filename
-            const lastSlashIndex = objectName.lastIndexOf('/');
-            const directoryPath = lastSlashIndex === -1 ? '' : objectName.substring(0, lastSlashIndex);
-            const fileName = lastSlashIndex === -1 ? objectName : objectName.substring(lastSlashIndex + 1);
-            // Find folder ID for the directory
-            try {
-                const folderId = await this._findFolderIdByPath(directoryPath);
-                // Use pagination to handle large folders
-                let file = null;
-                let offset = 0;
-                let hasMoreItems = true;
-                const LIMIT = 1000;
-                while (hasMoreItems && !file) {
-                    const folderItems = await this._apiRequest(`/folders/${folderId}/items`, 'GET', null, {
-                        'fields': 'name,type,id,size,created_at,modified_at',
-                        'limit': `${LIMIT}`,
-                        'offset': `${offset}`
-                    });
-                    // Look for the file
-                    file = folderItems.entries.find((item) => item.type === 'file' && item.name === fileName);
-                    // If file is found, break out of pagination loop
-                    if (file) {
-                        break;
-                    }
-                    // Update pagination variables
-                    offset += folderItems.entries.length;
-                    // Check if we've processed all items
-                    hasMoreItems = folderItems.entries.length === LIMIT && offset < folderItems.total_count;
-                }
-                if (file) {
-                    console.log(`✅ File found: ${file.name} (${file.id})`);
-                    // Use the file ID to get the content
-                    const fileResponse = await this._apiRequest(`/files/${file.id}/content`, 'GET');
-                    // If the API request returned a response object (for direct download)
-                    if (fileResponse instanceof Response) {
-                        const arrayBuffer = await fileResponse.arrayBuffer();
-                        return Buffer.from(arrayBuffer);
-                    }
-                    else {
-                        throw new Error('Unexpected response format when downloading file');
-                    }
-                }
-                else {
-                    console.log(`❌ File not found in directory`);
-                    throw new Error(`File not found: ${fileName}`);
-                }
+            // Get file ID using path resolution
+            const fileId = await this._getIdFromPath(objectName);
+            if (!fileId) {
+                throw new Error(`File not found: ${objectName}`);
             }
-            catch (error) {
-                console.log(`❌ Error finding file: ${error}`);
-                throw error;
+            console.log(`✅ File found with ID: ${fileId}`);
+            // Use SDK to download file content as a stream
+            const stream = await this._client.downloads.downloadFile(fileId);
+            if (!stream) {
+                throw new Error(`Failed to download file: ${objectName}`);
             }
+            // Convert stream to buffer
+            return new Promise((resolve, reject) => {
+                const chunks = [];
+                stream.on('data', (chunk) => chunks.push(chunk));
+                stream.on('error', reject);
+                stream.on('end', () => resolve(Buffer.concat(chunks)));
+            });
         }
         catch (error) {
             console.error('Error getting object', { objectName, error });
             throw new Error(`Failed to get object: ${objectName}`);
         }
     }
-    ;
     /**
      * Uploads a file to Box storage
      *
@@ -1240,30 +1176,44 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
                 }
             }
             // Check if file already exists
-            const fileId = await this._getIdFromPath(objectName);
-            const formData = new FormData();
-            // Add file metadata
-            const fileMetadata = {
-                name: parsedPath.name,
-                parent: { id: parentId }
-            };
-            formData.append('attributes', JSON.stringify(fileMetadata));
-            // Create a file blob with the correct content type
-            const fileBlob = new Blob([data], { type: contentType || 'application/octet-stream' });
-            formData.append('file', fileBlob, parsedPath.name);
-            // Upload the file
-            const endpoint = fileId ? `/files/${fileId}/content` : '/files/content';
-            console.log(`Uploading file using endpoint: ${endpoint}`);
+            let fileId = null;
             try {
-                await this._apiRequest(endpoint, 'POST', formData, {}, this._uploadApiUrl);
-                console.log(`✅ File uploaded successfully: ${objectName}`);
+                fileId = await this._getIdFromPath(objectName);
+            }
+            catch (error) {
+                // File doesn't exist, we'll upload as new
+            }
+            try {
+                // Convert Buffer to Readable stream for the SDK
+                const fileStream = stream_1.Readable.from(data);
+                if (fileId) {
+                    // Update existing file (upload new version)
+                    await this._client.uploads.uploadFileVersion(fileId, {
+                        attributes: {
+                            name: parsedPath.name
+                        },
+                        file: fileStream
+                    });
+                    console.log(`✅ File updated successfully: ${objectName}`);
+                }
+                else {
+                    // Upload new file
+                    await this._client.uploads.uploadFile({
+                        attributes: {
+                            name: parsedPath.name,
+                            parent: { id: parentId }
+                        },
+                        file: fileStream
+                    });
+                    console.log(`✅ File uploaded successfully: ${objectName}`);
+                }
                 return true;
             }
             catch (uploadError) {
-                console.error(`Error uploading file: ${uploadError.message}`);
-                if (uploadError.message && uploadError.message.includes('item_name_in_use')) {
+                console.error(`Error uploading file:`, uploadError);
+                if (uploadError.statusCode === 409) {
                     console.log(`File already exists (conflict): ${objectName}`);
-                    return false;
+                    return true;
                 }
                 return false;
             }
@@ -1307,8 +1257,11 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
     async CopyObject(sourceObjectName, destinationObjectName) {
         try {
             // Get source info
-            const sourceId = await this._getIdFromPath(sourceObjectName);
-            const sourceInfo = await this._apiRequest(`/items/${sourceId}`);
+            const sourceInfo = await this._getItemInfoFromPath(sourceObjectName);
+            if (!sourceInfo) {
+                console.log(`Source item not found: ${sourceObjectName}`);
+                return false;
+            }
             if (sourceInfo.type !== 'file') {
                 throw new Error('Only files can be copied with CopyObject');
             }
@@ -1325,8 +1278,8 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
                     destParentId = await this._getIdFromPath(destPath.parent);
                 }
             }
-            // Copy the file
-            await this._apiRequest(`/files/${sourceId}/copy`, 'POST', {
+            // Copy the file using SDK
+            await this._client.files.copyFile(sourceInfo.id, {
                 parent: { id: destParentId },
                 name: destPath.name
             });
@@ -1408,9 +1361,13 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
             try {
                 const folderId = await this._findFolderIdByPath(normalizedPath);
                 console.log(`✅ Directory ${normalizedPath} exists with ID: ${folderId}`);
-                // Make a direct call to verify it's a folder
+                // Make a direct call to verify it's a folder using SDK
                 try {
-                    const folderInfo = await this._apiRequest(`/folders/${folderId}`, 'GET');
+                    const folderInfo = await this._client.folders.getFolderById(folderId, {
+                        queryParams: {
+                            fields: ['type']
+                        }
+                    });
                     return folderInfo.type === 'folder';
                 }
                 catch (error) {
@@ -1461,13 +1418,15 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
                 let hasMoreItems = true;
                 const LIMIT = 1000;
                 while (hasMoreItems && !folder) {
-                    const items = await this._apiRequest(`/folders/${currentFolderId}/items`, 'GET', null, {
-                        'fields': 'name,type,id',
-                        'limit': `${LIMIT}`,
-                        'offset': `${offset}`
+                    const items = await this._client.folders.getFolderItems(currentFolderId, {
+                        queryParams: {
+                            fields: ['name', 'type', 'id'],
+                            limit: LIMIT,
+                            offset: offset
+                        }
                     });
                     // Filter to only folders
-                    const folders = items.entries.filter((item) => item.type === 'folder');
+                    const folders = items.entries?.filter((item) => item.type === 'folder') || [];
                     // Look for the target folder
                     folder = folders.find((item) => item.name === segment);
                     // If folder is found, break out of pagination loop
@@ -1475,11 +1434,11 @@ let BoxFileStorage = class BoxFileStorage extends FileStorageBase_1.FileStorageB
                         break;
                     }
                     // Update pagination variables
-                    offset += items.entries.length;
+                    offset += items.entries?.length || 0;
                     // Check if we've processed all items
-                    hasMoreItems = items.entries.length === LIMIT && offset < items.total_count;
+                    hasMoreItems = (items.entries?.length || 0) === LIMIT && offset < (items.totalCount || 0);
                 }
-                if (!folder) {
+                if (!folder || !folder.id) {
                     throw new Error(`Folder not found: ${segment}`);
                 }
                 currentFolderId = folder.id;