@gallop.software/studio 1.3.1 → 1.3.2

package/dist/handlers/index.js

@@ -1393,9 +1393,143 @@ async function handleReprocess(request) {
     return _server.NextResponse.json({ error: "Failed to reprocess images" }, { status: 500 });
   }
 }
-async function handleProcessAllStream() {
+async function handleReprocessStream(request) {
   const publicUrl = _optionalChain([process, 'access', _38 => _38.env, 'access', _39 => _39.CLOUDFLARE_R2_PUBLIC_URL, 'optionalAccess', _40 => _40.replace, 'call', _41 => _41(/\/\s*$/, "")]);
   const encoder = new TextEncoder();
+  let imageKeys;
+  try {
+    const body = await request.json();
+    imageKeys = body.imageKeys;
+    if (!imageKeys || !Array.isArray(imageKeys) || imageKeys.length === 0) {
+      return _server.NextResponse.json({ error: "No image keys provided" }, { status: 400 });
+    }
+  } catch (e29) {
+    return _server.NextResponse.json({ error: "Invalid request body" }, { status: 400 });
+  }
+  const stream = new ReadableStream({
+    async start(controller) {
+      const sendEvent = (data) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+      };
+      try {
+        const meta = await loadMeta();
+        const cdnUrls = getCdnUrls(meta);
+        const processed = [];
+        const errors = [];
+        const urlsToPurge = [];
+        const total = imageKeys.length;
+        sendEvent({ type: "start", total });
+        for (let i = 0; i < imageKeys.length; i++) {
+          let imageKey = imageKeys[i];
+          if (!imageKey.startsWith("/")) {
+            imageKey = `/${imageKey}`;
+          }
+          sendEvent({
+            type: "progress",
+            current: i + 1,
+            total,
+            percent: Math.round((i + 1) / total * 100),
+            message: `Processing ${imageKey.slice(1)}...`
+          });
+          try {
+            let buffer;
+            const entry = getMetaEntry(meta, imageKey);
+            const existingCdnIndex = _optionalChain([entry, 'optionalAccess', _42 => _42.c]);
+            const existingCdnUrl = existingCdnIndex !== void 0 ? cdnUrls[existingCdnIndex] : void 0;
+            const isInOurR2 = existingCdnUrl === publicUrl;
+            const isRemote = existingCdnIndex !== void 0 && !isInOurR2;
+            const originalPath = _path2.default.join(process.cwd(), "public", imageKey);
+            try {
+              buffer = await _fs.promises.readFile(originalPath);
+            } catch (e30) {
+              if (isInOurR2) {
+                buffer = await downloadFromCdn(imageKey);
+                const dir = _path2.default.dirname(originalPath);
+                await _fs.promises.mkdir(dir, { recursive: true });
+                await _fs.promises.writeFile(originalPath, buffer);
+              } else if (isRemote && existingCdnUrl) {
+                const remoteUrl = `${existingCdnUrl}${imageKey}`;
+                buffer = await downloadFromRemoteUrl(remoteUrl);
+                const dir = _path2.default.dirname(originalPath);
+                await _fs.promises.mkdir(dir, { recursive: true });
+                await _fs.promises.writeFile(originalPath, buffer);
+              } else {
+                throw new Error(`File not found: ${imageKey}`);
+              }
+            }
+            const ext = _path2.default.extname(imageKey).toLowerCase();
+            const isSvg = ext === ".svg";
+            if (isSvg) {
+              const imageDir = _path2.default.dirname(imageKey.slice(1));
+              const imagesPath = _path2.default.join(process.cwd(), "public", "images", imageDir === "." ? "" : imageDir);
+              await _fs.promises.mkdir(imagesPath, { recursive: true });
+              const fileName = _path2.default.basename(imageKey);
+              const destPath = _path2.default.join(imagesPath, fileName);
+              await _fs.promises.writeFile(destPath, buffer);
+              meta[imageKey] = {
+                ...entry,
+                o: { w: 0, h: 0 },
+                b: "",
+                f: { w: 0, h: 0 }
+              };
+              if (isRemote) {
+                delete meta[imageKey].c;
+              }
+            } else {
+              const updatedEntry = await processImage(buffer, imageKey);
+              if (isInOurR2) {
+                updatedEntry.c = existingCdnIndex;
+                await uploadToCdn(imageKey);
+                for (const thumbPath of _chunkWOHZ4LYGjs.getAllThumbnailPaths.call(void 0, imageKey)) {
+                  urlsToPurge.push(`${publicUrl}${thumbPath}`);
+                }
+                await deleteLocalThumbnails(imageKey);
+                try {
+                  await _fs.promises.unlink(originalPath);
+                } catch (e31) {
+                }
+              }
+              meta[imageKey] = updatedEntry;
+            }
+            processed.push(imageKey);
+          } catch (error) {
+            console.error(`Failed to reprocess ${imageKey}:`, error);
+            errors.push(imageKey);
+          }
+        }
+        sendEvent({ type: "cleanup", message: "Saving metadata..." });
+        await saveMeta(meta);
+        if (urlsToPurge.length > 0) {
+          sendEvent({ type: "cleanup", message: "Purging CDN cache..." });
+          await purgeCloudflareCache(urlsToPurge);
+        }
+        sendEvent({
+          type: "complete",
+          processed: processed.length,
+          errors: errors.length,
+          message: `Processed ${processed.length} image${processed.length !== 1 ? "s" : ""}${errors.length > 0 ? `, ${errors.length} error${errors.length !== 1 ? "s" : ""}` : ""}`
+        });
+        controller.close();
+      } catch (error) {
+        console.error("Reprocess stream error:", error);
+        sendEvent({ type: "error", message: "Failed to process images" });
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+async function handleProcessAllStream() {
+  const publicUrl = _optionalChain([process, 'access', _43 => _43.env, 'access', _44 => _44.CLOUDFLARE_R2_PUBLIC_URL, 'optionalAccess', _45 => _45.replace, 'call', _46 => _46(/\/\s*$/, "")]);
+  const encoder = new TextEncoder();
   const stream = new ReadableStream({
     async start(controller) {
       const sendEvent = (data) => {
@@ -1488,7 +1622,7 @@ async function handleProcessAllStream() {
               await deleteLocalThumbnails(key);
               try {
                 await _fs.promises.unlink(fullPath);
-              } catch (e29) {
+              } catch (e32) {
               }
             }
             processed.push(key.slice(1));
@@ -1527,13 +1661,13 @@ async function handleProcessAllStream() {
                 }
               }
             }
-          } catch (e30) {
+          } catch (e33) {
           }
         }
         const imagesDir = _path2.default.join(process.cwd(), "public", "images");
         try {
           await findOrphans(imagesDir);
-        } catch (e31) {
+        } catch (e34) {
         }
         async function removeEmptyDirs(dir) {
           try {
@@ -1551,13 +1685,13 @@ async function handleProcessAllStream() {
               await _fs.promises.rmdir(dir);
             }
             return isEmpty;
-          } catch (e32) {
+          } catch (e35) {
             return true;
           }
         }
         try {
           await removeEmptyDirs(imagesDir);
-        } catch (e33) {
+        } catch (e36) {
         }
         await saveMeta(meta);
         if (urlsToPurge.length > 0) {
@@ -1625,7 +1759,7 @@ async function handleScanStream() {
                 allFiles.push({ relativePath: relPath, fullPath });
               }
             }
-          } catch (e34) {
+          } catch (e37) {
           }
         }
         const publicDir = _path2.default.join(process.cwd(), "public");
@@ -1684,7 +1818,7 @@ async function handleScanStream() {
                     o: { w: metadata.width || 0, h: metadata.height || 0 },
                     b: blurhash
                   };
-                } catch (e35) {
+                } catch (e38) {
                   meta[imageKey] = { o: { w: 0, h: 0 } };
                 }
               }
@@ -1724,13 +1858,13 @@ async function handleScanStream() {
                 }
               }
             }
-          } catch (e36) {
+          } catch (e39) {
           }
         }
         const imagesDir = _path2.default.join(process.cwd(), "public", "images");
         try {
           await findOrphans(imagesDir);
-        } catch (e37) {
+        } catch (e40) {
         }
         await saveMeta(meta);
         sendEvent({
@@ -1797,13 +1931,13 @@ async function handleDeleteOrphans(request) {
           await _fs.promises.rmdir(dir);
         }
         return isEmpty;
-      } catch (e38) {
+      } catch (e41) {
         return true;
       }
     }
     try {
       await removeEmptyDirs(imagesDir);
-    } catch (e39) {
+    } catch (e42) {
     }
     return _server.NextResponse.json({
       success: true,
@@ -1985,6 +2119,9 @@ async function POST(request) {
   if (route === "reprocess") {
     return handleReprocess(request);
   }
+  if (route === "reprocess-stream") {
+    return handleReprocessStream(request);
+  }
   if (route === "process-all") {
     return handleProcessAllStream();
   }