npm package diff

Package: @forge/bridge

Versions: 5.8.0-next.12-experimental-f85d28a - 5.8.0-next.13

File: package/out/object-store/upload.js

Index: package/out/object-store/upload.js
===================================================================
--- package/out/object-store/upload.js
+++ package/out/object-store/upload.js
@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.upload = void 0;
+exports.upload = exports.createUploadPromises = void 0;
 const invoke_1 = require("../invoke");
 const errors_1 = require("../errors");
 const base64ToBlob = (base64, mimeType) => {
     const byteCharacters = atob(base64);
@@ -24,9 +24,9 @@
         checksum,
         checksumType
     };
 };
-const upload = async ({ functionKey, objects }) => {
+const createUploadPromises = async ({ functionKey, objects }) => {
     if (!functionKey || functionKey.length === 0) {
         throw new errors_1.BridgeAPIError('functionKey is required to filter and generate presigned URLs');
     }
     if (!Array.isArray(objects) || objects.length === 0) {
@@ -54,47 +54,71 @@
     if (!presignedURLsToObjectMetadata || typeof presignedURLsToObjectMetadata !== 'object') {
         throw new errors_1.BridgeAPIError('Invalid response from functionKey');
     }
     const checksumToBlobMap = new Map();
+    const checksumToIndexMap = new Map();
     blobs.forEach((blob, index) => {
         const metadata = allObjectMetadata[index];
         checksumToBlobMap.set(metadata.checksum, blob);
+        checksumToIndexMap.set(metadata.checksum, index);
     });
-    const uploadPromises = Object.entries(presignedURLsToObjectMetadata).map(async ([presignedUrl, metadata]) => {
-        const { key, length, checksum } = metadata;
+    const uploadPromises = Object.entries(presignedURLsToObjectMetadata).map(([presignedUrl, metadata]) => {
+        const { key, checksum } = metadata;
         const object = checksumToBlobMap.get(checksum);
-        if (!object) {
+        const index = checksumToIndexMap.get(checksum);
+        if (index === undefined) {
             return {
-                success: false,
-                key: key,
-                error: `Blob not found for checksum ${checksum}`
+                promise: Promise.resolve({
+                    success: false,
+                    key: key,
+                    error: `Index not found for checksum ${checksum}`
+                }),
+                index: -1
             };
         }
-        try {
-            const response = await fetch(presignedUrl, {
-                method: 'PUT',
-                body: object,
-                headers: {
-                    'Content-Type': object.type || 'application/octet-stream',
-                    'Content-Length': length.toString()
-                }
-            });
+        if (!object) {
             return {
-                success: response.ok,
-                key: key,
-                status: response.status,
-                error: response.ok ? undefined : `Upload failed with status ${response.status}`
+                promise: Promise.resolve({
+                    success: false,
+                    key: key,
+                    error: `Blob not found for checksum ${checksum}`
+                }),
+                index
             };
         }
-        catch (error) {
-            return {
-                success: false,
-                key: key,
-                status: 503,
-                error: error instanceof Error ? error.message : 'Upload failed'
-            };
-        }
+        const uploadPromise = (async () => {
+            try {
+                const response = await fetch(presignedUrl, {
+                    method: 'PUT',
+                    body: object,
+                    headers: {
+                        'Content-Type': object.type || 'application/octet-stream',
+                        'Content-Length': object.size.toString()
+                    }
+                });
+                return {
+                    success: response.ok,
+                    key: key,
+                    status: response.status,
+                    error: response.ok ? undefined : `Upload failed with status ${response.status}`
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    key: key,
+                    status: 503,
+                    error: error instanceof Error ? error.message : 'Upload failed'
+                };
+            }
+        })();
+        return { promise: uploadPromise, index, objectType: object.type, objectSize: object.size };
     });
-    const results = await Promise.all(uploadPromises);
+    return uploadPromises;
+};
+exports.createUploadPromises = createUploadPromises;
+const upload = async ({ functionKey, objects }) => {
+    const uploadPromises = await (0, exports.createUploadPromises)({ functionKey, objects });
+    const results = await Promise.all(uploadPromises.map((item) => item.promise));
     return results;
 };
 exports.upload = upload;