Exa Protocol ExaDrive SDK

https://exaprotocol.gitbook.io/home/
Admin
The ExaDrive SDK is a powerful, open-source TypeScript package that enables developers to seamlessly...
Tokens:6,146
Snippets:37
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Get All Files - Example

Source: https://exaprotocol.gitbook.io/home/getting-started/get-files

An example of how to call the getAllFiles() method and handle the promise response, logging the file data or any errors.

```javascript
exaDrive.getAllFiles()
  .then((res) => {
    console.log(res.data);
  })
  .catch((error) => {
    console.error('Failed to retrieve files:', error);
  });
```

--------------------------------

### Install ExaDrive SDK using npm

Source: https://exaprotocol.gitbook.io/home/getting-started/install-sdk

Installs the ExaDrive SDK package using the npm package manager. This is the standard way to add the SDK to a Node.js or frontend project.

```bash
npm install exadrive-sdk
```

--------------------------------

### Install ExaDrive SDK using Yarn

Source: https://exaprotocol.gitbook.io/home/getting-started/install-sdk

Installs the ExaDrive SDK package using the Yarn package manager. This command is an alternative for projects that utilize Yarn for dependency management.

```bash
yarn install exadrive-sdk
```

--------------------------------

### macOS Security Warning Example

Source: https://exaprotocol.gitbook.io/home/exacompute-desktop-app/download-and-install-desktop-app

Displays a typical macOS security warning encountered when trying to open a self-signed application, requiring user intervention to bypass Gatekeeper.

```text
Apple could not verify 'exa_protocol_client***.dmg' is free of malware that may harm your Mac or compromise your privacy.
```

--------------------------------

### Get Specific File - Example

Source: https://exaprotocol.gitbook.io/home/getting-started/get-files

An example of how to use the getFile() method with a file path and handle the promise, logging the file data or errors.

```javascript
exaDrive.getFile('/myapp1/images/file100.png')
  .then((res) => {
    console.log(res.data);
  })
  .catch((error) => {
    console.error('Failed to retrieve file:', error);
  });
```

--------------------------------

### Install ExaCompute Client on Ubuntu

Source: https://exaprotocol.gitbook.io/home/getting-started-with-exacompute/activate-your-rented-machine

This snippet shows the command to run the ExaCompute client installation script on an Ubuntu system after downloading the package. It requires root privileges.

```Shell
sudo ./exa-compute-client-linux
```

--------------------------------

### Implement File Syncing with Interval

Source: https://exaprotocol.gitbook.io/home/getting-started/get-files

An example of an asynchronous function to sync files from ExaDrive and a `setInterval` call to run the sync process periodically.

```javascript
const syncFiles = async () => {
  try {
    const files = await exaDrive.getAllFiles();
    // Update local storage or state with the latest file information
    updateLocalFileCache(files.data);
    console.log('File sync completed successfully');
  } catch (error) {
    console.error('File sync failed:', error);
  }
};

// Run sync every hour
setInterval(syncFiles, 3600000);
```

--------------------------------

### Import and Initialize ExaDrive SDK

Source: https://exaprotocol.gitbook.io/home/getting-started/install-sdk

Demonstrates how to import the ExaDrive class and initialize the SDK with provided APP_ID and API_KEY. This sets up the SDK for use within the application.

```javascript
import { ExaDrive } from 'exadrive-sdk';

const exaDrive = new ExaDrive(
      '<Your APP_ID>',
      '<Your API_KEY',
    );
```

--------------------------------

### Get All Files - Syntax

Source: https://exaprotocol.gitbook.io/home/getting-started/get-files

Shows the basic syntax for retrieving a list of all files stored in an ExaDrive.

```javascript
exaDrive.getAllFiles()
```

--------------------------------

### Update ExaDrive SDK using npm

Source: https://exaprotocol.gitbook.io/home/getting-started/best-practices

