@aws-sdk/lib-storage 3.32.0 → 3.36.0

package/CHANGELOG.md

@@ -3,6 +3,44 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.36.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.35.0...v3.36.0) (2021-10-08)
+
+
+### Features
+
+* publish files in dist-* only ([#2873](https://github.com/aws/aws-sdk-js-v3/issues/2873)) ([53b4243](https://github.com/aws/aws-sdk-js-v3/commit/53b4243b066f25ff2412d5f0dea1036054b2df32))
+
+
+
+
+
+# [3.35.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.34.0...v3.35.0) (2021-10-04)
+
+**Note:** Version bump only for package @aws-sdk/lib-storage
+
+
+
+
+
+# [3.34.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.33.0...v3.34.0) (2021-09-24)
+
+
+### Features
+
+* **non-clients:** remove comments from transpiled JS files ([#2813](https://github.com/aws/aws-sdk-js-v3/issues/2813)) ([e6fc7f3](https://github.com/aws/aws-sdk-js-v3/commit/e6fc7f3e0fa74785590ac19e7ed143c916bb9b6e))
+
+
+
+
+
+# [3.33.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.32.0...v3.33.0) (2021-09-21)
+
+**Note:** Version bump only for package @aws-sdk/lib-storage
+
+
+
+
+
 # [3.32.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.31.0...v3.32.0) (2021-09-17)
 
 **Note:** Version bump only for package @aws-sdk/lib-storage

package/dist-cjs/Upload.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Upload = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const events_1 = require("events");
+const chunker_1 = require("./chunker");
+const bytelength_1 = require("./bytelength");
+const abort_controller_1 = require("@aws-sdk/abort-controller");
+const MIN_PART_SIZE = 1024 * 1024 * 5;
+class Upload extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.MAX_PARTS = 10000;
+        this.queueSize = 4;
+        this.partSize = MIN_PART_SIZE;
+        this.leavePartsOnError = false;
+        this.tags = [];
+        this.concurrentUploaders = [];
+        this.uploadedParts = [];
+        this.isMultiPart = true;
+        this.queueSize = options.queueSize || this.queueSize;
+        this.partSize = options.partSize || this.partSize;
+        this.leavePartsOnError = options.leavePartsOnError || this.leavePartsOnError;
+        this.tags = options.tags || this.tags;
+        this.client = options.client;
+        this.params = options.params;
+        this.__validateInput();
+        this.totalBytes = bytelength_1.byteLength(this.params.Body);
+        this.bytesUploadedSoFar = 0;
+        this.abortController = new abort_controller_1.AbortController();
+    }
+    async abort() {
+        this.abortController.abort();
+    }
+    async done() {
+        return await Promise.race([this.__doMultipartUpload(), this.__abortTimeout(this.abortController.signal)]);
+    }
+    on(event, listener) {
+        this.uploadEvent = event;
+        super.on(event, listener);
+    }
+    async __uploadUsingPut(dataPart) {
+        this.isMultiPart = false;
+        const params = { ...this.params, Body: dataPart.data };
+        const putResult = await this.client.send(new client_s3_1.PutObjectCommand(params));
+        this.putResponse = putResult;
+        const totalSize = bytelength_1.byteLength(dataPart.data);
+        this.__notifyProgress({
+            loaded: totalSize,
+            total: totalSize,
+            part: 1,
+            Key: this.params.Key,
+            Bucket: this.params.Bucket,
+        });
+    }
+    async __createMultipartUpload() {
+        if (!this.createMultiPartPromise) {
+            const createCommandParams = { ...this.params, Body: undefined };
+            this.createMultiPartPromise = this.client.send(new client_s3_1.CreateMultipartUploadCommand(createCommandParams));
+        }
+        const createMultipartUploadResult = await this.createMultiPartPromise;
+        this.uploadId = createMultipartUploadResult.UploadId;
+    }
+    async __doConcurrentUpload(dataFeeder) {
+        for await (const dataPart of dataFeeder) {
+            if (this.uploadedParts.length > this.MAX_PARTS) {
+                throw new Error(`Exceeded ${this.MAX_PARTS} as part of the upload to ${this.params.Key} and ${this.params.Bucket}.`);
+            }
+            try {
+                if (this.abortController.signal.aborted) {
+                    return;
+                }
+                if (dataPart.partNumber === 1 && dataPart.lastPart) {
+                    return await this.__uploadUsingPut(dataPart);
+                }
+                if (!this.uploadId) {
+                    await this.__createMultipartUpload();
+                    if (this.abortController.signal.aborted) {
+                        return;
+                    }
+                }
+                const partResult = await this.client.send(new client_s3_1.UploadPartCommand({
+                    ...this.params,
+                    UploadId: this.uploadId,
+                    Body: dataPart.data,
+                    PartNumber: dataPart.partNumber,
+                }));
+                if (this.abortController.signal.aborted) {
+                    return;
+                }
+                this.uploadedParts.push({
+                    PartNumber: dataPart.partNumber,
+                    ETag: partResult.ETag,
+                });
+                this.bytesUploadedSoFar += bytelength_1.byteLength(dataPart.data);
+                this.__notifyProgress({
+                    loaded: this.bytesUploadedSoFar,
+                    total: this.totalBytes,
+                    part: dataPart.partNumber,
+                    Key: this.params.Key,
+                    Bucket: this.params.Bucket,
+                });
+            }
+            catch (e) {
+                if (!this.uploadId) {
+                    throw e;
+                }
+                if (this.leavePartsOnError) {
+                    throw e;
+                }
+            }
+        }
+    }
+    async __doMultipartUpload() {
+        const dataFeeder = chunker_1.getChunk(this.params.Body, this.partSize);
+        for (let index = 0; index < this.queueSize; index++) {
+            const currentUpload = this.__doConcurrentUpload(dataFeeder);
+            this.concurrentUploaders.push(currentUpload);
+        }
+        await Promise.all(this.concurrentUploaders);
+        if (this.abortController.signal.aborted) {
+            throw Object.assign(new Error("Upload aborted."), { name: "AbortError" });
+        }
+        let result;
+        if (this.isMultiPart) {
+            this.uploadedParts.sort((a, b) => a.PartNumber - b.PartNumber);
+            const uploadCompleteParams = {
+                ...this.params,
+                Body: undefined,
+                UploadId: this.uploadId,
+                MultipartUpload: {
+                    Parts: this.uploadedParts,
+                },
+            };
+            result = await this.client.send(new client_s3_1.CompleteMultipartUploadCommand(uploadCompleteParams));
+        }
+        else {
+            result = this.putResponse;
+        }
+        if (this.tags.length) {
+            await this.client.send(new client_s3_1.PutObjectTaggingCommand({
+                ...this.params,
+                Tagging: {
+                    TagSet: this.tags,
+                },
+            }));
+        }
+        return result;
+    }
+    __notifyProgress(progress) {
+        if (this.uploadEvent) {
+            this.emit(this.uploadEvent, progress);
+        }
+    }
+    async __abortTimeout(abortSignal) {
+        return new Promise((resolve, reject) => {
+            abortSignal.onabort = () => {
+                const abortError = new Error("Upload aborted.");
+                abortError.name = "AbortError";
+                reject(abortError);
+            };
+        });
+    }
+    __validateInput() {
+        if (!this.params) {
+            throw new Error(`InputError: Upload requires params to be passed to upload.`);
+        }
+        if (!this.client) {
+            throw new Error(`InputError: Upload requires a AWS client to do uploads with.`);
+        }
+        if (this.partSize < MIN_PART_SIZE) {
+            throw new Error(`EntityTooSmall: Your proposed upload partsize [${this.partSize}] is smaller than the minimum allowed size [${MIN_PART_SIZE}] (5MB)`);
+        }
+        if (this.queueSize < 1) {
+            throw new Error(`Queue size: Must have at least one uploading queue.`);
+        }
+    }
+}
+exports.Upload = Upload;

package/dist-cjs/bytelength.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.byteLength = void 0;
+const runtimeConfig_1 = require("./runtimeConfig");
+const byteLength = (input) => {
+    if (input === null || input === undefined)
+        return 0;
+    if (typeof input === "string")
+        input = Buffer.from(input);
+    if (typeof input.byteLength === "number") {
+        return input.byteLength;
+    }
+    else if (typeof input.length === "number") {
+        return input.length;
+    }
+    else if (typeof input.size === "number") {
+        return input.size;
+    }
+    else if (typeof input.path === "string") {
+        try {
+            return runtimeConfig_1.ClientDefaultValues.lstatSync(input.path).size;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    return undefined;
+};
+exports.byteLength = byteLength;

package/dist-cjs/chunker.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChunk = void 0;
+const stream_1 = require("stream");
+const buffer_1 = require("buffer");
+const getChunkBuffer_1 = require("./chunks/getChunkBuffer");
+const getChunkStream_1 = require("./chunks/getChunkStream");
+const getDataReadableStream_1 = require("./chunks/getDataReadableStream");
+const getDataReadable_1 = require("./chunks/getDataReadable");
+const getChunk = (data, partSize) => {
+    if (data instanceof buffer_1.Buffer) {
+        return getChunkBuffer_1.getChunkBuffer(data, partSize);
+    }
+    else if (data instanceof stream_1.Readable) {
+        return getChunkStream_1.getChunkStream(data, partSize, getDataReadable_1.getDataReadable);
+    }
+    else if (data instanceof String || typeof data === "string" || data instanceof Uint8Array) {
+        return getChunkBuffer_1.getChunkBuffer(buffer_1.Buffer.from(data), partSize);
+    }
+    if (typeof data.stream === "function") {
+        return getChunkStream_1.getChunkStream(data.stream(), partSize, getDataReadableStream_1.getDataReadableStream);
+    }
+    else if (data instanceof ReadableStream) {
+        return getChunkStream_1.getChunkStream(data, partSize, getDataReadableStream_1.getDataReadableStream);
+    }
+    else {
+        throw new Error("Body Data is unsupported format, expected data to be one of: string | Uint8Array | Buffer | Readable | ReadableStream | Blob;.");
+    }
+};
+exports.getChunk = getChunk;

package/dist-cjs/chunks/getChunkBuffer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChunkBuffer = void 0;
+async function* getChunkBuffer(data, partSize) {
+    let partNumber = 1;
+    let startByte = 0;
+    let endByte = partSize;
+    while (endByte < data.byteLength) {
+        yield {
+            partNumber,
+            data: data.slice(startByte, endByte),
+        };
+        partNumber += 1;
+        startByte = endByte;
+        endByte = startByte + partSize;
+    }
+    yield {
+        partNumber,
+        data: data.slice(startByte),
+        lastPart: true,
+    };
+}
+exports.getChunkBuffer = getChunkBuffer;

package/dist-cjs/chunks/getChunkStream.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChunkStream = void 0;
+const buffer_1 = require("buffer");
+async function* getChunkStream(data, partSize, getNextData) {
+    let partNumber = 1;
+    const currentBuffer = { chunks: [], length: 0 };
+    for await (const datum of getNextData(data)) {
+        currentBuffer.chunks.push(datum);
+        currentBuffer.length += datum.length;
+        while (currentBuffer.length >= partSize) {
+            const dataChunk = currentBuffer.chunks.length > 1 ? buffer_1.Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0];
+            yield {
+                partNumber,
+                data: dataChunk.slice(0, partSize),
+            };
+            currentBuffer.chunks = [dataChunk.slice(partSize)];
+            currentBuffer.length = currentBuffer.chunks[0].length;
+            partNumber += 1;
+        }
+    }
+    yield {
+        partNumber,
+        data: buffer_1.Buffer.concat(currentBuffer.chunks),
+        lastPart: true,
+    };
+}
+exports.getChunkStream = getChunkStream;

package/dist-cjs/chunks/getDataReadable.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDataReadable = void 0;
+const buffer_1 = require("buffer");
+async function* getDataReadable(data) {
+    for await (const chunk of data) {
+        yield buffer_1.Buffer.from(chunk);
+    }
+}
+exports.getDataReadable = getDataReadable;

package/dist-cjs/chunks/getDataReadableStream.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDataReadableStream = void 0;
+const buffer_1 = require("buffer");
+async function* getDataReadableStream(data) {
+    const reader = data.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            yield buffer_1.Buffer.from(value);
+        }
+    }
+    catch (e) {
+        throw e;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+exports.getDataReadableStream = getDataReadableStream;

package/dist-cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./Upload"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/dist-cjs/runtimeConfig.browser.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientDefaultValues = void 0;
+const runtimeConfig_shared_1 = require("./runtimeConfig.shared");
+exports.ClientDefaultValues = {
+    ...runtimeConfig_shared_1.ClientSharedValues,
+    runtime: "browser",
+};

package/dist-cjs/runtimeConfig.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientDefaultValues = void 0;
+const runtimeConfig_shared_1 = require("./runtimeConfig.shared");
+const fs_1 = require("fs");
+exports.ClientDefaultValues = {
+    ...runtimeConfig_shared_1.ClientSharedValues,
+    runtime: "node",
+    lstatSync: fs_1.lstatSync,
+};

package/dist-cjs/runtimeConfig.native.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientDefaultValues = void 0;
+const runtimeConfig_browser_1 = require("./runtimeConfig.browser");
+exports.ClientDefaultValues = {
+    ...runtimeConfig_browser_1.ClientDefaultValues,
+    runtime: "react-native",
+};

package/dist-cjs/runtimeConfig.shared.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientSharedValues = void 0;
+exports.ClientSharedValues = {
+    lstatSync: () => { },
+};

package/dist-cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });