@hanzo/s3 0.6.4 → 8.0.7

package/dist/esm/IamAwsProvider.mjs

@@ -0,0 +1,189 @@
+import * as fs from "fs/promises";
+import * as http from "http";
+import * as https from "https";
+import { URL, URLSearchParams } from "url";
+import { CredentialProvider } from "./CredentialProvider.mjs";
+import { Credentials } from "./Credentials.mjs";
+import { parseXml } from "./internal/helper.mjs";
+import { request } from "./internal/request.mjs";
+import { readAsString } from "./internal/response.mjs";
+export class IamAwsProvider extends CredentialProvider {
+  accessExpiresAt = '';
+  constructor({
+    customEndpoint = undefined,
+    transportAgent = undefined
+  }) {
+    super({
+      accessKey: '',
+      secretKey: ''
+    });
+    this.customEndpoint = customEndpoint;
+    this.transportAgent = transportAgent;
+
+    /**
+     * Internal Tracking variables
+     */
+    this._credentials = null;
+  }
+  async getCredentials() {
+    if (!this._credentials || this.isAboutToExpire()) {
+      this._credentials = await this.fetchCredentials();
+    }
+    return this._credentials;
+  }
+  async fetchCredentials() {
+    try {
+      // check for IRSA (https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html)
+      const tokenFile = process.env.AWS_WEB_IDENTITY_TOKEN_FILE;
+      if (tokenFile) {
+        return await this.fetchCredentialsUsingTokenFile(tokenFile);
+      }
+
+      // try with IAM role for EC2 instances (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)
+      let tokenHeader = 'Authorization';
+      let token = process.env.AWS_CONTAINER_AUTHORIZATION_TOKEN;
+      const relativeUri = process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI;
+      const fullUri = process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI;
+      let url;
+      if (relativeUri) {
+        url = new URL(relativeUri, 'http://169.254.170.2');
+      } else if (fullUri) {
+        url = new URL(fullUri);
+      } else {
+        token = await this.fetchImdsToken();
+        tokenHeader = 'X-aws-ec2-metadata-token';
+        url = await this.getIamRoleNamedUrl(token);
+      }
+      return this.requestCredentials(url, tokenHeader, token);
+    } catch (err) {
+      throw new Error(`Failed to get Credentials: ${err}`, {
+        cause: err
+      });
+    }
+  }
+  async fetchCredentialsUsingTokenFile(tokenFile) {
+    const token = await fs.readFile(tokenFile, {
+      encoding: 'utf8'
+    });
+    const region = process.env.AWS_REGION;
+    const stsEndpoint = new URL(region ? `https://sts.${region}.amazonaws.com` : 'https://sts.amazonaws.com');
+    const hostValue = stsEndpoint.hostname;
+    const portValue = stsEndpoint.port;
+    const qryParams = new URLSearchParams({
+      Action: 'AssumeRoleWithWebIdentity',
+      Version: '2011-06-15'
+    });
+    const roleArn = process.env.AWS_ROLE_ARN;
+    if (roleArn) {
+      qryParams.set('RoleArn', roleArn);
+      const roleSessionName = process.env.AWS_ROLE_SESSION_NAME;
+      qryParams.set('RoleSessionName', roleSessionName ? roleSessionName : Date.now().toString());
+    }
+    qryParams.set('WebIdentityToken', token);
+    qryParams.sort();
+    const requestOptions = {
+      hostname: hostValue,
+      port: portValue,
+      path: `${stsEndpoint.pathname}?${qryParams.toString()}`,
+      protocol: stsEndpoint.protocol,
+      method: 'POST',
+      headers: {},
+      agent: this.transportAgent
+    };
+    const transport = stsEndpoint.protocol === 'http:' ? http : https;
+    const res = await request(transport, requestOptions, null);
+    const body = await readAsString(res);
+    const assumeRoleResponse = parseXml(body);
+    const creds = assumeRoleResponse.AssumeRoleWithWebIdentityResponse.AssumeRoleWithWebIdentityResult.Credentials;
+    this.accessExpiresAt = creds.Expiration;
+    return new Credentials({
+      accessKey: creds.AccessKeyId,
+      secretKey: creds.SecretAccessKey,
+      sessionToken: creds.SessionToken
+    });
+  }
+  async fetchImdsToken() {
+    const endpoint = this.customEndpoint ? this.customEndpoint : 'http://169.254.169.254';
+    const url = new URL('/latest/api/token', endpoint);
+    const requestOptions = {
+      hostname: url.hostname,
+      port: url.port,
+      path: `${url.pathname}${url.search}`,
+      protocol: url.protocol,
+      method: 'PUT',
+      headers: {
+        'X-aws-ec2-metadata-token-ttl-seconds': '21600'
+      },
+      agent: this.transportAgent
+    };
+    const transport = url.protocol === 'http:' ? http : https;
+    const res = await request(transport, requestOptions, null);
+    return await readAsString(res);
+  }
+  async getIamRoleNamedUrl(token) {
+    const endpoint = this.customEndpoint ? this.customEndpoint : 'http://169.254.169.254';
+    const url = new URL('latest/meta-data/iam/security-credentials/', endpoint);
+    const roleName = await this.getIamRoleName(url, token);
+    return new URL(`${url.pathname}/${encodeURIComponent(roleName)}`, url.origin);
+  }
+  async getIamRoleName(url, token) {
+    const requestOptions = {
+      hostname: url.hostname,
+      port: url.port,
+      path: `${url.pathname}${url.search}`,
+      protocol: url.protocol,
+      method: 'GET',
+      headers: {
+        'X-aws-ec2-metadata-token': token
+      },
+      agent: this.transportAgent
+    };
+    const transport = url.protocol === 'http:' ? http : https;
+    const res = await request(transport, requestOptions, null);
+    const body = await readAsString(res);
+    const roleNames = body.split(/\r\n|[\n\r\u2028\u2029]/);
+    if (roleNames.length === 0) {
+      throw new Error(`No IAM roles attached to EC2 service ${url}`);
+    }
+    return roleNames[0];
+  }
+  async requestCredentials(url, tokenHeader, token) {
+    const headers = {};
+    if (token) {
+      headers[tokenHeader] = token;
+    }
+    const requestOptions = {
+      hostname: url.hostname,
+      port: url.port,
+      path: `${url.pathname}${url.search}`,
+      protocol: url.protocol,
+      method: 'GET',
+      headers: headers,
+      agent: this.transportAgent
+    };
+    const transport = url.protocol === 'http:' ? http : https;
+    const res = await request(transport, requestOptions, null);
+    const body = await readAsString(res);
+    const ecsCredentials = JSON.parse(body);
+    if (!ecsCredentials.Code || ecsCredentials.Code != 'Success') {
+      throw new Error(`${url} failed with code ${ecsCredentials.Code} and message ${ecsCredentials.Message}`);
+    }
+    this.accessExpiresAt = ecsCredentials.Expiration;
+    return new Credentials({
+      accessKey: ecsCredentials.AccessKeyID,
+      secretKey: ecsCredentials.SecretAccessKey,
+      sessionToken: ecsCredentials.Token
+    });
+  }
+  isAboutToExpire() {
+    const expiresAt = new Date(this.accessExpiresAt);
+    const provisionalExpiry = new Date(Date.now() + 1000 * 10); // 10 seconds leeway
+    return provisionalExpiry > expiresAt;
+  }
+}
+
+// deprecated default export, please use named exports.
+// keep for backward compatibility.
+// eslint-disable-next-line import/no-default-export
+export default IamAwsProvider;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fs","http","https","URL","URLSearchParams","CredentialProvider","Credentials","parseXml","request","readAsString","IamAwsProvider","accessExpiresAt","constructor","customEndpoint","undefined","transportAgent","accessKey","secretKey","_credentials","getCredentials","isAboutToExpire","fetchCredentials","tokenFile","process","env","AWS_WEB_IDENTITY_TOKEN_FILE","fetchCredentialsUsingTokenFile","tokenHeader","token","AWS_CONTAINER_AUTHORIZATION_TOKEN","relativeUri","AWS_CONTAINER_CREDENTIALS_RELATIVE_URI","fullUri","AWS_CONTAINER_CREDENTIALS_FULL_URI","url","fetchImdsToken","getIamRoleNamedUrl","requestCredentials","err","Error","cause","readFile","encoding","region","AWS_REGION","stsEndpoint","hostValue","hostname","portValue","port","qryParams","Action","Version","roleArn","AWS_ROLE_ARN","set","roleSessionName","AWS_ROLE_SESSION_NAME","Date","now","toString","sort","requestOptions","path","pathname","protocol","method","headers","agent","transport","res","body","assumeRoleResponse","creds","AssumeRoleWithWebIdentityResponse","AssumeRoleWithWebIdentityResult","Expiration","AccessKeyId","SecretAccessKey","sessionToken","SessionToken","endpoint","search","roleName","getIamRoleName","encodeURIComponent","origin","roleNames","split","length","ecsCredentials","JSON","parse","Code","Message","AccessKeyID","Token","expiresAt","provisionalExpiry"],"sources":["IamAwsProvider.ts"],"sourcesContent":["import * as fs from 'node:fs/promises'\nimport * as http from 'node:http'\nimport * as https from 'node:https'\nimport { URL, URLSearchParams } from 'node:url'\n\nimport { CredentialProvider } from './CredentialProvider.ts'\nimport { Credentials } from './Credentials.ts'\nimport { parseXml } from './internal/helper.ts'\nimport { request } from './internal/request.ts'\nimport { readAsString } from './internal/response.ts'\n\ninterface AssumeRoleResponse {\n  AssumeRoleWithWebIdentityResponse: {\n    AssumeRoleWithWebIdentityResult: {\n      Credentials: {\n        AccessKeyId: string\n        SecretAccessKey: string\n        SessionToken: string\n        Expiration: string\n      }\n    }\n  }\n}\n\ninterface EcsCredentials {\n  AccessKeyID: string\n  SecretAccessKey: string\n  Token: string\n  Expiration: string\n  Code: string\n  Message: string\n}\n\nexport interface IamAwsProviderOptions {\n  customEndpoint?: string\n  transportAgent?: http.Agent\n}\n\nexport class IamAwsProvider extends CredentialProvider {\n  private readonly customEndpoint?: string\n\n  private _credentials: Credentials | null\n  private readonly transportAgent?: http.Agent\n  private accessExpiresAt = ''\n\n  constructor({ customEndpoint = undefined, transportAgent = undefined }: IamAwsProviderOptions) {\n    super({ accessKey: '', secretKey: '' })\n\n    this.customEndpoint = customEndpoint\n    this.transportAgent = transportAgent\n\n    /**\n     * Internal Tracking variables\n     */\n    this._credentials = null\n  }\n\n  async getCredentials(): Promise<Credentials> {\n    if (!this._credentials || this.isAboutToExpire()) {\n      this._credentials = await this.fetchCredentials()\n    }\n    return this._credentials\n  }\n\n  private async fetchCredentials(): Promise<Credentials> {\n    try {\n      // check for IRSA (https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html)\n      const tokenFile = process.env.AWS_WEB_IDENTITY_TOKEN_FILE\n      if (tokenFile) {\n        return await this.fetchCredentialsUsingTokenFile(tokenFile)\n      }\n\n      // try with IAM role for EC2 instances (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)\n      let tokenHeader = 'Authorization'\n      let token = process.env.AWS_CONTAINER_AUTHORIZATION_TOKEN\n      const relativeUri = process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI\n      const fullUri = process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI\n      let url: URL\n      if (relativeUri) {\n        url = new URL(relativeUri, 'http://169.254.170.2')\n      } else if (fullUri) {\n        url = new URL(fullUri)\n      } else {\n        token = await this.fetchImdsToken()\n        tokenHeader = 'X-aws-ec2-metadata-token'\n        url = await this.getIamRoleNamedUrl(token)\n      }\n\n      return this.requestCredentials(url, tokenHeader, token)\n    } catch (err) {\n      throw new Error(`Failed to get Credentials: ${err}`, { cause: err })\n    }\n  }\n\n  private async fetchCredentialsUsingTokenFile(tokenFile: string): Promise<Credentials> {\n    const token = await fs.readFile(tokenFile, { encoding: 'utf8' })\n    const region = process.env.AWS_REGION\n    const stsEndpoint = new URL(region ? `https://sts.${region}.amazonaws.com` : 'https://sts.amazonaws.com')\n\n    const hostValue = stsEndpoint.hostname\n    const portValue = stsEndpoint.port\n    const qryParams = new URLSearchParams({\n      Action: 'AssumeRoleWithWebIdentity',\n      Version: '2011-06-15',\n    })\n\n    const roleArn = process.env.AWS_ROLE_ARN\n    if (roleArn) {\n      qryParams.set('RoleArn', roleArn)\n      const roleSessionName = process.env.AWS_ROLE_SESSION_NAME\n      qryParams.set('RoleSessionName', roleSessionName ? roleSessionName : Date.now().toString())\n    }\n\n    qryParams.set('WebIdentityToken', token)\n    qryParams.sort()\n\n    const requestOptions = {\n      hostname: hostValue,\n      port: portValue,\n      path: `${stsEndpoint.pathname}?${qryParams.toString()}`,\n      protocol: stsEndpoint.protocol,\n      method: 'POST',\n      headers: {},\n      agent: this.transportAgent,\n    } satisfies http.RequestOptions\n\n    const transport = stsEndpoint.protocol === 'http:' ? http : https\n    const res = await request(transport, requestOptions, null)\n    const body = await readAsString(res)\n\n    const assumeRoleResponse: AssumeRoleResponse = parseXml(body)\n    const creds = assumeRoleResponse.AssumeRoleWithWebIdentityResponse.AssumeRoleWithWebIdentityResult.Credentials\n    this.accessExpiresAt = creds.Expiration\n    return new Credentials({\n      accessKey: creds.AccessKeyId,\n      secretKey: creds.SecretAccessKey,\n      sessionToken: creds.SessionToken,\n    })\n  }\n\n  private async fetchImdsToken() {\n    const endpoint = this.customEndpoint ? this.customEndpoint : 'http://169.254.169.254'\n    const url = new URL('/latest/api/token', endpoint)\n\n    const requestOptions = {\n      hostname: url.hostname,\n      port: url.port,\n      path: `${url.pathname}${url.search}`,\n      protocol: url.protocol,\n      method: 'PUT',\n      headers: {\n        'X-aws-ec2-metadata-token-ttl-seconds': '21600',\n      },\n      agent: this.transportAgent,\n    } satisfies http.RequestOptions\n\n    const transport = url.protocol === 'http:' ? http : https\n    const res = await request(transport, requestOptions, null)\n    return await readAsString(res)\n  }\n\n  private async getIamRoleNamedUrl(token: string) {\n    const endpoint = this.customEndpoint ? this.customEndpoint : 'http://169.254.169.254'\n    const url = new URL('latest/meta-data/iam/security-credentials/', endpoint)\n\n    const roleName = await this.getIamRoleName(url, token)\n    return new URL(`${url.pathname}/${encodeURIComponent(roleName)}`, url.origin)\n  }\n\n  private async getIamRoleName(url: URL, token: string): Promise<string> {\n    const requestOptions = {\n      hostname: url.hostname,\n      port: url.port,\n      path: `${url.pathname}${url.search}`,\n      protocol: url.protocol,\n      method: 'GET',\n      headers: {\n        'X-aws-ec2-metadata-token': token,\n      },\n      agent: this.transportAgent,\n    } satisfies http.RequestOptions\n\n    const transport = url.protocol === 'http:' ? http : https\n    const res = await request(transport, requestOptions, null)\n    const body = await readAsString(res)\n    const roleNames = body.split(/\\r\\n|[\\n\\r\\u2028\\u2029]/)\n    if (roleNames.length === 0) {\n      throw new Error(`No IAM roles attached to EC2 service ${url}`)\n    }\n    return roleNames[0] as string\n  }\n\n  private async requestCredentials(url: URL, tokenHeader: string, token: string | undefined): Promise<Credentials> {\n    const headers: Record<string, string> = {}\n    if (token) {\n      headers[tokenHeader] = token\n    }\n    const requestOptions = {\n      hostname: url.hostname,\n      port: url.port,\n      path: `${url.pathname}${url.search}`,\n      protocol: url.protocol,\n      method: 'GET',\n      headers: headers,\n      agent: this.transportAgent,\n    } satisfies http.RequestOptions\n\n    const transport = url.protocol === 'http:' ? http : https\n    const res = await request(transport, requestOptions, null)\n    const body = await readAsString(res)\n    const ecsCredentials = JSON.parse(body) as EcsCredentials\n    if (!ecsCredentials.Code || ecsCredentials.Code != 'Success') {\n      throw new Error(`${url} failed with code ${ecsCredentials.Code} and message ${ecsCredentials.Message}`)\n    }\n\n    this.accessExpiresAt = ecsCredentials.Expiration\n    return new Credentials({\n      accessKey: ecsCredentials.AccessKeyID,\n      secretKey: ecsCredentials.SecretAccessKey,\n      sessionToken: ecsCredentials.Token,\n    })\n  }\n\n  private isAboutToExpire() {\n    const expiresAt = new Date(this.accessExpiresAt)\n    const provisionalExpiry = new Date(Date.now() + 1000 * 10) // 10 seconds leeway\n    return provisionalExpiry > expiresAt\n  }\n}\n\n// deprecated default export, please use named exports.\n// keep for backward compatibility.\n// eslint-disable-next-line import/no-default-export\nexport default IamAwsProvider\n"],"mappings":"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"}

package/dist/esm/errors.d.mts

@@ -0,0 +1,82 @@
+/// <reference lib="es2022.error" />
+declare class ExtendableError extends Error {
+  constructor(message?: string, opt?: ErrorOptions);
+}
+/**
+ * AnonymousRequestError is generated for anonymous keys on specific
+ * APIs. NOTE: PresignedURL generation always requires access keys.
+ */
+export declare class AnonymousRequestError extends ExtendableError {}
+/**
+ * InvalidArgumentError is generated for all invalid arguments.
+ */
+export declare class InvalidArgumentError extends ExtendableError {}
+/**
+ * InvalidPortError is generated when a non integer value is provided
+ * for ports.
+ */
+export declare class InvalidPortError extends ExtendableError {}
+/**
+ * InvalidEndpointError is generated when an invalid end point value is
+ * provided which does not follow domain standards.
+ */
+export declare class InvalidEndpointError extends ExtendableError {}
+/**
+ * InvalidBucketNameError is generated when an invalid bucket name is
+ * provided which does not follow AWS S3 specifications.
+ * http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html
+ */
+export declare class InvalidBucketNameError extends ExtendableError {}
+/**
+ * InvalidObjectNameError is generated when an invalid object name is
+ * provided which does not follow AWS S3 specifications.
+ * http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html
+ */
+export declare class InvalidObjectNameError extends ExtendableError {}
+/**
+ * AccessKeyRequiredError generated by signature methods when access
+ * key is not found.
+ */
+export declare class AccessKeyRequiredError extends ExtendableError {}
+/**
+ * SecretKeyRequiredError generated by signature methods when secret
+ * key is not found.
+ */
+export declare class SecretKeyRequiredError extends ExtendableError {}
+/**
+ * ExpiresParamError generated when expires parameter value is not
+ * well within stipulated limits.
+ */
+export declare class ExpiresParamError extends ExtendableError {}
+/**
+ * InvalidDateError generated when invalid date is found.
+ */
+export declare class InvalidDateError extends ExtendableError {}
+/**
+ * InvalidPrefixError generated when object prefix provided is invalid
+ * or does not conform to AWS S3 object key restrictions.
+ */
+export declare class InvalidPrefixError extends ExtendableError {}
+/**
+ * InvalidBucketPolicyError generated when the given bucket policy is invalid.
+ */
+export declare class InvalidBucketPolicyError extends ExtendableError {}
+/**
+ * IncorrectSizeError generated when total data read mismatches with
+ * the input size.
+ */
+export declare class IncorrectSizeError extends ExtendableError {}
+/**
+ * InvalidXMLError generated when an unknown XML is found.
+ */
+export declare class InvalidXMLError extends ExtendableError {}
+/**
+ * S3Error is generated for errors returned from S3 server.
+ * see getErrorTransformer for details
+ */
+export declare class S3Error extends ExtendableError {
+  code?: string;
+  region?: string;
+}
+export declare class IsValidBucketNameError extends ExtendableError {}
+export {};

package/dist/esm/errors.mjs

@@ -0,0 +1,117 @@
+/*
+ * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 Hanzo AI, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// <reference lib="ES2022.Error" />
+
+class ExtendableError extends Error {
+  constructor(message, opt) {
+    // error Option {cause?: unknown} is a 'nice to have',
+    // don't use it internally
+    super(message, opt);
+    // set error name, otherwise it's always 'Error'
+    this.name = this.constructor.name;
+  }
+}
+
+/**
+ * AnonymousRequestError is generated for anonymous keys on specific
+ * APIs. NOTE: PresignedURL generation always requires access keys.
+ */
+export class AnonymousRequestError extends ExtendableError {}
+
+/**
+ * InvalidArgumentError is generated for all invalid arguments.
+ */
+export class InvalidArgumentError extends ExtendableError {}
+
+/**
+ * InvalidPortError is generated when a non integer value is provided
+ * for ports.
+ */
+export class InvalidPortError extends ExtendableError {}
+
+/**
+ * InvalidEndpointError is generated when an invalid end point value is
+ * provided which does not follow domain standards.
+ */
+export class InvalidEndpointError extends ExtendableError {}
+
+/**
+ * InvalidBucketNameError is generated when an invalid bucket name is
+ * provided which does not follow AWS S3 specifications.
+ * http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html
+ */
+export class InvalidBucketNameError extends ExtendableError {}
+
+/**
+ * InvalidObjectNameError is generated when an invalid object name is
+ * provided which does not follow AWS S3 specifications.
+ * http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html
+ */
+export class InvalidObjectNameError extends ExtendableError {}
+
+/**
+ * AccessKeyRequiredError generated by signature methods when access
+ * key is not found.
+ */
+export class AccessKeyRequiredError extends ExtendableError {}
+
+/**
+ * SecretKeyRequiredError generated by signature methods when secret
+ * key is not found.
+ */
+export class SecretKeyRequiredError extends ExtendableError {}
+
+/**
+ * ExpiresParamError generated when expires parameter value is not
+ * well within stipulated limits.
+ */
+export class ExpiresParamError extends ExtendableError {}
+
+/**
+ * InvalidDateError generated when invalid date is found.
+ */
+export class InvalidDateError extends ExtendableError {}
+
+/**
+ * InvalidPrefixError generated when object prefix provided is invalid
+ * or does not conform to AWS S3 object key restrictions.
+ */
+export class InvalidPrefixError extends ExtendableError {}
+
+/**
+ * InvalidBucketPolicyError generated when the given bucket policy is invalid.
+ */
+export class InvalidBucketPolicyError extends ExtendableError {}
+
+/**
+ * IncorrectSizeError generated when total data read mismatches with
+ * the input size.
+ */
+export class IncorrectSizeError extends ExtendableError {}
+
+/**
+ * InvalidXMLError generated when an unknown XML is found.
+ */
+export class InvalidXMLError extends ExtendableError {}
+
+/**
+ * S3Error is generated for errors returned from S3 server.
+ * see getErrorTransformer for details
+ */
+export class S3Error extends ExtendableError {}
+export class IsValidBucketNameError extends ExtendableError {}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJFeHRlbmRhYmxlRXJyb3IiLCJFcnJvciIsImNvbnN0cnVjdG9yIiwibWVzc2FnZSIsIm9wdCIsIm5hbWUiLCJBbm9ueW1vdXNSZXF1ZXN0RXJyb3IiLCJJbnZhbGlkQXJndW1lbnRFcnJvciIsIkludmFsaWRQb3J0RXJyb3IiLCJJbnZhbGlkRW5kcG9pbnRFcnJvciIsIkludmFsaWRCdWNrZXROYW1lRXJyb3IiLCJJbnZhbGlkT2JqZWN0TmFtZUVycm9yIiwiQWNjZXNzS2V5UmVxdWlyZWRFcnJvciIsIlNlY3JldEtleVJlcXVpcmVkRXJyb3IiLCJFeHBpcmVzUGFyYW1FcnJvciIsIkludmFsaWREYXRlRXJyb3IiLCJJbnZhbGlkUHJlZml4RXJyb3IiLCJJbnZhbGlkQnVja2V0UG9saWN5RXJyb3IiLCJJbmNvcnJlY3RTaXplRXJyb3IiLCJJbnZhbGlkWE1MRXJyb3IiLCJTM0Vycm9yIiwiSXNWYWxpZEJ1Y2tldE5hbWVFcnJvciJdLCJzb3VyY2VzIjpbImVycm9ycy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogSGFuem8gUzMgSmF2YXNjcmlwdCBMaWJyYXJ5IGZvciBBbWF6b24gUzMgQ29tcGF0aWJsZSBDbG91ZCBTdG9yYWdlLCAoQykgMjAxNSBIYW56byBBSSwgSW5jLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG4vLy8gPHJlZmVyZW5jZSBsaWI9XCJFUzIwMjIuRXJyb3JcIiAvPlxuXG5jbGFzcyBFeHRlbmRhYmxlRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1lc3NhZ2U/OiBzdHJpbmcsIG9wdD86IEVycm9yT3B0aW9ucykge1xuICAgIC8vIGVycm9yIE9wdGlvbiB7Y2F1c2U/OiB1bmtub3dufSBpcyBhICduaWNlIHRvIGhhdmUnLFxuICAgIC8vIGRvbid0IHVzZSBpdCBpbnRlcm5hbGx5XG4gICAgc3VwZXIobWVzc2FnZSwgb3B0KVxuICAgIC8vIHNldCBlcnJvciBuYW1lLCBvdGhlcndpc2UgaXQncyBhbHdheXMgJ0Vycm9yJ1xuICAgIHRoaXMubmFtZSA9IHRoaXMuY29uc3RydWN0b3IubmFtZVxuICB9XG59XG5cbi8qKlxuICogQW5vbnltb3VzUmVxdWVzdEVycm9yIGlzIGdlbmVyYXRlZCBmb3IgYW5vbnltb3VzIGtleXMgb24gc3BlY2lmaWNcbiAqIEFQSXMuIE5PVEU6IFByZXNpZ25lZFVSTCBnZW5lcmF0aW9uIGFsd2F5cyByZXF1aXJlcyBhY2Nlc3Mga2V5cy5cbiAqL1xuZXhwb3J0IGNsYXNzIEFub255bW91c1JlcXVlc3RFcnJvciBleHRlbmRzIEV4dGVuZGFibGVFcnJvciB7fVxuXG4vKipcbiAqIEludmFsaWRBcmd1bWVudEVycm9yIGlzIGdlbmVyYXRlZCBmb3IgYWxsIGludmFsaWQgYXJndW1lbnRzLlxuICovXG5leHBvcnQgY2xhc3MgSW52YWxpZEFyZ3VtZW50RXJyb3IgZXh0ZW5kcyBFeHRlbmRhYmxlRXJyb3Ige31cblxuLyoqXG4gKiBJbnZhbGlkUG9ydEVycm9yIGlzIGdlbmVyYXRlZCB3aGVuIGEgbm9uIGludGVnZXIgdmFsdWUgaXMgcHJvdmlkZWRcbiAqIGZvciBwb3J0cy5cbiAqL1xuZXhwb3J0IGNsYXNzIEludmFsaWRQb3J0RXJyb3IgZXh0ZW5kcyBFeHRlbmRhYmxlRXJyb3Ige31cblxuLyoqXG4gKiBJbnZhbGlkRW5kcG9pbnRFcnJvciBpcyBnZW5lcmF0ZWQgd2hlbiBhbiBpbnZhbGlkIGVuZCBwb2ludCB2YWx1ZSBpc1xuICogcHJvdmlkZWQgd2hpY2ggZG9lcyBub3QgZm9sbG93IGRvbWFpbiBzdGFuZGFyZHMuXG4gKi9cbmV4cG9ydCBjbGFzcyBJbnZhbGlkRW5kcG9pbnRFcnJvciBleHRlbmRzIEV4dGVuZGFibGVFcnJvciB7fVxuXG4vKipcbiAqIEludmFsaWRCdWNrZXROYW1lRXJyb3IgaXMgZ2VuZXJhdGVkIHdoZW4gYW4gaW52YWxpZCBidWNrZXQgbmFtZSBpc1xuICogcHJvdmlkZWQgd2hpY2ggZG9lcyBub3QgZm9sbG93IEFXUyBTMyBzcGVjaWZpY2F0aW9ucy5cbiAqIGh0dHA6Ly9kb2NzLmF3cy5hbWF6b24uY29tL0FtYXpvblMzL2xhdGVzdC9kZXYvQnVja2V0UmVzdHJpY3Rpb25zLmh0bWxcbiAqL1xuZXhwb3J0IGNsYXNzIEludmFsaWRCdWNrZXROYW1lRXJyb3IgZXh0ZW5kcyBFeHRlbmRhYmxlRXJyb3Ige31cblxuLyoqXG4gKiBJbnZhbGlkT2JqZWN0TmFtZUVycm9yIGlzIGdlbmVyYXRlZCB3aGVuIGFuIGludmFsaWQgb2JqZWN0IG5hbWUgaXNcbiAqIHByb3ZpZGVkIHdoaWNoIGRvZXMgbm90IGZvbGxvdyBBV1MgUzMgc3BlY2lmaWNhdGlvbnMuXG4gKiBodHRwOi8vZG9jcy5hd3MuYW1hem9uLmNvbS9BbWF6b25TMy9sYXRlc3QvZGV2L1VzaW5nTWV0YWRhdGEuaHRtbFxuICovXG5leHBvcnQgY2xhc3MgSW52YWxpZE9iamVjdE5hbWVFcnJvciBleHRlbmRzIEV4dGVuZGFibGVFcnJvciB7fVxuXG4vKipcbiAqIEFjY2Vzc0tleVJlcXVpcmVkRXJyb3IgZ2VuZXJhdGVkIGJ5IHNpZ25hdHVyZSBtZXRob2RzIHdoZW4gYWNjZXNzXG4gKiBrZXkgaXMgbm90IGZvdW5kLlxuICovXG5leHBvcnQgY2xhc3MgQWNjZXNzS2V5UmVxdWlyZWRFcnJvciBleHRlbmRzIEV4dGVuZGFibGVFcnJvciB7fVxuXG4vKipcbiAqIFNlY3JldEtleVJlcXVpcmVkRXJyb3IgZ2VuZXJhdGVkIGJ5IHNpZ25hdHVyZSBtZXRob2RzIHdoZW4gc2VjcmV0XG4gKiBrZXkgaXMgbm90IGZvdW5kLlxuICovXG5leHBvcnQgY2xhc3MgU2VjcmV0S2V5UmVxdWlyZWRFcnJvciBleHRlbmRzIEV4dGVuZGFibGVFcnJvciB7fVxuXG4vKipcbiAqIEV4cGlyZXNQYXJhbUVycm9yIGdlbmVyYXRlZCB3aGVuIGV4cGlyZXMgcGFyYW1ldGVyIHZhbHVlIGlzIG5vdFxuICogd2VsbCB3aXRoaW4gc3RpcHVsYXRlZCBsaW1pdHMuXG4gKi9cbmV4cG9ydCBjbGFzcyBFeHBpcmVzUGFyYW1FcnJvciBleHRlbmRzIEV4dGVuZGFibGVFcnJvciB7fVxuXG4vKipcbiAqIEludmFsaWREYXRlRXJyb3IgZ2VuZXJhdGVkIHdoZW4gaW52YWxpZCBkYXRlIGlzIGZvdW5kLlxuICovXG5leHBvcnQgY2xhc3MgSW52YWxpZERhdGVFcnJvciBleHRlbmRzIEV4dGVuZGFibGVFcnJvciB7fVxuXG4vKipcbiAqIEludmFsaWRQcmVmaXhFcnJvciBnZW5lcmF0ZWQgd2hlbiBvYmplY3QgcHJlZml4IHByb3ZpZGVkIGlzIGludmFsaWRcbiAqIG9yIGRvZXMgbm90IGNvbmZvcm0gdG8gQVdTIFMzIG9iamVjdCBrZXkgcmVzdHJpY3Rpb25zLlxuICovXG5leHBvcnQgY2xhc3MgSW52YWxpZFByZWZpeEVycm9yIGV4dGVuZHMgRXh0ZW5kYWJsZUVycm9yIHt9XG5cbi8qKlxuICogSW52YWxpZEJ1Y2tldFBvbGljeUVycm9yIGdlbmVyYXRlZCB3aGVuIHRoZSBnaXZlbiBidWNrZXQgcG9saWN5IGlzIGludmFsaWQuXG4gKi9cbmV4cG9ydCBjbGFzcyBJbnZhbGlkQnVja2V0UG9saWN5RXJyb3IgZXh0ZW5kcyBFeHRlbmRhYmxlRXJyb3Ige31cblxuLyoqXG4gKiBJbmNvcnJlY3RTaXplRXJyb3IgZ2VuZXJhdGVkIHdoZW4gdG90YWwgZGF0YSByZWFkIG1pc21hdGNoZXMgd2l0aFxuICogdGhlIGlucHV0IHNpemUuXG4gKi9cbmV4cG9ydCBjbGFzcyBJbmNvcnJlY3RTaXplRXJyb3IgZXh0ZW5kcyBFeHRlbmRhYmxlRXJyb3Ige31cblxuLyoqXG4gKiBJbnZhbGlkWE1MRXJyb3IgZ2VuZXJhdGVkIHdoZW4gYW4gdW5rbm93biBYTUwgaXMgZm91bmQuXG4gKi9cbmV4cG9ydCBjbGFzcyBJbnZhbGlkWE1MRXJyb3IgZXh0ZW5kcyBFeHRlbmRhYmxlRXJyb3Ige31cblxuLyoqXG4gKiBTM0Vycm9yIGlzIGdlbmVyYXRlZCBmb3IgZXJyb3JzIHJldHVybmVkIGZyb20gUzMgc2VydmVyLlxuICogc2VlIGdldEVycm9yVHJhbnNmb3JtZXIgZm9yIGRldGFpbHNcbiAqL1xuZXhwb3J0IGNsYXNzIFMzRXJyb3IgZXh0ZW5kcyBFeHRlbmRhYmxlRXJyb3Ige1xuICBjb2RlPzogc3RyaW5nXG4gIHJlZ2lvbj86IHN0cmluZ1xufVxuXG5leHBvcnQgY2xhc3MgSXNWYWxpZEJ1Y2tldE5hbWVFcnJvciBleHRlbmRzIEV4dGVuZGFibGVFcnJvciB7fVxuIl0sIm1hcHBpbmdzIjoiQUFBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7O0FBRUE7O0FBRUEsTUFBTUEsZUFBZSxTQUFTQyxLQUFLLENBQUM7RUFDbENDLFdBQVdBLENBQUNDLE9BQWdCLEVBQUVDLEdBQWtCLEVBQUU7SUFDaEQ7SUFDQTtJQUNBLEtBQUssQ0FBQ0QsT0FBTyxFQUFFQyxHQUFHLENBQUM7SUFDbkI7SUFDQSxJQUFJLENBQUNDLElBQUksR0FBRyxJQUFJLENBQUNILFdBQVcsQ0FBQ0csSUFBSTtFQUNuQztBQUNGOztBQUVBO0FBQ0E7QUFDQTtBQUNBO0FBQ0EsT0FBTyxNQUFNQyxxQkFBcUIsU0FBU04sZUFBZSxDQUFDOztBQUUzRDtBQUNBO0FBQ0E7QUFDQSxPQUFPLE1BQU1PLG9CQUFvQixTQUFTUCxlQUFlLENBQUM7O0FBRTFEO0FBQ0E7QUFDQTtBQUNBO0FBQ0EsT0FBTyxNQUFNUSxnQkFBZ0IsU0FBU1IsZUFBZSxDQUFDOztBQUV0RDtBQUNBO0FBQ0E7QUFDQTtBQUNBLE9BQU8sTUFBTVMsb0JBQW9CLFNBQVNULGVBQWUsQ0FBQzs7QUFFMUQ7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBLE9BQU8sTUFBTVUsc0JBQXNCLFNBQVNWLGVBQWUsQ0FBQzs7QUFFNUQ7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBLE9BQU8sTUFBTVcsc0JBQXNCLFNBQVNYLGVBQWUsQ0FBQzs7QUFFNUQ7QUFDQTtBQUNBO0FBQ0E7QUFDQSxPQUFPLE1BQU1ZLHNCQUFzQixTQUFTWixlQUFlLENBQUM7O0FBRTVEO0FBQ0E7QUFDQTtBQUNBO0FBQ0EsT0FBTyxNQUFNYSxzQkFBc0IsU0FBU2IsZUFBZSxDQUFDOztBQUU1RDtBQUNBO0FBQ0E7QUFDQTtBQUNBLE9BQU8sTUFBTWMsaUJBQWlCLFNBQVNkLGVBQWUsQ0FBQzs7QUFFdkQ7QUFDQTtBQUNBO0FBQ0EsT0FBTyxNQUFNZSxnQkFBZ0IsU0FBU2YsZUFBZSxDQUFDOztBQUV0RDtBQUNBO0FBQ0E7QUFDQTtBQUNBLE9BQU8sTUFBTWdCLGtCQUFrQixTQUFTaEIsZUFBZSxDQUFDOztBQUV4RDtBQUNBO0FBQ0E7QUFDQSxPQUFPLE1BQU1pQix3QkFBd0IsU0FBU2pCLGVBQWUsQ0FBQzs7QUFFOUQ7QUFDQTtBQUNBO0FBQ0E7QUFDQSxPQUFPLE1BQU1rQixrQkFBa0IsU0FBU2xCLGVBQWUsQ0FBQzs7QUFFeEQ7QUFDQTtBQUNBO0FBQ0EsT0FBTyxNQUFNbUIsZUFBZSxTQUFTbkIsZUFBZSxDQUFDOztBQUVyRDtBQUNBO0FBQ0E7QUFDQTtBQUNBLE9BQU8sTUFBTW9CLE9BQU8sU0FBU3BCLGVBQWUsQ0FBQztBQUs3QyxPQUFPLE1BQU1xQixzQkFBc0IsU0FBU3JCLGVBQWUsQ0FBQyJ9

package/dist/esm/helpers.d.mts

@@ -0,0 +1,156 @@
+import type { Encryption, ObjectMetaData, RequestHeaders } from "./internal/type.mjs";
+import { RETENTION_MODES } from "./internal/type.mjs";
+export { ENCRYPTION_TYPES, LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from "./internal/type.mjs";
+export declare const DEFAULT_REGION = "us-east-1";
+export declare const PRESIGN_EXPIRY_DAYS_MAX: number;
+export interface ICopySourceOptions {
+  Bucket: string;
+  Object: string;
+  /**
+   * Valid versionId
+   */
+  VersionID?: string;
+  /**
+   * Etag to match
+   */
+  MatchETag?: string;
+  /**
+   * Etag to exclude
+   */
+  NoMatchETag?: string;
+  /**
+   * Modified Date of the object/part.  UTC Date in string format
+   */
+  MatchModifiedSince?: string | null;
+  /**
+   * Modified Date of the object/part to exclude UTC Date in string format
+   */
+  MatchUnmodifiedSince?: string | null;
+  /**
+   * true or false Object range to match
+   */
+  MatchRange?: boolean;
+  Start?: number;
+  End?: number;
+  Encryption?: Encryption;
+}
+export declare class CopySourceOptions {
+  readonly Bucket: string;
+  readonly Object: string;
+  readonly VersionID: string;
+  MatchETag: string;
+  private readonly NoMatchETag;
+  private readonly MatchModifiedSince;
+  private readonly MatchUnmodifiedSince;
+  readonly MatchRange: boolean;
+  readonly Start: number;
+  readonly End: number;
+  private readonly Encryption?;
+  constructor({
+    Bucket,
+    Object,
+    VersionID,
+    MatchETag,
+    NoMatchETag,
+    MatchModifiedSince,
+    MatchUnmodifiedSince,
+    MatchRange,
+    Start,
+    End,
+    Encryption
+  }: ICopySourceOptions);
+  validate(): boolean;
+  getHeaders(): RequestHeaders;
+}
+/**
+ * @deprecated use nodejs fs module
+ */
+export declare function removeDirAndFiles(dirPath: string, removeSelf?: boolean): void;
+export interface ICopyDestinationOptions {
+  /**
+   * Bucket name
+   */
+  Bucket: string;
+  /**
+   * Object Name for the destination (composed/copied) object defaults
+   */
+  Object: string;
+  /**
+   * Encryption configuration defaults to {}
+   * @default {}
+   */
+  Encryption?: Encryption;
+  UserMetadata?: ObjectMetaData;
+  /**
+   * query-string encoded string or Record<string, string> Object
+   */
+  UserTags?: Record<string, string> | string;
+  LegalHold?: 'on' | 'off';
+  /**
+   * UTC Date String
+   */
+  RetainUntilDate?: string;
+  Mode?: RETENTION_MODES;
+  MetadataDirective?: 'COPY' | 'REPLACE';
+  /**
+   * Extra headers for the target object
+   */
+  Headers?: Record<string, string>;
+}
+export declare class CopyDestinationOptions {
+  readonly Bucket: string;
+  readonly Object: string;
+  private readonly Encryption?;
+  private readonly UserMetadata?;
+  private readonly UserTags?;
+  private readonly LegalHold?;
+  private readonly RetainUntilDate?;
+  private readonly Mode?;
+  private readonly MetadataDirective?;
+  private readonly Headers?;
+  constructor({
+    Bucket,
+    Object,
+    Encryption,
+    UserMetadata,
+    UserTags,
+    LegalHold,
+    RetainUntilDate,
+    Mode,
+    MetadataDirective,
+    Headers
+  }: ICopyDestinationOptions);
+  getHeaders(): RequestHeaders;
+  validate(): boolean;
+}
+/**
+ * maybe this should be a generic type for Records, leave it for later refactor
+ */
+export declare class SelectResults {
+  private records?;
+  private response?;
+  private stats?;
+  private progress?;
+  constructor({
+    records,
+    // parsed data as stream
+    response,
+    // original response stream
+    stats,
+    // stats as xml
+    progress
+  }: {
+    records?: unknown;
+    response?: unknown;
+    stats?: string;
+    progress?: unknown;
+  });
+  setStats(stats: string): void;
+  getStats(): string | undefined;
+  setProgress(progress: unknown): void;
+  getProgress(): unknown;
+  setResponse(response: unknown): void;
+  getResponse(): unknown;
+  setRecords(records: unknown): void;
+  getRecords(): unknown;
+}