Sync Odoo Product Updates to Shopify Products

This trigger checks your Odoo account hourly for any products that have been updated since the last check. When it detects changes to product records, it captures the product information including name, description, SKU, price, and variant count, then passes this data to the next step. The hourly schedule balances keeping data current with system performance.

This step queries Shopify's product database using the product name from Odoo. It searches for any products where the title matches and retrieves their IDs if found. The search results get passed to the next step for validation to make sure you're working with unique products only.

This filter examines the search results from the previous step and only allows the workflow to continue if fewer than 2 products were found (meaning 0 or 1 product). If 2 or more products exist with the same title, the workflow stops here to avoid updating the wrong product. The comparison happens automatically using the result count from the search step.

This rule examines whether the product search returned any results by checking if the first product ID is empty. If no product was found in the search step, this path activates and sends the workflow to the Create Product step. The check happens automatically using the search results from the Get Product By Title step.

This step sends a request to Shopify to create a new product using the product name as title, description as body HTML, and default SKU code from Odoo. The product appears immediately in Shopify once created, though variants with pricing get added in subsequent steps. You can customize which fields get included by editing the body configuration if you track additional product attributes in Odoo.

This rule checks whether the Odoo product variant count equals exactly 1. If the product has only one variant, this path activates and sends the workflow to create a single product variant with pricing. The check happens automatically using the variant count from the Odoo product trigger data.

This step creates a single product variant in Shopify for the newly created product and sets the price from the Odoo list price. Since this is a simple single-variant product, only the price needs to be configured. The variant gets created immediately and customers can start purchasing the product.

This rule checks whether the Odoo product variant count is greater than 1. If the product has multiple variants, this path activates and sends the workflow to loop through each Odoo variant and create corresponding Shopify variants. The check happens automatically using the variant count from the Odoo product data.

This loop step iterates through all the variant IDs from the Odoo product and processes each one individually. For each iteration, it passes the variant ID to subsequent steps that retrieve full variant details and create the Shopify variant. The loop continues until all Odoo variants have been processed and created in Shopify.

This step queries Odoo for the full variant details using the variant ID from the loop. It retrieves the variant's list price, default SKU code, and display name which contains the variant title information. All of this data gets passed forward to extract the variant name and create the Shopify variant with accurate details.

This custom JavaScript step parses the Odoo variant display name and extracts the text inside parentheses, which represents the variant title. For example, if the display name is "[SKU123] T-Shirt (Blue)", it extracts "Blue" as the variant title. This extracted title gets used in the next step to properly label the Shopify variant.

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

/**
 * A MESA Script exports a class with a script() method.
 */
module.exports = new class {

  /**
   * MESA Script
   *
   * @param {object} prevResponse The response from the previous step
   * @param {object} context Additional context about this task
   */
  script = (prevResponse, context) => {

    // Retrieve the Variables Available to this step
    const vars = context.steps;
    // For storing response
    let response = {};
    // Get Odoo product variant
    const odooProductVariant = vars.odoo_1;
    // Get display name
    let displayNameProductVariant = vars.odoo_1.display_name;

    // Extracting variant title
    let variantTitle = this.extractVariantTitle(displayNameProductVariant);

    // Add to response
    response.variant_title = variantTitle;

    // Call the next step in this workflow
    // response will be the Variables Available from this step
    Mesa.output.next(response);
  }

  /**
   * Extract the variant title
   *
   * @param {string} displayName
   */
  extractVariantTitle = (displayName) => {
    // Matches text inside parentheses. Example: Extract Blue from [TESTPRODUCTBLUE] Test Product (Blue)
    const match = displayName.match(/\(([^)]+)\)/);
    // Returns the matched text or null if no match
    return match ? match[1] : null;
  }
}

This step creates a Shopify product variant using the extracted variant title as option1, the list price from Odoo, and the default SKU code. The variant gets created for the product that was created in step 6, and all the variant details come from the Odoo variant data retrieved and processed in the previous steps.

This rule checks whether the product search returned a product ID, meaning the Odoo product already exists in your Shopify store. If a matching product was found in the search step, this path activates and routes to retrieve and update the existing product. The logic runs automatically based on the search results.

This step queries Shopify for the complete product record using the product ID found in the search step. It retrieves all product details including title, description, variants, and their associated data. This complete product information gets used in subsequent steps to update the product and manage variants intelligently.

This step sends updated product information to Shopify and overwrites the existing product's title, description, and base SKU with the current values from Odoo. You can add or remove fields to sync by editing the body configuration—for example, you might add vendor, product type, or tags if those fields exist in both systems. The product ID from the retrieve step tells Shopify exactly which product to update.

This rule checks whether the Odoo product variant count equals exactly 1. If the product has only one variant, this path activates and sends the workflow to update the single Shopify product variant with current pricing. The check happens automatically using the variant count from the Odoo product trigger data.

