Sync Shopify Orders to Salesforce Opportunities with Opportunity Products

When any order is created in Shopify—whether from your online store, draft orders converted to paid, or any other order source—this trigger captures the complete order details including customer ID, line items, pricing, discounts, and order notes. The trigger watches your store continuously and passes the order data to the next step immediately after the order is placed.

The step queries Salesforce's Account object searching for a record where the custom field "Shopify_Customer_ID__c" matches the customer ID from the Shopify order. This custom field gets populated by the dependency workflow that syncs Shopify customers to Salesforce Accounts. The query returns the Account ID and Name, which get used in the opportunity creation step to properly link the records. If no matching Account is found, this workflow will fail—which is why the customer sync dependency workflow must be running first.

The code iterates through all line items in the Shopify order, extracts each product variant ID, and creates a comma-separated list formatted for Salesforce's SQL-style query syntax. For example, if an order contains three products, this step outputs something like '123456789','987654321','456789123' which the next step uses in a WHERE clause to find all matching products in one query. Here's the code:

const Mesa = require('vendor/Mesa.js');

module.exports = new class {
  script = (payload, context) => {
    const lineItems = context.steps['shopify-order-created'].line_items;

    let variantIds = lineItems.map(lineItem => {
      return `'${lineItem.variant_id}'`;
    });

    payload.variant_ids = variantIds;
    payload.variant_ids_csv = variantIds.join();

    Mesa.output.next(payload);
  }
}

The step queries Salesforce's Product2 object searching for records where the custom field "Shopify_Variant_Id__c" matches any of the variant IDs from Step 3. This custom field gets populated by the product sync dependency workflow. The query returns multiple Product records in one API call—one for each unique product in the order—including their Salesforce IDs and Shopify variant IDs. These IDs get used later to create OpportunityLineItem records that link products to the opportunity.

The transform maps several key fields:

• AccountId: Uses the Salesforce Account ID from Step 2 to link the opportunity
• Amount: Uses the Shopify order total price
• CloseDate: Uses the order creation date
• Description: Uses the Shopify order notes
• StageName: Hard-coded to "Closed Won" since the order already completed
• Pricebook2Id: You must manually enter your Salesforce Price Book ID here (see configuration instructions below)
• Name: Combines the Account name and Shopify order name (like "Acme Corp - #1234")

Critical Configuration: You must enter your Salesforce Price Book ID in the "Pricebook2Id" field. To find this: log into Salesforce, go to Price Books, click your desired price book, and copy the ID from the URL between r/ and /view. For example, in https://ab11.force.com/lightning/r/01s2E000002pddCQAQ/view, the ID is 01s2E000002pddCQAQ.

The step sends a POST request to Salesforce's Opportunity API endpoint with the transformed data from Step 5. Salesforce creates a new Opportunity record linked to the customer's Account, sets the stage to "Closed Won," records the order total as the opportunity amount, and uses the order date as the close date. The newly created Opportunity ID gets returned and is used in subsequent steps to create the associated product line items.

The code takes the line items from the Shopify order and the Salesforce products from Step 4, then matches them by comparing Shopify variant IDs. For each line item, it finds the matching Salesforce product and adds a new field called "salesforce_product_id" to that line item. This enriched line item data gets passed to the loop so each iteration has both the Shopify product details and the Salesforce Product ID needed to create the OpportunityLineItem. Here's the code:

const Mesa = require('vendor/Mesa.js');

module.exports = new (class {
  script = (payload, context) => {
    const salesforceProducts =
      context.steps['salesforce-query-multiple-product'];

    let lineItems = context.steps['shopify-order-created'].line_items;

    lineItems.forEach((lineItem, key) => {
      let salesforceProduct = salesforceProducts.filter(
        product =>
        product.Shopify_Variant_ID__c == lineItem.variant_id
      );

      if (salesforceProduct && salesforceProduct.length > 0) {
        lineItems[key]['salesforce_product_id'] = salesforceProduct[0].Id;
      }
    });

    const newPayload = {};
    newPayload.line_items = lineItems;

    Mesa.output.next(newPayload);
  };
})();

The loop iterates through all line items from Step 7 (which now include the Salesforce Product IDs), processing one product at a time through the remaining workflow steps. For example, if an order contains a t-shirt, a hat, and a mug, the loop runs three times—once for each item—creating three separate OpportunityLineItem records linked to the same Opportunity. This structure allows orders of any size to sync completely to Salesforce.

The transform maps:

• OpportunityId: Uses the Opportunity ID created in Step 6
• UnitPrice: Uses the line item price from Shopify
• Quantity: Uses the line item quantity
• Product2Id: Uses the Salesforce Product ID appended in Step 7

Additionally, the custom transform code calculates discount percentages if any discounts were applied to the line item. It takes the discount amount, divides it by the total line item price (unit price × quantity), and converts it to a percentage. Here's the transform code:

const Mesa = require('vendor/Mesa.js');
const Transform = require('vendor/Transform.js');

module.exports = new class {
  script = (payload, context) => {
    const currentItem = context.steps.loop;

    const output = Transform.convert(context, payload);

    // Add discounts
    let totalDiscounts = parseFloat(currentItem.total_discount_set.shop_money.amount);

    if (currentItem.discount_allocations && currentItem.discount_allocations) {
      totalDiscounts = currentItem.discount_allocations.reduce((a, {amount}) => a + parseFloat(amount), 0);
    }

    if (totalDiscounts && totalDiscounts > 0) {
      // Get total price for line item (quantity * unit price, then divide by discount to get percentage)
      output['Discount'] = parseFloat(totalDiscounts / (output.UnitPrice * output.Quantity) * 100);
    }

    Mesa.output.next(output);
  }
}

The step sends a POST request to Salesforce's OpportunityLineItem API endpoint with the transformed data from Step 9. Salesforce creates a new OpportunityLineItem record for the current line item in the loop, linking it to the Opportunity created in Step 6 and the Product from your Salesforce catalog. This includes quantity, unit price, and any calculated discounts. The loop continues until all line items have been processed and added to the opportunity.