Operation                               Units
--------------------------------------------------
record.load()                           10
record.save()                           20
record.delete()                         20
search.create().run()                   10
search.lookupFields()                   1
email.send()                            20
http.request()                          10
file.load()                             10

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

    const beforeLoad = (context) => {
        log.debug('Before Load', `Record ID: ${context.newRecord.id}`);
    };

    const afterSubmit = (context) => {
        // Runs after record is saved to database
    };

    return { beforeLoad, afterSubmit };
});

const afterSubmit = (context) => {
    try {
        const customerId = context.newRecord.getValue('entity');
        if (!customerId) {
            log.error('Validation Error', 'Customer is required');
            return;
        }
        // Process logic...
        log.audit('Success', `Processed customer ${customerId}`);
    } catch (error) {
        log.error({
            title: 'Script Error',
            details: `Error: ${error.message}\nStack: ${error.stack}`
        });
    }
};

const beforeSubmit = (context) => {
    if (context.type !== context.UserEventType.EDIT) return;

    const oldRec = context.oldRecord;
    const newRec = context.newRecord;

    const oldStatus = oldRec.getValue('status');
    const newStatus = newRec.getValue('status');

    if (oldStatus !== newStatus) {
        log.audit('Status Changed', `From ${oldStatus} to ${newStatus}`);
        if (newStatus === 'approved' && oldStatus !== 'approved') {
            // Trigger approval notification
        }
    }
};

define(['N/runtime', 'N/log'], (runtime, log) => {

    const beforeSubmit = (context) => {
        const execContext = runtime.executionContext;

        // Log the execution context
        log.debug('Execution Context', execContext);

        // Skip if running from CSV import
        if (execContext === runtime.ContextType.CSV_IMPORT) {
            log.audit('Skipped', 'Running from CSV import');
            return;
        }

        // Skip if running from another script
        if (execContext === runtime.ContextType.SCHEDULED ||
            execContext === runtime.ContextType.MAP_REDUCE) {
            log.audit('Skipped', 'Running from scheduled processing');
            return;
        }

        // Continue with validation for UI and web service contexts
        // ...
    };

    return { beforeSubmit };
});

define(['N/record', 'N/runtime', 'N/log'], (record, runtime, log) => {

    const afterSubmit = (context) => {
        // Method 1: Check execution context
        if (runtime.executionContext === runtime.ContextType.USER_EVENT) {
            log.debug('Skipped', 'Avoiding recursive call');
            return;
        }

        // Method 2: Use a flag field
        const rec = context.newRecord;
        if (rec.getValue('custbody_processed_flag')) {
            return;  // Already processed
        }

        // Method 3: Track in script parameter or global
        const scriptObj = runtime.getCurrentScript();
        const processedIds = scriptObj.getParameter('custscript_processed') || '';
        if (processedIds.includes(rec.id)) {
            return;
        }

        // Safe to update
        record.submitFields({
            type: rec.type,
            id: rec.id,
            values: {
                'custbody_processed_flag': true,
                'custbody_processed_date': new Date()
            }
        });
    };

    return { afterSubmit };
});

/**
 * @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
    };
});

const fieldChanged = (context) => {
    if (context.fieldId === 'custbody_payment_type') {
        const rec = context.currentRecord;
        const paymentType = rec.getValue('custbody_payment_type');
        const ccField = rec.getField({ fieldId: 'custbody_cc_number' });
        const checkField = rec.getField({ fieldId: 'custbody_check_number' });
        ccField.isDisplay = (paymentType === 'credit_card');
        checkField.isDisplay = (paymentType === 'check');
    }
};

const fieldChanged = (context) => {
    if (context.fieldId === 'custbody_unit_cost' || context.fieldId === 'custbody_sale_price') {
        const rec = context.currentRecord;
        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 });
    }
};

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
            });
        });
    }
};

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 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);
};

/**
 * @NApiVersion 2.1
 * @NScriptType ScheduledScript
 */
