@gallop.software/studio 2.3.45 → 2.3.47

package/dist/server/index.js

@@ -208,7 +208,7 @@ async function processImage(buffer, imageKey) {
 
 // src/handlers/utils/cdn.ts
 import { promises as fs3 } from "fs";
-import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand } from "@aws-sdk/client-s3";
+import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand, CopyObjectCommand } from "@aws-sdk/client-s3";
 
 // src/types.ts
 function getThumbnailPath(originalPath, size) {
@@ -400,6 +400,34 @@ async function deleteOriginalFromCdn(imageKey) {
   } catch {
   }
 }
+async function copyInCdn(oldKey, newKey) {
+  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
+  if (!bucketName) throw new Error("R2 bucket not configured");
+  const r2 = getR2Client();
+  const oldKeyClean = oldKey.replace(/^\//, "");
+  const newKeyClean = newKey.replace(/^\//, "");
+  await r2.send(
+    new CopyObjectCommand({
+      Bucket: bucketName,
+      CopySource: `${bucketName}/${oldKeyClean}`,
+      Key: newKeyClean
+    })
+  );
+}
+async function moveInCdn(oldKey, newKey, hasThumbnails) {
+  await copyInCdn(oldKey, newKey);
+  if (hasThumbnails) {
+    const oldThumbPaths = getAllThumbnailPaths(oldKey);
+    const newThumbPaths = getAllThumbnailPaths(newKey);
+    for (let i = 0; i < oldThumbPaths.length; i++) {
+      try {
+        await copyInCdn(oldThumbPaths[i], newThumbPaths[i]);
+      } catch {
+      }
+    }
+  }
+  await deleteFromCdn(oldKey, hasThumbnails);
+}
 
 // src/handlers/utils/response.ts
 function jsonResponse(data, init) {
@@ -1808,43 +1836,20 @@ async function handleMoveStream(request) {
               const itemCdnUrl = isItemInCloud ? cdnUrls[itemEntry.c] : void 0;
               const isItemInR2 = isItemInCloud && itemCdnUrl === r2PublicUrl;
               const itemHasThumbnails = isProcessed(itemEntry);
+              let vItemMoved = false;
               if (isItemInR2) {
                 try {
-                  const itemLocalPath = getPublicPath(vItem.newKey);
-                  const buffer = await downloadFromCdn(vItem.oldKey);
-                  await fs6.mkdir(path6.dirname(itemLocalPath), { recursive: true });
-                  await fs6.writeFile(itemLocalPath, buffer);
-                  if (itemHasThumbnails) {
-                    const oldThumbPaths = getAllThumbnailPaths(vItem.oldKey);
-                    const newThumbPaths = getAllThumbnailPaths(vItem.newKey);
-                    for (let t = 0; t < oldThumbPaths.length; t++) {
-                      try {
-                        const thumbBuffer = await downloadFromCdn(oldThumbPaths[t]);
-                        const newThumbLocalPath = getPublicPath(newThumbPaths[t]);
-                        await fs6.mkdir(path6.dirname(newThumbLocalPath), { recursive: true });
-                        await fs6.writeFile(newThumbLocalPath, thumbBuffer);
-                      } catch {
-                      }
-                    }
-                  }
-                  await deleteFromCdn(vItem.oldKey, itemHasThumbnails);
-                  await uploadOriginalToCdn(vItem.newKey);
-                  if (itemHasThumbnails) {
-                    await uploadToCdn(vItem.newKey);
-                  }
-                  try {
-                    await fs6.unlink(itemLocalPath);
-                  } catch {
-                  }
-                  if (itemHasThumbnails) {
-                    await deleteLocalThumbnails(vItem.newKey);
-                  }
+                  await moveInCdn(vItem.oldKey, vItem.newKey, itemHasThumbnails);
+                  vItemMoved = true;
                 } catch (err) {
                   console.error(`Failed to move cloud item ${vItem.oldKey}:`, err);
+                  delete meta[vItem.oldKey];
                 }
               }
-              delete meta[vItem.oldKey];
-              meta[vItem.newKey] = itemEntry;
+              if (vItemMoved) {
+                delete meta[vItem.oldKey];
+                meta[vItem.newKey] = itemEntry;
+              }
               processedFiles++;
               sendEvent({
                 type: "progress",
@@ -1907,37 +1912,11 @@ async function handleMoveStream(request) {
                 currentFile: itemName
               });
             } else if (isPushedToR2 && isImage) {
-              const buffer = await downloadFromCdn(oldKey);
-              await fs6.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
-              await fs6.writeFile(newAbsolutePath, buffer);
-              let newEntry = {
-                o: entry?.o,
-                b: entry?.b
-              };
-              if (hasProcessedThumbnails) {
-                const processedEntry = await processImage(buffer, newKey);
-                newEntry = { ...newEntry, ...processedEntry };
-              }
-              await uploadOriginalToCdn(newKey);
-              if (hasProcessedThumbnails) {
-                await uploadToCdn(newKey);
-              }
-              await deleteFromCdn(oldKey, hasProcessedThumbnails);
-              try {
-                await fs6.unlink(newAbsolutePath);
-              } catch {
-              }
-              if (hasProcessedThumbnails) {
-                await deleteLocalThumbnails(newKey);
-              }
-              await deleteEmptyFolders(path6.dirname(newAbsolutePath));
-              if (hasProcessedThumbnails) {
-                const newThumbRelPath = newKey.slice(1);
-                await deleteEmptyFolders(path6.join(getPublicPath("images"), newThumbRelPath));
-              }
-              newEntry.c = entry?.c;
+              await moveInCdn(oldKey, newKey, hasProcessedThumbnails);
               delete meta[oldKey];
-              meta[newKey] = newEntry;
+              if (entry) {
+                meta[newKey] = entry;
+              }
               moved.push(itemPath);
               processedFiles++;
               sendEvent({
@@ -2095,11 +2074,7 @@ async function handleMoveStream(request) {
                     const fileIsInR2 = fileIsInCloud && fileCdnUrl2 === r2PublicUrl;
                     const fileHasThumbs = isProcessed(fileEntry);
                     if (fileIsInR2) {
-                      await deleteFromCdn(fileOldKey, fileHasThumbs);
-                      await uploadOriginalToCdn(fileNewKey);
-                      if (fileHasThumbs) {
-                        await uploadToCdn(fileNewKey);
-                      }
+                      await moveInCdn(fileOldKey, fileNewKey, fileHasThumbs);
                     }
                     delete meta[fileOldKey];
                     meta[fileNewKey] = fileEntry;
@@ -2120,44 +2095,20 @@ async function handleMoveStream(request) {
                   const cloudCdnUrl = cloudIsInCloud ? cdnUrls[cloudEntry.c] : void 0;
                   const cloudIsInR2 = cloudIsInCloud && cloudCdnUrl === r2PublicUrl;
                   const cloudHasThumbs = isProcessed(cloudEntry);
+                  let cloudFileMoved = false;
                   if (cloudIsInR2) {
                     try {
-                      const cloudLocalPath = getPublicPath(cloudFile.newKey);
-                      const buffer = await downloadFromCdn(cloudFile.oldKey);
-                      await fs6.mkdir(path6.dirname(cloudLocalPath), { recursive: true });
-                      await fs6.writeFile(cloudLocalPath, buffer);
-                      if (cloudHasThumbs) {
-                        const oldThumbPaths = getAllThumbnailPaths(cloudFile.oldKey);
-                        const newThumbPaths = getAllThumbnailPaths(cloudFile.newKey);
-                        for (let t = 0; t < oldThumbPaths.length; t++) {
-                          try {
-                            const thumbBuffer = await downloadFromCdn(oldThumbPaths[t]);
-                            const newThumbLocalPath = getPublicPath(newThumbPaths[t]);
-                            await fs6.mkdir(path6.dirname(newThumbLocalPath), { recursive: true });
-                            await fs6.writeFile(newThumbLocalPath, thumbBuffer);
-                          } catch {
-                          }
-                        }
-                      }
-                      await deleteFromCdn(cloudFile.oldKey, cloudHasThumbs);
-                      await uploadOriginalToCdn(cloudFile.newKey);
-                      if (cloudHasThumbs) {
-                        await uploadToCdn(cloudFile.newKey);
-                      }
-                      try {
-                        await fs6.unlink(cloudLocalPath);
-                      } catch {
-                      }
-                      if (cloudHasThumbs) {
-                        await deleteLocalThumbnails(cloudFile.newKey);
-                      }
-                      await deleteEmptyFolders(path6.dirname(cloudLocalPath));
+                      await moveInCdn(cloudFile.oldKey, cloudFile.newKey, cloudHasThumbs);
+                      cloudFileMoved = true;
                     } catch (err) {
                       console.error(`Failed to move cloud file ${cloudFile.oldKey}:`, err);
+                      delete meta[cloudFile.oldKey];
                     }
                   }
-                  delete meta[cloudFile.oldKey];
-                  meta[cloudFile.newKey] = cloudEntry;
+                  if (cloudFileMoved) {
+                    delete meta[cloudFile.oldKey];
+                    meta[cloudFile.newKey] = cloudEntry;
+                  }
                   processedFiles++;
                   sendEvent({
                     type: "progress",