client.ts

import * as fs from 'node:fs'
import type { IncomingMessage } from 'node:http'
import * as http from 'node:http'
import * as https from 'node:https'
import path from 'node:path'
import type { Readable as ReadableStream } from 'node:stream'
import * as stream from 'node:stream'

import async from 'async'
import { isBrowser } from 'browser-or-node'
import _ from 'lodash'
import { mkdirp } from 'mkdirp'
import Xml from 'xml'

import { asCallback, asCallbackFn } from './as-callback.ts'
import { fsp, streamPromise } from './async.ts'
import { CredentialProvider } from './CredentialProvider.ts'
import * as errors from './errors.ts'
import { S3Error } from './errors.ts'
import { extensions } from './extensions.ts'
import type { MetaData } from './helpers.ts'
import {
  DEFAULT_REGION,
  extractMetadata,
  getVersionId,
  insertContentType,
  isAmazonEndpoint,
  isBoolean,
  isEmpty,
  isFunction,
  isNumber,
  isObject,
  isOptionalFunction,
  isReadableStream,
  isString,
  isValidBucketName,
  isValidEndpoint,
  isValidObjectName,
  isValidPort,
  isValidPrefix,
  isVirtualHostStyle,
  makeDateLong,
  pipesetup,
  prependXAMZMeta,
  readableStream,
  sanitizeETag,
  toSha256,
  uriEscape,
  uriResourceEscape,
} from './helpers.ts'
import { qs } from './qs.ts'
import type { Region } from './s3-endpoints.ts'
import { getS3Endpoint } from './s3-endpoints.ts'
import { signV4 } from './signing.ts'
import * as transformers from './transformers.ts'
import type {
  Binary,
  BucketItemFromList,
  BucketItemStat,
  GetObjectOpt,
  IRequest,
  MakeBucketOpt,
  NoResultCallback,
  RequestHeaders,
  ResultCallback,
  StatObjectOpts,
  UploadedObjectInfo,
} from './type.ts'
import { drainResponse, findCallback, readAsBuffer } from './typed-client.ts'
import type { Part } from './xml-parsers.ts'
import * as xmlParsers from './xml-parsers.ts'

const requestOptionProperties = [
  'agent',
  'ca',
  'cert',
  'ciphers',
  'clientCertEngine',
  'crl',
  'dhparam',
  'ecdhCurve',
  'family',
  'honorCipherOrder',
  'key',
  'passphrase',
  'pfx',
  'rejectUnauthorized',
  'secureOptions',
  'secureProtocol',
  'servername',
  'sessionIdContext',
] as const

export interface ClientOptions {
  endPoint: string
  accessKey: string
  secretKey: string
  useSSL?: boolean
  port?: number
  region?: Region
  transport?: typeof http | typeof https
  sessionToken?: string
  partSize?: number
  pathStyle?: boolean
  credentialsProvider?: CredentialProvider
  s3AccelerateEndpoint?: string
}

// will be replaced by rollup plugin
const version = process.env.MINIO_JS_PACKAGE_VERSION || 'development'
const Package = { version }

export type RequestMethod = 'HEAD' | 'GET' | 'POST' | 'DELETE' | 'PUT'
export type RequestOption = Partial<IRequest> & {
  method: RequestMethod
  bucketName?: string
  objectName?: string
  region?: string
  query?: string
  pathStyle?: boolean
}

export class Client {
  protected transport: typeof http | typeof https
  protected host: string
  protected port: number
  protected protocol: string
  protected accessKey: string
  protected secretKey: string
  protected sessionToken?: string
  protected userAgent: string
  protected anonymous: boolean
  protected pathStyle: boolean
  protected regionMap: Record<string, string>
  public region?: string
  protected credentialsProvider?: CredentialProvider
  protected partSize: number = 64 * 1024 * 1024
  protected overRidePartSize?: boolean

  protected maximumPartSize = 5 * 1024 * 1024 * 1024
  protected maxObjectSize = 5 * 1024 * 1024 * 1024 * 1024
  public enableSHA256: boolean
  protected s3AccelerateEndpoint?: string
  protected reqOptions: Record<string, unknown>

  private readonly clientExtensions: extensions
  private logStream?: stream.Writable

  constructor(params: ClientOptions) {
    // @ts-expect-error deprecated property
    if (params.secure !== undefined) {
      throw new Error('"secure" option deprecated, "useSSL" should be used instead')
    }
    // Default values if not specified.
    if (params.useSSL === undefined) {
      params.useSSL = true
    }
    if (!params.port) {
      params.port = 0
    }
    // Validate input params.
    if (!isValidEndpoint(params.endPoint)) {
      throw new errors.InvalidEndpointError(`Invalid endPoint : ${params.endPoint}`)
    }
    if (!isValidPort(params.port)) {
      throw new errors.InvalidArgumentError(`Invalid port : ${params.port}`)
    }
    if (!isBoolean(params.useSSL)) {
      throw new errors.InvalidArgumentError(
        `Invalid useSSL flag type : ${params.useSSL}, expected to be of type "boolean"`,
      )
    }

    // Validate region only if its set.
    if (params.region) {
      if (!isString(params.region)) {
        throw new errors.InvalidArgumentError(`Invalid region : ${params.region}`)
      }
    }

    const host = params.endPoint.toLowerCase()
    let port = params.port
    let protocol: string
    let transport
    // Validate if configuration is not using SSL
    // for constructing relevant endpoints.
    if (params.useSSL) {
      // Defaults to secure.
      transport = https
      protocol = 'https:'
      port = port || 443
    } else {
      transport = http
      protocol = 'http:'
      port = port || 80
    }

    // if custom transport is set, use it.
    if (params.transport) {
      if (!isObject(params.transport)) {
        throw new errors.InvalidArgumentError(
          `Invalid transport type : ${params.transport}, expected to be type "object"`,
        )
      }
      transport = params.transport
    }

    // User Agent should always following the below style.
    // Please open an issue to discuss any new changes here.
    //
    //       MinIO (OS; ARCH) LIB/VER APP/VER
    //
    const libraryComments = `(${process.platform}; ${process.arch})`
    const libraryAgent = `MinIO ${libraryComments} minio-js/${Package.version}`
    // User agent block ends.

    this.transport = transport
    this.host = host
    this.port = port
    this.protocol = protocol
    this.accessKey = params.accessKey
    this.secretKey = params.secretKey
    this.sessionToken = params.sessionToken
    this.userAgent = `${libraryAgent}`

    // Default path style is true
    if (params.pathStyle === undefined) {
      this.pathStyle = true
    } else {
      this.pathStyle = params.pathStyle
    }

    if (!this.accessKey) {
      this.accessKey = ''
    }
    if (!this.secretKey) {
      this.secretKey = ''
    }
    this.anonymous = !this.accessKey || !this.secretKey

    if (params.credentialsProvider) {
      this.credentialsProvider = params.credentialsProvider
      this.checkAndRefreshCreds()
    }

    this.regionMap = {}
    if (params.region) {
      this.region = params.region
    }

    if (params.partSize) {
      this.partSize = params.partSize
      this.overRidePartSize = true
    }
    if (this.partSize < 5 * 1024 * 1024) {
      throw new errors.InvalidArgumentError(`Part size should be greater than 5MB`)
    }
    if (this.partSize > 5 * 1024 * 1024 * 1024) {
      throw new errors.InvalidArgumentError(`Part size should be less than 5GB`)
    }

    // SHA256 is enabled only for authenticated http requests. If the request is authenticated
    // and the connection is https we use x-amz-content-sha256=UNSIGNED-PAYLOAD
    // header for signature calculation.
    this.enableSHA256 = !this.anonymous && !params.useSSL

    this.s3AccelerateEndpoint = params.s3AccelerateEndpoint || undefined
    this.reqOptions = {}

    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
    // @ts-ignore
    this.clientExtensions = new extensions(this)
  }

