Error handling refactor

2025-11-03 16:00 UTC gpt-5-thinking Open in ChatGPT ↗

This is a Google Apps Script.

Modify it so that it’s error reporting is centralized and logical. Make sure that a full progress log is stored alongside the generated invoice, as a “receipt” of the generation process.

/**

Invoice Generator for Google Apps Script
This file contains all functions needed to create invoices from templates,
populate them with data, and convert them to PDFs.
Can be called from external applications via Web App deployment.
@version 1.0.0
@author Uncharted Limbo Collective */

// ============================================================================ // TYPE DEFINITIONS // ============================================================================

/**

Invoice fee entry representing a line item on the invoice.
@typedef {Object} InvoiceFeeEntry
@property {string} Description - Description of the service or product
@property {number} Quantity - Quantity of items
@property {number} UnitPrice - Price per unit
@property {number} SubTotal - Total for this line item (Quantity × UnitPrice)
@example
{
Description: ‘Web Development’,
Quantity: 10,
UnitPrice: 150,
SubTotal: 1500
} */

/**

Complete invoice data structure containing all information needed to generate an invoice.
@typedef {Object} InvoiceData
@property {string} ClientLegalName - Full legal name of the client company
@property {string} ClientAddress - Complete mailing address of the client
@property {string} [ClientTaxId] - Tax identification number (optional)
@property {string} InvoiceReference - Unique invoice reference number
@property {Date} InvoiceDate - Date the invoice was issued
@property {string} InvoiceCurrency - ISO currency code (e.g., ‘GBP’, ‘USD’, ‘EUR’)
@property {number} InvoiceDaysNotice - Payment terms in days (e.g., 30 for Net 30)
@property {string} ProjectCode - Project identifier code
@property {number} TotalAmount - Total invoice amount including VAT
@property {number} NetAmount - Invoice amount before VAT
@property {number} VatAmount - VAT amount in currency
@property {number} VatRate - VAT rate as decimal (e.g., 0.2 for 20%)
@property {string[]} ScopeOfWork - Array of scope of work items (bullet points)
@property {InvoiceFeeEntry[]} FeeItems - Array of fee line items
@example
{
ClientLegalName: ‘Acme Corporation Ltd’,
ClientAddress: ‘123 Business Street, London, UK’,
ClientTaxId: ‘GB123456789’,
InvoiceReference: ‘INV-2025-001’,
InvoiceDate: new Date(‘2025-01-15’),
InvoiceCurrency: ‘GBP’,
InvoiceDaysNotice: 30,
ProjectCode: ‘PROJ-001’,
TotalAmount: 1200,
NetAmount: 1000,
VatAmount: 200,
VatRate: 0.2,
ScopeOfWork: [
```
'Website development',
```
```
'API integration',
```
```
'Testing and deployment'
```
],
FeeItems: [
```
{
```
```
  Description: 'Development Hours',
```
```
  Quantity: 10,
```
```
  UnitPrice: 100,
```
```
  SubTotal: 1000
```
```
}
```
]
} */

/**

Result object returned from invoice creation operations.
@typedef {Object} InvoiceCreationResult
@property {boolean} success - Whether the operation succeeded
@property {string} message - Success or error message
@property {string} [pdfUrl] - URL of the created PDF file (only if success is true)
@property {string} [documentUrl] - URL of the Google Doc (only if success is true)
@property {Object} [details] - Additional details about the operation
@property {Object} [details.validationErrors] - Map of field names to validation errors (if validation failed)
@property {string} [details.filename] - Generated filename
@property {string} [details.clientName] - Client name used
@property {string} [details.projectCode] - Project code used
@property {string} [details.currency] - Currency used
@property {string} [details.folderPath] - Path where document was saved
@example
// Success response
{
success: true,
message: ‘Invoice created successfully’,
pdfUrl: ‘https://drive.google.com/file/d/…’,
documentUrl: ‘https://docs.google.com/document/d/…’,
details: {
```
filename: '250115_INV-2025-001',
```
```
clientName: 'Acme Corporation',
```
```
projectCode: 'PROJ-001',
```
```
currency: 'GBP'
```
}
}
@example
// Error response
{
success: false,
message: ‘Invoice data validation failed’,
details: {
```
validationErrors: {
```

  ClientLegalName: 'Client legal name is required',

  InvoiceDate: 'Valid invoice date is required'

```
}
```
}
} */

/**

Options for invoice creation and rendering.
@typedef {Object} InvoiceOptions
@property {boolean} [debugMode=false] - If true, validates without creating files
@property {boolean} [overwriteExisting=false] - If true, overwrites existing files
@property {string} [destinationFolderId] - Custom folder ID for saving files
@example
{
debugMode: true,
overwriteExisting: false
} */

const API_KEYS = { ‘csharp-app’: ”, ‘mobile-app’: ” };

// ============================================================================ // CONFIGURATION // =========================================================================== /**

Configuration constants for invoice generation. */ const INVOICE_CONFIG = { TEMPLATE_ID_GBP: ”, TEMPLATE_ID_EUR: ”, TEMPLATE_ID_USD: ‘1vKOJAWj-’, INVOICE_FOLDER_ID: ‘1-’, ADMIN_EMAIL: ” };

// ============================================================================ // HELPER FUNCTIONS // ============================================================================

