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.', 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('enderror', (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);
 +        }
 +    });
+}
 /**