  /**
   *  This is s3 Specific and does not hold validity in any other Object storage.
   */
  private getAccelerateEndPointIfSet(bucketName: string, objectName?: string) {
    if (!isEmpty(this.s3AccelerateEndpoint) && !isEmpty(bucketName) && !isEmpty(objectName)) {
      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html
      // Disable transfer acceleration for non-compliant bucket names.
      if (bucketName.includes('.')) {
        throw new Error(`Transfer Acceleration is not supported for non compliant bucket:${bucketName}`)
      }
      // If transfer acceleration is requested set new host.
      // For more details about enabling transfer acceleration read here.
      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html
      return this.s3AccelerateEndpoint
    }
    return false
  }

  /**
   * @param endPoint - valid S3 acceleration end point
   */
  public setS3TransferAccelerate(endPoint: string) {
    this.s3AccelerateEndpoint = endPoint
  }

  /**
   * Sets the supported request options.
   */
  public setRequestOptions(options: Pick<https.RequestOptions, (typeof requestOptionProperties)[number]>) {
    // TODO: add options type details
    if (!isObject(options)) {
      throw new TypeError('request options should be of type "object"')
    }
    this.reqOptions = _.pick(options, requestOptionProperties)
  }

  /**
   * returns options object that can be used with http.request()
   * Takes care of constructing virtual-host-style or path-style hostname
   */
  protected getRequestOptions(opts: RequestOption): IRequest & { host: string; headers: Record<string, string> } {
    const method = opts.method
    const region = opts.region
    const bucketName = opts.bucketName
    let objectName = opts.objectName
    const headers = opts.headers
    const query = opts.query

    let reqOptions = {
      method,
      headers: {} as RequestHeaders,
      protocol: this.protocol,
    }

    // Verify if virtual host supported.
    let virtualHostStyle
    if (bucketName) {
      virtualHostStyle = isVirtualHostStyle(this.host, this.protocol, bucketName, this.pathStyle)
    }

    let path = '/'
    let host = this.host

    let port: undefined | number
    if (this.port) {
      port = this.port
    }

    if (objectName) {
      objectName = `${uriResourceEscape(objectName)}`
    }

    // For Amazon S3 endpoint, get endpoint based on region.
    if (isAmazonEndpoint(host)) {
      const accelerateEndPoint = this.getAccelerateEndPointIfSet(bucketName!, objectName)
      if (accelerateEndPoint) {
        host = `${accelerateEndPoint}`
      } else {
        host = getS3Endpoint(region!)
      }
    }

    if (virtualHostStyle && !opts.pathStyle) {
      // For all hosts which support virtual host style, `bucketName`
      // is part of the hostname in the following format:
      //
      //  var host = 'bucketName.example.com'
      //
      if (bucketName) {
        host = `${bucketName}.${host}`
      }
      if (objectName) {
        path = `/${objectName}`
      }
    } else {
      // For all S3 compatible storage services we will fallback to
      // path style requests, where `bucketName` is part of the URI
      // path.
      if (bucketName) {
        path = `/${bucketName}`
      }
      if (objectName) {
        path = `/${bucketName}/${objectName}`
      }
    }

    if (query) {
      path += `?${query}`
    }
    reqOptions.headers.host = host
    if ((reqOptions.protocol === 'http:' && port !== 80) || (reqOptions.protocol === 'https:' && port !== 443)) {
      reqOptions.headers.host = `${host}:${port}`
    }
    reqOptions.headers['user-agent'] = this.userAgent
    if (headers) {
      // have all header keys in lower case - to make signing easy
      for (const [k, v] of Object.entries(headers)) {
        reqOptions.headers[k.toLowerCase()] = v
      }
    }

    // Use any request option specified in minioClient.setRequestOptions()
    reqOptions = Object.assign({}, this.reqOptions, reqOptions)

    return {
      ...reqOptions,
      headers: Object.fromEntries(Object.entries(reqOptions.headers).map(([key, value]) => [key, value.toString()])),
      host,
      port,
      path,
    } satisfies https.RequestOptions
  }

  /**
   * Set application specific information.
   *
   * Generates User-Agent in the following style.
   *
   *    MinIO (OS; ARCH) LIB/VER APP/VER
   *
   * @param appName - Application name.
   * @param appVersion - Application version.
   */
  public setAppInfo(appName: string, appVersion: string) {
    if (!isString(appName)) {
      throw new TypeError(`Invalid appName: ${appName}`)
    }
    if (appName.trim() === '') {
      throw new errors.InvalidArgumentError('Input appName cannot be empty.')
    }
    if (!isString(appVersion)) {
      throw new TypeError(`Invalid appVersion: ${appVersion}`)
    }
    if (appVersion.trim() === '') {
      throw new errors.InvalidArgumentError('Input appVersion cannot be empty.')
    }
    this.userAgent = `${this.userAgent} ${appName}/${appVersion}`
  }

  /**
   * Calculate part size given the object size. Part size will be at least this.partSize
   *
   * @param size - total size
   *
   * @internal
   */
  protected calculatePartSize(size: number) {
    if (!isNumber(size)) {
      throw new TypeError('size should be of type "number"')
    }
    if (size > this.maxObjectSize) {
      throw new TypeError(`size should not be more than ${this.maxObjectSize}`)
    }
    if (this.overRidePartSize) {
      return this.partSize
    }
    let partSize = this.partSize
    for (;;) {
      // while(true) {...} throws linting error.
      // If partSize is big enough to accomodate the object size, then use it.
      if (partSize * 10000 > size) {
        return partSize
      }
      // Try part sizes as 64MB, 80MB, 96MB etc.
      partSize += 16 * 1024 * 1024
    }
  }

  /**
   * log the request, response, error
   */
  private logHTTP(reqOptions: IRequest, response: http.IncomingMessage | null, err?: unknown) {
    // if no logStream available return.
    if (!this.logStream) {
      return
    }
    if (!isObject(reqOptions)) {
      throw new TypeError('reqOptions should be of type "object"')
    }
    if (response && !isReadableStream(response)) {
      throw new TypeError('response should be of type "Stream"')
    }
    if (err && !(err instanceof Error)) {
      throw new TypeError('err should be of type "Error"')
    }
    const logStream = this.logStream
    const logHeaders = (headers: RequestHeaders) => {
      Object.entries(headers).forEach(([k, v]) => {
        if (k == 'authorization') {
          if (isString(v)) {
            const redactor = new RegExp('Signature=([0-9a-f]+)')
            v = v.replace(redactor, 'Signature=**REDACTED**')
          }
        }
        logStream.write(`${k}: ${v}\n`)
      })
      logStream.write('\n')
    }
    logStream.write(`REQUEST: ${reqOptions.method} ${reqOptions.path}\n`)
    logHeaders(reqOptions.headers)
    if (response) {
      this.logStream.write(`RESPONSE: ${response.statusCode}\n`)
      logHeaders(response.headers as RequestHeaders)
    }
    if (err) {
      logStream.write('ERROR BODY:\n')
      const errJSON = JSON.stringify(err, null, '\t')
      logStream.write(`${errJSON}\n`)
    }
  }

