Client Script Overview

Client Scripts execute in the user's browser when interacting with NetSuite forms. They provide immediate feedback, enforce business rules before submission, and create dynamic user experiences that respond to field changes in real-time.

Client Script Entry Points

Client Scripts have six entry points, each triggered by different user actions on the form:

Client Script Template

A comprehensive Client Script structure with all entry points:

/**
 * @NApiVersion 2.1
 * @NScriptType ClientScript
 * @NModuleScope SameAccount
 */
define(['N/currentRecord', 'N/dialog', 'N/runtime', 'N/search'],
    (currentRecord, dialog, runtime, search) => {

    /**
     * Page initialization - runs when form loads
     * @param {Object} context
     * @param {Record} context.currentRecord - Current form record
     * @param {string} context.mode - create, edit, copy, or view
     */
    const pageInit = (context) => {
        const rec = context.currentRecord;
        const mode = context.mode;

        console.log(`Page initialized in ${mode} mode`);

        // Set default values on create
        if (mode === 'create') {
            rec.setValue({
                fieldId: 'custbody_created_by',
                value: runtime.getCurrentUser().id
            });
        }

        // Disable fields based on status
        if (mode === 'edit') {
            const status = rec.getValue('status');
            if (status === 'approved') {
                // Use jQuery to disable field (standard approach)
                jQuery('#custbody_amount').attr('disabled', true);
            }
        }
    };

    /**
     * Field change handler
     * @param {Object} context
     * @param {Record} context.currentRecord
     * @param {string} context.sublistId - Sublist internal ID (if applicable)
     * @param {string} context.fieldId - Changed field's internal ID
     * @param {number} context.line - Line index (if sublist)
     */
    const fieldChanged = (context) => {
        const rec = context.currentRecord;
        const fieldId = context.fieldId;
        const sublistId = context.sublistId;

        // Body field change
        if (!sublistId && fieldId === 'entity') {
            const customerId = rec.getValue('entity');
            if (customerId) {
                lookupCustomerDefaults(rec, customerId);
            }
        }

        // Sublist field change
        if (sublistId === 'item' && fieldId === 'quantity') {
            calculateLineAmount(rec, context.line);
        }
    };

    /**
     * Post-sourcing handler - after NetSuite finishes sourcing
     * @param {Object} context
     */
    const postSourcing = (context) => {
        const rec = context.currentRecord;
        const fieldId = context.fieldId;
        const sublistId = context.sublistId;

        // Override sourced price for specific customer
        if (sublistId === 'item' && fieldId === 'item') {
            const customerId = rec.getValue('entity');
            const itemId = rec.getCurrentSublistValue({
                sublistId: 'item',
                fieldId: 'item'
            });

            // Look up special pricing
            const specialPrice = getSpecialPrice(customerId, itemId);
            if (specialPrice) {
                rec.setCurrentSublistValue({
                    sublistId: 'item',
                    fieldId: 'rate',
                    value: specialPrice
                });
            }
        }
    };

    /**
     * Line initialization
     * @param {Object} context
     */
    const lineInit = (context) => {
        const rec = context.currentRecord;
        const sublistId = context.sublistId;

        if (sublistId === 'item') {
            // Default quantity to 1 for new lines
            rec.setCurrentSublistValue({
                sublistId: 'item',
                fieldId: 'quantity',
                value: 1
            });
        }
    };

    /**
     * Field validation - return false to reject change
     * @param {Object} context
     * @returns {boolean}
     */
    const validateField = (context) => {
        const rec = context.currentRecord;
        const fieldId = context.fieldId;
        const sublistId = context.sublistId;

        // Validate discount percentage
        if (sublistId === 'item' && fieldId === 'custcol_discount_pct') {
            const discount = rec.getCurrentSublistValue({
                sublistId: 'item',
                fieldId: 'custcol_discount_pct'
            });

            if (discount > 25) {
                dialog.alert({
                    title: 'Discount Limit',
                    message: 'Discount cannot exceed 25%. Contact management for approval.'
                });
                return false; // Reject the change
            }
        }

        return true; // Accept the change
    };

    /**
     * Line validation - return false to reject line commit
     * @param {Object} context
     * @returns {boolean}
     */
    const validateLine = (context) => {
        const rec = context.currentRecord;
        const sublistId = context.sublistId;

        if (sublistId === 'item') {
            const quantity = rec.getCurrentSublistValue({
                sublistId: 'item',
                fieldId: 'quantity'
            });
            const rate = rec.getCurrentSublistValue({
                sublistId: 'item',
                fieldId: 'rate'
            });

            if (!quantity || quantity <= 0) {
                dialog.alert({
                    title: 'Invalid Quantity',
                    message: 'Quantity must be greater than zero.'
                });
                return false;
            }

            if (!rate || rate < 0) {
                dialog.alert({
                    title: 'Invalid Rate',
                    message: 'Rate cannot be negative.'
                });
                return false;
            }
        }

        return true;
    };

    /**
     * Delete validation
     * @param {Object} context
     * @returns {boolean}
     */
    const validateDelete = (context) => {
        const rec = context.currentRecord;
        const sublistId = context.sublistId;

        if (sublistId === 'item') {
            const lineCount = rec.getLineCount({ sublistId: 'item' });
            if (lineCount <= 1) {
                dialog.alert({
                    title: 'Cannot Delete',
                    message: 'Transaction must have at least one line item.'
                });
                return false;
            }
        }

        return true;
    };

    /**
     * Sublist changed - after line commit or delete
     * @param {Object} context
     */
    const sublistChanged = (context) => {
        const rec = context.currentRecord;
        const sublistId = context.sublistId;

        if (sublistId === 'item') {
            updateHeaderTotals(rec);
        }
    };

    /**
     * Save validation - return false to prevent save
     * @param {Object} context
     * @returns {boolean}
     */
    const saveRecord = (context) => {
        const rec = context.currentRecord;

        // Validate required custom fields
        const projectCode = rec.getValue('custbody_project_code');
        if (!projectCode) {
            dialog.alert({
                title: 'Missing Required Field',
                message: 'Please enter a Project Code before saving.'
            });
            return false;
        }

        // Confirm large orders
        const total = rec.getValue('total');
        if (total > 100000) {
            // Note: dialog.confirm returns a Promise in 2.1
            // For synchronous behavior, use window.confirm
            if (!window.confirm('Order total exceeds $100,000. Continue?')) {
                return false;
            }
        }

        return true;
    };

    // Helper functions
    const lookupCustomerDefaults = (rec, customerId) => {
        const customerLookup = search.lookupFields({
            type: search.Type.CUSTOMER,
            id: customerId,
            columns: ['custentity_default_terms', 'custentity_sales_rep']
        });
        // Apply defaults...
    };

    const calculateLineAmount = (rec, line) => {
        // Calculate logic...
    };

    const getSpecialPrice = (customerId, itemId) => {
        // Price lookup logic...
        return null;
    };

    const updateHeaderTotals = (rec) => {
        // Recalculate header...
    };

    return {
        pageInit,
        fieldChanged,
        postSourcing,
        lineInit,
        validateField,
        validateLine,
        validateDelete,
        sublistChanged,
        saveRecord
    };
});

