@aws-amplify/storage 5.6.4-api-v6.2 → 5.6.4-api-v6.13

package/lib-esm/AwsClients/S3/runtime/xhrTransferHandler.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { HttpRequest, HttpResponse, TransferHandler } from '@aws-amplify/core/internals/aws-client-utils';
+import type { EventEmitter } from 'events';
+/**
+ * @internal
+ */
+export interface XhrTransferHandlerOptions {
+    responseType: 'text' | 'blob';
+    abortSignal?: AbortSignal;
+    emitter?: EventEmitter;
+}
+/**
+ * Base transfer handler implementation using XMLHttpRequest to support upload and download progress events.
+ *
+ * @param request - The request object.
+ * @param options - The request options.
+ * @returns A promise that will be resolved with the response object.
+ *
+ * @internal
+ */
+export declare const xhrTransferHandler: TransferHandler<HttpRequest, HttpResponse, XhrTransferHandlerOptions>;
+export declare const isCancelError: (error: unknown) => boolean;

package/lib-esm/AwsClients/S3/runtime/xhrTransferHandler.js

@@ -0,0 +1,196 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { withMemoization, } from '@aws-amplify/core/internals/aws-client-utils';
+import { ConsoleLogger as Logger } from '@aws-amplify/core';
+import { SEND_DOWNLOAD_PROGRESS_EVENT, SEND_UPLOAD_PROGRESS_EVENT, ABORT_ERROR_CODE, ABORT_ERROR_MESSAGE, CANCELED_ERROR_CODE, CANCELED_ERROR_MESSAGE, NETWORK_ERROR_CODE, NETWORK_ERROR_MESSAGE, } from './constants';
+var logger = new Logger('xhr-http-handler');
+/**
+ * Base transfer handler implementation using XMLHttpRequest to support upload and download progress events.
+ *
+ * @param request - The request object.
+ * @param options - The request options.
+ * @returns A promise that will be resolved with the response object.
+ *
+ * @internal
+ */
+export var xhrTransferHandler = function (request, options) {
+    var url = request.url, method = request.method, headers = request.headers, body = request.body;
+    var emitter = options.emitter, responseType = options.responseType, abortSignal = options.abortSignal;
+    return new Promise(function (resolve, reject) {
+        var _a;
+        var xhr = new XMLHttpRequest();
+        xhr.open(method.toUpperCase(), url.toString());
+        Object.entries(headers)
+            .filter(function (_a) {
+            var _b = __read(_a, 1), header = _b[0];
+            return !FORBIDDEN_HEADERS.includes(header);
+        })
+            .forEach(function (_a) {
+            var _b = __read(_a, 2), header = _b[0], value = _b[1];
+            xhr.setRequestHeader(header, value);
+        });
+        xhr.responseType = responseType;
+        if (emitter) {
+            xhr.upload.addEventListener('progress', function (event) {
+                emitter.emit(SEND_UPLOAD_PROGRESS_EVENT, event);
+                logger.debug(event);
+            });
+            xhr.addEventListener('progress', function (event) {
+                emitter.emit(SEND_DOWNLOAD_PROGRESS_EVENT, event);
+                logger.debug(event);
+            });
+        }
+        xhr.addEventListener('error', function () {
+            var error = simulateAxiosError(NETWORK_ERROR_MESSAGE, NETWORK_ERROR_CODE, xhr, options);
+            logger.error(NETWORK_ERROR_MESSAGE);
+            reject(error);
+            xhr = null; // clean up request
+        });
+        // Handle browser request cancellation (as opposed to a manual cancellation)
+        xhr.addEventListener('abort', function () {
+            // The abort event can be triggered after the error or load event. So we need to check if the xhr is null.
+            if (!xhr || (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted))
+                return;
+            var error = simulateAxiosError(ABORT_ERROR_MESSAGE, ABORT_ERROR_CODE, xhr, options);
+            logger.error(ABORT_ERROR_MESSAGE);
+            reject(error);
+            xhr = null; // clean up request
+        });
+        // Skip handling timeout error since we don't have a timeout
+        xhr.addEventListener('readystatechange', function () {
+            if (!xhr || xhr.readyState !== xhr.DONE) {
+                return;
+            }
+            var onloadend = function () {
+                // The load event is triggered after the error/abort/load event. So we need to check if the xhr is null.
+                if (!xhr)
+                    return;
+                var responseHeaders = convertResponseHeaders(xhr.getAllResponseHeaders());
+                var responseType = xhr.responseType;
+                var responseBlob = xhr.response;
+                var responseText = responseType === 'text' ? xhr.responseText : '';
+                var bodyMixIn = {
+                    blob: function () { return Promise.resolve(responseBlob); },
+                    text: withMemoization(function () {
+                        return responseType === 'blob'
+                            ? readBlobAsText(responseBlob)
+                            : Promise.resolve(responseText);
+                    }),
+                    json: function () {
+                        return Promise.reject(
+                        // S3 does not support JSON response. So fail-fast here with nicer error message.
+                        new Error('Parsing response to JSON is not implemented. Please use response.text() instead.'));
+                    },
+                };
+                var response = {
+                    statusCode: xhr.status,
+                    headers: responseHeaders,
+                    // The xhr.responseType is only set to 'blob' for streaming binary S3 object data. The streaming data is
+                    // exposed via public interface of Storage.get(). So we need to return the response as a Blob object for
+                    // backward compatibility. In other cases, the response payload is only used internally, we return it is
+                    // {@link ResponseBodyMixin}
+                    body: (xhr.responseType === 'blob'
+                        ? Object.assign(responseBlob, bodyMixIn)
+                        : bodyMixIn),
+                };
+                resolve(response);
+                xhr = null; // clean up request
+            };
+            // readystate handler is calling before onerror or ontimeout handlers,
+            // so we should call onloadend on the next 'tick'
+            // @see https://github.com/axios/axios/blob/9588fcdec8aca45c3ba2f7968988a5d03f23168c/lib/adapters/xhr.js#L98-L99
+            setTimeout(onloadend);
+        });
+        if (abortSignal) {
+            var onCancelled = function () {
+                // The abort event is triggered after the error or load event. So we need to check if the xhr is null.
+                if (!xhr) {
+                    return;
+                }
+                var canceledError = simulateAxiosCanceledError(CANCELED_ERROR_MESSAGE !== null && CANCELED_ERROR_MESSAGE !== void 0 ? CANCELED_ERROR_MESSAGE : abortSignal.reason, CANCELED_ERROR_CODE, xhr, options);
+                xhr.abort();
+                reject(canceledError);
+                xhr = null;
+            };
+            abortSignal.aborted
+                ? onCancelled()
+                : abortSignal.addEventListener('abort', onCancelled);
+        }
+        if (typeof ReadableStream === 'function' &&
+            body instanceof ReadableStream) {
+            // This does not matter as previous implementation uses Axios which does not support ReadableStream anyway.
+            throw new Error('ReadableStream request payload is not supported.');
+        }
+        xhr.send((_a = body) !== null && _a !== void 0 ? _a : null);
+    });
+};
+// TODO: V6 remove this
+var simulateAxiosError = function (message, code, request, config) {
+    return Object.assign(new Error(message), {
+        code: code,
+        config: config,
+        request: request,
+    });
+};
+var simulateAxiosCanceledError = function (message, code, request, config) {
+    var error = simulateAxiosError(message, code, request, config);
+    error.name = 'CanceledError';
+    error['__CANCEL__'] = true;
+    return error;
+};
+export var isCancelError = function (error) {
+    return !!(error === null || error === void 0 ? void 0 : error['__CANCEL__']);
+};
+/**
+ * Convert xhr.getAllResponseHeaders() string to a Record<string, string>. Note that modern browser already returns
+ * header names in lowercase.
+ * @param xhrHeaders - string of headers returned from xhr.getAllResponseHeaders()
+ */
+var convertResponseHeaders = function (xhrHeaders) {
+    if (!xhrHeaders) {
+        return {};
+    }
+    return xhrHeaders
+        .split('\r\n')
+        .reduce(function (headerMap, line) {
+        var parts = line.split(': ');
+        var header = parts.shift();
+        var value = parts.join(': ');
+        headerMap[header.toLowerCase()] = value;
+        return headerMap;
+    }, {});
+};
+var readBlobAsText = function (blob) {
+    var reader = new FileReader();
+    return new Promise(function (resolve, reject) {
+        reader.onloadend = function () {
+            if (reader.readyState !== FileReader.DONE) {
+                return;
+            }
+            resolve(reader.result);
+        };
+        reader.onerror = function () {
+            reject(reader.error);
+        };
+        reader.readAsText(blob);
+    });
+};
+// To add more forbidden headers as found set by S3. Intentionally NOT list all of them here to save bundle size.
+// https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name
+var FORBIDDEN_HEADERS = ['host'];