  /**
   * Enable tracing
   */
  public traceOn(stream?: stream.Writable) {
    if (!stream) {
      stream = process.stdout
    }
    this.logStream = stream
  }

  /**
   * Disable tracing
   */
  public traceOff() {
    this.logStream = undefined
  }

  /**
   * make new request with promise response
   * always return response
   */
  makeRequestAsync(
    options: RequestOption,
    payload: Binary | Uint8Array = '',
    expectedCodes: number[] = [200],
    region = '',
    returnResponse = true,
  ): Promise<IncomingMessage> {
    if (!isObject(options)) {
      throw new TypeError('options should be of type "object"')
    }
    if (!isString(payload) && !isObject(payload)) {
      // Buffer is of type 'object'
      throw new TypeError('payload should be of type "string" or "Buffer"')
    }
    expectedCodes.forEach((statusCode) => {
      if (!isNumber(statusCode)) {
        throw new TypeError('statusCode should be of type "number"')
      }
    })
    if (!isString(region)) {
      throw new TypeError('region should be of type "string"')
    }
    if (!isBoolean(returnResponse)) {
      throw new TypeError('returnResponse should be of type "boolean"')
    }
    if (!options.headers) {
      options.headers = {}
    }
    if (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE') {
      options.headers['content-length'] = payload.length.toString()
    }

    const sha256sum = this.enableSHA256 ? toSha256(payload) : ''
    const stream = readableStream(payload)
    return this.makeRequestStreamAsync(options, stream, sha256sum, expectedCodes, region, returnResponse)
  }

  /**
   * new request with promise
   * always return response
   */
  protected async makeRequestAsyncOmit(
    options: RequestOption,
    payload: Binary | Uint8Array = '',
    statusCodes: number[] = [200],
    region = '',
  ): Promise<void> {
    await this.makeRequestAsync(options, payload, statusCodes, region, false)
  }

  /**
   * makeRequest is the primitive used by the apis for making S3 requests.
   * payload can be empty string in case of no payload.
   * statusCode is the expected statusCode. If response.statusCode does not match
   * we parse the XML error and call the callback with the error message.
   *
   * A valid region is passed by the calls - listBuckets, makeBucket and getBucketRegion.
   *
   * @internal
   */
  makeRequest(
    options: RequestOption,
    payload: Binary | Uint8Array,
    expectedCodes: number[],
    region: string,
    returnResponse: boolean,
    cb: (err: null | unknown, response: IncomingMessage) => void,
  ) {
    if (!isFunction(cb)) {
      throw new TypeError('callback should be of type "function"')
    }
    if (!options.headers) {
      options.headers = {}
    }
    if (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE') {
      options.headers['content-length'] = payload.length.toString()
    }

    cbStyleReturn(this.makeRequestAsync(options, payload, expectedCodes, region, returnResponse), cb)
  }

  /**
   * makeRequestStream will be used directly instead of makeRequest in case the payload
   * is available as a stream. for ex. putObject
   *
   * @internal
   */
  makeRequestStreamAsync(
    options: RequestOption,
    stream: stream.Readable | Buffer,
    sha256sum: string,
    statusCodes: number[] = [200],
    region = '',
    returnResponse = true,
  ) {
    if (!isObject(options)) {
      throw new TypeError('options should be of type "object"')
    }
    if (!(Buffer.isBuffer(stream) || isReadableStream(stream))) {
      throw new errors.InvalidArgumentError('stream should be a Buffer or readable Stream')
    }
    if (!isString(sha256sum)) {
      throw new TypeError('sha256sum should be of type "string"')
    }
    statusCodes.forEach((statusCode) => {
      if (!isNumber(statusCode)) {
        throw new TypeError('statusCode should be of type "number"')
      }
    })
    if (!isString(region)) {
      throw new TypeError('region should be of type "string"')
    }
    if (!isBoolean(returnResponse)) {
      throw new TypeError('returnResponse should be of type "boolean"')
    }

    // sha256sum will be empty for anonymous or https requests
    if (!this.enableSHA256 && sha256sum.length !== 0) {
      throw new errors.InvalidArgumentError(`sha256sum expected to be empty for anonymous or https requests`)
    }
    // sha256sum should be valid for non-anonymous http requests.
    if (this.enableSHA256 && sha256sum.length !== 64) {
      throw new errors.InvalidArgumentError(`Invalid sha256sum : ${sha256sum}`)
    }

    const regionPromise = region ? Promise.resolve(region) : this.getBucketRegionAsync(options.bucketName!)

    const req = () => {
      return regionPromise.then(
        (reg) =>
          new Promise<http.IncomingMessage>((resolve, reject) => {
            options.region = reg
            const reqOptions = this.getRequestOptions(options)
            if (!this.anonymous) {
              // For non-anonymous https requests sha256sum is 'UNSIGNED-PAYLOAD' for signature calculation.
              if (!this.enableSHA256) {
                sha256sum = 'UNSIGNED-PAYLOAD'
              }

              const date = new Date()

              reqOptions.headers['x-amz-date'] = makeDateLong(date)
              reqOptions.headers['x-amz-content-sha256'] = sha256sum
              if (this.sessionToken) {
                reqOptions.headers['x-amz-security-token'] = this.sessionToken
              }

              this.checkAndRefreshCreds()
              reqOptions.headers.authorization = signV4(reqOptions, this.accessKey, this.secretKey, reg, date)
            }

            const req = this.transport.request(reqOptions, (response) => {
              if (!response.statusCode) {
                return reject(new Error("BUG: response doesn't have a statusCode"))
              }

              if (!statusCodes.includes(response.statusCode)) {
                // For an incorrect region, S3 server always sends back 400.
                // But we will do cache invalidation for all errors so that,
                // in future, if AWS S3 decides to send a different status code or
                // XML error code we will still work fine.
                delete this.regionMap[options.bucketName!]
                // @ts-expect-error looks like `getErrorTransformer` want a `http.ServerResponse`,
                // but we only have a http.IncomingMessage here
                const errorTransformer = transformers.getErrorTransformer(response)
                pipesetup(response, errorTransformer).on('error', (e) => {
                  this.logHTTP(reqOptions, response, e)
                  reject(e)
                })
                return
              }
              this.logHTTP(reqOptions, response)
              if (returnResponse) {
                return resolve(response)
              }
              // We drain the socket so that the connection gets closed. Note that this
              // is not expensive as the socket will not have any data.
              response.on('data', Discard)
              resolve(response)
            })

            req.on('error', (e) => {
              this.logHTTP(reqOptions, null, e)
              reject(e)
            })

            if (Buffer.isBuffer(stream)) {
              req.end(stream)
            } else {
              pipesetup(stream, req)
            }
          }),
      )
    }

    return req()
  }

  /// Bucket operations