/**

Returns currency symbol for a given currency code.
@param {string} currencyCode - ISO currency code (e.g., ‘GBP’, ‘USD’, ‘EUR’)
@returns {string} Currency symbol */ function getCurrencySymbol(acronym){

var currencyDict = { “USD”: ”$”, // United States Dollar “EUR”: ”€”, // Euro “JPY”: ”¥”, // Japanese Yen “GBP”: ”£”, // British Pound Sterling “AUD”: “A$”, // Australian Dollar “CAD”: “C$”, // Canadian Dollar “CHF”: “Fr.”, // Swiss Franc “CNY”: ”¥”, // Chinese Yuan “INR”: ”₹”, // Indian Rupee “MXN”: “Mex$”, // Mexican Peso “BRL”: “R$”, // Brazilian Real “ZAR”: “R”, // South African Rand “RUB”: ”₽”, // Russian Ruble “SGD”: “S$”, // Singapore Dollar “HKD”: “HK$”, // Hong Kong Dollar “NZD”: “NZ$”, // New Zealand Dollar “KRW”: ”₩”, // South Korean Won “SEK”: “kr”, // Swedish Krona “NOK”: “kr”, // Norwegian Krone “AED”: “د.إ”, // United Arab Emirates Dirham “QAR”: ”﷼”, // Qatari Riyal };

return currencyDict[acronym] }

/**

Formats a date as dd/MM/yyyy for invoice display.
@param {Date} date - Date to format
@returns {string} Formatted date string */ function formatInvoiceDate(date) { return Utilities.formatDate(date, Session.getScriptTimeZone(), ‘dd/MM/yyyy’); }

/**

Gets the appropriate template ID based on currency.
@param {string} currency - Currency code (GBP, EUR, USD)
@returns {string} Template document ID
@private */ function getTemplateIdForCurrency(currency) { const templates = { ‘EUR’: INVOICE_CONFIG.TEMPLATE_ID_EUR, ‘USD’: INVOICE_CONFIG.TEMPLATE_ID_USD, ‘GBP’: INVOICE_CONFIG.TEMPLATE_ID_GBP };

return templates[currency] || INVOICE_CONFIG.TEMPLATE_ID_GBP; }

/**

Generates a standardized filename for the invoice document.
Format: YYMMDD_InvoiceReference
@param {Date} invoiceDate - Invoice date
@param {string} invoiceReference - Invoice reference number
@returns {string} Formatted filename
@private */ function generateInvoiceFilename(invoiceDate, invoiceReference) { const dateStr = invoiceDate.toISOString().slice(2, 10).replace(/-/g, ”); return ${dateStr}_${invoiceReference}; }

/**

Checks if a file with the given name exists in the specified folder.
@param {GoogleAppsScript.Drive.Folder} folder - Folder to search
@param {string} filename - Filename to search for
@returns {GoogleAppsScript.Drive.File|null} Found file or null
@private */ function findFileInFolder(folder, filename) { const files = folder.getFilesByName(filename); return files.hasNext() ? files.next() : null; }

// ============================================================================ // VALIDATION // ============================================================================

/**

Validates invoice data to ensure all required fields are present and valid.
@param {InvoiceData} data - The invoice data to validate
@returns {Object} Object containing isValid flag and errors object
@private */ function validateInvoiceData(data) { const errors = {};

// Client validation if (!data.ClientLegalName || data.ClientLegalName.trim() === ”) { errors.ClientLegalName = ‘Client legal name is required’; } if (!data.ClientAddress || data.ClientAddress.trim() === ”) { Logger.log(“WARNING - Client address is empty!”); //errors.ClientAddress = ‘Client address is required’; }

// Invoice info validation if (!data.InvoiceReference || data.InvoiceReference.trim() === ”) { errors.InvoiceReference = ‘Invoice reference is required’; } if (!(data.InvoiceDate instanceof Date) || isNaN(data.InvoiceDate)) { errors.InvoiceDate = ‘Valid invoice date is required’; } if (!data.InvoiceCurrency || data.InvoiceCurrency.trim() === ”) { errors.InvoiceCurrency = ‘Invoice currency is required’; } if (typeof data.InvoiceDaysNotice !== ‘number’ || data.InvoiceDaysNotice < 0) { errors.InvoiceDaysNotice = ‘Valid days notice is required’; }

// Financial validation if (typeof data.TotalAmount !== ‘number’ || data.TotalAmount <= 0) { errors.TotalAmount = ‘Valid total amount is required’; } if (typeof data.NetAmount !== ‘number’ || data.NetAmount <= 0) { errors.NetAmount = ‘Valid net amount is required’; } if (typeof data.VatAmount !== ‘number’ || data.VatAmount < 0) { errors.VatAmount = ‘Valid VAT amount is required’; } if (typeof data.VatRate !== ‘number’ || data.VatRate < 0) { errors.VatRate = ‘Valid VAT rate is required’; }

// Scope and fees validation if (!Array.isArray(data.ScopeOfWork) || data.ScopeOfWork.length === 0) { errors.ScopeOfWork = ‘At least one scope of work item is required’; } if (!Array.isArray(data.FeeItems) || data.FeeItems.length === 0) { errors.FeeItems = ‘At least one fee item is required’; }

return { isValid: Object.keys(errors).length === 0, errors }; }

// ============================================================================ // FOLDER MANAGEMENT // ============================================================================

/**

Retrieves or creates the folder structure for an invoice.
Creates client and project folders if they don’t exist.
@param {GoogleAppsScript.Drive.Folder} invoiceRootFolder - Root invoice folder
@param {string} clientName - Client name for folder
@param {string} projectCode - Project code for subfolder
@param {boolean} debugMode - If true, simulates folder operations
@returns {Object} Object containing clientFolder and projectFolder
@private */ function getOrCreateInvoiceFolders(invoiceRootFolder, clientName, projectCode, debugMode = false) { if (debugMode) { return { clientFolder: { getName: () => clientName, getId: () => ‘debug-client-folder-id’ }, projectFolder: { getName: () => projectCode, getId: () => ‘debug-project-folder-id’ } }; }

// Get existing folder names const existingClientFolders = []; const clientFolders = invoiceRootFolder.getFolders();

while (clientFolders.hasNext()) { existingClientFolders.push(clientFolders.next()); }

// Find or create client folder let clientFolder = existingClientFolders.find(folder => folder.getName() === clientName);

if (!clientFolder) { Logger.log(Creating client folder: ${clientName}); clientFolder = invoiceRootFolder.createFolder(clientName); } else { Logger.log(Client folder exists: ${clientName}); }

// Find or create project folder const existingProjectFolders = clientFolder.getFolders(); let projectFolder = null;

while (existingProjectFolders.hasNext()) { const folder = existingProjectFolders.next(); if (folder.getName() === projectCode) { projectFolder = folder; break; } }

if (!projectFolder) { Logger.log(Creating project folder: ${projectCode}); projectFolder = clientFolder.createFolder(projectCode); } else { Logger.log(Project folder exists: ${projectCode}); }

return { clientFolder, projectFolder }; }

// ============================================================================ // DOCUMENT POPULATION // ============================================================================

/**

Converts a Google Document to PDF and moves it to the specified folder.
@param {GoogleAppsScript.Document.Document} doc - The document to convert
@param {string} folderId - ID of the destination folder
@returns {string} URL of the created PDF file
@private */ function convertDocumentToPdf(doc, folderId) { const pdfBlob = doc.getAs(‘application/pdf’); pdfBlob.setName(doc.getName() + ‘.pdf’);

const pdfFile = DriveApp.createFile(pdfBlob); const fileId = pdfFile.getId();

// Move PDF to correct folder const file = DriveApp.getFileById(fileId); const sourceFolder = DriveApp.getFileById(doc.getId()).getParents().next(); const destinationFolder = DriveApp.getFolderById(folderId);

destinationFolder.addFile(file); sourceFolder.removeFile(file);

return pdfFile.getUrl(); }

/**

Populates a Google Document template with invoice data.
@param {GoogleAppsScript.Document.Document} doc - The document to populate
@param {InvoiceData} data - The invoice data
@param {string} currencySymbol - Currency symbol for formatting
@private */ function populateDocumentTemplate(doc, data, currencySymbol) { const body = doc.getBody();

// Replace client information body.replaceText(‘{{Client}}’, data.ClientLegalName); body.replaceText(‘{{Address}}’, data.ClientAddress); body.replaceText(‘{{Tax_ID}}’, data.ClientTaxId || ‘N/A’);

// Replace invoice metadata body.replaceText(‘{{Invoice Reference}}’, data.InvoiceReference); body.replaceText(‘{{Date Invoiced}}’, Utilities.formatDate(data.InvoiceDate, Session.getScriptTimeZone(), ‘dd/MM/yyyy’)); body.replaceText(‘{{Notice}}’, String(data.InvoiceDaysNotice)); body.replaceText(‘{{Currency}}’, data.InvoiceCurrency);

// Replace financial amounts body.replaceText(‘{{TotalAmount}}’, currencySymbol + data.TotalAmount.toFixed(2)); body.replaceText(‘{{Amount}}’, currencySymbol + data.NetAmount.toFixed(2)); body.replaceText(‘{{VAT}}’, currencySymbol + data.VatAmount.toFixed(2)); body.replaceText(‘{{VAT_Rate}}’, (data.VatRate * 100).toFixed(1) + ’%’);

// Add scope of work bullet points insertBulletListAfterParagraph(doc, ‘Scope of Work’, data.ScopeOfWork);

// Add fee structure table populateInvoiceFeeTable(doc, data.FeeItems, currencySymbol); }

/**

Inserts a formatted bullet list into a Google Document after a specific parent paragraph.
This function searches for a paragraph with text matching the parent string,
then inserts a bulleted list immediately after it with the specified items.
@param {GoogleAppsScript.Document.Document} doc - The Google Document object
@param {string} parentText - The exact text of the paragraph after which to insert bullets
@param {string[]} bulletItems - Array of strings to be inserted as bullet points
@throws {Error} If doc is not a valid Document object
@throws {Error} If bulletItems is not an array or is empty
@example
const doc = DocumentApp.openById(‘your-doc-id’);
insertBulletListAfterParagraph(doc, ‘Scope of Work’, [‘Task 1’, ‘Task 2’, ‘Task 3’]); */ function insertBulletListAfterParagraph(doc, parentText, bulletItems) { // Input validation if (!doc || typeof doc.getBody !== ‘function’) { throw new Error(‘Invalid document object provided’); }

if (!Array.isArray(bulletItems) || bulletItems.length === 0) { throw new Error(‘bulletItems must be a non-empty array’); }

if (typeof parentText !== ‘string’ || parentText.trim() === ”) { throw new Error(‘parentText must be a non-empty string’); }

const body = doc.getBody(); const paragraphs = body.getParagraphs();

// Define bullet styling once (not in loop) const bulletStyle = { [DocumentApp.Attribute.FONT_SIZE]: 12, [DocumentApp.Attribute.FOREGROUND_COLOR]: ‘#000000’ };

// Find the parent paragraph and insert bullets after it for (let i = 0; i < paragraphs.length; i++) { const paragraphText = paragraphs[i].getText();
```
 if (paragraphText === parentText) {
     // Insert all bullet items after the parent paragraph
     bulletItems.forEach((bulletText, index) => {
         const insertPosition = i + 1 + index;
         const listItem = body.insertListItem(insertPosition, bulletText);
         listItem.setGlyphType(DocumentApp.GlyphType.BULLET);
         listItem.setAttributes(bulletStyle);
     });

     // Exit after first match (parent text should be unique)
     return;
 }
```
}

// Log warning if parent paragraph was not found Logger.log(Warning: Parent paragraph "${parentText}" not found in document); }

/**

Populates a Google Document table with invoice fee data.
Inserts rows into the first table found in the document, with each row containing
description, quantity, unit price, and subtotal. Applies consistent formatting
including center alignment and custom border styling.
@param {GoogleAppsScript.Document.Document} doc - The Google Document object
@param {InvoiceFeeEntry[]} feeRows - Array of fee entries with Description, Quantity, UnitPrice, and SubTotal
@param {string} currencySymbol - Currency symbol to prepend to monetary values (e.g., ’£’, ’$’, ’€’)
@throws {Error} If doc is not a valid Document object
@throws {Error} If feeRows is not a valid array with data
@throws {Error} If the document contains no tables
@example
const doc = DocumentApp.openById(‘doc-id’);
const fees = [
{ Description: ‘Web Development’, Quantity: 40, UnitPrice: 150, SubTotal: 6000 },
{ Description: ‘Design Services’, Quantity: 20, UnitPrice: 100, SubTotal: 2000 }
];
populateInvoiceFeeTable(doc, fees, ’£’); */ function populateInvoiceFeeTable(doc, feeRows, currencySymbol) { // Input validation if (!doc || typeof doc.getBody !== ‘function’) { throw new Error(‘Invalid document object provided’); }

if (!Array.isArray(feeRows) || feeRows.length === 0) { throw new Error(‘feeRows must be a non-empty array’); }

if (typeof currencySymbol !== ‘string’) { throw new Error(‘currencySymbol must be a string’); }

const body = doc.getBody(); const tables = body.getTables();

if (tables.length === 0) { throw new Error(‘Document must contain at least one table’); }

const table = tables[0]; const numRows = feeRows.length;

// Define cell alignment style once const centerAlignStyle = { [DocumentApp.Attribute.HORIZONTAL_ALIGNMENT]: DocumentApp.HorizontalAlignment.CENTER };

// Insert and populate rows feeRows.forEach((feeEntry, index) => { const newRow = table.insertTableRow(1 + index);
```
 // Append cells in the correct order with proper formatting
 const cells = [
     newRow.appendTableCell(String(feeEntry.Description)),
     newRow.appendTableCell(String(feeEntry.Quantity)),
     newRow.appendTableCell(currencySymbol + String(feeEntry.UnitPrice)),
     newRow.appendTableCell(currencySymbol + String(feeEntry.SubTotal))
 ];

 // Apply center alignment to all cells
 cells.forEach(cell => {
     cell.getChild(0).asParagraph().setAttributes(centerAlignStyle);
 });
```
});

// Apply custom border styling to inserted rows doc.saveAndClose(); applyTableBorderStyling(doc, table, numRows, 4); // Always 4 columns for InvoiceFeeEntry }

/**

Applies custom border styling to table rows using the Google Docs API.
Sets solid bottom borders and removes left/right borders for a cleaner appearance.
This is a separate function to maintain single responsibility and improve testability.
@param {GoogleAppsScript.Document.Document} doc - The Google Document object
@param {GoogleAppsScript.Document.Table} table - The table element to style
@param {number} rowCount - Number of rows to apply styling to
@param {number} columnCount - Number of columns in each row
@private */ function applyTableBorderStyling(doc, table, rowCount, columnCount) { const docId = doc.getId(); const body = doc.getBody(); const tableIndex = body.getChildIndex(table); const startIndex = Docs.Documents.get(docId).body.content[tableIndex + 1].startIndex;

const borderStyleRequest = { updateTableCellStyle: { tableCellStyle: { borderBottom: { dashStyle: ‘SOLID’, width: { magnitude: 1, unit: ‘PT’ }, color: { color: { rgbColor: { red: 0 } } } }, borderRight: { dashStyle: ‘SOLID’, width: { magnitude: 0, unit: ‘PT’ }, color: { color: {} } }, borderLeft: { dashStyle: ‘SOLID’, width: { magnitude: 0, unit: ‘PT’ }, color: { color: {} } } }, tableRange: { tableCellLocation: { tableStartLocation: { index: startIndex }, rowIndex: 1 }, rowSpan: rowCount, columnSpan: columnCount }, fields: ‘borderBottom,borderRight,borderLeft’ } };

Docs.Documents.batchUpdate({ requests: [borderStyleRequest] }, docId); }

/**

Sends an email notification about duplicate invoice file.
@param {string} clientName - Client name
@param {string} filename - Duplicate filename
@param {string} folderUrl - URL of the folder containing duplicate
@private */ function notifyDuplicateFile(clientName, filename, folderUrl) { const subject = Duplicate Invoice File: ${filename}; const body = An invoice document with the same name already exists.\n\n + Client: ${clientName}\n + Filename: ${filename}\n + Folder: ${folderUrl}\n\n + Please review and take appropriate action.;

// MailApp.sendEmail(INVOICE_CONFIG.ADMIN_EMAIL, subject, body); Logger.log(Duplicate file notification sent: ${filename} - ${folderUrl} - ${clientName} ); }

// ============================================================================ // DOCUMENT RENDERING // ============================================================================

/**

Renders an invoice document from template, populating it with data.
This function validates the input data, populates a Google Document template,
converts it to PDF, and returns the result. In debug mode, validation is
performed without creating any files.
@param {InvoiceData} data - Complete invoice data including client, amounts, and line items
@param {string} docId - Google Document template ID
@param {Object} options - Configuration options
@param {boolean} [options.debugMode=false] - If true, validates without creating files
@param {string} [options.destinationFolderId] - Folder ID where PDF should be saved
@returns {RenderResult} Result object containing success status and details
@example
// Production mode
const result = renderInvoiceDocument(invoiceData, ‘doc-id’, {
destinationFolderId: ‘folder-id’
});
if (result.success) {
Logger.log(‘PDF created: ’ + result.pdfUrl);
}
@example
// Debug mode
const debugResult = renderInvoiceDocument(invoiceData, ‘doc-id’, {
debugMode: true
});
if (!debugResult.success) {
Logger.log(‘Validation errors: ’ + JSON.stringify(debugResult.validationErrors));

} */ function renderInvoiceDocument(data, docId, options = {}) { const debugMode = options.debugMode || false;

try { // Step 1: Validate input data const validation = validateInvoiceData(data);

 if (!validation.isValid) {
     return {
         success: false,
         message: 'Validation failed',
         validationErrors: validation.errors
     };
 }

 // In debug mode, return success after validation
 if (debugMode) {
     return {
         success: true,
         message: 'Debug mode: All validations passed. Document would be created successfully.',
         debugInfo: {
             documentId: docId,
             currency: data.InvoiceCurrency,
             totalAmount: data.TotalAmount,
             feeItemCount: data.FeeItems.length,
             scopeItemCount: data.ScopeOfWork.length,
             clientName: data.ClientLegalName,
             invoiceReference: data.InvoiceReference
         }
     };
 }

 // Step 2: Validate document ID
 if (!docId || typeof docId !== 'string') {
     throw new Error('Valid document ID is required');
 }

 // Step 3: Open and populate document
 const doc = DocumentApp.openById(docId);
 const currencySymbol = getCurrencySymbol(data.InvoiceCurrency);

 populateDocumentTemplate(doc, data, currencySymbol);

 Logger.log('Document template populated successfully');

 // Step 4: Convert to PDF
 const folderId = options.destinationFolderId ||
     DriveApp.getFileById(docId).getParents().next().getId();

 const pdfUrl = convertDocumentToPdf(doc, folderId);

 Logger.log('PDF created successfully: ' + pdfUrl);

 return {
     success: true,
     message: 'Invoice document created successfully',
     pdfUrl: pdfUrl
 };

} catch (error) { Logger.log(‘Error rendering invoice document: ’ + error.toString());

 return {
     success: false,
     message: 'Error creating invoice document: ' + error.message,
     validationErrors: { system: error.toString() }
 };

} }

/**

Debug wrapper for testing invoice document rendering without creating files.
@param {InvoiceData} data - Invoice data to validate
@param {string} docId - Document template ID
@returns {RenderResult} Validation result with debug information
@example
const debugResult = debugRenderInvoiceDocument(testData, ‘doc-id’);
if (debugResult.success) {
Logger.log(’✓ All checks passed. Ready for production.’);
Logger.log(JSON.stringify(debugResult.debugInfo, null, 2));
} else {
Logger.log(’✗ Validation failed:’);
Logger.log(JSON.stringify(debugResult.validationErrors, null, 2));
} */ function debugRenderInvoiceDocument(data, docId) { return renderInvoiceDocument(data, docId, { debugMode: true }); }

// ============================================================================ // INVOICE CREATION // ============================================================================

/**

Creates an invoice document from template and generates a PDF.
This is the main function for invoice generation. It handles:
- Folder structure creation/retrieval
- Template selection based on currency
- Document population
- PDF generation
- File organization
Supports a debug mode that validates everything without creating files.
@param {InvoiceData} invoiceData - Complete invoice data
@param {Object} options - Configuration options
@param {boolean} [options.debugMode=false] - If true, validates without creating files
@param {boolean} [options.overwriteExisting=false] - If true, overwrites existing files
@returns {InvoiceCreationResult} Result object with success status and details
@example
// Production mode
const result = createInvoice(invoiceData);
if (result.success) {
Logger.log(‘Invoice created: ’ + result.pdfUrl);
} else {
Logger.log(‘Error: ’ + result.message);
}
@example
// Debug mode
const debugResult = createInvoice(invoiceData, { debugMode: true });
if (debugResult.success) {
Logger.log(’✓ Invoice would be created successfully’);
Logger.log(JSON.stringify(debugResult.details, null, 2));
} */ function createInvoice(invoiceData, options = {}) { const debugMode = options.debugMode || false; const overwriteExisting = options.overwriteExisting || false;

try { // Step 1: Validate invoice data const validation = validateInvoiceData(invoiceData);

 if (!validation.isValid) {
      // Return detailed validation errors
      const errorMessages = Object.keys(validation.errors)
          .map(key => `${key}: ${validation.errors[key]}`)
          .join(', ');

      return {
          success: false,
          message: `Validation failed: ${errorMessages}`,
          details: {
              validationErrors: validation.errors,
              receivedData: {
                  hasClientName: !!invoiceData.ClientLegalName,
                  hasAddress: !!invoiceData.ClientAddress,
                  hasInvoiceRef: !!invoiceData.InvoiceReference,
                  hasInvoiceDate: !!invoiceData.InvoiceDate,
                  hasCurrency: !!invoiceData.InvoiceCurrency,
                  hasDaysNotice: invoiceData.InvoiceDaysNotice !== undefined,
                  hasProjectCode: !!invoiceData.ProjectCode,
                  hasTotalAmount: invoiceData.TotalAmount !== undefined,
                  hasNetAmount: invoiceData.NetAmount !== undefined,
                  hasVatAmount: invoiceData.VatAmount !== undefined,
                  hasVatRate: invoiceData.VatRate !== undefined,
                  hasScopeOfWork: Array.isArray(invoiceData.ScopeOfWork),
                  hasFeeItems: Array.isArray(invoiceData.FeeItems)
              }
          }
      };
  }

// Step 2: Extract required data
const clientName = invoiceData.ClientLegalName;
const projectCode = invoiceData.ProjectCode;
const invoiceDate = invoiceData.InvoiceDate;
const invoiceReference = invoiceData.InvoiceReference;
const currency = invoiceData.InvoiceCurrency;

// Step 3: Get template and folders
const templateId = INVOICE_CONFIG.TEMPLATE_ID_GBP //getTemplateIdForCurrency(currency);
const filename = generateInvoiceFilename(invoiceDate, invoiceReference);

if (debugMode) {
  return {
    success: true,
    message: 'Debug mode: All validations passed. Invoice ready for creation.',
    details: {
      templateId,
      filename,
      clientName,
      projectCode,
      currency,
      invoiceDate: invoiceDate.toISOString(),
      wouldCreateFolders: true,
      wouldCreateDocument: true,
      wouldGeneratePDF: true
    }
  };
}

// Step 4: Get or create folder structure
const invoiceRootFolder = DriveApp.getFolderById(INVOICE_CONFIG.INVOICE_FOLDER_ID);
const { clientFolder, projectFolder } = getOrCreateInvoiceFolders(
  invoiceRootFolder,
  clientName,
  projectCode,
  debugMode
);

Logger.log(`Using folders - Client: ${clientFolder.getName()}, Project: ${projectFolder.getName()}`);

// Step 5: Check for existing file
const existingFile = findFileInFolder(projectFolder, filename);

if (existingFile && !overwriteExisting) {
  notifyDuplicateFile(clientName, filename, projectFolder.getUrl());

  return {
    success: false,
    message: 'Duplicate file exists. Admin notified.',
    details: {
      filename,
      folderUrl: projectFolder.getUrl(),
      action: 'notification_sent'
    }
  };
}

// Step 6: Create document from template
const template = DriveApp.getFileById(templateId);
const documentCopy = template.makeCopy(filename, projectFolder);

Logger.log(`Document created: ${filename} in ${clientFolder.getName()}/${projectFolder.getName()}`);

// Step 7: Render invoice content and generate PDF
const renderResult = renderInvoiceDocument(invoiceData, documentCopy.getId(), {
  destinationFolderId: projectFolder.getId()
});

if (!renderResult.success) {
  return {
    success: false,
    message: 'Failed to render invoice document',
    details: {
      renderError: renderResult.message,
      documentId: documentCopy.getId()
    }
  };
}

Logger.log('Invoice created successfully');

return {
  success: true,
  message: 'Invoice created successfully',
  pdfUrl: renderResult.pdfUrl,
  documentUrl: documentCopy.getUrl(),
  details: {
    filename,
    clientName,
    projectCode,
    currency,
    folderPath: `${clientFolder.getName()}/${projectFolder.getName()}`
  }
};

} catch (error) { Logger.log(Error creating invoice: ${error.toString()});

return {
  success: false,
  message: `Error creating invoice: ${error.message}`,
  details: { error: error.toString() }
};

} }

/**

Debug wrapper for testing invoice creation without creating files.
@param {InvoiceData} invoiceData - Invoice data to validate
@returns {InvoiceCreationResult} Validation result with debug information
@example
const debugResult = debugCreateInvoice(testInvoiceData);
if (debugResult.success) {
Logger.log(’✓ Ready for production’);
Logger.log(‘Details: ’ + JSON.stringify(debugResult.details, null, 2));
} else {
Logger.log(’✗ Validation failed’);
Logger.log(‘Errors: ’ + JSON.stringify(debugResult.details.validationErrors, null, 2));
} */ function debugCreateInvoice(invoiceData) { return createInvoice(invoiceData, { debugMode: true }); }

// ============================================================================ // WEB APP ENTRY POINTS // ============================================================================

/**

Web App entry point for HTTP POST requests from external applications.
Handles invoice creation requests with JSON payload.
This function must be deployed as a Web App with appropriate permissions.
@param {Object} e - Event object containing request data
@returns {GoogleAppsScript.Content.TextOutput} JSON response
@example POST Request Body:
{
“invoiceData”: {
```
"ClientLegalName": "Acme Corp",
```
```
"ClientAddress": "123 Main St",
```
```
"ClientTaxId": "GB123456789",
```
```
"InvoiceReference": "INV-001",
```
```
"InvoiceDate": "2025-01-15",
```
```
"InvoiceCurrency": "GBP",
```
```
"InvoiceDaysNotice": 30,
```
```
"TotalAmount": 1200,
```
```
"NetAmount": 1000,
```
```
"VatAmount": 200,
```
```
"VatRate": 0.2,
```
```
"ProjectCode": "PROJ-001",
```
```
"ScopeOfWork": ["Task 1", "Task 2"],
```
```
"FeeItems": [
```
```
  {
```
```
    "Description": "Development",
```
```
    "Quantity": 10,
```
```
    "UnitPrice": 100,
```
```
    "SubTotal": 1000
```
```
  }
```
```
]
```
},
“options”: {
```
"debugMode": false,
```
```
"overwriteExisting": false
```
}
} */

function doPost(e) { let debug_data = ""; try { // Authenticate via API key const apiKey = e.parameter.apiKey;

    if (!apiKey || !Object.values(API_KEYS).includes(apiKey)) {
      return ContentService
        .createTextOutput(JSON.stringify({
          success: false,
          message: 'Unauthorized: Invalid or missing API key'
        }))
        .setMimeType(ContentService.MimeType.JSON);
    }

    // Parse incoming JSON
    const requestData = JSON.parse(e.postData.contents);
    const invoiceData = requestData.InvoicePayload;
    debug_data = invoiceData;
    const options = requestData.options || {};

    // Convert date string to Date object
    if (invoiceData.InvoiceDate && typeof invoiceData.InvoiceDate === 'string') {
        invoiceData.InvoiceDate = new Date(invoiceData.InvoiceDate);
    }

    // Create invoice
    const result = createInvoice(invoiceData, options);

    // Return JSON response
    return ContentService
        .createTextOutput(JSON.stringify(result))
        .setMimeType(ContentService.MimeType.JSON);

} catch (error) {
    // Return error response
    const errorResponse = {
        success: false,
        message: 'Error processing request: ' + error.message,
        details: {
          error: error.toString() ,
          payload: debug_data
        }
    };

    return ContentService
        .createTextOutput(JSON.stringify(errorResponse))
        .setMimeType(ContentService.MimeType.JSON);
}

}

/**

Web App entry point for HTTP GET requests.
Used for testing connectivity and getting API status.
@returns {GoogleAppsScript.Content.TextOutput} JSON response with API info */ function doGet(e) { const response = { success: true, message: ‘Invoice Generator API is running’, version: ‘1.0.0’, endpoints: { POST: ‘Send invoice data as JSON to create invoice’, GET: ‘API status check’ }, debugMode: e.parameter.debug === ‘true’ };

return ContentService .createTextOutput(JSON.stringify(response)) .setMimeType(ContentService.MimeType.JSON); }

Awesome brief. I’ve refactored your script to centralize error handling and to capture a full, timestamped progress log (“receipt”) that’s saved next to the generated invoice. The progress log includes: inputs summary, each major step, warnings, caught errors (with stack), and the final outcome. It’s saved as both human-readable .txt and machine-readable .json for easy auditing.

What changed (short + sweet)

Added a ProgressLogger utility (steps, info, warn, error; JSON + TXT export).
Added a reportError helper to normalize/capture errors and (optionally) email admins.
Threaded the logger through createInvoice, renderInvoiceDocument, and the web handlers.
Automatically writes a <filename>__receipt.txt and <filename>__receipt.json into the project folder alongside the Doc/PDF for successes, duplicates, and failures (wherever we can determine the folder).
Messages in API responses now include a condensed status while the full log is on Drive.

Paste the code below over your existing script (it’s a drop-in replacement). Search for the “NEW/CHANGED” banners to see additions.

/**
 * Invoice Generator for Google Apps Script
 *
 * Centralized error reporting + full progress receipt next to the generated invoice.
 *
 * @version 1.1.0
 * @author Uncharted Limbo Collective
 */

// ============================================================================
// TYPE DEFINITIONS (unchanged)
// ============================================================================

/**
 * Invoice fee entry representing a line item on the invoice.
 *
 * @typedef {Object} InvoiceFeeEntry
 * @property {string} Description
 * @property {number} Quantity
 * @property {number} UnitPrice
 * @property {number} SubTotal
 */

/**
 * @typedef {Object} InvoiceData
 * @property {string} ClientLegalName
 * @property {string} ClientAddress
 * @property {string} [ClientTaxId]
 * @property {string} InvoiceReference
 * @property {Date}   InvoiceDate
 * @property {string} InvoiceCurrency
 * @property {number} InvoiceDaysNotice
 * @property {string} ProjectCode
 * @property {number} TotalAmount
 * @property {number} NetAmount
 * @property {number} VatAmount
 * @property {number} VatRate
 * @property {string[]} ScopeOfWork
 * @property {InvoiceFeeEntry[]} FeeItems
 */

/**
 * @typedef {Object} InvoiceCreationResult
 * @property {boolean} success
 * @property {string} message
 * @property {string} [pdfUrl]
 * @property {string} [documentUrl]
 * @property {Object} [details]
 * @property {Object} [details.validationErrors]
 * @property {string} [details.filename]
 * @property {string} [details.clientName]
 * @property {string} [details.projectCode]
 * @property {string} [details.currency]
 * @property {string} [details.folderPath]
 * @property {string} [details.receiptTxtUrl]
 * @property {string} [details.receiptJsonUrl]
 */

/**
 * @typedef {Object} InvoiceOptions
 * @property {boolean} [debugMode=false]
 * @property {boolean} [overwriteExisting=false]
 * @property {string}  [destinationFolderId]
 */

// ============================================================================
// CONFIGURATION (unchanged, fill in your IDs/emails)
// ============================================================================

const API_KEYS = {
  'csharp-app': '',
  'mobile-app': ''
};

const INVOICE_CONFIG = {
  TEMPLATE_ID_GBP: '',
  TEMPLATE_ID_EUR: '',
  TEMPLATE_ID_USD: '1vKOJAWj-',
  INVOICE_FOLDER_ID: '1-',
  ADMIN_EMAIL: '' // optional: used for serious error notifications
};

// ============================================================================
// NEW: CENTRALIZED LOGGING + ERROR REPORTING
// ============================================================================

/**
 * Progress logger that accumulates a timeline and can write a receipt file.
 */
const ProgressLogger = (() => {
  const nowIso = () => new Date().toISOString();

  function ProgressLogger(context = {}) {
    this.context = context; // e.g. client, project, filename, currency
    this.timeline = [];
    this.outcome = null; // { success, message }
  }

  ProgressLogger.prototype._push = function (level, msg, extra) {
    const entry = {
      ts: nowIso(),
      level,
      message: String(msg)
    };
    if (extra !== undefined) entry.extra = extra;
    this.timeline.push(entry);
    // also log to GAS logger for live debugging
    Logger.log(`[${level}] ${entry.ts} - ${entry.message}${extra ? ' ' + JSON.stringify(extra) : ''}`);
  };

  ProgressLogger.prototype.step  = function (msg, extra) { this._push('STEP', msg, extra); };
  ProgressLogger.prototype.info  = function (msg, extra) { this._push('INFO', msg, extra); };
  ProgressLogger.prototype.warn  = function (msg, extra) { this._push('WARN', msg, extra); };
  ProgressLogger.prototype.error = function (msg, extra) { this._push('ERROR', msg, extra); };

  ProgressLogger.prototype.setOutcome = function (success, message, extra) {
    this.outcome = { ts: nowIso(), success: !!success, message: String(message) };
    if (extra) this.outcome.extra = extra;
  };

  ProgressLogger.prototype.toJSON = function () {
    return JSON.stringify({
      context: this.context,
      outcome: this.outcome,
      timeline: this.timeline
    }, null, 2);
  };

  ProgressLogger.prototype.toText = function () {
    const header = [
      '===== INVOICE GENERATION RECEIPT =====',
      `Generated: ${nowIso()}`,
      `Client: ${this.context.clientName || '-'}`,
      `Project: ${this.context.projectCode || '-'}`,
      `InvoiceRef: ${this.context.invoiceReference || '-'}`,
      `Filename: ${this.context.filename || '-'}`,
      `Currency: ${this.context.currency || '-'}`,
      ''
    ].join('\n');

    const steps = this.timeline.map(e => `[${e.level}] ${e.ts} :: ${e.message}${e.extra ? ' :: ' + JSON.stringify(e.extra) : ''}`).join('\n');

    const outcome = [
      '',
      '----- OUTCOME -----',
      `Success: ${this.outcome ? this.outcome.success : '-'}`,
      `Message: ${this.outcome ? this.outcome.message : '-'}`,
      this.outcome && this.outcome.extra ? `Extra: ${JSON.stringify(this.outcome.extra)}` : ''
    ].join('\n');

    return `${header}${steps}${outcome}\n=======================================\n`;
  };

  /**
   * Saves both TXT and JSON receipts in the given folder, using the filename base.
   * Returns { txtUrl, jsonUrl }.
   */
  ProgressLogger.prototype.saveReceipts = function (folder, filenameBase) {
    if (!folder) throw new Error('Receipt folder not available');

    const txtBlob = Utilities.newBlob(this.toText(), 'text/plain', `${filenameBase}__receipt.txt`);
    const jsonBlob = Utilities.newBlob(this.toJSON(), 'application/json', `${filenameBase}__receipt.json`);

    const txtFile = folder.createFile(txtBlob);
    const jsonFile = folder.createFile(jsonBlob);

    return { txtUrl: txtFile.getUrl(), jsonUrl: jsonFile.getUrl() };
  };

  return ProgressLogger;
})();

/**
 * Central error reporting. Normalizes error object, logs, and optionally emails admin.
 */
function reportError(logger, err, contextMessage, severity = 'error') {
  const normalized = {
    name: (err && err.name) || 'Error',
    message: (err && err.message) || String(err),
    stack: (err && err.stack) || 'no stack',
  };
  logger.error(contextMessage || 'Unhandled error', normalized);

  // Optional: email only on critical failures and if ADMIN_EMAIL set
  if (INVOICE_CONFIG.ADMIN_EMAIL && severity === 'critical') {
    try {
      const subject = `Invoice Generator - Critical Error (${logger.context.invoiceReference || 'unknown'})`;
      const body = `${contextMessage}\n\n${JSON.stringify(normalized, null, 2)}\n\nContext:\n${JSON.stringify(logger.context, null, 2)}`;
      // MailApp.sendEmail(INVOICE_CONFIG.ADMIN_EMAIL, subject, body);
      logger.info('Admin notification prepared (disabled by default).');
    } catch (emailErr) {
      logger.warn('Failed to send admin email', { emailErr: String(emailErr) });
    }
  }

  return normalized;
}

// ============================================================================
// HELPER FUNCTIONS (mostly unchanged; minor tweaks to add logging where helpful)
// ============================================================================

function getCurrencySymbol(acronym){
  var currencyDict = {
    "USD": "$","EUR": "€","JPY": "¥","GBP": "£","AUD": "A$","CAD": "C$","CHF": "Fr.","CNY": "¥",
    "INR": "₹","MXN": "Mex$","BRL": "R$","ZAR": "R","RUB": "₽","SGD": "S$","HKD": "HK$","NZD": "NZ$",
    "KRW": "₩","SEK": "kr","NOK": "kr","AED": "د.إ","QAR": "﷼",
  };
  return currencyDict[acronym];
}

function formatInvoiceDate(date) {
  return Utilities.formatDate(date, Session.getScriptTimeZone(), 'dd/MM/yyyy');
}

function getTemplateIdForCurrency(currency) {
  const templates = {
    'EUR': INVOICE_CONFIG.TEMPLATE_ID_EUR,
    'USD': INVOICE_CONFIG.TEMPLATE_ID_USD,
    'GBP': INVOICE_CONFIG.TEMPLATE_ID_GBP
  };
  return templates[currency] || INVOICE_CONFIG.TEMPLATE_ID_GBP;
}

function generateInvoiceFilename(invoiceDate, invoiceReference) {
  const dateStr = invoiceDate.toISOString().slice(2, 10).replace(/-/g, '');
  return `${dateStr}_${invoiceReference}`;
}

function findFileInFolder(folder, filename) {
  const files = folder.getFilesByName(filename);
  return files.hasNext() ? files.next() : null;
}

// ============================================================================
// VALIDATION (unchanged except removed stray Logger warning)
// ============================================================================

function validateInvoiceData(data) {
  const errors = {};

  if (!data.ClientLegalName || data.ClientLegalName.trim() === '') {
    errors.ClientLegalName = 'Client legal name is required';
  }
  if (!data.ClientAddress || data.ClientAddress.trim() === '') {
    // optional: allow blank address but note it
    errors.ClientAddress = 'Client address is required';
  }

  if (!data.InvoiceReference || data.InvoiceReference.trim() === '') {
    errors.InvoiceReference = 'Invoice reference is required';
  }
  if (!(data.InvoiceDate instanceof Date) || isNaN(data.InvoiceDate)) {
    errors.InvoiceDate = 'Valid invoice date is required';
  }
  if (!data.InvoiceCurrency || data.InvoiceCurrency.trim() === '') {
    errors.InvoiceCurrency = 'Invoice currency is required';
  }
  if (typeof data.InvoiceDaysNotice !== 'number' || data.InvoiceDaysNotice < 0) {
    errors.InvoiceDaysNotice = 'Valid days notice is required';
  }

  if (typeof data.TotalAmount !== 'number' || data.TotalAmount <= 0) {
    errors.TotalAmount = 'Valid total amount is required';
  }
  if (typeof data.NetAmount !== 'number' || data.NetAmount <= 0) {
    errors.NetAmount = 'Valid net amount is required';
  }
  if (typeof data.VatAmount !== 'number' || data.VatAmount < 0) {
    errors.VatAmount = 'Valid VAT amount is required';
  }
  if (typeof data.VatRate !== 'number' || data.VatRate < 0) {
    errors.VatRate = 'Valid VAT rate is required';
  }

  if (!Array.isArray(data.ScopeOfWork) || data.ScopeOfWork.length === 0) {
    errors.ScopeOfWork = 'At least one scope of work item is required';
  }
  if (!Array.isArray(data.FeeItems) || data.FeeItems.length === 0) {
    errors.FeeItems = 'At least one fee item is required';
  }

  return {
    isValid: Object.keys(errors).length === 0,
    errors
  };
}

// ============================================================================
// FOLDER MANAGEMENT (unchanged)
// ============================================================================

function getOrCreateInvoiceFolders(invoiceRootFolder, clientName, projectCode, debugMode = false) {
  if (debugMode) {
    return {
      clientFolder: { getName: () => clientName, getId: () => 'debug-client-folder-id', getUrl: () => 'about:blank' },
      projectFolder: { getName: () => projectCode, getId: () => 'debug-project-folder-id', getUrl: () => 'about:blank', createFile: () => ({ getUrl: ()=>'about:blank'}) }
    };
  }

  const existingClientFolders = [];
  const clientFolders = invoiceRootFolder.getFolders();
  while (clientFolders.hasNext()) existingClientFolders.push(clientFolders.next());

  let clientFolder = existingClientFolders.find(folder => folder.getName() === clientName);
  if (!clientFolder) clientFolder = invoiceRootFolder.createFolder(clientName);

  const existingProjectFolders = clientFolder.getFolders();
  let projectFolder = null;
  while (existingProjectFolders.hasNext()) {
    const folder = existingProjectFolders.next();
    if (folder.getName() === projectCode) { projectFolder = folder; break; }
  }
  if (!projectFolder) projectFolder = clientFolder.createFolder(projectCode);

  return { clientFolder, projectFolder };
}

// ============================================================================
// DOCUMENT POPULATION (unchanged functionality)
// ============================================================================

function convertDocumentToPdf(doc, folderId) {
  const pdfBlob = doc.getAs('application/pdf');
  pdfBlob.setName(doc.getName() + '.pdf');

  const pdfFile = DriveApp.createFile(pdfBlob);
  const fileId = pdfFile.getId();

  const file = DriveApp.getFileById(fileId);
  const sourceFolder = DriveApp.getFileById(doc.getId()).getParents().next();
  const destinationFolder = DriveApp.getFolderById(folderId);

  destinationFolder.addFile(file);
  sourceFolder.removeFile(file);

  return pdfFile.getUrl();
}

function populateDocumentTemplate(doc, data, currencySymbol) {
  const body = doc.getBody();
  body.replaceText('{{Client}}', data.ClientLegalName);
  body.replaceText('{{Address}}', data.ClientAddress);
  body.replaceText('{{Tax_ID}}', data.ClientTaxId || 'N/A');

  body.replaceText('{{Invoice Reference}}', data.InvoiceReference);
  body.replaceText('{{Date Invoiced}}', Utilities.formatDate(data.InvoiceDate, Session.getScriptTimeZone(), 'dd/MM/yyyy'));
  body.replaceText('{{Notice}}', String(data.InvoiceDaysNotice));
  body.replaceText('{{Currency}}', data.InvoiceCurrency);

  body.replaceText('{{TotalAmount}}', currencySymbol + data.TotalAmount.toFixed(2));
  body.replaceText('{{Amount}}', currencySymbol + data.NetAmount.toFixed(2));
  body.replaceText('{{VAT}}', currencySymbol + data.VatAmount.toFixed(2));
  body.replaceText('{{VAT_Rate}}', (data.VatRate * 100).toFixed(1) + '%');

  insertBulletListAfterParagraph(doc, 'Scope of Work', data.ScopeOfWork);
  populateInvoiceFeeTable(doc, data.FeeItems, currencySymbol);
}

function insertBulletListAfterParagraph(doc, parentText, bulletItems) {
  if (!doc || typeof doc.getBody !== 'function') throw new Error('Invalid document object provided');
  if (!Array.isArray(bulletItems) || bulletItems.length === 0) throw new Error('bulletItems must be a non-empty array');
  if (typeof parentText !== 'string' || parentText.trim() === '') throw new Error('parentText must be a non-empty string');

  const body = doc.getBody();
  const paragraphs = body.getParagraphs();
  const bulletStyle = {
    [DocumentApp.Attribute.FONT_SIZE]: 12,
    [DocumentApp.Attribute.FOREGROUND_COLOR]: '#000000'
  };

  for (let i = 0; i < paragraphs.length; i++) {
    const paragraphText = paragraphs[i].getText();
    if (paragraphText === parentText) {
      bulletItems.forEach((bulletText, index) => {
        const insertPosition = i + 1 + index;
        const listItem = body.insertListItem(insertPosition, bulletText);
        listItem.setGlyphType(DocumentApp.GlyphType.BULLET);
        listItem.setAttributes(bulletStyle);
      });
      return;
    }
  }
  Logger.log(`Warning: Parent paragraph "${parentText}" not found in document`);
}

function populateInvoiceFeeTable(doc, feeRows, currencySymbol) {
  if (!doc || typeof doc.getBody !== 'function') throw new Error('Invalid document object provided');
  if (!Array.isArray(feeRows) || feeRows.length === 0) throw new Error('feeRows must be a non-empty array');
  if (typeof currencySymbol !== 'string') throw new Error('currencySymbol must be a string');

  const body = doc.getBody();
  const tables = body.getTables();
  if (tables.length === 0) throw new Error('Document must contain at least one table');

  const table = tables[0];
  const numRows = feeRows.length;
  const centerAlignStyle = { [DocumentApp.Attribute.HORIZONTAL_ALIGNMENT]: DocumentApp.HorizontalAlignment.CENTER };

  feeRows.forEach((feeEntry, index) => {
    const newRow = table.insertTableRow(1 + index);
    const cells = [
      newRow.appendTableCell(String(feeEntry.Description)),
      newRow.appendTableCell(String(feeEntry.Quantity)),
      newRow.appendTableCell(currencySymbol + String(feeEntry.UnitPrice)),
      newRow.appendTableCell(currencySymbol + String(feeEntry.SubTotal))
    ];
    cells.forEach(cell => cell.getChild(0).asParagraph().setAttributes(centerAlignStyle));
  });

  doc.saveAndClose();
  applyTableBorderStyling(doc, table, numRows, 4);
}

function applyTableBorderStyling(doc, table, rowCount, columnCount) {
  const docId = doc.getId();
  const body = doc.getBody();
  const tableIndex = body.getChildIndex(table);
  const startIndex = Docs.Documents.get(docId).body.content[tableIndex + 1].startIndex;

  const borderStyleRequest = {
    updateTableCellStyle: {
      tableCellStyle: {
        borderBottom: { dashStyle: 'SOLID', width: { magnitude: 1, unit: 'PT' }, color: { color: { rgbColor: { red: 0 } } } },
        borderRight: { dashStyle: 'SOLID', width: { magnitude: 0, unit: 'PT' }, color: { color: {} } },
        borderLeft:  { dashStyle: 'SOLID', width: { magnitude: 0, unit: 'PT' }, color: { color: {} } }
      },
      tableRange: {
        tableCellLocation: { tableStartLocation: { index: startIndex }, rowIndex: 1 },
        rowSpan: rowCount,
        columnSpan: columnCount
      },
      fields: 'borderBottom,borderRight,borderLeft'
    }
  };
  Docs.Documents.batchUpdate({ requests: [borderStyleRequest] }, docId);
}

function notifyDuplicateFile(clientName, filename, folderUrl) {
  const subject = `Duplicate Invoice File: ${filename}`;
  const body = `An invoice document with the same name already exists.\n\nClient: ${clientName}\nFilename: ${filename}\nFolder: ${folderUrl}\n\nPlease review and take appropriate action.`;
  // MailApp.sendEmail(INVOICE_CONFIG.ADMIN_EMAIL, subject, body);
  Logger.log(`Duplicate file notification sent: ${filename} - ${folderUrl} - ${clientName} `);
}

// ============================================================================
// DOCUMENT RENDERING (CHANGED: accepts logger; richer steps/errors)
// ============================================================================

function renderInvoiceDocument(data, docId, options = {}, logger) {
  const debugMode = options.debugMode || false;
  const localLog = logger || new ProgressLogger({ docId });

  try {
    localLog.step('Render: validate data');
    const validation = validateInvoiceData(data);
    if (!validation.isValid) {
      localLog.setOutcome(false, 'Validation failed', { errors: validation.errors });
      return {
        success: false,
        message: 'Validation failed',
        validationErrors: validation.errors
      };
    }

    if (debugMode) {
      localLog.info('Render: debug mode - skipping file ops');
      localLog.setOutcome(true, 'Debug OK');
      return {
        success: true,
        message: 'Debug mode: All validations passed. Document would be created successfully.',
        debugInfo: {
          documentId: docId,
          currency: data.InvoiceCurrency,
          totalAmount: data.TotalAmount,
          feeItemCount: data.FeeItems.length,
          scopeItemCount: data.ScopeOfWork.length,
          clientName: data.ClientLegalName,
          invoiceReference: data.InvoiceReference
        }
      };
    }

    if (!docId || typeof docId !== 'string') {
      throw new Error('Valid document ID is required');
    }

    localLog.step('Render: open template copy');
    const doc = DocumentApp.openById(docId);
    const currencySymbol = getCurrencySymbol(data.InvoiceCurrency) || '';

    localLog.step('Render: populate template placeholders and tables');
    populateDocumentTemplate(doc, data, currencySymbol);
    localLog.info('Render: population complete');

    localLog.step('Render: convert to PDF');
    const folderId = options.destinationFolderId ||
      DriveApp.getFileById(docId).getParents().next().getId();
    const pdfUrl = convertDocumentToPdf(doc, folderId);
    localLog.info('Render: PDF created', { pdfUrl });

    localLog.setOutcome(true, 'Invoice document created successfully', { pdfUrl });
    return { success: true, message: 'Invoice document created successfully', pdfUrl };

  } catch (error) {
    const norm = reportError(localLog, error, 'Error rendering invoice document');
    localLog.setOutcome(false, 'Error creating invoice document', { error: norm });
    return {
      success: false,
      message: 'Error creating invoice document: ' + error.message,
      validationErrors: { system: String(error) }
    };
  }
}

// Debug wrapper (unchanged interface)
function debugRenderInvoiceDocument(data, docId) {
  return renderInvoiceDocument(data, docId, { debugMode: true });
}

// ============================================================================
// INVOICE CREATION (CHANGED: centralized logging + receipt saving)
// ============================================================================

function createInvoice(invoiceData, options = {}) {
  const debugMode = options.debugMode || false;
  const overwriteExisting = options.overwriteExisting || false;

  // create a logger as early as possible with context (updated as we learn more)
  const ctx = {
    clientName: invoiceData && invoiceData.ClientLegalName,
    projectCode: invoiceData && invoiceData.ProjectCode,
    currency: invoiceData && invoiceData.InvoiceCurrency,
    invoiceReference: invoiceData && invoiceData.InvoiceReference,
  };
  const logger = new ProgressLogger(ctx);
  let projectFolder = null;
  let clientFolder  = null;
  let filename      = null;

  try {
    logger.step('Validate invoice data');
    const validation = validateInvoiceData(invoiceData);
    if (!validation.isValid) {
      logger.setOutcome(false, 'Validation failed', validation.errors);
      // No folder to save in, but still return detailed errors
      return {
        success: false,
        message: `Validation failed: ${Object.keys(validation.errors).map(k => `${k}: ${validation.errors[k]}`).join(', ')}`,
        details: { validationErrors: validation.errors }
      };
    }

    // Extract
    const clientName = invoiceData.ClientLegalName;
    const projectCode = invoiceData.ProjectCode;
    const invoiceDate = invoiceData.InvoiceDate;
    const invoiceReference = invoiceData.InvoiceReference;
    const currency = invoiceData.InvoiceCurrency;

    filename = generateInvoiceFilename(invoiceDate, invoiceReference);
    // update context with filename
    logger.context.filename = filename;

    logger.step('Select template based on currency');
    const templateId = getTemplateIdForCurrency(currency);

    if (debugMode) {
      logger.info('Debug mode: simulate folder/document/pdf creation');
      logger.setOutcome(true, 'Debug mode: Invoice would be created successfully.');
      return {
        success: true,
        message: 'Debug mode: All validations passed. Invoice ready for creation.',
        details: {
          templateId,
          filename,
          clientName,
          projectCode,
          currency,
          invoiceDate: invoiceDate.toISOString(),
          wouldCreateFolders: true,
          wouldCreateDocument: true,
          wouldGeneratePDF: true
        }
      };
    }

    logger.step('Get or create folder structure');
    const invoiceRootFolder = DriveApp.getFolderById(INVOICE_CONFIG.INVOICE_FOLDER_ID);
    const folders = getOrCreateInvoiceFolders(invoiceRootFolder, clientName, projectCode, false);
    clientFolder = folders.clientFolder;
    projectFolder = folders.projectFolder;
    logger.info('Folders ready', {
      clientFolder: clientFolder.getName(),
      projectFolder: projectFolder.getName()
    });

    logger.step('Check for existing file collision');
    const existingFile = findFileInFolder(projectFolder, filename);
    if (existingFile && !overwriteExisting) {
      logger.warn('Duplicate file exists; notifying admin and aborting', { filename });
      notifyDuplicateFile(clientName, filename, projectFolder.getUrl());

      // Save receipt before returning (duplicate case)
      const receipts = logger.saveReceipts(projectFolder, filename);
      logger.info('Receipt saved for duplicate case', receipts);

      logger.setOutcome(false, 'Duplicate file exists. Admin notified.');
      return {
        success: false,
        message: 'Duplicate file exists. Admin notified.',
        details: {
          filename,
          folderUrl: projectFolder.getUrl(),
          action: 'notification_sent',
          receiptTxtUrl: receipts.txtUrl,
          receiptJsonUrl: receipts.jsonUrl
        }
      };
    }

    logger.step('Create document from template');
    const template = DriveApp.getFileById(templateId);
    const documentCopy = template.makeCopy(filename, projectFolder);
    logger.info('Document copy created', { documentId: documentCopy.getId() });

    logger.step('Render invoice (populate + PDF)');
    const renderResult = renderInvoiceDocument(invoiceData, documentCopy.getId(), { destinationFolderId: projectFolder.getId() }, logger);

    if (!renderResult.success) {
      logger.warn('Render failed', { renderMessage: renderResult.message });
      const receipts = logger.saveReceipts(projectFolder, filename);
      logger.setOutcome(false, 'Failed to render invoice document', { documentId: documentCopy.getId() });

      return {
        success: false,
        message: 'Failed to render invoice document',
        details: {
          renderError: renderResult.message,
          documentId: documentCopy.getId(),
          receiptTxtUrl: receipts.txtUrl,
          receiptJsonUrl: receipts.jsonUrl
        }
      };
    }

    logger.step('Finalize invoice creation');
    const pdfUrl = renderResult.pdfUrl;
    const docUrl = documentCopy.getUrl();
    logger.info('Invoice created', { pdfUrl, docUrl });

    // Save success receipt
    const receipts = logger.saveReceipts(projectFolder, filename);
    logger.info('Receipt saved', receipts);

    logger.setOutcome(true, 'Invoice created successfully');
    return {
      success: true,
      message: 'Invoice created successfully',
      pdfUrl,
      documentUrl: docUrl,
      details: {
        filename,
        clientName,
        projectCode,
        currency,
        folderPath: `${clientFolder.getName()}/${projectFolder.getName()}`,
        receiptTxtUrl: receipts.txtUrl,
        receiptJsonUrl: receipts.jsonUrl
      }
    };

  } catch (error) {
    const norm = reportError(logger, error, 'Error creating invoice', 'critical');

    // If we have a project folder and filename, save a receipt there even for failures.
    let receiptUrls = {};
    try {
      if (projectFolder && filename) {
        receiptUrls = logger.saveReceipts(projectFolder, filename);
        logger.info('Receipt saved for failure case', receiptUrls);
      }
    } catch (saveErr) {
      logger.warn('Failed to save receipt after error', { saveErr: String(saveErr) });
    }

    logger.setOutcome(false, 'Error creating invoice', { error: norm });
    return {
      success: false,
      message: `Error creating invoice: ${error.message}`,
      details: Object.assign({ error: String(error) }, receiptUrls)
    };
  }
}

// Debug wrapper (unchanged interface)
function debugCreateInvoice(invoiceData) {
  return createInvoice(invoiceData, { debugMode: true });
}

// ============================================================================
// WEB APP ENTRY POINTS (CHANGED: use centralized logging + better messages)
// ============================================================================

function doPost(e) {
  const logger = new ProgressLogger({ entryPoint: 'doPost' });
  let parsedPayload = null;

  try {
    logger.step('Auth: validate API key');
    const apiKey = e.parameter.apiKey;
    if (!apiKey || !Object.values(API_KEYS).includes(apiKey)) {
      logger.setOutcome(false, 'Unauthorized: Invalid or missing API key');
      return ContentService
        .createTextOutput(JSON.stringify({ success: false, message: 'Unauthorized: Invalid or missing API key' }))
        .setMimeType(ContentService.MimeType.JSON);
    }

    logger.step('Parse request JSON');
    parsedPayload = JSON.parse(e.postData.contents);

    // Accept both "invoiceData" and "InvoicePayload" for compatibility
    const invoiceData = parsedPayload.invoiceData || parsedPayload.InvoicePayload;
    const options = parsedPayload.options || {};

    logger.info('Normalize date fields');
    if (invoiceData.InvoiceDate && typeof invoiceData.InvoiceDate === 'string') {
      invoiceData.InvoiceDate = new Date(invoiceData.InvoiceDate);
    }

    logger.step('Create invoice');
    const result = createInvoice(invoiceData, options);

    logger.setOutcome(true, 'Handled doPost successfully');
    return ContentService
      .createTextOutput(JSON.stringify(result))
      .setMimeType(ContentService.MimeType.JSON);

  } catch (error) {
    const norm = reportError(logger, error, 'doPost handler failure', 'critical');
    logger.setOutcome(false, 'doPost failed', { error: norm, payloadEchoed: !!parsedPayload });

    // Return error response (without Drive receipt because we might not know folder/filename here)
    const errorResponse = {
      success: false,
      message: 'Error processing request: ' + error.message,
      details: {
        error: String(error),
        payload: parsedPayload
      }
    };

    return ContentService
      .createTextOutput(JSON.stringify(errorResponse))
      .setMimeType(ContentService.MimeType.JSON);
  }
}

function doGet(e) {
  const response = {
    success: true,
    message: 'Invoice Generator API is running',
    version: '1.1.0',
    endpoints: { POST: 'Send invoice data as JSON to create invoice', GET: 'API status check' },
    debugMode: e && e.parameter && e.parameter.debug === 'true'
  };
  return ContentService
    .createTextOutput(JSON.stringify(response))
    .setMimeType(ContentService.MimeType.JSON);
}

Notes / behaviors you’ll see

The logger writes both .txt and .json receipts. The JSON is great for downstream parsing; the TXT is for humans.
For duplicate filenames, we still emit a receipt (status: not created) in the target project folder.
For errors after folders are known, we also write a receipt there. If the failure occurs before we know the folder, we just return the error (no receipt is possible).
Admin email is commented out; flip it on if you want email notifications.

If you want the receipt to also include rendered template field values or the full input payload, say the word and I’ll tuck those into the context and timeline entries.

Here’s the only change you need — create the PDF directly in the destination folder instead of root, and drop the add/remove logic:

// REPLACE the existing convertDocumentToPdf with this version
function convertDocumentToPdf(doc, folderId) {
  const pdfBlob = doc.getAs('application/pdf');
  pdfBlob.setName(doc.getName() + '.pdf');

  const destinationFolder = DriveApp.getFolderById(folderId);
  const pdfFile = destinationFolder.createFile(pdfBlob); // create directly in destination

  return pdfFile.getUrl();
}

Got it — here’s a focused list of redundancies in the current script (no code changes yet):

Double validation of invoice data

Where: createInvoice() validates, then renderInvoiceDocument() validates again.
Why redundant: createInvoice() already blocks bad input before calling renderInvoiceDocument().

Unused date helper while formatting inline

Where: formatInvoiceDate() exists, but populateDocumentTemplate() formats the date with Utilities.formatDate(...) directly.
Why redundant: Two ways to do the same thing; the helper isn’t used.

Template selection function not used (hardcoded template)

Where: getTemplateIdForCurrency() exists, but createInvoice() sets templateId = INVOICE_CONFIG.TEMPLATE_ID_GBP //getTemplateIdForCurrency(currency);
Why redundant: Currency-based selection function is bypassed; dead logic.

Re-validation inside lower-level render helpers

Where: insertBulletListAfterParagraph() and populateInvoiceFeeTable() both validate inputs (e.g., non-empty arrays) that validateInvoiceData() already enforces.
Why redundant: Defensive, but duplicates top-level validation.

Duplicate debug pathways

Where: debugCreateInvoice() just calls createInvoice(..., { debugMode: true }) and debugRenderInvoiceDocument() calls renderInvoiceDocument(..., { debugMode: true }).
Why redundant: Two wrappers whose behavior could be achieved by passing the flag to the primary functions directly.

Mixed/duplicate request payload field names

Where: doPost() expects InvoicePayload, while the example comment shows "invoiceData".
Why redundant: Maintaining both field names or mismatched docs vs code leads to duplicated parsing/compat handling.

Duplicate date normalization responsibility

Where: doPost() converts InvoiceDate string → Date, but createInvoice() can be called directly (e.g., from other entry points) without normalization.
Why redundant: Multiple places need to remember to normalize the date; work is duplicated or inconsistently applied.

Redundant logging vs structured progress receipt (if using centralized logger)

Where: Many Logger.log(...) calls in functions (getOrCreateInvoiceFolders, renderInvoiceDocument, etc.) in addition to any centralized progress log (if present).
Why redundant: Two parallel logging streams for the same events.

Duplicate notification signal for duplicates

Where: createInvoice() both logs and calls notifyDuplicateFile() (which itself logs, and has a commented-out MailApp.sendEmail).
Why redundant: Multiple log lines for the same event; email path commented out but still maintained.

Currency symbol already looked up once but re-derived per render

Where: renderInvoiceDocument() calls getCurrencySymbol(...) even though currency is known and could be passed from the caller.
Why redundant: Minor, but repeat work across layers.

If you want, I can prune exactly these with the smallest possible diffs in a follow-up pass.

Perfect—here are the only logging clean-ups to remove redundancy (keep everything else as-is).

1) `getOrCreateInvoiceFolders(...)`

Delete the informational Logger.log lines; higher-level flows already record these via the centralized logger.

if (!clientFolder) {
    Logger.log(`Creating client folder: ${clientName}`);
    clientFolder = invoiceRootFolder.createFolder(clientName);
} else {
    Logger.log(`Client folder exists: ${clientName}`);
}
if (!clientFolder) {
    clientFolder = invoiceRootFolder.createFolder(clientName);
}

if (!projectFolder) {
    Logger.log(`Creating project folder: ${projectCode}`);
    projectFolder = clientFolder.createFolder(projectCode);
} else {
    Logger.log(`Project folder exists: ${projectCode}`);
}
if (!projectFolder) {
    projectFolder = clientFolder.createFolder(projectCode);
}

2) `notifyDuplicateFile(...)`