Ensures you are using the latest version of the ExaDrive SDK by updating it via npm. This command fetches and installs the most recent package version.

```bash
npm update exadrive-sdk
```

--------------------------------

### Get All Files

Source: https://exaprotocol.gitbook.io/home/getting-started/get-files

Retrieves a list of all files stored in your ExaDrive. Supports optional pagination parameters.

```APIDOC
## GET /files

### Description
Retrieves a list of all files stored in the ExaDrive. This method can be used with pagination parameters.

### Method
GET

### Endpoint
/files

### Parameters
#### Query Parameters
- **page** (integer) - Optional - The page number for pagination.
- **limit** (integer) - Optional - The number of files to retrieve per page.

### Request Example
```javascript
exadrive.getAllFiles({ page: 1, limit: 100 })
  .then((res) => {
    console.log(res.data);
  })
  .catch((error) => {
    console.error('Failed to retrieve files:', error);
  });
```

### Response
#### Success Response (200)
- **fileName** (string) - The name of the file.
- **fileDetails** (object) - An object containing file details:
  - **encoding** (string) - The file's encoding (e.g., "7bit").
  - **mimetype** (string) - The MIME type of the file.
  - **size** (integer) - The file size in bytes.
- **url** (string) - The URL where the file can be accessed.
- **directoryPath** (string) - The path to the directory where the file is stored.

#### Response Example
```json
[
  {
    "fileName": "file1.png",
    "fileDetails": {
      "encoding": "7bit",
      "mimetype": "image/png",
      "size": 411663
    },
    "url": "https://12345678-w3.exadrivecdn.com/myapp1/images/file1.png",
    "directoryPath": "/myapp1/images"
  }
]
```
```

--------------------------------

### Check ExaDrive SDK Version using npm

Source: https://exaprotocol.gitbook.io/home/getting-started/best-practices

Verifies the currently installed version of the ExaDrive SDK using the npm list command. This helps in identifying if the SDK is outdated.

```bash
npm list exadrive-sdk
```

--------------------------------

### Get Specific File - Syntax

Source: https://exaprotocol.gitbook.io/home/getting-started/get-files

Demonstrates the syntax for retrieving information about a single, specific file using its name.

```javascript
exaDrive.getFile(fileName)
```

--------------------------------

### Filter Files by Criteria

Source: https://exaprotocol.gitbook.io/home/getting-started/get-files

A JavaScript function to filter an array of file objects based on specified criteria like file type and size, demonstrated with an example call.

```javascript
const filterFiles = (files, criteria) => {
  return files.filter(file => {
    return (
      (!criteria.type || file.fileDetails.mimetype.includes(criteria.type)) &&
      (!criteria.minSize || file.fileDetails.size >= criteria.minSize) &&
      (!criteria.maxSize || file.fileDetails.size <= criteria.maxSize)
    );
  });
};

exaDrive.getAllFiles()
  .then((res) => {
    const imageFiles = filterFiles(res.data, { type: 'image', minSize: 100000 });
    console.log('Image files larger than 100KB:', imageFiles);
  })
  .catch((error) => {
    console.error('Failed to retrieve and filter files:', error);
  });
```

--------------------------------

### Get Specific File

Source: https://exaprotocol.gitbook.io/home/getting-started/get-files

Retrieves detailed information about a specific file identified by its name and path.

```APIDOC
## GET /files/{fileName}

### Description
Retrieves detailed information about a specific file. Requires the file name and its path.

### Method
GET

### Endpoint
/files/{fileName}

### Parameters
#### Path Parameters
- **fileName** (string) - Required - The name of the file to retrieve, including its directory path.

### Request Example
```javascript
exadrive.getFile('/myapp1/images/file100.png')
  .then((res) => {
    console.log(res.data);
  })
  .catch((error) => {
    console.error('Failed to retrieve file:', error);
  });