define(['N/search', 'N/record', 'N/runtime', 'N/log'], (search, record, runtime, log) => {
    const execute = (context) => {
        log.audit('Script Start', `Type: ${context.type}`);
        try {
            const script = runtime.getCurrentScript();
            mySearch.run().each((result) => {
                if (script.getRemainingUsage() < 100) return false;
                processRecord(result);
                return true;
            });
        } catch (e) {
            log.error('Script Error', e.message);
        }
    };
    return { execute };
});

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

    mySearch.run().each((result) => {
        if (script.getRemainingUsage() < RESERVE_UNITS) {
            log.audit('Governance Limit', 'Stopping - reschedule needed');
            rescheduleScript();
            return false;
        }
        processRecord(result);
        return true;
    });
};

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;

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 }
        });
        scheduledTask.submit();
    } catch (e) {
        if (e.name === 'FAILED_TO_SUBMIT_JOB_REQUEST_1') {
            log.debug('Already Queued', 'Script already pending');
        } else { throw e; }
    }
};

const taskStatus = task.checkStatus({ taskId: taskId });
// Possible statuses: PENDING, PROCESSING, COMPLETE, FAILED
log.debug('Status', taskStatus.status);

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

    const getInputData = () => {
        log.audit('Stage', 'getInputData started');
        // Return a saved search - NetSuite streams results
        return search.create({
            type: search.Type.SALES_ORDER,
            filters: [
                ['status', 'anyof', 'SalesOrd:B'],
                ['mainline', 'is', 'T']
            ],
            columns: ['entity', 'tranid', 'total', 'trandate']
        });
    };

    const map = (context) => {
        const searchResult = JSON.parse(context.value);
        const orderId = searchResult.id;
        const customerId = searchResult.values.entity.value;
        try {
            const orderData = processOrder(orderId);
            context.write({
                key: customerId,
                value: { orderId, total: orderData.total, status: orderData.status }
            });
        } catch (e) {
            log.error('Map Error', `Order ${orderId}: ${e.message}`);
        }
    };

    const reduce = (context) => {
        const customerId = context.key;
        let totalAmount = 0;
        let orderCount = 0;
        context.values.forEach((valueJson) => {
            const value = JSON.parse(valueJson);
            totalAmount += value.total;
            orderCount++;
        });
        try {
            record.submitFields({
                type: record.Type.CUSTOMER,
                id: customerId,
                values: {
                    'custentity_pending_order_total': totalAmount,
                    'custentity_pending_order_count': orderCount
                }
            });
            context.write({ key: 'success', value: customerId });
        } catch (e) {
            context.write({ key: 'error', value: { customerId, error: e.message } });
        }
    };

    const summarize = (summary) => {
        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
        }));

        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;
        });

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

        sendSummaryEmail(successCount, errorList);
    };

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

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

const map = (context) => {
    const data = JSON.parse(context.value);
    record.submitFields({
        type: record.Type.CUSTOMER,
        id: data.id,
        values: { 'custentity_processed': true }
    });
    // Don't call context.write() - skip reduce stage
};

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

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']
    });
};

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');

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

const getInputData = () => {
    const script = runtime.getCurrentScript();
    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']]
    });
};

const map = (context) => {
    try {
        const data = JSON.parse(context.value);
        processRecord(data);
        context.write({ key: 'success', value: data.id });
    } catch (e) {
        log.error('Map Error', {
            key: context.key,
            error: e.message,
            stack: e.stack
        });
        context.write({
            key: 'error',
            value: JSON.stringify({ key: context.key, error: e.message })
        });
    }
};

const summarize = (summary) => {
    if (summary.inputSummary.error) {
        log.error('Input Error', summary.inputSummary.error);
        sendAlertEmail('getInputData failed', summary.inputSummary.error);
        return;
    }

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

    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 });
};

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;
};

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

    const onRequest = (context) => {
        if (context.request.method === 'GET') {
            showForm(context);
        } else {
            processSubmission(context);
        }
    };

    const showForm = (context) => {
        const form = serverWidget.createForm({ title: 'Custom Data Entry Form' });

        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'
        });
        form.addSubmitButton({ label: 'Save Record' });
        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;

        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.toRecord({ type: 'customrecord_my_record', id: recordId });
    };

    return { onRequest };
});

// 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: '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' });

// Other fields
form.addField({ id: 'check', type: serverWidget.FieldType.CHECKBOX, label: 'Active' });
form.addField({ id: 'file', type: serverWidget.FieldType.FILE, label: 'Upload File' });