This step updates the first (and only) variant of the Shopify product with the current list price from Odoo. It uses the variant ID from the retrieved product data to target the exact variant to update. Since this is a single-variant product, only the price needs updating—title and SKU remain unchanged.

This rule checks whether the Odoo product variant count is greater than 1. If the product has multiple variants, this path activates and sends the workflow to retrieve both Odoo and Shopify variants, match them by SKU, then update or create variants as needed. The check happens automatically using the variant count from the Odoo product data.

This step queries Odoo for all variants that belong to the product being processed. It uses the variant IDs from the Odoo product to search and retrieve complete variant records including SKU, price, and display names. This complete Odoo variant data gets matched against Shopify variants in subsequent steps to determine which need updating and which need creating.

This step queries Shopify for all variants associated with the product being updated. It retrieves variant IDs, SKUs, prices, and other details for each variant. This Shopify variant data gets matched against the Odoo variants in the next step to identify which variants already exist and which are new.

This custom JavaScript step compares the Odoo variant list against the Shopify variant list using SKU as the matching field. For each Odoo variant, it searches for a Shopify variant with the same SKU and adds flags indicating whether a match exists plus the Shopify variant ID if found. This enriched data gets passed to the loop which processes each variant appropriately.

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

/**
 * A MESA Script exports a class with a script() method.
 */
module.exports = new class {

  /**
   * MESA Script
   *
   * @param {object} prevResponse The response from the previous step
   * @param {object} context Additional context about this task
   */
  script = (prevResponse, context) => {

    // Retrieve the Variables Available to this step
    const vars = context.steps;
    
    // For storing response
    let response = {};

    // Find a matching Shopify item based on SKU
    // Add has_shopify_match and Shopify variant ID and product ID if a match is found
    let updatedOdooProductVariants = vars.odoo_2.map(odooItem => {
      let shopifyMatch = vars.shopify_7.find(shopifyItem => shopifyItem.sku === odooItem.default_code);

      return {
        ...odooItem,
        has_shopify_match: shopifyMatch ? "yes" : "no",
        shopify_variant_id: shopifyMatch ? shopifyMatch.id : null,
        shopify_product_id: shopifyMatch ? shopifyMatch.product_id : null
      };
    });

    // Add to response
    response.updated_odoo_product_variants = updatedOdooProductVariants;

    // Call the next step in this workflow
    // response will be the Variables Available from this step
    Mesa.output.next(response);
  }
}

This loop step iterates through all the enriched Odoo variants from the matching code step and processes each one individually. For each iteration, it checks whether a Shopify match exists and routes to either create a new variant or update the existing one. The loop continues until all Odoo variants have been synchronized to Shopify.

This rule checks whether the has_shopify_match field equals "no" for the current variant in the loop. If no matching Shopify variant was found by SKU, this path activates and sends the workflow to extract the variant title and create a new Shopify variant. The check happens automatically using the matching data from the custom code step.

This custom JavaScript step parses the Odoo variant display name from the loop and extracts the text inside parentheses, which represents the variant title. The extracted title gets used in the next step to properly label the new Shopify variant being created.

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

/**
 * A MESA Script exports a class with a script() method.
 */
module.exports = new class {

  /**
   * MESA Script
   *
   * @param {object} prevResponse The response from the previous step
   * @param {object} context Additional context about this task
   */
  script = (prevResponse, context) => {

    // Retrieve the Variables Available to this step
    const vars = context.steps;

    let response = {};
    // Get Odoo product variant
    const odooProductVariant = vars.loop_2;
    // Get display name
    let displayNameProductVariant = vars.loop_2.display_name;

    // Extracting variant title
    let variantTitle = this.extractVariantTitle(displayNameProductVariant);

    // Add to response
    response.variant_title = variantTitle;

    // Call the next step in this workflow
    // response will be the Variables Available from this step
    Mesa.output.next(response);
  }

  /**
   * Extract the variant title
   *
   * @param {string} displayName
   */
  extractVariantTitle = (displayName) => {
    const match = displayName.match(/\(([^)]+)\)/); // Matches text inside parentheses
    return match ? match[1] : null; // Returns the matched text or null if no match
  }
}

This step creates a Shopify product variant using the extracted variant title as option1, the list price from the Odoo variant data in the loop, and the default SKU code. The variant gets created for the existing product being updated, expanding the available options customers can purchase.

This rule checks whether the has_shopify_match field equals "yes" for the current variant in the loop. If a matching Shopify variant was found by SKU, this path activates and sends the workflow to extract the current variant title and update the existing Shopify variant. The check happens automatically using the matching data from the custom code step.

This custom JavaScript step parses the Odoo variant display name from the loop and extracts the text inside parentheses, which represents the current variant title. The extracted title gets used in the next step to update the Shopify variant with current naming from Odoo.

This step updates an existing Shopify product variant using the Shopify variant ID from the matching code step. It overwrites the variant's option1 with the extracted title, price with the current Odoo list price, and SKU with the Odoo default code. The variant gets updated immediately with current information from Odoo.