```

### Response
#### Success Response (200)
- **filename** (string) - The name of the file.
- **fileDetails** (object) - An object containing file details:
  - **encoding** (string) - The file's encoding (e.g., "7bit").
  - **mimetype** (string) - The MIME type of the file.
  - **size** (integer) - The file size in bytes.
- **url** (string) - The URL where the file can be accessed.
- **directoryPath** (string) - The path to the directory where the file is stored.

#### Response Example
```json
{
  "filename": "file100.png",
  "fileDetails": {
    "encoding": "7bit",
    "mimetype": "image/png",
    "size": 411663
  },
  "url": "https://12345678-w3.exadrivecdn.com/myapp1/images/file100.png",
  "directoryPath": "/myapp1/images"
}
```
```

--------------------------------

### Paginate File Retrieval

Source: https://exaprotocol.gitbook.io/home/getting-started/get-files

Provides an asynchronous JavaScript pattern for fetching files in batches (pages) to handle large datasets efficiently.

```javascript
const getFilesBatch = async (page = 1, limit = 100) => {
  try {
    const res = await exaDrive.getAllFiles({ page, limit });
    console.log(`Files (Page ${page}):`, res.data);
    return res.data;
  } catch (error) {
    console.error(`Failed to retrieve files (Page ${page}):`, error);
  }
};

const getAllFilesPaginated = async () => {
  let page = 1;
  let allFiles = [];
  let batch;
  do {
    batch = await getFilesBatch(page);
    allFiles = allFiles.concat(batch);
    page++;
  } while (batch && batch.length > 0);
  
  console.log('Total files retrieved:', allFiles.length);
  return allFiles;
};
```

--------------------------------

### Check for ExaDrive SDK Updates Automatically (JavaScript)

Source: https://exaprotocol.gitbook.io/home/getting-started/best-practices

A JavaScript function that checks for the latest version of the 'exadrive-sdk' from npm and compares it with the currently installed version. It uses `axios` for fetching data and `semver` for version comparison.

```javascript
const axios = require('axios');
const semver = require('semver');
const currentVersion = require('./package.json').dependencies['exadrive-sdk'];

async function checkForUpdates() {
  try {
    const response = await axios.get('https://registry.npmjs.org/exadrive-sdk');
    const latestVersion = response.data['dist-tags'].latest;
    
    if (semver.gt(latestVersion, currentVersion)) {
      console.log(`A new version of ExaDrive SDK is available: ${latestVersion}`);
      console.log('Run "npm update exadrive-sdk" to update.');
    } else {
      console.log('ExaDrive SDK is up to date.');
    }
  } catch (error) {
    console.error('Failed to check for updates:', error);
  }
}

// Run this check periodically or at application startup
checkForUpdates();
```

--------------------------------

### Delete File with User Confirmation (JavaScript)

Source: https://exaprotocol.gitbook.io/home/getting-started/delete-files

Adds a confirmation step before deleting a file to prevent accidental data loss. It uses a placeholder `promptUser` function to get user consent before proceeding with the deletion.

```javascript
const deleteWithConfirmation = async (directoryFilePath) => {
  const confirmation = await promptUser(`Are you sure you want to delete ${fileName}? (yes/no)`);
  if (confirmation.toLowerCase() === 'yes') {
    try {
      const result = await exaDrive.deleteFile(directoryFilePath);
      console.log(`File ${directoryFilePath} deleted successfully:`, result.data);
      return result.data;
    } catch (error) {
      console.error(`Failed to delete ${directoryFilePath}:`, error);
      throw error;
    }
  } else {
    console.log(`Deletion of ${directoryFilePath} cancelled.`);
    return { fileName, deleted: false, reason: 'User cancelled' };
  }
};

// Helper function to prompt user (implementation depends on your environment)
function promptUser(message) {
  // This is a placeholder. Implement according to your application's UI/UX
  return new Promise((resolve) => {
    // In a browser environment, you might use:
    // resolve(window.confirm(message) ? 'yes' : 'no');
    
    // In a Node.js CLI environment, you might use readline:
    // const readline = require('readline').createInterface({
    //   input: process.stdin,
    //   output: process.stdout
    // });
    // readline.question(message + ' ', (answer) => {
    //   readline.close();
    //   resolve(answer);
    // });
  });
}
```