Entry Point Execution Order

Understanding the sequence helps debug and design scripts:

Client-Side vs Server-Side Validation

Common Client Script Patterns

Pattern 1: Dynamic Field Show/Hide

const pageInit = (context) => {
    const rec = context.currentRecord;
    toggleFieldVisibility(rec);
};

const fieldChanged = (context) => {
    if (context.fieldId === 'custbody_payment_type') {
        toggleFieldVisibility(context.currentRecord);
    }
};

const toggleFieldVisibility = (rec) => {
    const paymentType = rec.getValue('custbody_payment_type');
    const creditCardField = rec.getField({ fieldId: 'custbody_cc_number' });
    const checkField = rec.getField({ fieldId: 'custbody_check_number' });

    // Show/hide based on payment type
    if (paymentType === 'credit_card') {
        creditCardField.isDisplay = true;
        checkField.isDisplay = false;
    } else if (paymentType === 'check') {
        creditCardField.isDisplay = false;
        checkField.isDisplay = true;
    } else {
        creditCardField.isDisplay = false;
        checkField.isDisplay = false;
    }
};

Pattern 2: Calculated Fields

const fieldChanged = (context) => {
    const rec = context.currentRecord;
    const fieldId = context.fieldId;

    // Recalculate margin when cost or price changes
    if (fieldId === 'custbody_unit_cost' || fieldId === 'custbody_sale_price') {
        const cost = rec.getValue('custbody_unit_cost') || 0;
        const price = rec.getValue('custbody_sale_price') || 0;

        const margin = price > 0 ? ((price - cost) / price * 100).toFixed(2) : 0;

        rec.setValue({
            fieldId: 'custbody_margin_pct',
            value: margin,
            ignoreFieldChange: true // Prevent recursion
        });
    }
};

Pattern 3: Cascading Dropdowns

const fieldChanged = (context) => {
    const rec = context.currentRecord;

    if (context.fieldId === 'custbody_country') {
        const countryId = rec.getValue('custbody_country');

        // Clear dependent field
        rec.setValue({
            fieldId: 'custbody_state',
            value: ''
        });

        // Rebuild state dropdown based on country
        const stateField = rec.getField({ fieldId: 'custbody_state' });

        // Remove existing options (except blank)
        stateField.removeSelectOption({ value: null }); // Clear all
        stateField.insertSelectOption({ value: '', text: '-- Select --' });

        // Lookup states for selected country
        const states = lookupStates(countryId);
        states.forEach(state => {
            stateField.insertSelectOption({
                value: state.id,
                text: state.name
            });
        });
    }
};

Pattern 4: Sublist Totals in Real-Time

const sublistChanged = (context) => {
    if (context.sublistId === 'item') {
        calculateTotals(context.currentRecord);
    }
};

const calculateTotals = (rec) => {
    const lineCount = rec.getLineCount({ sublistId: 'item' });
    let totalQty = 0;
    let totalWeight = 0;

    for (let i = 0; i < lineCount; i++) {
        totalQty += rec.getSublistValue({
            sublistId: 'item',
            fieldId: 'quantity',
            line: i
        }) || 0;

        totalWeight += rec.getSublistValue({
            sublistId: 'item',
            fieldId: 'custcol_weight',
            line: i
        }) || 0;
    }

    // Update header fields
    rec.setValue({ fieldId: 'custbody_total_qty', value: totalQty });
    rec.setValue({ fieldId: 'custbody_total_weight', value: totalWeight });

    // Update shipping estimate based on weight
    const shippingRate = getShippingRate(totalWeight);
    rec.setValue({ fieldId: 'custbody_est_shipping', value: shippingRate });
};

