Auto-Apply Tax/Nexus by Region (SuiteScript 2.1)

[
  { "country":"CA", "state":"ON", "subsidiary": "2", "nexus": "5",  "taxcode": "1234", "taxitem": "",   "note":"Canada HST ON" },
  { "country":"CA", "state":"BC", "subsidiary": "2", "nexus": "6",  "taxcode": "2345", "taxitem": "",   "note":"Canada GST+PST BC" },
  { "country":"US", "state":"CA", "subsidiary": "1", "nexus": "10", "taxcode": "3456", "taxitem": "",   "note":"US CA State Tax" },
  { "country":"US", "state":"",   "subsidiary": "1", "nexus": "11", "taxcode": "4567", "taxitem": "",   "note":"US no-state default" },
  { "country":"GB", "state":"",   "subsidiary": "3", "nexus": "20", "taxcode": "5678", "taxitem": "",   "note":"UK VAT Std" }
]

/**
 * @NApiVersion 2.1
 * @NScriptType UserEventScript
 * Title: UE | Auto-Apply Tax/Nexus by Region
 * Author: The NetSuite Pro
 */
define(['N/runtime','N/record','N/log'], (runtime, record, log) => {

  const P_RULES = 'custscript_tax_rules_json';
  const F_EXEMPT = 'custentity_tax_exempt';                 // change if you use another flag
  const F_APPLIED_NOTE = 'custbody_tax_applied_note';        // optional
  const F_NEXUS = 'nexus';                                   // SuiteTax body field
  const F_TAXITEM_BODY = 'taxitem';                          // Legacy body tax
  const F_SHIP_COUNTRY = 'shipcountry';
  const F_SHIP_STATE = 'shipstate';

  const SUITETAX = runtime.isFeatureInEffect({ feature: runtime.Feature.SUITETAX });

  const beforeSubmit = (ctx) => {
    if (![ctx.UserEventType.CREATE, ctx.UserEventType.EDIT, ctx.UserEventType.COPY].includes(ctx.type)) return;

    const rec = ctx.newRecord;
    const type = rec.type; // salesorder or invoice

    try {
      // Bail out if no shipping country; e.g., service invoices
      const shipCountry = (rec.getValue(F_SHIP_COUNTRY) || '').toString().toUpperCase();
      const shipState = (rec.getValue(F_SHIP_STATE) || '').toString().toUpperCase();
      const subsidiary = (rec.getValue('subsidiary') || '').toString();
      if (!shipCountry || !subsidiary) return;

      // Customer exemption?
      const customerId = rec.getValue('entity');
      const isExempt = safeGetCustomerExempt(customerId);

      const rules = loadRules();
      const rule = findRule(rules, shipCountry, shipState, subsidiary);
      if (!rule) {
        log.debug('No matching tax rule', { shipCountry, shipState, subsidiary });
        return;
      }

      if (isExempt) {
        // For exempt customers: ensure no tax. Behavior differs per setup.
        applyExempt(rec);
        setNote(rec, `Exempt: no tax applied (${rule.note || 'by rule'})`);
        return;
      }

      if (SUITETAX) {
        applySuiteTax(rec, rule);
        setNote(rec, rule.note || `SuiteTax: nexus ${rule.nexus}, taxcode ${rule.taxcode}`);
      } else {
        applyLegacyTax(rec, rule);
        setNote(rec, rule.note || `Legacy tax: taxitem ${rule.taxitem || '(none)'} / taxcode ${rule.taxcode || '(line)'}`);
      }

    } catch (e) {
      log.error('Auto Tax UE error', e);
    }
  };

  function loadRules() {
    try {
      const json = runtime.getCurrentScript().getParameter({ name: P_RULES }) || '[]';
      return JSON.parse(json);
    } catch (_e) { return []; }
  }

  function findRule(rules, country, state, subsidiary) {
    // First pass: country+state+subsidiary
    let r = rules.find(x => eq(x.country,country) && eq(x.state,state) && eq(x.subsidiary,subsidiary));
    if (r) return r;
    // Fallback: country-only+subsidiary
    r = rules.find(x => eq(x.country,country) && !x.state && eq(x.subsidiary,subsidiary));
    return r || null;
  }

  function eq(a,b){ return String(a||'').toUpperCase() === String(b||'').toUpperCase(); }

  function safeGetCustomerExempt(customerId) {
    try {
      if (!customerId) return false;
      const c = record.load({ type: record.Type.CUSTOMER, id: customerId });
      return !!c.getValue(F_EXEMPT);
    } catch (_e) {
      return false;
    }
  }

  // ---- SuiteTax path ----
  function applySuiteTax(rec, rule) {
    if (rule.nexus) rec.setValue({ fieldId: F_NEXUS, value: Number(rule.nexus) });

    // If you also maintain explicit tax codes per line:
    if (rule.taxcode) {
      const lineCount = rec.getLineCount({ sublistId: 'item' });
      for (let i = 0; i < lineCount; i++) {
        // skip non-taxable lines (e.g., description-only) if needed
        const item = rec.getSublistValue({ sublistId:'item', fieldId:'item', line:i });
        if (!item) continue;
        // In SuiteTax, many accounts allow setting 'taxcode' per line still:
        try {
          rec.setSublistValue({ sublistId:'item', fieldId:'taxcode', line:i, value: Number(rule.taxcode) });
        } catch (_ignore) {
          // Some tenants lock taxcode (calculated by engine) — safe to ignore
        }
      }
    }
  }

  // ---- Legacy tax path ----
  function applyLegacyTax(rec, rule) {
    if (rule.taxitem) {
      rec.setValue({ fieldId: F_TAXITEM_BODY, value: Number(rule.taxitem) });
    }
    if (rule.taxcode) {
      const cnt = rec.getLineCount({ sublistId:'item' });
      for (let i = 0; i < cnt; i++) {
        const item = rec.getSublistValue({ sublistId:'item', fieldId:'item', line:i });
        if (!item) continue;
        rec.setSublistValue({ sublistId:'item', fieldId:'taxcode', line:i, value: Number(rule.taxcode) });
      }
    }
  }

  // ---- Exempt handling (generic) ----
  function applyExempt(rec) {
    // Approach 1: set an exempt tax code on lines (preferred if you manage a specific exempt code)
    const cnt = rec.getLineCount({ sublistId:'item' });
    for (let i = 0; i < cnt; i++) {
      try {
        // Replace with your exempt code internal ID if you manage one:
        // rec.setSublistValue({ sublistId:'item', fieldId:'taxcode', line:i, value: 999 }); 
        // Or mark non-taxable item logic; leave blank here as many tenants calculate zero via certificates.
      } catch (_e) {}
    }
  }

  function setNote(rec, msg) {
    try {
      if (F_APPLIED_NOTE) rec.setValue({ fieldId: F_APPLIED_NOTE, value: msg });
    } catch (_e) {}
  }

  return { beforeSubmit };
});