Remove its internal Logger.log to avoid double-logging; the caller already logs and the receipt records the event.

function notifyDuplicateFile(clientName, filename, folderUrl) {
  const subject = `Duplicate Invoice File: ${filename}`;
  const body = `An invoice document with the same name already exists.\n\n` +
               `Client: ${clientName}\n` +
               `Filename: ${filename}\n` +
               `Folder: ${folderUrl}\n\n` +
               `Please review and take appropriate action.`;

  // MailApp.sendEmail(INVOICE_CONFIG.ADMIN_EMAIL, subject, body);
  Logger.log(`Duplicate file notification sent: ${filename} - ${folderUrl} - ${clientName} `);
  // MailApp.sendEmail(INVOICE_CONFIG.ADMIN_EMAIL, subject, body);
}

3) (If present in your current file) old logs inside rendering

If your renderInvoiceDocument(...) still has these legacy lines, delete them—central logger already captures these steps.

Logger.log('Document template populated successfully');
Logger.log('PDF created successfully: ' + pdfUrl);

That’s it—after these removals, all status/progress will be captured by your centralized progress logger/receipt, without parallel Logger.log noise.

Great—here are minimal diffs to eliminate nested/duplicate validations so that all invoice-data validation happens only in createInvoice() via validateInvoiceData(). Internal helpers keep only structural/invariant checks (e.g., doc/table presence), not business-data validation.

