@gallop.software/studio 2.3.43 → 2.3.45

package/dist/server/index.js

@@ -1758,7 +1758,21 @@ async function handleMoveStream(request) {
               }
               return count;
             };
-            totalFiles += await countFilesRecursive(absolutePath);
+            const localFileCount = await countFilesRecursive(absolutePath);
+            const folderPrefix = oldKey + "/";
+            let cloudOnlyCount = 0;
+            for (const metaKey of Object.keys(meta)) {
+              if (metaKey.startsWith(folderPrefix)) {
+                const relPath = metaKey.slice(folderPrefix.length);
+                const localPath = path6.join(absolutePath, relPath);
+                try {
+                  await fs6.access(localPath);
+                } catch {
+                  cloudOnlyCount++;
+                }
+              }
+            }
+            totalFiles += localFileCount + cloudOnlyCount;
             expandedItems.push({ itemPath, safePath, itemName, oldKey, newKey, newAbsolutePath, isVirtualFolder: false });
           } else if (!hasLocalItem) {
             const folderPrefix = oldKey + "/";
@@ -1979,74 +1993,187 @@ async function handleMoveStream(request) {
                 continue;
               } catch {
               }
-              await fs6.rename(absolutePath, newAbsolutePath);
-              const stats = await fs6.stat(newAbsolutePath);
-              if (stats.isFile() && isImage && entry) {
-                const oldThumbPaths = getAllThumbnailPaths(oldKey);
-                const newThumbPaths = getAllThumbnailPaths(newKey);
-                for (let j = 0; j < oldThumbPaths.length; j++) {
-                  const oldThumbPath = getPublicPath(oldThumbPaths[j]);
-                  const newThumbPath = getPublicPath(newThumbPaths[j]);
-                  try {
-                    await fs6.access(oldThumbPath);
-                    sourceFolders.add(path6.dirname(oldThumbPath));
-                    await fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
-                    await fs6.rename(oldThumbPath, newThumbPath);
-                  } catch {
+              const stats = await fs6.stat(absolutePath);
+              if (stats.isFile()) {
+                await fs6.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
+                await fs6.rename(absolutePath, newAbsolutePath);
+                if (isImage && entry) {
+                  const oldThumbPaths = getAllThumbnailPaths(oldKey);
+                  const newThumbPaths = getAllThumbnailPaths(newKey);
+                  for (let j = 0; j < oldThumbPaths.length; j++) {
+                    const oldThumbPath = getPublicPath(oldThumbPaths[j]);
+                    const newThumbPath = getPublicPath(newThumbPaths[j]);
+                    try {
+                      await fs6.access(oldThumbPath);
+                      sourceFolders.add(path6.dirname(oldThumbPath));
+                      await fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
+                      await fs6.rename(oldThumbPath, newThumbPath);
+                    } catch {
+                    }
+                  }
+                  const fileIsInCloud = entry.c !== void 0;
+                  const fileCdnUrl2 = fileIsInCloud ? cdnUrls[entry.c] : void 0;
+                  const fileIsInR2 = fileIsInCloud && fileCdnUrl2 === r2PublicUrl;
+                  const fileHasThumbs = isProcessed(entry);
+                  if (fileIsInR2) {
+                    await deleteFromCdn(oldKey, fileHasThumbs);
+                    await uploadOriginalToCdn(newKey);
+                    if (fileHasThumbs) {
+                      await uploadToCdn(newKey);
+                    }
                   }
+                  delete meta[oldKey];
+                  meta[newKey] = entry;
                 }
-                delete meta[oldKey];
-                meta[newKey] = entry;
+                processedFiles++;
+                sendEvent({
+                  type: "progress",
+                  current: processedFiles,
+                  total: totalFiles,
+                  moved: moved.length,
+                  percent: Math.round(processedFiles / totalFiles * 100),
+                  currentFile: itemName
+                });
+                moved.push(itemPath);
               } else if (stats.isDirectory()) {
                 const oldPrefix = oldKey + "/";
                 const newPrefix = newKey + "/";
-                for (const key of Object.keys(meta)) {
-                  if (key.startsWith(oldPrefix)) {
-                    const newMetaKey = newPrefix + key.slice(oldPrefix.length);
-                    meta[newMetaKey] = meta[key];
-                    delete meta[key];
-                  }
-                }
-                const oldThumbRelPath = oldKey.slice(1);
-                const newThumbRelPath = newKey.slice(1);
-                const imagesDir = getPublicPath("images");
-                const oldThumbFolder = path6.join(imagesDir, oldThumbRelPath);
-                const newThumbFolder = path6.join(imagesDir, newThumbRelPath);
-                try {
-                  await fs6.access(oldThumbFolder);
-                  sourceFolders.add(oldThumbFolder);
-                  await fs6.mkdir(path6.dirname(newThumbFolder), { recursive: true });
-                  await fs6.rename(oldThumbFolder, newThumbFolder);
-                } catch {
-                }
-              }
-              moved.push(itemPath);
-              if (stats.isDirectory()) {
-                const countFilesInDir = async (dir) => {
-                  let count = 0;
+                const localFiles = [];
+                const collectLocalFiles = async (dir, relativeDir) => {
                   const entries = await fs6.readdir(dir, { withFileTypes: true });
-                  for (const entry2 of entries) {
-                    if (entry2.isDirectory()) {
-                      count += await countFilesInDir(path6.join(dir, entry2.name));
+                  for (const dirEntry of entries) {
+                    const entryRelPath = relativeDir ? `${relativeDir}/${dirEntry.name}` : dirEntry.name;
+                    if (dirEntry.isDirectory()) {
+                      await collectLocalFiles(path6.join(dir, dirEntry.name), entryRelPath);
                     } else {
-                      count++;
+                      localFiles.push({ relativePath: entryRelPath, isImage: isImageFile(dirEntry.name) });
                     }
                   }
-                  return count;
                 };
-                const filesInDir = await countFilesInDir(newAbsolutePath);
-                processedFiles += filesInDir;
-              } else {
-                processedFiles++;
+                await collectLocalFiles(absolutePath, "");
+                const cloudOnlyFiles = [];
+                for (const [metaKey, metaEntry] of Object.entries(meta)) {
+                  if (metaKey.startsWith(oldPrefix) && metaEntry && typeof metaEntry === "object") {
+                    const relPath = metaKey.slice(oldPrefix.length);
+                    const localPath = path6.join(absolutePath, relPath);
+                    try {
+                      await fs6.access(localPath);
+                    } catch {
+                      cloudOnlyFiles.push({
+                        oldKey: metaKey,
+                        newKey: newPrefix + relPath,
+                        entry: metaEntry
+                      });
+                    }
+                  }
+                }
+                for (const localFile of localFiles) {
+                  const fileOldPath = path6.join(absolutePath, localFile.relativePath);
+                  const fileNewPath = path6.join(newAbsolutePath, localFile.relativePath);
+                  const fileOldKey = oldPrefix + localFile.relativePath;
+                  const fileNewKey = newPrefix + localFile.relativePath;
+                  const fileEntry = meta[fileOldKey];
+                  sourceFolders.add(path6.dirname(fileOldPath));
+                  await fs6.mkdir(path6.dirname(fileNewPath), { recursive: true });
+                  await fs6.rename(fileOldPath, fileNewPath);
+                  if (localFile.isImage && fileEntry) {
+                    const oldThumbPaths = getAllThumbnailPaths(fileOldKey);
+                    const newThumbPaths = getAllThumbnailPaths(fileNewKey);
+                    for (let t = 0; t < oldThumbPaths.length; t++) {
+                      const oldThumbPath = getPublicPath(oldThumbPaths[t]);
+                      const newThumbPath = getPublicPath(newThumbPaths[t]);
+                      try {
+                        await fs6.access(oldThumbPath);
+                        sourceFolders.add(path6.dirname(oldThumbPath));
+                        await fs6.mkdir(path6.dirname(newThumbPath), { recursive: true });
+                        await fs6.rename(oldThumbPath, newThumbPath);
+                      } catch {
+                      }
+                    }
+                    const fileIsInCloud = fileEntry.c !== void 0;
+                    const fileCdnUrl2 = fileIsInCloud ? cdnUrls[fileEntry.c] : void 0;
+                    const fileIsInR2 = fileIsInCloud && fileCdnUrl2 === r2PublicUrl;
+                    const fileHasThumbs = isProcessed(fileEntry);
+                    if (fileIsInR2) {
+                      await deleteFromCdn(fileOldKey, fileHasThumbs);
+                      await uploadOriginalToCdn(fileNewKey);
+                      if (fileHasThumbs) {
+                        await uploadToCdn(fileNewKey);
+                      }
+                    }
+                    delete meta[fileOldKey];
+                    meta[fileNewKey] = fileEntry;
+                  }
+                  processedFiles++;
+                  sendEvent({
+                    type: "progress",
+                    current: processedFiles,
+                    total: totalFiles,
+                    moved: moved.length,
+                    percent: Math.round(processedFiles / totalFiles * 100),
+                    currentFile: path6.basename(localFile.relativePath)
+                  });
+                }
+                for (const cloudFile of cloudOnlyFiles) {
+                  const cloudEntry = cloudFile.entry;
+                  const cloudIsInCloud = cloudEntry.c !== void 0;
+                  const cloudCdnUrl = cloudIsInCloud ? cdnUrls[cloudEntry.c] : void 0;
+                  const cloudIsInR2 = cloudIsInCloud && cloudCdnUrl === r2PublicUrl;
+                  const cloudHasThumbs = isProcessed(cloudEntry);
+                  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));
+                    } catch (err) {
+                      console.error(`Failed to move cloud file ${cloudFile.oldKey}:`, err);
+                    }
+                  }
+                  delete meta[cloudFile.oldKey];
+                  meta[cloudFile.newKey] = cloudEntry;
+                  processedFiles++;
+                  sendEvent({
+                    type: "progress",
+                    current: processedFiles,
+                    total: totalFiles,
+                    moved: moved.length,
+                    percent: Math.round(processedFiles / totalFiles * 100),
+                    currentFile: path6.basename(cloudFile.newKey)
+                  });
+                }
+                sourceFolders.add(absolutePath);
+                const oldThumbRelPath = oldKey.slice(1);
+                const oldThumbFolder = path6.join(getPublicPath("images"), oldThumbRelPath);
+                sourceFolders.add(oldThumbFolder);
+                moved.push(itemPath);
               }
-              sendEvent({
-                type: "progress",
-                current: processedFiles,
-                total: totalFiles,
-                moved: moved.length,
-                percent: Math.round(processedFiles / totalFiles * 100),
-                currentFile: itemName
-              });
             }
           } catch (err) {
             console.error(`Failed to move ${itemName}:`, err);