@aws-sdk/lib-storage 3.577.0 → 3.582.0

package/README.md

@@ -16,12 +16,23 @@ try {
     client: new S3({}) || new S3Client({}),
     params: { Bucket, Key, Body },
 
+    // optional tags
     tags: [
       /*...*/
-    ], // optional tags
-    queueSize: 4, // optional concurrency configuration
-    partSize: 1024 * 1024 * 5, // optional size of each part, in bytes, at least 5MB
-    leavePartsOnError: false, // optional manually handle dropped parts
+    ],
+
+    // additional optional fields show default values below:
+
+    // (optional) concurrency configuration
+    queueSize: 4,
+
+    // (optional) size of each part, in bytes, at least 5MB
+    partSize: 1024 * 1024 * 5,
+
+    // (optional) when true, do not automatically call AbortMultipartUpload when
+    // a multipart upload fails to complete. You should then manually handle
+    // the leftover parts.
+    leavePartsOnError: false,
   });
 
   parallelUploads3.on("httpUploadProgress", (progress) => {

package/dist-cjs/index.js

@@ -69,7 +69,7 @@ async function* getChunkStream(data, partSize, getNextData) {
   for await (const datum of getNextData(data)) {
     currentBuffer.chunks.push(datum);
     currentBuffer.length += datum.byteLength;
-    while (currentBuffer.length >= partSize) {
+    while (currentBuffer.length > partSize) {
       const dataChunk = currentBuffer.chunks.length > 1 ? import_buffer.Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0];
       yield {
         partNumber,
@@ -175,7 +175,7 @@ var _Upload = class _Upload extends import_events.EventEmitter {
   constructor(options) {
     super();
     /**
-     * S3 multipart upload does not allow more than 10000 parts.
+     * S3 multipart upload does not allow more than 10,000 parts.
      */
     this.MAX_PARTS = 1e4;
     // Defaults.
@@ -184,8 +184,11 @@ var _Upload = class _Upload extends import_events.EventEmitter {
     this.leavePartsOnError = false;
     this.tags = [];
     this.concurrentUploaders = [];
+    this.abortMultipartUploadCommand = null;
     this.uploadedParts = [];
+    this.uploadEnqueuedPartsCount = 0;
     this.isMultiPart = true;
+    this.sent = false;
     this.queueSize = options.queueSize || this.queueSize;
     this.partSize = options.partSize || this.partSize;
     this.leavePartsOnError = options.leavePartsOnError || this.leavePartsOnError;
@@ -201,6 +204,12 @@ var _Upload = class _Upload extends import_events.EventEmitter {
     this.abortController.abort();
   }
   async done() {
+    if (this.sent) {
+      throw new Error(
+        "@aws-sdk/lib-storage: this instance of Upload has already executed .done(). Create a new instance."
+      );
+    }
+    this.sent = true;
     return await Promise.race([this.__doMultipartUpload(), this.__abortTimeout(this.abortController.signal)]);
   }
   on(event, listener) {
@@ -275,84 +284,49 @@ var _Upload = class _Upload extends import_events.EventEmitter {
   async __createMultipartUpload() {
     if (!this.createMultiPartPromise) {
       const createCommandParams = { ...this.params, Body: void 0 };
-      this.createMultiPartPromise = this.client.send(new import_client_s3.CreateMultipartUploadCommand(createCommandParams));
+      this.createMultiPartPromise = this.client.send(new import_client_s3.CreateMultipartUploadCommand(createCommandParams)).then((createMpuResponse) => {
+        this.abortMultipartUploadCommand = new import_client_s3.AbortMultipartUploadCommand({
+          Bucket: this.params.Bucket,
+          Key: this.params.Key,
+          UploadId: createMpuResponse.UploadId
+        });
+        return createMpuResponse;
+      });
     }
     return this.createMultiPartPromise;
   }
   async __doConcurrentUpload(dataFeeder) {
     for await (const dataPart of dataFeeder) {
-      if (this.uploadedParts.length > this.MAX_PARTS) {
+      if (this.uploadEnqueuedPartsCount > this.MAX_PARTS) {
         throw new Error(
-          `Exceeded ${this.MAX_PARTS} as part of the upload to ${this.params.Key} and ${this.params.Bucket}.`
+          `Exceeded ${this.MAX_PARTS} parts in multipart upload to Bucket: ${this.params.Bucket} Key: ${this.params.Key}.`
         );
       }
-      try {
+      if (this.abortController.signal.aborted) {
+        return;
+      }
+      if (dataPart.partNumber === 1 && dataPart.lastPart) {
+        return await this.__uploadUsingPut(dataPart);
+      }
+      if (!this.uploadId) {
+        const { UploadId } = await this.__createMultipartUpload();
+        this.uploadId = UploadId;
         if (this.abortController.signal.aborted) {
           return;
         }
-        if (dataPart.partNumber === 1 && dataPart.lastPart) {
-          return await this.__uploadUsingPut(dataPart);
-        }
-        if (!this.uploadId) {
-          const { UploadId } = await this.__createMultipartUpload();
-          this.uploadId = UploadId;
-          if (this.abortController.signal.aborted) {
-            return;
-          }
-        }
-        const partSize = byteLength(dataPart.data) || 0;
-        const requestHandler = this.client.config.requestHandler;
-        const eventEmitter = requestHandler instanceof import_events.EventEmitter ? requestHandler : null;
-        let lastSeenBytes = 0;
-        const uploadEventListener = /* @__PURE__ */ __name((event, request) => {
-          const requestPartSize = Number(request.query["partNumber"]) || -1;
-          if (requestPartSize !== dataPart.partNumber) {
-            return;
-          }
-          if (event.total && partSize) {
-            this.bytesUploadedSoFar += event.loaded - lastSeenBytes;
-            lastSeenBytes = event.loaded;
-          }
-          this.__notifyProgress({
-            loaded: this.bytesUploadedSoFar,
-            total: this.totalBytes,
-            part: dataPart.partNumber,
-            Key: this.params.Key,
-            Bucket: this.params.Bucket
-          });
-        }, "uploadEventListener");
-        if (eventEmitter !== null) {
-          eventEmitter.on("xhr.upload.progress", uploadEventListener);
-        }
-        const partResult = await this.client.send(
-          new import_client_s3.UploadPartCommand({
-            ...this.params,
-            UploadId: this.uploadId,
-            Body: dataPart.data,
-            PartNumber: dataPart.partNumber
-          })
-        );
-        if (eventEmitter !== null) {
-          eventEmitter.off("xhr.upload.progress", uploadEventListener);
-        }
-        if (this.abortController.signal.aborted) {
+      }
+      const partSize = byteLength(dataPart.data) || 0;
+      const requestHandler = this.client.config.requestHandler;
+      const eventEmitter = requestHandler instanceof import_events.EventEmitter ? requestHandler : null;
+      let lastSeenBytes = 0;
+      const uploadEventListener = /* @__PURE__ */ __name((event, request) => {
+        const requestPartSize = Number(request.query["partNumber"]) || -1;
+        if (requestPartSize !== dataPart.partNumber) {
           return;
         }
-        if (!partResult.ETag) {
-          throw new Error(
-            `Part ${dataPart.partNumber} is missing ETag in UploadPart response. Missing Bucket CORS configuration for ETag header?`
-          );
-        }
-        this.uploadedParts.push({
-          PartNumber: dataPart.partNumber,
-          ETag: partResult.ETag,
-          ...partResult.ChecksumCRC32 && { ChecksumCRC32: partResult.ChecksumCRC32 },
-          ...partResult.ChecksumCRC32C && { ChecksumCRC32C: partResult.ChecksumCRC32C },
-          ...partResult.ChecksumSHA1 && { ChecksumSHA1: partResult.ChecksumSHA1 },
-          ...partResult.ChecksumSHA256 && { ChecksumSHA256: partResult.ChecksumSHA256 }
-        });
-        if (eventEmitter === null) {
-          this.bytesUploadedSoFar += partSize;
+        if (event.total && partSize) {
+          this.bytesUploadedSoFar += event.loaded - lastSeenBytes;
+          lastSeenBytes = event.loaded;
         }
         this.__notifyProgress({
           loaded: this.bytesUploadedSoFar,
@@ -361,24 +335,66 @@ var _Upload = class _Upload extends import_events.EventEmitter {
           Key: this.params.Key,
           Bucket: this.params.Bucket
         });
-      } catch (e) {
-        if (!this.uploadId) {
-          throw e;
-        }
-        if (this.leavePartsOnError) {
-          throw e;
-        }
+      }, "uploadEventListener");
+      if (eventEmitter !== null) {
+        eventEmitter.on("xhr.upload.progress", uploadEventListener);
       }
+      this.uploadEnqueuedPartsCount += 1;
+      const partResult = await this.client.send(
+        new import_client_s3.UploadPartCommand({
+          ...this.params,
+          UploadId: this.uploadId,
+          Body: dataPart.data,
+          PartNumber: dataPart.partNumber
+        })
+      );
+      if (eventEmitter !== null) {
+        eventEmitter.off("xhr.upload.progress", uploadEventListener);
+      }
+      if (this.abortController.signal.aborted) {
+        return;
+      }
+      if (!partResult.ETag) {
+        throw new Error(
+          `Part ${dataPart.partNumber} is missing ETag in UploadPart response. Missing Bucket CORS configuration for ETag header?`
+        );
+      }
+      this.uploadedParts.push({
+        PartNumber: dataPart.partNumber,
+        ETag: partResult.ETag,
+        ...partResult.ChecksumCRC32 && { ChecksumCRC32: partResult.ChecksumCRC32 },
+        ...partResult.ChecksumCRC32C && { ChecksumCRC32C: partResult.ChecksumCRC32C },
+        ...partResult.ChecksumSHA1 && { ChecksumSHA1: partResult.ChecksumSHA1 },
+        ...partResult.ChecksumSHA256 && { ChecksumSHA256: partResult.ChecksumSHA256 }
+      });
+      if (eventEmitter === null) {
+        this.bytesUploadedSoFar += partSize;
+      }
+      this.__notifyProgress({
+        loaded: this.bytesUploadedSoFar,
+        total: this.totalBytes,
+        part: dataPart.partNumber,
+        Key: this.params.Key,
+        Bucket: this.params.Bucket
+      });
     }
   }
   async __doMultipartUpload() {
     const dataFeeder = getChunk(this.params.Body, this.partSize);
+    const concurrentUploaderFailures = [];
     for (let index = 0; index < this.queueSize; index++) {
-      const currentUpload = this.__doConcurrentUpload(dataFeeder);
+      const currentUpload = this.__doConcurrentUpload(dataFeeder).catch((err) => {
+        concurrentUploaderFailures.push(err);
+      });
       this.concurrentUploaders.push(currentUpload);
     }
     await Promise.all(this.concurrentUploaders);
+    if (concurrentUploaderFailures.length >= 1) {
+      await this.markUploadAsAborted();
+      throw concurrentUploaderFailures[0];
+    }
     if (this.abortController.signal.aborted) {
+      await this.markUploadAsAborted();
       throw Object.assign(new Error("Upload aborted."), { name: "AbortError" });
     }
     let result;
@@ -399,6 +415,7 @@ var _Upload = class _Upload extends import_events.EventEmitter {
     } else {
       result = this.singleUploadResult;
     }
+    this.abortMultipartUploadCommand = null;
     if (this.tags.length) {
       await this.client.send(
         new import_client_s3.PutObjectTaggingCommand({
@@ -411,6 +428,17 @@ var _Upload = class _Upload extends import_events.EventEmitter {
     }
     return result;
   }
+  /**
+   * Abort the last multipart upload in progress
+   * if we know the upload id, the user did not specify to leave the parts, and
+   * we have a prepared AbortMultipartUpload command.
+   */
+  async markUploadAsAborted() {
+    if (this.uploadId && !this.leavePartsOnError && null !== this.abortMultipartUploadCommand) {
+      await this.client.send(this.abortMultipartUploadCommand);
+      this.abortMultipartUploadCommand = null;
+    }
+  }
   __notifyProgress(progress) {
     if (this.uploadEvent) {
       this.emit(this.uploadEvent, progress);

package/dist-es/Upload.js

@@ -1,4 +1,4 @@
-import { CompleteMultipartUploadCommand, CreateMultipartUploadCommand, PutObjectCommand, PutObjectTaggingCommand, UploadPartCommand, } from "@aws-sdk/client-s3";
+import { AbortMultipartUploadCommand, CompleteMultipartUploadCommand, CreateMultipartUploadCommand, PutObjectCommand, PutObjectTaggingCommand, UploadPartCommand, } from "@aws-sdk/client-s3";
 import { AbortController } from "@smithy/abort-controller";
 import { getEndpointFromInstructions, toEndpointV1, } from "@smithy/middleware-endpoint";
 import { extendedEncodeURIComponent } from "@smithy/smithy-client";
@@ -15,8 +15,11 @@ export class Upload extends EventEmitter {
         this.leavePartsOnError = false;
         this.tags = [];
         this.concurrentUploaders = [];
+        this.abortMultipartUploadCommand = null;
         this.uploadedParts = [];
+        this.uploadEnqueuedPartsCount = 0;
         this.isMultiPart = true;
+        this.sent = false;
         this.queueSize = options.queueSize || this.queueSize;
         this.partSize = options.partSize || this.partSize;
         this.leavePartsOnError = options.leavePartsOnError || this.leavePartsOnError;
@@ -32,6 +35,10 @@ export class Upload extends EventEmitter {
         this.abortController.abort();
     }
     async done() {
+        if (this.sent) {
+            throw new Error("@aws-sdk/lib-storage: this instance of Upload has already executed .done(). Create a new instance.");
+        }
+        this.sent = true;
         return await Promise.race([this.__doMultipartUpload(), this.__abortTimeout(this.abortController.signal)]);
     }
     on(event, listener) {
@@ -106,78 +113,49 @@ export class Upload extends EventEmitter {
     async __createMultipartUpload() {
         if (!this.createMultiPartPromise) {
             const createCommandParams = { ...this.params, Body: undefined };
-            this.createMultiPartPromise = this.client.send(new CreateMultipartUploadCommand(createCommandParams));
+            this.createMultiPartPromise = this.client
+                .send(new CreateMultipartUploadCommand(createCommandParams))
+                .then((createMpuResponse) => {
+                this.abortMultipartUploadCommand = new AbortMultipartUploadCommand({
+                    Bucket: this.params.Bucket,
+                    Key: this.params.Key,
+                    UploadId: createMpuResponse.UploadId,
+                });
+                return createMpuResponse;
+            });
         }
         return this.createMultiPartPromise;
     }
     async __doConcurrentUpload(dataFeeder) {
         for await (const dataPart of dataFeeder) {
-            if (this.uploadedParts.length > this.MAX_PARTS) {
-                throw new Error(`Exceeded ${this.MAX_PARTS} as part of the upload to ${this.params.Key} and ${this.params.Bucket}.`);
+            if (this.uploadEnqueuedPartsCount > this.MAX_PARTS) {
+                throw new Error(`Exceeded ${this.MAX_PARTS} parts in multipart upload to Bucket: ${this.params.Bucket} Key: ${this.params.Key}.`);
             }
-            try {
+            if (this.abortController.signal.aborted) {
+                return;
+            }
+            if (dataPart.partNumber === 1 && dataPart.lastPart) {
+                return await this.__uploadUsingPut(dataPart);
+            }
+            if (!this.uploadId) {
+                const { UploadId } = await this.__createMultipartUpload();
+                this.uploadId = UploadId;
                 if (this.abortController.signal.aborted) {
                     return;
                 }
-                if (dataPart.partNumber === 1 && dataPart.lastPart) {
-                    return await this.__uploadUsingPut(dataPart);
-                }
-                if (!this.uploadId) {
-                    const { UploadId } = await this.__createMultipartUpload();
-                    this.uploadId = UploadId;
-                    if (this.abortController.signal.aborted) {
-                        return;
-                    }
-                }
-                const partSize = byteLength(dataPart.data) || 0;
-                const requestHandler = this.client.config.requestHandler;
-                const eventEmitter = requestHandler instanceof EventEmitter ? requestHandler : null;
-                let lastSeenBytes = 0;
-                const uploadEventListener = (event, request) => {
-                    const requestPartSize = Number(request.query["partNumber"]) || -1;
-                    if (requestPartSize !== dataPart.partNumber) {
-                        return;
-                    }
-                    if (event.total && partSize) {
-                        this.bytesUploadedSoFar += event.loaded - lastSeenBytes;
-                        lastSeenBytes = event.loaded;
-                    }
-                    this.__notifyProgress({
-                        loaded: this.bytesUploadedSoFar,
-                        total: this.totalBytes,
-                        part: dataPart.partNumber,
-                        Key: this.params.Key,
-                        Bucket: this.params.Bucket,
-                    });
-                };
-                if (eventEmitter !== null) {
-                    eventEmitter.on("xhr.upload.progress", uploadEventListener);
-                }
-                const partResult = await this.client.send(new UploadPartCommand({
-                    ...this.params,
-                    UploadId: this.uploadId,
-                    Body: dataPart.data,
-                    PartNumber: dataPart.partNumber,
-                }));
-                if (eventEmitter !== null) {
-                    eventEmitter.off("xhr.upload.progress", uploadEventListener);
-                }
-                if (this.abortController.signal.aborted) {
+            }
+            const partSize = byteLength(dataPart.data) || 0;
+            const requestHandler = this.client.config.requestHandler;
+            const eventEmitter = requestHandler instanceof EventEmitter ? requestHandler : null;
+            let lastSeenBytes = 0;
+            const uploadEventListener = (event, request) => {
+                const requestPartSize = Number(request.query["partNumber"]) || -1;
+                if (requestPartSize !== dataPart.partNumber) {
                     return;
                 }
-                if (!partResult.ETag) {
-                    throw new Error(`Part ${dataPart.partNumber} is missing ETag in UploadPart response. Missing Bucket CORS configuration for ETag header?`);
-                }
-                this.uploadedParts.push({
-                    PartNumber: dataPart.partNumber,
-                    ETag: partResult.ETag,
-                    ...(partResult.ChecksumCRC32 && { ChecksumCRC32: partResult.ChecksumCRC32 }),
-                    ...(partResult.ChecksumCRC32C && { ChecksumCRC32C: partResult.ChecksumCRC32C }),
-                    ...(partResult.ChecksumSHA1 && { ChecksumSHA1: partResult.ChecksumSHA1 }),
-                    ...(partResult.ChecksumSHA256 && { ChecksumSHA256: partResult.ChecksumSHA256 }),
-                });
-                if (eventEmitter === null) {
-                    this.bytesUploadedSoFar += partSize;
+                if (event.total && partSize) {
+                    this.bytesUploadedSoFar += event.loaded - lastSeenBytes;
+                    lastSeenBytes = event.loaded;
                 }
                 this.__notifyProgress({
                     loaded: this.bytesUploadedSoFar,
@@ -186,25 +164,62 @@ export class Upload extends EventEmitter {
                     Key: this.params.Key,
                     Bucket: this.params.Bucket,
                 });
+            };
+            if (eventEmitter !== null) {
+                eventEmitter.on("xhr.upload.progress", uploadEventListener);
             }
-            catch (e) {
-                if (!this.uploadId) {
-                    throw e;
-                }
-                if (this.leavePartsOnError) {
-                    throw e;
-                }
+            this.uploadEnqueuedPartsCount += 1;
+            const partResult = await this.client.send(new UploadPartCommand({
+                ...this.params,
+                UploadId: this.uploadId,
+                Body: dataPart.data,
+                PartNumber: dataPart.partNumber,
+            }));
+            if (eventEmitter !== null) {
+                eventEmitter.off("xhr.upload.progress", uploadEventListener);
+            }
+            if (this.abortController.signal.aborted) {
+                return;
+            }
+            if (!partResult.ETag) {
+                throw new Error(`Part ${dataPart.partNumber} is missing ETag in UploadPart response. Missing Bucket CORS configuration for ETag header?`);
             }
+            this.uploadedParts.push({
+                PartNumber: dataPart.partNumber,
+                ETag: partResult.ETag,
+                ...(partResult.ChecksumCRC32 && { ChecksumCRC32: partResult.ChecksumCRC32 }),
+                ...(partResult.ChecksumCRC32C && { ChecksumCRC32C: partResult.ChecksumCRC32C }),
+                ...(partResult.ChecksumSHA1 && { ChecksumSHA1: partResult.ChecksumSHA1 }),
+                ...(partResult.ChecksumSHA256 && { ChecksumSHA256: partResult.ChecksumSHA256 }),
+            });
+            if (eventEmitter === null) {
+                this.bytesUploadedSoFar += partSize;
+            }
+            this.__notifyProgress({
+                loaded: this.bytesUploadedSoFar,
+                total: this.totalBytes,
+                part: dataPart.partNumber,
+                Key: this.params.Key,
+                Bucket: this.params.Bucket,
+            });
         }
     }
     async __doMultipartUpload() {
         const dataFeeder = getChunk(this.params.Body, this.partSize);
+        const concurrentUploaderFailures = [];
         for (let index = 0; index < this.queueSize; index++) {
-            const currentUpload = this.__doConcurrentUpload(dataFeeder);
+            const currentUpload = this.__doConcurrentUpload(dataFeeder).catch((err) => {
+                concurrentUploaderFailures.push(err);
+            });
             this.concurrentUploaders.push(currentUpload);
         }
         await Promise.all(this.concurrentUploaders);
+        if (concurrentUploaderFailures.length >= 1) {
+            await this.markUploadAsAborted();
+            throw concurrentUploaderFailures[0];
+        }
         if (this.abortController.signal.aborted) {
+            await this.markUploadAsAborted();
             throw Object.assign(new Error("Upload aborted."), { name: "AbortError" });
         }
         let result;
@@ -226,6 +241,7 @@ export class Upload extends EventEmitter {
         else {
             result = this.singleUploadResult;
         }
+        this.abortMultipartUploadCommand = null;
         if (this.tags.length) {
             await this.client.send(new PutObjectTaggingCommand({
                 ...this.params,
@@ -236,6 +252,12 @@ export class Upload extends EventEmitter {
         }
         return result;
     }
+    async markUploadAsAborted() {
+        if (this.uploadId && !this.leavePartsOnError && null !== this.abortMultipartUploadCommand) {
+            await this.client.send(this.abortMultipartUploadCommand);
+            this.abortMultipartUploadCommand = null;
+        }
+    }
     __notifyProgress(progress) {
         if (this.uploadEvent) {
             this.emit(this.uploadEvent, progress);

package/dist-es/chunks/getChunkStream.js

@@ -5,7 +5,7 @@ export async function* getChunkStream(data, partSize, getNextData) {
     for await (const datum of getNextData(data)) {
         currentBuffer.chunks.push(datum);
         currentBuffer.length += datum.byteLength;
-        while (currentBuffer.length >= partSize) {
+        while (currentBuffer.length > partSize) {
             const dataChunk = currentBuffer.chunks.length > 1 ? Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0];
             yield {
                 partNumber,

package/dist-types/Upload.d.ts

@@ -9,25 +9,31 @@ export interface RawDataPart {
 }
 export declare class Upload extends EventEmitter {
     /**
-     * S3 multipart upload does not allow more than 10000 parts.
+     * S3 multipart upload does not allow more than 10,000 parts.
      */
     private MAX_PARTS;
-    private queueSize;
-    private partSize;
-    private leavePartsOnError;
-    private tags;
-    private client;
-    private params;
+    private readonly queueSize;
+    private readonly partSize;
+    private readonly leavePartsOnError;
+    private readonly tags;
+    private readonly client;
+    private readonly params;
     private totalBytes?;
     private bytesUploadedSoFar;
     private abortController;
     private concurrentUploaders;
     private createMultiPartPromise?;
+    private abortMultipartUploadCommand;
     private uploadedParts;
-    private uploadId?;
+    private uploadEnqueuedPartsCount;
+    /**
+     * Last UploadId if the upload was done with MultipartUpload and not PutObject.
+     */
+    uploadId?: string;
     uploadEvent?: string;
     private isMultiPart;
     private singleUploadResult?;
+    private sent;
     constructor(options: Options);
     abort(): Promise<void>;
     done(): Promise<CompleteMultipartUploadCommandOutput>;
@@ -36,6 +42,12 @@ export declare class Upload extends EventEmitter {
     private __createMultipartUpload;
     private __doConcurrentUpload;
     private __doMultipartUpload;
+    /**
+     * Abort the last multipart upload in progress
+     * if we know the upload id, the user did not specify to leave the parts, and
+     * we have a prepared AbortMultipartUpload command.
+     */
+    private markUploadAsAborted;
     private __notifyProgress;
     private __abortTimeout;
     private __validateInput;

package/dist-types/ts3.4/Upload.d.ts

@@ -8,22 +8,25 @@ export interface RawDataPart {
 }
 export declare class Upload extends EventEmitter {
   private MAX_PARTS;
-  private queueSize;
-  private partSize;
-  private leavePartsOnError;
-  private tags;
-  private client;
-  private params;
+  private readonly queueSize;
+  private readonly partSize;
+  private readonly leavePartsOnError;
+  private readonly tags;
+  private readonly client;
+  private readonly params;
   private totalBytes?;
   private bytesUploadedSoFar;
   private abortController;
   private concurrentUploaders;
   private createMultiPartPromise?;
+  private abortMultipartUploadCommand;
   private uploadedParts;
-  private uploadId?;
+  private uploadEnqueuedPartsCount;
+  uploadId?: string;
   uploadEvent?: string;
   private isMultiPart;
   private singleUploadResult?;
+  private sent;
   constructor(options: Options);
   abort(): Promise<void>;
   done(): Promise<CompleteMultipartUploadCommandOutput>;
@@ -32,6 +35,7 @@ export declare class Upload extends EventEmitter {
   private __createMultipartUpload;
   private __doConcurrentUpload;
   private __doMultipartUpload;
+  private markUploadAsAborted;
   private __notifyProgress;
   private __abortTimeout;
   private __validateInput;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/lib-storage",
-  "version": "3.577.0",
+  "version": "3.582.0",
   "description": "Storage higher order operation",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -28,17 +28,17 @@
   "dependencies": {
     "@smithy/abort-controller": "^3.0.0",
     "@smithy/middleware-endpoint": "^3.0.0",
-    "@smithy/smithy-client": "^3.0.0",
+    "@smithy/smithy-client": "^3.0.1",
     "buffer": "5.6.0",
     "events": "3.3.0",
     "stream-browserify": "3.0.0",
     "tslib": "^2.6.2"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.577.0"
+    "@aws-sdk/client-s3": "^3.582.0"
   },
   "devDependencies": {
-    "@aws-sdk/client-s3": "3.577.0",
+    "@aws-sdk/client-s3": "3.582.0",
     "@smithy/types": "^3.0.0",
     "@tsconfig/recommended": "1.0.1",
     "@types/node": "^16.18.96",