ZIP extraction error handling (#4002) * Improve error handling in extractFileFromZipBuffer function * Add warning logging to NovelAI image upscaling

c218c1baeaa58025ce38f1abc0dec742b0156097

Cohee <18619528+Cohee1207@users.noreply.github.com>

Signed

Parents: 1651fa1ed7ad80e6cd56677ddf911573051f22e7

src/endpoints/novelai.js+3 -2 Viewed

             });
             if (!upscaleResult.ok) {
-                throw new Error('NovelAI returned an error.');
+                const text = await upscaleResult.text();
+                throw new Error('NovelAI returned an error.', { cause: text });
+            }
             const upscaledArchiveBuffer = await upscaleResult.arrayBuffer();

             return response.send(upscaledBase64);
         } catch (error) {
-            console.warn('NovelAI generated an image, but upscaling failed. Returning original image.');
+            console.warn('NovelAI generated an image, but upscaling failed. Returning original image.', error);
             return response.send(originalBase64);
+        }
     } catch (error) {

src/util.js+48 -25 Viewed

  * @returns {Promise<Buffer|null>} Buffer containing the extracted file. Null if the file was not found.
  */
 export async function extractFileFromZipBuffer(archiveBuffer, fileExtension) {
-    return await new Promise((resolve, reject) => yauzl.fromBuffer(Buffer.from(archiveBuffer), { lazyEntries: true }, (err, zipfile) => {
+    return await new Promise((resolve) => {
-        if (err) reject(err);
+        try {
+            yauzl.fromBuffer(Buffer.from(archiveBuffer), { lazyEntries: true }, (err, zipfile) => {
-        zipfile.readEntry();
+                if (err) {
-        zipfile.on('entry', (entry) => {
+                    console.warn(`Error opening ZIP file: ${err.message}`);
-            if (entry.fileName.endsWith(fileExtension) && !entry.fileName.startsWith('__MACOSX')) {
+                    return resolve(null);
-                console.info(`Extracting ${entry.fileName}`);
+                }
-                zipfile.openReadStream(entry, (err, readStream) => {
-                    if (err) {
+                zipfile.readEntry();
-                        reject(err);
-                    } else {
+                zipfile.on('entry', (entry) => {
-                        const chunks = [];
+                    if (entry.fileName.endsWith(fileExtension) && !entry.fileName.startsWith('__MACOSX')) {
-                        readStream.on('data', (chunk) => {
+                        console.info(`Extracting ${entry.fileName}`);
-                            chunks.push(chunk);
+                        zipfile.openReadStream(entry, (err, readStream) => {
-                        });
+                            if (err) {
+                                console.warn(`Error opening read stream: ${err.message}`);
+                                return zipfile.readEntry();
+                            } else {
+                                const chunks = [];
+                                readStream.on('data', (chunk) => {
+                                    chunks.push(chunk);
+                                });
+                                readStream.on('end', () => {
+                                    const buffer = Buffer.concat(chunks);
+                                    resolve(buffer);
+                                    zipfile.readEntry(); // Continue to the next entry
+                                });
-                        readStream.on('end', () => {
+                                readStream.on('error', (err) => {
-                            const buffer = Buffer.concat(chunks);
+                                    console.warn(`Error reading stream: ${err.message}`);
-                            resolve(buffer);
+                                    zipfile.readEntry();
-                            zipfile.readEntry(); // Continue to the next entry
+                                });
+                            }
                         });
+                    } else {
+                        zipfile.readEntry();
+                    }
                 });
-            } else {
-                zipfile.readEntry();
+                zipfile.on('error', (err) => {
-            }
+                    console.warn('ZIP processing error', err);
-        });
+                    resolve(null);
-        zipfile.on('end', () => resolve(null));
+                });
-    }));
+                zipfile.on('end', () => resolve(null));
+            });
+        } catch (error) {
+            console.warn('Failed to process ZIP buffer', error);
+            resolve(null);
+        }
+    });
+}
 /**