// DELETE /files?ids=id1,id2,id3
const response = await fetch("/files?ids=id1,id2,id3", {
    method: "DELETE",
});

// Response includes:
// - X-Delete-Successful: Number of successful deletions
// - X-Delete-Failed: Number of failed deletions
// - X-Delete-Errors: JSON array of errors (if any)

// DELETE /files
// Body: { "ids": ["id1", "id2", "id3"] }
const response = await fetch("/files", {
    method: "DELETE",
    headers: {
        "Content-Type": "application/json",
    },
    body: JSON.stringify({
        ids: ["id1", "id2", "id3"],
    }),
});

// DELETE /files
// Body: ["id1", "id2", "id3"]
const response = await fetch("/files", {
    method: "DELETE",
    headers: {
        "Content-Type": "application/json",
    },
    body: JSON.stringify(["id1", "id2", "id3"]),
});

// Status: 204 (No Content) - All deletions successful
// Status: 207 (Multi-Status) - Partial success

// Headers:
// X-Delete-Successful: 2
// X-Delete-Failed: 1
// X-Delete-Errors: [{"error":"File not found","id":"id3"}]

// Body: Array of successfully deleted files
[
    { id: "id1", status: "deleted", ... },
    { id: "id2", status: "deleted", ... },
]

const response = await fetch("/files?ids=id1,id2,id3", {
    method: "DELETE",
});

const successful = parseInt(response.headers.get("X-Delete-Successful") || "0");
const failed = parseInt(response.headers.get("X-Delete-Failed") || "0");

if (failed > 0) {
    const errors = JSON.parse(response.headers.get("X-Delete-Errors") || "[]");
    console.error("Failed deletions:", errors);
}

if (successful > 0) {
    const deletedFiles = await response.json();
    console.log("Successfully deleted:", deletedFiles.length);
}

import express from "express";
import { DiskStorage } from "@visulima/storage";

const app = express();
const storage = new DiskStorage({ directory: "./uploads" });
const rest = new Rest({ storage });

// Batch delete endpoint
app.delete("/files", rest.handle, (req, res) => {
    // Response is automatically handled by the handler
    // Check headers for deletion status
    const successful = res.getHeader("X-Delete-Successful");
    const failed = res.getHeader("X-Delete-Failed");

    console.log(`Deleted: ${successful}, Failed: ${failed}`);
});

import { DiskStorage } from "@visulima/storage";

const storage = new DiskStorage({ directory: "./uploads" });

// Delete multiple files
const result = await storage.deleteBatch(["id1", "id2", "id3"]);

console.log(`Successful: ${result.successfulCount}, Failed: ${result.failedCount}`);
console.log("Successful files:", result.successful);
console.log("Failed operations:", result.failed);

// Copy multiple files
const result = await storage.copyBatch([
    { source: "file1.jpg", destination: "backup/file1.jpg" },
    { source: "file2.jpg", destination: "backup/file2.jpg", options: { storageClass: "STANDARD_IA" } },
    { source: "file3.jpg", destination: "backup/file3.jpg" },
]);

console.log(`Copied: ${result.successfulCount}, Failed: ${result.failedCount}`);

// Move multiple files
const result = await storage.moveBatch([
    { source: "temp/file1.jpg", destination: "permanent/file1.jpg" },
    { source: "temp/file2.jpg", destination: "permanent/file2.jpg" },
]);

console.log(`Moved: ${result.successfulCount}, Failed: ${result.failedCount}`);

interface BatchOperationResponse<T extends File> {
    /** Successfully processed files */
    successful: T[];
    /** Failed operations with error details */
    failed: Array<{ error: string; id: string }>;
    /** Total number of successful operations */
    successfulCount: number;
    /** Total number of failed operations */
    failedCount: number;
}

try {
    const result = await storage.deleteBatch(["id1", "id2", "id3"]);

    if (result.failedCount > 0) {
        console.warn(`${result.failedCount} operations failed:`, result.failed);
    }

    if (result.successfulCount > 0) {
        console.log(`Successfully processed ${result.successfulCount} files`);
    }
} catch (error) {
    console.error("Batch operation error:", error);
}

// Batch update metadata
async function batchUpdateMetadata(files: Array<{ id: string; metadata: Record<string, any> }>) {
    const results = await Promise.allSettled(files.map(({ id, metadata }) => storage.update({ id }, metadata)));

    return results;
}