--------------------------------

### Check ExaDrive API Network Connectivity

Source: https://exaprotocol.gitbook.io/home/getting-started/best-practices

Checks network connectivity to the ExaDrive API by making a GET request to a health check endpoint. It logs whether the connection is successful or indicates a connectivity issue.

```javascript
async function checkNetworkConnectivity() {
  try {
    await axios.get('https://api.exadrive.com/health'); // Replace with actual health check endpoint
    console.log('Network connection to ExaDrive API is successful');
  } catch (error) {
    console.error('Network connectivity issue:', error);
  }
}
```

--------------------------------

### Implement Logging with Winston for ExaDrive SDK

Source: https://exaprotocol.gitbook.io/home/getting-started/best-practices

Configures Winston logger for the ExaDrive SDK to handle logging effectively. It sets up file transports for 'error.log' and 'combined.log' with JSON formatting.

```javascript
const winston = require('winston');
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  defaultMeta: { service: 'exadrive-sdk' },
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});

// Use logger instead of console.log/error in your application
```

--------------------------------

### Batch Uploads with ExaDrive SDK

Source: https://exaprotocol.gitbook.io/home/getting-started/upload-files

Shows how to upload multiple files concurrently using `Promise.all` with the `uploadFile` method. This approach improves efficiency when uploading several files at once.

```javascript
const filePaths = ['file1.jpg', 'file2.pdf', 'file3.docx'];

Promise.all(filePaths.map(file => exaDrive.uploadFile(file, '/myapp1/images')))
  .then((results) => {
    results.forEach((res, index) => {
      console.log(`File ${index + 1} uploaded:`, res.data);
    });
  })
  .catch((error) => {
    console.error('One or more uploads failed:', error);
  });
```

--------------------------------

### Upload a Single File with ExaDrive SDK

Source: https://exaprotocol.gitbook.io/home/getting-started/upload-files

Demonstrates how to upload a single file using the `uploadFile` method of the ExaDrive SDK. This method takes the file path and directory path as arguments and returns a promise with upload details.

```javascript
exaDrive.uploadFile('path/to/file.png', '/myapp1/images')
  .then((res) => {
    console.log(res.data);
  })
  .catch((error) => {
    console.error('Upload failed:', error);
  });
```

--------------------------------

### Implement Try-Catch for ExaDrive SDK File Uploads (JavaScript)

Source: https://exaprotocol.gitbook.io/home/getting-started/best-practices

Demonstrates how to wrap ExaDrive SDK file upload operations in a try-catch block to gracefully handle potential errors, including server responses and network issues. It logs detailed error information and re-throws the error for further handling.

```javascript
async function uploadFile(filePath) {
  try {
    const result = await exaDrive.uploadFile(filePath);
    console.log('File uploaded successfully:', result);
    return result;
  } catch (error) {
    console.error('Error uploading file:', error.message);
    // Implement appropriate error handling logic
    if (error.response) {
      // The request was made and the server responded with a status code
      // that falls out of the range of 2xx
      console.error('Server responded with error:', error.response.data);
    } else if (error.request) {
      // The request was made but no response was received
      console.error('No response received from server');
    } else {
      // Something happened in setting up the request that triggered an Error
      console.error('Error setting up request:', error.message);
    }
    throw error; // Re-throw or handle as needed
  }
}
```

--------------------------------

### Integrate Image in HTML

Source: https://exaprotocol.gitbook.io/home/exadrive-dashboard/use-the-file-in-your-project

Shows how to use a file's public CDN URL to display an image within an HTML document.

```html
<img src="https://12345678-w3.exadrivecdn.com/file.png" alt="My Image">
```

--------------------------------

