tango-app-api-trax 3.9.70 → 3.9.71

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-trax",
-    "version": "3.9.70",
+    "version": "3.9.71",
     "description": "Trax",
     "main": "index.js",
     "type": "module",

package/src/controllers/internalTrax.controller.js

@@ -29,8 +29,7 @@ import { insertSingleProcessData } from '../controllers/trax.controller.js';
 import handlebars from './handlebar-helper.js';
 import { buildVisitChecklistTemplateData, getCompiledVisitChecklistTemplate, createImageCache, resolveTemplateUrls } from '../utils/visitChecklistPdf.utils.js';
 import archiver from 'archiver';
-import puppeteer from 'puppeteer';
-import { getBrowser as getBrowserInstance } from '../utils/browserPool.utils.js';
+import { getBrowser as getBrowserInstance, withPdfSlot } from '../utils/browserPool.utils.js';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath as toPath } from 'url';
@@ -3765,57 +3764,34 @@ export const downloadInsertPdf = async ( req, res ) => {
     }
     const cdnBase = JSON.parse( process.env.CDNURL )?.TraxAnswerCDN || '';
     const pdfTemplate = getCompiledVisitChecklistTemplate();
-    const imageCache = createImageCache();
 
     const safeName = ( str ) =>
       ( str || '' ).toString().replace( /[<>:"/\\|?*]+/g, '_' );
 
-    // const query = {
-    //   query: {
-    //     bool: {
-    //       must: [
-    //         {
-    //           term: {
-    //             _id: req.body.checklistId,
-    //           },
-    //         },
-    //       ],
-    //     },
-    //   },
-    // };
-
-
-    // 1) Launch browser page + fetch OpenSearch data in parallel
-    const [ browser, aiDetails ] = await Promise.all( [
-      getBrowserInstance(),
-      // getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).traxIndex, query ),
-      processedchecklist.findOne( { _id: req.body.checklistId } ),
-    ] );
-    console.log( aiDetails );
+    // 1) Fetch the checklist document. The browser is acquired later, at
+    //    point-of-use inside the render slot — grabbing it here and holding it
+    //    across the slow image work below risks a stale (recycled) browser.
+    const aiDetails = await processedchecklist.findOne( { _id: req.body.checklistId } );
 
     if ( !aiDetails ) {
       return res.sendError( 'Checklist not found', 404 );
     }
 
-    const doc = { ...aiDetails?.toObject() };
-
-    console.log( doc );
+    const doc = aiDetails.toObject();
 
-    // 2) Fetch brandInfo + compliance data in parallel
+    // 2) Fetch brandInfo + compliance data in parallel.
     const complianceURL = JSON.parse( process.env.LAMBDAURL ).complianceHistory;
-    const detectionPayload = {
-      'storeId': [ doc.store_id ],
-      'userEmail': doc.userEmail,
-      'sourceChecklist_id': doc.sourceCheckList_id,
-    };
-
     const [ brandInfo, complianceData ] = await Promise.all( [
       getBrandInfo( doc.client_id ),
-      LamdaServiceCall( complianceURL, detectionPayload ),
+      LamdaServiceCall( complianceURL, {
+        storeId: [ doc.store_id ],
+        userEmail: doc.userEmail,
+        sourceChecklist_id: doc.sourceCheckList_id,
+      } ),
     ] );
 
     if ( complianceData?.data?.length ) {
-      doc['historyData'] = complianceData.data;
+      doc.historyData = complianceData.data;
     }
 
     // CDN fix
@@ -3830,62 +3806,146 @@ export const downloadInsertPdf = async ( req, res ) => {
     } );
 
     const templateData = buildVisitChecklistTemplateData( doc, brandInfo );
+    // Keep images as CDN URLs (do NOT inline as base64) — Chrome fetches them
+    // at render time. Inlining produced a multi-MB HTML string that crashed
+    // puppeteer's setContent CDP transfer ("Target closed").
     const resolvedData = resolveTemplateUrls( templateData, cdnBase );
-    await imageCache.resolveAllImages( resolvedData );
 
     const html = pdfTemplate( resolvedData );
 
-    // 3) Create page and render — images are already base64 so use domcontentloaded
-    page = await browser.newPage();
-    await page.setViewport( { width: 1280, height: 1800 } );
+    // 3) Render inside a concurrency slot. Acquire a *fresh* browser from the
+    //    pool at point-of-use, and retry on a new page if the render frame
+    //    detaches (renderer crash / recycled browser) — that surfaces as
+    //    "Execution context is not available in detached frame".
+    // Render inside the concurrency slot; the slot returns just the PDF buffer.
+    const finalBuffer = await withPdfSlot( async () => {
+      const MAX_RENDER_ATTEMPTS = 2;
+      let buffer = null;
+      let lastError;
 
-    try {
-      await page.setContent( html, {
-        waitUntil: 'domcontentloaded',
-        timeout: 15000,
-      } );
-      await page.emulateMediaType( 'screen' );
-    } catch ( err ) {
-      logger.error( { functionName: 'downloadInsertPdf', message: 'setContent failed', error: err } );
-    }
-
-    let pdfBuffer;
-    try {
-      pdfBuffer = await page.pdf( {
-        format: 'A4',
-        printBackground: true,
-        preferCSSPageSize: true,
-        displayHeaderFooter: true,
-        headerTemplate: '<span></span>',
-        footerTemplate: [
-          '<div style="width:100%;padding:0 10mm;font-size:10px;',
-          'font-family:Arial,sans-serif;display:flex;',
-          'justify-content:space-between;align-items:center;',
-          'border-top:1px solid #d9d9d9;padding-top:4px;">',
-          '<span style="color:#999;">Page ',
-          '<span class="pageNumber"></span>',
-          ' of <span class="totalPages"></span></span>',
-          '<span style="display:flex;align-items:center;gap:6px;">',
-          '<span style="color:#666;font-weight:400;font-size:10px;">',
-          'Generated by</span>',
-          tangoyeLogoSvg,
-          '</span></div>',
-        ].join( '' ),
-      } );
-    } catch ( err ) {
-      logger.error( { functionName: 'downloadInsertPdf', message: 'PDF generation failed', error: err } );
-      return res.sendError( 'PDF generation failed', 500 );
-    }
+      for ( let attempt = 1; attempt <= MAX_RENDER_ATTEMPTS; attempt++ ) {
+        const browser = await getBrowserInstance();
+        page = await browser.newPage();
 
-    if ( !pdfBuffer || pdfBuffer.length === 0 ) {
-      logger.error( { functionName: 'downloadInsertPdf', message: 'Empty PDF', docId: doc._id } );
-      return res.sendError( 'PDF generation resulted in empty buffer', 500 );
-    }
+        try {
+          await page.setViewport( { width: 1280, height: 1800 } );
+          await page.setContent( html, {
+            waitUntil: 'domcontentloaded',
+            timeout: 30000,
+          } );
+          await page.emulateMediaType( 'screen' );
+
+          // Images load from CDN URLs (not inlined). Wait for them to finish,
+          // capped at 30s so a slow/broken image can't hang the render.
+          await Promise.race( [
+            page.evaluate( async () => {
+              const images = Array.from( document.images );
+              await Promise.all(
+                  images.map( ( img ) => {
+                    if ( img.complete ) return;
+                    return new Promise( ( resolve ) => {
+                      img.onload = img.onerror = resolve;
+                    } );
+                  } ),
+              );
+            } ),
+            new Promise( ( resolve ) => setTimeout( resolve, 30000 ) ),
+          ] );
+
+          // Downscale images in-page before printing. They're embedded at
+          // source (camera) resolution otherwise, which bloats the PDF and
+          // print memory. Cap the largest side at 1200px — plenty for the
+          // small display sizes. Processed one at a time to bound peak memory.
+          await page.evaluate( async ( maxDim ) => {
+            const imgs = Array.from( document.images );
+            for ( const img of imgs ) {
+              try {
+                const nw = img.naturalWidth;
+                const nh = img.naturalHeight;
+                if ( !nw || !nh ) continue;
+                const scale = maxDim / Math.max( nw, nh );
+                if ( scale >= 1 ) continue; // already small enough
+                const canvas = document.createElement( 'canvas' );
+                canvas.width = Math.round( nw * scale );
+                canvas.height = Math.round( nh * scale );
+                canvas.getContext( '2d' ).drawImage( img, 0, 0, canvas.width, canvas.height );
+                const dataUrl = canvas.toDataURL( 'image/jpeg', 0.75 );
+                canvas.width = 0;
+                canvas.height = 0;
+                img.src = dataUrl;
+                if ( img.decode ) await img.decode().catch( () => {} );
+              } catch ( e ) {
+                // Keep the original image if downscaling fails.
+              }
+            }
+          }, 900 );
+
+          const pdfBuffer = await page.pdf( {
+            format: 'A4',
+            printBackground: true,
+            preferCSSPageSize: true,
+            displayHeaderFooter: true,
+            headerTemplate: '<span></span>',
+            footerTemplate: [
+              '<div style="width:100%;padding:0 10mm;font-size:10px;',
+              'font-family:Arial,sans-serif;display:flex;',
+              'justify-content:space-between;align-items:center;',
+              'border-top:1px solid #d9d9d9;padding-top:4px;">',
+              '<span style="color:#999;">Page ',
+              '<span class="pageNumber"></span>',
+              ' of <span class="totalPages"></span></span>',
+              '<span style="display:flex;align-items:center;gap:6px;">',
+              '<span style="color:#666;font-weight:400;font-size:10px;">',
+              'Generated by</span>',
+              tangoyeLogoSvg,
+              '</span></div>',
+            ].join( '' ),
+          } );
+
+          if ( !pdfBuffer || pdfBuffer.length === 0 ) {
+            throw new Error( 'PDF generation resulted in empty buffer' );
+          }
+
+          buffer = Buffer.isBuffer( pdfBuffer ) ? pdfBuffer : Buffer.from( pdfBuffer );
+          break;
+        } catch ( err ) {
+          lastError = err;
+          logger.error( {
+            functionName: 'downloadInsertPdf',
+            message: `PDF render attempt ${attempt} failed`,
+            docId: doc?._id,
+            error: err,
+          } );
+
+          const msg = String( err?.message || '' );
+          const retriable =
+            msg.includes( 'detached frame' ) ||
+            msg.includes( 'Execution context' ) ||
+            msg.includes( 'Target closed' ) ||
+            msg.includes( 'Session closed' );
+
+          if ( !retriable || attempt === MAX_RENDER_ATTEMPTS ) break;
+        } finally {
+          // Free the page (and its renderer) as soon as this attempt ends.
+          if ( page ) {
+            await page.close().catch( () => {} );
+            page = null;
+          }
+        }
+      }
 
-    const finalBuffer = Buffer.isBuffer( pdfBuffer ) ?
-      pdfBuffer :
-      Buffer.from( pdfBuffer );
+      if ( !buffer ) {
+        logger.error( { functionName: 'downloadInsertPdf', message: 'PDF generation failed after retries', error: lastError } );
+      }
+      return buffer;
+    } );
 
+    if ( !finalBuffer ) {
+      return res.sendError( 'PDF generation failed', 500 );
+    }
+
+    // Upload the PDF to S3 and return a signed download URL — a tiny JSON
+    // response, so the client never hits the "max response size" limit.
     let pdfName;
     if ( doc?.store_id ) {
       pdfName = `${safeName(
@@ -3897,13 +3957,17 @@ export const downloadInsertPdf = async ( req, res ) => {
       )}.pdf`;
     }
 
-    res.set( {
-      'Content-Type': 'application/pdf',
-      'Content-Disposition': `attachment; filename="${pdfName}"`,
-      'Content-Length': finalBuffer.length,
+    const bucket = JSON.parse( process.env.BUCKET );
+    const uploaded = await fileUpload( {
+      fileName: pdfName,
+      Key: 'traxDailyReports/',
+      Bucket: bucket.sop,
+      body: finalBuffer,
+      ContentType: 'application/pdf',
     } );
+    const downloadUrl = await signedUrl( { file_path: uploaded.Key, Bucket: bucket.sop } );
 
-    return res.send( finalBuffer );
+    return res.sendSuccess( { url: downloadUrl, key: uploaded.Key, fileName: pdfName } );
   } catch ( e ) {
     logger.error( { functionName: 'downloadInsertPdf', error: e } );
     return res.sendError( e, 500 );
@@ -4030,13 +4094,11 @@ export const downloadInsertPdfOld = async ( req, res ) => {
           },
         } );
 
-        const browser = await puppeteer.launch( {
-          headless: 'new',
-          args: [ '--no-sandbox', '--disable-dev-shm-usage' ],
-        } );
+        const browser = await getBrowserInstance();
+        let page = null;
 
         try {
-          const page = await browser.newPage();
+          page = await browser.newPage();
 
           await page.setViewport( {
             width: 1280,
@@ -4272,7 +4334,7 @@ export const downloadInsertPdfOld = async ( req, res ) => {
             }
           }
         } finally {
-          await browser.close();
+          if ( page ) await page.close().catch( () => {} );
         }
 
         // console.log( '🎉 All processing completed' );

package/src/controllers/mobileTrax.controller.js

@@ -28,7 +28,7 @@ import isSameOrBefore from 'dayjs/plugin/isSameOrBefore.js';
 import * as cameraService from '../services/camera.service.js';
 import * as recurringFlagTracker from '../services/recurringFlagTracker.service.js';
 dayjs.extend( isSameOrBefore );
-import puppeteer from 'puppeteer';
+import { getBrowser, withPdfSlot } from '../utils/browserPool.utils.js';
 import handlebars from './handlebar-helper.js';
 import fs from 'fs';
 import path from 'path';
@@ -237,12 +237,13 @@ export async function startChecklist( req, res ) {
       } );
       let getupdatedchecklist = await processedchecklist.aggregate( findQuery );
       // let bucket = JSON.parse( process.env.BUCKET );
+      const cdnurl = JSON.parse( process.env.CDNURL );
       getupdatedchecklist[0].questionAnswers.forEach( ( section ) => {
-        section.questions.forEach( async ( question ) => {
+        section.questions.forEach( ( question ) => {
           if ( question.questionReferenceImage && question.questionReferenceImage!='' ) {
             question.questionReferenceImage = `${cdnurl.TraxAnswerCDN}${question.questionReferenceImage}`;
           }
-          question.answers.forEach( async ( answer ) => {
+          question.answers.forEach( ( answer ) => {
             if ( answer.referenceImage != '' ) {
               answer.referenceImage = `${cdnurl.TraxAnswerCDN}${answer.referenceImage}`;
             }
@@ -5510,6 +5511,7 @@ export async function chunkUpload( req, res ) {
 }
 
 export async function downloadChecklist( req, res ) {
+  let page = null;
   try {
     let requestData = req.body;
 
@@ -5594,54 +5596,53 @@ export async function downloadChecklist( req, res ) {
     const template = handlebars.compile( templateHtml );
     const html = template( { data: checklistDetails } );
 
-    // Generate PDF using puppeteer instead of deprecated html-pdf
-    const browser = await puppeteer.launch( {
-      headless: 'new',
-      args: [ '--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage' ],
-    } );
+    // Generate PDF on a page from the shared browser pool, capped by withPdfSlot
+    return await withPdfSlot( async () => {
+      const browser = await getBrowser();
 
-    const page = await browser.newPage();
-
-    await page.setContent( html, {
-      waitUntil: 'domcontentloaded',
-    } );
+      page = await browser.newPage();
 
-    /* -------- WAIT FOR ALL IMAGES TO LOAD -------- */
+      await page.setContent( html, {
+        waitUntil: 'domcontentloaded',
+      } );
 
-    await page.evaluate( async () => {
-      const images = Array.from( document.images );
+      /* -------- WAIT FOR ALL IMAGES TO LOAD -------- */
 
-      await Promise.all(
-          images.map( ( img ) => {
-            if ( img.complete ) return;
+      await page.evaluate( async () => {
+        const images = Array.from( document.images );
 
-            return new Promise( ( resolve ) => {
-              img.onload = img.onerror = resolve;
-            } );
-          } ),
-      );
-    } );
+        await Promise.all(
+            images.map( ( img ) => {
+              if ( img.complete ) return;
 
-    /* ---------------- GENERATE PDF ---------------- */
+              return new Promise( ( resolve ) => {
+                img.onload = img.onerror = resolve;
+              } );
+            } ),
+        );
+      } );
 
-    const pdfBuffer = await page.pdf( {
-      format: 'A4',
-      printBackground: true,
-    } );
+      /* ---------------- GENERATE PDF ---------------- */
 
-    await browser.close();
+      const pdfBuffer = await page.pdf( {
+        format: 'A4',
+        printBackground: true,
+      } );
 
-    /* ---------------- RESPONSE ---------------- */
+      /* ---------------- RESPONSE ---------------- */
 
-    res.setHeader( 'Content-Type', 'application/pdf' );
-    res.setHeader(
-        'Content-Disposition',
-        'attachment; filename=checkListDetails.pdf',
-    );
+      res.setHeader( 'Content-Type', 'application/pdf' );
+      res.setHeader(
+          'Content-Disposition',
+          'attachment; filename=checkListDetails.pdf',
+      );
 
-    return res.end( pdfBuffer );
+      return res.end( pdfBuffer );
+    } );
   } catch ( e ) {
     logger.error( { functionName: 'getChecklistQuestionAnswers', error: e } );
     return res.sendError( e, 500 );
+  } finally {
+    if ( page ) await page.close().catch( () => {} );
   }
 }

package/src/hbs/visit-checklist.hbs

@@ -82,11 +82,13 @@
   .q-answer-link{font-size:12px;color:#0085D2;text-decoration:underline;word-break:break-all}
   .q-answer-caption{font-size:11px;color:#666;margin-bottom:4px}
   .q-answer-remarks{font-size:11px;color:#666;margin-top:6px;white-space:pre-line}
-  /* User verification (Submitted By) */
+  /* User verification (Acknowledged by) */
   .user-verify{margin-top:28px;padding-top:18px;border-top:1px solid #d9d9d9;break-inside:avoid}
   .user-verify-title{font-size:15px;font-weight:700;color:#1a1a1a;margin-bottom:14px}
   .user-verify-photo{display:block;width:200px;height:240px;object-fit:cover;border-radius:8px;margin-bottom:10px}
   .user-verify-name{font-size:14px;color:#1a1a1a;font-weight:600}
+  .user-verify-ack{font-size:14px;color:#1a1a1a;line-height:1.5;max-width:240px;margin-top:10px}
+  .user-verify-ack strong{font-weight:700}
   .user-verify-sign-label{font-size:12px;color:#666;margin-top:16px;margin-bottom:6px;font-weight:600}
   .user-verify-signature{display:block;width:220px;height:auto;max-height:110px;object-fit:contain;border:1px solid #eee;border-radius:6px;padding:6px;background:#fff}
   /* Footer */
@@ -299,12 +301,12 @@
 {{/each}}
 {{#if showUserVerification}}
 <div class="user-verify">
-  <div class="user-verify-title">Submitted By</div>
+  <div class="user-verify-title">Acknowledged by</div>
   {{#if userImage}}
-  <img class="user-verify-photo" src="{{userImage}}" alt="Submitted by photo" />
+  <img class="user-verify-photo" src="{{userImage}}" alt="Acknowledged by photo" />
   {{/if}}
   {{#if submittedBy}}
-  <div class="user-verify-name">{{userSignature}}</div>
+  <div class="user-verify-ack">I, <strong>{{submittedBy}}</strong> acknowledge that the checklist responses are accurate and correct.</div>
   {{/if}}
 </div>
 {{/if}}

package/src/utils/browserPool.utils.js

@@ -70,3 +70,43 @@ export async function getBrowser() {
   return launchPromise;
 }
 
+
+/**
+
+ * Concurrency limiter for PDF generation.
+
+ * Caps how many PDF jobs (pages/renderers) run at once so a burst of requests
+
+ * can't spawn unbounded Chrome work and exhaust memory. Configurable via
+
+ * MAX_CONCURRENT_PDF (default 3). Run each PDF job inside withPdfSlot(); the
+
+ * slot is always released, even if the task throws.
+
+ */
+
+const MAX_CONCURRENT_PDF = Number( process.env.MAX_CONCURRENT_PDF ) || 3;
+
+let activePdf = 0;
+
+const pdfWaiters = [];
+
+
+export async function withPdfSlot( task ) {
+  if ( activePdf >= MAX_CONCURRENT_PDF ) {
+    await new Promise( ( resolve ) => pdfWaiters.push( resolve ) );
+  }
+
+  activePdf++;
+
+  try {
+    return await task();
+  } finally {
+    activePdf--;
+
+    const next = pdfWaiters.shift();
+
+    if ( next ) next();
+  }
+}
+

package/src/utils/visitChecklistPdf.utils.js

@@ -4,7 +4,7 @@ import path from 'path';
 
 import { fileURLToPath } from 'url';
 
-import puppeteer from 'puppeteer';
+import { getBrowser, withPdfSlot } from './browserPool.utils.js';
 
 import handlebars from '../controllers/handlebar-helper.js';
 
@@ -1285,14 +1285,19 @@ export function createImageCache() {
 }
 
 
-export function getCompiledVisitChecklistTemplate() {
-  const templatePath = path.join( __dirname, '../hbs/visit-checklist.hbs' );
-
-
-  const templateHtml = fs.readFileSync( templatePath, 'utf8' );
+// Compiled once and reused for every request. Reading the .hbs from disk and
+// recompiling it on each PDF request was pure per-request overhead.
+// NOTE: editing visit-checklist.hbs now requires a server restart to take effect.
+let compiledVisitChecklistTemplate = null;
 
+export function getCompiledVisitChecklistTemplate() {
+  if ( !compiledVisitChecklistTemplate ) {
+    const templatePath = path.join( __dirname, '../hbs/visit-checklist.hbs' );
+    const templateHtml = fs.readFileSync( templatePath, 'utf8' );
+    compiledVisitChecklistTemplate = handlebars.compile( templateHtml );
+  }
 
-  return handlebars.compile( templateHtml );
+  return compiledVisitChecklistTemplate;
 }
 
 
@@ -1529,53 +1534,51 @@ export async function generateVisitChecklistPDF( templateData, baseUrl = 'https:
   const html = template( resolvedData );
 
 
-  const browser = await puppeteer.launch( {
-
-    headless: 'new',
+  // Render on a page from the shared browser pool, capped by withPdfSlot
+  return withPdfSlot( async () => {
+    const browser = await getBrowser();
 
-    args: [ '--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage' ],
+    let page = null;
 
-  } );
-
-
-  try {
-    const page = await browser.newPage();
+    try {
+      page = await browser.newPage();
 
-    await page.setContent( html, { waitUntil: 'domcontentloaded' } );
+      await page.setContent( html, { waitUntil: 'domcontentloaded' } );
 
 
-    await page.evaluate( async () => {
-      const images = Array.from( document.images );
+      await page.evaluate( async () => {
+        const images = Array.from( document.images );
 
-      await Promise.all(
+        await Promise.all(
 
-          images.map( ( img ) => {
-            if ( img.complete ) return;
+            images.map( ( img ) => {
+              if ( img.complete ) return;
 
-            return new Promise( ( resolve ) => {
-              img.onload = img.onerror = resolve;
-            } );
-          } ),
+              return new Promise( ( resolve ) => {
+                img.onload = img.onerror = resolve;
+              } );
+            } ),
 
-      );
-    } );
+        );
+      } );
 
 
-    const pdfBuffer = await page.pdf( {
+      const pdfBuffer = await page.pdf( {
 
-      format: 'A4',
+        format: 'A4',
 
-      printBackground: true,
+        printBackground: true,
 
-      margin: { top: '10mm', right: '10mm', bottom: '10mm', left: '10mm' },
+        margin: { top: '10mm', right: '10mm', bottom: '10mm', left: '10mm' },
 
-    } );
+      } );
 
 
-    return pdfBuffer;
-  } finally {
-    await browser.close();
-  }
+      return pdfBuffer;
+    } finally {
+      if ( page ) await page.close().catch( () => {} );
+    }
+  } );
 }