The ExaDrive SDK provides functionality to delete files from your ExaDrive storage. This feature allows you to manage your storage space efficiently by removing unnecessary files.
Deleting a Single File
To delete a specific file from ExaDrive, use the deleteFile() method.
Syntax
Copy exaDrive.deleteFile(directoryPath)
fileName: A string representing the name of the file you want to delete.
Example
Copy exaDrive.deleteFile('/myapp1/images/file1000.png')
.then((res) => {
console.log(res.data);
})
.catch((error) => {
console.error('Failed to delete file:', error);
}); Response Structure
The method returns a promise that resolves with an object confirming the deletion of the file.
Copy {
"fileName": "/myapp1/images/file1000.png",
"deleted": true
} Response Fields
fileName : The name of the deleted file.
deleted : A boolean indicating whether the file was successfully deleted.
Deleting Multiple Files
To delete multiple files, you need to send separate requests for each file. Here's an example of how to delete multiple files:
Copy 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);
}); Advanced Usage
Batch Deletion with Concurrency Control
For improved performance when deleting multiple files, you can implement a batch deletion function with concurrency control:
Copy 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);
}); Deletion with Confirmation
Implement a confirmation step before deleting files to prevent accidental deletions:
Copy 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);
// });
});
} Best Practices
Error Handling : Always include robust error handling to manage potential failures during the deletion process.
Confirmation : Implement a confirmation step for critical or irreversible deletions to prevent accidental data loss.
Logging : Maintain logs of deletion operations for auditing and troubleshooting purposes.
Batch Processing : When deleting multiple files, use batch processing with concurrency control to optimize performance and respect API rate limits.
Cleanup Routines : Implement regular cleanup routines to automatically delete unnecessary or temporary files:
Copy 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);
Soft Delete : Consider implementing a "soft delete" feature in your application logic, where files are marked as deleted but not immediately removed from storage. This can provide a safety net for accidental deletions.
By following these practices and utilizing the deletion capabilities of the ExaDrive SDK, you can effectively manage your file storage and maintain an organized ExaDrive environment.