### Track ExaDrive SDK Large File Upload Progress (JavaScript)

Source: https://exaprotocol.gitbook.io/home/getting-started/best-practices

Shows how to implement progress tracking for large file uploads using the ExaDrive SDK. It utilizes the `onUploadProgress` callback to monitor the upload status and display the percentage completion.

```javascript
async function uploadLargeFile(filePath) {
  const fileSize = await getFileSize(filePath); // Implement this function
  let uploadedBytes = 0;

  try {
    await exaDrive.uploadFile(filePath, {
      onUploadProgress: (progressEvent) => {
        uploadedBytes = progressEvent.loaded;
        const percentCompleted = Math.round((uploadedBytes * 100) / fileSize);
        console.log(`Upload progress: ${percentCompleted}%`);
        // Update UI with progress
      }
    });
    console.log('Large file upload completed successfully');
  } catch (error) {
    console.error('Error uploading large file:', error);
    handleApiError(error);
  }
}
```

--------------------------------

### Validate ExaDrive SDK Credentials

Source: https://exaprotocol.gitbook.io/home/getting-started/best-practices

Asynchronously validates the provided API credentials (APP_ID and API_KEY) for the ExaDrive SDK. It logs success or failure messages to the console.

```javascript
async function validateCredentials() {
  try {
    await exaDrive.validateCredentials(); // Implement this method in your SDK
    console.log('Credentials are valid');
  } catch (error) {
    console.error('Invalid credentials:', error);
  }
}
```

--------------------------------

### Upload Multer File with ExaDrive SDK

Source: https://exaprotocol.gitbook.io/home/getting-started/upload-files

Demonstrates uploading a file directly from a Multer file object using the `uploadMulterFile` method. This is an alternative to `uploadFile` when working with Multer.

```javascript
exaDrive.uploadMulterFile(file: any, virtualDirectoryPath: string)
  .then(response => {
    console.log('Multer file uploaded successfully:', response);
  })
  .catch(error => {
    console.error('Error uploading Multer file:', error);
  });
```

--------------------------------

### Upload File with Buffer using ExaDrive SDK (JavaScript)

Source: https://exaprotocol.gitbook.io/home/getting-started/upload-files

The uploadFileWithBuffer function uploads file data directly from a memory buffer. It requires the file buffer, original filename, MIME type, and the desired virtual directory path. The function returns a Promise that resolves with the upload response or rejects with an error.

```javascript
exaDrive.uploadFileWithBuffer(buffer: Buffer, originalFileName: string, mimeType: string, virtualDirectoryPath: string)
  .then(response => {
    console.log('File uploaded with buffer successfully:', response);
  })
  .catch(error => {
    console.error('Error uploading file with buffer:', error);
  });
```

--------------------------------

### Automated File Cleanup Routine using ExaDrive SDK

Source: https://exaprotocol.gitbook.io/home/getting-started/delete-files

This JavaScript snippet demonstrates how to automatically clean up old files in ExaDrive. It defines a function `cleanupOldFiles` that filters files older than a specified number of days and then uses `batchDeleteFiles` for efficient deletion. The cleanup is scheduled to run weekly.

```javascript
const cleanupOldFiles = async (olderThanDays = 30) => {
  const allFiles = await exaDrive.getAllFiles();
  const now = new Date();
  const filesToDelete = allFiles.data.filter(file => {
    const fileDate = new Date(file.uploadDate); // Assuming there's an uploadDate field
    const daysDifference = (now - fileDate) / (1000 * 60 * 60 * 24);
    return daysDifference > olderThanDays;
  });

  return batchDeleteFiles(filesToDelete.map(file => file.fileName));
};

// Run cleanup every week
setInterval(() => cleanupOldFiles(30), 7 * 24 * 60 * 60 * 1000);
```

--------------------------------

### Custom API Error Handling for Exa Protocol (JavaScript)

Source: https://exaprotocol.gitbook.io/home/getting-started/best-practices

