map-reduce.js

/**
 * @NApiVersion 2.x
 * @NScriptType MapReduceScript
 * @Description A Map/Reduce script to merge lines from invoices in NetSuite.
 */

define(['N/record', 'N/search', 'N/log'], function(record, search, log) {

    /**
     * Entry point for the getInputData stage.
     * This stage is used to search for the data that will be processed.
     * 
     * @returns {Array|Object|Search|RecordRef} The input data to be processed by the map/reduce script.
     */
    function getInputData() {
        // Perform a search to retrieve the invoices that need to be processed
        return search.create({
            type: search.Type.INVOICE,
            filters: [
                // Add any necessary filters here
            ],
            columns: [
                // Specify the columns to be retrieved
            ]
        });
    }

    /**
     * Entry point for the map stage.
     * This stage is used to process each key-value pair.
     * 
     * @param {Object} context - Data collection containing the key-value pairs to process through the map stage.
     * @param {string} context.key - The key to be processed.
     * @param {string} context.value - The value to be processed.
     */
    function map(context) {
        var result = JSON.parse(context.value);
        var invoiceId = result.id;

        try {
            var invoice = record.load({
                type: record.Type.INVOICE,
                id: invoiceId
            });

            // Logic to merge lines from the invoice
            // For example, combine lines with the same item and sum their quantities

            invoice.save();
        } catch (e) {
            log.error('Error processing invoice', e.message);
        }
    }

    /**
     * Entry point for the reduce stage.
     * This stage is used to aggregate results from the map stage.
     * 
     * @param {Object} context - Data collection containing the key-value pairs to process through the reduce stage.
     * @param {string} context.key - The key to be processed.
     * @param {string} context.values - The values to be processed.
     */
    function reduce(context) {
        // Implement any necessary aggregation logic here
    }

    /**
     * Entry point for the summarize stage.
     * This stage is used to summarize the processing and report any errors.
     * 
     * @param {Object} summary - Holds statistics regarding the execution of a map/reduce script.
     * @param {number} summary.concurrency - Maximum concurrency number when executing parallel tasks.
     * @param {Date} summary.dateCreated - Date and time when the script began running.
     * @param {Date} summary.dateCompleted - Date and time when the script finished running.
     * @param {Object} summary.inputSummary - Statistics about the script input stage.
     * @param {Object} summary.mapSummary - Statistics about the script map stage.
     * @param {Object} summary.reduceSummary - Statistics about the script reduce stage.
     * @param {Array} summary.output - An array of values saved from the reduce stage.
     */
    function summarize(summary) {
        log.audit('Summary', 'Map/Reduce Script Completed');
        log.audit('Concurrency', summary.concurrency);
        log.audit('Date Created', summary.dateCreated);
        log.audit('Date Completed', summary.dateCompleted);

        if (summary.inputSummary.error) {
            log.error('Input Error', summary.inputSummary.error);
        }

        summary.mapSummary.errors.iterator().each(function(key, error) {
            log.error('Map Error', 'Error for key: ' + key + ', error: ' + error);
            return true;
        });

        summary.reduceSummary.errors.iterator().each(function(key, error) {
            log.error('Reduce Error', 'Error for key: ' + key + ', error: ' + error);
            return true;
        });
    }

    return {
        getInputData: getInputData,
        map: map,
        reduce: reduce,
        summarize: summarize
    };
});