fix(browser): delete selected versions with standard S3 APIs

Author: cxymds

components/object/list.tsx

@@ -63,7 +63,7 @@ import {
 import { OBJECT_LIST_DEFAULT_PAGE_SIZE, resolveObjectListPageSize } from "@/lib/object-list-pagination"
 import {
   resolveBucketVersioningState,
-  shouldForceDeleteObjects,
+  shouldDeleteAllVersions,
   shouldShowDeleteAllVersions,
   type BucketVersioningState,
 } from "@/lib/object-delete"
@@ -715,7 +715,7 @@ export function ObjectList({
     setDeleteDialogOpen(false)
     if (!keys.length) return
 
-    if (shouldForceDeleteObjects(bucketVersioningState, deleteAllVersions)) {
+    if (shouldDeleteAllVersions(bucketVersioningState, deleteAllVersions)) {
       await handleDeleteAllVersions(keys)
     } else {
       await handleDelete(keys)
@@ -767,7 +767,7 @@ export function ObjectList({
       }
 
       if (objectKeys.length > 0) {
-        addDeleteKeys(objectKeys, bucket, undefined, { forceDelete: true })
+        addDeleteKeys(objectKeys, bucket, undefined, { deleteAllVersions: true })
       }
       for (const prefix of folderPrefixes) {
         addDeleteFolder(prefix, bucket, { forceDelete: true })

contexts/task-context.tsx

@@ -24,7 +24,12 @@ const emptyManager: TaskManagerApi<AnyTask> = {
 const TaskContext = React.createContext<{
   taskManager: TaskManagerApi<AnyTask>
   addUploadFiles: (items: { file: File; key: string }[], bucketName: string) => void
-  addDeleteKeys: (keys: string[], bucketName: string, prefix?: string, options?: { forceDelete?: boolean }) => void
+  addDeleteKeys: (
+    keys: string[],
+    bucketName: string,
+    prefix?: string,
+    options?: { deleteAllVersions?: boolean },
+  ) => void
   addDeleteFolder: (prefix: string, bucketName: string, options?: { forceDelete?: boolean }) => void
   isTaskPanelOpen: boolean
   setTaskPanelOpen: (open: boolean) => void
@@ -101,7 +106,7 @@ export function TaskProvider({ children }: { children: React.ReactNode }) {
   )
 
   const addDeleteKeys = React.useCallback(
-    (keys: string[], bucketName: string, prefix?: string, options?: { forceDelete?: boolean }) => {
+    (keys: string[], bucketName: string, prefix?: string, options?: { deleteAllVersions?: boolean }) => {
       if (!managerState) return
       const { manager, deleteHelpers } = managerState
       const newTasks = deleteHelpers.createTasks(keys, bucketName, prefix, options)

lib/delete-task.ts

@@ -17,7 +17,7 @@ export interface DeleteTask extends ManagedTask<DeleteStatus> {
   bucketName: string
   prefix?: string
   versionId?: string
-  forceDelete?: boolean
+  deleteAllVersions?: boolean
   actionLabel: string
   displayName: string
   subInfo: string
@@ -47,13 +47,12 @@ export interface DeleteTaskHelpers {
     keys: string[],
     bucketName: string,
     prefix?: string,
-    options?: { forceDelete?: boolean },
+    options?: { deleteAllVersions?: boolean },
   ) => DeleteTask[]
   createVersionedTasks: (
     items: { key: string; versionId?: string }[],
     bucketName: string,
     prefix?: string,
-    options?: { forceDelete?: boolean },
   ) => DeleteTask[]
   createFolderDeleteTask: (prefix: string, bucketName: string, options?: { forceDelete?: boolean }) => FolderDeleteTask
 }
@@ -73,7 +72,7 @@ function assertDeleteObjectsSucceeded(errors: { Key?: string; Code?: string; Mes
   throw new Error(first?.Message || first?.Code || `Failed to delete ${errors.length} object(s)${target}`)
 }
 
-function attachForceDeleteHeader(command: DeleteObjectCommand | DeleteObjectsCommand) {
+function attachForceDeleteHeader(command: DeleteObjectCommand) {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ;(command.middlewareStack.add as any)(
     (next: (args: unknown) => Promise<unknown>) => async (args: { request?: { headers?: Record<string, string> } }) => {
@@ -91,67 +90,74 @@ export function createDeleteTaskHelpers(s3Client: S3Client, config: DeleteTaskCo
   const retryDelay = config.retryDelay ?? 1000
 
   const perform: TaskHandler<DeleteTask>["perform"] = async (task) => {
-    const { key, bucketName, prefix, versionId, forceDelete } = task
-    const abortController = new AbortController()
-    task.abortController = abortController
-
-    const command = new DeleteObjectCommand({
-      Bucket: bucketName,
-      Key: (prefix ?? "") + key,
-      ...(versionId ? { VersionId: versionId } : {}),
-    })
-
-    if (forceDelete) attachForceDeleteHeader(command)
-
-    await s3Client.send(command, { abortSignal: abortController.signal })
-    task.progress = 100
-  }
-
-  const performFolder: TaskHandler<FolderDeleteTask>["perform"] = async (task) => {
-    const { bucketName, prefix, forceDelete } = task
+    const { key, bucketName, prefix, versionId, deleteAllVersions } = task
     const abortController = new AbortController()
     task.abortController = abortController
 
-    if (forceDelete) {
-      let isTruncated = true
+    if (deleteAllVersions && !versionId) {
+      // The recursive extension also covers child keys. A file selection must
+      // delete only the versions listed for this exact key, including markers.
+      const objectKey = (prefix ?? "") + key
+      const versions: { Key: string; VersionId: string }[] = []
       let keyMarker: string | undefined
       let versionIdMarker: string | undefined
-
-      while (isTruncated) {
+      while (true) {
         const data = await s3Client.send(
           new ListObjectVersionsCommand({
             Bucket: bucketName,
-            Prefix: prefix,
+            Prefix: objectKey,
             KeyMarker: keyMarker,
             VersionIdMarker: versionIdMarker,
             EncodingType: "url",
           }),
           { abortSignal: abortController.signal },
         )
         decodeS3UrlEncodedObjectVersions(data)
-
-        const objectsToDelete: { Key: string; VersionId?: string }[] = []
-        data.Versions?.forEach((v) => {
-          if (v.Key) objectsToDelete.push({ Key: v.Key, VersionId: v.VersionId })
-        })
-        data.DeleteMarkers?.forEach((m) => {
-          if (m.Key) objectsToDelete.push({ Key: m.Key, VersionId: m.VersionId })
-        })
-
-        if (objectsToDelete.length > 0) {
-          const command = new DeleteObjectsCommand({
-            Bucket: bucketName,
-            Delete: { Objects: objectsToDelete, Quiet: true },
-          })
-          attachForceDeleteHeader(command)
-          const result = await s3Client.send(command, { abortSignal: abortController.signal })
-          assertDeleteObjectsSucceeded(result.Errors)
+        for (const version of [...(data.Versions ?? []), ...(data.DeleteMarkers ?? [])]) {
+          if (version.Key !== objectKey) continue
+          if (!version.VersionId) throw new Error("Object version listing did not return a version ID")
+          versions.push({ Key: objectKey, VersionId: version.VersionId })
+        }
+        if (!data.IsTruncated || (data.NextKeyMarker && data.NextKeyMarker !== objectKey)) break
+        if (!data.NextKeyMarker || (data.NextKeyMarker === keyMarker && data.NextVersionIdMarker === versionIdMarker)) {
+          throw new Error("Object version listing did not advance")
         }
-
-        isTruncated = data.IsTruncated ?? false
         keyMarker = data.NextKeyMarker
         versionIdMarker = data.NextVersionIdMarker
       }
+      for (let offset = 0; offset < versions.length; offset += 1000) {
+        const result = await s3Client.send(
+          new DeleteObjectsCommand({
+            Bucket: bucketName,
+            Delete: { Objects: versions.slice(offset, offset + 1000), Quiet: true },
+          }),
+          { abortSignal: abortController.signal },
+        )
+        assertDeleteObjectsSucceeded(result.Errors)
+      }
+      task.progress = 100
+      return
+    }
+
+    const command = new DeleteObjectCommand({
+      Bucket: bucketName,
+      Key: (prefix ?? "") + key,
+      ...(versionId ? { VersionId: versionId } : {}),
+    })
+
+    await s3Client.send(command, { abortSignal: abortController.signal })
+    task.progress = 100
+  }
+
+  const performFolder: TaskHandler<FolderDeleteTask>["perform"] = async (task) => {
+    const { bucketName, prefix, forceDelete } = task
+    const abortController = new AbortController()
+    task.abortController = abortController
+
+    if (forceDelete) {
+      const command = new DeleteObjectCommand({ Bucket: bucketName, Key: prefix })
+      attachForceDeleteHeader(command)
+      await s3Client.send(command, { abortSignal: abortController.signal })
     } else {
       let isTruncated = true
       let continuationToken: string | undefined
@@ -189,9 +195,21 @@ export function createDeleteTaskHelpers(s3Client: S3Client, config: DeleteTaskCo
   const shouldRetry = (task: DeleteTask | FolderDeleteTask, error: unknown) => {
     if (task.status === lifecycle.canceled) return false
     if ((task.retryCount ?? 0) >= maxRetries) return false
-    const errorMessage = String((error as Error)?.message ?? "").toLowerCase()
-    const nonRetryableErrors = ["access denied", "forbidden", "invalid credentials", "bucket not found", "no such key"]
-    return !nonRetryableErrors.some((msg) => errorMessage.includes(msg))
+    const errorRecord = error as { name?: unknown; code?: unknown; Code?: unknown; message?: unknown }
+    const errorText = [errorRecord?.name, errorRecord?.code, errorRecord?.Code, errorRecord?.message]
+      .filter((value): value is string => typeof value === "string")
+      .join(" ")
+      .toLowerCase()
+      .replace(/[\s_-]+/g, "")
+    const nonRetryableErrors = [
+      "accessdenied",
+      "forbidden",
+      "invalidcredentials",
+      "bucketnotfound",
+      "nosuchbucket",
+      "nosuchkey",
+    ]
+    return !nonRetryableErrors.some((code) => errorText.includes(code))
   }
 
   const handler: TaskHandler<DeleteTask> = {
@@ -215,7 +233,7 @@ export function createDeleteTaskHelpers(s3Client: S3Client, config: DeleteTaskCo
   }
 
   const createTasksFromItems = (
-    items: { key: string; versionId?: string; forceDelete?: boolean }[],
+    items: { key: string; versionId?: string; deleteAllVersions?: boolean }[],
     bucketName: string,
     prefix?: string,
   ): DeleteTask[] =>
@@ -224,7 +242,7 @@ export function createDeleteTaskHelpers(s3Client: S3Client, config: DeleteTaskCo
       kind: "delete" as const,
       key: item.key,
       versionId: item.versionId,
-      forceDelete: item.forceDelete,
+      deleteAllVersions: item.deleteAllVersions,
       status: lifecycle.pending,
       progress: 0,
       bucketName,
@@ -237,25 +255,21 @@ export function createDeleteTaskHelpers(s3Client: S3Client, config: DeleteTaskCo
       retryCount: 0,
     }))
 
-  const createTasks = (keys: string[], bucketName: string, prefix?: string, options?: { forceDelete?: boolean }) =>
-    createTasksFromItems(
-      keys.map((key) => ({ key, forceDelete: options?.forceDelete })),
-      bucketName,
-      prefix,
-    )
-
-  const createVersionedTasks = (
-    items: { key: string; versionId?: string }[],
+  const createTasks = (
+    keys: string[],
     bucketName: string,
     prefix?: string,
-    options?: { forceDelete?: boolean },
+    options?: { deleteAllVersions?: boolean },
   ) =>
     createTasksFromItems(
-      items.map((item) => ({ ...item, forceDelete: options?.forceDelete })),
+      keys.map((key) => ({ key, deleteAllVersions: options?.deleteAllVersions })),
       bucketName,
       prefix,
     )
 
+  const createVersionedTasks = (items: { key: string; versionId?: string }[], bucketName: string, prefix?: string) =>
+    createTasksFromItems(items, bucketName, prefix)
+
   const createFolderDeleteTask = (
     prefix: string,
     bucketName: string,

lib/object-delete.ts

@@ -8,6 +8,6 @@ export function shouldShowDeleteAllVersions(state: BucketVersioningState): boole
   return state === "enabled"
 }
 
-export function shouldForceDeleteObjects(state: BucketVersioningState, deleteAllVersions: boolean): boolean {
+export function shouldDeleteAllVersions(state: BucketVersioningState, deleteAllVersions: boolean): boolean {
   return state === "enabled" && deleteAllVersions
 }