formula-parser-payroll 2.1.0

package/dist/database/payroll-formula.service.js

@@ -0,0 +1,794 @@
+"use strict";
+/**
+ * NestJS Payroll Formula Parser Service
+ *
+ * This service provides database-integrated formula parsing.
+ * It fetches employee data and component values from the database
+ * and then uses the core formula parser.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PayrollFormulaService = void 0;
+const formula_engine_1 = require("../formula-engine");
+const formula_parser_1 = require("../formula-parser");
+const helpers_1 = require("./helpers");
+/**
+ * Payroll Formula Parser Service
+ *
+ * Use this service when you need to parse formulas with just formula and empId.
+ * This service handles fetching employee data and component values from the database.
+ *
+ * @example
+ * ```typescript
+ * const service = new PayrollFormulaService();
+ * const result = await service.parseByEmpId({
+ *   formula: 'SALARY * 0.1 + AL_001',
+ *   empId: 'EMP001',
+ *   auth: authContext,
+ * });
+ * console.log(result.result);
+ * ```
+ */
+class PayrollFormulaService {
+    constructor() {
+        // Performance optimization: Cache for reserved words and component lists
+        this.reservedWordsCache = new Map();
+        this.componentListCache = new Map();
+        this.CACHE_TTL = 5 * 60 * 1000; // 5 minutes cache
+        this.CHUNK_SIZE = 50; // Process employees in chunks of 50 to prevent memory overflow
+    }
+    /**
+     * Parse formula by employee ID(s)
+     * This method fetches all required data from database and evaluates the formula
+     *
+     * When listEmpId is provided: returns Record<empId, hasil>
+     * When empId is provided: returns FormulaParseResultLegacy
+     */
+    async parseByEmpId(input) {
+        const { formula: rawFormula, empId, listEmpId, auth } = input;
+        console.log('>>> PayrollFormulaService.parseByEmpId CALLED', { rawFormula, listEmpIdLen: listEmpId?.length });
+        // If listEmpId is provided, process multiple employees IN PARALLEL WITH CHUNKING
+        if (listEmpId && listEmpId.length > 0) {
+            const resultData = {};
+            // OPTIMIZATION: Process employees in chunks to prevent memory overflow
+            // For large employee lists (1000+), processing all at once can overwhelm memory
+            const chunks = this.chunkArray(listEmpId, this.CHUNK_SIZE);
+            console.log(`>>> Processing ${listEmpId.length} employees in ${chunks.length} chunks of ${this.CHUNK_SIZE}`);
+            for (const chunk of chunks) {
+                // Process each chunk in parallel
+                const promises = chunk.map(emp => this.parseForSingleEmployee(rawFormula, emp, auth));
+                const results = await Promise.all(promises);
+                // Map results back to employee IDs
+                chunk.forEach((emp, idx) => {
+                    resultData[emp] = results[idx].hasil;
+                });
+            }
+            return resultData;
+        }
+        // Single employee processing
+        if (!empId) {
+            return {
+                hasil: 0,
+                message: 'Either empId or listEmpId must be provided',
+            };
+        }
+        return this.parseForSingleEmployee(rawFormula, empId, auth);
+    }
+    /**
+     * Check if a formula is valid
+     * This ports the logic from payroll-server's formulaValidtyCheck
+     */
+    async formulaValidityCheck(input) {
+        const { formula: rawFormula, auth } = input;
+        try {
+            if (!rawFormula) {
+                throw new Error('Formula cannot be empty');
+            }
+            const formula = rawFormula.replace(/"/g, `'`);
+            // 1. Get reserved words from DB
+            const getWordList = await this.getReservedWords(auth);
+            const reservedWords = new Set(getWordList.words2); // words2 contains allowdeductCode
+            // 2. Extra keywords that are always valid
+            // Added more from server logic
+            const extraValid = new Set([
+                'IF', 'AND', 'OR', 'NOT', 'TRUE', 'FALSE', 'SALARY',
+                'MIN', 'MAX', 'MOD', 'ROUND', 'ROUNDDOWN', 'ROUNDUP', 'TRUNC',
+                'DATE', 'DAYS', 'TODAY', 'DATETIME_NOW', 'ISDATE', 'DAY', 'MONTH', 'YEAR',
+                'DAYSINMONTH', 'DAYOFWEEK', 'ISNUMERIC', 'HOUR', 'MINUTE', 'SECOND',
+                'DATEDIFF', 'DATEADD', 'CONCATENATE', 'CONCATENATESKIPNULL', 'FINDLIST', 'CREATEDATE',
+                'LENGTHOFSERVICE', 'CHILDDEPENDENTS',
+                'CUSTOMFIELD', // Base word
+            ]);
+            // 3. Handle String Literals first!
+            // Anything inside quotes should NOT be validated as a variable.
+            // Replace quoted strings with placeholders
+            const formulaNoStrings = formula.replace(/'[^']*'/g, 'STRING_LITERAL');
+            // 4. Extract all alpha tokens (potential variables/functions)
+            // This regex matches words like GRADE, CUSTOMFIELD5, AL_001, etc.
+            // We use the formula WITHOUT strings to check tokens.
+            const tokens = formulaNoStrings.match(/\b[a-zA-Z_][a-zA-Z0-9_]*\b/g) || [];
+            for (const token of tokens) {
+                const upperToken = token.toUpperCase();
+                // Skip placeholders
+                if (upperToken === 'STRING_LITERAL')
+                    continue;
+                // Skip if it's a reserved word or a known function/keyword
+                if (reservedWords.has(upperToken) || extraValid.has(upperToken)) {
+                    continue;
+                }
+                // Special handling for CUSTOMFIELD1 - CUSTOMFIELD10
+                if (/^CUSTOMFIELD\d+$/.test(upperToken)) {
+                    continue;
+                }
+                // Skip if it's a payroll component code (AL_xxx, DE_xxx, NE_xxx)
+                if (/^(AL|DE|NE)_\d+$/i.test(token)) {
+                    continue;
+                }
+                // Potential typo or invalid keyword
+                throw new Error(`Failed not defined reserve word or formula is not valid: ${token}`);
+            }
+            // 5. Final syntax check by attempting a dummy parse
+            // We need to replace all valid tokens with dummy values, otherwise the parser will complain about #NAME?
+            let dummyFormula = formula;
+            // Sort tokens by length (desc) to avoid partial replacement
+            const sortedTokens = [...new Set(tokens)].sort((a, b) => b.length - a.length);
+            for (const token of sortedTokens) {
+                // Replace token with "0" (as string) or 0 (as number)
+                // Since we don't know the type, let's use 0 which is safe for most math/logic
+                // Use regex for word boundary replacement
+                const regex = new RegExp(`\\b${token}\\b`, 'g');
+                dummyFormula = dummyFormula.replace(regex, '0');
+            }
+            // Restore string literals (they were replaced by 'STRING_LITERAL' in token check step? No, that was a copy)
+            // wait, 'tokens' were extracted from 'formulaNoStrings'.
+            // 'dummyFormula' starts from original 'formula' (which has strings).
+            // If we replace tokens in original formula, we might accidentally replace content inside strings!
+            // But we know 'tokens' are extracted from outside strings.
+            // Safer approach:
+            // We already validated all tokens are "legal".
+            // The only reason to run parseFormula is to check parentheses balance, commas in functions, etc.
+            // So let's run parseFormula on the dummy-filled string.
+            // But we must be careful not to replace text inside quotes. 
+            // E.g. IF(GRADE = "GRADE", ...) -> The second GRADE is string.
+            // Strategy:
+            // 1. Hide strings placeholders
+            const regexKutip = /'[^']*'/g;
+            let match;
+            const placeholders = {};
+            let pIdx = 0;
+            let formulaWithPlaceholders = formula.replace(regexKutip, (m) => {
+                const key = `__STR_${pIdx++}__`;
+                placeholders[key] = m; // equivalent to "0" for parsing safety?
+                // Actually, for syntax check, a string literal is just a value.
+                // Let's replace it with "0" (string "0") to be safe? 
+                // Or just keep it as a string literal but simple one like 'S'
+                return "'S'";
+            });
+            // 2. Replace variables in non-string part with 0
+            // We must NOT replace Functions (IF, MAX, etc) with 0. Only variables.
+            const functionsToPreserve = new Set([
+                'IF', 'AND', 'OR', 'NOT',
+                'MIN', 'MAX', 'MOD', 'ROUND', 'ROUNDDOWN', 'ROUNDUP', 'TRUNC',
+                'DATE', 'DAYS', 'TODAY', 'DATETIME_NOW', 'ISDATE', 'DAY', 'MONTH', 'YEAR',
+                'DAYSINMONTH', 'DAYOFWEEK', 'ISNUMERIC', 'HOUR', 'MINUTE', 'SECOND',
+                'DATEDIFF', 'DATEADD', 'CONCATENATE', 'CONCATENATESKIPNULL', 'FINDLIST', 'CREATEDATE',
+                'LENGTHOFSERVICE'
+            ]);
+            for (const token of sortedTokens) {
+                const upperToken = token.toUpperCase();
+                // If it is a function, DO NOT replace it.
+                if (functionsToPreserve.has(upperToken)) {
+                    continue;
+                }
+                // `TRUE` and `FALSE` are boolean literals, parser handles them. No need to replace.
+                if (upperToken === 'TRUE' || upperToken === 'FALSE') {
+                    continue;
+                }
+                const regex = new RegExp(`\\b${token}\\b`, 'g');
+                formulaWithPlaceholders = formulaWithPlaceholders.replace(regex, '0');
+            }
+            // 3. Test parse
+            try {
+                const result = (0, formula_engine_1.parseFormula)(formulaWithPlaceholders);
+                // We ignore the result value, just checking for throw
+            }
+            catch (parseError) {
+                // If it's #NAME?, it means we missed a token?
+                // Any other error is syntax error.
+                const err = parseError;
+                if (err.message.includes('#NAME?')) {
+                    // This can happen if hot-formula-parser doesn't support a specific function 
+                    // that we thought was valid in extraValid (e.g. LENGTHOFSERVICE is custom registered).
+                    // But Custom functions SHOULD be registered in formula-engine.ts
+                    // If we validated token as legal, but parser says #NAME, it might be a function name we didn't replace?
+                    // Functions like 'IF', 'ROUND' are in extraValid. 
+                    // We should NOT replace function names with 0!
+                    // Ah! My token extraction logic extracts everything including IF, ROUND.
+                    // But my validation loop "continues" (skips error) if it is in extraValid.
+                    // So 'IF' is in tokens?
+                    // Yes: const tokens = formulaNoStrings.match(...)
+                    // Wait, I should ONLY replace "Variables", not "Functions".
+                    throw parseError; // Rethrow to see details if needed
+                }
+                throw parseError;
+            }
+            return { result: 'success' };
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    /**
+     * Clear all caches (useful for testing or when data is updated)
+     */
+    clearCache() {
+        this.reservedWordsCache.clear();
+        this.componentListCache.clear();
+    }
+    /**
+     * Clear cache for specific company
+     */
+    clearCacheForCompany(companyId, taxCountry) {
+        const cacheKey = `${companyId}_${taxCountry}`;
+        this.reservedWordsCache.delete(cacheKey);
+        this.componentListCache.delete(cacheKey);
+    }
+    /**
+     * Parse formula for a single employee
+     * Internal method used by parseByEmpId
+     */
+    async parseForSingleEmployee(rawFormula, empId, auth) {
+        try {
+            // Normalize formula
+            const formula = rawFormula.replace(/"/g, `'`);
+            // OPTIMIZATION: Pre-extract actual component codes from formula
+            // This is more accurate than just checking if components exist
+            const componentMatches = formula.match(/\b(AL_\d+|DE_\d+|NE_\d+|SALARY)\b/gi) || [];
+            const uniqueComponents = new Set(componentMatches.map(c => c.toUpperCase()));
+            const hasComponents = uniqueComponents.size > 0;
+            let allCompo = [];
+            let empCompo = [];
+            let compoCodes = [];
+            if (hasComponents) {
+                // Step 1: Get list of component codes, but filter by what's actually in formula
+                const listCompo = await this.getComponentList(auth);
+                // OPTIMIZATION: Only include components that are actually in the formula
+                compoCodes = listCompo
+                    .map(v => v.allowdeductCode)
+                    .filter(code => uniqueComponents.has(code.toUpperCase()));
+                console.log(`>>> Detected ${uniqueComponents.size} unique components in formula, ${compoCodes.length} exist in DB`);
+            }
+            // Step 2: Fetch all required data in parallel
+            // Only fetch components if they are actually in the formula
+            const currencyCode = (0, helpers_1.getCurrencyCode)(auth.userData.taxCountry);
+            const [allCompoRes, empCompoRes, empData, getWordList] = await Promise.all([
+                hasComponents ? this.getAllComponents(auth, compoCodes, currencyCode) : Promise.resolve([]),
+                hasComponents ? this.getEmployeeComponents(auth, empId, compoCodes, currencyCode) : Promise.resolve([]),
+                this.getEmployeeData(auth, empId),
+                this.getReservedWords(auth),
+            ]);
+            allCompo = allCompoRes;
+            empCompo = empCompoRes;
+            if (!empData) {
+                return {
+                    hasil: 0,
+                    message: `Employee not found: ${empId}`,
+                };
+            }
+            // Step 3: Build object values from components
+            const objectVal = {};
+            if (hasComponents) {
+                // Initialize all components to 0
+                for (const compo of allCompo) {
+                    objectVal[compo.allowdeductCode] = '0';
+                }
+                // Initialize employee components to 0 first
+                for (const empCompoItem of empCompo) {
+                    objectVal[empCompoItem.allowdeductCode] = '0';
+                }
+                // OPTIMIZATION: Chunked parallel decryption for employee components
+                // Process in chunks of 20 to prevent overwhelming the system
+                const itemsToDecrypt = empCompo.filter(item => item.allowdeductValue);
+                if (itemsToDecrypt.length > 0) {
+                    const DECRYPT_CHUNK_SIZE = 20;
+                    const decryptChunks = this.chunkArray(itemsToDecrypt, DECRYPT_CHUNK_SIZE);
+                    for (const chunk of decryptChunks) {
+                        const decryptPromises = chunk.map(async (item) => ({
+                            code: item.allowdeductCode,
+                            value: await (0, helpers_1.decryptValue)(item.allowdeductValue, auth, empId)
+                        }));
+                        const decryptedValues = await Promise.all(decryptPromises);
+                        for (const { code, value } of decryptedValues) {
+                            objectVal[code] = value.toString();
+                        }
+                    }
+                }
+            }
+            // Step 4: Extract required words from formula
+            const requiredWords = this.extractRequiredWordsFromFormula(formula, getWordList.words2);
+            // Step 5: Batch load organizational data
+            const dataCache = await this.batchLoadFormulaData(auth, empData, requiredWords);
+            // Step 6: Process all words using cached data
+            const employeeDataConverted = this.convertToEmployeeData(empData);
+            const orgDataConverted = this.convertToOrganizationalData(dataCache);
+            for (const word of requiredWords) {
+                // Process personal data
+                (0, formula_parser_1.processPersonalData)(word, objectVal, employeeDataConverted);
+                // Process organizational data
+                (0, formula_parser_1.processOrganizationalData)(word, objectVal, orgDataConverted, formula);
+                // Process custom fields
+                (0, formula_parser_1.processCustomFields)(word, objectVal, orgDataConverted);
+            }
+            // Step 7: Handle formula replacement (same as original logic)
+            let processedFormula = formula;
+            // Handle quoted strings
+            const regexKutip = /\"(.*?)\"/g;
+            let match;
+            const objectX = {};
+            let arr = 0;
+            const replacements = {};
+            while ((match = regexKutip.exec(processedFormula))) {
+                replacements[`${match[1]}`] = 'PART' + arr;
+                objectX['PART' + arr] = `${match[1]}`;
+                arr++;
+            }
+            const hasReplacements = Object.values(replacements).some(value => value !== undefined && value !== '');
+            if (hasReplacements) {
+                const regex = new RegExp(Object.keys(replacements).join('|'), 'g');
+                processedFormula = processedFormula.replace(regex, m => replacements[m]);
+            }
+            // Extract and replace keywords
+            const formula2 = processedFormula.match(/[a-zA-Z0-9_]+|[+\-*/]/g) || [];
+            let keys = Object.keys(objectVal);
+            keys = (0, formula_parser_1.sortKeyByLengthDesc)(keys);
+            // Build replacement map
+            const replacementMap = new Map();
+            for (const wordnya of formula2) {
+                if (keys.includes(wordnya) && wordnya !== 'LENGTHOFSERVICE' && !replacementMap.has(wordnya)) {
+                    replacementMap.set(wordnya, objectVal[wordnya].toString());
+                }
+            }
+            // Single-pass replacement
+            if (replacementMap.size > 0) {
+                const pattern = Array.from(replacementMap.keys())
+                    .map(word => `\\b${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`)
+                    .join('|');
+                const regex = new RegExp(pattern, 'g');
+                processedFormula = processedFormula.replace(regex, m => replacementMap.get(m) || m);
+            }
+            // Restore quoted strings
+            const keys2 = Object.keys(objectX);
+            if (keys2.length > 0) {
+                keys2.forEach(key => {
+                    processedFormula = processedFormula.replace(new RegExp(key, 'g'), `${objectX[key]}`);
+                });
+            }
+            // Step 8: Parse the formula
+            const result = (0, formula_engine_1.parseFormula)(processedFormula);
+            // console.log('\n=== DEBUG PAYROLL-FORMULA-PARSER ===');
+            // console.log('Emp ID:', empId);
+            // console.log('Raw Formula:', rawFormula);
+            // console.log('Processed Formula:', processedFormula);
+            // console.log('Result:', result);
+            // console.log('Resolved Variables:', JSON.stringify(objectVal, null, 2));
+            // console.log('====================================\n');
+            return {
+                hasil: result,
+                message: 'success',
+            };
+        }
+        catch (error) {
+            console.log(error);
+            throw error;
+        }
+    }
+    /**
+     * Parse formula for multiple employees
+     */
+    async parseForMultipleEmployees(formula, empIds, auth) {
+        const results = {};
+        for (const empId of empIds) {
+            results[empId] = await this.parseForSingleEmployee(formula, empId, auth);
+        }
+        return results;
+    }
+    // ==================== Private Methods ====================
+    /**
+     * Get list of component codes
+     */
+    async getComponentList(auth) {
+        // OPTIMIZATION: Cache component list (rarely changes)
+        const cacheKey = `${auth.userData.companyId}_${auth.userData.taxCountry}`;
+        const cached = this.componentListCache.get(cacheKey);
+        if (cached && (Date.now() - cached.timestamp < this.CACHE_TTL)) {
+            return cached.data;
+        }
+        let query = `
+      SELECT allowdeduct_code as allowdeductCode
+      FROM tpympayallowdeduct
+      WHERE company_id = ?
+        AND (
+          (allowdeduct_code LIKE 'AL_%' AND allowdeducttype = 'A' AND allowdeduct_code REGEXP 'AL_[0-9]+')
+          OR (allowdeduct_code LIKE 'DE_%' AND allowdeducttype = 'D' AND allowdeduct_code REGEXP 'DE_[0-9]+')
+          OR (allowdeduct_code LIKE 'NE_%' AND allowdeducttype = 'N' AND allowdeduct_code REGEXP 'NE_[0-9]+')
+          OR allowdeduct_code = 'SALARY'
+        )
+    `;
+        if (auth.userData.taxCountry === 'TH') {
+            query += ` AND allowdeduct_code NOT IN ('NE_002', 'NE_003')`;
+        }
+        const result = await auth.connFin.query(query, [auth.userData.companyId]);
+        // Cache the result
+        this.componentListCache.set(cacheKey, { data: result, timestamp: Date.now() });
+        return result;
+    }
+    /**
+     * Get all components for company
+     */
+    async getAllComponents(auth, compoCodes, currencyCode) {
+        if (compoCodes.length === 0)
+            return [];
+        const placeholders = compoCodes.map(() => '?').join(',');
+        const query = `
+      SELECT allowdeduct_code as allowdeductCode
+      FROM tpympayallowdeduct
+      WHERE company_id = ?
+        AND allowdeduct_code IN (${placeholders})
+        AND currency_code = ?
+    `;
+        return auth.connFin.query(query, [auth.userData.companyId, ...compoCodes, currencyCode]);
+    }
+    /**
+     * Get employee component values
+     */
+    async getEmployeeComponents(auth, empId, compoCodes, currencyCode) {
+        if (compoCodes.length === 0)
+            return [];
+        const placeholders = compoCodes.map(() => '?').join(',');
+        const query = `
+      SELECT allowdeduct_code as allowdeductCode, allowdeduct_value as allowdeductValue
+      FROM tpydempallowdeduct
+      WHERE emp_id = ?
+        AND company_id = ?
+        AND allowdeduct_code IN (${placeholders})
+        AND currency_code = ?
+    `;
+        return auth.connFin.query(query, [empId, auth.userData.companyId, ...compoCodes, currencyCode]);
+    }
+    /**
+     * OPTIMIZATION: Batch get employee components for multiple employees
+     * This reduces database roundtrips when processing multiple employees
+     */
+    async getBatchEmployeeComponents(auth, empIds, compoCodes, currencyCode) {
+        if (empIds.length === 0 || compoCodes.length === 0)
+            return new Map();
+        const empPlaceholders = empIds.map(() => '?').join(',');
+        const compoPlaceholders = compoCodes.map(() => '?').join(',');
+        const query = `
+      SELECT emp_id as empId, allowdeduct_code as allowdeductCode, allowdeduct_value as allowdeductValue
+      FROM tpydempallowdeduct
+      WHERE emp_id IN (${empPlaceholders})
+        AND company_id = ?
+        AND allowdeduct_code IN (${compoPlaceholders})
+        AND currency_code = ?
+    `;
+        const results = await auth.connFin.query(query, [...empIds, auth.userData.companyId, ...compoCodes, currencyCode]);
+        // Group by employee ID
+        const grouped = new Map();
+        for (const row of results) {
+            if (!grouped.has(row.empId)) {
+                grouped.set(row.empId, []);
+            }
+            grouped.get(row.empId).push({
+                allowdeductCode: row.allowdeductCode,
+                allowdeductValue: row.allowdeductValue,
+            });
+        }
+        return grouped;
+    }
+    /**
+     * Get employee data with relations
+     */
+    async getEmployeeData(auth, empId) {
+        const query = `
+      SELECT 
+        ec.emp_id as empId,
+        ec.emp_no as empNo,
+        ec.start_date as startDate,
+        ec.end_date as endDate,
+        ec.position_id as positionId,
+        ec.cost_code as costCode,
+        ec.grade_code as gradeCode,
+        ec.work_location_code as workLocationCode,
+        ec.job_status_code as jobStatusCode,
+        ecg.join_date as joinDate,
+        ecg.fulljoin_date as fulljoinDate,
+        ecg.permanent_date as permanentDate,
+        ecg.pension_date as pensionDate,
+        ecg.terminate_date as terminateDate,
+        ep.gender as gender,
+        edp.birthdate as birthdate,
+        edp.maritalstatus as maritalstatus,
+        edp.religion_code as religionCode,
+        ejs.jobstatusname_en as jobstatusnameEn
+      FROM teodempcompany ec
+      LEFT JOIN teodempcompanygroup ecg ON ec.emp_id = ecg.emp_id
+      LEFT JOIN teomemppersonal ep ON ec.emp_id = ep.emp_id
+      LEFT JOIN teodemppersonal edp ON ec.emp_id = edp.emp_id
+      LEFT JOIN teomjobstatus ejs ON ec.job_status_code = ejs.jobstatuscode AND ec.company_id = ejs.company_id
+      WHERE ec.emp_id = ? AND ec.company_id = ?
+    `;
+        const results = await auth.connFin.query(query, [empId, auth.userData.companyId]);
+        return results[0] || null;
+    }
+    /**
+     * OPTIMIZATION: Batch get employee data for multiple employees
+     * This reduces database roundtrips significantly
+     */
+    async getBatchEmployeeData(auth, empIds) {
+        if (empIds.length === 0)
+            return new Map();
+        const placeholders = empIds.map(() => '?').join(',');
+        const query = `
+      SELECT 
+        ec.emp_id as empId,
+        ec.emp_no as empNo,
+        ec.start_date as startDate,
+        ec.end_date as endDate,
+        ec.position_id as positionId,
+        ec.cost_code as costCode,
+        ec.grade_code as gradeCode,
+        ec.work_location_code as workLocationCode,
+        ec.job_status_code as jobStatusCode,
+        ecg.join_date as joinDate,
+        ecg.fulljoin_date as fulljoinDate,
+        ecg.permanent_date as permanentDate,
+        ecg.pension_date as pensionDate,
+        ecg.terminate_date as terminateDate,
+        ep.gender as gender,
+        edp.birthdate as birthdate,
+        edp.maritalstatus as maritalstatus,
+        edp.religion_code as religionCode,
+        ejs.jobstatusname_en as jobstatusnameEn
+      FROM teodempcompany ec
+      LEFT JOIN teodempcompanygroup ecg ON ec.emp_id = ecg.emp_id
+      LEFT JOIN teomemppersonal ep ON ec.emp_id = ep.emp_id
+      LEFT JOIN teodemppersonal edp ON ec.emp_id = edp.emp_id
+      LEFT JOIN teomjobstatus ejs ON ec.job_status_code = ejs.jobstatuscode AND ec.company_id = ejs.company_id
+      WHERE ec.emp_id IN (${placeholders}) AND ec.company_id = ?
+    `;
+        const results = await auth.connFin.query(query, [...empIds, auth.userData.companyId]);
+        // Map by employee ID
+        const mapped = new Map();
+        for (const row of results) {
+            mapped.set(row.empId, row);
+        }
+        return mapped;
+    }
+    /**
+     * Get reserved words list for formula processing
+     */
+    async getReservedWords(auth) {
+        // OPTIMIZATION: Cache reserved words (rarely changes, huge performance boost!)
+        const cacheKey = `${auth.userData.companyId}_${auth.userData.taxCountry}`;
+        const cached = this.reservedWordsCache.get(cacheKey);
+        if (cached && (Date.now() - cached.timestamp < this.CACHE_TTL)) {
+            return cached.data;
+        }
+        const query = `
+      SELECT word
+      FROM tsfmreserveword
+      WHERE (ISNULL(taxcountry) OR taxcountry = '' OR taxcountry = ?)
+        AND (company_id = 1 OR company_id = ?)
+        AND module IN ('GENERAL', 'PAYROLL')
+        AND (category = 'EMPLOYEE' OR category = 'PAYFORMULA' OR category = 'CLAIMFORMULA')
+      GROUP BY word
+    `;
+        const results = await auth.connFin.query(query, [auth.userData.taxCountry, auth.userData.companyId]);
+        const words2 = results.map((r) => r.word);
+        const result = {
+            words2,
+            arrayAcr: [],
+            claimTypes2: [],
+            attStatuses: [],
+            leaveTypes: [],
+            payvarMaster: [],
+            arrayDiscp: [],
+            attintfWord: [],
+        };
+        // Cache the result
+        this.reservedWordsCache.set(cacheKey, { data: result, timestamp: Date.now() });
+        return result;
+    }
+    /**
+     * Extract required words from formula
+     */
+    extractRequiredWordsFromFormula(formula, wordList) {
+        const required = new Set();
+        if (!formula)
+            return required;
+        for (const word of wordList) {
+            if (formula.includes(word)) {
+                required.add(word);
+            }
+        }
+        return required;
+    }
+    /**
+     * Batch load all required data for formula parsing
+     */
+    async batchLoadFormulaData(auth, empData, requiredWords) {
+        const cache = {};
+        const queries = [];
+        const queryMap = [];
+        // Position data
+        if ((0, helpers_1.needsPositionData)(requiredWords) && empData.positionId) {
+            queryMap.push('position');
+            queries.push(auth.conn.query(`
+        SELECT p.pos_name_en as posNameEn, p.pos_code as posCode,
+               d.pos_name_en as deptNameEn, d.pos_code as deptCode
+        FROM teomposition p
+        LEFT JOIN teomposition d ON p.dept_id = d.position_id AND p.company_id = d.company_id
+        WHERE p.position_id = ? AND p.company_id = ?
+      `, [empData.positionId, auth.userData.companyId]));
+        }
+        // Cost Center data
+        if ((0, helpers_1.needsCostCenterData)(requiredWords) && empData.costCode) {
+            queryMap.push('costCenter');
+            queries.push(auth.conn.query(`
+        SELECT costcenter_code as costcenterCode, costcenter_name_en as costcenterNameEn
+        FROM teomcostcenter
+        WHERE costcenter_code = ? AND company_id = ?
+      `, [empData.costCode, auth.userData.companyId]));
+        }
+        // Grade data
+        if ((0, helpers_1.needsGradeData)(requiredWords) && empData.gradeCode) {
+            queryMap.push('grade');
+            queries.push(auth.conn.query(`
+        SELECT grade_code as gradeCode, grade_name as gradeName
+        FROM teomjobgrade
+        WHERE grade_code = ? AND company_id = ?
+      `, [empData.gradeCode, auth.userData.companyId]));
+        }
+        // Work Location data
+        if ((0, helpers_1.needsWorkLocationData)(requiredWords) && empData.workLocationCode) {
+            queryMap.push('workLocation');
+            queries.push(auth.conn.query(`
+        SELECT worklocation_code as worklocationCode, worklocation_name as worklocationName
+        FROM teomworklocation
+        WHERE worklocation_code = ?
+      `, [empData.workLocationCode]));
+        }
+        // Custom Field data
+        if ((0, helpers_1.needsCustomFieldData)(requiredWords)) {
+            queryMap.push('customField');
+            queries.push(auth.conn.query(`
+        SELECT customfield1, customfield2, customfield3, customfield4, customfield5,
+               customfield6, customfield7, customfield8, customfield9, customfield10
+        FROM teodempcustomfield
+        WHERE emp_id = ? AND company_code = ?
+      `, [empData.empId, auth.userData.companyCode]));
+        }
+        // Employment Status
+        if (requiredWords.has('EMPLOYMENTSTATUS')) {
+            queryMap.push('employmentStatus');
+            queries.push(auth.connFin.query(`
+        SELECT employmentstatus_code as employmentStatusCode
+        FROM teodemploymenthistory
+        WHERE emp_id = ?
+          AND effectivedt = (
+            SELECT MAX(effectivedt)
+            FROM teodemploymenthistory
+            WHERE emp_id = ? AND company_id = ?
+          )
+      `, [empData.empId, empData.empId, auth.userData.companyId]));
+        }
+        // Child Dependents
+        if (requiredWords.has('CHILDDEPENDENTS')) {
+            queryMap.push('childDependents');
+            queries.push(auth.conn.query(`
+        SELECT COUNT(*) as count
+        FROM teodempfamily f
+        INNER JOIN teomfamilyrelation r ON f.relationship = r.relationship_code AND r.ischild = 1
+        WHERE f.emp_id = ? AND f.dependentsts = 1
+      `, [empData.empId]));
+        }
+        // Execute all queries in parallel
+        const results = await Promise.all(queries);
+        // Map results back to cache
+        results.forEach((result, index) => {
+            const key = queryMap[index];
+            if (key === 'position' && result[0]) {
+                cache.position = {
+                    posNameEn: result[0].posNameEn,
+                    posCode: result[0].posCode,
+                    dept: {
+                        posNameEn: result[0].deptNameEn,
+                        posCode: result[0].deptCode,
+                    },
+                };
+            }
+            else if (key === 'costCenter' && result[0]) {
+                cache.costCenter = result[0];
+            }
+            else if (key === 'grade' && result[0]) {
+                cache.grade = result[0];
+            }
+            else if (key === 'workLocation' && result[0]) {
+                cache.workLocation = result[0];
+            }
+            else if (key === 'customField' && result[0]) {
+                cache.customField = result[0];
+            }
+            else if (key === 'employmentStatus' && result[0]) {
+                cache.employmentStatus = result[0].employmentStatusCode;
+            }
+            else if (key === 'childDependents' && result[0]) {
+                cache.childDependents = result[0].count;
+            }
+        });
+        return cache;
+    }
+    /**
+     * Convert raw employee data to EmployeeData interface
+     */
+    convertToEmployeeData(empData) {
+        return {
+            empId: empData.empId,
+            empNo: empData.empNo,
+            startDate: empData.startDate,
+            endDate: empData.endDate,
+            positionId: empData.positionId,
+            costCode: empData.costCode,
+            gradeCode: empData.gradeCode,
+            workLocationCode: empData.workLocationCode,
+            jobStatusCode: empData.jobStatusCode,
+            personal: {
+                birthdate: empData.birthdate,
+                maritalstatus: empData.maritalstatus,
+                religionCode: empData.religionCode,
+                gender: empData.gender,
+            },
+            companyGroup: {
+                joinDate: empData.joinDate,
+                fulljoinDate: empData.fulljoinDate,
+                permanentDate: empData.permanentDate,
+                pensionDate: empData.pensionDate,
+                terminateDate: empData.terminateDate,
+            },
+            jobStatus: {
+                jobstatusnameEn: empData.jobstatusnameEn,
+            },
+        };
+    }
+    /**
+     * Convert cache to OrganizationalData interface
+     */
+    convertToOrganizationalData(cache) {
+        return {
+            position: cache.position ? {
+                posNameEn: cache.position.posNameEn,
+                posCode: cache.position.posCode,
+                dept: cache.position.dept,
+            } : undefined,
+            costCenter: cache.costCenter,
+            grade: cache.grade,
+            workLocation: cache.workLocation,
+            customField: cache.customField,
+            employmentStatus: cache.employmentStatus,
+            childDependents: cache.childDependents,
+        };
+    }
+    /**
+     * OPTIMIZATION: Utility to chunk array for batched processing
+     * This prevents memory overflow when processing thousands of items
+     */
+    chunkArray(array, chunkSize) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += chunkSize) {
+            chunks.push(array.slice(i, i + chunkSize));
+        }
+        return chunks;
+    }
+}
+exports.PayrollFormulaService = PayrollFormulaService;
+//# sourceMappingURL=payroll-formula.service.js.map