@hanzo/s3 0.6.4 → 8.0.7

package/dist/main/notification.d.ts

@@ -0,0 +1,58 @@
+import { EventEmitter } from 'eventemitter3';
+import type { TypedClient } from "./internal/client.js";
+type Event = unknown;
+export declare class TargetConfig {
+  private Filter?;
+  private Event?;
+  private Id;
+  setId(id: unknown): void;
+  addEvent(newevent: Event): void;
+  addFilterSuffix(suffix: string): void;
+  addFilterPrefix(prefix: string): void;
+}
+export declare class TopicConfig extends TargetConfig {
+  private Topic;
+  constructor(arn: string);
+}
+export declare class QueueConfig extends TargetConfig {
+  private Queue;
+  constructor(arn: string);
+}
+export declare class CloudFunctionConfig extends TargetConfig {
+  private CloudFunction;
+  constructor(arn: string);
+}
+export declare class NotificationConfig {
+  private TopicConfiguration?;
+  private CloudFunctionConfiguration?;
+  private QueueConfiguration?;
+  add(target: TargetConfig): void;
+}
+export declare const buildARN: (partition: string, service: string, region: string, accountId: string, resource: string) => string;
+export declare const ObjectCreatedAll = "s3:ObjectCreated:*";
+export declare const ObjectCreatedPut = "s3:ObjectCreated:Put";
+export declare const ObjectCreatedPost = "s3:ObjectCreated:Post";
+export declare const ObjectCreatedCopy = "s3:ObjectCreated:Copy";
+export declare const ObjectCreatedCompleteMultipartUpload = "s3:ObjectCreated:CompleteMultipartUpload";
+export declare const ObjectRemovedAll = "s3:ObjectRemoved:*";
+export declare const ObjectRemovedDelete = "s3:ObjectRemoved:Delete";
+export declare const ObjectRemovedDeleteMarkerCreated = "s3:ObjectRemoved:DeleteMarkerCreated";
+export declare const ObjectReducedRedundancyLostObject = "s3:ReducedRedundancyLostObject";
+export type NotificationEvent = 's3:ObjectCreated:*' | 's3:ObjectCreated:Put' | 's3:ObjectCreated:Post' | 's3:ObjectCreated:Copy' | 's3:ObjectCreated:CompleteMultipartUpload' | 's3:ObjectRemoved:*' | 's3:ObjectRemoved:Delete' | 's3:ObjectRemoved:DeleteMarkerCreated' | 's3:ReducedRedundancyLostObject' | 's3:TestEvent' | 's3:ObjectRestore:Post' | 's3:ObjectRestore:Completed' | 's3:Replication:OperationFailedReplication' | 's3:Replication:OperationMissedThreshold' | 's3:Replication:OperationReplicatedAfterThreshold' | 's3:Replication:OperationNotTracked' | string;
+export type NotificationRecord = unknown;
+export declare class NotificationPoller extends EventEmitter<{
+  notification: (event: NotificationRecord) => void;
+  error: (error: unknown) => void;
+}> {
+  private client;
+  private bucketName;
+  private prefix;
+  private suffix;
+  private events;
+  private ending;
+  constructor(client: TypedClient, bucketName: string, prefix: string, suffix: string, events: NotificationEvent[]);
+  start(): void;
+  stop(): void;
+  checkForChanges(): void;
+}
+export {};

package/dist/main/notification.js