package/lib-esm/AwsClients/S3/runtime/xmlParser/dom.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Drop-in replacement for fast-xml-parser's XmlParser class used in the AWS SDK S3 client XML deserializer. This
+ * implementation is not tested against the full xml conformance test suite. It is only tested against the XML responses
+ * from S3. This implementation requires the `DOMParser` class in the runtime.
+ */
+export declare const parser: {
+    parse: (xmlStr: string) => any;
+};

package/lib-esm/AwsClients/S3/runtime/xmlParser/dom.js

@@ -0,0 +1,89 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Drop-in replacement for fast-xml-parser's XmlParser class used in the AWS SDK S3 client XML deserializer. This
+ * implementation is not tested against the full xml conformance test suite. It is only tested against the XML responses
+ * from S3. This implementation requires the `DOMParser` class in the runtime.
+ */
+export var parser = {
+    parse: function (xmlStr) {
+        var domParser = new DOMParser();
+        var xml = domParser.parseFromString(xmlStr, 'text/xml');
+        var parsedObj = parseXmlNode(xml);
+        var rootKey = Object.keys(parsedObj)[0];
+        return parsedObj[rootKey];
+    },
+};
+var parseXmlNode = function (node) {
+    var _a;
+    var _b, _c;
+    if (isDocumentNode(node)) {
+        return _a = {},
+            _a[node.documentElement.nodeName] = parseXmlNode(node.documentElement),
+            _a;
+    }
+    if (node.nodeType === Node.TEXT_NODE) {
+        return (_b = node.nodeValue) === null || _b === void 0 ? void 0 : _b.trim();
+    }
+    if (isElementNode(node)) {
+        // Node like <Location>foo</Location> will be converted to { Location: 'foo' }
+        // instead of { Location: { '#text': 'foo' } }.
+        if (isTextOnlyElementNode(node)) {
+            return (_c = node.childNodes[0]) === null || _c === void 0 ? void 0 : _c.nodeValue;
+        }
+        var nodeValue = {};
+        // convert attributes
+        for (var i = 0; i < node.attributes.length; i++) {
+            var attr = node.attributes[i];
+            if (!isNamespaceAttributeName(attr.nodeName)) {
+                nodeValue[attr.nodeName] = attr.nodeValue;
+            }
+        }
+        // convert child nodes
+        if (node.children.length > 0) {
+            for (var i = 0; i < node.children.length; i++) {
+                var child = node.children[i];
+                var childValue = parseXmlNode(child);
+                if (childValue === undefined) {
+                    continue;
+                }
+                var childName = child.nodeName;
+                if (nodeValue[childName] === undefined) {
+                    nodeValue[childName] = childValue;
+                }
+                else if (Array.isArray(nodeValue[childName])) {
+                    nodeValue[childName].push(childValue);
+                }
+                else {
+                    nodeValue[childName] = [nodeValue[childName], childValue];
+                }
+            }
+        }
+        // Return empty element node as empty string instead of `{}`, which is the default behavior of fast-xml-parser.
+        return Object.keys(nodeValue).length === 0 ? '' : nodeValue;
+    }
+};
+var isElementNode = function (node) {
+    return node.nodeType === Node.ELEMENT_NODE;
+};
+var isDocumentNode = function (node) {
+    return node.nodeType === Node.DOCUMENT_NODE;
+};
+var isTextOnlyElementNode = function (node) {
+    var _a;
+    return hasOnlyNamespaceAttributes(node) &&
+        node.children.length === 0 &&
+        ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.nodeType) === Node.TEXT_NODE;
+};
+var hasOnlyNamespaceAttributes = function (node) {
+    for (var i = 0; i < node.attributes.length; i++) {
+        var attr = node.attributes[i];
+        if (!isNamespaceAttributeName(attr.nodeName)) {
+            return false;
+        }
+    }
+    return true;
+};
+var isNamespaceAttributeName = function (name) {
+    return name === 'xmlns' || name.startsWith('xmlns:');
+};