Provides a custom function to handle specific API errors returned by the Exa Protocol, such as authentication failures (401), forbidden access (403), and rate limiting (429). It also includes general handling for network errors.

```javascript
function handleApiError(error) {
  if (error.response) {
    switch (error.response.status) {
      case 401:
        console.error('Authentication failed. Please check your APP_ID and API_KEY.');
        // Implement logic to refresh authentication or prompt for new credentials
        break;
      case 403:
        console.error('Access forbidden. Your account may not have the necessary permissions.');
        break;
      case 429:
        console.error('Rate limit exceeded. Please try again later.');
        // Implement retry logic with exponential backoff
        break;
      default:
        console.error('An unexpected error occurred:', error.response.data);
    }
  } else {
    console.error('Network error:', error.message);
  }
}
```

--------------------------------

### Upload File with Buffer

Source: https://exaprotocol.gitbook.io/home/getting-started/upload-files

The `uploadFileWithBuffer` function allows direct upload of file data from memory (Buffer) to ExaDrive, specifying the original filename, MIME type, and target virtual directory path.

```APIDOC
## POST /upload/buffer

### Description
Uploads a file directly from a memory buffer to ExaDrive.

### Method
POST

### Endpoint
`/upload/buffer`

### Parameters
#### Request Body
- **buffer** (Buffer) - Required - The buffer containing the file data.
- **originalFileName** (string) - Required - The original name of the file.
- **mimeType** (string) - Required - The mime-type of the file.
- **virtualDirectoryPath** (string) - Required - The virtual path for the file's directory.

### Request Example
```json
{
  "buffer": "<base64_encoded_buffer>",
  "originalFileName": "myImage.png",
  "mimeType": "image/png",
  "virtualDirectoryPath": "/images/uploads"
}
```

### Response
#### Success Response (200)
- **filename** (string) - The name of the uploaded file.
- **fileDetails** (object) - Details about the uploaded file, including encoding, mimetype, and size.
  - **encoding** (string) - The file's encoding.
  - **mimetype** (string) - The file's MIME type.
  - **size** (integer) - The size of the file in bytes.
- **url** (string) - The URL to access the uploaded file.

#### Response Example
```json
{
  "filename": "myImage.png",
  "fileDetails": {
    "encoding": "7bit",
    "mimetype": "image/png",
    "size": 411663
  },
  "url": "https://12345678-w3.exadrivecdn.com/myapp1/images/myImage.png"
}
```
```

--------------------------------

### Upload File with Retry Mechanism

Source: https://exaprotocol.gitbook.io/home/getting-started/upload-files

Provides a robust function `uploadWithRetry` that handles file uploads with automatic retries in case of failure. It includes a configurable number of retries and a delay between attempts.

```javascript
const uploadWithRetry = async (filePath, directoryPath, maxRetries = 3) => {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const result = await exaDrive.uploadFile(filePath, directoryPath);
      return result;
    } catch (error) {
      if (attempt === maxRetries) throw error;
      console.log(`Upload attempt ${attempt} failed, retrying...`);
      await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
    }
  }
};
```

--------------------------------

### Delete Multiple Files from ExaDrive (JavaScript)

Source: https://exaprotocol.gitbook.io/home/getting-started/delete-files

Provides an asynchronous function to delete multiple files from ExaDrive by iterating through a list of file paths and calling `deleteFile` for each. It handles success and error logging for each deletion attempt.

```javascript
const deleteMultipleFiles = async (directoryFilePath) => {
  const results = [];
  for (const fileName of fileNames) {
    try {
      const result = await exaDrive.deleteFile(directoryFilePath);
      results.push(result.data);
      console.log(`Successfully deleted ${directoryFilePath}`);
    } catch (error) {
      console.error(`Failed to delete ${directoryFilePath}:`, error);
      results.push({ fileName, deleted: false, error: error.message });
    }
  }
  return results;
};

// Usage
const filesToDelete = ['/myapp1/images/file1.png', '/myapp1/images/file2.jpg', '/myapp1/images/file3.pdf'];
deleteMultipleFiles(filesToDelete)
  .then((results) => {
    console.log('Deletion results:', results);
  })
  .catch((error) => {
    console.error('Error in deletion process:', error);
  });
```