@@ -0,0 +1,230 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _eventemitter = require("eventemitter3");
+var _Parser = require("stream-json/jsonl/Parser.js");
+var _helpers = require("./helpers.js");
+var _helper = require("./internal/helper.js");
+/*
+ * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 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.
+ */
+
+// TODO: type this
+
+// Base class for three supported configs.
+class TargetConfig {
+  setId(id) {
+    this.Id = id;
+  }
+  addEvent(newevent) {
+    if (!this.Event) {
+      this.Event = [];
+    }
+    this.Event.push(newevent);
+  }
+  addFilterSuffix(suffix) {
+    if (!this.Filter) {
+      this.Filter = {
+        S3Key: {
+          FilterRule: []
+        }
+      };
+    }
+    this.Filter.S3Key.FilterRule.push({
+      Name: 'suffix',
+      Value: suffix
+    });
+  }
+  addFilterPrefix(prefix) {
+    if (!this.Filter) {
+      this.Filter = {
+        S3Key: {
+          FilterRule: []
+        }
+      };
+    }
+    this.Filter.S3Key.FilterRule.push({
+      Name: 'prefix',
+      Value: prefix
+    });
+  }
+}
+
+// 1. Topic (simple notification service)
+exports.TargetConfig = TargetConfig;
+class TopicConfig extends TargetConfig {
+  constructor(arn) {
+    super();
+    this.Topic = arn;
+  }
+}
+
+// 2. Queue (simple queue service)
+exports.TopicConfig = TopicConfig;
+class QueueConfig extends TargetConfig {
+  constructor(arn) {
+    super();
+    this.Queue = arn;
+  }
+}
+
+// 3. CloudFront (lambda function)
+exports.QueueConfig = QueueConfig;
+class CloudFunctionConfig extends TargetConfig {
+  constructor(arn) {
+    super();
+    this.CloudFunction = arn;
+  }
+}
+
+// Notification config - array of target configs.
+// Target configs can be
+// 1. Topic (simple notification service)
+// 2. Queue (simple queue service)
+// 3. CloudFront (lambda function)
+exports.CloudFunctionConfig = CloudFunctionConfig;
+class NotificationConfig {
+  add(target) {
+    let instance;
+    if (target instanceof TopicConfig) {
+      instance = this.TopicConfiguration ?? (this.TopicConfiguration = []);
+    }
+    if (target instanceof QueueConfig) {
+      instance = this.QueueConfiguration ?? (this.QueueConfiguration = []);
+    }
+    if (target instanceof CloudFunctionConfig) {
+      instance = this.CloudFunctionConfiguration ?? (this.CloudFunctionConfiguration = []);
+    }
+    if (instance) {
+      instance.push(target);
+    }
+  }
+}
+exports.NotificationConfig = NotificationConfig;
+const buildARN = (partition, service, region, accountId, resource) => {
+  return 'arn:' + partition + ':' + service + ':' + region + ':' + accountId + ':' + resource;
+};
+exports.buildARN = buildARN;
+const ObjectCreatedAll = 's3:ObjectCreated:*';
+exports.ObjectCreatedAll = ObjectCreatedAll;
+const ObjectCreatedPut = 's3:ObjectCreated:Put';
+exports.ObjectCreatedPut = ObjectCreatedPut;
+const ObjectCreatedPost = 's3:ObjectCreated:Post';
+exports.ObjectCreatedPost = ObjectCreatedPost;
+const ObjectCreatedCopy = 's3:ObjectCreated:Copy';
+exports.ObjectCreatedCopy = ObjectCreatedCopy;
+const ObjectCreatedCompleteMultipartUpload = 's3:ObjectCreated:CompleteMultipartUpload';
+exports.ObjectCreatedCompleteMultipartUpload = ObjectCreatedCompleteMultipartUpload;
+const ObjectRemovedAll = 's3:ObjectRemoved:*';
+exports.ObjectRemovedAll = ObjectRemovedAll;
+const ObjectRemovedDelete = 's3:ObjectRemoved:Delete';
+exports.ObjectRemovedDelete = ObjectRemovedDelete;
+const ObjectRemovedDeleteMarkerCreated = 's3:ObjectRemoved:DeleteMarkerCreated';
+exports.ObjectRemovedDeleteMarkerCreated = ObjectRemovedDeleteMarkerCreated;
+const ObjectReducedRedundancyLostObject = 's3:ReducedRedundancyLostObject';
+
+// put string at least so auto-complete could work
+
+// TODO: type this
+exports.ObjectReducedRedundancyLostObject = ObjectReducedRedundancyLostObject;
+// Poll for notifications, used in #listenBucketNotification.
+// Listening constitutes repeatedly requesting s3 whether or not any
+// changes have occurred.
+class NotificationPoller extends _eventemitter.EventEmitter {
+  constructor(client, bucketName, prefix, suffix, events) {
+    super();
+    this.client = client;
+    this.bucketName = bucketName;
+    this.prefix = prefix;
+    this.suffix = suffix;
+    this.events = events;
+    this.ending = false;
+  }
+
+  // Starts the polling.
+  start() {
+    this.ending = false;
+    process.nextTick(() => {
+      this.checkForChanges();
+    });
+  }
+
+  // Stops the polling.
+  stop() {
+    this.ending = true;
+  }
+  checkForChanges() {
+    // Don't continue if we're looping again but are cancelled.
+    if (this.ending) {
+      return;
+    }
+    const method = 'GET';
+    const queries = [];
+    if (this.prefix) {
+      const prefix = (0, _helper.uriEscape)(this.prefix);
+      queries.push(`prefix=${prefix}`);
+    }
+    if (this.suffix) {
+      const suffix = (0, _helper.uriEscape)(this.suffix);
+      queries.push(`suffix=${suffix}`);
+    }
+    if (this.events) {
+      this.events.forEach(s3event => queries.push('events=' + (0, _helper.uriEscape)(s3event)));
+    }
+    queries.sort();
+    let query = '';
+    if (queries.length > 0) {
+      query = `${queries.join('&')}`;
+    }
+    const region = this.client.region || _helpers.DEFAULT_REGION;
+    this.client.makeRequestAsync({
+      method,
+      bucketName: this.bucketName,
+      query
+    }, '', [200], region).then(response => {
+      const asm = _Parser.make();
+      (0, _helper.pipesetup)(response, asm).on('data', data => {
+        // Data is flushed periodically (every 5 seconds), so we should
+        // handle it after flushing from the JSON parser.
+        let records = data.value.Records;
+        // If null (= no records), change to an empty array.
+        if (!records) {
+          records = [];
+        }
+
+        // Iterate over the notifications and emit them individually.
+        records.forEach(record => {
+          this.emit('notification', record);
+        });
+
+        // If we're done, stop.
+        if (this.ending) {
+          response === null || response === void 0 ? void 0 : response.destroy();
+        }
+      }).on('error', e => this.emit('error', e)).on('end', () => {
+        // Do it again, if we haven't cancelled yet.
+        process.nextTick(() => {
+          this.checkForChanges();
+        });
+      });
+    }, e => {
+      return this.emit('error', e);
+    });
+  }
+}
+exports.NotificationPoller = NotificationPoller;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_eventemitter","require","_Parser","_helpers","_helper","TargetConfig","setId","id","Id","addEvent","newevent","Event","push","addFilterSuffix","suffix","Filter","S3Key","FilterRule","Name","Value","addFilterPrefix","prefix","exports","TopicConfig","constructor","arn","Topic","QueueConfig","Queue","CloudFunctionConfig","CloudFunction","NotificationConfig","add","target","instance","TopicConfiguration","QueueConfiguration","CloudFunctionConfiguration","buildARN","partition","service","region","accountId","resource","ObjectCreatedAll","ObjectCreatedPut","ObjectCreatedPost","ObjectCreatedCopy","ObjectCreatedCompleteMultipartUpload","ObjectRemovedAll","ObjectRemovedDelete","ObjectRemovedDeleteMarkerCreated","ObjectReducedRedundancyLostObject","NotificationPoller","EventEmitter","client","bucketName","events","ending","start","process","nextTick","checkForChanges","stop","method","queries","uriEscape","forEach","s3event","sort","query","length","join","DEFAULT_REGION","makeRequestAsync","then","response","asm","jsonLineParser","make","pipesetup","on","data","records","value","Records","record","emit","destroy","e"],"sources":["notification.ts"],"sourcesContent":["/*\n * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 Hanzo AI, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventEmitter } from 'eventemitter3'\nimport jsonLineParser from 'stream-json/jsonl/Parser.js'\n\nimport { DEFAULT_REGION } from './helpers.ts'\nimport type { TypedClient } from './internal/client.ts'\nimport { pipesetup, uriEscape } from './internal/helper.ts'\n\n// TODO: type this\n\ntype Event = unknown\n\n// Base class for three supported configs.\nexport class TargetConfig {\n  private Filter?: { S3Key: { FilterRule: { Name: string; Value: string }[] } }\n  private Event?: Event[]\n  private Id: unknown\n\n  setId(id: unknown) {\n    this.Id = id\n  }\n\n  addEvent(newevent: Event) {\n    if (!this.Event) {\n      this.Event = []\n    }\n    this.Event.push(newevent)\n  }\n\n  addFilterSuffix(suffix: string) {\n    if (!this.Filter) {\n      this.Filter = { S3Key: { FilterRule: [] } }\n    }\n    this.Filter.S3Key.FilterRule.push({ Name: 'suffix', Value: suffix })\n  }\n\n  addFilterPrefix(prefix: string) {\n    if (!this.Filter) {\n      this.Filter = { S3Key: { FilterRule: [] } }\n    }\n    this.Filter.S3Key.FilterRule.push({ Name: 'prefix', Value: prefix })\n  }\n}\n\n// 1. Topic (simple notification service)\nexport class TopicConfig extends TargetConfig {\n  private Topic: string\n\n  constructor(arn: string) {\n    super()\n    this.Topic = arn\n  }\n}\n\n// 2. Queue (simple queue service)\nexport class QueueConfig extends TargetConfig {\n  private Queue: string\n\n  constructor(arn: string) {\n    super()\n    this.Queue = arn\n  }\n}\n\n// 3. CloudFront (lambda function)\nexport class CloudFunctionConfig extends TargetConfig {\n  private CloudFunction: string\n\n  constructor(arn: string) {\n    super()\n    this.CloudFunction = arn\n  }\n}\n\n// Notification config - array of target configs.\n// Target configs can be\n// 1. Topic (simple notification service)\n// 2. Queue (simple queue service)\n// 3. CloudFront (lambda function)\nexport class NotificationConfig {\n  private TopicConfiguration?: TargetConfig[]\n  private CloudFunctionConfiguration?: TargetConfig[]\n  private QueueConfiguration?: TargetConfig[]\n\n  add(target: TargetConfig) {\n    let instance: TargetConfig[] | undefined\n    if (target instanceof TopicConfig) {\n      instance = this.TopicConfiguration ??= []\n    }\n    if (target instanceof QueueConfig) {\n      instance = this.QueueConfiguration ??= []\n    }\n    if (target instanceof CloudFunctionConfig) {\n      instance = this.CloudFunctionConfiguration ??= []\n    }\n    if (instance) {\n      instance.push(target)\n    }\n  }\n}\n\nexport const buildARN = (partition: string, service: string, region: string, accountId: string, resource: string) => {\n  return 'arn:' + partition + ':' + service + ':' + region + ':' + accountId + ':' + resource\n}\nexport const ObjectCreatedAll = 's3:ObjectCreated:*'\nexport const ObjectCreatedPut = 's3:ObjectCreated:Put'\nexport const ObjectCreatedPost = 's3:ObjectCreated:Post'\nexport const ObjectCreatedCopy = 's3:ObjectCreated:Copy'\nexport const ObjectCreatedCompleteMultipartUpload = 's3:ObjectCreated:CompleteMultipartUpload'\nexport const ObjectRemovedAll = 's3:ObjectRemoved:*'\nexport const ObjectRemovedDelete = 's3:ObjectRemoved:Delete'\nexport const ObjectRemovedDeleteMarkerCreated = 's3:ObjectRemoved:DeleteMarkerCreated'\nexport const ObjectReducedRedundancyLostObject = 's3:ReducedRedundancyLostObject'\nexport type NotificationEvent =\n  | 's3:ObjectCreated:*'\n  | 's3:ObjectCreated:Put'\n  | 's3:ObjectCreated:Post'\n  | 's3:ObjectCreated:Copy'\n  | 's3:ObjectCreated:CompleteMultipartUpload'\n  | 's3:ObjectRemoved:*'\n  | 's3:ObjectRemoved:Delete'\n  | 's3:ObjectRemoved:DeleteMarkerCreated'\n  | 's3:ReducedRedundancyLostObject'\n  | 's3:TestEvent'\n  | 's3:ObjectRestore:Post'\n  | 's3:ObjectRestore:Completed'\n  | 's3:Replication:OperationFailedReplication'\n  | 's3:Replication:OperationMissedThreshold'\n  | 's3:Replication:OperationReplicatedAfterThreshold'\n  | 's3:Replication:OperationNotTracked'\n  | string // put string at least so auto-complete could work\n\n// TODO: type this\nexport type NotificationRecord = unknown\n// Poll for notifications, used in #listenBucketNotification.\n// Listening constitutes repeatedly requesting s3 whether or not any\n// changes have occurred.\nexport class NotificationPoller extends EventEmitter<{\n  notification: (event: NotificationRecord) => void\n  error: (error: unknown) => void\n}> {\n  private client: TypedClient\n  private bucketName: string\n  private prefix: string\n  private suffix: string\n  private events: NotificationEvent[]\n  private ending: boolean\n\n  constructor(client: TypedClient, bucketName: string, prefix: string, suffix: string, events: NotificationEvent[]) {\n    super()\n\n    this.client = client\n    this.bucketName = bucketName\n    this.prefix = prefix\n    this.suffix = suffix\n    this.events = events\n\n    this.ending = false\n  }\n\n  // Starts the polling.\n  start() {\n    this.ending = false\n\n    process.nextTick(() => {\n      this.checkForChanges()\n    })\n  }\n\n  // Stops the polling.\n  stop() {\n    this.ending = true\n  }\n\n  checkForChanges() {\n    // Don't continue if we're looping again but are cancelled.\n    if (this.ending) {\n      return\n    }\n\n    const method = 'GET'\n    const queries = []\n    if (this.prefix) {\n      const prefix = uriEscape(this.prefix)\n      queries.push(`prefix=${prefix}`)\n    }\n    if (this.suffix) {\n      const suffix = uriEscape(this.suffix)\n      queries.push(`suffix=${suffix}`)\n    }\n    if (this.events) {\n      this.events.forEach((s3event) => queries.push('events=' + uriEscape(s3event)))\n    }\n    queries.sort()\n\n    let query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    const region = this.client.region || DEFAULT_REGION\n\n    this.client.makeRequestAsync({ method, bucketName: this.bucketName, query }, '', [200], region).then(\n      (response) => {\n        const asm = jsonLineParser.make()\n\n        pipesetup(response, asm)\n          .on('data', (data) => {\n            // Data is flushed periodically (every 5 seconds), so we should\n            // handle it after flushing from the JSON parser.\n            let records = data.value.Records\n            // If null (= no records), change to an empty array.\n            if (!records) {\n              records = []\n            }\n\n            // Iterate over the notifications and emit them individually.\n            records.forEach((record: NotificationRecord) => {\n              this.emit('notification', record)\n            })\n\n            // If we're done, stop.\n            if (this.ending) {\n              response?.destroy()\n            }\n          })\n          .on('error', (e) => this.emit('error', e))\n          .on('end', () => {\n            // Do it again, if we haven't cancelled yet.\n            process.nextTick(() => {\n              this.checkForChanges()\n            })\n          })\n      },\n      (e) => {\n        return this.emit('error', e)\n      },\n    )\n  }\n}\n"],"mappings":"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"}

package/dist/main/s3.d.ts

@@ -0,0 +1,40 @@
+import type { LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from "./helpers.js";
+import { TypedClient } from "./internal/client.js";
+import { CopyConditions } from "./internal/copy-conditions.js";
+import { PostPolicy } from "./internal/post-policy.js";
+export * from "./errors.js";
+export * from "./helpers.js";
+export * from "./notification.js";
+export { CopyConditions, PostPolicy };
+export { IamAwsProvider } from "./IamAwsProvider.js";
+export type { MakeBucketOpt } from "./internal/client.js";
+export type { ClientOptions, NoResultCallback, RemoveOptions } from "./internal/client.js";
+export type { Region } from "./internal/s3-endpoints.js";
+export type { BucketItem, BucketItemCopy, BucketItemFromList, BucketItemStat, BucketItemWithMetadata, BucketStream, EmptyObject, ExistingObjectReplication, GetObjectLegalHoldOptions, IncompleteUploadedBucketItem, InputSerialization, IsoDate, ItemBucketMetadata, ItemBucketMetadataList, LegalHoldStatus, LifecycleConfig, LifecycleRule, MetadataItem, ObjectLockInfo, OutputSerialization, PostPolicyResult, PutObjectLegalHoldOptions, ReplicaModifications, ReplicationConfig, ReplicationConfigOpts, ReplicationRule, ReplicationRuleAnd, ReplicationRuleDestination, ReplicationRuleFilter, ReplicationRuleStatus, Retention, RetentionOptions, ScanRange, SelectOptions, SelectProgress, SourceSelectionCriteria, Tag } from "./internal/type.js";
+/**
+ * @deprecated keep for backward compatible, use `RETENTION_MODES` instead
+ */
+export type Mode = RETENTION_MODES;
+/**
+ * @deprecated keep for backward compatible
+ */
+export type LockUnit = RETENTION_VALIDITY_UNITS;
+export type VersioningConfig = Record<string | number | symbol, unknown>;
+export type TagList = Record<string, string>;
+export interface LockConfig {
+  mode: RETENTION_MODES;
+  unit: RETENTION_VALIDITY_UNITS;
+  validity: number;
+}
+export interface LegalHoldOptions {
+  versionId: string;
+  status: LEGAL_HOLD_STATUS;
+}
+export interface SourceObjectStats {
+  size: number;
+  metaData: string;
+  lastModicied: Date;
+  versionId: string;
+  etag: string;
+}
+export declare class Client extends TypedClient {}