1) `renderInvoiceDocument(...)`

Remove the re-validation of data and the validation-related return branches. Assume caller already validated.

function renderInvoiceDocument(data, docId, options = {}, logger) {
  const debugMode = options.debugMode || false;
  const localLog = logger || new ProgressLogger({ docId });

  try {
    localLog.step('Render: validate data');
    const validation = validateInvoiceData(data);
    if (!validation.isValid) {
      localLog.setOutcome(false, 'Validation failed', { errors: validation.errors });
      return {
        success: false,
        message: 'Validation failed',
        validationErrors: validation.errors
      };
    }

    if (debugMode) {
      localLog.info('Render: debug mode - skipping file ops');
      localLog.setOutcome(true, 'Debug OK');
      return {
        success: true,
        message: 'Debug mode: All validations passed. Document would be created successfully.',
        debugInfo: {
          documentId: docId,
          currency: data.InvoiceCurrency,
          totalAmount: data.TotalAmount,
          feeItemCount: data.FeeItems.length,
          scopeItemCount: data.ScopeOfWork.length,
          clientName: data.ClientLegalName,
          invoiceReference: data.InvoiceReference
        }
      };
    }

    if (!docId || typeof docId !== 'string') {
      throw new Error('Valid document ID is required');
    }

Add a short comment to the top of the function (optional but helpful):

/**
/**
 * Renders an invoice document from template, populating it with data.
 * NOTE: Assumes caller has already validated business data via validateInvoiceData().
 */

2) `insertBulletListAfterParagraph(...)`

Remove business-data validations (bulletItems non-empty, parentText non-empty). Keep only the structural doc guard.

function insertBulletListAfterParagraph(doc, parentText, bulletItems) {
    // Input validation
    if (!doc || typeof doc.getBody !== 'function') {
        throw new Error('Invalid document object provided');
    }

    if (!Array.isArray(bulletItems) || bulletItems.length === 0) {
        throw new Error('bulletItems must be a non-empty array');
    }

    if (typeof parentText !== 'string' || parentText.trim() === '') {
        throw new Error('parentText must be a non-empty string');
    }

(If bulletItems might be empty in some templates, the loop below will simply insert nothing—which is fine if upstream validation already guaranteed content.)

3) `populateInvoiceFeeTable(...)`

Remove fee/currency validations tied to business data. Keep only structural checks (doc and presence of at least one table in the template).

function populateInvoiceFeeTable(doc, feeRows, currencySymbol) {
    // Input validation
    if (!doc || typeof doc.getBody !== 'function') {
        throw new Error('Invalid document object provided');
    }

    if (!Array.isArray(feeRows) || feeRows.length === 0) {
        throw new Error('feeRows must be a non-empty array');
    }

    if (typeof currencySymbol !== 'string') {
        throw new Error('currencySymbol must be a string');
    }

    const body = doc.getBody();
    const tables = body.getTables();

    if (tables.length === 0) {
        throw new Error('Document must contain at least one table');
    }

4) (For clarity) Add a single-source-of-truth note to `createInvoice(...)`

No behavior change—just a comment to document intent.

/**
 * Creates an invoice document from template and generates a PDF.
 * Single source of truth for business-data validation: calls validateInvoiceData() once here.
 */
function createInvoice(invoiceData, options = {}) {

With these changes:

Only createInvoice() performs business-data validation via validateInvoiceData().
Rendering and helpers assume validated data and only guard against document/template structure issues.

Here’s a clean way to split it up for Apps Script readability, with no imports needed and minimal risk of name collisions.

Option A — Plain Apps Script, namespaced modules (recommended)

Apps Script loads all .gs/.js files into one global scope. Use a single global namespace (e.g., IG) that each file extends. That keeps things tidy and avoids collisions.

File layout (suggested order & contents)

00_config.gs

API_KEYS, INVOICE_CONFIG
(Optional) small helpers like getCurrencySymbol, formatInvoiceDate
var IG = IG || {}; // create the namespace once

10_types.doc.js (comments only, for docs)

JSDoc typedefs: InvoiceData, InvoiceFeeEntry, InvoiceCreationResult, InvoiceOptions
No runtime code; just documentation

20_logging.gs

IG.ProgressLogger class
IG.reportError(logger, err, contextMessage, severity)

30_validation.gs

IG.validateInvoiceData = function(data) { ... }

40_drive.fs.gs

Drive/folder helpers:
- IG.findFileInFolder(folder, filename)
- IG.getOrCreateInvoiceFolders(root, clientName, projectCode, debugMode)
- IG.convertDocumentToPdf(doc, folderId)
- IG.notifyDuplicateFile(clientName, filename, folderUrl)

50_doc.render.gs

Document population & styling:
- IG.insertBulletListAfterParagraph(doc, parentText, bulletItems)
- IG.populateInvoiceFeeTable(doc, feeRows, currencySymbol)
- IG.applyTableBorderStyling(doc, table, rowCount, columnCount)
- IG.populateDocumentTemplate(doc, data, currencySymbol)
- IG.renderInvoiceDocument(data, docId, options, logger)
  (assumes validation already done in create step)

60_invoice.core.gs

Orchestration:
- IG.getTemplateIdForCurrency(currency)
- IG.generateInvoiceFilename(date, ref)
- IG.createInvoice(invoiceData, options)
- IG.debugCreateInvoice(invoiceData)

90_webapp.entry.gs

Entry points only (keep thin):
- function doPost(e) { return IG.Web.doPost(e); }
- function doGet(e) { return IG.Web.doGet(e); }
Implemented in:
- IG.Web = { doPost(e) { ... }, doGet(e) { ... } } (defined in this same file)

How each file extends the same namespace

At the top of every file (except 00_config.gs which creates it), add:

var IG = IG || {};

Then attach functions/classes:

IG.validateInvoiceData = function(data) { ... };
IG.ProgressLogger = function(ctx) { ... };

Why this works well

Logical separation: config, validation, drive ops, doc rendering, orchestration, web entry.
No cyclic headaches: Orchestrator (createInvoice) calls down into render/drive; lower layers don’t call back up.
Apps Script-friendly: No import/export; just one IG object extended across files.

Option B — TypeScript + clasp (bonus, if you want typings & tests)

If you use clasp + build step:

Folder structure

/src
  /config.ts
  /types.ts
  /logging.ts
  /validation.ts
  /drive.ts
  /doc.ts
  /invoice.ts
  /web.ts
appsscript.json
package.json
tsconfig.json
.clasp.json

Export functions from modules and re-export a small set of global entry points in web.ts (e.g., global.doPost = doPost;).
Use Jest for unit tests on pure functions (validation, filename, doc text transforms).
Build step bundles to /dist or pushes compiled .gs via clasp push.

Pros: typing, tests, cleaner deps.
Cons: build step required.

Tiny usage sketch (Option A)

90_webapp.entry.gs

var IG = IG || {};

IG.Web = IG.Web || {};

IG.Web.doPost = function(e) {
  const logger = new IG.ProgressLogger({ entry: 'doPost' });
  // auth, parse, normalize date, then:
  return ContentService
    .createTextOutput(JSON.stringify(IG.createInvoice(invoiceData, options)))
    .setMimeType(ContentService.MimeType.JSON);
};

function doPost(e) { return IG.Web.doPost(e); }
function doGet(e)  { return IG.Web.doGet(e);  }

60_invoice.core.gs

var IG = IG || {};

IG.createInvoice = function(invoiceData, options) {
  const logger = new IG.ProgressLogger({ /* context */ });
  const validation = IG.validateInvoiceData(invoiceData);
  // rest of orchestration...
};

This gives you crisp files, predictable dependencies, and easy navigation—without changing any external behavior.

Short answer: you can’t. The Google Docs API only accepts points ("PT") for table border widths. If you want to think in pixels, convert px → pt yourself and pass points to the API.

Rule of thumb (CSS pixel @ 96 DPI):

1 px = 0.75 pt
pt = px × 0.75

Example drop-in helper + usage in your applyTableBorderStyling request:

function pxToPt(px) { return Math.round(px * 0.75 * 100) / 100; } // keep 2 decimals

// e.g., 2px bottom border
const borderStyleRequest = {
  updateTableCellStyle: {
    tableCellStyle: {
      borderBottom: {
        dashStyle: 'SOLID',
        width: { magnitude: pxToPt(2), unit: 'PT' }, // 2px → 1.5pt
        color: { color: { rgbColor: { red: 0, green: 0, blue: 0 } } }
      }
    },
    tableRange: { /* ... */ },
    fields: 'borderBottom'
  }
};

Notes:

Docs renders in points; exact on-screen thickness can vary by zoom/display.
Stick to simple fractions (e.g., 1px → 0.75pt, 2px → 1.5pt, 3px → 2.25pt) to avoid rounding surprises.

Make the first cell of each row have Italic style and the second bold

function populateBankTable(table, bankInfo) {

// Define cell alignment style once
const centerAlignStyle = {
    [DocumentApp.Attribute.HORIZONTAL_ALIGNMENT]: DocumentApp.HorizontalAlignment.CENTER
};

// Insert and populate rows
bankInfo.forEach((bankEntry, index) => {
    const newRow = table.insertTableRow(1 + index);

    // Append cells in the correct order with proper formatting
    const cells = [
        newRow.appendTableCell(String(bankEntry.Label)),
        newRow.appendTableCell(String(bankEntry.Info)),
    ];

    // Apply center alignment to all cells
    cells.forEach(cell => {
        cell.getChild(0).asParagraph().setAttributes(centerAlignStyle);
    });
});

}

Here’s a drop-in replacement that keeps center alignment and styles the first cell italic and the second cell bold:

function populateBankTable(table, bankInfo) {
  const centerAlignStyle = {
    [DocumentApp.Attribute.HORIZONTAL_ALIGNMENT]: DocumentApp.HorizontalAlignment.CENTER
  };

  bankInfo.forEach((bankEntry, index) => {
    const newRow = table.insertTableRow(1 + index);

    const cells = [
      newRow.appendTableCell(String(bankEntry.Label)), // first cell → italic
      newRow.appendTableCell(String(bankEntry.Info))   // second cell → bold
    ];

    // Apply alignment and text styles
    // First cell: italic
    const p0 = cells[0].getChild(0).asParagraph();
    p0.setAttributes(centerAlignStyle);
    p0.editAsText().setItalic(true);

    // Second cell: bold
    const p1 = cells[1].getChild(0).asParagraph();
    p1.setAttributes(centerAlignStyle);
    p1.editAsText().setBold(true);
  });
}

Yes—both are valid in Google Apps Script’s DocumentApp.Text class.

editAsText() on a Paragraph returns a Text element.
Text supports:
- setBold(boolean) and setBold(startOffset, endOffset, boolean)
- setItalic(boolean) and setItalic(startOffset, endOffset, boolean)

Your usage:

const p = cell.getChild(0).asParagraph();
const t = p.editAsText();
t.setItalic(true); // whole paragraph italic
t.setBold(true);   // whole paragraph bold

(You can also apply them to ranges using the overloads if needed.)

this function has started crashing on the last line.

Make it more robust, and explain with comments what it does. if there is an alternative way to write it, go for it

function applyTableBorderStyling(doc, table, rowCount, columnCount) { const docId = doc.getId(); const body = doc.getBody(); const tableIndex = body.getChildIndex(table); const startIndex = Docs.Documents.get(docId).body.content[tableIndex + 1].startIndex;

const borderStyleRequest = {
    updateTableCellStyle: {
        tableCellStyle: {
            borderBottom: {
                dashStyle: 'SOLID',
                width: { magnitude: 1, unit: 'PT' },
                color: { color: { rgbColor: { red: 0 } } }
            },
            borderRight: {
                dashStyle: 'SOLID',
                width: { magnitude: 0, unit: 'PT' },
                color: { color: {} }
            },
            borderLeft: {
                dashStyle: 'SOLID',
                width: { magnitude: 0, unit: 'PT' },
                color: { color: {} }
            }
        },
        tableRange: {
            tableCellLocation: { tableStartLocation: { index: startIndex }, rowIndex: 1 },
            rowSpan: rowCount,
            columnSpan: columnCount
        },
        fields: 'borderBottom,borderRight,borderLeft'
    }
};

Docs.Documents.batchUpdate({ requests: [borderStyleRequest] }, docId);

}

Here’s a robust, drop-in replacement that avoids the brittle tableIndex + 1 trick (the usual cause of the crash) and explains each step.
It finds the correct Docs API startIndex for the specific table by matching the nth table in the Apps Script DOM to the nth table in the Docs API structure. It also guards inputs and wraps the API call.

/**
 * Apply custom borders to a contiguous block of table cells using the Google Docs API.
 *
 * Why this version is more robust:
 * - Stops relying on `body.content[tableIndex + 1]`. That offset is brittle and can be wrong,
 *   causing invalid indices and API errors on batchUpdate.
 * - Finds the exact table's startIndex by matching the *nth* table in DocumentApp's body
 *   to the *nth* table in the Docs API's body.content (both are ordered).
 * - Validates inputs, clamps spans, and safely wraps the batchUpdate call.
 *
 * @param {GoogleAppsScript.Document.Document} doc
 * @param {GoogleAppsScript.Document.Table} table
 * @param {number} rowCount     Number of rows to style (>=1)
 * @param {number} columnCount  Number of columns to style (>=1)
 */
function applyTableBorderStyling(doc, table, rowCount, columnCount) {
  // ---- Basic guards (fail fast with helpful messages)
  if (!doc || typeof doc.getId !== 'function') {
    throw new Error('applyTableBorderStyling: invalid Document provided.');
  }
  if (!table || typeof table.getNumRows !== 'function') {
    throw new Error('applyTableBorderStyling: invalid Table provided.');
  }

  // Clamp spans to at least 1, and to the actual table size to avoid out-of-range updates.
  var maxRows = table.getNumRows();
  var maxCols = table.getRow(0).getNumCells();
  var safeRowSpan = Math.max(1, Math.min(Number(rowCount) || 1, maxRows));
  var safeColSpan = Math.max(1, Math.min(Number(columnCount) || 1, maxCols));

  var docId = doc.getId();

  // ---- Determine which table (ordinal) we are styling in the document
  // Count how many tables appear in the document *before* this one.
  var body = doc.getBody();
  var childCount = body.getNumChildren();
  var targetTableOrdinal = -1; // 0-based among tables only
  var seenTables = 0;

  for (var i = 0; i < childCount; i++) {
    var child = body.getChild(i);
    if (child.getType && child.getType() === DocumentApp.ElementType.TABLE) {
      if (child === table) {
        targetTableOrdinal = seenTables; // found the ordinal of this table
        break;
      }
      seenTables++;
    }
  }

  if (targetTableOrdinal < 0) {
    throw new Error('applyTableBorderStyling: could not locate target table ordinal.');
  }

  // ---- Fetch Docs API structure and locate the same ordinal table there
  var docStruct;
  try {
    docStruct = Docs.Documents.get(docId); // Advanced Google Services: "Docs API" must be enabled
  } catch (e) {
    throw new Error('applyTableBorderStyling: Docs API call failed. Ensure Advanced Docs service is enabled. ' + e);
  }

  // Collect all TABLE structural elements from the Docs API body, in order.
  var content = (docStruct && docStruct.body && docStruct.body.content) || [];
  var tableNodes = [];
  for (var c = 0; c < content.length; c++) {
    var se = content[c];
    if (se && se.table) {
      tableNodes.push(se); // this `se` has .startIndex and .endIndex
    }
  }

  if (targetTableOrdinal >= tableNodes.length) {
    throw new Error('applyTableBorderStyling: table ordinal out of range for Docs API body.');
  }

  // This is the structural element for our exact table
  var targetTableNode = tableNodes[targetTableOrdinal];
  var tableStartIndex = targetTableNode.startIndex; // robust start index

  // ---- Build the update request
  // Set a solid bottom border (1pt), and zero left/right borders for a clean column look.
  var borderStyleRequest = {
    updateTableCellStyle: {
      tableCellStyle: {
        borderBottom: {
          dashStyle: 'SOLID',
          width: { magnitude: 1, unit: 'PT' },
          color: { color: { rgbColor: { red: 0, green: 0, blue: 0 } } }
        },
        borderRight: {
          dashStyle: 'SOLID',
          width: { magnitude: 0, unit: 'PT' },
          color: { color: {} }
        },
        borderLeft: {
          dashStyle: 'SOLID',
          width: { magnitude: 0, unit: 'PT' },
          color: { color: {} }
        }
      },
      tableRange: {
        tableCellLocation: {
          tableStartLocation: { index: tableStartIndex },
          rowIndex: 1 // skip header row (assumes header at row 0)
        },
        rowSpan: safeRowSpan,
        columnSpan: safeColSpan
      },
      fields: 'borderBottom,borderRight,borderLeft'
    }
  };

  // ---- Execute safely
  try {
    Docs.Documents.batchUpdate({ requests: [borderStyleRequest] }, docId);
  } catch (e2) {
    // Provide a clear message; common causes are wrong indices or disabled API.
    throw new Error('applyTableBorderStyling: batchUpdate failed: ' + e2);
  }
}

Why the old version crashed

body.content[tableIndex + 1] is not reliable. The Apps Script getChildIndex(table) counts all body children (paragraphs, tables, etc.). In the Docs API, body.content also mixes paragraphs and tables, but the +1 offset often points to the next structural element, not the table, leading to an invalid startIndex or a missing .startIndex (undefined), which then crashes at batchUpdate.

Alternative approach (when you don’t need Docs API styling)

Unfortunately, DocumentApp does not expose granular table border styling (width/sides) like the Docs API does. If your goal is only visual separation (e.g., row dividers), you can:

Insert a thin “spacer” row with an underline style in its paragraph(s), or
Add a bottom paragraph border effect using characters/lines (a hack, not true borders).

For real borders, the Docs API approach above is the correct (and now robust) method.

totally fair questions — let’s clean this up and skip the brittle gymnastics.

Why it bailed “when there are no other tables”

It shouldn’t bail just because it’s the first table. The real failure usually happens because the table object you pass is stale (e.g., you called doc.saveAndClose() and/or re-opened the doc; the old Table reference no longer matches anything). Then the lookup can’t find the table and throws.

Why all the complexity

The Docs API requires a startIndex (a low-level cursor position) to target a table. Apps Script’s DocumentApp doesn’t expose that index, so we have to map from “the N-th table” to that index via the Docs API. That’s the necessary bridge.

A simpler, robust approach: address the table by ordinal (default: the first table)

Don’t pass a Table object around (it can go stale).
Just say which table number you mean (0 = first), then:
1. Get the N-th table’s size via DocumentApp to clamp spans.
2. Get the N-th table’s startIndex via the Docs API.
3. Apply the borders.

Drop-in function (safe defaults, heavy comments):

/**
 * Apply borders to a specific table identified by its ordinal (0 = first table).
 * This avoids stale Table references and the brittle child-index math.
 *
 * @param {GoogleAppsScript.Document.Document} doc
 * @param {number} tableOrdinal  0-based index of the table in the document (default 0)
 * @param {number} rowStart      first row to style (default 1 to skip header)
 * @param {number} rowSpan       number of rows to style (clamped to table size)
 * @param {number} colSpan       number of columns to style (clamped to table size)
 */
function applyTableBorderStylingByOrdinal(doc, tableOrdinal, rowStart, rowSpan, colSpan) {
  if (!doc || typeof doc.getId !== 'function') {
    throw new Error('applyTableBorderStylingByOrdinal: invalid Document.');
  }

  // Defaults: operate on the first table, from row 1 (skip header), cover all rows/cols.
  var ord = Math.max(0, Number(tableOrdinal) || 0);
  var body = doc.getBody();
  var tables = body.getTables();
  if (!tables || tables.length === 0) {
    throw new Error('applyTableBorderStylingByOrdinal: document has no tables.');
  }
  if (ord >= tables.length) {
    throw new Error('applyTableBorderStylingByOrdinal: table ordinal out of range.');
  }

  // Table size for safe clamping
  var targetTable = tables[ord];
  var totalRows = targetTable.getNumRows();
  var totalCols = targetTable.getRow(0).getNumCells();

  var startRow = Math.max(0, Number(rowStart) || 1); // default: skip header row 0
  var maxRowSpan = Math.max(1, Math.min(Number(rowSpan) || (totalRows - startRow), totalRows - startRow));
  var maxColSpan = Math.max(1, Math.min(Number(colSpan) || totalCols, totalCols));

  // Fetch Docs API structure and pick the N-th table’s structural element
  var docId = doc.getId();
  var docStruct = Docs.Documents.get(docId); // Advanced Docs service must be enabled
  var content = (docStruct && docStruct.body && docStruct.body.content) || [];
  var tableNodes = [];
  for (var i = 0; i < content.length; i++) {
    if (content[i] && content[i].table) tableNodes.push(content[i]);
  }
  if (ord >= tableNodes.length) {
    throw new Error('applyTableBorderStylingByOrdinal: Docs API table ordinal out of range.');
  }
  var tableStartIndex = tableNodes[ord].startIndex;

  // Build the update: solid 1pt bottom border; remove left/right for a clean look
  var req = {
    updateTableCellStyle: {
      tableCellStyle: {
        borderBottom: {
          dashStyle: 'SOLID',
          width: { magnitude: 1, unit: 'PT' },
          color: { color: { rgbColor: { red: 0, green: 0, blue: 0 } } }
        },
        borderRight: {
          dashStyle: 'SOLID',
          width: { magnitude: 0, unit: 'PT' },
          color: { color: {} }
        },
        borderLeft: {
          dashStyle: 'SOLID',
          width: { magnitude: 0, unit: 'PT' },
          color: { color: {} }
        }
      },
      tableRange: {
        tableCellLocation: {
          tableStartLocation: { index: tableStartIndex },
          rowIndex: startRow
        },
        rowSpan: maxRowSpan,
        columnSpan: maxColSpan
      },
      fields: 'borderBottom,borderRight,borderLeft'
    }
  };

  // Execute
  Docs.Documents.batchUpdate({ requests: [req] }, docId);
}

Usage examples

Style all rows of the first table except header:

applyTableBorderStylingByOrdinal(doc, 0, 1); // rowSpan/colSpan auto-clamped

Style first 5 rows and all columns of the second table:

applyTableBorderStylingByOrdinal(doc, 1, 1, 5);

tl;dr

We’re not “exiting because there are no tables before” — the real problem is stale references.
The “crazy stuff” is just the minimal necessary step to translate “table #N” into the startIndex the Docs API demands. Addressing by ordinal makes this simple and robust.

You’re right—that error is on me. I defaulted to rowIndex: 1 (skip header), but if your table only has one row total (header only), rowIndex 1 is out of range. Here’s a fixed, robust version that clamps the start row and span safely and simply no-ops when there are no target rows to style.

/**
 * Apply borders to a specific table identified by its ordinal (0 = first).
 * Robust against header-only tables and short tables: clamps row/col ranges
 * and safely returns without calling Docs API if there’s nothing to style.
 *
 * @param {GoogleAppsScript.Document.Document} doc
 * @param {number} tableOrdinal  0-based table index in the document (default 0)
 * @param {number} [rowStart=1]  first row to style; defaults to 1 to skip header,
 *                               but will auto-fallback to 0 if the table has only 1 row
 * @param {number} [rowSpan]     number of rows to style; defaults to “all rows from rowStart”
 * @param {number} [colSpan]     number of columns to style; defaults to “all columns”
 */
function applyTableBorderStylingByOrdinal(doc, tableOrdinal, rowStart, rowSpan, colSpan) {
  if (!doc || typeof doc.getId !== 'function') {
    throw new Error('applyTableBorderStylingByOrdinal: invalid Document.');
  }

  var body = doc.getBody();
  var tables = body.getTables();
  if (!tables || tables.length === 0) {
    // Nothing to do
    return;
  }

  var ord = Math.max(0, Number(tableOrdinal) || 0);
  if (ord >= tables.length) {
    // Nothing to do
    return;
  }

  var targetTable = tables[ord];
  var totalRows = targetTable.getNumRows();
  if (totalRows === 0) {
    // Nothing to do
    return;
  }
  var totalCols = targetTable.getRow(0).getNumCells();

  // --- Determine safe row start
  // Default to skipping header (1), but fall back to 0 if there isn’t a data row.
  var desiredStart = (typeof rowStart === 'number') ? rowStart : 1;
  var safeStart = desiredStart;

  if (desiredStart >= totalRows) {
    // e.g., table has only 1 row (index 0), so 1 is invalid -> fall back to 0
    safeStart = Math.max(0, totalRows - 1);
  }
  if (safeStart < 0) safeStart = 0;

  // --- Determine safe row span
  var availableRows = totalRows - safeStart; // rows we can style starting at safeStart
  if (availableRows <= 0) {
    // Nothing to style; avoid Docs API error
    return;
  }
  var desiredRowSpan = (typeof rowSpan === 'number' && rowSpan > 0) ? rowSpan : availableRows;
  var safeRowSpan = Math.max(1, Math.min(desiredRowSpan, availableRows));

  // --- Determine safe column span
  var desiredColSpan = (typeof colSpan === 'number' && colSpan > 0) ? colSpan : totalCols;
  var safeColSpan = Math.max(1, Math.min(desiredColSpan, totalCols));

  // --- Map ordinal table to Docs API startIndex
  var docId = doc.getId();
  var docStruct = Docs.Documents.get(docId); // Advanced Docs service must be enabled
  var content = (docStruct && docStruct.body && docStruct.body.content) || [];
  var tableNodes = [];
  for (var i = 0; i < content.length; i++) {
    if (content[i] && content[i].table) tableNodes.push(content[i]);
  }
  if (ord >= tableNodes.length) {
    // Couldn’t map—safely exit
    return;
  }
  var tableStartIndex = tableNodes[ord].startIndex;

  // --- Build and execute the update (bottom border 1pt; no left/right)
  var req = {
    updateTableCellStyle: {
      tableCellStyle: {
        borderBottom: {
          dashStyle: 'SOLID',
          width: { magnitude: 1, unit: 'PT' },
          color: { color: { rgbColor: { red: 0, green: 0, blue: 0 } } }
        },
        borderRight: {
          dashStyle: 'SOLID',
          width: { magnitude: 0, unit: 'PT' },
          color: { color: {} }
        },
        borderLeft: {
          dashStyle: 'SOLID',
          width: { magnitude: 0, unit: 'PT' },
          color: { color: {} }
        }
      },
      tableRange: {
        tableCellLocation: {
          tableStartLocation: { index: tableStartIndex },
          rowIndex: safeStart
        },
        rowSpan: safeRowSpan,
        columnSpan: safeColSpan
      },
      fields: 'borderBottom,borderRight,borderLeft'
    }
  };

  Docs.Documents.batchUpdate({ requests: [req] }, docId);
}

What changed / why it fixes your error

If the table has only 1 row (header-only), we now auto-fallback rowStart to 0 (the header row) or quietly do nothing if there are zero stylable rows (so we never hit the “row index out of range” error).
We clamp rowSpan and colSpan to the table’s actual size, preventing Docs API validation errors.
If we can’t map the ordinal to a Docs API table node (rare), we return instead of throwing.

How to call it

Style all rows except header when present, but still safe for header-only tables:

applyTableBorderStylingByOrdinal(doc, 0, 1);

Style entire table (including header), regardless of size:

applyTableBorderStylingByOrdinal(doc, 0, 0);

If you prefer the original signature (passing the Table object), I can adapt the same guards to that version too.

You’re right to be annoyed. The “range extends outside the table” error usually happens when the Docs API sees fewer rows/columns than we asked for (often due to header-only tables or merged cells). Here’s a robust replacement for your function that:

Maps your DocumentApp.Table → the exact Docs API table node.
Clamps the row start (we keep your “start at row 1” intent but fall back to 0 if needed).
Computes effective columns per row using column spans (so merged cells don’t break the request).
Clamps rowSpan/columnSpan to what actually exists before the API call.
No-ops safely if there’s nothing to style.

Drop this in place of your current function:

/**
 * Apply row-bottom borders to a table region using the Docs API, safely.
 * - Starts at rowIndex 1 (skip header) when possible; falls back to 0 for header-only tables.
 * - Clamps rowSpan/columnSpan to the real table size, accounting for merged cells.
 *
 * @param {GoogleAppsScript.Document.Document} doc
 * @param {GoogleAppsScript.Document.Table} table
 * @param {number} rowCount     Number of rows to style (from the start row). If falsy, styles all available rows.
 * @param {number} columnCount  Number of columns to style (from column 0). If falsy, styles all available columns.
 */
function applyTableBorderStyling(doc, table, rowCount, columnCount) {
  if (!doc || typeof doc.getId !== 'function') throw new Error('applyTableBorderStyling: invalid Document.');
  if (!table || typeof table.getNumRows !== 'function') throw new Error('applyTableBorderStyling: invalid Table.');

  var docId = doc.getId();
  var body = doc.getBody();

  // --- Find this table's ordinal among all tables (avoid brittle childIndex+1 math)
  var tables = body.getTables();
  if (!tables || tables.length === 0) return; // nothing to do

  var ordinal = -1;
  for (var i = 0; i < tables.length; i++) {
    if (tables[i] === table) { ordinal = i; break; }
  }
  if (ordinal < 0) return; // couldn't match (stale reference) → safely do nothing

  // --- Get the Docs API structure and locate the same ordinal table node
  var docStruct = Docs.Documents.get(docId); // Advanced Docs service must be enabled
  var content = (docStruct && docStruct.body && docStruct.body.content) || [];
  var tableNodes = [];
  for (var ci = 0; ci < content.length; ci++) {
    if (content[ci] && content[ci].table) tableNodes.push(content[ci]);
  }
  if (ordinal >= tableNodes.length) return; // mismatch → safely stop

  var node = tableNodes[ordinal];
  var apiTable = node.table;
  var apiRows = apiTable.rows || [];
  var totalApiRows = apiRows.length;
  if (totalApiRows === 0) return;

  // --- Choose a safe start row: prefer 1 (skip header), but fall back to 0 if there’s only one row.
  var startRow = (totalApiRows > 1) ? 1 : 0;

  // --- Determine available rows from startRow
  var availableRows = totalApiRows - startRow;
  if (availableRows <= 0) return;

  // --- Desired row span: honor caller, but clamp to what's available
  var desiredRowSpan = (typeof rowCount === 'number' && rowCount > 0) ? rowCount : availableRows;
  var safeRowSpan = Math.max(1, Math.min(desiredRowSpan, availableRows));

  // --- Compute effective columns across the targeted row range, accounting for merged cells
  function effectiveColsForRow(row) {
    var cells = row.tableCells || [];
    var sum = 0;
    for (var k = 0; k < cells.length; k++) {
      var span = (cells[k].columnSpan && cells[k].columnSpan.magnitude) || cells[k].columnSpan || 1;
      sum += (typeof span === 'number' && span > 0) ? span : 1;
    }
    return sum;
  }
  var minEffectiveCols = Infinity;
  for (var r = startRow; r < startRow + safeRowSpan; r++) {
    minEffectiveCols = Math.min(minEffectiveCols, effectiveColsForRow(apiRows[r]));
  }
  if (!isFinite(minEffectiveCols) || minEffectiveCols <= 0) return;

  // --- Desired column span: honor caller, but clamp to the minimum effective columns in the range
  var desiredColSpan = (typeof columnCount === 'number' && columnCount > 0) ? columnCount : minEffectiveCols;
  var safeColSpan = Math.max(1, Math.min(desiredColSpan, minEffectiveCols));

  // If after clamping there is still nothing valid to style, exit quietly
  if (safeRowSpan <= 0 || safeColSpan <= 0) return;

  // --- Build the update (solid bottom border 1pt; no left/right)
  var req = {
    updateTableCellStyle: {
      tableCellStyle: {
        borderBottom: {
          dashStyle: 'SOLID',
          width: { magnitude: 1, unit: 'PT' },
          color: { color: { rgbColor: { red: 0, green: 0, blue: 0 } } }
        },
        borderRight: {
          dashStyle: 'SOLID',
          width: { magnitude: 0, unit: 'PT' },
          color: { color: {} }
        },
        borderLeft: {
          dashStyle: 'SOLID',
          width: { magnitude: 0, unit: 'PT' },
          color: { color: {} }
        }
      },
      tableRange: {
        tableCellLocation: {
          tableStartLocation: { index: node.startIndex },
          rowIndex: startRow,
          columnIndex: 0
        },
        rowSpan: safeRowSpan,
        columnSpan: safeColSpan
      },
      fields: 'borderBottom,borderRight,borderLeft'
    }
  };

  // --- Execute
  Docs.Documents.batchUpdate({ requests: [req] }, docId);
}

Why this fixes your error

We compute the real row/column limits from the Docs API (not assumptions from DocumentApp), including merged cells.
We clamp the requested range to those limits, so the range can’t extend past the table.
If anything doesn’t line up (e.g., stale Table reference), we quietly no-op instead of throwing, so your invoice flow doesn’t explode.