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

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.', error);
             return response.send(originalBase64);
+        }
     } catch (error) {

src/util.js+27 -4 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) => {
 +                if (err) {
 +                    console.warn(`Error opening ZIP file: ${err.message}`);
 +                    return resolve(null);
 +                }
                 zipfile.readEntry();
++
                 zipfile.on('entry', (entry) => {
                     if (entry.fileName.endsWith(fileExtension) && !entry.fileName.startsWith('__MACOSX')) {
                         console.info(`Extracting ${entry.fileName}`);
                         zipfile.openReadStream(entry, (err, readStream) => {
                             if (err) {
 -                        reject(err);
 +                                console.warn(`Error opening read stream: ${err.message}`);
 +                                return zipfile.readEntry();
                             } else {
                                 const chunks = [];
                                 readStream.on('data', (chunk) => {

                                     resolve(buffer);
                                     zipfile.readEntry(); // Continue to the next entry
                                 });
++
 +                                readStream.on('error', (err) => {
 +                                    console.warn(`Error reading stream: ${err.message}`);
 +                                    zipfile.readEntry();
 +                                });
+                            }
                         });
                     } else {
                         zipfile.readEntry();
+                    }
                 });
++
 +                zipfile.on('error', (err) => {
 +                    console.warn('ZIP processing error', err);
 +                    resolve(null);
 +                });
++
                 zipfile.on('end', () => resolve(null));
                 }));
 +        } catch (error) {
 +            console.warn('Failed to process ZIP buffer', error);
 +            resolve(null);
 +        }
 +    });
+}
 /**