Debugging Client Scripts

// Debugging techniques
const fieldChanged = (context) => {
    // Log context for debugging
    console.log('fieldChanged triggered');
    console.log('Field ID:', context.fieldId);
    console.log('Sublist ID:', context.sublistId);
    console.log('Line:', context.line);

    // Log current values
    const rec = context.currentRecord;
    console.log('Customer:', rec.getValue('entity'));
    console.log('Total:', rec.getValue('total'));

    // Inspect record structure
    console.log('Record object:', rec);
};

Client Script Deployment

Performance Considerations

Industry Patterns

Scheduled Script Overview

Scheduled Scripts run on NetSuite's servers without user interaction. They're ideal for batch processing, data synchronization, report generation, and any operation that should happen automatically at specific times or intervals.

Scheduled Script Entry Point

Scheduled Scripts have a single entry point that receives execution context:

/**
 * @NApiVersion 2.1
 * @NScriptType ScheduledScript
 * @NModuleScope SameAccount
 */
define(['N/search', 'N/record', 'N/email', 'N/runtime', 'N/log'],
    (search, record, email, runtime, log) => {

    /**
     * Main execution entry point
     * @param {Object} context
     * @param {string} context.type - SCHEDULED, ON_DEMAND, USER_INTERFACE, ABORTED, SKIPPED
     */
    const execute = (context) => {
        log.audit('Script Start', `Execution Type: ${context.type}`);

        try {
            // Main processing logic
            processOverdueInvoices();

            log.audit('Script Complete', 'Processing finished successfully');

        } catch (e) {
            log.error('Script Error', e.message);
            sendErrorNotification(e);
        }
    };

    const processOverdueInvoices = () => {
        const invoiceSearch = search.create({
            type: search.Type.INVOICE,
            filters: [
                ['status', 'anyof', 'CustInvc:A'], // Open
                ['duedate', 'before', 'today'],
                ['mainline', 'is', 'T']
            ],
            columns: ['entity', 'tranid', 'total', 'duedate', 'daysoverdue']
        });

        let processedCount = 0;
        const script = runtime.getCurrentScript();

        invoiceSearch.run().each((result) => {
            // Check governance before processing
            if (script.getRemainingUsage() < 100) {
                log.audit('Governance', 'Yielding - low governance remaining');
                return false; // Stop iteration
            }

            // Process each invoice
            updateOverdueStatus(result);
            processedCount++;

            return true; // Continue to next result
        });

        log.audit('Processing Complete', `Processed ${processedCount} overdue invoices`);
    };

    const updateOverdueStatus = (result) => {
        const invoiceId = result.id;
        const daysOverdue = result.getValue('daysoverdue');

        record.submitFields({
            type: record.Type.INVOICE,
            id: invoiceId,
            values: {
                'custbody_overdue_flag': true,
                'custbody_overdue_days': daysOverdue
            }
        });
    };

    const sendErrorNotification = (error) => {
        email.send({
            author: -5, // System user
            recipients: ['admin@company.com'],
            subject: 'Scheduled Script Error',
            body: `Error in Overdue Invoice Processing:\n\n${error.message}\n\nStack: ${error.stack}`
        });
    };

    return { execute };
});

Execution Types

The context.type parameter indicates how the script was triggered:

Scheduling Options

Configure scheduling in the Script Deployment record:

Governance Management

Scheduled Scripts must manage their 10,000-unit budget carefully:

const processRecords = () => {
    const script = runtime.getCurrentScript();

    // Reserve units for cleanup
    const RESERVE_UNITS = 500;

    mySearch.run().each((result) => {
        const remaining = script.getRemainingUsage();

        // Log periodically
        if (remaining % 1000 < 50) {
            log.debug('Governance Check', `${remaining} units remaining`);
        }

        // Stop before hitting limit
        if (remaining < RESERVE_UNITS) {
            log.audit('Governance Limit', 'Stopping - reschedule needed');
            rescheduleScript();
            return false;
        }

        processRecord(result);
        return true;
    });
};

const rescheduleScript = () => {
    const scheduledTask = task.create({
        taskType: task.TaskType.SCHEDULED_SCRIPT,
        scriptId: runtime.getCurrentScript().id,
        deploymentId: runtime.getCurrentScript().deploymentId,
        params: {
            'custscript_last_processed_id': lastProcessedId
        }
    });
    scheduledTask.submit();
};

Script Parameters

Use script parameters to pass configuration and maintain state across executions:

// Access script parameters
const script = runtime.getCurrentScript();
const batchSize = script.getParameter({ name: 'custscript_batch_size' }) || 1000;
const emailRecipient = script.getParameter({ name: 'custscript_notify_email' });
const lastProcessedId = script.getParameter({ name: 'custscript_last_id' }) || 0;

// Process from where we left off
const searchFilters = [
    ['internalid', 'greaterthan', lastProcessedId],
    ['mainline', 'is', 'T']
];