package/dist/main/s3.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  IamAwsProvider: true,
+  Client: true,
+  CopyConditions: true,
+  PostPolicy: true
+};
+var _callbackify = require("./internal/callbackify.js");
+var _client = require("./internal/client.js");
+var _copyConditions = require("./internal/copy-conditions.js");
+exports.CopyConditions = _copyConditions.CopyConditions;
+var _postPolicy = require("./internal/post-policy.js");
+exports.PostPolicy = _postPolicy.PostPolicy;
+var _errors = require("./errors.js");
+Object.keys(_errors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _errors[key]) return;
+  exports[key] = _errors[key];
+});
+var _helpers = require("./helpers.js");
+Object.keys(_helpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _helpers[key]) return;
+  exports[key] = _helpers[key];
+});
+var _notification = require("./notification.js");
+Object.keys(_notification).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _notification[key]) return;
+  exports[key] = _notification[key];
+});
+var _IamAwsProvider = require("./IamAwsProvider.js");
+exports.IamAwsProvider = _IamAwsProvider.IamAwsProvider;
+/*
+ * 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.
+ */
+
+/**
+ * @deprecated keep for backward compatible, use `RETENTION_MODES` instead
+ */
+
+/**
+ * @deprecated keep for backward compatible
+ */
+
+class Client extends _client.TypedClient {}
+
+// refactored API use promise internally
+exports.Client = Client;
+Client.prototype.makeBucket = (0, _callbackify.callbackify)(Client.prototype.makeBucket);
+Client.prototype.bucketExists = (0, _callbackify.callbackify)(Client.prototype.bucketExists);
+Client.prototype.removeBucket = (0, _callbackify.callbackify)(Client.prototype.removeBucket);
+Client.prototype.listBuckets = (0, _callbackify.callbackify)(Client.prototype.listBuckets);
+Client.prototype.getObject = (0, _callbackify.callbackify)(Client.prototype.getObject);
+Client.prototype.fGetObject = (0, _callbackify.callbackify)(Client.prototype.fGetObject);
+Client.prototype.getPartialObject = (0, _callbackify.callbackify)(Client.prototype.getPartialObject);
+Client.prototype.statObject = (0, _callbackify.callbackify)(Client.prototype.statObject);
+Client.prototype.putObjectRetention = (0, _callbackify.callbackify)(Client.prototype.putObjectRetention);
+Client.prototype.putObject = (0, _callbackify.callbackify)(Client.prototype.putObject);
+Client.prototype.fPutObject = (0, _callbackify.callbackify)(Client.prototype.fPutObject);
+Client.prototype.removeObject = (0, _callbackify.callbackify)(Client.prototype.removeObject);
+Client.prototype.removeBucketReplication = (0, _callbackify.callbackify)(Client.prototype.removeBucketReplication);
+Client.prototype.setBucketReplication = (0, _callbackify.callbackify)(Client.prototype.setBucketReplication);
+Client.prototype.getBucketReplication = (0, _callbackify.callbackify)(Client.prototype.getBucketReplication);
+Client.prototype.getObjectLegalHold = (0, _callbackify.callbackify)(Client.prototype.getObjectLegalHold);
+Client.prototype.setObjectLegalHold = (0, _callbackify.callbackify)(Client.prototype.setObjectLegalHold);
+Client.prototype.setObjectLockConfig = (0, _callbackify.callbackify)(Client.prototype.setObjectLockConfig);
+Client.prototype.getObjectLockConfig = (0, _callbackify.callbackify)(Client.prototype.getObjectLockConfig);
+Client.prototype.getBucketPolicy = (0, _callbackify.callbackify)(Client.prototype.getBucketPolicy);
+Client.prototype.setBucketPolicy = (0, _callbackify.callbackify)(Client.prototype.setBucketPolicy);
+Client.prototype.getBucketTagging = (0, _callbackify.callbackify)(Client.prototype.getBucketTagging);
+Client.prototype.getObjectTagging = (0, _callbackify.callbackify)(Client.prototype.getObjectTagging);
+Client.prototype.setBucketTagging = (0, _callbackify.callbackify)(Client.prototype.setBucketTagging);
+Client.prototype.removeBucketTagging = (0, _callbackify.callbackify)(Client.prototype.removeBucketTagging);
+Client.prototype.setObjectTagging = (0, _callbackify.callbackify)(Client.prototype.setObjectTagging);
+Client.prototype.removeObjectTagging = (0, _callbackify.callbackify)(Client.prototype.removeObjectTagging);
+Client.prototype.getBucketVersioning = (0, _callbackify.callbackify)(Client.prototype.getBucketVersioning);
+Client.prototype.setBucketVersioning = (0, _callbackify.callbackify)(Client.prototype.setBucketVersioning);
+Client.prototype.selectObjectContent = (0, _callbackify.callbackify)(Client.prototype.selectObjectContent);
+Client.prototype.setBucketLifecycle = (0, _callbackify.callbackify)(Client.prototype.setBucketLifecycle);
+Client.prototype.getBucketLifecycle = (0, _callbackify.callbackify)(Client.prototype.getBucketLifecycle);
+Client.prototype.removeBucketLifecycle = (0, _callbackify.callbackify)(Client.prototype.removeBucketLifecycle);
+Client.prototype.setBucketEncryption = (0, _callbackify.callbackify)(Client.prototype.setBucketEncryption);
+Client.prototype.getBucketEncryption = (0, _callbackify.callbackify)(Client.prototype.getBucketEncryption);
+Client.prototype.removeBucketEncryption = (0, _callbackify.callbackify)(Client.prototype.removeBucketEncryption);
+Client.prototype.getObjectRetention = (0, _callbackify.callbackify)(Client.prototype.getObjectRetention);
+Client.prototype.removeObjects = (0, _callbackify.callbackify)(Client.prototype.removeObjects);
+Client.prototype.removeIncompleteUpload = (0, _callbackify.callbackify)(Client.prototype.removeIncompleteUpload);
+Client.prototype.copyObject = (0, _callbackify.callbackify)(Client.prototype.copyObject);
+Client.prototype.composeObject = (0, _callbackify.callbackify)(Client.prototype.composeObject);
+Client.prototype.presignedUrl = (0, _callbackify.callbackify)(Client.prototype.presignedUrl);
+Client.prototype.presignedGetObject = (0, _callbackify.callbackify)(Client.prototype.presignedGetObject);
+Client.prototype.presignedPutObject = (0, _callbackify.callbackify)(Client.prototype.presignedPutObject);
+Client.prototype.presignedPostPolicy = (0, _callbackify.callbackify)(Client.prototype.presignedPostPolicy);
+Client.prototype.setBucketNotification = (0, _callbackify.callbackify)(Client.prototype.setBucketNotification);
+Client.prototype.getBucketNotification = (0, _callbackify.callbackify)(Client.prototype.getBucketNotification);
+Client.prototype.removeAllBucketNotification = (0, _callbackify.callbackify)(Client.prototype.removeAllBucketNotification);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_callbackify","require","_client","_copyConditions","exports","CopyConditions","_postPolicy","PostPolicy","_errors","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","_helpers","_notification","_IamAwsProvider","IamAwsProvider","Client","TypedClient","makeBucket","callbackify","bucketExists","removeBucket","listBuckets","getObject","fGetObject","getPartialObject","statObject","putObjectRetention","putObject","fPutObject","removeObject","removeBucketReplication","setBucketReplication","getBucketReplication","getObjectLegalHold","setObjectLegalHold","setObjectLockConfig","getObjectLockConfig","getBucketPolicy","setBucketPolicy","getBucketTagging","getObjectTagging","setBucketTagging","removeBucketTagging","setObjectTagging","removeObjectTagging","getBucketVersioning","setBucketVersioning","selectObjectContent","setBucketLifecycle","getBucketLifecycle","removeBucketLifecycle","setBucketEncryption","getBucketEncryption","removeBucketEncryption","getObjectRetention","removeObjects","removeIncompleteUpload","copyObject","composeObject","presignedUrl","presignedGetObject","presignedPutObject","presignedPostPolicy","setBucketNotification","getBucketNotification","removeAllBucketNotification"],"sources":["s3.ts"],"sourcesContent":["/*\n * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 Hanzo AI, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from './helpers.ts'\nimport { callbackify } from './internal/callbackify.ts'\nimport { TypedClient } from './internal/client.ts'\nimport { CopyConditions } from './internal/copy-conditions.ts'\nimport { PostPolicy } from './internal/post-policy.ts'\n\nexport * from './errors.ts'\nexport * from './helpers.ts'\nexport * from './notification.ts'\nexport { CopyConditions, PostPolicy }\nexport { IamAwsProvider } from './IamAwsProvider.ts'\nexport type { MakeBucketOpt } from './internal/client.ts'\nexport type { ClientOptions, NoResultCallback, RemoveOptions } from './internal/client.ts'\nexport type { Region } from './internal/s3-endpoints.ts'\nexport type {\n  BucketItem,\n  BucketItemCopy,\n  BucketItemFromList,\n  BucketItemStat,\n  BucketItemWithMetadata,\n  BucketStream,\n  EmptyObject,\n  ExistingObjectReplication,\n  GetObjectLegalHoldOptions,\n  IncompleteUploadedBucketItem,\n  InputSerialization,\n  IsoDate,\n  ItemBucketMetadata,\n  ItemBucketMetadataList,\n  LegalHoldStatus,\n  LifecycleConfig,\n  LifecycleRule,\n  MetadataItem,\n  ObjectLockInfo,\n  OutputSerialization,\n  PostPolicyResult,\n  PutObjectLegalHoldOptions,\n  ReplicaModifications,\n  ReplicationConfig,\n  ReplicationConfigOpts,\n  ReplicationRule,\n  ReplicationRuleAnd,\n  ReplicationRuleDestination,\n  ReplicationRuleFilter,\n  ReplicationRuleStatus,\n  Retention,\n  RetentionOptions,\n  ScanRange,\n  SelectOptions,\n  SelectProgress,\n  SourceSelectionCriteria,\n  Tag,\n} from './internal/type.ts'\n\n/**\n * @deprecated keep for backward compatible, use `RETENTION_MODES` instead\n */\nexport type Mode = RETENTION_MODES\n\n/**\n * @deprecated keep for backward compatible\n */\nexport type LockUnit = RETENTION_VALIDITY_UNITS\n\nexport type VersioningConfig = Record<string | number | symbol, unknown>\nexport type TagList = Record<string, string>\n\nexport interface LockConfig {\n  mode: RETENTION_MODES\n  unit: RETENTION_VALIDITY_UNITS\n  validity: number\n}\n\nexport interface LegalHoldOptions {\n  versionId: string\n  status: LEGAL_HOLD_STATUS\n}\n\nexport interface SourceObjectStats {\n  size: number\n  metaData: string\n  lastModicied: Date\n  versionId: string\n  etag: string\n}\n\nexport class Client extends TypedClient {}\n\n// refactored API use promise internally\nClient.prototype.makeBucket = callbackify(Client.prototype.makeBucket)\nClient.prototype.bucketExists = callbackify(Client.prototype.bucketExists)\nClient.prototype.removeBucket = callbackify(Client.prototype.removeBucket)\nClient.prototype.listBuckets = callbackify(Client.prototype.listBuckets)\n\nClient.prototype.getObject = callbackify(Client.prototype.getObject)\nClient.prototype.fGetObject = callbackify(Client.prototype.fGetObject)\nClient.prototype.getPartialObject = callbackify(Client.prototype.getPartialObject)\nClient.prototype.statObject = callbackify(Client.prototype.statObject)\nClient.prototype.putObjectRetention = callbackify(Client.prototype.putObjectRetention)\nClient.prototype.putObject = callbackify(Client.prototype.putObject)\nClient.prototype.fPutObject = callbackify(Client.prototype.fPutObject)\nClient.prototype.removeObject = callbackify(Client.prototype.removeObject)\n\nClient.prototype.removeBucketReplication = callbackify(Client.prototype.removeBucketReplication)\nClient.prototype.setBucketReplication = callbackify(Client.prototype.setBucketReplication)\nClient.prototype.getBucketReplication = callbackify(Client.prototype.getBucketReplication)\nClient.prototype.getObjectLegalHold = callbackify(Client.prototype.getObjectLegalHold)\nClient.prototype.setObjectLegalHold = callbackify(Client.prototype.setObjectLegalHold)\nClient.prototype.setObjectLockConfig = callbackify(Client.prototype.setObjectLockConfig)\nClient.prototype.getObjectLockConfig = callbackify(Client.prototype.getObjectLockConfig)\nClient.prototype.getBucketPolicy = callbackify(Client.prototype.getBucketPolicy)\nClient.prototype.setBucketPolicy = callbackify(Client.prototype.setBucketPolicy)\nClient.prototype.getBucketTagging = callbackify(Client.prototype.getBucketTagging)\nClient.prototype.getObjectTagging = callbackify(Client.prototype.getObjectTagging)\nClient.prototype.setBucketTagging = callbackify(Client.prototype.setBucketTagging)\nClient.prototype.removeBucketTagging = callbackify(Client.prototype.removeBucketTagging)\nClient.prototype.setObjectTagging = callbackify(Client.prototype.setObjectTagging)\nClient.prototype.removeObjectTagging = callbackify(Client.prototype.removeObjectTagging)\nClient.prototype.getBucketVersioning = callbackify(Client.prototype.getBucketVersioning)\nClient.prototype.setBucketVersioning = callbackify(Client.prototype.setBucketVersioning)\nClient.prototype.selectObjectContent = callbackify(Client.prototype.selectObjectContent)\nClient.prototype.setBucketLifecycle = callbackify(Client.prototype.setBucketLifecycle)\nClient.prototype.getBucketLifecycle = callbackify(Client.prototype.getBucketLifecycle)\nClient.prototype.removeBucketLifecycle = callbackify(Client.prototype.removeBucketLifecycle)\nClient.prototype.setBucketEncryption = callbackify(Client.prototype.setBucketEncryption)\nClient.prototype.getBucketEncryption = callbackify(Client.prototype.getBucketEncryption)\nClient.prototype.removeBucketEncryption = callbackify(Client.prototype.removeBucketEncryption)\nClient.prototype.getObjectRetention = callbackify(Client.prototype.getObjectRetention)\nClient.prototype.removeObjects = callbackify(Client.prototype.removeObjects)\nClient.prototype.removeIncompleteUpload = callbackify(Client.prototype.removeIncompleteUpload)\nClient.prototype.copyObject = callbackify(Client.prototype.copyObject)\nClient.prototype.composeObject = callbackify(Client.prototype.composeObject)\nClient.prototype.presignedUrl = callbackify(Client.prototype.presignedUrl)\nClient.prototype.presignedGetObject = callbackify(Client.prototype.presignedGetObject)\nClient.prototype.presignedPutObject = callbackify(Client.prototype.presignedPutObject)\nClient.prototype.presignedPostPolicy = callbackify(Client.prototype.presignedPostPolicy)\nClient.prototype.setBucketNotification = callbackify(Client.prototype.setBucketNotification)\nClient.prototype.getBucketNotification = callbackify(Client.prototype.getBucketNotification)\nClient.prototype.removeAllBucketNotification = callbackify(Client.prototype.removeAllBucketNotification)\n"],"mappings":"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"}

package/dist/main/signing.d.ts

@@ -0,0 +1,5 @@
+import type { IRequest } from "./internal/type.js";
+export declare function postPresignSignatureV4(region: string, date: Date, secretKey: string, policyBase64: string): string;
+export declare function signV4(request: IRequest, accessKey: string, secretKey: string, region: string, requestDate: Date, sha256sum: string, serviceName?: string): string;
+export declare function signV4ByServiceName(request: IRequest, accessKey: string, secretKey: string, region: string, requestDate: Date, contentSha256: string, serviceName?: string): string;
+export declare function presignSignatureV4(request: IRequest, accessKey: string, secretKey: string, sessionToken: string | undefined, region: string, requestDate: Date, expires: number | undefined): string;