Reading and Writing Data Using the Adobe Commerce API

Hey there, fellow JavaScript devs! Ready to dive into the world of Adobe Commerce API? Let's get our hands dirty with some data syncing for user-facing integrations. Buckle up, because we're about to make your e-commerce projects a whole lot smoother.

Authentication: Your Golden Ticket

First things first, we need to get you authenticated. Grab your API credentials and let's implement that OAuth 2.0 flow. Here's a quick snippet to get you started:

const getAccessToken = async (clientId, clientSecret) => {
  const response = await fetch('https://your-store.com/oauth/token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      grant_type: 'client_credentials',
      client_id: clientId,
      client_secret: clientSecret
    })
  });
  const data = await response.json();
  return data.access_token;
};

Reading Data: Knowledge is Power

Fetching Product Info

Let's grab some product data using GraphQL. Here's a query that'll fetch you the goods:

const getProducts = async (accessToken) => {
  const query = `
    query {
      products(pageSize: 20) {
        items {
          sku
          name
          price {
            regularPrice {
              amount {
                value
                currency
              }
            }
          }
        }
      }
    }
  `;

  const response = await fetch('https://your-store.com/graphql', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${accessToken}`
    },
    body: JSON.stringify({ query })
  });

  return response.json();
};

Retrieving Customer Data

For customer data, we'll hit up the REST API:

const getCustomer = async (accessToken, customerId) => {
  const response = await fetch(`https://your-store.com/rest/V1/customers/${customerId}`, {
    headers: { 'Authorization': `Bearer ${accessToken}` }
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  return response.json();
};

Writing Data: Make Your Mark

Updating Product Inventory

Time to update that inventory. Here's a PUT request to make it happen:

const updateInventory = async (accessToken, sku, quantity) => {
  const response = await fetch(`https://your-store.com/rest/V1/products/${sku}/stockItems/1`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${accessToken}`
    },
    body: JSON.stringify({ stockItem: { qty: quantity } })
  });

  return response.json();
};

Creating Customer Orders

Let's create an order with a GraphQL mutation:

const createOrder = async (accessToken, input) => {
  const mutation = `
    mutation ($input: PlaceOrderInput!) {
      placeOrder(input: $input) {
        order {
          order_number
        }
      }
    }
  `;

  const response = await fetch('https://your-store.com/graphql', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${accessToken}`
    },
    body: JSON.stringify({ query: mutation, variables: { input } })
  });

  return response.json();
};

Syncing Strategies: Keep It Fresh

Real-time Synchronization

WebHooks are your best friend for real-time updates. Set them up to listen for changes and trigger your sync functions.

Batch Synchronization

For less time-sensitive data, scheduled jobs are the way to go. Here's a simple cron job setup:

const cron = require('node-cron');

cron.schedule('0 0 * * *', () => {
  console.log('Running a sync job at midnight every day');
  // Your sync function here
});

Performance Optimization: Speed Demon

Cache aggressively and respect those rate limits, folks! Here's a basic caching example:

const NodeCache = require('node-cache');
const myCache = new NodeCache({ stdTTL: 100, checkperiod: 120 });

const getCachedData = async (key, fetchFunction) => {
  const value = myCache.get(key);
  if (value) return value;

  const result = await fetchFunction();
  myCache.set(key, result);
  return result;
};

Error Handling and Logging: Don't Fly Blind

Always wrap your API calls in try-catch blocks and log those errors. Your future self will thank you!

const apiCall = async () => {
  try {
    // Your API call here
  } catch (error) {
    console.error('API call failed:', error);
    // Maybe retry or notify someone
  }
};

Security Considerations: Lock It Down

Always sanitize your inputs and encrypt sensitive data. Here's a quick input sanitization example:

const sanitizeInput = (input) => {
  return input.replace(/[^\w\s]/gi, '');
};

Testing and Debugging: Trust, but Verify

Unit test those API calls and mock responses for consistent testing. Here's a Jest example:

jest.mock('node-fetch');

test('getProducts fetches data correctly', async () => {
  fetch.mockResolvedValue({
    json: () => Promise.resolve({ data: { products: { items: [] } } })
  });

  const result = await getProducts('fake-token');
  expect(result.data.products.items).toEqual([]);
});

Wrapping Up

There you have it, folks! You're now armed with the knowledge to read and write data like a pro using the Adobe Commerce API. Remember to keep your code clean, your errors logged, and your data secure. Happy coding, and may your integrations be ever smooth and your data always in sync!