// Save progress for next run
const saveProgress = (lastId) => {
    // Note: Parameters are read-only at runtime
    // Use a custom record or scheduled script queue for persistent state
    log.audit('Progress', `Last processed ID: ${lastId}`);
};

Triggering Scheduled Scripts Programmatically

Queue Scheduled Scripts from other scripts using the N/task module:

/**
 * Queue a scheduled script from a User Event
 */
const afterSubmit = (context) => {
    if (context.type !== context.UserEventType.CREATE) return;

    const rec = context.newRecord;

    // Check if processing needed
    if (rec.getValue('custbody_needs_processing')) {
        queueProcessingScript(rec.id);
    }
};

const queueProcessingScript = (recordId) => {
    try {
        const scheduledTask = task.create({
            taskType: task.TaskType.SCHEDULED_SCRIPT,
            scriptId: 'customscript_process_order',
            deploymentId: 'customdeploy_process_order_queue',
            params: {
                'custscript_order_id': recordId
            }
        });

        const taskId = scheduledTask.submit();
        log.audit('Task Queued', `Task ID: ${taskId} for Order: ${recordId}`);

    } catch (e) {
        if (e.name === 'FAILED_TO_SUBMIT_JOB_REQUEST_1') {
            // Script already queued - this is OK
            log.debug('Already Queued', 'Script execution already pending');
        } else {
            throw e;
        }
    }
};

Checking Script Status

const checkScriptStatus = (taskId) => {
    const taskStatus = task.checkStatus({
        taskId: taskId
    });

    log.debug('Task Status', JSON.stringify({
        status: taskStatus.status,
        percentComplete: taskStatus.getPercentageCompleted()
    }));

    // Possible statuses:
    // PENDING, PROCESSING, COMPLETE, FAILED
    return taskStatus.status;
};

Common Patterns

Pattern 1: Batch Email Sender

const execute = (context) => {
    const script = runtime.getCurrentScript();
    const batchLimit = script.getParameter({ name: 'custscript_email_batch' }) || 100;

    // Find pending emails
    const emailQueue = search.create({
        type: 'customrecord_email_queue',
        filters: [['custrecord_eq_status', 'is', 'Pending']],
        columns: ['custrecord_eq_recipient', 'custrecord_eq_subject', 'custrecord_eq_body']
    });

    let sentCount = 0;

    emailQueue.run().each((result) => {
        if (sentCount >= batchLimit) return false;
        if (script.getRemainingUsage() < 100) return false;

        try {
            email.send({
                author: script.getParameter({ name: 'custscript_sender' }),
                recipients: result.getValue('custrecord_eq_recipient'),
                subject: result.getValue('custrecord_eq_subject'),
                body: result.getValue('custrecord_eq_body')
            });

            // Mark as sent
            record.submitFields({
                type: 'customrecord_email_queue',
                id: result.id,
                values: { 'custrecord_eq_status': 'Sent' }
            });

            sentCount++;
        } catch (e) {
            record.submitFields({
                type: 'customrecord_email_queue',
                id: result.id,
                values: {
                    'custrecord_eq_status': 'Failed',
                    'custrecord_eq_error': e.message
                }
            });
        }

        return true;
    });

    log.audit('Email Batch Complete', `Sent ${sentCount} emails`);
};

Pattern 2: Data Synchronization

const execute = (context) => {
    const lastSyncDate = getLastSyncDate();

    // Get records modified since last sync
    const modifiedRecords = search.create({
        type: search.Type.CUSTOMER,
        filters: [
            ['lastmodifieddate', 'onorafter', lastSyncDate],
            ['isinactive', 'is', 'F']
        ],
        columns: ['entityid', 'companyname', 'email', 'lastmodifieddate']
    });

    const script = runtime.getCurrentScript();
    let syncedCount = 0;
    let latestModified = lastSyncDate;

    modifiedRecords.run().each((result) => {
        if (script.getRemainingUsage() < 200) {
            log.audit('Pause Sync', 'Will continue next run');
            return false;
        }

        // Send to external system
        const success = syncToExternalSystem(result);

        if (success) {
            syncedCount++;
            const modDate = result.getValue('lastmodifieddate');
            if (modDate > latestModified) {
                latestModified = modDate;
            }
        }

        return true;
    });

    // Save sync checkpoint
    saveLastSyncDate(latestModified);
    log.audit('Sync Complete', `Synced ${syncedCount} customers`);
};

Pattern 3: Report Generation

const execute = (context) => {
    const script = runtime.getCurrentScript();
    const reportDate = new Date();

    // Generate report data
    const reportData = generateSalesReport(reportDate);

    // Create file
    const reportFile = file.create({
        name: `Sales_Report_${formatDate(reportDate)}.csv`,
        fileType: file.Type.CSV,
        contents: reportData,
        folder: script.getParameter({ name: 'custscript_report_folder' })
    });

    const fileId = reportFile.save();

    // Email report
    email.send({
        author: -5,
        recipients: script.getParameter({ name: 'custscript_report_recipients' }).split(','),
        subject: `Daily Sales Report - ${formatDate(reportDate)}`,
        body: 'Please find attached the daily sales report.',
        attachments: [file.load({ id: fileId })]
    });

    log.audit('Report Sent', `File ID: ${fileId}`);
};

