Mastering Liquid: Safely Handling Blank Metafields in Shopify JSON Events

Hey there, fellow store owners and developers! Ever found yourself pulling your hair out trying to get your Shopify Flow automations or custom integrations to send perfectly formatted JSON data, only to have it break when a metafield is left blank? You're definitely not alone. This is a super common hurdle, and it was the hot topic in a recent community discussion that really sparked some great insights.

Our friend @ctevan kicked off the thread with a classic scenario: trying to include an optional "Eco advisor" metafield from Draft Orders in a Klaviyo event. The challenge? When that metafield was empty, the JSON payload would just… well, break. They wanted it to send "none" instead of nothing, but Liquid wasn't cooperating with their attempts like {% if getDraftOrderDataForeachitem.ecoAdvisor.value %} or checking for nil.

The Metafield Mystery: Why Empty Isn't Always 'False' in Liquid

This is where things get a little quirky with Liquid. As @One-Sun1995 wisely pointed out, an unset list metafield still comes back as an empty array. And here's the kicker: an empty array is actually considered "truthy" in Liquid. So, your {% if eco %} condition passes, but then there's nothing for your loop to iterate over, or it just outputs an empty string, leaving your JSON malformed. It's a subtle but critical distinction!

The key takeaway here is that for list metafields, you often need to check for the size. So, instead of just {% if eco %}, you'd want something like {% if eco and eco.size > 0 %}. This ensures you're not just checking if the metafield object exists, but if it actually contains any values.

The JSON Filter: Your Best Friend for Robust Payloads

One of the most valuable pieces of advice that emerged from the discussion, echoed by both @IndustryInsightsDesk and @Josh-FiveAcreCode, is to consistently use Liquid's | json filter. This filter is an absolute lifesaver for dynamic JSON generation. Why? Because it automatically:

• Adds the necessary quotes around string values.
• Escapes any special characters (like double quotes, backslashes, newlines) within your string, preventing your JSON from breaking.

Manually adding quotes ("{{ value }}") is risky because if your value itself contains a quote, it'll mess up your JSON structure. The | json filter handles all that for you, making your code much more robust and less prone to unexpected errors.

Three Smart Ways to Handle Blank Metafields in JSON

Based on the community's collective wisdom, there are generally three excellent ways to deal with optional metafields when crafting JSON. Let's break them down with practical Liquid examples.

Option 1: Output a Default String (e.g., "none")

This is what @ctevan originally aimed for. The trick is to ensure your default string is properly quoted and that you handle the list metafield correctly. For a list, you'll likely want to join its values first.

Here’s a robust way to do it, combining insights from @One-Sun1995 and @IndustryInsightsDesk:

{% assign eco = getDraftOrderDataForeachitem.ecoAdvisor.value %}
"eco_advisor": {% if eco and eco.size > 0 %}{{ eco | join: ', ' | json }}{% else %}"none"{% endif %},

Notice how we're using eco | join: ', ' | json. This first joins the list items into a single string (e.g., "Advisor A, Advisor B"), and then the | json filter adds the quotes and escapes it perfectly. If it's empty, we fall back to a safely quoted "none".

Option 2: Output JSON null

For many APIs, sending a true JSON null value is a cleaner way to indicate an empty or unset field. It's semantically correct and often preferred over a string like "none". Remember, null should NOT be quoted in JSON.

This approach was highlighted by @Josh-FiveAcreCode:

{% assign event_code = order.metafields.custom.event_code.value %}

{
  "order_id": {{ order.id | json }},
  "event_code":
  {% if event_code != blank %}
    {{ event_code | json }}
  {% else %}
    null
  {% endif %}
}

In this example, order.metafields.custom.event_code.value would be a single value, not a list. If it were a list, you'd apply the same join logic as in Option 1 before the | json filter, and use eco.size > 0 for the condition. The != blank check is suitable for single-value metafields.

Option 3: Omit the Field Entirely When Blank

Sometimes, if a field is optional and has no value, you might not want to include it in your JSON payload at all. This keeps your JSON leaner and can simplify parsing on the receiving end. This is also a fantastic pattern shared by @Josh-FiveAcreCode:

{% assign event_code = order.metafields.custom.event_code.value %}

{
  "order_id": {{ order.id | json }}
  {% if event_code != blank %},
  "event_code": {{ event_code | json }}
  {% endif %}
}

The key here is the comma placement. The comma before "event_code" is only included if event_code actually has a value. This prevents a trailing comma error if the field is omitted. Again, for list metafields, you'd adapt the event_code assignment and the `if` condition to use `eco` and `eco.size > 0`.

Putting It All Together for Your Shopify Flow

So, to bring it back to @ctevan's original problem with the "Eco advisor" list metafield in a Shopify Flow context, here's how you might apply these principles:

Let's say you want to output "none" if the list is empty, and a comma-separated, properly quoted string if it has values:

{% comment %} First, safely assign the metafield value {% endcomment %}
{% assign eco_advisor_values = getDraftOrderDataForeachitem.ecoAdvisor.value %}

{% comment %} Check if it's a list and has items, then join and JSON-escape {% endcomment %}
"eco_advisor": {% if eco_advisor_values and eco_advisor_values.size > 0 %}{{ eco_advisor_values | join: ', ' | json }}{% else %}"none"{% endif %},

This snippet is a robust solution that takes care of the truthiness of empty arrays, ensures proper JSON formatting with the | json filter, and provides a graceful fallback for blank metafields. Always remember to test your JSON output thoroughly with both filled and empty metafields to ensure it's valid!

The community really came through on this one, offering varied but equally valid approaches depending on your specific needs. The core lesson is to understand how Liquid handles different data types, especially when they're empty, and to leverage the powerful | json filter for bulletproof JSON generation. Happy coding!