s3mini 0.9.2 → 0.9.4

package/dist/s3mini.js

@@ -31,6 +31,21 @@ const ERROR_UPLOAD_ID_REQUIRED = `${ERROR_PREFIX}uploadId must be a non-empty st
 const ERROR_PREFIX_TYPE = `${ERROR_PREFIX}prefix must be a string`;
 const ERROR_DELIMITER_REQUIRED = `${ERROR_PREFIX}delimiter must be a string`;
 
+const isBun = typeof navigator !== 'undefined' && navigator.userAgent === 'Bun';
+/** Strips the bucket name from a full endpoint URL, returning the base origin for Bun.S3Client. */
+const extractBaseEndpoint = (endpoint, bucket) => {
+    // Path-style (/bucket/…): just use the origin
+    if (endpoint.pathname.split('/').some(Boolean)) {
+        return endpoint.origin;
+    }
+    // Virtual-hosted (bucket.host…): strip the bucket subdomain
+    const prefix = bucket + '.';
+    if (endpoint.hostname.startsWith(prefix)) {
+        const base = endpoint.hostname.slice(prefix.length);
+        return `${endpoint.protocol}//${base}${endpoint.port ? ':' + endpoint.port : ''}`;
+    }
+    return endpoint.origin;
+};
 const ENCODR = new TextEncoder();
 const chunkSize = 0x8000; // 32KB chunks
 const HEX_CHARS = new Uint8Array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102]);
