Reading and Writing Data Using the NetSuite API

Hey there, fellow JavaScript wizards! Ready to dive into the world of NetSuite API? Let's get our hands dirty with some data syncing for user-facing integrations. Buckle up!

Introduction

NetSuite's API is a powerhouse for managing business data. When it comes to user-facing integrations, syncing data efficiently is crucial. We'll explore how to read, write, and keep data in sync using NetSuite's API, with a focus on real-world scenarios.

Setting up the NetSuite API

First things first, let's get that API connection up and running.

Authentication

NetSuite uses OAuth 2.0 for authentication. Here's a quick setup:

const OAuth = require('oauth-1.0a');
const crypto = require('crypto');

const oauth = OAuth({
  consumer: { key: 'your_consumer_key', secret: 'your_consumer_secret' },
  signature_method: 'HMAC-SHA1',
  hash_function(base_string, key) {
    return crypto.createHmac('sha1', key).update(base_string).digest('base64');
  },
});

Initializing the API Client

Now, let's initialize our API client:

const axios = require('axios');

const netsuite = axios.create({
  baseURL: 'https://your-account.suitetalk.api.netsuite.com/services/rest/record/v1',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': oauth.toHeader(oauth.authorize({
      url: 'https://your-account.suitetalk.api.netsuite.com/services/rest/record/v1',
      method: 'GET'
    })).Authorization
  }
});

Reading Data from NetSuite

SuiteQL is your best friend for efficient queries. Let's fetch some customer data:

async function getCustomers() {
  const query = `SELECT id, companyname, email FROM customer WHERE isinactive = 'F'`;
  const response = await netsuite.post('/query', { q: query });
  return response.data.items;
}

Writing Data to NetSuite

Updating records is a breeze. Here's how to update inventory levels:

async function updateInventory(itemId, quantity) {
  const payload = {
    quantity: quantity
  };
  await netsuite.patch(`/inventoryitem/${itemId}`, payload);
}

Implementing Real-time Sync

Webhooks are your go-to for instant updates. Here's a simple Express.js webhook listener:

const express = require('express');
const app = express();

app.post('/webhook', express.json(), (req, res) => {
  const { event, payload } = req.body;
  console.log(`Received ${event} event:`, payload);
  // Process the webhook payload
  res.sendStatus(200);
});

app.listen(3000, () => console.log('Webhook listener running on port 3000'));

Handling Bulk Operations

For large datasets, SuiteScript 2.0 is your best bet. Here's a bulk customer import:

/**
 * @NApiVersion 2.0
 * @NScriptType MapReduceScript
 */
define(['N/record'], function(record) {
    function getInputData() {
        return JSON.parse(runtime.getCurrentScript().getParameter({name: 'custscript_customer_data'}));
    }

    function map(context) {
        var customerData = JSON.parse(context.value);
        var customerId = record.create({
            type: record.Type.CUSTOMER,
            isDynamic: true,
            defaultValues: customerData
        }).save();
        context.write(customerId, customerData.email);
    }

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

Error Handling and Retry Mechanisms

Always be prepared for API hiccups. Here's a retry mechanism with exponential backoff:

async function retryOperation(operation, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await operation();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 1000));
    }
  }
}

Optimizing API Usage

Remember, NetSuite has rate limits. Implement caching for frequently accessed data:

const NodeCache = require('node-cache');
const cache = new NodeCache({ stdTTL: 600 }); // 10 minutes TTL

async function getCachedCustomer(id) {
  let customer = cache.get(id);
  if (!customer) {
    customer = await getCustomer(id);
    cache.set(id, customer);
  }
  return customer;
}

Testing and Debugging

Always use NetSuite's sandbox environment for testing. Log API calls for easier debugging:

netsuite.interceptors.request.use(request => {
  console.log('Starting Request', request);
  return request;
});

netsuite.interceptors.response.use(response => {
  console.log('Response:', response);
  return response;
});

Conclusion

And there you have it! You're now equipped to tackle NetSuite API integrations like a pro. Remember to keep your code clean, handle errors gracefully, and always optimize for performance. Happy coding, and may your API calls always return 200 OK!

For more advanced topics, check out NetSuite's official documentation and join the developer community. The sky's the limit with what you can build!