  /**
   * Creates the bucket `bucketName`.
   *
   * @param bucketName - Name of the bucket
   * @param region - region, see ts types for valid values, or use empty string.
   * @param makeOpts - Options to create a bucket.
   * @param callback? - if no callback. will return a promise.
   */
  makeBucket(bucketName: string, region: Region, makeOpts: MakeBucketOpt, callback: NoResultCallback): void
  makeBucket(bucketName: string, region: Region, callback: NoResultCallback): void
  makeBucket(bucketName: string, callback: NoResultCallback): void
  makeBucket(bucketName: string, region?: Region, makeOpts?: MakeBucketOpt): Promise<void>

  // there is also a deprecated Backward Compatibility sign
  // makeBucket(bucketName: string, makeOpts: MakeBucketOpt, callback: NoResultCallback): void

  makeBucket(
    bucketName: string,
    regionOrCallback?: string | NoResultCallback | MakeBucketOpt, // MakeBucketOpt as second params is deprecated
    makeOptsOrCallback?: MakeBucketOpt | NoResultCallback,
    callback?: NoResultCallback,
  ): void | Promise<void> {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)
    }

    let [[region = '', makeOpts = {}], cb] = findCallback<
      [string, MakeBucketOpt] | [MakeBucketOpt, string],
      NoResultCallback
    >([regionOrCallback, makeOptsOrCallback, callback])
    if (isObject(region)) {
      // Backward Compatibility
      // makeBucket(bucketName: string, makeOpts: MakeBucketOpt, callback: NoResultCallback): void
      makeOpts = region as MakeBucketOpt
      region = ''
    }

    if (!isString(region)) {
      throw new TypeError('region should be of type "string"')
    }
    if (!isObject(makeOpts)) {
      throw new TypeError('makeOpts should be of type "object"')
    }

    let payload = ''
    // Region already set in constructor, validate if
    // caller requested bucket location is same.
    if (region && this.region) {
      if (region !== this.region) {
        throw new errors.InvalidArgumentError(`Configured region ${this.region}, requested ${region}`)
      }
    }
    // sending makeBucket request with XML containing 'us-east-1' fails. For
    // default region server expects the request without body
    if (region && region !== DEFAULT_REGION) {
      const createBucketConfiguration = []
      createBucketConfiguration.push({
        _attr: {
          xmlns: 'http://s3.amazonaws.com/doc/2006-03-01/',
        },
      })
      createBucketConfiguration.push({
        LocationConstraint: region,
      })
      const payloadObject = {
        CreateBucketConfiguration: createBucketConfiguration,
      }
      payload = Xml(payloadObject)
    }
    const method = 'PUT'
    const headers: RequestHeaders = {}
    if (makeOpts.ObjectLocking) {
      headers['x-amz-bucket-object-lock-enabled'] = true
    }
    if (!region) {
      region = DEFAULT_REGION
    }
    const finalRegion = region // type narrow
    const requestOpt: RequestOption = { method, bucketName, headers }
    return asCallbackFn(cb, async () => {
      try {
        await this.makeRequestAsyncOmit(requestOpt, payload, [200], finalRegion)
      } catch (err: unknown) {
        if (region === '' || region === DEFAULT_REGION) {
          if (err instanceof S3Error) {
            const errCode = err.code
            const errRegion = err.region
            if (errCode === 'AuthorizationHeaderMalformed' && errRegion !== '') {
              // Retry with region returned as part of error
              await this.makeRequestAsyncOmit(requestOpt, payload, [200], errCode)
            }
          }
        }
        throw err
      }
    })
  }

  /**
   * List of buckets created.
   */
  listBuckets(): Promise<BucketItemFromList[]>
  listBuckets(callback: ResultCallback<BucketItemFromList[]>): void
  listBuckets(cb?: ResultCallback<BucketItemFromList[]>): void | Promise<BucketItemFromList[]> {
    const method = 'GET'
    return asCallbackFn(cb, async () => {
      const response = await this.makeRequestAsync({ method }, '', [200], DEFAULT_REGION)
      const body = await readAsBuffer(response)
      return xmlParsers.parseListBucket(body.toString())
    })
  }

  listIncompleteUploads(bucket: string, prefix: string, recursive: boolean): stream.Readable {
    if (prefix === undefined) {
      prefix = ''
    }
    if (recursive === undefined) {
      recursive = false
    }
    if (!isValidBucketName(bucket)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucket)
    }
    if (!isValidPrefix(prefix)) {
      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)
    }
    if (!isBoolean(recursive)) {
      throw new TypeError('recursive should be of type "boolean"')
    }
    const delimiter = recursive ? '' : '/'
    let keyMarker = ''
    let uploadIdMarker = ''
    const uploads: unknown[] = []
    let ended = false
    const readStream = new stream.Readable({ objectMode: true })
    readStream._read = () => {
      // push one upload info per _read()
      if (uploads.length) {
        return readStream.push(uploads.shift())
      }
      if (ended) {
        return readStream.push(null)
      }
      this.listIncompleteUploadsQuery(bucket, prefix, keyMarker, uploadIdMarker, delimiter)
        .on('error', (e) => readStream.emit('error', e))
        .on('data', (result) => {
          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
          // @ts-ignore
          result.prefixes.forEach((prefix) => uploads.push(prefix))
          async.eachSeries(
            result.uploads,
            (upload, cb) => {
              // for each incomplete upload add the sizes of its uploaded parts
              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
              // @ts-ignore
              this.listParts(bucket, upload.key, upload.uploadId).then(
                (parts: any) => {
                  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                  // @ts-ignore
                  upload.size = parts.reduce((acc, item) => acc + item.size, 0)
                  uploads.push(upload)
                  cb()
                },
                (err: any) => cb(err),
              )
            },
            (err) => {
              if (err) {
                readStream.emit('error', err)
                return
              }
              if (result.isTruncated) {
                keyMarker = result.nextKeyMarker
                uploadIdMarker = result.nextUploadIdMarker
              } else {
                ended = true
              }

              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
              // @ts-ignore
              readStream._read()
            },
          )
        })
    }
    return readStream
  }

  /**
   * Remove a bucket.
   *
   * @param bucketName - name of the bucket
   */
  bucketExists(bucketName: string, callback: ResultCallback<boolean>): void
  bucketExists(bucketName: string): Promise<boolean>

  // * `callback(err)` _function_ : `err` is `null` if the bucket exists
  bucketExists(bucketName: string, cb?: ResultCallback<boolean>): void | Promise<boolean> {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    const method = 'HEAD'

    return asCallbackFn(cb, async () => {
      try {
        await this.makeRequestAsyncOmit({ method, bucketName }, '', [200], '')
      } catch (err) {
        if (err instanceof S3Error) {
          if (err.code == 'NoSuchBucket' || err.code == 'NotFound') {
            return false
          }
        }

        throw err
      }

      return true
    })
  }

  /**
   * Remove a bucket
   *
   * @param bucketName - name of the bucket
   * @param callback
   */
  removeBucket(bucketName: string, callback: NoResultCallback): void
  removeBucket(bucketName: string): Promise<void>

  // * `callback(err)` _function_ : `err` is `null` if the bucket is removed successfully.
  removeBucket(bucketName: string, cb?: NoResultCallback): void | Promise<void> {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }

    const method = 'DELETE'
    return asCallbackFn(cb, async () => {
      await this.makeRequestAsyncOmit({ method, bucketName }, '', [204], '')
      delete this.regionMap[bucketName]
    })
  }

  /**
   * Remove the partially uploaded object.
   *
   * @param bucketName - name of the bucket
   * @param objectName -  name of the object
   * @param callback - callback function is called with non `null` value in case of error
   */
  removeIncompleteUpload(bucketName: string, objectName: string, callback: NoResultCallback): void
  removeIncompleteUpload(bucketName: string, objectName: string): Promise<void>

  removeIncompleteUpload(bucketName: string, objectName: string, cb?: NoResultCallback): void | Promise<void> {
    if (!isValidBucketName(bucketName)) {
      throw new errors.IsValidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isValidObjectName(objectName)) {
      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)
    }
    if (!isOptionalFunction(cb)) {
      throw new TypeError('callback should be of type "function"')
    }

    return asCallbackFn(cb, async () => {
      const uploadId = await this.findUploadId(bucketName, objectName)
      if (!uploadId) {
        return
      }
      const method = 'DELETE'
      const query = `uploadId=${uploadId}`
      await this.makeRequestAsync(
        {
          method,
          bucketName,
          objectName,
          query,
        },
        '',
        [204],
        '',
        false,
      )
    })
  }

  fGetObject(bucketName: string, objectName: string, filePath: string, callback: NoResultCallback): void
  fGetObject(
    bucketName: string,
    objectName: string,
    filePath: string,
    getOpts: GetObjectOpt,
    callback: NoResultCallback,
  ): void
  /**
   * Callback is called with `error` in case of error or `null` in case of success
   *
   * @param bucketName - name of the bucket
   * @param objectName - name of the object
   * @param filePath - path to which the object data will be written to
   * @param getOpts? - Optional object get option
   */
  fGetObject(bucketName: string, objectName: string, filePath: string, getOpts?: GetObjectOpt): Promise<void>

  fGetObject(
    bucketName: string,
    objectName: string,
    filePath: string,
    getOptsOrCallback?: GetObjectOpt | NoResultCallback,
    callback?: NoResultCallback,
  ) {
    // Input validation.
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isValidObjectName(objectName)) {
      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)
    }
    if (!isString(filePath)) {
      throw new TypeError('filePath should be of type "string"')
    }

    const [[getOpts = {}], cb] = findCallback<[GetObjectOpt], NoResultCallback>([getOptsOrCallback, callback])

    if (!isOptionalFunction(cb)) {
      throw new TypeError('callback should be of type "function"')
    }

    const executor = async (): Promise<string> => {
      let partFileStream: stream.Writable
      const objStat = await this.statObject(bucketName, objectName, getOpts)
      const partFile = `${filePath}.${objStat.etag}.part.minio`

      await mkdirp(path.dirname(filePath))

      let offset = 0
      try {
        const stats = await fsp.stat(partFile)
        if (objStat.size === stats.size) {
          return partFile
        }
        offset = stats.size
        partFileStream = fs.createWriteStream(partFile, { flags: 'a' })
      } catch (e) {
        if (e instanceof Error && (e as unknown as { code: string }).code === 'ENOENT') {
          // file not exist
          partFileStream = fs.createWriteStream(partFile, { flags: 'w' })
        } else {
          // other error, maybe access deny
          throw e
        }
      }

      const downloadStream = await this.getPartialObject(bucketName, objectName, offset, 0, getOpts)

      await streamPromise.pipeline(downloadStream, partFileStream)
      const stats = await fsp.stat(partFile)
      if (stats.size === objStat.size) {
        return partFile
      }

      throw new Error('Size mismatch between downloaded file and the object')
    }

    return asCallback(
      cb,
      executor().then((partFile) => fsp.rename(partFile, filePath)),
    )
  }

  getObject(
    bucketName: string,
    objectName: string,
    getOpts: GetObjectOpt,
    callback: ResultCallback<ReadableStream>,
  ): void
  getObject(bucketName: string, objectName: string, callback: ResultCallback<ReadableStream>): void

  /**
   * Get Objects. return a readable stream of the object content by callback or promise.
   *
   * @param bucketName - name of the bucket
   * @param objectName - name of the object
   * @param getOpts
   */
  getObject(bucketName: string, objectName: string, getOpts?: GetObjectOpt): Promise<ReadableStream>

  getObject(
    bucketName: string,
    objectName: string,
    getOpts_Callback?: GetObjectOpt | ResultCallback<ReadableStream>, // getOpts
    callback?: ResultCallback<ReadableStream>, // callback
  ): void | Promise<ReadableStream> {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isValidObjectName(objectName)) {
      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)
    }

    const [[getOpts = {}], cb] = findCallback<[GetObjectOpt], ResultCallback<ReadableStream>>([
      getOpts_Callback,
      callback,
    ])

    return asCallback(cb, this.getPartialObject(bucketName, objectName, 0, 0, getOpts))
  }

  /**
   * Callback is called with readable stream of the partial object content.
   */
  getPartialObject(
    bucketName: string,
    objectName: string,
    offset: number,
    length?: number,
    getOpts?: GetObjectOpt,
  ): Promise<stream.Readable>

  getPartialObject(
    bucketName: string,
    objectName: string,
    offset: number,
    callback: ResultCallback<stream.Readable>,
  ): void
  getPartialObject(
    bucketName: string,
    objectName: string,
    offset: number,
    length: number,
    callback: ResultCallback<stream.Readable>,
  ): void
  getPartialObject(
    bucketName: string,
    objectName: string,
    offset: number,
    length: number,
    getOpts: GetObjectOpt,
    callback: ResultCallback<stream.Readable>,
  ): void

  getPartialObject(
    bucketName: string,
    objectName: string,
    offset: number,
    length_callback?: number | ResultCallback<stream.Readable>, // length
    getOpts_callback?: GetObjectOpt | ResultCallback<stream.Readable>, // get opt
    callback?: ResultCallback<stream.Readable>, // callback
  ): void | Promise<stream.Readable> {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isValidObjectName(objectName)) {
      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)
    }
    if (!isNumber(offset)) {
      throw new TypeError('offset should be of type "number"')
    }

    const [[length = 0, getOpts = {}], cb] = findCallback<[number, GetObjectOpt], ResultCallback<stream.Readable>>([
      length_callback,
      getOpts_callback,
      callback,
    ])

    if (!isNumber(length)) {
      throw new TypeError(`length should be of type "number"`)
    }

    let range = ''
    if (offset || length) {
      if (offset) {
        range = `bytes=${+offset}-`
      } else {
        range = 'bytes=0-'
        offset = 0
      }
      if (length) {
        range += `${+length + offset - 1}`
      }
    }

    const headers: RequestHeaders = {}
    if (range !== '') {
      headers.range = range
    }

    const expectedStatusCodes = [200]
    if (range) {
      expectedStatusCodes.push(206)
    }

    const method = 'GET'
    const query = qs(getOpts)
    return asCallback(
      cb,
      this.makeRequestAsync({ method, bucketName, objectName, headers, query }, '', expectedStatusCodes),
    )
  }

  /**
   * Uploads the object.
   *
   * Uploading a stream
   * __Arguments__
   * * `bucketName` _string_: name of the bucket
   * * `objectName` _string_: name of the object
   * * `stream` _Stream_: Readable stream
   * * `size` _number_: size of the object (optional)
   * * `callback(err, etag)` _function_: non null `err` indicates error, `etag` _string_ is the etag of the object uploaded.
   *
   * Uploading "Buffer" or "string"
   * __Arguments__
   * * `bucketName` _string_: name of the bucket
   * * `objectName` _string_: name of the object
   * * `string or Buffer` _string_ or _Buffer_: string or buffer
   * * `callback(err, objInfo)` _function_: `err` is `null` in case of success and `info` will have the following object details:
   *   * `etag` _string_: etag of the object
   * * `callback(err, objInfo)` _function_: non null `err` indicates error, `objInfo` _object_ which contains versionId and etag.
   */
  fPutObject(
    bucketName: string,
    objectName: string,
    filePath: string,
    metaData: MetaData,
    callback?: NoResultCallback,
  ) {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isValidObjectName(objectName)) {
      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)
    }

    if (!isString(filePath)) {
      throw new TypeError('filePath should be of type "string"')
    }

    ;[[metaData = {}], callback] = findCallback<[MetaData], NoResultCallback>([metaData, callback])

    if (!isObject(metaData)) {
      throw new TypeError('metaData should be of type "object"')
    }

    // Inserts correct `content-type` attribute based on metaData and filePath
    metaData = insertContentType(metaData, filePath)

    // Updates metaData to have the correct prefix if needed
    metaData = prependXAMZMeta(metaData)
    const apiCallback = callback

    type Part = {
      part: number
      etag: string
    }

    const executor = async (fd: number) => {
      const stats = await fsp.fstat(fd)
      const fileSize = stats.size
      if (fileSize > this.maxObjectSize) {
        throw new Error(`${filePath} size : ${stats.size}, max allowed size : 5TB`)
      }

      if (fileSize <= this.partSize) {
        // simple PUT request, no multipart
        const uploader = this.getUploader(bucketName, objectName, metaData, false)
        const buf = await fsp.readfile(fd)
        const { md5sum, sha256sum } = transformers.hashBinary(buf, this.enableSHA256)
        return await uploader(buf, fileSize, sha256sum, md5sum)
      }

      const previousUploadId = await this.findUploadId(bucketName, objectName)
      let eTags: Part[] = []
      // if there was a previous incomplete upload, fetch all its uploaded parts info
      let uploadId: string
      if (previousUploadId) {
        eTags = await this.listParts(bucketName, objectName, previousUploadId)
        uploadId = previousUploadId
      } else {
        // there was no previous upload, initiate a new one
        uploadId = (await this.initiateNewMultipartUpload(bucketName, objectName, metaData)) as string
      }

      {
        const partSize = this.calculatePartSize(fileSize)
        const uploader = this.getUploader(bucketName, objectName, metaData, true)
        // convert array to object to make things easy
        const parts = eTags.reduce(function (acc, item) {
          if (!acc[item.part]) {
            acc[item.part] = item
          }
          return acc
        }, {} as Record<number, Part>)
        const partsDone: { part: number; etag: string }[] = []
        let partNumber = 1
        let uploadedSize = 0

        // will be reused for hashing and uploading
        // don't worry it's "unsafe", we will read data from fs to fill it
        const buf = Buffer.allocUnsafe(this.partSize)
        while (uploadedSize < fileSize) {
          const part = parts[partNumber]
          let length = partSize
          if (length > fileSize - uploadedSize) {
            length = fileSize - uploadedSize
          }

          await fsp.read(fd, buf, 0, length, 0)
          const { md5sum, sha256sum } = transformers.hashBinary(buf.subarray(0, length), this.enableSHA256)

          const md5sumHex = Buffer.from(md5sum, 'base64').toString('hex')

          if (part && md5sumHex === part.etag) {
            // md5 matches, chunk already uploaded
            partsDone.push({ part: partNumber, etag: part.etag })
            partNumber++
            uploadedSize += length
            continue
          }

          const objInfo = await uploader(uploadId, partNumber, buf.subarray(0, length), length, sha256sum, md5sum)
          partsDone.push({ part: partNumber, etag: objInfo.etag })
          partNumber++
          uploadedSize += length
        }
        eTags = partsDone
      }

      // at last, finish uploading
      return this.completeMultipartUpload(bucketName, objectName, uploadId, eTags)
    }

    const ensureFileClose = async <T>(executor: (fd: number) => Promise<T>) => {
      let fd
      try {
        fd = await fsp.open(filePath, 'r')
      } catch (e) {
        throw new Error(`failed to open file ${filePath}: err ${e}`, { cause: e })
      }

      try {
        return await executor(fd)
      } finally {
        await fsp.fclose(fd)
      }
    }

    return asCallback(apiCallback, ensureFileClose(executor))
  }

  // ====================================================== //
  // ====================================================== //
  // ====================================================== //
  // ====================================================== //
  // ====================================================== //
  // ====================================================== //
  // ====================================================== //
  // ====================================================== //
  /* eslint-disable @typescript-eslint/ban-ts-comment */

  completeMultipartUpload(
    bucketName: string,
    objectName: string,
    uploadId: string,
    etags: {
      part: number
      etag?: string
    }[],
  ): Promise<{ etag: string; versionId: string | null }>

  completeMultipartUpload(
    bucketName: string,
    objectName: string,
    uploadId: string,
    etags: {
      part: number
      etag?: string
    }[],
    cb: ResultCallback<{ etag: string; versionId: string | null }>,
  ): void

  // this call will aggregate the parts on the server into a single object.
  completeMultipartUpload(
    bucketName: string,
    objectName: string,
    uploadId: string,
    etags: {
      part: number
      etag?: string
    }[],
    cb?: ResultCallback<{ etag: string; versionId: string | null }>,
  ) {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isValidObjectName(objectName)) {
      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)
    }
    if (!isString(uploadId)) {
      throw new TypeError('uploadId should be of type "string"')
    }
    if (!isObject(etags)) {
      throw new TypeError('etags should be of type "Array"')
    }
    if (!isOptionalFunction(cb)) {
      throw new TypeError('cb should be of type "function"')
    }

    if (!uploadId) {
      throw new errors.InvalidArgumentError('uploadId cannot be empty')
    }

    const method = 'POST'
    const query = `uploadId=${uriEscape(uploadId)}`

    const parts: unknown[] = []

    etags.forEach((element) => {
      parts.push({
        Part: [
          {
            PartNumber: element.part,
          },
          {
            ETag: element.etag,
          },
        ],
      })
    })

    const payloadObject = { CompleteMultipartUpload: parts }
    const payload = Xml(payloadObject)

    return asCallbackFn(cb, async () => {
      const res = await this.makeRequestAsync({ method, bucketName, objectName, query }, payload)
      const body = await readAsBuffer(res)
      const result = xmlParsers.parseCompleteMultipart(body.toString())
      if (!result) {
        throw new Error('BUG: failed to parse server response')
      }

      if (result.errCode) {
        // Multipart Complete API returns an error XML after a 200 http status
        throw new errors.S3Error(result.errMessage)
      }

      return {
        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
        // @ts-ignore
        etag: result.etag as string,
        versionId: getVersionId(res.headers),
      }
    })
  }

  // Called by listIncompleteUploads to fetch a batch of incomplete uploads.
  listIncompleteUploadsQuery(
    bucketName: string,
    prefix: string,
    keyMarker: string,
    uploadIdMarker: string,
    delimiter: string,
  ): stream.Transform {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isString(prefix)) {
      throw new TypeError('prefix should be of type "string"')
    }
    if (!isString(keyMarker)) {
      throw new TypeError('keyMarker should be of type "string"')
    }
    if (!isString(uploadIdMarker)) {
      throw new TypeError('uploadIdMarker should be of type "string"')
    }
    if (!isString(delimiter)) {
      throw new TypeError('delimiter should be of type "string"')
    }
    const queries = []
    queries.push(`prefix=${uriEscape(prefix)}`)
    queries.push(`delimiter=${uriEscape(delimiter)}`)

    if (keyMarker) {
      keyMarker = uriEscape(keyMarker)
      queries.push(`key-marker=${keyMarker}`)
    }
    if (uploadIdMarker) {
      queries.push(`upload-id-marker=${uploadIdMarker}`)
    }

    const maxUploads = 1000
    queries.push(`max-uploads=${maxUploads}`)
    queries.sort()
    queries.unshift('uploads')
    let query = ''
    if (queries.length > 0) {
      query = `${queries.join('&')}`
    }
    const method = 'GET'
    const transformer = transformers.getListMultipartTransformer()
    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {
      if (e) {
        return transformer.emit('error', e)
      }
      if (!response) {
        throw new Error('BUG: no response')
      }

      pipesetup(response, transformer)
    })
    return transformer
  }

  public get extensions() {
    return this.clientExtensions
  }

  public async setCredentialsProvider(credentialsProvider: CredentialProvider) {
    if (!(credentialsProvider instanceof CredentialProvider)) {
      throw new Error('Unable to get  credentials. Expected instance of CredentialProvider')
    }
    this.credentialsProvider = credentialsProvider
    await this.checkAndRefreshCreds()
  }

  private async fetchCredentials() {
    if (this.credentialsProvider) {
      const credentialsConf = await this.credentialsProvider.getCredentials()
      if (credentialsConf) {
        // @ts-expect-error secretKey maybe undefined
        this.accessKey = credentialsConf.getAccessKey()
        // @ts-expect-error secretKey maybe undefined
        this.secretKey = credentialsConf.getSecretKey()
        this.sessionToken = credentialsConf.getSessionToken()
      } else {
        throw new Error('Unable to get credentials. Expected instance of BaseCredentialsProvider')
      }
    } else {
      throw new Error('Unable to get credentials. Expected instance of BaseCredentialsProvider')
    }
  }

  /**
   * Initiate a new multipart upload.
   * @internal
   */
  async initiateNewMultipartUpload(bucketName: string, objectName: string, metaData: MetaData): Promise<string> {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isValidObjectName(objectName)) {
      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)
    }
    if (!isObject(metaData)) {
      throw new errors.InvalidObjectNameError('contentType should be of type "object"')
    }
    const method = 'POST'
    const headers = Object.assign({}, metaData)
    const query = 'uploads'
    const res = await this.makeRequestAsync({ method, bucketName, objectName, query, headers })
    const body = await readAsBuffer(res)
    return xmlParsers.parseInitiateMultipart(body.toString())
  }

  protected async checkAndRefreshCreds() {
    if (this.credentialsProvider) {
      return await this.fetchCredentials()
    }
  }

  /**
   * gets the region of the bucket
   *
   * @param bucketName
   *
   * @internal
   */
  protected async getBucketRegionAsync(bucketName: string): Promise<string> {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`)
    }

    const me = this

    const executor = async (): Promise<string> => {
      // Region is set with constructor, return the region right here.
      if (this.region) {
        return this.region
      }

      if (this.regionMap[bucketName]) {
        return this.regionMap[bucketName]
      }

      const extractRegionAsync = async (response: IncomingMessage) => {
        const body = await readAllAsString(response)
        const region = xmlParsers.parseBucketRegion(body)
        this.regionMap[bucketName] = region
        return region
      }

      const method = 'GET'
      const query = 'location'

      // `getBucketLocation` behaves differently in following ways for
      // different environments.
      //
      // - For nodejs env we default to path style requests.
      // - For browser env path style requests on buckets yields CORS
      //   error. To circumvent this problem we make a virtual host
      //   style request signed with 'us-east-1'. This request fails
      //   with an error 'AuthorizationHeaderMalformed', additionally
      //   the error XML also provides Region of the bucket. To validate
      //   this region is proper we retry the same request with the newly
      //   obtained region.
      const pathStyle = this.pathStyle && !isBrowser

      let region: string

      try {
        const res = await me.makeRequestAsync({ method, bucketName, query, pathStyle }, '', [200], DEFAULT_REGION)
        return extractRegionAsync(res)
      } catch (e) {
        if (!(e instanceof Error && e.name === 'AuthorizationHeaderMalformed')) {
          throw e
        }
        // @ts-expect-error we set extra properties on error object
        region = e.Region as string
        if (!region) {
          throw e
        }
      }

      const res = await me.makeRequestAsync({ method, bucketName, query, pathStyle }, '', [200], region)
      return extractRegionAsync(res)
    }

    return executor()
  }

  findUploadId(bucketName: string, objectName: string, cb: ResultCallback<string | undefined>): void
  findUploadId(bucketName: string, objectName: string): Promise<string | undefined>
  findUploadId(
    bucketName: string,
    objectName: string,
    cb?: ResultCallback<string | undefined>,
  ): void | Promise<string | undefined> {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isValidObjectName(objectName)) {
      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)
    }
    if (!isOptionalFunction(cb)) {
      throw new TypeError('cb should be of type "function"')
    }
    return asCallback(
      cb,
      new Promise((resolve, reject) => {
        let latestUpload: string | undefined
        const listNext = (keyMarker: string, uploadIdMarker: string) => {
          this.listIncompleteUploadsQuery(bucketName, objectName, keyMarker, uploadIdMarker, '')
            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
            // @ts-ignore
            .on('error', (e) => reject(e))
            .on('data', (result) => {
              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
              // @ts-ignore
              result.uploads.forEach((upload) => {
                if (upload.key === objectName) {
                  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                  // @ts-ignore
                  if (!latestUpload || upload.initiated.getTime() > latestUpload.initiated.getTime()) {
                    latestUpload = upload
                    return
                  }
                }
              })
              if (result.isTruncated) {
                listNext(result.nextKeyMarker, result.nextUploadIdMarker)
                return
              }
              if (latestUpload) {
                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                // @ts-ignore
                return resolve(latestUpload.uploadId)
              }
              resolve(undefined)
            })
        }
        listNext('', '')
      }),
    )
  }

  // Stat information of the object.
  //
  // __Arguments__
  // * `bucketName` _string_: name of the bucket
  // * `objectName` _string_: name of the object
  // * `statOpts`  _object_ : Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional).

  statObject(
    bucketName: string,
    objectName: string,
    statOpts: StatObjectOpts,
    callback: ResultCallback<BucketItemStat>,
  ): void
  statObject(bucketName: string, objectName: string, callback: ResultCallback<BucketItemStat>): void
  statObject(bucketName: string, objectName: string, statOpts?: StatObjectOpts): Promise<BucketItemStat>

  statObject(
    bucketName: string,
    objectName: string,
    statOptsOrCallback: StatObjectOpts | ResultCallback<BucketItemStat> = {},
    callback?: ResultCallback<BucketItemStat>,
  ): void | Promise<BucketItemStat> {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isValidObjectName(objectName)) {
      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)
    }

    let statOpts: StatObjectOpts = {}
    let cb: ResultCallback<BucketItemStat> | undefined

    // backward compatibility
    if (typeof statOptsOrCallback === 'function') {
      // statObject(bucketName, objectName, callback): void
      statOpts = {}
      cb = statOptsOrCallback
    } else {
      // statObject(bucketName, objectName, statOpts, callback): void
      statOpts = statOptsOrCallback
      cb = callback
    }

    if (!isObject(statOpts)) {
      throw new errors.InvalidArgumentError('statOpts should be of type "object"')
    }
    if (!isOptionalFunction(cb)) {
      throw new TypeError('callback should be of type "function"')
    }

    const query = qs(statOpts)
    const method = 'HEAD'
    return asCallbackFn(cb, async () => {
      const res = await this.makeRequestAsync({ method, bucketName, objectName, query })

      // We drain the socket so that the connection gets closed. Note that this
      // is not expensive as the socket will not have any data.
      // HEAD request doesn't expect to have many response body
      await drainResponse(res)

      const result: BucketItemStat = {
        size: parseInt(res.headers['content-length'] as string),
        metaData: extractMetadata(res.headers),
        lastModified: new Date(res.headers['last-modified'] as string),
        versionId: getVersionId(res.headers),
        etag: sanitizeETag(res.headers.etag),
      }

      return result
    })
  }

  // Stat information of the object.
  //
  // __Arguments__
  // * `bucketName` _string_: name of the bucket
  // * `objectName` _string_: name of the object
  // * `statOpts`  _object_ : Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional).
  // * `callback(err, stat)` _function_: `err` is not `null` in case of error, `stat` contains the object information:
  //   * `stat.size` _number_: size of the object
  //   * `stat.etag` _string_: etag of the object
  //   * `stat.metaData` _string_: MetaData of the object
  //   * `stat.lastModified` _Date_: modified time stamp

  // Complete the multipart upload. After all the parts are uploaded issuing

  // Returns a function that can be used for uploading objects.
  // If multipart === true, it returns function that is used to upload
  getUploader(
    bucketName: string,
    objectName: string,
    metaData: MetaData,
    multipart: false,
  ): (buf: Buffer, length: number, sha256sum: string, md5sum: string) => Promise<UploadedObjectInfo>
  getUploader(
    bucketName: string,
    objectName: string,
    metaData: MetaData,
    multipart: true,
  ): (
    uploadId: string,
    partNumber: number,
    buf: Buffer,
    length: number,
    sha256sum: string,
    md5sum: string,
  ) => Promise<UploadedObjectInfo>

  // a part of the multipart.
  getUploader(bucketName: string, objectName: string, metaData: MetaData, multipart: boolean) {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isValidObjectName(objectName)) {
      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)
    }
    if (!isBoolean(multipart)) {
      throw new TypeError('multipart should be of type "boolean"')
    }
    if (!isObject(metaData)) {
      throw new TypeError('metadata should be of type "object"')
    }

    const validate = (stream: stream.Readable | Buffer, length: number, sha256sum: string, md5sum: string) => {
      if (!(Buffer.isBuffer(stream) || isReadableStream(stream))) {
        throw new TypeError('stream should be of type "Stream" or Buffer')
      }
      if (!isNumber(length)) {
        throw new TypeError('length should be of type "number"')
      }
      if (!isString(sha256sum)) {
        throw new TypeError('sha256sum should be of type "string"')
      }
      if (!isString(md5sum)) {
        throw new TypeError('md5sum should be of type "string"')
      }
    }

    const simpleUploader = (buf: Buffer, length: number, sha256sum: string, md5sum: string) => {
      validate(buf, length, sha256sum, md5sum)
      return upload('', buf, length, sha256sum, md5sum)
    }

    const multipartUploader = (
      uploadId: string,
      partNumber: number,
      buf: Buffer,
      length: number,
      sha256sum: string,
      md5sum: string,
    ) => {
      if (!isString(uploadId)) {
        throw new TypeError('uploadId should be of type "string"')
      }
      if (!isNumber(partNumber)) {
        throw new TypeError('partNumber should be of type "number"')
      }
      if (!uploadId) {
        throw new errors.InvalidArgumentError('Empty uploadId')
      }
      if (!partNumber) {
        throw new errors.InvalidArgumentError('partNumber cannot be 0')
      }
      validate(buf, length, sha256sum, md5sum)
      const query = `partNumber=${partNumber}&uploadId=${uriEscape(uploadId)}`
      return upload(query, buf, length, sha256sum, md5sum)
    }

    const upload = async (query: string, stream: Buffer, length: number, sha256sum: string, md5sum: string) => {
      const method = 'PUT'
      let headers: RequestHeaders = { 'Content-Length': length }

      if (!multipart) {
        headers = Object.assign({}, metaData, headers)
      }

      if (!this.enableSHA256) {
        headers['Content-MD5'] = md5sum
      }

      const response = await this.makeRequestStreamAsync(
        {
          method,
          bucketName,
          objectName,
          query,
          headers,
        },
        stream,
        sha256sum,
        [200],
        '',
        false,
      )
      return {
        etag: sanitizeETag(response.headers.etag),
        versionId: getVersionId(response.headers),
      }
    }
    if (multipart) {
      return multipartUploader
    }
    return simpleUploader
  }

  // Get part-info of all parts of an incomplete upload specified by uploadId.
  listParts(bucketName: string, objectName: string, uploadId: string): Promise<Part[]> {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isValidObjectName(objectName)) {
      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)
    }
    if (!isString(uploadId)) {
      throw new TypeError('uploadId should be of type "string"')
    }
    if (!uploadId) {
      throw new errors.InvalidArgumentError('uploadId cannot be empty')
    }
    return new Promise<Part[]>((resolve, reject) => {
      let parts: Part[] = []
      const listNext = (marker?: number) => {
        this.listPartsQuery(bucketName, objectName, uploadId, marker)
          .then((result) => {
            parts = parts.concat(result.parts)
            if (result.isTruncated) {
              listNext(result.marker)
              return
            }
            resolve(parts)
          })
          .catch((e) => reject(e))
      }
      listNext(0)
    })
  }

  // Called by listParts to fetch a batch of part-info
  async listPartsQuery(bucketName: string, objectName: string, uploadId: string, marker?: number) {
    if (!isValidBucketName(bucketName)) {
      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)
    }
    if (!isValidObjectName(objectName)) {
      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)
    }
    if (!isString(uploadId)) {
      throw new TypeError('uploadId should be of type "string"')
    }
    if (!isNumber(marker)) {
      throw new TypeError('marker should be of type "number"')
    }
    if (!uploadId) {
      throw new errors.InvalidArgumentError('uploadId cannot be empty')
    }
    let query = ''
    if (marker && marker !== 0) {
      query += `part-number-marker=${marker}&`
    }
    query += `uploadId=${uriEscape(uploadId)}`

    const method = 'GET'

    const res = await this.makeRequestAsync({ method, bucketName, objectName, query })
    const body = await readAsBuffer(res)
    return xmlParsers.parseListParts(body.toString())
  }
}

function Discard() {}

function cbStyleReturn<T>(promise: Promise<T>, cb: (err: unknown | null, result: T) => void) {
  if (!isFunction(cb)) {
    throw new TypeError('callback should be of type "function"')
  }
  promise.then(
    (r) => {
      cb(null, r)
    },
    (err) => {
      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
      // @ts-ignore
      cb(err)
    },
  )
}

async function readAllAsString(res: http.IncomingMessage): Promise<string> {
  const body = await readAsBuffer(res)
  return body.toString()
}