const sublist = form.addSublist({
    id: 'custpage_items',
    type: serverWidget.SublistType.INLINEEDITOR,
    label: 'Line Items'
});

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' });

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

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

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

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
});

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

    const get = (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 };
        }
    };

    const post = (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' };
        } catch (e) {
            return { success: false, error: e.message };
        }
    };

    const put = (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 });
            return { success: true, message: 'Customer updated' };
        } catch (e) {
            return { success: false, error: e.message };
        }
    };

    const doDelete = (requestParams) => {
        if (!requestParams.id) return { error: 'Record ID required' };
        try {
            record.delete({ type: 'customrecord_my_record', id: requestParams.id });
            return { success: true, message: 'Record deleted' };
        } catch (e) {
            return { success: false, error: e.message };
        }
    };

    return { get, post, put, delete: doDelete };
});

// 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"

// External: Calling from JavaScript
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));

// Internal: From SuiteScript
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' }
});

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;
    }
};

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;
};

// Approval threshold by department
({department} = "Engineering" AND {amount} > 5000) OR
({department} = "Marketing" AND {amount} > 2500) OR
({department} = "Sales" AND {amount} > 10000)

// Multi-level approval
{amount} > 10000 AND {custbody_mgr_approved} = T AND {custbody_dir_approved} != T

// Record change detection (use with Before Submit)
{amount} != {previousvalue.amount}

// Day of week (for scheduled workflows)
{today} = "Monday" OR {today} = "Wednesday"

// In Set Field Value action
Field: [Workflow Variable] custworkflow_original_amount
Value: {total}
Value Type: Field

// Formula-based variable
Field: [Workflow Variable] custworkflow_days_pending
Value: ROUND(({today} - {datecreated}), 0)
Value Type: Formula

Subject: ${record.type} ${record.tranid} Requires Your Approval

Body:
Dear ${record.salesrep.entityid},

A ${record.type} has been submitted for your approval:

Transaction: ${record.tranid}
Customer: ${record.entity}
Amount: ${record.total}
Submitted By: ${currentuser.firstname} ${currentuser.lastname}

Please review and approve: ${record.recordurl}

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

    const onAction = (context) => {
        try {
            const rec = context.newRecord;
            const customerId = rec.getValue('entity');

            const creditLimit = lookupCreditLimit(customerId);
            const orderTotal = rec.getValue('total');

            if (orderTotal > creditLimit) {
                return 'OVER_LIMIT';
            }
            return 'APPROVED';
        } catch (e) {
            log.error('Workflow Action Error', e.message);
            return 'ERROR';
        }
    };

    const lookupCreditLimit = (customerId) => {
        const customerFields = search.lookupFields({
            type: search.Type.CUSTOMER,
            id: customerId,
            columns: ['creditlimit']
        });
        return parseFloat(customerFields.creditlimit) || 0;
    };

    return { onAction };
});

const onAction = (context) => {
    const rec = context.newRecord;
    const lineCount = rec.getLineCount({ sublistId: 'item' });

    let hasBackorder = false;
    let totalWeight = 0;

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

        if (qty > qtyAvailable) hasBackorder = true;
        totalWeight += (weight * qty);
    }

    return hasBackorder ? 'BACKORDER' : 'AVAILABLE';
};

// NOTE: Must load record in dynamic mode
const onAction = (context) => {
    const recId = context.newRecord.id;
    const recType = context.newRecord.type;

    const rec = record.load({ type: recType, id: recId, isDynamic: true });

    rec.selectNewLine({ sublistId: 'item' });
    rec.setCurrentSublistValue({
        sublistId: 'item', fieldId: 'item', value: 123
    });
    rec.setCurrentSublistValue({
        sublistId: 'item', fieldId: 'quantity', value: 1
    });
    rec.commitLine({ sublistId: 'item' });
    rec.save();

    return 'LINE_ADDED';
};

// 1. Overdue Invoice Reminders
//    Schedule: Daily at 8:00 AM
//    Record: Invoice
//    Condition: {duedate} < {today} AND {status} != "Paid In Full"
//    Action: Send Email to customer contact

// 2. Stale Quote Follow-up
//    Schedule: Weekly on Monday
//    Record: Estimate
//    Condition: {trandate} < ({today} - 14) AND {status} = "Open"
//    Action: Create Task for sales rep

// 3. Month-end Accrual
//    Schedule: Monthly on Last Day
//    Record: Journal Entry
//    Condition: {custbody_accrual_type} = "Auto"
//    Action: Custom action to create reversal

// 4. Anniversary Notifications
//    Schedule: Daily
//    Record: Customer
//    Condition: MONTH({custentity_anniversary}) = MONTH({today})
//    Action: Send Campaign Email

