@hanzo/s3 0.6.4 → 8.0.7

package/dist/main/helpers.d.ts

@@ -0,0 +1,156 @@
+import type { Encryption, ObjectMetaData, RequestHeaders } from "./internal/type.js";
+import { RETENTION_MODES } from "./internal/type.js";
+export { ENCRYPTION_TYPES, LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from "./internal/type.js";
+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;
+}

package/dist/main/helpers.js

@@ -0,0 +1,233 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeDirAndFiles = removeDirAndFiles;
+var fs = _interopRequireWildcard(require("fs"), true);
+var path = _interopRequireWildcard(require("path"), true);
+var querystring = _interopRequireWildcard(require("query-string"), true);
+var errors = _interopRequireWildcard(require("./errors.js"), true);
+var _helper = require("./internal/helper.js");
+var _type = require("./internal/type.js");
+exports.RETENTION_MODES = _type.RETENTION_MODES;
+exports.ENCRYPTION_TYPES = _type.ENCRYPTION_TYPES;
+exports.LEGAL_HOLD_STATUS = _type.LEGAL_HOLD_STATUS;
+exports.RETENTION_VALIDITY_UNITS = _type.RETENTION_VALIDITY_UNITS;
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const DEFAULT_REGION = 'us-east-1';
+exports.DEFAULT_REGION = DEFAULT_REGION;
+const PRESIGN_EXPIRY_DAYS_MAX = 24 * 60 * 60 * 7; // 7 days in seconds
+exports.PRESIGN_EXPIRY_DAYS_MAX = PRESIGN_EXPIRY_DAYS_MAX;
+class CopySourceOptions {
+  constructor({
+    Bucket,
+    Object,
+    VersionID = '',
+    MatchETag = '',
+    NoMatchETag = '',
+    MatchModifiedSince = null,
+    MatchUnmodifiedSince = null,
+    MatchRange = false,
+    Start = 0,
+    End = 0,
+    Encryption = undefined
+  }) {
+    this.Bucket = Bucket;
+    this.Object = Object;
+    this.VersionID = VersionID;
+    this.MatchETag = MatchETag;
+    this.NoMatchETag = NoMatchETag;
+    this.MatchModifiedSince = MatchModifiedSince;
+    this.MatchUnmodifiedSince = MatchUnmodifiedSince;
+    this.MatchRange = MatchRange;
+    this.Start = Start;
+    this.End = End;
+    this.Encryption = Encryption;
+  }
+  validate() {
+    if (!(0, _helper.isValidBucketName)(this.Bucket)) {
+      throw new errors.InvalidBucketNameError('Invalid Source bucket name: ' + this.Bucket);
+    }
+    if (!(0, _helper.isValidObjectName)(this.Object)) {
+      throw new errors.InvalidObjectNameError(`Invalid Source object name: ${this.Object}`);
+    }
+    if (this.MatchRange && this.Start !== -1 && this.End !== -1 && this.Start > this.End || this.Start < 0) {
+      throw new errors.InvalidObjectNameError('Source start must be non-negative, and start must be at most end.');
+    } else if (this.MatchRange && !(0, _helper.isNumber)(this.Start) || !(0, _helper.isNumber)(this.End)) {
+      throw new errors.InvalidObjectNameError('MatchRange is specified. But Invalid Start and End values are specified.');
+    }
+    return true;
+  }
+  getHeaders() {
+    const headerOptions = {};
+    headerOptions['x-amz-copy-source'] = encodeURI(this.Bucket + '/' + this.Object);
+    if (!(0, _helper.isEmpty)(this.VersionID)) {
+      headerOptions['x-amz-copy-source'] = `${encodeURI(this.Bucket + '/' + this.Object)}?versionId=${this.VersionID}`;
+    }
+    if (!(0, _helper.isEmpty)(this.MatchETag)) {
+      headerOptions['x-amz-copy-source-if-match'] = this.MatchETag;
+    }
+    if (!(0, _helper.isEmpty)(this.NoMatchETag)) {
+      headerOptions['x-amz-copy-source-if-none-match'] = this.NoMatchETag;
+    }
+    if (!(0, _helper.isEmpty)(this.MatchModifiedSince)) {
+      headerOptions['x-amz-copy-source-if-modified-since'] = this.MatchModifiedSince;
+    }
+    if (!(0, _helper.isEmpty)(this.MatchUnmodifiedSince)) {
+      headerOptions['x-amz-copy-source-if-unmodified-since'] = this.MatchUnmodifiedSince;
+    }
+    return headerOptions;
+  }
+}
+
+/**
+ * @deprecated use nodejs fs module
+ */
+exports.CopySourceOptions = CopySourceOptions;
+function removeDirAndFiles(dirPath, removeSelf = true) {
+  if (removeSelf) {
+    return fs.rmSync(dirPath, {
+      recursive: true,
+      force: true
+    });
+  }
+  fs.readdirSync(dirPath).forEach(item => {
+    fs.rmSync(path.join(dirPath, item), {
+      recursive: true,
+      force: true
+    });
+  });
+}
+class CopyDestinationOptions {
+  constructor({
+    Bucket,
+    Object,
+    Encryption,
+    UserMetadata,
+    UserTags,
+    LegalHold,
+    RetainUntilDate,
+    Mode,
+    MetadataDirective,
+    Headers
+  }) {
+    this.Bucket = Bucket;
+    this.Object = Object;
+    this.Encryption = Encryption ?? undefined; // null input will become undefined, easy for runtime assert
+    this.UserMetadata = UserMetadata;
+    this.UserTags = UserTags;
+    this.LegalHold = LegalHold;
+    this.Mode = Mode; // retention mode
+    this.RetainUntilDate = RetainUntilDate;
+    this.MetadataDirective = MetadataDirective;
+    this.Headers = Headers;
+  }
+  getHeaders() {
+    const replaceDirective = 'REPLACE';
+    const headerOptions = {};
+    const userTags = this.UserTags;
+    if (!(0, _helper.isEmpty)(userTags)) {
+      headerOptions['X-Amz-Tagging-Directive'] = replaceDirective;
+      headerOptions['X-Amz-Tagging'] = (0, _helper.isObject)(userTags) ? querystring.stringify(userTags) : (0, _helper.isString)(userTags) ? userTags : '';
+    }
+    if (this.Mode) {
+      headerOptions['X-Amz-Object-Lock-Mode'] = this.Mode; // GOVERNANCE or COMPLIANCE
+    }
+
+    if (this.RetainUntilDate) {
+      headerOptions['X-Amz-Object-Lock-Retain-Until-Date'] = this.RetainUntilDate; // needs to be UTC.
+    }
+
+    if (this.LegalHold) {
+      headerOptions['X-Amz-Object-Lock-Legal-Hold'] = this.LegalHold; // ON or OFF
+    }
+
+    if (this.UserMetadata) {
+      for (const [key, value] of Object.entries(this.UserMetadata)) {
+        headerOptions[`X-Amz-Meta-${key}`] = value.toString();
+      }
+    }
+    if (this.MetadataDirective) {
+      headerOptions[`X-Amz-Metadata-Directive`] = this.MetadataDirective;
+    }
+    if (this.Encryption) {
+      const encryptionHeaders = (0, _helper.getEncryptionHeaders)(this.Encryption);
+      for (const [key, value] of Object.entries(encryptionHeaders)) {
+        headerOptions[key] = value;
+      }
+    }
+    if (this.Headers) {
+      for (const [key, value] of Object.entries(this.Headers)) {
+        headerOptions[key] = value;
+      }
+    }
+    return headerOptions;
+  }
+  validate() {
+    if (!(0, _helper.isValidBucketName)(this.Bucket)) {
+      throw new errors.InvalidBucketNameError('Invalid Destination bucket name: ' + this.Bucket);
+    }
+    if (!(0, _helper.isValidObjectName)(this.Object)) {
+      throw new errors.InvalidObjectNameError(`Invalid Destination object name: ${this.Object}`);
+    }
+    if (!(0, _helper.isEmpty)(this.UserMetadata) && !(0, _helper.isObject)(this.UserMetadata)) {
+      throw new errors.InvalidObjectNameError(`Destination UserMetadata should be an object with key value pairs`);
+    }
+    if (!(0, _helper.isEmpty)(this.Mode) && ![_type.RETENTION_MODES.GOVERNANCE, _type.RETENTION_MODES.COMPLIANCE].includes(this.Mode)) {
+      throw new errors.InvalidObjectNameError(`Invalid Mode specified for destination object it should be one of [GOVERNANCE,COMPLIANCE]`);
+    }
+    if (this.Encryption !== undefined && (0, _helper.isEmptyObject)(this.Encryption)) {
+      throw new errors.InvalidObjectNameError(`Invalid Encryption configuration for destination object `);
+    }
+    return true;
+  }
+}
+
+/**
+ * maybe this should be a generic type for Records, leave it for later refactor
+ */
+exports.CopyDestinationOptions = CopyDestinationOptions;
+class SelectResults {
+  constructor({
+    records,
+    // parsed data as stream
+    response,
+    // original response stream
+    stats,
+    // stats as xml
+    progress // stats as xml
+  }) {
+    this.records = records;
+    this.response = response;
+    this.stats = stats;
+    this.progress = progress;
+  }
+  setStats(stats) {
+    this.stats = stats;
+  }
+  getStats() {
+    return this.stats;
+  }
+  setProgress(progress) {
+    this.progress = progress;
+  }
+  getProgress() {
+    return this.progress;
+  }
+  setResponse(response) {
+    this.response = response;
+  }
+  getResponse() {
+    return this.response;
+  }
+  setRecords(records) {
+    this.records = records;
+  }
+  getRecords() {
+    return this.records;
+  }
+}
+exports.SelectResults = SelectResults;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fs","_interopRequireWildcard","require","path","querystring","errors","_helper","_type","exports","RETENTION_MODES","ENCRYPTION_TYPES","LEGAL_HOLD_STATUS","RETENTION_VALIDITY_UNITS","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","DEFAULT_REGION","PRESIGN_EXPIRY_DAYS_MAX","CopySourceOptions","constructor","Bucket","VersionID","MatchETag","NoMatchETag","MatchModifiedSince","MatchUnmodifiedSince","MatchRange","Start","End","Encryption","undefined","validate","isValidBucketName","InvalidBucketNameError","isValidObjectName","InvalidObjectNameError","isNumber","getHeaders","headerOptions","encodeURI","isEmpty","removeDirAndFiles","dirPath","removeSelf","rmSync","recursive","force","readdirSync","forEach","item","join","CopyDestinationOptions","UserMetadata","UserTags","LegalHold","RetainUntilDate","Mode","MetadataDirective","Headers","replaceDirective","userTags","isObject","stringify","isString","value","entries","toString","encryptionHeaders","getEncryptionHeaders","GOVERNANCE","COMPLIANCE","includes","isEmptyObject","SelectResults","records","response","stats","progress","setStats","getStats","setProgress","getProgress","setResponse","getResponse","setRecords","getRecords"],"sources":["helpers.ts"],"sourcesContent":["import * as fs from 'node:fs'\nimport * as path from 'node:path'\n\nimport * as querystring from 'query-string'\n\nimport * as errors from './errors.ts'\nimport {\n  getEncryptionHeaders,\n  isEmpty,\n  isEmptyObject,\n  isNumber,\n  isObject,\n  isString,\n  isValidBucketName,\n  isValidObjectName,\n} from './internal/helper.ts'\nimport type { Encryption, ObjectMetaData, RequestHeaders } from './internal/type.ts'\nimport { RETENTION_MODES } from './internal/type.ts'\n\nexport { ENCRYPTION_TYPES, LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from './internal/type.ts'\n\nexport const DEFAULT_REGION = 'us-east-1'\n\nexport const PRESIGN_EXPIRY_DAYS_MAX = 24 * 60 * 60 * 7 // 7 days in seconds\n\nexport interface ICopySourceOptions {\n  Bucket: string\n  Object: string\n  /**\n   * Valid versionId\n   */\n  VersionID?: string\n  /**\n   * Etag to match\n   */\n  MatchETag?: string\n  /**\n   * Etag to exclude\n   */\n  NoMatchETag?: string\n  /**\n   * Modified Date of the object/part.  UTC Date in string format\n   */\n  MatchModifiedSince?: string | null\n  /**\n   * Modified Date of the object/part to exclude UTC Date in string format\n   */\n  MatchUnmodifiedSince?: string | null\n  /**\n   * true or false Object range to match\n   */\n  MatchRange?: boolean\n  Start?: number\n  End?: number\n  Encryption?: Encryption\n}\n\nexport class CopySourceOptions {\n  public readonly Bucket: string\n  public readonly Object: string\n  public readonly VersionID: string\n  public MatchETag: string\n  private readonly NoMatchETag: string\n  private readonly MatchModifiedSince: string | null\n  private readonly MatchUnmodifiedSince: string | null\n  public readonly MatchRange: boolean\n  public readonly Start: number\n  public readonly End: number\n  private readonly Encryption?: Encryption\n\n  constructor({\n    Bucket,\n    Object,\n    VersionID = '',\n    MatchETag = '',\n    NoMatchETag = '',\n    MatchModifiedSince = null,\n    MatchUnmodifiedSince = null,\n    MatchRange = false,\n    Start = 0,\n    End = 0,\n    Encryption = undefined,\n  }: ICopySourceOptions) {\n    this.Bucket = Bucket\n    this.Object = Object\n    this.VersionID = VersionID\n    this.MatchETag = MatchETag\n    this.NoMatchETag = NoMatchETag\n    this.MatchModifiedSince = MatchModifiedSince\n    this.MatchUnmodifiedSince = MatchUnmodifiedSince\n    this.MatchRange = MatchRange\n    this.Start = Start\n    this.End = End\n    this.Encryption = Encryption\n  }\n\n  validate() {\n    if (!isValidBucketName(this.Bucket)) {\n      throw new errors.InvalidBucketNameError('Invalid Source bucket name: ' + this.Bucket)\n    }\n    if (!isValidObjectName(this.Object)) {\n      throw new errors.InvalidObjectNameError(`Invalid Source object name: ${this.Object}`)\n    }\n    if ((this.MatchRange && this.Start !== -1 && this.End !== -1 && this.Start > this.End) || this.Start < 0) {\n      throw new errors.InvalidObjectNameError('Source start must be non-negative, and start must be at most end.')\n    } else if ((this.MatchRange && !isNumber(this.Start)) || !isNumber(this.End)) {\n      throw new errors.InvalidObjectNameError(\n        'MatchRange is specified. But Invalid Start and End values are specified.',\n      )\n    }\n\n    return true\n  }\n\n  getHeaders(): RequestHeaders {\n    const headerOptions: RequestHeaders = {}\n    headerOptions['x-amz-copy-source'] = encodeURI(this.Bucket + '/' + this.Object)\n\n    if (!isEmpty(this.VersionID)) {\n      headerOptions['x-amz-copy-source'] = `${encodeURI(this.Bucket + '/' + this.Object)}?versionId=${this.VersionID}`\n    }\n\n    if (!isEmpty(this.MatchETag)) {\n      headerOptions['x-amz-copy-source-if-match'] = this.MatchETag\n    }\n    if (!isEmpty(this.NoMatchETag)) {\n      headerOptions['x-amz-copy-source-if-none-match'] = this.NoMatchETag\n    }\n\n    if (!isEmpty(this.MatchModifiedSince)) {\n      headerOptions['x-amz-copy-source-if-modified-since'] = this.MatchModifiedSince\n    }\n    if (!isEmpty(this.MatchUnmodifiedSince)) {\n      headerOptions['x-amz-copy-source-if-unmodified-since'] = this.MatchUnmodifiedSince\n    }\n\n    return headerOptions\n  }\n}\n\n/**\n * @deprecated use nodejs fs module\n */\nexport function removeDirAndFiles(dirPath: string, removeSelf = true) {\n  if (removeSelf) {\n    return fs.rmSync(dirPath, { recursive: true, force: true })\n  }\n\n  fs.readdirSync(dirPath).forEach((item) => {\n    fs.rmSync(path.join(dirPath, item), { recursive: true, force: true })\n  })\n}\n\nexport interface ICopyDestinationOptions {\n  /**\n   * Bucket name\n   */\n  Bucket: string\n  /**\n   * Object Name for the destination (composed/copied) object defaults\n   */\n  Object: string\n  /**\n   * Encryption configuration defaults to {}\n   * @default {}\n   */\n  Encryption?: Encryption\n  UserMetadata?: ObjectMetaData\n  /**\n   * query-string encoded string or Record<string, string> Object\n   */\n  UserTags?: Record<string, string> | string\n  LegalHold?: 'on' | 'off'\n  /**\n   * UTC Date String\n   */\n  RetainUntilDate?: string\n  Mode?: RETENTION_MODES\n  MetadataDirective?: 'COPY' | 'REPLACE'\n  /**\n   * Extra headers for the target object\n   */\n  Headers?: Record<string, string>\n}\n\nexport class CopyDestinationOptions {\n  public readonly Bucket: string\n  public readonly Object: string\n  private readonly Encryption?: Encryption\n  private readonly UserMetadata?: ObjectMetaData\n  private readonly UserTags?: Record<string, string> | string\n  private readonly LegalHold?: 'on' | 'off'\n  private readonly RetainUntilDate?: string\n  private readonly Mode?: RETENTION_MODES\n  private readonly MetadataDirective?: string\n  private readonly Headers?: Record<string, string>\n\n  constructor({\n    Bucket,\n    Object,\n    Encryption,\n    UserMetadata,\n    UserTags,\n    LegalHold,\n    RetainUntilDate,\n    Mode,\n    MetadataDirective,\n    Headers,\n  }: ICopyDestinationOptions) {\n    this.Bucket = Bucket\n    this.Object = Object\n    this.Encryption = Encryption ?? undefined // null input will become undefined, easy for runtime assert\n    this.UserMetadata = UserMetadata\n    this.UserTags = UserTags\n    this.LegalHold = LegalHold\n    this.Mode = Mode // retention mode\n    this.RetainUntilDate = RetainUntilDate\n    this.MetadataDirective = MetadataDirective\n    this.Headers = Headers\n  }\n\n  getHeaders(): RequestHeaders {\n    const replaceDirective = 'REPLACE'\n    const headerOptions: RequestHeaders = {}\n\n    const userTags = this.UserTags\n    if (!isEmpty(userTags)) {\n      headerOptions['X-Amz-Tagging-Directive'] = replaceDirective\n      headerOptions['X-Amz-Tagging'] = isObject(userTags)\n        ? querystring.stringify(userTags)\n        : isString(userTags)\n        ? userTags\n        : ''\n    }\n\n    if (this.Mode) {\n      headerOptions['X-Amz-Object-Lock-Mode'] = this.Mode // GOVERNANCE or COMPLIANCE\n    }\n\n    if (this.RetainUntilDate) {\n      headerOptions['X-Amz-Object-Lock-Retain-Until-Date'] = this.RetainUntilDate // needs to be UTC.\n    }\n\n    if (this.LegalHold) {\n      headerOptions['X-Amz-Object-Lock-Legal-Hold'] = this.LegalHold // ON or OFF\n    }\n\n    if (this.UserMetadata) {\n      for (const [key, value] of Object.entries(this.UserMetadata)) {\n        headerOptions[`X-Amz-Meta-${key}`] = value.toString()\n      }\n    }\n\n    if (this.MetadataDirective) {\n      headerOptions[`X-Amz-Metadata-Directive`] = this.MetadataDirective\n    }\n\n    if (this.Encryption) {\n      const encryptionHeaders = getEncryptionHeaders(this.Encryption)\n      for (const [key, value] of Object.entries(encryptionHeaders)) {\n        headerOptions[key] = value\n      }\n    }\n    if (this.Headers) {\n      for (const [key, value] of Object.entries(this.Headers)) {\n        headerOptions[key] = value\n      }\n    }\n\n    return headerOptions\n  }\n\n  validate() {\n    if (!isValidBucketName(this.Bucket)) {\n      throw new errors.InvalidBucketNameError('Invalid Destination bucket name: ' + this.Bucket)\n    }\n    if (!isValidObjectName(this.Object)) {\n      throw new errors.InvalidObjectNameError(`Invalid Destination object name: ${this.Object}`)\n    }\n    if (!isEmpty(this.UserMetadata) && !isObject(this.UserMetadata)) {\n      throw new errors.InvalidObjectNameError(`Destination UserMetadata should be an object with key value pairs`)\n    }\n\n    if (!isEmpty(this.Mode) && ![RETENTION_MODES.GOVERNANCE, RETENTION_MODES.COMPLIANCE].includes(this.Mode)) {\n      throw new errors.InvalidObjectNameError(\n        `Invalid Mode specified for destination object it should be one of [GOVERNANCE,COMPLIANCE]`,\n      )\n    }\n\n    if (this.Encryption !== undefined && isEmptyObject(this.Encryption)) {\n      throw new errors.InvalidObjectNameError(`Invalid Encryption configuration for destination object `)\n    }\n    return true\n  }\n}\n\n/**\n * maybe this should be a generic type for Records, leave it for later refactor\n */\nexport class SelectResults {\n  private records?: unknown\n  private response?: unknown\n  private stats?: string\n  private progress?: unknown\n\n  constructor({\n    records, // parsed data as stream\n    response, // original response stream\n    stats, // stats as xml\n    progress, // stats as xml\n  }: {\n    records?: unknown\n    response?: unknown\n    stats?: string\n    progress?: unknown\n  }) {\n    this.records = records\n    this.response = response\n    this.stats = stats\n    this.progress = progress\n  }\n\n  setStats(stats: string) {\n    this.stats = stats\n  }\n\n  getStats() {\n    return this.stats\n  }\n\n  setProgress(progress: unknown) {\n    this.progress = progress\n  }\n\n  getProgress() {\n    return this.progress\n  }\n\n  setResponse(response: unknown) {\n    this.response = response\n  }\n\n  getResponse() {\n    return this.response\n  }\n\n  setRecords(records: unknown) {\n    this.records = records\n  }\n\n  getRecords(): unknown {\n    return this.records\n  }\n}\n"],"mappings":"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"}

package/dist/main/internal/async.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as fs from 'node:fs';
+import * as stream from 'node:stream';
+export { promises as fsp } from 'node:fs';
+export declare const streamPromise: {
+  pipeline: typeof stream.pipeline.__promisify__;
+};
+export declare const fstat: typeof fs.fstat.__promisify__;

package/dist/main/internal/async.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var fs = _interopRequireWildcard(require("fs"), true);
+var stream = _interopRequireWildcard(require("stream"), true);
+var _util = require("util");
+var _nodeFs = require("fs");
+exports.fsp = _nodeFs.promises;
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+// promise helper for stdlib
+
+// TODO: use "node:fs/promise" directly after we stop testing on nodejs 12
+
+const streamPromise = {
+  // node:stream/promises Added in: v15.0.0
+  pipeline: (0, _util.promisify)(stream.pipeline)
+};
+exports.streamPromise = streamPromise;
+const fstat = (0, _util.promisify)(fs.fstat);
+exports.fstat = fstat;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/main/internal/callbackify.d.ts

@@ -0,0 +1 @@
+export declare function callbackify(fn: (...args: any[]) => any): (this: any, ...args: any[]) => any;

package/dist/main/internal/callbackify.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.callbackify = callbackify;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// Wrapper for an async function that supports callback style API.
+// It will preserve 'this'.
+function callbackify(fn) {
+  return function (...args) {
+    const lastArg = args[args.length - 1];
+    if (typeof lastArg === 'function') {
+      const callback = args.pop();
+      return fn.apply(this, args).then(result => callback(null, result), err => callback(err));
+    }
+    return fn.apply(this, args);
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjYWxsYmFja2lmeSIsImZuIiwiYXJncyIsImxhc3RBcmciLCJsZW5ndGgiLCJjYWxsYmFjayIsInBvcCIsImFwcGx5IiwidGhlbiIsInJlc3VsdCIsImVyciJdLCJzb3VyY2VzIjpbImNhbGxiYWNraWZ5LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIEB0eXBlc2NyaXB0LWVzbGludC9uby1leHBsaWNpdC1hbnkgKi9cblxuLy8gV3JhcHBlciBmb3IgYW4gYXN5bmMgZnVuY3Rpb24gdGhhdCBzdXBwb3J0cyBjYWxsYmFjayBzdHlsZSBBUEkuXG4vLyBJdCB3aWxsIHByZXNlcnZlICd0aGlzJy5cbmV4cG9ydCBmdW5jdGlvbiBjYWxsYmFja2lmeShmbjogKC4uLmFyZ3M6IGFueVtdKSA9PiBhbnkpIHtcbiAgcmV0dXJuIGZ1bmN0aW9uICh0aGlzOiBhbnksIC4uLmFyZ3M6IGFueVtdKSB7XG4gICAgY29uc3QgbGFzdEFyZyA9IGFyZ3NbYXJncy5sZW5ndGggLSAxXVxuXG4gICAgaWYgKHR5cGVvZiBsYXN0QXJnID09PSAnZnVuY3Rpb24nKSB7XG4gICAgICBjb25zdCBjYWxsYmFjayA9IGFyZ3MucG9wKClcbiAgICAgIHJldHVybiBmbi5hcHBseSh0aGlzLCBhcmdzKS50aGVuKFxuICAgICAgICAocmVzdWx0OiBhbnkpID0+IGNhbGxiYWNrKG51bGwsIHJlc3VsdCksXG4gICAgICAgIChlcnI6IGFueSkgPT4gY2FsbGJhY2soZXJyKSxcbiAgICAgIClcbiAgICB9XG5cbiAgICByZXR1cm4gZm4uYXBwbHkodGhpcywgYXJncylcbiAgfVxufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQTs7QUFFQTtBQUNBO0FBQ08sU0FBU0EsV0FBV0EsQ0FBQ0MsRUFBMkIsRUFBRTtFQUN2RCxPQUFPLFVBQXFCLEdBQUdDLElBQVcsRUFBRTtJQUMxQyxNQUFNQyxPQUFPLEdBQUdELElBQUksQ0FBQ0EsSUFBSSxDQUFDRSxNQUFNLEdBQUcsQ0FBQyxDQUFDO0lBRXJDLElBQUksT0FBT0QsT0FBTyxLQUFLLFVBQVUsRUFBRTtNQUNqQyxNQUFNRSxRQUFRLEdBQUdILElBQUksQ0FBQ0ksR0FBRyxDQUFDLENBQUM7TUFDM0IsT0FBT0wsRUFBRSxDQUFDTSxLQUFLLENBQUMsSUFBSSxFQUFFTCxJQUFJLENBQUMsQ0FBQ00sSUFBSSxDQUM3QkMsTUFBVyxJQUFLSixRQUFRLENBQUMsSUFBSSxFQUFFSSxNQUFNLENBQUMsRUFDdENDLEdBQVEsSUFBS0wsUUFBUSxDQUFDSyxHQUFHLENBQzVCLENBQUM7SUFDSDtJQUVBLE9BQU9ULEVBQUUsQ0FBQ00sS0FBSyxDQUFDLElBQUksRUFBRUwsSUFBSSxDQUFDO0VBQzdCLENBQUM7QUFDSCJ9