@lossless.org/client 1.6.0 → 1.8.0

package/ts/objectstorage/classes.bucket.ts

@@ -18,6 +18,7 @@ import {
   purgeExactPath as purgeExactPathOperation,
 } from './internal.exactpathpurge.operations.js';
 import { beginBasicBucketOperation } from './internal.exactupload.capability.js';
+import { headBucketExists, runAccountRequest } from './internal.bucketrequests.js';
 
 export interface IListObjectKeysPageOptions {
   prefix?: string;
@@ -30,9 +31,171 @@ export interface IListObjectKeysPageResult {
   nextStartAfter?: string;
 }
 
+export interface IListObjectEntriesPageOptions extends IListObjectKeysPageOptions {
+  /** Optional caller-owned cancellation signal */
+  signal?: AbortSignal;
+}
+
+/**
+ * One object as ListObjectsV2 reported it when the page was listed.
+ * - `size`: the `Size` field, the object's byte length; HEAD reports the same
+ *   value as `ContentLength`.
+ * - `etag`: the `ETag` field without its surrounding double quotes; HEAD
+ *   reports the same entity tag, quoted. It identifies an object version, it
+ *   is not a content digest: AWS S3 derives it from the content MD5 only for
+ *   single-part uploads without SSE-KMS or SSE-C, and other providers define
+ *   it themselves.
+ * - `lastModified`: the `LastModified` field when the provider sends one.
+ */
+export interface IObjectListingEntry {
+  key: string;
+  size: number;
+  etag: string;
+  lastModified?: Date;
+}
+
+export interface IListObjectEntriesPageResult {
+  entries: IObjectListingEntry[];
+  nextStartAfter?: string;
+}
+
+export interface IListAllObjectEntriesOptions {
+  /** Entries fetched per ListObjectsV2 request, 1 to 1000 (default 1000) */
+  pageSize?: number;
+  /** Optional caller-owned cancellation signal */
+  signal?: AbortSignal;
+}
+
 const compareUtf8ObjectKeys = (leftArg: string, rightArg: string): number =>
   Buffer.compare(Buffer.from(leftArg, 'utf8'), Buffer.from(rightArg, 'utf8'));
 
+const assertListingPageOptions = (
+  optionsArg: IListObjectKeysPageOptions,
+  labelArg: string,
+): string => {
+  if (!optionsArg || typeof optionsArg !== 'object' || Array.isArray(optionsArg)) {
+    throw new TypeError(`${labelArg} options must be a plain object`);
+  }
+  const prefix = optionsArg.prefix ?? '';
+  if (typeof prefix !== 'string') {
+    throw new TypeError(`${labelArg} prefix must be a string`);
+  }
+  if (!Number.isInteger(optionsArg.limit) || optionsArg.limit < 1 || optionsArg.limit > 1_000) {
+    throw new Error(`${labelArg} limit must be an integer from 1 to 1000`);
+  }
+  if (
+    optionsArg.startAfter !== undefined
+    && (
+      typeof optionsArg.startAfter !== 'string'
+      || optionsArg.startAfter.length === 0
+      || !optionsArg.startAfter.startsWith(prefix)
+    )
+  ) {
+    throw new Error(`${labelArg} startAfter must be a non-empty key under the prefix`);
+  }
+  return prefix;
+};
+
+const createListingPageCommand = (
+  bucketNameArg: string,
+  prefixArg: string,
+  optionsArg: IListObjectKeysPageOptions,
+): plugins.s3.ListObjectsV2Command => new plugins.s3.ListObjectsV2Command({
+  Bucket: bucketNameArg,
+  Prefix: prefixArg,
+  MaxKeys: optionsArg.limit,
+  ...(optionsArg.startAfter ? { StartAfter: optionsArg.startAfter } : {}),
+});
+
+/**
+ * Validate one ListObjectsV2 keyset page: a truncation flag, at most `limit`
+ * string keys under the prefix in strict UTF-8 byte order after `startAfter`,
+ * and no empty truncated page.
+ */
+const readListingPageContents = (
+  responseArg: plugins.s3.ListObjectsV2Output,
+  prefixArg: string,
+  optionsArg: IListObjectKeysPageOptions,
+  labelArg: string,
+): { contents: plugins.s3._Object[]; keys: string[]; nextStartAfter?: string } => {
+  if (typeof responseArg.IsTruncated !== 'boolean') {
+    throw new Error(`Object storage returned an invalid ${labelArg} truncation flag`);
+  }
+  if (responseArg.Contents !== undefined && !Array.isArray(responseArg.Contents)) {
+    throw new Error(`Object storage returned invalid ${labelArg} contents`);
+  }
+  const contents = responseArg.Contents ?? [];
+  const keys = contents.map((entry) => {
+    if (!entry || typeof entry.Key !== 'string') {
+      throw new Error(`Object storage returned a ${labelArg} entry without a string key`);
+    }
+    return entry.Key;
+  });
+  if (keys.length > optionsArg.limit) {
+    throw new Error(`Object storage returned more ${labelArg === 'key page' ? 'keys' : 'entries'} than the requested page limit`);
+  }
+  if (new Set(keys).size !== keys.length) {
+    throw new Error('Object storage returned duplicate keys in one page');
+  }
+
+  let previousKey = optionsArg.startAfter;
+  for (const key of keys) {
+    if (!key.startsWith(prefixArg)) {
+      throw new Error('Object storage returned a key outside the requested prefix');
+    }
+    if (previousKey !== undefined && compareUtf8ObjectKeys(key, previousKey) <= 0) {
+      throw new Error('Object storage returned keys outside strict UTF-8 byte order');
+    }
+    previousKey = key;
+  }
+  if (responseArg.IsTruncated && keys.length === 0) {
+    throw new Error(`Object storage returned an empty truncated ${labelArg}`);
+  }
+  return {
+    contents,
+    keys,
+    ...(responseArg.IsTruncated ? { nextStartAfter: keys[keys.length - 1] } : {}),
+  };
+};
+
+/**
+ * Strip the double quotes S3 puts around an entity tag. A provider that
+ * returns the tag unquoted is accepted as is; anything else is refused.
+ */
+const normalizeListingEtag = (etagArg: unknown, keyArg: string): string => {
+  if (typeof etagArg !== 'string') {
+    throw new Error(`Object storage returned a listing entry without an ETag for key '${keyArg}'`);
+  }
+  const quoted = /^"([^"]+)"$/.exec(etagArg);
+  const etag = quoted ? quoted[1] : etagArg;
+  if (etag.length === 0 || etag.includes('"')) {
+    throw new Error(`Object storage returned an invalid ETag for key '${keyArg}'`);
+  }
+  return etag;
+};
+
+const toObjectListingEntry = (
+  entryArg: plugins.s3._Object,
+  keyArg: string,
+): IObjectListingEntry => {
+  if (!Number.isSafeInteger(entryArg.Size) || (entryArg.Size as number) < 0) {
+    throw new Error(`Object storage returned a listing entry without a valid size for key '${keyArg}'`);
+  }
+  const lastModified = entryArg.LastModified;
+  if (
+    lastModified !== undefined
+    && (!(lastModified instanceof Date) || Number.isNaN(lastModified.getTime()))
+  ) {
+    throw new Error(`Object storage returned an invalid LastModified for key '${keyArg}'`);
+  }
+  return {
+    key: keyArg,
+    size: entryArg.Size as number,
+    etag: normalizeListingEtag(entryArg.ETag, keyArg),
+    ...(lastModified ? { lastModified } : {}),
+  };
+};
+
 const destroyReadableAndWaitForSettlement = async (
   readableArg: plugins.stream.Readable,
 ): Promise<void> => {
@@ -78,29 +241,45 @@ const destroyReadableAndWaitForSettlement = async (
  * operate on blobs of data in an S3-compatible object store.
  */
 export class Bucket {
-  public static async getBucketByName(smartbucketRef: SmartBucket, bucketNameArg: string): Promise<Bucket> {
-    const command = new plugins.s3.ListBucketsCommand({});
-    const buckets = await smartbucketRef.storageClient.send(command);
-    const foundBucket = buckets.Buckets!.find((bucket) => bucket.Name === bucketNameArg);
-
-    if (foundBucket) {
-      console.log(`bucket with name ${bucketNameArg} exists.`);
-      console.log(`Taking this as base for new Bucket instance`);
-      return new this(smartbucketRef, bucketNameArg);
-    } else {
+  /**
+   * Returns a reference to an existing bucket, checked with one HeadBucket
+   * request. Rejects when the bucket does not exist or the credentials may
+   * not access it.
+   */
+  public static async getBucketByName(
+    smartbucketRef: SmartBucket,
+    bucketNameArg: string,
+    optionsArg: interfaces.IBucketRequestOptions = {},
+  ): Promise<Bucket> {
+    if (!(await headBucketExists(smartbucketRef, bucketNameArg, optionsArg.signal))) {
       throw new Error(`Bucket '${bucketNameArg}' not found.`);
     }
+    return new this(smartbucketRef, bucketNameArg);
   }
 
-  public static async createBucketByName(smartbucketRef: SmartBucket, bucketName: string) {
-    const command = new plugins.s3.CreateBucketCommand({ Bucket: bucketName });
-    await smartbucketRef.storageClient.send(command);
+  public static async createBucketByName(
+    smartbucketRef: SmartBucket,
+    bucketName: string,
+    optionsArg: interfaces.IBucketRequestOptions = {},
+  ) {
+    await runAccountRequest(smartbucketRef, optionsArg.signal, (clientArg, abortSignalArg) =>
+      clientArg.send(new plugins.s3.CreateBucketCommand({ Bucket: bucketName }), {
+        abortSignal: abortSignalArg,
+      }),
+    );
     return new Bucket(smartbucketRef, bucketName);
   }
 
-  public static async removeBucketByName(smartbucketRef: SmartBucket, bucketName: string) {
-    const command = new plugins.s3.DeleteBucketCommand({ Bucket: bucketName });
-    await smartbucketRef.storageClient.send(command);
+  public static async removeBucketByName(
+    smartbucketRef: SmartBucket,
+    bucketName: string,
+    optionsArg: interfaces.IBucketRequestOptions = {},
+  ) {
+    await runAccountRequest(smartbucketRef, optionsArg.signal, (clientArg, abortSignalArg) =>
+      clientArg.send(new plugins.s3.DeleteBucketCommand({ Bucket: bucketName }), {
+        abortSignal: abortSignalArg,
+      }),
+    );
   }
 
   public smartbucketRef: SmartBucket;
@@ -191,43 +370,32 @@ export class Bucket {
       overwrite?: boolean;
     }
   ): Promise<File> {
-    try {
-      const reducedPath = await helpers.reducePathDescriptorToPath(optionsArg);
-      if (optionsArg.overwrite !== true) {
-        const exists = await this.fastExists({ path: reducedPath });
-
-        if (exists) {
-          throw new Error(
-            `Object already exists at path '${reducedPath}' in bucket '${this.name}'. ` +
-            `Set overwrite:true to replace it.`
-          );
-        } else {
-          console.log(`Creating new object at path '${reducedPath}' in bucket '${this.name}'.`);
-        }
+    const reducedPath = await helpers.reducePathDescriptorToPath(optionsArg);
+    if (optionsArg.overwrite !== true) {
+      const exists = await this.fastExists({ path: reducedPath });
+
+      if (exists) {
+        throw new Error(
+          `Object already exists at path '${reducedPath}' in bucket '${this.name}'. ` +
+          `Set overwrite:true to replace it.`
+        );
       }
-
-      const command = new plugins.s3.PutObjectCommand({
-        Bucket: this.name,
-        Key: reducedPath,
-        Body: optionsArg.contents,
-      });
-      await this.smartbucketRef.storageClient.send(command);
-
-      console.log(`Object '${reducedPath}' has been successfully stored in bucket '${this.name}'.`);
-      const parsedPath = plugins.path.parse(reducedPath);
-      return new File({
-        directoryRefArg: await this.getDirectoryFromPath({
-          path: parsedPath.dir,
-        }),
-        fileName: parsedPath.base,
-      });
-    } catch (error) {
-      console.error(
-        `Error storing object at path '${optionsArg.path}' in bucket '${this.name}':`,
-        error
-      );
-      throw error;
     }
+
+    const command = new plugins.s3.PutObjectCommand({
+      Bucket: this.name,
+      Key: reducedPath,
+      Body: optionsArg.contents,
+    });
+    await this.smartbucketRef.storageClient.send(command);
+
+    const parsedPath = plugins.path.parse(reducedPath);
+    return new File({
+      directoryRefArg: await this.getDirectoryFromPath({
+        path: parsedPath.dir,
+      }),
+      fileName: parsedPath.base,
+    });
   }
 
 
@@ -552,8 +720,6 @@ export class Bucket {
             `Object already exists at path '${optionsArg.path}' in bucket '${this.name}'. ` +
             `Set overwrite:true to replace it.`
           );
-        } else {
-          console.log(`Creating new object at path '${optionsArg.path}' in bucket '${this.name}'.`);
         }
       }
 
@@ -572,18 +738,10 @@ export class Bucket {
       await operation.runProvider(
         () => operation.client.send(command, { abortSignal: operation.signal }),
       );
-
-      console.log(
-        `Object '${optionsArg.path}' has been successfully stored in bucket '${this.name}'.`
-      );
     } catch (error) {
       if (sourceOwnershipStarted || putDispatched || operation.signal.aborted) {
         await disposeSource();
       }
-      console.error(
-        `Error storing object at path '${optionsArg.path}' in bucket '${this.name}':`,
-        error
-      );
       throw error;
     } finally {
       operation.finish();
@@ -647,9 +805,6 @@ export class Bucket {
       await operation.runProvider(
         () => operation.client.send(command, { abortSignal: operation.signal }),
       );
-    } catch (err) {
-      console.error('Error updating metadata:', err);
-      throw err; // rethrow to allow caller to handle
     } finally {
       operation.finish();
     }
@@ -664,40 +819,20 @@ export class Bucket {
     targetBucket?: Bucket;
     overwrite?: boolean;
   }): Promise<void> {
-    try {
-      const destinationBucket = optionsArg.targetBucket || this;
-      const exists = await destinationBucket.fastExists({
-        path: optionsArg.destinationPath,
-      });
-
-      if (exists && !optionsArg.overwrite) {
-        console.error(
-          `Object already exists at destination path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`
-        );
-        return;
-      } else if (exists && optionsArg.overwrite) {
-        console.log(
-          `Overwriting existing object at destination path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`
-        );
-      } else {
-        console.log(
-          `Moving object to path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`
-        );
-      }
-
-      await this.fastCopy(optionsArg);
-      await this.fastRemove({ path: optionsArg.sourcePath });
+    const destinationBucket = optionsArg.targetBucket || this;
+    const exists = await destinationBucket.fastExists({
+      path: optionsArg.destinationPath,
+    });
 
-      console.log(
-        `Object '${optionsArg.sourcePath}' has been successfully moved to '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`
-      );
-    } catch (error) {
+    if (exists && !optionsArg.overwrite) {
       console.error(
-        `Error moving object from '${optionsArg.sourcePath}' to '${optionsArg.destinationPath}':`,
-        error
+        `Object already exists at destination path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`
       );
-      throw error;
+      return;
     }
+
+    await this.fastCopy(optionsArg);
+    await this.fastRemove({ path: optionsArg.sourcePath });
   }
 
   /**
@@ -733,7 +868,6 @@ export class Bucket {
       await operation.runProvider(
         () => operation.client.send(command, { abortSignal: operation.signal }),
       );
-      console.log(`Object '${optionsArg.path}' exists in bucket '${this.name}'.`);
       return true;
     } catch (error: any) {
       try {
@@ -742,10 +876,8 @@ export class Bucket {
         throw abortError;
       }
       if (error?.name === 'NotFound') {
-        console.log(`Object '${optionsArg.path}' does not exist in bucket '${this.name}'.`);
         return false;
       } else {
-        console.error('Error checking object existence:', error);
         throw error; // Rethrow if it's not a NotFound error to handle unexpected issues
       }
     } finally {
@@ -805,27 +937,19 @@ export class Bucket {
   }
 
   public async getMagicBytes(optionsArg: { path: string; length: number }): Promise<Buffer> {
-    try {
-      const command = new plugins.s3.GetObjectCommand({
-        Bucket: this.name,
-        Key: optionsArg.path,
-        Range: `bytes=0-${optionsArg.length - 1}`,
-      });
-      const response = await this.smartbucketRef.storageClient.send(command);
-      const chunks: Buffer[] = [];
-      const stream = response.Body as any; // SdkStreamMixin includes readable stream
+    const command = new plugins.s3.GetObjectCommand({
+      Bucket: this.name,
+      Key: optionsArg.path,
+      Range: `bytes=0-${optionsArg.length - 1}`,
+    });
+    const response = await this.smartbucketRef.storageClient.send(command);
+    const chunks: Buffer[] = [];
+    const stream = response.Body as any; // SdkStreamMixin includes readable stream
 
-      for await (const chunk of stream) {
-        chunks.push(chunk);
-      }
-      return Buffer.concat(chunks);
-    } catch (error) {
-      console.error(
-        `Error retrieving magic bytes from object at path '${optionsArg.path}' in bucket '${this.name}':`,
-        error
-      );
-      throw error;
+    for await (const chunk of stream) {
+      chunks.push(chunk);
     }
+    return Buffer.concat(chunks);
   }
 
   // ==========================================
@@ -933,73 +1057,90 @@ export class Bucket {
   public async listObjectKeysPage(
     optionsArg: IListObjectKeysPageOptions,
   ): Promise<IListObjectKeysPageResult> {
-    if (!optionsArg || typeof optionsArg !== 'object' || Array.isArray(optionsArg)) {
-      throw new TypeError('Object key page options must be a plain object');
-    }
-    const prefix = optionsArg.prefix ?? '';
-    if (typeof prefix !== 'string') {
-      throw new TypeError('Object key page prefix must be a string');
-    }
-    if (!Number.isInteger(optionsArg.limit) || optionsArg.limit < 1 || optionsArg.limit > 1_000) {
-      throw new Error('Object key page limit must be an integer from 1 to 1000');
-    }
-    if (
-      optionsArg.startAfter !== undefined
-      && (
-        typeof optionsArg.startAfter !== 'string'
-        || optionsArg.startAfter.length === 0
-        || !optionsArg.startAfter.startsWith(prefix)
-      )
-    ) {
-      throw new Error('Object key page startAfter must be a non-empty key under the prefix');
-    }
-
+    const prefix = assertListingPageOptions(optionsArg, 'Object key page');
     const response = await this.smartbucketRef.storageClient.send(
-      new plugins.s3.ListObjectsV2Command({
-        Bucket: this.name,
-        Prefix: prefix,
-        MaxKeys: optionsArg.limit,
-        ...(optionsArg.startAfter ? { StartAfter: optionsArg.startAfter } : {}),
-      }),
+      createListingPageCommand(this.name, prefix, optionsArg),
     );
-    if (typeof response.IsTruncated !== 'boolean') {
-      throw new Error('Object storage returned an invalid key page truncation flag');
-    }
-    if (response.Contents !== undefined && !Array.isArray(response.Contents)) {
-      throw new Error('Object storage returned invalid key page contents');
-    }
+    const { keys, nextStartAfter } = readListingPageContents(
+      response,
+      prefix,
+      optionsArg,
+      'key page',
+    );
+    return {
+      keys,
+      ...(nextStartAfter !== undefined ? { nextStartAfter } : {}),
+    };
+  }
 
-    const keys = (response.Contents ?? []).map((entry) => {
-      if (!entry || typeof entry.Key !== 'string') {
-        throw new Error('Object storage returned a key page entry without a string key');
-      }
-      return entry.Key;
-    });
-    if (keys.length > optionsArg.limit) {
-      throw new Error('Object storage returned more keys than the requested page limit');
+  /**
+   * List one keyset page of objects with the size, ETag and last-modified time
+   * ListObjectsV2 already returns, so a caller needs no HEAD per object.
+   * Pagination, prefix, limit (1 to 1000) and `startAfter` behave exactly like
+   * `listObjectKeysPage()`: `nextStartAfter` is present only while the provider
+   * reports more entries. `signal` aborts the in-flight request and rejects with
+   * its reason. This requires a general-purpose S3 provider with UTF-8
+   * byte-ordered keys.
+   */
+  public async listObjectEntriesPage(
+    optionsArg: IListObjectEntriesPageOptions,
+  ): Promise<IListObjectEntriesPageResult> {
+    const prefix = assertListingPageOptions(optionsArg, 'Object entry page');
+    if (optionsArg.signal !== undefined && !(optionsArg.signal instanceof AbortSignal)) {
+      throw new TypeError('Object entry page signal must be an AbortSignal');
     }
-    if (new Set(keys).size !== keys.length) {
-      throw new Error('Object storage returned duplicate keys in one page');
+    const operation = beginBasicBucketOperation(this, optionsArg.signal);
+    try {
+      operation.assertCurrent();
+      const command = createListingPageCommand(operation.bucketName, prefix, optionsArg);
+      const response = await operation.runProvider(
+        () => operation.client.send(command, { abortSignal: operation.signal }),
+      );
+      operation.assertCurrent();
+      const { contents, keys, nextStartAfter } = readListingPageContents(
+        response,
+        prefix,
+        optionsArg,
+        'entry page',
+      );
+      return {
+        entries: contents.map((entry, index) => toObjectListingEntry(entry, keys[index])),
+        ...(nextStartAfter !== undefined ? { nextStartAfter } : {}),
+      };
+    } finally {
+      operation.finish();
     }
+  }
 
-    let previousKey = optionsArg.startAfter;
-    for (const key of keys) {
-      if (!key.startsWith(prefix)) {
-        throw new Error('Object storage returned a key outside the requested prefix');
-      }
-      if (previousKey !== undefined && compareUtf8ObjectKeys(key, previousKey) <= 0) {
-        throw new Error('Object storage returned keys outside strict UTF-8 byte order');
+  /**
+   * Iterate every object under a prefix with its size, ETag and last-modified
+   * time, one `listObjectEntriesPage()` request per page. No request is in
+   * flight while the caller holds an entry; breaking out stops the listing.
+   * @example
+   * ```ts
+   * for await (const entry of bucket.listAllObjectEntries('npm/', { signal })) {
+   *   console.log(entry.key, entry.size, entry.etag);
+   * }
+   * ```
+   */
+  public async *listAllObjectEntries(
+    prefix: string = '',
+    optionsArg: IListAllObjectEntriesOptions = {},
+  ): AsyncIterableIterator<IObjectListingEntry> {
+    const limit = optionsArg.pageSize ?? 1_000;
+    let startAfter: string | undefined;
+    do {
+      const page = await this.listObjectEntriesPage({
+        prefix,
+        limit,
+        ...(startAfter !== undefined ? { startAfter } : {}),
+        ...(optionsArg.signal ? { signal: optionsArg.signal } : {}),
+      });
+      for (const entry of page.entries) {
+        yield entry;
       }
-      previousKey = key;
-    }
-    if (response.IsTruncated && keys.length === 0) {
-      throw new Error('Object storage returned an empty truncated key page');
-    }
-
-    return {
-      keys,
-      ...(response.IsTruncated ? { nextStartAfter: keys[keys.length - 1] } : {}),
-    };
+      startAfter = page.nextStartAfter;
+    } while (startAfter !== undefined);
   }
 
   /**
@@ -1061,50 +1202,41 @@ export class Bucket {
   }
 
   public async cleanAllContents(): Promise<void> {
-    try {
-      // Define the command type explicitly
-      const listCommandInput: plugins.s3.ListObjectsV2CommandInput = {
-        Bucket: this.name,
-      };
-  
-      let isTruncated = true;
-      let continuationToken: string | undefined = undefined;
-  
-      while (isTruncated) {
-        // Add the continuation token to the input if present
-        const listCommand = new plugins.s3.ListObjectsV2Command({
-          ...listCommandInput,
-          ContinuationToken: continuationToken,
+    // Define the command type explicitly
+    const listCommandInput: plugins.s3.ListObjectsV2CommandInput = {
+      Bucket: this.name,
+    };
+
+    let isTruncated = true;
+    let continuationToken: string | undefined = undefined;
+
+    while (isTruncated) {
+      // Add the continuation token to the input if present
+      const listCommand = new plugins.s3.ListObjectsV2Command({
+        ...listCommandInput,
+        ContinuationToken: continuationToken,
+      });
+
+      // Explicitly type the response
+      const response: plugins.s3.ListObjectsV2Output =
+        await this.smartbucketRef.storageClient.send(listCommand);
+
+      if (response.Contents && response.Contents.length > 0) {
+        // Delete objects in batches, mapping each item to { Key: string }
+        const deleteCommand = new plugins.s3.DeleteObjectsCommand({
+          Bucket: this.name,
+          Delete: {
+            Objects: response.Contents.map((item) => ({ Key: item.Key! })),
+            Quiet: true,
+          },
         });
-  
-        // Explicitly type the response
-        const response: plugins.s3.ListObjectsV2Output =
-          await this.smartbucketRef.storageClient.send(listCommand);
-        
-        console.log(`Cleaning contents of bucket '${this.name}': Now deleting ${response.Contents?.length} items...`);
-
-        if (response.Contents && response.Contents.length > 0) {
-          // Delete objects in batches, mapping each item to { Key: string }
-          const deleteCommand = new plugins.s3.DeleteObjectsCommand({
-            Bucket: this.name,
-            Delete: {
-              Objects: response.Contents.map((item) => ({ Key: item.Key! })),
-              Quiet: true,
-            },
-          });
-  
-          await this.smartbucketRef.storageClient.send(deleteCommand);
-        }
-  
-        // Update continuation token and truncation status
-        isTruncated = response.IsTruncated || false;
-        continuationToken = response.NextContinuationToken;
+
+        await this.smartbucketRef.storageClient.send(deleteCommand);
       }
-  
-      console.log(`All contents in bucket '${this.name}' have been deleted.`);
-    } catch (error) {
-      console.error(`Error cleaning contents of bucket '${this.name}':`, error);
-      throw error;
+
+      // Update continuation token and truncation status
+      isTruncated = response.IsTruncated || false;
+      continuationToken = response.NextContinuationToken;
     }
   }
 }