// Show "Approve" button only to managers
Condition: {role} = "Manager" OR {role} = "Administrator"

// Show "Escalate" button when pending > 3 days
Condition: ({today} - {custbody_submit_date}) > 3

// Show "Override" button for specific users
Condition: {currentuser.id} = 123 OR {currentuser.id} = 456

define(['N/workflow'],
    (workflow) => {

    const afterSubmit = (context) => {
        if (context.type === context.UserEventType.CREATE) {
            workflow.initiate({
                recordType: context.newRecord.type,
                recordId: context.newRecord.id,
                workflowId: 'customworkflow_approval'
            });
        }
    };

    return { afterSubmit };
});

define(['N/workflow'],
    (workflow) => {

    const triggerApproval = (recordType, recordId) => {
        workflow.trigger({
            recordType: recordType,
            recordId: recordId,
            workflowId: 'customworkflow_approval',
            actionId: 'customworkflowaction_approve'
        });
    };

    return { triggerApproval };
});

define(['N/search'],
    (search) => {

    const getWorkflowState = (recordType, recordId, workflowId) => {
        const results = search.create({
            type: 'workflowinstance',
            filters: [
                ['record', 'is', recordId],
                'AND',
                ['recordtype', 'is', recordType],
                'AND',
                ['workflow', 'is', workflowId]
            ],
            columns: ['state', 'datecreated']
        }).run().getRange({ start: 0, end: 1 });

        if (results.length > 0) {
            return results[0].getValue('state');
        }
        return null;
    };

    return { getWorkflowState };
});

// Implementation using checkbox fields
Transition to "All Approved" when:
{custbody_finance_approved} = T AND
{custbody_legal_approved} = T AND
{custbody_ops_approved} = T

// Scheduled workflow for escalation
// Runs daily at 9:00 AM

// Record: Sales Order
// Condition:
//   {custbody_approval_status} = "Pending" AND
//   ({today} - {custbody_submit_date}) > 3 AND
//   {custbody_escalated} != T

// Actions:
// 1. Set Field: custbody_escalated = T
// 2. Set Field: custbody_approver = {custbody_original_approver.supervisor}
// 3. Send Email: To new approver about escalation
// 4. Add Note: "Approval escalated due to 3-day SLA breach"

const onAction = (context) => {
    const rec = context.newRecord;
    const originalApprover = rec.getValue('custbody_approver');

    const delegateSearch = search.create({
        type: 'customrecord_delegation',
        filters: [
            ['custrecord_delegate_from', 'is', originalApprover],
            'AND',
            ['custrecord_delegate_start', 'onorbefore', 'today'],
            'AND',
            ['custrecord_delegate_end', 'onorafter', 'today'],
            'AND',
            ['isinactive', 'is', false]
        ],
        columns: ['custrecord_delegate_to']
    }).run().getRange({ start: 0, end: 1 });

    if (delegateSearch.length > 0) {
        return delegateSearch[0].getValue('custrecord_delegate_to');
    }
    return originalApprover;
};

// Extract domain from email
SUBSTR({email}, INSTR({email}, '@') + 1)

// Format phone as (XXX) XXX-XXXX
'(' || SUBSTR({phone}, 1, 3) || ') ' ||
SUBSTR({phone}, 4, 3) || '-' || SUBSTR({phone}, 7, 4)

// First initial + last name
SUBSTR({firstname}, 1, 1) || '. ' || {lastname}

// Handle null values
NVL({altname}, {entityid})

// Margin calculation
ROUND(({amount} - {costestimate}) / NULLIF({amount}, 0) * 100, 2)

// Prevent division by zero
{numerator} / NULLIF({denominator}, 0)

// Quantity in cases (12 per case)
FLOOR({quantity} / 12) || ' cases, ' || MOD({quantity}, 12) || ' units'

// Weighted average
SUM({quantity} * {rate}) / NULLIF(SUM({quantity}), 0)

// Round to nearest 5
ROUND({amount} / 5) * 5

// Days until due
{duedate} - TRUNC(SYSDATE)

// Days overdue (positive if past due)
TRUNC(SYSDATE) - {duedate}

// Age in years
FLOOR(MONTHS_BETWEEN(SYSDATE, {birthdate}) / 12)

// First day of current month
TRUNC(SYSDATE, 'MM')