@@ -155,7 +170,7 @@ const unescapeXml = (value) => value.replaceAll(/&(quot|apos|lt|gt|amp);/g, m =>
  */
 const parseXml = (input) => {
     const xmlContent = input.replace(/<\?xml[^?]*\?>\s*/, '');
-    const RE_TAG = /<([A-Za-z_][\w\-.]*)[^>]*>([\s\S]*?)<\/\1>/gm;
+    const RE_TAG = /<([A-Za-z_][\w\-.]*)[^>]*?>([\s\S]*?)<\/\1>/gm;
     const result = {}; // strong type, no `any`
     let match;
     while ((match = RE_TAG.exec(xmlContent)) !== null) {
@@ -398,6 +413,7 @@ class S3mini {
     logger;
     _fetch;
     minPartSize;
+    _bun;
     signingKeyDate;
     signingKey;
     constructor({ accessKeyId, secretAccessKey, endpoint, region = 'auto', requestSizeInBytes = DEFAULT_REQUEST_SIZE_IN_BYTES, requestAbortTimeout = undefined, logger = undefined, fetch = globalThis.fetch, minPartSize = MIN_PART_SIZE, }) {
@@ -412,6 +428,16 @@ class S3mini {
         this.logger = logger;
         this._fetch = (input, init) => fetch(input, init);
         this.minPartSize = minPartSize;
+        if (isBun) {
+            const { S3Client } = globalThis.Bun;
+            this._bun = new S3Client({
+                accessKeyId,
+                secretAccessKey,
+                endpoint: extractBaseEndpoint(this.endpoint, this.bucketName),
+                region: this.region,
+                bucket: this.bucketName,
+            });
+        }
     }
     _sanitize(obj) {
         if (typeof obj !== 'object' || obj === null) {
@@ -472,6 +498,18 @@ class S3mini {
     _hasCredentials() {
         return this.#accessKeyId.trim().length > 0 && this.#secretAccessKey.trim().length > 0;
     }
+    /** Run a read op via Bun-native S3, returning null on NoSuchKey. */
+    async _bunRead(key, op) {
+        try {
+            return await op(this._bun.file(key));
+        }
+        catch (e) {
+            if (e?.code === 'NoSuchKey') {
+                return null;
+            }
+            throw e;
+        }
+    }
     _ensureValidUrl(raw) {
         const candidate = /^(https?:)?\/\//i.test(raw) ? raw : `https://${raw}`;
         try {
@@ -677,32 +715,24 @@ class S3mini {
     }
     _extractBucketName() {
         const url = this.endpoint;
-        // First check if bucket is in the pathname (path-style URLs)
-        const pathSegments = url.pathname.split('/').filter(Boolean);
-        if (pathSegments.length > 0) {
-            if (typeof pathSegments[0] === 'string') {
-                return pathSegments[0];
-            }
+        // Path-style: bucket is the first non-empty path segment
+        const firstSegment = url.pathname.split('/').find(Boolean);
+        if (firstSegment) {
+            return firstSegment;
+        }
+        // Virtual-hosted style: bucket is the first subdomain label
+        const hostname = url.hostname;
+        // IP addresses (v4: digits+dots, v6: contains colons) can't carry a bucket subdomain
+        if (/^\d+\.\d+\.\d+\.\d+$/.test(hostname) || hostname.includes(':')) {
+            return '';
         }
-        // Otherwise extract from subdomain (virtual-hosted-style URLs)
-        const hostParts = url.hostname.split('.');
-        // Common patterns:
-        // bucket-name.s3.amazonaws.com
-        // bucket-name.s3.region.amazonaws.com
-        // bucket-name.region.digitaloceanspaces.com
-        // bucket-name.region.cdn.digitaloceanspaces.com
-        if (hostParts.length >= 3) {
-            // Check if it's a known S3-compatible service
-            const domain = hostParts.slice(-2).join('.');
-            const knownDomains = ['amazonaws.com', 'digitaloceanspaces.com', 'cloudflare.com'];
-            if (knownDomains.some(d => domain.includes(d))) {
-                if (typeof hostParts[0] === 'string') {
-                    return hostParts[0];
-                }
-            }
+        const labels = hostname.split('.');
+        // Need ≥3 labels for virtual-hosted (bucket.service.tld)
+        // Single-label (localhost) or two-label (example.com) have no room for a bucket subdomain
+        if (labels.length < 3) {
+            return '';
         }
-        // Fallback: use the first subdomain
-        return hostParts[0] || '';
+        return labels[0];
     }
     /**
      * Checks if a bucket exists.
@@ -732,6 +762,12 @@ class S3mini {
         this._checkDelimiter(delimiter);
         this._checkPrefix(prefix);
         this._checkOpts(opts);
+        if (this._bun && delimiter === '/') {
+            const extraKeys = Object.keys(opts).filter(k => k !== 'delimiter');
+            if (extraKeys.length === 0) {
+                return this._bunListAll(prefix, maxKeys, opts.delimiter);
+            }
+        }
         const keyPath = delimiter === '/' ? delimiter : uriEscape(delimiter);
         const unlimited = !(maxKeys && maxKeys > 0);
         let remaining = unlimited ? Infinity : maxKeys;
@@ -772,13 +808,17 @@ class S3mini {
         this._checkOpts(opts);
         const keyPath = delimiter === '/' ? delimiter : uriEscape(delimiter);
         let token = nextContinuationToken;
+        let remaining = maxKeys;
         const all = [];
-        const batchResult = await this._fetchObjectBatch(keyPath, prefix, maxKeys, token, opts);
-        if (batchResult === null) {
-            return null; // 404 - bucket not found
-        }
-        all.push(...batchResult.objects);
-        token = batchResult.continuationToken;
+        do {
+            const batchResult = await this._fetchObjectBatch(keyPath, prefix, remaining, token, opts);
+            if (batchResult === null) {
+                return null; // 404 - bucket not found
+            }
+            all.push(...batchResult.objects);
+            remaining -= batchResult.objects.length;
+            token = batchResult.continuationToken;
+        } while (token && remaining > 0);
         return { objects: all, nextContinuationToken: token };
     }
     async _fetchObjectBatch(keyPath, prefix, remaining, token, opts) {
@@ -873,6 +913,71 @@ class S3mini {
             response.NextMarker ||
             response.nextMarker);
     }
+    async _bunListAll(prefix, maxKeys, delimiter) {
+        const unlimited = !(maxKeys && maxKeys > 0);
+        let remaining = unlimited ? Infinity : maxKeys;
+        let startAfter;
+        const all = [];
+        try {
+            do {
+                const batchSize = Math.min(remaining === Infinity ? 1000 : remaining, 1000);
+                const res = await this._bunFetchPage(prefix, delimiter, batchSize, startAfter);
+                const mapped = this._bunMapListResult(res);
+                all.push(...mapped);
+                if (!unlimited) {
+                    remaining -= mapped.length;
+                }
+                startAfter = this._bunNextCursor(res);
+            } while (startAfter && remaining > 0);
+        }
+        catch (e) {
+            if (e?.code === 'NoSuchBucket') {
+                return null;
+            }
+            throw e;
+        }
+        return all;
+    }
+    _bunFetchPage(prefix, delimiter, maxKeys, startAfter) {
+        return this._bun.list({
+            prefix: prefix || undefined,
+            delimiter: delimiter || '/',
+            maxKeys,
+            ...(startAfter ? { startAfter } : {}),
+        });
+    }
+    _bunNextCursor(res) {
+        if (!res.isTruncated) {
+            return undefined;
+        }
+        return res.contents?.length ? res.contents.at(-1).key : undefined;
+    }
+    _bunMapListResult(res) {
+        const objects = [];
+        if (res.contents) {
+            for (const item of res.contents) {
+                objects.push({
+                    Key: item.key,
+                    Size: item.size,
+                    LastModified: item.lastModified instanceof Date ? item.lastModified : new Date(item.lastModified),
+                    ETag: item.etag ?? '',
+                    StorageClass: item.storageClass ?? '',
+                });
+            }
+        }
+        if (res.commonPrefixes) {
+            for (const item of res.commonPrefixes) {
+                objects.push({
+                    Key: item.prefix,
+                    Size: 0,
+                    LastModified: new Date(0),
+                    ETag: '',
+                    StorageClass: '',
+                });
+            }
+        }
+        return objects;
+    }
     /**
      * Lists multipart uploads in the bucket.
      * This method sends a request to list multipart uploads in the specified bucket.
@@ -919,7 +1024,9 @@ class S3mini {
      * @returns A promise that resolves to the object data (string) or null if not found.
      */
     async getObject(key, opts = {}, ssecHeaders) {
-        // if ssecHeaders is set, add it to headers
+        if (this._bun && !ssecHeaders && !Object.keys(opts).length) {
+            return this._bunRead(key, f => f.text());
+        }
         const res = await this._signedRequest('GET', key, {
             query: opts, // use opts.query if it exists, otherwise use an empty object
             tolerated: [200, 404, 412, 304],
@@ -961,6 +1068,9 @@ class S3mini {
      * @returns A promise that resolves to the object data as an ArrayBuffer or null if not found.
      */
     async getObjectArrayBuffer(key, opts = {}, ssecHeaders) {
+        if (this._bun && !ssecHeaders && !Object.keys(opts).length) {
+            return this._bunRead(key, f => f.arrayBuffer());
+        }
         const res = await this._signedRequest('GET', key, {
             query: opts,
             tolerated: [200, 404, 412, 304],
@@ -981,6 +1091,9 @@ class S3mini {
      * @returns A promise that resolves to the object data as JSON or null if not found.
      */
     async getObjectJSON(key, opts = {}, ssecHeaders) {
+        if (this._bun && !ssecHeaders && !Object.keys(opts).length) {
+            return this._bunRead(key, f => f.json());
+        }
         const res = await this._signedRequest('GET', key, {
             query: opts,
             tolerated: [200, 404, 412, 304],
@@ -1001,6 +1114,19 @@ class S3mini {
      * @returns A promise that resolves to an object containing the ETag and the object data as an ArrayBuffer or null if not found.
      */
     async getObjectWithETag(key, opts = {}, ssecHeaders) {
+        if (this._bun && !ssecHeaders && !Object.keys(opts).length) {
+            try {
+                const f = this._bun.file(key);
+                const [stat, data] = await Promise.all([f.stat(), f.arrayBuffer()]);
+                return { etag: sanitizeETag(stat.etag), data };
+            }
+            catch (e) {
+                if (e?.code === 'NoSuchKey') {
+                    return { etag: null, data: null };
+                }
+                throw e;
+            }
+        }
         try {
             const res = await this._signedRequest('GET', key, {
                 query: opts,
@@ -1035,6 +1161,28 @@ class S3mini {
      * @returns A promise that resolves to the Response object.
      */
     async getObjectRaw(key, wholeFile = true, rangeFrom = 0, rangeTo, opts = {}, ssecHeaders) {
+        if (this._bun && !ssecHeaders && !Object.keys(opts).length) {
+            const f = this._bun.file(key);
+            if (wholeFile) {
+                const buf = await f.arrayBuffer();
+                const stat = await f.stat();
+                return new Response(buf, {
+                    status: 200,
+                    headers: { 'content-length': String(stat.size), etag: stat.etag, 'content-type': stat.type },
+                });
+            }
+            const sliced = rangeTo === undefined ? f.slice(rangeFrom) : f.slice(rangeFrom, rangeTo);
+            const buf = await sliced.arrayBuffer();
+            const stat = await f.stat();
+            const endByte = rangeTo === undefined ? stat.size - 1 : rangeTo - 1;
+            return new Response(buf, {
+                status: 206,
+                headers: {
+                    'content-range': `bytes ${rangeFrom}-${endByte}/${stat.size}`,
+                    'content-length': String(buf.byteLength),
+                },
+            });
+        }
         let rangeHdr = {};
         if (!wholeFile) {
             rangeHdr =
@@ -1055,6 +1203,9 @@ class S3mini {
      */
     async getContentLength(key, ssecHeaders) {
         try {
+            if (this._bun && !ssecHeaders) {
+                return (await this._bun.file(key).stat()).size;
+            }
             const res = await this._signedRequest('HEAD', key, {
                 headers: ssecHeaders ? { ...ssecHeaders } : undefined,
             });
@@ -1076,6 +1227,9 @@ class S3mini {
      * @returns A promise that resolves to true if the object exists, false if not found, or null if ETag mismatch.
      */
     async objectExists(key, opts = {}) {
+        if (this._bun && !Object.keys(opts).length) {
+            return this._bun.file(key).exists();
+        }
         const res = await this._signedRequest('HEAD', key, {
             query: opts,
             tolerated: [200, 404, 412, 304],
@@ -1102,6 +1256,15 @@ class S3mini {
      * }
      */
     async getEtag(key, opts = {}, ssecHeaders) {
+        if (this._bun && !ssecHeaders && !Object.keys(opts).length) {
+            return this._bunRead(key, async (f) => {
+                const { etag } = await f.stat();
+                if (!etag) {
+                    throw new Error(`${ERROR_PREFIX}ETag not found in response headers`);
+                }
+                return sanitizeETag(etag);
+            });
+        }
         const res = await this._signedRequest('HEAD', key, {
             query: opts,
             tolerated: [200, 304, 404, 412],
@@ -1137,6 +1300,12 @@ class S3mini {
      * await s3.putObject('image.png', buffer, 'image/png');
      */
     async putObject(key, data, fileType = DEFAULT_STREAM_CONTENT_TYPE, ssecHeaders, additionalHeaders, contentLength) {
+        if (this._bun && !ssecHeaders && !additionalHeaders) {
+            const f = this._bun.file(key);
+            await f.write(data, { type: fileType });
+            const { etag } = await f.stat();
+            return new Response(null, { status: 200, headers: etag ? { etag } : {} });
+        }
         const size = contentLength ?? getByteSize(data);
         return this._signedRequest('PUT', key, {
             body: data,
@@ -1169,6 +1338,14 @@ class S3mini {
      * await s3.putAnyObject('image.png', buffer, 'image/png');
      */
     async putAnyObject(key, data, fileType = DEFAULT_STREAM_CONTENT_TYPE, ssecHeaders, additionalHeaders, contentLength) {
+        // Bun handles multipart automatically for large files
+        if (this._bun && !ssecHeaders && !additionalHeaders) {
+            this._checkKey(key);
+            const f = this._bun.file(key);
+            await f.write(data, { type: fileType });
+            const { etag } = await f.stat();
+            return this._createSuccessResponse(etag || '');
+        }
         const size = contentLength ?? getByteSize(data);
         // Single PUT for small files
         if (!Number.isNaN(size) && size <= this.minPartSize) {
@@ -1631,72 +1808,74 @@ class S3mini {
      * @returns A promise that resolves to true if the object was deleted successfully, false otherwise.
      */
     async deleteObject(key) {
+        if (this._bun) {
+            await this._bun.file(key).delete();
+            return true;
+        }
         const res = await this._signedRequest('DELETE', key, { tolerated: [200, 204] });
         return res.status === 200 || res.status === 204;
     }
     async _deleteObjectsProcess(keys) {
+        const out = await this._sendDeleteRequest(keys);
+        const resultMap = new Map(keys.map(k => [k, false]));
+        this._markDeletedKeys(out, resultMap);
+        this._logDeleteErrors(out, resultMap);
+        return keys.map(key => resultMap.get(key) || false);
+    }
+    async _sendDeleteRequest(keys) {
         const objectsXml = keys.map(key => `<Object><Key>${escapeXml(key)}</Key></Object>`).join('');
         const xmlBody = '<Delete>' + objectsXml + '</Delete>';
-        const query = { delete: '' };
         const sha256base64 = base64FromBuffer(await sha256(xmlBody));
-        const headers = {
-            [HEADER_CONTENT_TYPE]: XML_CONTENT_TYPE,
-            [HEADER_CONTENT_LENGTH]: getByteSize(xmlBody),
-            [HEADER_AMZ_CHECKSUM_SHA256]: sha256base64,
-        };
         const res = await this._signedRequest('POST', '', {
-            query,
+            query: { delete: '' },
             body: xmlBody,
-            headers,
+            headers: {
+                [HEADER_CONTENT_TYPE]: XML_CONTENT_TYPE,
+                [HEADER_CONTENT_LENGTH]: getByteSize(xmlBody),
+                [HEADER_AMZ_CHECKSUM_SHA256]: sha256base64,
+            },
             withQuery: true,
         });
         const parsed = parseXml(await res.text());
         if (!parsed || typeof parsed !== 'object') {
             throw new Error(`${ERROR_PREFIX}Failed to delete objects: ${JSON.stringify(parsed)}`);
         }
-        const out = (parsed.DeleteResult || parsed.deleteResult || parsed);
-        const resultMap = new Map();
-        for (const key of keys) {
-            resultMap.set(key, false);
-        }
+        return (parsed.DeleteResult || parsed.deleteResult || parsed);
+    }
+    _markDeletedKeys(out, resultMap) {
         const deleted = out.deleted || out.Deleted;
-        if (deleted) {
-            const deletedArray = Array.isArray(deleted) ? deleted : [deleted];
-            for (const item of deletedArray) {
-                if (item && typeof item === 'object') {
-                    const obj = item;
-                    // Check both key and Key
-                    const key = obj.key || obj.Key;
-                    if (key && typeof key === 'string') {
-                        resultMap.set(key, true);
-                    }
+        if (!deleted) {
+            return;
+        }
+        const items = Array.isArray(deleted) ? deleted : [deleted];
+        for (const item of items) {
+            if (item && typeof item === 'object') {
+                const key = item.key || item.Key;
+                if (key && typeof key === 'string') {
+                    resultMap.set(key, true);
                 }
             }
         }
-        // Handle errors (check both cases)
+    }
+    _logDeleteErrors(out, resultMap) {
         const errors = out.error || out.Error;
-        if (errors) {
-            const errorsArray = Array.isArray(errors) ? errors : [errors];
-            for (const item of errorsArray) {
-                if (item && typeof item === 'object') {
-                    const obj = item;
-                    // Check both cases for all properties
-                    const key = obj.key || obj.Key;
-                    const code = obj.code || obj.Code;
-                    const message = obj.message || obj.Message;
-                    if (key && typeof key === 'string') {
-                        resultMap.set(key, false);
-                        // Optionally log the error for debugging
-                        this._log('warn', `Failed to delete object: ${key}`, {
-                            code: code || 'Unknown',
-                            message: message || 'Unknown error',
-                        });
-                    }
+        if (!errors) {
+            return;
+        }
+        const items = Array.isArray(errors) ? errors : [errors];
+        for (const item of items) {
+            if (item && typeof item === 'object') {
+                const obj = item;
+                const key = obj.key || obj.Key;
+                if (key && typeof key === 'string') {
+                    resultMap.set(key, false);
+                    this._log('warn', `Failed to delete object: ${key}`, {
+                        code: obj.code || obj.Code || 'Unknown',
+                        message: obj.message || obj.Message || 'Unknown error',
+                    });
                 }
             }
         }
-        // Return boolean array in the same order as input keys
-        return keys.map(key => resultMap.get(key) || false);
     }
     /**
      * Deletes multiple objects from the bucket.
@@ -1789,27 +1968,34 @@ class S3mini {
      * @param {'GET' | 'PUT'} method - HTTP method ('GET' for download, 'PUT' for upload)
      * @param {string} key - The object key/path
      * @param {number} [expiresIn=3600] - URL expiration time in seconds (1–604800)
-     * @param {Record<string, string>} [queryParams={}] - Additional query parameters to sign
+     * @param {Record<string, string>} [queryParams={}] - Additional query parameters to include in the URL
+     * @param {Record<string, string>} [headers={}] - HTTP headers to sign. The consumer of the URL
+     *   MUST send these exact headers with matching values. The `host` header is always signed automatically.
      * @returns {Promise<string>} Pre-signed URL string
      * @throws {TypeError} If key is empty or expiresIn is out of range
      * @example
      * // Download URL valid for 1 hour
      * const url = await s3.getPresignedUrl('GET', 'photos/vacation.jpg');
      *
-     * // Upload URL valid for 5 minutes
-     * const url = await s3.getPresignedUrl('PUT', 'uploads/file.bin', 300);
+     * // Upload URL valid for 5 minutes with signed Content-Type
+     * const url = await s3.getPresignedUrl('PUT', 'uploads/file.bin', 300, {}, {
+     *   'Content-Type': 'application/octet-stream',
+     * });
      *
-     * // Client-side usage (no credentials needed)
-     * await fetch(url, { method: 'PUT', body: data });
+     * // Client-side usage (must include signed headers)
+     * await fetch(url, { method: 'PUT', body: data, headers: { 'Content-Type': 'application/octet-stream' } });
      */
-    async getPresignedUrl(method, key, expiresIn = 3600, queryParams = {}) {
+    async getPresignedUrl(method, key, expiresIn = 3600, queryParams = {}, headers = {}) {
         this._checkKey(key);
         if (!Number.isFinite(expiresIn) || expiresIn <= 0 || expiresIn > 604800) {
             throw new TypeError(`${ERROR_PREFIX}expiresIn must be between 1 and 604800 seconds`);
         }
-        return this._presign(method, uriResourceEscape(key), Math.floor(expiresIn), queryParams);
+        if (this._bun && !Object.keys(queryParams).length && !Object.keys(headers).length) {
+            return this._bun.presign(key, { method, expiresIn: Math.floor(expiresIn) });
+        }
+        return this._presign(method, uriResourceEscape(key), Math.floor(expiresIn), queryParams, headers);
     }
-    async _presign(method, keyPath, expiresIn, queryParams) {
+    async _presign(method, keyPath, expiresIn, queryParams, headers) {
         const url = new URL(this.endpoint);
         if (keyPath.length > 0) {
             url.pathname =
@@ -1822,7 +2008,16 @@ class S3mini {
         const shortDatetime = `${year}${month}${day}`;
         const fullDatetime = `${shortDatetime}T${String(d.getUTCHours()).padStart(2, '0')}${String(d.getUTCMinutes()).padStart(2, '0')}${String(d.getUTCSeconds()).padStart(2, '0')}Z`;
         const credentialScope = `${shortDatetime}/${this.region}/${S3_SERVICE}/${AWS_REQUEST_TYPE}`;
-        const signedHeaders = 'host';
+        const headerEntries = [['host', url.host]];
+        for (const [key, value] of Object.entries(headers)) {
+            const lowerKey = key.toLowerCase();
+            if (lowerKey !== 'host') {
+                headerEntries.push([lowerKey, String(value).trim()]);
+            }
+        }
+        headerEntries.sort(([a], [b]) => a.localeCompare(b));
+        const canonicalHeaders = headerEntries.map(([k, v]) => `${k}:${v}`).join('\n');
+        const signedHeaders = headerEntries.map(([k]) => k).join(';');
         const allQueryParams = {
             ...queryParams,
             'X-Amz-Algorithm': AWS_ALGORITHM,
@@ -1832,7 +2027,7 @@ class S3mini {
             'X-Amz-SignedHeaders': signedHeaders,
         };
         const canonicalQueryString = this._buildCanonicalQueryString(allQueryParams);
-        const canonicalRequest = `${method}\n${url.pathname}\n${canonicalQueryString}\nhost:${url.host}\n\n${signedHeaders}\n${UNSIGNED_PAYLOAD}`;
+        const canonicalRequest = `${method}\n${url.pathname}\n${canonicalQueryString}\n${canonicalHeaders}\n\n${signedHeaders}\n${UNSIGNED_PAYLOAD}`;
         const stringToSign = `${AWS_ALGORITHM}\n${fullDatetime}\n${credentialScope}\n${hexFromBuffer(await sha256(canonicalRequest))}`;
         if (shortDatetime !== this.signingKeyDate || !this.signingKey) {
             this.signingKeyDate = shortDatetime;