Add Shopify Product Tags Using SKU Pattern Rules

This trigger monitors your Shopify store and activates whenever you create a new product. It captures the complete product data including all variants and their SKUs, which get passed to the pattern-matching steps. The trigger fires immediately after you save a new product in Shopify, processing tags before you even navigate away from the product page. No configuration needed—this works automatically once you activate the workflow.

This mapping step defines the relationship between SKU patterns and product tags. You create rows where the "Destination" field contains the tag name you want to apply, and the "Source" field contains the SKU pattern to match. For example, mapping "Panda" to "PANDA-" means any SKU starting with "PANDA-" gets the "Panda" tag. The mapping supports partial matches, so "TOWEL" catches "BEACH-TOWEL-001" and "HAND-TOWEL-SM" equally well.

Add one row for each tag you want to automate. Common examples include brand prefixes (NIKE-, ADIDAS-), product categories (SHIRT, PANT, SHOE), or seasonal codes (SS24, FW24). The pattern matching is case-sensitive, so "PANDA-" and "panda-" are treated as different patterns.

This custom code transforms your tag-to-pattern mapping into an array structure that the loop steps can iterate through. It takes each row from your mapping and creates an object containing both the tag name and its pattern, then bundles all these objects into a single array. This conversion happens automatically and requires no input from you—the code simply reformats data so the next steps can process it efficiently.

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

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

    // Create an array of tags and patterns
    let array = [];
    for (let tag in vars.transform) {
      array.push({
        "tag": tag,
        "pattern": vars.transform[tag]
      });
    }

    Mesa.output.next({"array": array});
  }
}

This code loops through your mapping and builds an array that subsequent steps can iterate through to test each pattern.

This loop processes each product variant separately by iterating through the variants array from the trigger. If your new product is a t-shirt with small, medium, and large sizes, this creates three separate processes—one for each size. Each variant's data (especially its SKU) gets passed to the pattern-checking steps. Products with only one variant still go through this loop once, maintaining consistency in how the workflow processes all products.

This second loop runs inside the variant loop and checks each variant against every pattern rule you defined. For each variant, it iterates through the array created in step 3, testing one pattern at a time. If you have 10 pattern rules and a product with 3 variants, this creates 30 individual pattern-checking processes. This nested approach ensures comprehensive tagging where a single product can match multiple patterns and receive all applicable tags.

This custom code uses regular expressions to compare the variant's SKU against the current pattern. It takes the pattern from the loop and tests whether the SKU starts with or contains that pattern. The code returns a match indicator (1 for match, 0 for no match) that the next filter uses to decide whether to continue. If a variant doesn't have a SKU assigned, the code throws an error with instructions to add one, preventing the workflow from proceeding with incomplete data.

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

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

    let pattern = vars.loop_2.pattern;
    let tag = vars.loop_2.tag;

    // Check regex match of pattern and tag
    let regex = new RegExp(`${pattern}.*`, 'g');
    if (vars && vars.loop && vars.loop.sku) {
      let match = vars.loop.sku.match(regex);
      Mesa.log.info("match", match);

      let isMatch = (match !== null);    
      Mesa.trigger.setTaskExternalData({
        label: "SKU " + vars.loop.sku + " matches pattern " + pattern + ": " + isMatch,
      });  

      Mesa.output.next({"is_match": isMatch});
    } else {
      throw new Error(`No product variant SKU found. Please add a SKU for product variant ${vars.loop.title}. Then replay this task.`);
    }
  }
}

The regex pattern uses .* which means "followed by anything," so "PANDA-" matches "PANDA-001," "PANDA-BAMBOO," or any other SKU starting with that prefix.

This filter checks the match indicator from the previous step and only allows the workflow to continue if it equals 1 (meaning a match was found). When the SKU doesn't match the current pattern, this filter stops processing for this pattern and moves to the next one in the loop. This gate-keeping prevents unnecessary API calls and ensures only relevant tags get applied to products.

This step fetches the complete, current product data from Shopify to get the latest tag list. Even though the trigger provided initial product data, this retrieval ensures accuracy by grabbing real-time information directly from your store. The step specifically targets the product using its ID and returns all fields, but the workflow primarily uses the tags field to check what tags already exist.

This filter checks whether the matching tag already exists on the product by examining the tags string from the retrieve step. If the product already has "Panda" as a tag, this filter stops the workflow from adding it again. Only products missing the tag pass through this filter to the add tag step. This prevents duplicate tags from accumulating each time you edit and re-save a product.

This step adds the matched tag to the product in Shopify. It takes the tag name from the current loop iteration and appends it to the product's existing tags without removing any tags that were already there. The action completes immediately and the tag appears on the product in your Shopify admin. After this step, the workflow returns to the pattern loop to check if any remaining patterns also match this variant.