@gallop.software/studio 0.1.106 → 0.1.107

package/dist/handlers/index.mjs

@@ -150,7 +150,7 @@ async function processImage(buffer, imageKey) {
 // src/handlers/utils/cdn.ts
 import { promises as fs3 } from "fs";
 import path4 from "path";
-import { S3Client, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
+import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand } from "@aws-sdk/client-s3";
 function getR2Client() {
   const accountId = process.env.CLOUDFLARE_R2_ACCOUNT_ID;
   const accessKeyId = process.env.CLOUDFLARE_R2_ACCESS_KEY_ID;
@@ -210,6 +210,56 @@ async function deleteLocalThumbnails(imageKey) {
     }
   }
 }
+async function downloadFromRemoteUrl(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download from ${url}: ${response.status}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+}
+async function uploadOriginalToCdn(imageKey) {
+  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
+  if (!bucketName) throw new Error("R2 bucket not configured");
+  const r2 = getR2Client();
+  const localPath = path4.join(process.cwd(), "public", imageKey);
+  const fileBuffer = await fs3.readFile(localPath);
+  await r2.send(
+    new PutObjectCommand({
+      Bucket: bucketName,
+      Key: imageKey.replace(/^\//, ""),
+      Body: fileBuffer,
+      ContentType: getContentType(imageKey)
+    })
+  );
+}
+async function deleteFromCdn(imageKey, hasThumbnails) {
+  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
+  if (!bucketName) throw new Error("R2 bucket not configured");
+  const r2 = getR2Client();
+  try {
+    await r2.send(
+      new DeleteObjectCommand({
+        Bucket: bucketName,
+        Key: imageKey.replace(/^\//, "")
+      })
+    );
+  } catch {
+  }
+  if (hasThumbnails) {
+    for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+      try {
+        await r2.send(
+          new DeleteObjectCommand({
+            Bucket: bucketName,
+            Key: thumbPath.replace(/^\//, "")
+          })
+        );
+      } catch {
+      }
+    }
+  }
+}
 
 // src/handlers/list.ts
 async function handleList(request) {
@@ -744,49 +794,103 @@ async function handleMove(request) {
     if (!absoluteDestination.startsWith(path6.join(process.cwd(), "public"))) {
       return NextResponse2.json({ error: "Invalid destination" }, { status: 400 });
     }
-    try {
-      const destStats = await fs5.stat(absoluteDestination);
-      if (!destStats.isDirectory()) {
-        return NextResponse2.json({ error: "Destination is not a folder" }, { status: 400 });
-      }
-    } catch {
-      return NextResponse2.json({ error: "Destination folder not found" }, { status: 404 });
-    }
+    await fs5.mkdir(absoluteDestination, { recursive: true });
     const moved = [];
     const errors = [];
     const meta = await loadMeta();
+    const cdnUrls = getCdnUrls(meta);
+    const r2PublicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/$/, "") || "";
     let metaChanged = false;
     for (const itemPath of paths) {
       const safePath = itemPath.replace(/\.\./g, "");
-      const absolutePath = path6.join(process.cwd(), safePath);
       const itemName = path6.basename(safePath);
       const newAbsolutePath = path6.join(absoluteDestination, itemName);
-      if (absoluteDestination.startsWith(absolutePath + path6.sep)) {
-        errors.push(`Cannot move ${itemName} into itself`);
-        continue;
-      }
-      try {
-        await fs5.access(absolutePath);
-      } catch {
-        errors.push(`${itemName} not found`);
-        continue;
-      }
-      try {
-        await fs5.access(newAbsolutePath);
+      const oldRelativePath = safePath.replace(/^public\//, "");
+      const newRelativePath = path6.join(safeDestination.replace(/^public\//, ""), itemName);
+      const oldKey = "/" + oldRelativePath;
+      const newKey = "/" + newRelativePath;
+      if (meta[newKey]) {
         errors.push(`${itemName} already exists in destination`);
         continue;
-      } catch {
       }
+      const entry = meta[oldKey];
+      const isImage = isImageFile(itemName);
+      const isInCloud = entry?.c !== void 0;
+      const fileCdnUrl = isInCloud && entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
+      const isRemote = isInCloud && (!r2PublicUrl || fileCdnUrl !== r2PublicUrl);
+      const isPushedToR2 = isInCloud && r2PublicUrl && fileCdnUrl === r2PublicUrl;
+      const hasProcessedThumbnails = entry?.p === 1;
       try {
-        await fs5.rename(absolutePath, newAbsolutePath);
-        const stats = await fs5.stat(newAbsolutePath);
-        if (stats.isFile() && isImageFile(itemName)) {
-          const oldRelativePath = safePath.replace(/^public\//, "");
-          const newRelativePath = path6.join(safeDestination.replace(/^public\//, ""), itemName);
-          const oldKey = "/" + oldRelativePath;
-          const newKey = "/" + newRelativePath;
-          if (meta[oldKey]) {
-            const entry = meta[oldKey];
+        if (isRemote && isImage) {
+          const remoteUrl = `${fileCdnUrl}${oldKey}`;
+          const buffer = await downloadFromRemoteUrl(remoteUrl);
+          await fs5.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
+          await fs5.writeFile(newAbsolutePath, buffer);
+          const newEntry = {
+            w: entry?.w,
+            h: entry?.h,
+            b: entry?.b
+            // Don't copy p since remote images don't have local thumbnails
+            // Don't copy c since it's now local
+          };
+          delete meta[oldKey];
+          meta[newKey] = newEntry;
+          metaChanged = true;
+          moved.push(itemPath);
+        } else if (isPushedToR2 && isImage) {
+          const buffer = await downloadFromCdn(oldKey);
+          await fs5.mkdir(path6.dirname(newAbsolutePath), { recursive: true });
+          await fs5.writeFile(newAbsolutePath, buffer);
+          const newEntry = {
+            w: entry?.w,
+            h: entry?.h,
+            b: entry?.b
+          };
+          if (hasProcessedThumbnails) {
+            const processedEntry = await processImage(buffer, newKey);
+            newEntry.w = processedEntry.w;
+            newEntry.h = processedEntry.h;
+            newEntry.b = processedEntry.b;
+            newEntry.p = 1;
+          }
+          await uploadOriginalToCdn(newKey);
+          if (hasProcessedThumbnails) {
+            await uploadToCdn(newKey);
+          }
+          await deleteFromCdn(oldKey, hasProcessedThumbnails);
+          try {
+            await fs5.unlink(newAbsolutePath);
+          } catch {
+          }
+          if (hasProcessedThumbnails) {
+            await deleteLocalThumbnails(newKey);
+          }
+          newEntry.c = entry?.c;
+          delete meta[oldKey];
+          meta[newKey] = newEntry;
+          metaChanged = true;
+          moved.push(itemPath);
+        } else {
+          const absolutePath = path6.join(process.cwd(), safePath);
+          if (absoluteDestination.startsWith(absolutePath + path6.sep)) {
+            errors.push(`Cannot move ${itemName} into itself`);
+            continue;
+          }
+          try {
+            await fs5.access(absolutePath);
+          } catch {
+            errors.push(`${itemName} not found`);
+            continue;
+          }
+          try {
+            await fs5.access(newAbsolutePath);
+            errors.push(`${itemName} already exists in destination`);
+            continue;
+          } catch {
+          }
+          await fs5.rename(absolutePath, newAbsolutePath);
+          const stats = await fs5.stat(newAbsolutePath);
+          if (stats.isFile() && isImage && entry) {
             const oldThumbPaths = getAllThumbnailPaths(oldKey);
             const newThumbPaths = getAllThumbnailPaths(newKey);
             for (let i = 0; i < oldThumbPaths.length; i++) {
@@ -801,10 +905,22 @@ async function handleMove(request) {
             delete meta[oldKey];
             meta[newKey] = entry;
             metaChanged = true;
+          } 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];
+                metaChanged = true;
+              }
+            }
           }
+          moved.push(itemPath);
         }
-        moved.push(itemPath);
-      } catch {
+      } catch (err) {
+        console.error(`Failed to move ${itemName}:`, err);
         errors.push(`Failed to move ${itemName}`);
       }
     }