// Last day of previous month
TRUNC(SYSDATE, 'MM') - 1

// Quarter name
'Q' || TO_CHAR({trandate}, 'Q') || ' ' || TO_CHAR({trandate}, 'YYYY')

// Simple CASE (compare to specific values)
CASE {status}
    WHEN 'Pending Fulfillment' THEN 'In Progress'
    WHEN 'Fulfilled' THEN 'Complete'
    WHEN 'Cancelled' THEN 'Void'
    ELSE 'Unknown'
END

// Searched CASE (evaluate conditions)
CASE
    WHEN {amount} >= 10000 THEN 'Large'
    WHEN {amount} >= 1000 THEN 'Medium'
    WHEN {amount} > 0 THEN 'Small'
    ELSE 'Zero'
END

// Nested CASE for complex logic
CASE
    WHEN {type} = 'Customer' THEN
        CASE
            WHEN {balance} > {creditlimit} THEN 'Over Credit'
            WHEN {balance} > {creditlimit} * 0.8 THEN 'Near Limit'
            ELSE 'Good Standing'
        END
    ELSE 'N/A'
END

// DECODE syntax: DECODE(expression, search1, result1, search2, result2, ..., default)

// Map status codes to labels
DECODE({custbody_status},
    1, 'New',
    2, 'In Progress',
    3, 'Completed',
    4, 'On Hold',
    'Unknown')

// Weighted average rate
SUM({quantity} * {rate}) / NULLIF(SUM({quantity}), 0)

// Count with condition
SUM(CASE WHEN {status} = 'Overdue' THEN 1 ELSE 0 END)

// Percentage of total
{amount} / SUM({amount}) * 100

// Conditional sum
SUM(CASE WHEN {type} = 'Invoice' THEN {amount} ELSE 0 END)

// Access parent record fields
{customer.companyname}
{customer.salesrep}
{item.displayname}

// Access custom fields on joined records
{customer.custentity_region}
{item.custitem_category}

// Multiple levels of joins
{customer.salesrep.email}

// Days since last activity
TRUNC(SYSDATE) - {lastmodifieddate}

// Full address in one column
{shipaddress1} ||
NVL2({shipaddress2}, CHR(10) || {shipaddress2}, '') ||
CHR(10) || {shipcity} || ', ' || {shipstate} || ' ' || {shipzip}

// Age bucket
CASE
    WHEN TRUNC(SYSDATE) - {duedate} <= 0 THEN 'Current'
    WHEN TRUNC(SYSDATE) - {duedate} <= 30 THEN '1-30 Days'
    WHEN TRUNC(SYSDATE) - {duedate} <= 60 THEN '31-60 Days'
    WHEN TRUNC(SYSDATE) - {duedate} <= 90 THEN '61-90 Days'
    ELSE 'Over 90 Days'
END

// Scrap percentage
ROUND(({quantityscrapped} / NULLIF({quantity}, 0)) * 100, 2) || '%'

// Production efficiency
ROUND(({quantitycompleted} / NULLIF({quantityplanned}, 0)) * 100, 1)

// Yield rate
ROUND(({quantitycompleted} / NULLIF({quantitystarted}, 0)) * 100, 2)

// Days of supply
{quantityonhand} / NULLIF({averagedailyusage}, 0)

// Reorder flag
CASE WHEN {quantityonhand} <= {reorderpoint} THEN 'REORDER' ELSE '' END

// Margin percentage
ROUND(({rate} - {costestimate}) / NULLIF({rate}, 0) * 100, 2)

// Utilization rate
ROUND(({billablehours} / NULLIF({availablehours}, 0)) * 100, 1) || '%'

// Budget burn rate
ROUND(({actualcost} / NULLIF({budgetedcost}, 0)) * 100, 1)

// Project health
CASE
    WHEN {percentcomplete} >= {percenttimecomplete} THEN 'On Track'
    WHEN {percentcomplete} >= {percenttimecomplete} * 0.8 THEN 'At Risk'
    ELSE 'Behind'
END

// Average transaction value
{totalrevenue} / NULLIF({transactioncount}, 0)

// Discount percentage
ROUND((1 - ({actualprice} / NULLIF({listprice}, 0))) * 100, 1) || '%'

// Sell-through rate
ROUND(({quantitysold} / NULLIF({quantityreceived}, 0)) * 100, 1)