package/lib-esm/AwsClients/S3/runtime/xmlParser/pureJs.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pure JS XML parser that can be used in Non-browser environments, like React Native and Node.js. This is the same
+ * XML parser implementation as used in AWS SDK S3 client. It depends on pure JavaScript XML parser library
+ * `fast-xml-parser`.
+ *
+ * Ref: https://github.com/aws/aws-sdk-js-v3/blob/1e806ba3f4a83c9e3eb0b41a3a7092da93826b8f/clients/client-s3/src/protocols/Aws_restXml.ts#L12938-L12959
+ */
+export declare const parser: {
+    parse: (xmlStr: string) => any;
+};

package/lib-esm/AwsClients/S3/runtime/xmlParser/pureJs.js

@@ -0,0 +1,54 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { XMLParser } from 'fast-xml-parser';
+/**
+ * Pure JS XML parser that can be used in Non-browser environments, like React Native and Node.js. This is the same
+ * XML parser implementation as used in AWS SDK S3 client. It depends on pure JavaScript XML parser library
+ * `fast-xml-parser`.
+ *
+ * Ref: https://github.com/aws/aws-sdk-js-v3/blob/1e806ba3f4a83c9e3eb0b41a3a7092da93826b8f/clients/client-s3/src/protocols/Aws_restXml.ts#L12938-L12959
+ */
+export var parser = {
+    parse: function (xmlStr) {
+        var parser = new XMLParser({
+            attributeNamePrefix: '',
+            htmlEntities: true,
+            ignoreAttributes: false,
+            ignoreDeclaration: true,
+            parseTagValue: false,
+            trimValues: false,
+            removeNSPrefix: true,
+            tagValueProcessor: function (_, val) {
+                return val.trim() === '' && val.includes('\n') ? '' : undefined;
+            },
+        });
+        parser.addEntity('#xD', '\r');
+        parser.addEntity('#10', '\n');
+        var parsedObj = parser.parse(xmlStr);
+        var textNodeName = '#text';
+        var key = Object.keys(parsedObj)[0];
+        var parsedObjToReturn = parsedObj[key];
+        if (parsedObjToReturn[textNodeName]) {
+            parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
+            delete parsedObjToReturn[textNodeName];
+        }
+        return getValueFromTextNode(parsedObjToReturn);
+    },
+};
+/**
+ * Recursively parses object and populates value is node from "#text" key if it's available
+ *
+ * Ref: https://github.com/aws/aws-sdk-js-v3/blob/6b4bde6f338720abf28b931f8a4506613bd64d3f/packages/smithy-client/src/get-value-from-text-node.ts#L1
+ */
+var getValueFromTextNode = function (obj) {
+    var textNodeName = '#text';
+    for (var key in obj) {
+        if (obj.hasOwnProperty(key) && obj[key][textNodeName] !== undefined) {
+            obj[key] = obj[key][textNodeName];
+        }
+        else if (typeof obj[key] === 'object' && obj[key] !== null) {
+            obj[key] = getValueFromTextNode(obj[key]);
+        }
+    }
+    return obj;
+};