Deployment Best Practices

Industry Patterns

Map/Reduce Overview

Map/Reduce Scripts are NetSuite's solution for processing large data volumes that exceed Scheduled Script governance limits. They automatically handle governance, enable parallel processing, and support yield/resume for long-running operations.

The Four Stages

Map/Reduce Scripts execute in four sequential stages:

Basic Map/Reduce Template

/**
 * @NApiVersion 2.1
 * @NScriptType MapReduceScript
 * @NModuleScope SameAccount
 */
define(['N/search', 'N/record', 'N/email', 'N/runtime', 'N/log'],
    (search, record, email, runtime, log) => {

    /**
     * Stage 1: Define the data to process
     * @returns {Array|Object|Search} Input data
     */
    const getInputData = () => {
        log.audit('Stage', 'getInputData started');

        // Option 1: Return a saved search
        return search.create({
            type: search.Type.SALES_ORDER,
            filters: [
                ['status', 'anyof', 'SalesOrd:B'], // Pending Fulfillment
                ['mainline', 'is', 'T']
            ],
            columns: ['entity', 'tranid', 'total', 'trandate']
        });

        // Option 2: Return an array
        // return [1, 2, 3, 4, 5];

        // Option 3: Return a search ID
        // return search.load({ id: 'customsearch_pending_orders' });

        // Option 4: Return an object
        // return { key1: 'value1', key2: 'value2' };
    };

    /**
     * Stage 2: Process each input element
     * @param {Object} context
     * @param {string} context.key - Unique key (search result ID or index)
     * @param {string} context.value - JSON string of the data
     */
    const map = (context) => {
        const searchResult = JSON.parse(context.value);
        const orderId = searchResult.id;
        const customerId = searchResult.values.entity.value;

        log.debug('Map', `Processing Order ${orderId}`);

        try {
            // Perform some transformation or lookup
            const orderData = processOrder(orderId);

            // Emit key-value pair for reduce stage
            // Group by customer for aggregation
            context.write({
                key: customerId,
                value: {
                    orderId: orderId,
                    total: orderData.total,
                    status: orderData.status
                }
            });

        } catch (e) {
            log.error('Map Error', `Order ${orderId}: ${e.message}`);
            // Errors here don't stop other map executions
        }
    };

    /**
     * Stage 3: Process grouped values
     * @param {Object} context
     * @param {string} context.key - The grouping key
     * @param {Iterator} context.values - Iterator of values for this key
     */
    const reduce = (context) => {
        const customerId = context.key;
        let totalAmount = 0;
        let orderCount = 0;

        // Iterate through all values for this key
        context.values.forEach((valueJson) => {
            const value = JSON.parse(valueJson);
            totalAmount += value.total;
            orderCount++;
        });

        log.debug('Reduce', `Customer ${customerId}: ${orderCount} orders, $${totalAmount}`);

        // Update customer record with aggregated data
        try {
            record.submitFields({
                type: record.Type.CUSTOMER,
                id: customerId,
                values: {
                    'custentity_pending_order_total': totalAmount,
                    'custentity_pending_order_count': orderCount
                }
            });

            // Write success for summarize
            context.write({
                key: 'success',
                value: customerId
            });

        } catch (e) {
            context.write({
                key: 'error',
                value: { customerId, error: e.message }
            });
        }
    };

    /**
     * Stage 4: Summarize results
     * @param {Object} summary - Contains execution summary
     */
    const summarize = (summary) => {
        log.audit('Summarize', 'Processing complete');

        // Log usage statistics
        log.audit('Usage', JSON.stringify({
            mapErrors: summary.mapSummary.errors.length,
            reduceErrors: summary.reduceSummary.errors.length,
            inputStageTime: summary.inputSummary.seconds,
            mapStageTime: summary.mapSummary.seconds,
            reduceStageTime: summary.reduceSummary.seconds
        }));

        // Count successes and errors
        let successCount = 0;
        let errorList = [];

        summary.output.iterator().each((key, value) => {
            if (key === 'success') {
                successCount++;
            } else if (key === 'error') {
                errorList.push(JSON.parse(value));
            }
            return true;
        });

        // Handle any errors from map/reduce stages
        summary.mapSummary.errors.iterator().each((key, error) => {
            log.error('Map Stage Error', `Key: ${key}, Error: ${error}`);
            return true;
        });

        summary.reduceSummary.errors.iterator().each((key, error) => {
            log.error('Reduce Stage Error', `Key: ${key}, Error: ${error}`);
            return true;
        });

        // Send completion notification
        sendSummaryEmail(successCount, errorList);
    };

    // Helper functions
    const processOrder = (orderId) => {
        const orderRecord = record.load({
            type: record.Type.SALES_ORDER,
            id: orderId
        });
        return {
            total: orderRecord.getValue('total'),
            status: orderRecord.getValue('status')
        };
    };

    const sendSummaryEmail = (successCount, errors) => {
        email.send({
            author: -5,
            recipients: ['admin@company.com'],
            subject: 'Map/Reduce Processing Complete',
            body: `Processed ${successCount} customers successfully.\n\nErrors: ${errors.length}`
        });
    };

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

Parallel Execution

Map and Reduce stages run in parallel across multiple processors:

// Check concurrency in summarize
const summarize = (summary) => {
    log.audit('Concurrency Used', {
        mapConcurrency: summary.mapSummary.concurrency,
        reduceConcurrency: summary.reduceSummary.concurrency
    });
};

Common Patterns

Pattern 1: Map Only (No Reduce)

When you don't need aggregation, skip the reduce stage:

const map = (context) => {
    const data = JSON.parse(context.value);

    // Process each record independently
    record.submitFields({
        type: record.Type.CUSTOMER,
        id: data.id,
        values: { 'custentity_processed': true }
    });

    // Don't call context.write() - skip reduce stage
};

// Return null to skip reduce
const reduce = null;  // Or simply don't define it

Pattern 2: Using Script Parameters

const getInputData = () => {
    const script = runtime.getCurrentScript();
    const subsidiaryId = script.getParameter({ name: 'custscript_subsidiary' });
    const startDate = script.getParameter({ name: 'custscript_start_date' });

    return search.create({
        type: search.Type.INVOICE,
        filters: [
            ['subsidiary', 'anyof', subsidiaryId],
            ['trandate', 'onorafter', startDate],
            ['mainline', 'is', 'T']
        ],
        columns: ['entity', 'total']
    });
};

Pattern 3: Processing Large Files

const getInputData = () => {
    const script = runtime.getCurrentScript();
    const fileId = script.getParameter({ name: 'custscript_import_file' });

    const csvFile = file.load({ id: fileId });
    const contents = csvFile.getContents();
    const lines = contents.split('\n');

    // Skip header row, return data rows
    return lines.slice(1).map((line, index) => ({
        lineNumber: index + 2,
        data: line
    }));
};

const map = (context) => {
    const input = JSON.parse(context.value);
    const lineData = input.data.split(',');

    // Process CSV row
    // ...
};

Pattern 4: Yield Point Recovery

const getInputData = () => {
    const script = runtime.getCurrentScript();

    // Check if resuming from a yield
    if (script.getParameter({ name: 'custscript_resume_id' })) {
        return search.create({
            type: search.Type.SALES_ORDER,
            filters: [
                ['internalid', 'greaterthan', script.getParameter({ name: 'custscript_resume_id' })],
                ['mainline', 'is', 'T']
            ]
        });
    }

    return search.create({
        type: search.Type.SALES_ORDER,
        filters: [['mainline', 'is', 'T']]
    });
};

Error Handling

const map = (context) => {
    try {
        const data = JSON.parse(context.value);
        processRecord(data);

        context.write({
            key: 'success',
            value: data.id
        });

    } catch (e) {
        // Log the error - doesn't stop other map executions
        log.error('Map Error', {
            key: context.key,
            error: e.message,
            stack: e.stack
        });

        // Optionally write error for summarize tracking
        context.write({
            key: 'error',
            value: JSON.stringify({
                key: context.key,
                error: e.message
            })
        });
    }
};

const summarize = (summary) => {
    // Check for input stage errors
    if (summary.inputSummary.error) {
        log.error('Input Error', summary.inputSummary.error);
        sendAlertEmail('getInputData failed', summary.inputSummary.error);
        return;
    }

    // Iterate all map errors
    let mapErrorCount = 0;
    summary.mapSummary.errors.iterator().each((key, error) => {
        mapErrorCount++;
        log.error('Map Error', `Key ${key}: ${error}`);
        return true; // Continue iteration
    });

    // Iterate all reduce errors
    let reduceErrorCount = 0;
    summary.reduceSummary.errors.iterator().each((key, error) => {
        reduceErrorCount++;
        log.error('Reduce Error', `Key ${key}: ${error}`);
        return true;
    });

    log.audit('Error Summary', {
        mapErrors: mapErrorCount,
        reduceErrors: reduceErrorCount
    });
};

Performance Optimization

Monitoring Progress

// Check status from another script
const checkMapReduceStatus = (taskId) => {
    const status = task.checkStatus({ taskId });

    log.debug('M/R Status', {
        status: status.status, // PENDING, PROCESSING, COMPLETE, FAILED
        stage: status.stage,   // GET_INPUT, MAP, REDUCE, SUMMARIZE
        percentComplete: status.getPercentageCompleted()
    });

    return status;
};

Industry Applications

Suitelets vs Restlets

Both script types create custom endpoints in NetSuite, but serve different purposes:

Suitelet Basics

Suitelets create custom pages within NetSuite, accessible via URL or as embedded content.

/**
 * @NApiVersion 2.1
 * @NScriptType Suitelet
 * @NModuleScope SameAccount
 */
define(['N/ui/serverWidget', 'N/search', 'N/record', 'N/redirect'],
    (serverWidget, search, record, redirect) => {

    /**
     * Entry point for Suitelet
     * @param {Object} context
     * @param {ServerRequest} context.request - HTTP request
     * @param {ServerResponse} context.response - HTTP response
     */
    const onRequest = (context) => {
        if (context.request.method === 'GET') {
            showForm(context);
        } else {
            processSubmission(context);
        }
    };

    const showForm = (context) => {
        // Create a form using N/ui/serverWidget
        const form = serverWidget.createForm({
            title: 'Custom Data Entry Form'
        });

        // Add fields
        form.addField({
            id: 'custpage_customer',
            type: serverWidget.FieldType.SELECT,
            label: 'Customer',
            source: 'customer'
        });

        form.addField({
            id: 'custpage_memo',
            type: serverWidget.FieldType.TEXTAREA,
            label: 'Notes'
        });

        form.addField({
            id: 'custpage_amount',
            type: serverWidget.FieldType.CURRENCY,
            label: 'Amount'
        });

        // Add submit button
        form.addSubmitButton({
            label: 'Save Record'
        });

        // Write form to response
        context.response.writePage(form);
    };

    const processSubmission = (context) => {
        const customerId = context.request.parameters.custpage_customer;
        const memo = context.request.parameters.custpage_memo;
        const amount = context.request.parameters.custpage_amount;

        // Create or update record
        const newRecord = record.create({
            type: 'customrecord_my_record'
        });
        newRecord.setValue('custrecord_customer', customerId);
        newRecord.setValue('custrecord_memo', memo);
        newRecord.setValue('custrecord_amount', amount);
        const recordId = newRecord.save();

        // Redirect to the new record
        redirect.toRecord({
            type: 'customrecord_my_record',
            id: recordId
        });
    };

    return { onRequest };
});

Suitelet UI Components

The N/ui/serverWidget module provides rich UI building blocks:

Field Types

// Text fields
form.addField({ id: 'name', type: serverWidget.FieldType.TEXT, label: 'Name' });
form.addField({ id: 'email', type: serverWidget.FieldType.EMAIL, label: 'Email' });
form.addField({ id: 'phone', type: serverWidget.FieldType.PHONE, label: 'Phone' });
form.addField({ id: 'notes', type: serverWidget.FieldType.TEXTAREA, label: 'Notes' });
form.addField({ id: 'richtext', type: serverWidget.FieldType.RICHTEXT, label: 'Description' });

// Numeric fields
form.addField({ id: 'qty', type: serverWidget.FieldType.INTEGER, label: 'Quantity' });
form.addField({ id: 'rate', type: serverWidget.FieldType.FLOAT, label: 'Rate' });
form.addField({ id: 'amount', type: serverWidget.FieldType.CURRENCY, label: 'Amount' });
form.addField({ id: 'pct', type: serverWidget.FieldType.PERCENT, label: 'Discount %' });

// Date/Time fields
form.addField({ id: 'date', type: serverWidget.FieldType.DATE, label: 'Date' });
form.addField({ id: 'datetime', type: serverWidget.FieldType.DATETIMETZ, label: 'Date/Time' });

// Selection fields
form.addField({ id: 'customer', type: serverWidget.FieldType.SELECT, label: 'Customer', source: 'customer' });
form.addField({ id: 'item', type: serverWidget.FieldType.SELECT, label: 'Item', source: 'item' });

// Other fields
form.addField({ id: 'check', type: serverWidget.FieldType.CHECKBOX, label: 'Active' });
form.addField({ id: 'file', type: serverWidget.FieldType.FILE, label: 'Upload File' });
form.addField({ id: 'html', type: serverWidget.FieldType.INLINEHTML, label: '' }).defaultValue = '<p>Custom HTML</p>';

Sublists

// Add a sublist
const sublist = form.addSublist({
    id: 'custpage_items',
    type: serverWidget.SublistType.INLINEEDITOR, // or LIST, STATICLIST
    label: 'Line Items'
});

// Add sublist columns
sublist.addField({ id: 'item', type: serverWidget.FieldType.SELECT, label: 'Item', source: 'item' });
sublist.addField({ id: 'qty', type: serverWidget.FieldType.INTEGER, label: 'Quantity' });
sublist.addField({ id: 'rate', type: serverWidget.FieldType.CURRENCY, label: 'Rate' });

// Pre-populate sublist lines
sublist.setSublistValue({ id: 'item', line: 0, value: '123' });
sublist.setSublistValue({ id: 'qty', line: 0, value: '10' });

Tabs and Field Groups

// Add tabs
form.addTab({ id: 'maintab', label: 'Main Info' });
form.addTab({ id: 'detailstab', label: 'Details' });

// Add field groups
form.addFieldGroup({ id: 'addressgroup', label: 'Address', tab: 'maintab' });

// Add fields to tab/group
const cityField = form.addField({
    id: 'city',
    type: serverWidget.FieldType.TEXT,
    label: 'City',
    container: 'addressgroup'
});

Suitelet Access & Deployment

Generate Suitelet URLs programmatically:

const url = require('N/url');

// Internal URL (for logged-in users)
const internalUrl = url.resolveScript({
    scriptId: 'customscript_my_suitelet',
    deploymentId: 'customdeploy_my_suitelet',
    params: { customer: '123' }
});

// External URL (for external access)
const externalUrl = url.resolveScript({
    scriptId: 'customscript_my_suitelet',
    deploymentId: 'customdeploy_my_suitelet',
    params: { customer: '123' },
    returnExternalUrl: true
});

Restlet Basics

Restlets provide RESTful API endpoints for external integrations:

/**
 * @NApiVersion 2.1
 * @NScriptType Restlet
 * @NModuleScope SameAccount
 */
define(['N/record', 'N/search', 'N/log'],
    (record, search, log) => {

    /**
     * GET request handler - retrieve data
     * @param {Object} requestParams - URL query parameters
     * @returns {Object} Response data
     */
    const get = (requestParams) => {
        log.debug('GET Request', JSON.stringify(requestParams));

        const customerId = requestParams.id;

        if (!customerId) {
            return { error: 'Customer ID required' };
        }

        try {
            const customer = record.load({
                type: record.Type.CUSTOMER,
                id: customerId
            });

            return {
                success: true,
                data: {
                    id: customer.id,
                    name: customer.getValue('companyname'),
                    email: customer.getValue('email'),
                    balance: customer.getValue('balance')
                }
            };

        } catch (e) {
            return { success: false, error: e.message };
        }
    };

    /**
     * POST request handler - create data
     * @param {Object} requestBody - Request body (parsed JSON)
     * @returns {Object} Response data
     */
    const post = (requestBody) => {
        log.debug('POST Request', JSON.stringify(requestBody));

        try {
            const newCustomer = record.create({
                type: record.Type.CUSTOMER
            });

            newCustomer.setValue('companyname', requestBody.name);
            newCustomer.setValue('email', requestBody.email);
            newCustomer.setValue('subsidiary', requestBody.subsidiary || 1);

            const customerId = newCustomer.save();

            return {
                success: true,
                id: customerId,
                message: 'Customer created successfully'
            };

        } catch (e) {
            return { success: false, error: e.message };
        }
    };

    /**
     * PUT request handler - update data
     * @param {Object} requestBody - Request body
     * @returns {Object} Response data
     */
    const put = (requestBody) => {
        log.debug('PUT Request', JSON.stringify(requestBody));

        if (!requestBody.id) {
            return { error: 'Customer ID required for update' };
        }

        try {
            const values = {};
            if (requestBody.name) values['companyname'] = requestBody.name;
            if (requestBody.email) values['email'] = requestBody.email;

            record.submitFields({
                type: record.Type.CUSTOMER,
                id: requestBody.id,
                values: values
            });

            return {
                success: true,
                message: 'Customer updated successfully'
            };

        } catch (e) {
            return { success: false, error: e.message };
        }
    };

    /**
     * DELETE request handler - remove data
     * @param {Object} requestParams - URL parameters
     * @returns {Object} Response data
     */
    const doDelete = (requestParams) => {
        log.debug('DELETE Request', JSON.stringify(requestParams));

        if (!requestParams.id) {
            return { error: 'Record ID required for deletion' };
        }

        try {
            record.delete({
                type: 'customrecord_my_record',
                id: requestParams.id
            });

            return {
                success: true,
                message: 'Record deleted successfully'
            };

        } catch (e) {
            return { success: false, error: e.message };
        }
    };

    return {
        get: get,
        post: post,
        put: put,
        delete: doDelete  // 'delete' is reserved word
    };
});

Restlet Authentication

Restlets require authentication. Common methods:

Token-Based Authentication Setup

// Integration record settings:
// - Enable Token-Based Authentication
// - Create Access Token for user/role

// HTTP request headers for TBA:
// Authorization: OAuth realm="ACCOUNT_ID",
//   oauth_consumer_key="CONSUMER_KEY",
//   oauth_token="TOKEN_ID",
//   oauth_signature_method="HMAC-SHA256",
//   oauth_timestamp="TIMESTAMP",
//   oauth_nonce="NONCE",
//   oauth_version="1.0",
//   oauth_signature="SIGNATURE"

Calling Restlets

// Example: Calling a Restlet from JavaScript (external)
const restletUrl = 'https://ACCOUNT_ID.restlets.api.netsuite.com/app/site/hosting/restlet.nl';
const params = `?script=123&deploy=1&id=456`;

fetch(restletUrl + params, {
    method: 'GET',
    headers: {
        'Authorization': 'OAuth ...',
        'Content-Type': 'application/json'
    }
})
.then(response => response.json())
.then(data => console.log(data));

// From SuiteScript (internal)
const https = require('N/https');
const url = require('N/url');

const restletUrl = url.resolveScript({
    scriptId: 'customscript_my_restlet',
    deploymentId: 'customdeploy_my_restlet'
});

const response = https.post({
    url: restletUrl,
    body: JSON.stringify({ name: 'Test' }),
    headers: { 'Content-Type': 'application/json' }
});

Common Patterns

Pattern: Wizard-Style Suitelet

const onRequest = (context) => {
    const step = context.request.parameters.step || '1';

    switch (step) {
        case '1':
            renderStep1(context);
            break;
        case '2':
            if (context.request.method === 'POST') {
                saveStep1Data(context);
            }
            renderStep2(context);
            break;
        case '3':
            if (context.request.method === 'POST') {
                saveStep2Data(context);
                completeWizard(context);
            }
            break;
    }
};

Pattern: Bulk Action Restlet

const post = (requestBody) => {
    const recordIds = requestBody.ids;
    const action = requestBody.action;

    const results = {
        success: [],
        failed: []
    };

    recordIds.forEach(id => {
        try {
            if (action === 'approve') {
                record.submitFields({
                    type: 'salesorder',
                    id: id,
                    values: { 'orderstatus': 'B' }
                });
            }
            results.success.push(id);
        } catch (e) {
            results.failed.push({ id, error: e.message });
        }
    });

    return results;
};

Industry Applications