--------------------------------

### Delete a Single File from ExaDrive (JavaScript)

Source: https://exaprotocol.gitbook.io/home/getting-started/delete-files

Demonstrates how to delete a single file from ExaDrive storage using the `deleteFile` method. This function takes a file path as input and returns a promise that resolves with a confirmation object upon successful deletion.

```javascript
exaDrive.deleteFile('/myapp1/images/file1000.png')
  .then((res) => {
    console.log(res.data);
  })
  .catch((error) => {
    console.error('Failed to delete file:', error);
  });
```

--------------------------------

### Batch Delete Files with Concurrency (JavaScript)

Source: https://exaprotocol.gitbook.io/home/getting-started/delete-files

Implements a batch deletion function with concurrency control to efficiently delete multiple files from ExaDrive. It uses a queue and a fixed number of concurrent workers to manage deletion requests.

```javascript
const batchDeleteFiles = async (fileNames, concurrency = 5) => {
  const results = [];
  const queue = [...fileNames];
  const workers = new Array(concurrency).fill(queue.shift());

  const deleteFile = async (directoryFilePath) => {
    if (!fileName) return;
    try {
      const result = await exaDrive.deleteFile(directoryFilePath);
      results.push(result.data);
      console.log(`Successfully deleted ${directoryFilePath}`);
    } catch (error) {
      console.error(`Failed to delete ${directoryFilePath}:`, error);
      results.push({ fileName, deleted: false, error: error.message });
    }
    return deleteFile(queue.shift());
  };

  await Promise.all(workers.map(deleteFile));
  return results;
};

// Usage
// if you don't send any directory then the file will automatically go to the root folder
const filesToDelete = ['file1.png', 'file2.jpg', 'file3.pdf', /* ... more files */];
batchDeleteFiles(filesToDelete)
  .then((results) => {
    console.log('Batch deletion results:', results);
  })
  .catch((error) => {
    console.error('Error in batch deletion process:', error);
  });
```

--------------------------------

### Update File CDN Availability with ExaDrive

Source: https://exaprotocol.gitbook.io/home/getting-started/update-file

The `updateFile` function updates an existing file's public CDN availability in ExaDrive storage. It takes the virtual file path and a boolean to enable or disable the CDN. The function returns a promise that resolves with a success message or rejects with an error.

```javascript
exaDrive.updateFile(virtualFilePath: string, enableCDN: boolean)
  .then(response => {
    console.log('File updated successfully:', response);
  })
  .catch(error => {
    console.error('Error updating file:', error);
  });
```

--------------------------------

### Update File

Source: https://exaprotocol.gitbook.io/home/getting-started/update-file

Updates an existing file's public CDN availability in ExaDrive storage by enabling or disabling it.

```APIDOC
## Update File

### Description
Updates an existing file's public CDN availability in ExaDrive storage. You can enable or disable it.

### Method
POST (Assumed, as it modifies data)

### Endpoint
`/files/update` (Assumed, based on functionality)

### Parameters
#### Request Body
- **virtualFilePath** (string) - Required - The virtual path of the file you want to update.
- **enableCDN** (boolean) - Required - Boolean field to enable or disable the public CDN link.

### Request Example
```json
{
  "virtualFilePath": "/path/to/your/file.txt",
  "enableCDN": true
}
```

### Response
#### Success Response (200)
- **message** (string) - The virtual path of the updated file.
- **enableCDN** (boolean) - The CDN availability status.

#### Response Example
```json
{
  "message": "/path/to/your/file.txt",
  "enableCDN": true
}
```
```
Tokens:
Raw