Cart Transform Function API

cart.transform.run

Input Query (Rust)

query Input {
  presentmentCurrencyRate
  cart {
    lines {
      id
      quantity
      cost {
        amountPerQuantity {
          amount
          currencyCode
        }
      }
      # Access the cart line attribute to decide if we should add a warranty
      giftWrapAdded: attribute(key: "Gift Wrap Added") {
        value
      }
      merchandise {
        __typename
        ... on ProductVariant {
          id
          title
          product {
            # Access the metafield value to determine the cost of the gift wrap
            giftWrapCost: metafield(namespace: "$app:gift-wrap", key: "cost") {
              type
              jsonValue
            }
          }
        }
      }
    }
  }
  cartTransform {
    # Access the variant ID that represents the warranty product
    giftWrapVariantID: metafield(namespace: "$app:optional-add-ons", key: "function-configuration") {
      value
    }
  }
}

Input Query (JavaScript)

query RunInput {
  presentmentCurrencyRate
  cart {
    lines {
      id
      quantity
      cost {
        amountPerQuantity {
          amount
          currencyCode
        }
      }
      # Access the cart line attribute to decide if we should add a warranty
      giftWrapAdded: attribute(key: "Gift Wrap Added") {
        value
      }
      merchandise {
        __typename
        ... on ProductVariant {
          id
          title
          product {
            # Access the metafield value to determine the cost of the gift wrap
            giftWrapCost: metafield(namespace: "$app:gift-wrap", key: "cost") {
              type
              value
            }
          }
        }
      }
    }
  }
  cartTransform {
    # Access the variant ID that represents the warranty product
    giftWrapVariantID: metafield(namespace: "$app:optional-add-ons", key: "function-configuration") {
      value
    }
  }
}

Input Object (Rust)

{
  "presentmentCurrencyRate": "1.0",
  "cart": {
    "lines": [
      {
        "id": "gid://shopify/CartLine/1",
        "quantity": 1,
        "cost": {
          "amountPerQuantity": {
            "amount": "100.0",
            "currencyCode": "CAD"
          }
        },
        "giftWrapAdded": {
          "value": "No"
        },
        "merchandise": {
          "__typename": "ProductVariant",
          "id": "gid://shopify/ProductVariant/1099",
          "title": "Something that is not wrapped",
          "product": {
            "giftWrapCost": {
              "type": "money",
              "jsonValue": {
                "amount": "5.00",
                "currencyCode": "CAD"
              }
            }
          }
        }
      },
      {
        "id": "gid://shopify/CartLine/2",
        "quantity": 5,
        "cost": {
          "amountPerQuantity": {
            "amount": "100.0",
            "currencyCode": "CAD"
          }
        },
        "giftWrapAdded": {
          "value": "Yes"
        },
        "merchandise": {
          "__typename": "ProductVariant",
          "id": "gid://shopify/ProductVariant/456",
          "title": "Something that is wrapped",
          "product": {
            "giftWrapCost": {
              "type": "money",
              "jsonValue": {
                "amount": "5.00",
                "currencyCode": "CAD"
              }
            }
          }
        }
      }
    ]
  },
  "cartTransform": {
    "giftWrapVariantID": {
      "value": "gid://shopify/ProductVariant/2"
    }
  }
}

Input Object (JavaScript)

{
  "presentmentCurrencyRate": "1.0",
  "cart": {
    "lines": [
      {
        "id": "gid://shopify/CartLine/1",
        "quantity": 1,
        "cost": {
          "amountPerQuantity": {
            "amount": "100.0",
            "currencyCode": "CAD"
          }
        },
        "giftWrapAdded": {
          "value": "No"
        },
        "merchandise": {
          "__typename": "ProductVariant",
          "id": "gid://shopify/ProductVariant/1099",
          "title": "Something that is not wrapped",
          "product": {
            "giftWrapCost": {
              "type": "money",
              "value": "{\"amount\":\"5.00\",\"currencyCode\":\"CAD\"}"
            }
          }
        }
      },
      {
        "id": "gid://shopify/CartLine/2",
        "quantity": 5,
        "cost": {
          "amountPerQuantity": {
            "amount": "100.0",
            "currencyCode": "CAD"
          }
        },
        "giftWrapAdded": {
          "value": "Yes"
        },
        "merchandise": {
          "__typename": "ProductVariant",
          "id": "gid://shopify/ProductVariant/456",
          "title": "Something that is wrapped",
          "product": {
            "giftWrapCost": {
              "type": "money",
              "value": "{\"amount\":\"5.00\",\"currencyCode\":\"CAD\"}"
            }
          }
        }
      }
    ]
  },
  "cartTransform": {
    "giftWrapVariantID": {
      "value": "gid://shopify/ProductVariant/2"
    }
  }
}

Function Code (Rust)

use crate::schema;
use shopify_function::prelude::*;
use shopify_function::Result;


#[derive(Debug, Deserialize)]
#[shopify_function(rename_all = "camelCase")]

pub struct Money {
  pub amount: String,
  pub currency_code: String,
}

#[shopify_function]
fn cart_transform_run(input: schema::cart_transform_run::Input) -> Result<schema::CartTransformRunResult> {
    let presentment_currency_rate_f64 = input.presentment_currency_rate().0;
    let cart_operations: Vec<schema::Operation> = get_update_cart_operations(
        &input.cart(),
        &input.cart_transform(),
        presentment_currency_rate_f64,
    );

    Ok(schema::CartTransformRunResult {
        operations: cart_operations,
    })
}

fn get_update_cart_operations(
    cart: &schema::cart_transform_run::input::Cart,
    cart_transform: &schema::cart_transform_run::input::CartTransform,
    presentment_currency_rate: f64,
) -> Vec<schema::Operation> {
    cart.lines()
        .iter()
        .filter_map(|line| {
            let gift_wrap_added = get_gift_wrap_added(line);
            let gift_wrap_cost = get_gift_wrap_cost(line);
            let gift_wrap_variant_id = &cart_transform.gift_wrap_variant_id();
            if let (schema::cart_transform_run::input::cart::lines::Merchandise::ProductVariant(variant), Some(_gift_wrap_variant_id)) =
                (&line.merchandise(), gift_wrap_variant_id)
            {
                if gift_wrap_added && gift_wrap_cost > 0.0 {
                    let original_item = schema::ExpandedItem {
                        merchandise_id: variant.id().clone(),
                        quantity: 1,
                        price: Some(schema::ExpandedItemPriceAdjustment {
                            adjustment: schema::ExpandedItemPriceAdjustmentValue::FixedPricePerUnit(
                                schema::ExpandedItemFixedPricePerUnitAdjustment {
                                    amount: Decimal(line.cost().amount_per_quantity().amount().0),
                                },
                            ),
                        }),
                        attributes: None,
                    };
                    let expanded_cart_item = schema::ExpandedItem {
                        merchandise_id: _gift_wrap_variant_id.value().clone(),
                        quantity: 1,
                        price: Some(schema::ExpandedItemPriceAdjustment {
                            adjustment: schema::ExpandedItemPriceAdjustmentValue::FixedPricePerUnit(
                                schema::ExpandedItemFixedPricePerUnitAdjustment {
                                    amount: Decimal(
                                            gift_wrap_cost
                                            * presentment_currency_rate,
                                    ),
                                },
                            ),
                        }),
                        attributes: None,
                    };
                    let expand_operation = schema::LineExpandOperation {
                        cart_line_id: line.id().clone(),
                        title: variant.title().to_owned().cloned(),
                        image: None,
                        price: None,
                        expanded_cart_items: vec![original_item, expanded_cart_item],
                    };
                    Some(schema::Operation::LineExpand(expand_operation))
                } else {
                    None
                }
            } else {
                None
            }
        })
        .collect()
}

fn get_gift_wrap_added(line: &schema::cart_transform_run::input::cart::Lines) -> bool {
    match &line.gift_wrap_added() {
        Some(input_cart_lines_gift_wrap_added) => match &input_cart_lines_gift_wrap_added.value() {
            Some(text) => text.as_str() == "Yes",
            None => false,
        },
        None => false,
    }
}

fn get_gift_wrap_cost(line: &schema::cart_transform_run::input::cart::Lines) -> f64 {
    match &line.merchandise() {
        schema::cart_transform_run::input::cart::lines::Merchandise::ProductVariant(variant) => {
            if let Some(gift_wrap_cost) = variant.product().gift_wrap_cost() {
                let money = gift_wrap_cost.json_value();
                money.amount.parse::<f64>().unwrap_or(5.00)
            } else {
                5.00
            }
        },
        _ => 5.00,
    }
}

Performance Cost (Rust)

91707 instructions

Function Code (JavaScript)

// @ts-check

/*
A straightforward example of a function that expands a single line into a bundle with add-on products.
The add-on options are are stored in a line item property and metafield on the product.
*/

/**
 * @typedef {import("../generated/api").RunInput} RunInput
 * @typedef {import("../generated/api").CartTransformRunResult} CartTransformRunResult
 * @typedef {import("../generated/api").Operation} Operation
 */

/**
 * @type {CartTransformRunResult}
 */
const NO_CHANGES = {
  operations: [],
};

/**
 * @param {RunInput} input
 * @returns {CartTransformRunResult}
 */
export function cartTransformRun(input) {
  const operations = input.cart.lines.reduce(
    /** @param {Operation[]} acc */
    (acc, cartLine) => {
      const expandOperation = optionallyBuildExpandOperation(cartLine, input);

      if (expandOperation) {
        return [...acc, { lineExpand: expandOperation }];
      }

      return acc;
    },
    []
  );

  return operations.length > 0 ? { operations } : NO_CHANGES;
}

/**
 * @param {RunInput['cart']['lines'][number]} cartLine
 * @param {RunInput} input
 */
function optionallyBuildExpandOperation(
  { id: cartLineId, merchandise, giftWrapAdded, cost},
  { cartTransform: { giftWrapVariantID }, presentmentCurrencyRate }
) {
  const hasGiftWrapMetafields =
    merchandise.__typename === "ProductVariant" &&
    !!merchandise.product.giftWrapCost &&
    !!giftWrapVariantID;
  const shouldAddGiftWrap = giftWrapAdded?.value === "Yes";
  const giftWrapCost = merchandise.__typename === "ProductVariant" &&
    merchandise.product?.giftWrapCost?.value
      ? JSON.parse(merchandise.product.giftWrapCost.value).amount
      : "5.0";

  if (
    merchandise.__typename === "ProductVariant" &&
    hasGiftWrapMetafields &&
    shouldAddGiftWrap
  ) {
    return {
      cartLineId,
      title: `${merchandise.title}`,
      expandedCartItems: [
        {
          merchandiseId: merchandise.id,
          quantity: 1,
          price: {
            adjustment: {
              fixedPricePerUnit: {
                amount: cost.amountPerQuantity.amount,
              },
            },
          },
        },
        {
          merchandiseId: giftWrapVariantID.value,
          quantity: 1,
          price: {
            adjustment: {
              fixedPricePerUnit: {
                amount: (
                  parseFloat(giftWrapCost) *
                  presentmentCurrencyRate
                ).toFixed(1),
              },
            },
          },
        },
      ],
    };
  }

  return null;
}

Performance Cost (JavaScript)

492416 instructions

Output JSON (Rust)

{
  "operations": [
    {
      "lineExpand": {
        "cartLineId": "gid://shopify/CartLine/2",
        "expandedCartItems": [
          {
            "attributes": null,
            "merchandiseId": "gid://shopify/ProductVariant/456",
            "price": {
              "adjustment": {
                "fixedPricePerUnit": {
                  "amount": "100.0"
                }
              }
            },
            "quantity": 1
          },
          {
            "attributes": null,
            "merchandiseId": "gid://shopify/ProductVariant/2",
            "price": {
              "adjustment": {
                "fixedPricePerUnit": {
                  "amount": "5.0"
                }
              }
            },
            "quantity": 1
          }
        ],
        "image": null,
        "price": null,
        "title": "Something that is wrapped"
      }
    }
  ]
}

Output JSON (JavaScript)

{
  "operations": [
    {
      "lineExpand": {
        "cartLineId": "gid://shopify/CartLine/2",
        "expandedCartItems": [
          {
            "merchandiseId": "gid://shopify/ProductVariant/456",
            "price": {
              "adjustment": {
                "fixedPricePerUnit": {
                  "amount": "100.0"
                }
              }
            },
            "quantity": 1
          },
          {
            "merchandiseId": "gid://shopify/ProductVariant/2",
            "price": {
              "adjustment": {
                "fixedPricePerUnit": {
                  "amount": "5.0"
                }
              }
            },
            "quantity": 1
          }
        ],
        "title": "Something that is wrapped"
      }
    }
  ]
}

cart.transform.run

Input Query (Rust)

query Input {
  presentmentCurrencyRate
  cart {
    lines {
      id
      quantity
      cost {
        amountPerQuantity {
          amount
          currencyCode
        }
      }
      # Access the cart line attribute to decide if we should add an assembly service
      assemblyServiceAdded: attribute(key: "Assembly Service Added") {
        value
      }
      merchandise {
        __typename
        ... on ProductVariant {
          id
          title
          product {
            # Access the metafield value to determine the cost of the assembly service
            assemblyServiceCost: metafield(namespace: "$app:assembly-service", key: "cost") {
              type
              jsonValue
            }
          }
        }
      }
    }
  }
  cartTransform {
    # Access the variant ID that represents the assembly service product
    assemblyServiceVariantID: metafield(namespace: "$app:optional-add-ons", key: "function-configuration") {
      value
    }
  }
}

Input Query (JavaScript)

query RunInput {
  presentmentCurrencyRate
  cart {
    lines {
      id
      quantity
      cost {
        amountPerQuantity {
          amount
          currencyCode
        }
      }
      # Access the cart line attribute to decide if we should add an assembly service
      assemblyServiceAdded: attribute(key: "Assembly Service Added") {
        value
      }
      merchandise {
        __typename
        ... on ProductVariant {
          id
          title
          product {
            # Access the metafield value to determine the cost of the assembly service
            assemblyServiceCost: metafield(namespace: "$app:assembly-service", key: "cost") {
              type
              value
            }
          }
        }
      }
    }
  }
  cartTransform {
    # Access the variant ID that represents the warranty product
    assemblyServiceVariantID: metafield(namespace: "$app:optional-add-ons", key: "function-configuration") {
      value
    }
  }
}

Input Object (Rust)

{
    "presentmentCurrencyRate": "1.0",
    "cart": {
        "lines": [
            {
                "id": "gid://shopify/CartLine/1",
                "quantity": 1,
                "cost": {
                    "amountPerQuantity": {
                        "amount": "100.0",
                        "currencyCode": "CAD"
                    }
                },
                "assemblyServiceAdded": {
                    "value": "No"
                },
                "merchandise": {
                    "__typename": "ProductVariant",
                    "id": "gid://shopify/ProductVariant/1099",
                    "title": "Something without assembly service",
                    "product": {
                        "assemblyServiceCost": {
                            "type": "money",
                            "jsonValue": {
                                "amount": "25.00",
                                "currencyCode": "CAD"
                            }
                        }
                    }
                }
            },
            {
                "id": "gid://shopify/CartLine/2",
                "quantity": 5,
                "cost": {
                    "amountPerQuantity": {
                        "amount": "100.0",
                        "currencyCode": "CAD"
                    }
                },
                "assemblyServiceAdded": {
                    "value": "Yes"
                },
                "merchandise": {
                    "__typename": "ProductVariant",
                    "id": "gid://shopify/ProductVariant/456",
                    "title": "Something with an assembly service",
                    "product": {
                        "assemblyServiceCost": {
                            "type": "money",
                            "jsonValue": {
                                "amount": "25.00",
                                "currencyCode": "CAD"
                            }
                        }
                    }
                }
            }
        ]
    },
    "cartTransform": {
        "assemblyServiceVariantID": {
            "value": "gid://shopify/ProductVariant/2"
        }
    }
}

Input Object (JavaScript)

{
    "presentmentCurrencyRate": "1.0",
    "cart": {
        "lines": [
            {
                "id": "gid://shopify/CartLine/1",
                "quantity": 1,
                "cost": {
                    "amountPerQuantity": {
                        "amount": "100.0",
                        "currencyCode": "CAD"
                    }
                },
                "assemblyServiceAdded": {
                    "value": "No"
                },
                "merchandise": {
                    "__typename": "ProductVariant",
                    "id": "gid://shopify/ProductVariant/1099",
                    "title": "Something without assembly service",
                    "product": {
                        "assemblyServiceCost": {
                            "type": "money",
                            "value": "{\"amount\":\"25.00\",\"currencyCode\":\"CAD\"}"
                        }
                    }
                }
            },
            {
                "id": "gid://shopify/CartLine/2",
                "quantity": 5,
                "cost": {
                    "amountPerQuantity": {
                        "amount": "100.0",
                        "currencyCode": "CAD"
                    }
                },
                "assemblyServiceAdded": {
                    "value": "Yes"
                },
                "merchandise": {
                    "__typename": "ProductVariant",
                    "id": "gid://shopify/ProductVariant/456",
                    "title": "Something with an assembly service",
                    "product": {
                        "assemblyServiceCost": {
                            "type": "money",
                            "value": "{\"amount\":\"25.00\",\"currencyCode\":\"CAD\"}"
                        }
                    }
                }
            }
        ]
    },
    "cartTransform": {
        "assemblyServiceVariantID": {
            "value": "gid://shopify/ProductVariant/2"
        }
    }
}

Function Code (Rust)

use crate::schema;
use shopify_function::prelude::*;
use shopify_function::Result;

#[derive(Debug, Deserialize)]
#[shopify_function(rename_all = "camelCase")]
pub struct Money {
    pub amount: String,
    pub currency_code: String,
}

#[shopify_function]
fn cart_transform_run(input: schema::cart_transform_run::Input) -> Result<schema::CartTransformRunResult> {
    let presentment_currency_rate_f64 = input.presentment_currency_rate().0;
    let cart_operations: Vec<schema::Operation> = get_update_cart_operations(
        &input.cart(),
        &input.cart_transform(),
        presentment_currency_rate_f64,
    );

    Ok(schema::CartTransformRunResult {
        operations: cart_operations,
    })
}

fn get_update_cart_operations(
    cart: &schema::cart_transform_run::input::Cart,
    cart_transform: &schema::cart_transform_run::input::CartTransform,
    presentment_currency_rate: f64,
) -> Vec<schema::Operation> {
    cart.lines()
        .iter()
        .filter_map(|line| {
            let assembly_service_added = get_assembly_service_added(line);
            let assembly_service_cost = get_assembly_service_cost(line);
            let assembly_service_variant_id = &cart_transform.assembly_service_variant_id();
            if let (
                schema::cart_transform_run::input::cart::lines::Merchandise::ProductVariant(variant),
                Some(_assembly_service_variant_id),
            ) = (&line.merchandise(), assembly_service_variant_id)
            {
                if assembly_service_added && assembly_service_cost > 0.0 {
                    let original_item = schema::ExpandedItem {
                        merchandise_id: variant.id().clone(),
                        quantity: 1,
                        price: Some(schema::ExpandedItemPriceAdjustment {
                            adjustment: schema::ExpandedItemPriceAdjustmentValue::FixedPricePerUnit(
                                schema::ExpandedItemFixedPricePerUnitAdjustment {
                                    amount: Decimal(line.cost().amount_per_quantity().amount().0),
                                },
                            ),
                        }),
                        attributes: None,
                    };
                    let expanded_cart_item = schema::ExpandedItem {
                        merchandise_id: _assembly_service_variant_id.value().clone(),
                        quantity: 1,
                        price: Some(schema::ExpandedItemPriceAdjustment {
                            adjustment: schema::ExpandedItemPriceAdjustmentValue::FixedPricePerUnit(
                                schema::ExpandedItemFixedPricePerUnitAdjustment {
                                    amount: Decimal(
                                        assembly_service_cost * presentment_currency_rate,
                                    ),
                                },
                            ),
                        }),
                        attributes: None,
                    };
                    let expand_operation = schema::LineExpandOperation {
                        cart_line_id: line.id().clone(),
                        title: variant.title().to_owned().cloned(),
                        image: None,
                        price: None,
                        expanded_cart_items: vec![original_item, expanded_cart_item],
                    };
                    Some(schema::Operation::LineExpand(expand_operation))
                } else {
                    None
                }
            } else {
                None
            }
        })
        .collect()
}

fn get_assembly_service_added(line: &schema::cart_transform_run::input::cart::Lines) -> bool {
    match &line.assembly_service_added() {
        Some(input_cart_lines_assembly_service_added) => {
            match &input_cart_lines_assembly_service_added.value() {
                Some(text) => text.as_str() == "Yes",
                None => false,
            }
        }
        None => false,
    }
}

fn get_assembly_service_cost(line: &schema::cart_transform_run::input::cart::Lines) -> f64 {
    match &line.merchandise() {
        schema::cart_transform_run::input::cart::lines::Merchandise::ProductVariant(variant) => {
            if let Some(assembly_service_cost) = variant.product().assembly_service_cost() {
                let money = assembly_service_cost.json_value();
                money.amount.parse::<f64>().unwrap_or(25.00)
            } else {
                25.00
            }
        }
        _ => 25.00,
    }
}

Performance Cost (Rust)

92394 instructions

Function Code (JavaScript)

// @ts-check

/*
A straightforward example of a function that expands a single line into a bundle with add-on products.
The add-on options are are stored in a line item property and metafield on the product.
*/

/**
 * @typedef {import("../generated/api").RunInput} RunInput
 * @typedef {import("../generated/api").CartTransformRunResult} CartTransformRunResult
 * @typedef {import("../generated/api").Operation} Operation
 */

/**
 * @type {CartTransformRunResult}
 */
const NO_CHANGES = {
  operations: [],
};

/**
 * @param {RunInput} input
 * @returns {CartTransformRunResult}
 */
export function cartTransformRun(input) {
  const operations = input.cart.lines.reduce(
    /** @param {Operation[]} acc */
    (acc, cartLine) => {
      const expandOperation = optionallyBuildExpandOperation(cartLine, input);

      if (expandOperation) {
        return [...acc, { lineExpand: expandOperation }];
      }

      return acc;
    },
    []
  );

  return operations.length > 0 ? { operations } : NO_CHANGES;
}

/**
 * @param {RunInput['cart']['lines'][number]} cartLine
 * @param {RunInput} input
 */
function optionallyBuildExpandOperation(
  { id: cartLineId, merchandise, assemblyServiceAdded, cost},
  { cartTransform: { assemblyServiceVariantID }, presentmentCurrencyRate }
) {
  const hasAssemblyServiceMetafields =
    merchandise.__typename === "ProductVariant" &&
    !!merchandise.product.assemblyServiceCost &&
    !!assemblyServiceVariantID;
  const shouldAddAssemblyService = assemblyServiceAdded?.value === "Yes";
  const assemblyServiceCost = merchandise.__typename === "ProductVariant" &&
    merchandise.product?.assemblyServiceCost?.value
      ? JSON.parse(merchandise.product.assemblyServiceCost.value).amount
      : "5.00";

  if (
    merchandise.__typename === "ProductVariant" &&
    hasAssemblyServiceMetafields &&
    shouldAddAssemblyService
  ) {
    return {
      cartLineId,
      title: `${merchandise.title}`,
      expandedCartItems: [
        {
          merchandiseId: merchandise.id,
          quantity: 1,
          price: {
            adjustment: {
              fixedPricePerUnit: {
                amount: cost.amountPerQuantity.amount,
              },
            },
          },
        },
        {
          merchandiseId: assemblyServiceVariantID.value,
          quantity: 1,
          price: {
            adjustment: {
              fixedPricePerUnit: {
                amount: (
                  parseFloat(assemblyServiceCost) *
                  presentmentCurrencyRate
                ).toFixed(2),
              },
            },
          },
        },
      ],
    };
  }

  return null;
}

Performance Cost (JavaScript)

495305 instructions

Output JSON (Rust)

{
    "operations": [
        {
            "lineExpand": {
                "cartLineId": "gid://shopify/CartLine/2",
                "expandedCartItems": [
                    {
                        "attributes": null,
                        "merchandiseId": "gid://shopify/ProductVariant/456",
                        "price": {
                            "adjustment": {
                                "fixedPricePerUnit": {
                                    "amount": "100.0"
                                }
                            }
                        },
                        "quantity": 1
                    },
                    {
                        "attributes": null,
                        "merchandiseId": "gid://shopify/ProductVariant/2",
                        "price": {
                            "adjustment": {
                                "fixedPricePerUnit": {
                                    "amount": "25.0"
                                }
                            }
                        },
                        "quantity": 1
                    }
                ],
                "image": null,
                "price": null,
                "title": "Something with an assembly service"
            }
        }
    ]
}

Output JSON (JavaScript)

{
    "operations": [
        {
            "lineExpand": {
                "cartLineId": "gid://shopify/CartLine/2",
                "expandedCartItems": [
                    {
                        "merchandiseId": "gid://shopify/ProductVariant/456",
                        "price": {
                            "adjustment": {
                                "fixedPricePerUnit": {
                                    "amount": "100.0"
                                }
                            }
                        },
                        "quantity": 1
                    },
                    {
                        "merchandiseId": "gid://shopify/ProductVariant/2",
                        "price": {
                            "adjustment": {
                                "fixedPricePerUnit": {
                                    "amount": "25.00"
                                }
                            }
                        },
                        "quantity": 1
                    }
                ],
                "title": "Something with an assembly service"
            }
        }
    ]
}

cart.transform.run

Input Query (Rust)

query Input {
  presentmentCurrencyRate
  cart {
    lines {
      id
      quantity
      merchandise {
        __typename
        ... on ProductVariant {
          id
          title
          product {
            bundledComponentData: metafield(namespace: "$app:bundles-price-per-component", key: "function-configuration") {
              jsonValue
            }
          }
        }
      }
    }
  }
}

Input Query (JavaScript)

query RunInput {
  presentmentCurrencyRate
  cart {
    lines {
      id
      quantity
      merchandise {
        __typename
        ... on ProductVariant {
          id
          title
          product {
            bundledComponentData: metafield(namespace: "$app:bundles-price-per-component", key: "function-configuration") {
              type
              value
            }
          }
        }
      }
    }
  }
}

Input Object (Rust)

{
    "presentmentCurrencyRate": "1.0",
    "cart": {
        "lines": [
            {
                "id": "1",
                "quantity": 1,
                "merchandise": {
                    "__typename": "ProductVariant",
                    "id": "gid://shopify/ProductVariant/1",
                    "title": "Holiday Package",
                    "product": {
                        "bundledComponentData": {
                            "jsonValue": [
                                {
                                    "id": "gid://shopify/ProductVariant/2",
                                    "price": "25.00"
                                },
                                {
                                    "id": "gid://shopify/ProductVariant/3",
                                    "price": "25.00"
                                },
                                {
                                    "id": "gid://shopify/ProductVariant/4",
                                    "price": "25.00"
                                }
                            ]
                        }
                    }
                }
            }
        ]
    }
}

Input Object (JavaScript)

{
    "presentmentCurrencyRate": "1.0",
    "cart": {
        "lines": [
            {
                "id": "1",
                "quantity": 1,
                "merchandise": {
                    "__typename": "ProductVariant",
                    "id": "gid://shopify/ProductVariant/1",
                    "title": "Holiday Package",
                    "product": {
                        "bundledComponentData": {
                            "type": "json",
                            "value": "[{\"id\":\"gid://shopify/ProductVariant/2\",\"price\":\"25.00\"},{\"id\":\"gid://shopify/ProductVariant/3\",\"price\":\"25.00\"},{\"id\":\"gid://shopify/ProductVariant/4\",\"price\":\"25.00\"}]"
                        }
                    }
                }
            }
        ]
    }
}

Function Code (Rust)

use crate::schema;
use shopify_function::prelude::*;
use shopify_function::Result;

#[derive(Debug, Deserialize, Clone)]
pub struct Component {
    id: String,
    price: String,
}

pub type BundleData = Vec<Component>;

#[shopify_function]
fn cart_transform_run(input: schema::cart_transform_run::Input) -> Result<schema::CartTransformRunResult> {
    let presentment_currency_rate_f64 = input.presentment_currency_rate().0;
    let cart_operations: Vec<schema::Operation> = get_update_cart_operations(
        &input.cart(),
        presentment_currency_rate_f64,
    );

    Ok(schema::CartTransformRunResult {
        operations: cart_operations,
    })
}

fn get_update_cart_operations(
    cart: &schema::cart_transform_run::input::Cart,
    presentment_currency_rate: f64,
) -> Vec<schema::Operation> {
    cart.lines()
        .iter()
        .filter_map(|line| {
            if let schema::cart_transform_run::input::cart::lines::Merchandise::ProductVariant(variant) = &line.merchandise() {
                let bundle_data: &BundleData = match variant.product().bundled_component_data() {
                    Some(bundled_component_data) => bundled_component_data.json_value(),
                    None => return None,
                };

                let expanded_items = create_expanded_items(
                    bundle_data,
                    presentment_currency_rate,
                );

                if !expanded_items.is_empty() {
                    let expand_operation = schema::LineExpandOperation {
                        cart_line_id: line.id().clone(),
                        title: Some(variant.title().cloned().unwrap_or_default()),
                        image: None,
                        price: None,
                        expanded_cart_items: expanded_items,
                    };
                    return Some(schema::Operation::LineExpand(expand_operation));
                }
            }
            None
        })
        .collect()
}

fn create_expanded_items(
    components: &BundleData,
    presentment_currency_rate: f64,
) -> Vec<schema::ExpandedItem> {
    components
        .into_iter()
        .filter_map(|component| {
            let price_float = component.price.parse::<f64>().ok()?;
            let adjusted_price = price_float * presentment_currency_rate;

            Some(schema::ExpandedItem {
                merchandise_id: component.id.clone(),
                quantity: 1,
                price: Some(schema::ExpandedItemPriceAdjustment {
                    adjustment: schema::ExpandedItemPriceAdjustmentValue::FixedPricePerUnit(
                        schema::ExpandedItemFixedPricePerUnitAdjustment {
                            amount: Decimal(adjusted_price),
                        },
                    ),
                }),
                attributes: None,
            })
        })
        .collect()
}

fn get_bundle_data(line: &schema::cart_transform_run::input::cart::Lines) -> Option<BundleData> {
    if let schema::cart_transform_run::input::cart::lines::Merchandise::ProductVariant(variant) = &line.merchandise() {
        let bundle_data: &BundleData = match variant.product().bundled_component_data() {
            Some(bundled_component_data) => bundled_component_data.json_value(),
            None => return None,
        };
        Some(bundle_data.clone())
    } else {
        None
    }
}

Performance Cost (Rust)

71757 instructions

Function Code (JavaScript)

// @ts-check

/*
A straightforward example of a function that expands a bundle into its component parts.
The parts of a bundle are stored in a metafield on the product parent value with a specific format,
specifying each part's quantity and variant.

The function reads the cart. Any item containing the metafield that specifies the bundle parts
will return an Expand operation containing the parts.
*/

/**
 * @typedef {import("../generated/api").RunInput} RunInput
 * @typedef {import("../generated/api").CartTransformRunResult} CartTransformRunResult
 * @typedef {import("../generated/api").Operation} Operation
 */

/**
 * @type {CartTransformRunResult}
 */
const NO_CHANGES = {
  operations: [],
};

/**
 * @param {RunInput} input
 * @returns {CartTransformRunResult}
 */
export function cartTransformRun(input) {
  const operations = input.cart.lines.reduce(
    /** @param {Operation[]} acc */
    (acc, cartLine) => {
      const expandOperation = optionallyBuildExpandOperation(cartLine, input.presentmentCurrencyRate);

      if (expandOperation) {
        return [...acc, { lineExpand: expandOperation }];
      }

      return acc;
    },
    []
  );

  return operations.length > 0 ? { operations } : NO_CHANGES;
};

/**
 * @param {RunInput['cart']['lines'][number]} cartLine
 * @param {RunInput['presentmentCurrencyRate']} presentmentCurrencyRate
 */
function optionallyBuildExpandOperation({ id: cartLineId, merchandise }, presentmentCurrencyRate) {
  if (merchandise.__typename === "ProductVariant" && merchandise.product.bundledComponentData) {
    const bundleData = JSON.parse(
      merchandise.product.bundledComponentData.value
    );

    if (bundleData.length === 0) {
      throw new Error("Invalid bundle composition");
    }

    const expandedCartItems = bundleData.map((component) => ({
      merchandiseId: component.id,
      quantity: component.quantity || 1,
      price: {
        adjustment: {
          fixedPricePerUnit: {
            amount: (component.price * presentmentCurrencyRate).toFixed(2),
          },
        },
      },
    }));

    if (expandedCartItems.length > 0) {
      return { cartLineId, expandedCartItems };
    }
  }

  return null;
}

Performance Cost (JavaScript)

418204 instructions

Output JSON (Rust)

{
    "operations": [
        {
            "lineExpand": {
                "cartLineId": "1",
                "expandedCartItems": [
                    {
                        "attributes": null,
                        "merchandiseId": "gid://shopify/ProductVariant/2",
                        "price": {
                            "adjustment": {
                                "fixedPricePerUnit": {
                                    "amount": "25.0"
                                }
                            }
                        },
                        "quantity": 1
                    },
                    {
                        "attributes": null,
                        "merchandiseId": "gid://shopify/ProductVariant/3",
                        "price": {
                            "adjustment": {
                                "fixedPricePerUnit": {
                                    "amount": "25.0"
                                }
                            }
                        },
                        "quantity": 1
                    },
                    {
                        "attributes": null,
                        "merchandiseId": "gid://shopify/ProductVariant/4",
                        "price": {
                            "adjustment": {
                                "fixedPricePerUnit": {
                                    "amount": "25.0"
                                }
                            }
                        },
                        "quantity": 1
                    }
                ],
                "image": null,
                "price": null,
                "title": "Holiday Package"
            }
        }
    ]
}

Output JSON (JavaScript)

{
    "operations": [
        {
            "lineExpand": {
                "cartLineId": "1",
                "expandedCartItems": [
                    {
                        "merchandiseId": "gid://shopify/ProductVariant/2",
                        "price": {
                            "adjustment": {
                                "fixedPricePerUnit": {
                                    "amount": "25.00"
                                }
                            }
                        },
                        "quantity": 1
                    },
                    {
                        "merchandiseId": "gid://shopify/ProductVariant/3",
                        "price": {
                            "adjustment": {
                                "fixedPricePerUnit": {
                                    "amount": "25.00"
                                }
                            }
                        },
                        "quantity": 1
                    },
                    {
                        "merchandiseId": "gid://shopify/ProductVariant/4",
                        "price": {
                            "adjustment": {
                                "fixedPricePerUnit": {
                                    "amount": "25.00"
                                }
                            }
                        },
                        "quantity": 1
                    }
                ]
            }
        }
    ]
}

cart.transform.run

Input Query (Rust)

query Input {
  cart {
    lines {
      id
      quantity
      cost {
        amountPerQuantity {
          amount
        }
      }
      merchandise {
        __typename
        ... on ProductVariant {
          product {
            title
          }
        }
        ... on CustomProduct {
          title
        }
      }
    }
    buyerIdentity {
      customer {
        id
        hasAnyTag(tags: ["VIP"])
      }
    }
  }
}

Input Query (JavaScript)

query Input {
  cart {
    lines {
      id
      quantity
      cost {
        amountPerQuantity {
          amount
        }
      }
      merchandise {
        ... on ProductVariant {
          product {
            title
          }
        }
        ... on CustomProduct {
          title
        }
      }
    }
    buyerIdentity {
      customer {
        id
        hasAnyTag(tags: ["VIP"])
      }
    }
  }
}

Input Object (Rust)

{
    "cart": {
      "lines": [
        {
          "id": "gid://shopify/CartLine/6727c32a-9829-445b-8460-71774972fa55",
          "quantity": 1,
          "cost": {
            "amountPerQuantity": {
              "amount": "749.95"
            }
          },
          "merchandise": {
            "__typename": "ProductVariant",
            "product": {
              "title": "The Collection Snowboard: Liquid"
            }
          }
        }
      ],
      "buyerIdentity": {
        "customer": {
          "id": "gid://shopify/Customer/8808655552742",
          "hasAnyTag": true
        }
      }
    }
  }

Input Object (JavaScript)

{
    "cart": {
      "lines": [
        {
          "id": "gid://shopify/CartLine/6727c32a-9829-445b-8460-71774972fa55",
          "quantity": 1,
          "cost": {
            "amountPerQuantity": {
              "amount": "749.95"
            }
          },
          "merchandise": {
            "__typename": "ProductVariant",
            "product": {
              "title": "The Collection Snowboard: Liquid"
            }
          }
        }
      ],
      "buyerIdentity": {
        "customer": {
          "id": "gid://shopify/Customer/8808655552742",
          "hasAnyTag": true
        }
      }
    }
  }

Function Code (Rust)

use crate::schema;
use shopify_function::prelude::*;
use shopify_function::Result;

#[shopify_function]
fn cart_transform_run(input: schema::cart_transform_run::Input) -> Result<schema::CartTransformRunResult> {
    // Check if customer is VIP based on having any tags
    let is_vip_customer = input
        .cart()
        .buyer_identity()
        .and_then(|buyer| buyer.customer())
        .map(|customer| customer.has_any_tag())
        .unwrap_or(&false);

    if !is_vip_customer {
        return Ok(schema::CartTransformRunResult { operations: vec![] });
    }

    let operations: Vec<schema::Operation> = input
        .cart()
        .lines()
        .iter()
        .map(|line| {
            let discount_amount = Decimal(line.cost().amount_per_quantity().amount().0 - 50.00);
            schema::Operation::LineUpdate(schema::LineUpdateOperation {
                cart_line_id: line.id().clone(),
                title: Some("VIP Exclusive".to_string()),
                price: Some(schema::LineUpdateOperationPriceAdjustment {
                    adjustment: schema::LineUpdateOperationPriceAdjustmentValue::FixedPricePerUnit(
                        schema::LineUpdateOperationFixedPricePerUnitAdjustment {
                            amount: discount_amount,
                        },
                    ),
                }),
                image: None,
            })
        })
        .collect();

    Ok(schema::CartTransformRunResult {
        operations,
    })
}

Performance Cost (Rust)

35116 instructions

Function Code (JavaScript)

// @ts-check

/*
A straightforward example of a function that updates a line item title and price for VIP customers.

The function reads the cart and checks if the customer is a VIP. For VIP customers,
each line item will be updated with a custom title and a discounted price of $50 off
the original price.
*/

/**
 * @typedef {import("../generated/api").Input} Input
 * @typedef {import("../generated/api").CartTransformRunResult} CartTransformRunResult
 * @typedef {import("../generated/api").Operation} Operation
 */

/**
 * @type {CartTransformRunResult}
 */
const NO_CHANGES = {
  operations: [],
};

/**
 * @param {Input} input
 * @returns {CartTransformRunResult}
 */
export function cartTransformRun(input) {
  const isVipCustomer = input.cart.buyerIdentity?.customer?.hasAnyTag ?? false;

  if (!isVipCustomer) {
    return NO_CHANGES;
  }

  const operations = input.cart.lines.reduce(
    /** @param {Operation[]} acc */
    (acc, cartLine) => {
      const updateOperation = buildVipUpdateOperation(cartLine);
      return [...acc, { lineUpdate: updateOperation }];
    },
    []
  );

  return operations.length > 0 ? { operations } : NO_CHANGES;
}

/**
 * @param {Input['cart']['lines'][number]} cartLine
 */
function buildVipUpdateOperation(
  { id: cartLineId, cost }
) {
  return {
    cartLineId,
    title: "VIP Exclusive",
    price: {
      adjustment: {
        fixedPricePerUnit: {
          amount: cost.amountPerQuantity.amount - 50.00,
        },
      },
    },
  };
}

Performance Cost (JavaScript)

243616 instructions

Output JSON (Rust)

{
    "operations": [
      {
        "lineUpdate": {
          "cartLineId": "gid://shopify/CartLine/6727c32a-9829-445b-8460-71774972fa55",
          "image": null,
          "price": {
            "adjustment": {
              "fixedPricePerUnit": {
                "amount": "699.95"
              }
            }
          },
          "title": "VIP Exclusive"
        }
      }
    ]
  }

Output JSON (JavaScript)

{
    "operations": [
      {
        "lineUpdate": {
          "cartLineId": "gid://shopify/CartLine/6727c32a-9829-445b-8460-71774972fa55",
          "price": {
            "adjustment": {
              "fixedPricePerUnit": {
                "amount": 699.95
              }
            }
          },
          "title": "VIP Exclusive"
        }
      }
    ]
  }

cart.transform.run

Input Query (Rust)

query Input {
  cart {
    lines {
      id
      quantity
      cost {
        amountPerQuantity {
          amount
        }
      }
    }
  }
}

Input Query (JavaScript)

query Input {
  cart {
    lines {
      id
      quantity
      cost {
        amountPerQuantity {
          amount
        }
      }
    }
  }
}

Input Object (Rust)

{
    "cart": {
      "lines": [
        {
          "id": "gid://shopify/CartLine/eafd573a-fd97-446f-93bb-04d47e1d5332",
          "quantity": 2,
          "cost": {
            "amountPerQuantity": {
              "amount": "729.95"
            }
          }
        },
        {
          "id": "gid://shopify/CartLine/52cde2c2-b749-41ae-baa6-889c03deee26",
          "quantity": 5,
          "cost": {
            "amountPerQuantity": {
              "amount": "749.95"
            }
          }
        },
        {
          "id": "gid://shopify/CartLine/a8a95ef8-5c64-4052-9939-250ea091bc9c",
          "quantity": 6,
          "cost": {
            "amountPerQuantity": {
              "amount": "629.95"
            }
          }
        }
      ]
    }
  }

Input Object (JavaScript)

{
    "cart": {
      "lines": [
        {
          "id": "gid://shopify/CartLine/eafd573a-fd97-446f-93bb-04d47e1d5332",
          "quantity": 2,
          "cost": {
            "amountPerQuantity": {
              "amount": "729.95"
            }
          }
        },
        {
          "id": "gid://shopify/CartLine/52cde2c2-b749-41ae-baa6-889c03deee26",
          "quantity": 5,
          "cost": {
            "amountPerQuantity": {
              "amount": "749.95"
            }
          }
        },
        {
          "id": "gid://shopify/CartLine/a8a95ef8-5c64-4052-9939-250ea091bc9c",
          "quantity": 6,
          "cost": {
            "amountPerQuantity": {
              "amount": "629.95"
            }
          }
        }
      ]
    }
  }

Function Code (Rust)

use crate::schema;
use shopify_function::prelude::*;
use shopify_function::Result;

#[shopify_function]
fn cart_transform_run(input: schema::cart_transform_run::Input) -> Result<schema::CartTransformRunResult> {
    let cart_lines_with_high_quantity: Vec<&schema::cart_transform_run::input::cart::Lines> = input.cart().lines()
        .iter()
        .filter(|line| *line.quantity() > 5)
        .collect();

    if cart_lines_with_high_quantity.is_empty() {
        return Ok(schema::CartTransformRunResult {
            operations: vec![],
        });
    }

    let operations: Vec<schema::Operation> = cart_lines_with_high_quantity
        .iter()
        .map(|line| {
            let discount_amount = Decimal(line.cost().amount_per_quantity().amount().0 - 50.00);
            schema::Operation::LineUpdate(schema::LineUpdateOperation {
                cart_line_id: line.id().clone(),
                price: Some(schema::LineUpdateOperationPriceAdjustment {
                    adjustment: schema::LineUpdateOperationPriceAdjustmentValue::FixedPricePerUnit(
                        schema::LineUpdateOperationFixedPricePerUnitAdjustment {
                            amount: discount_amount,
                        },
                    ),
                }),
                title: None,
                image: None,
            })
        })
        .collect();

    Ok(schema::CartTransformRunResult {
        operations,
    })
}

Performance Cost (Rust)

40067 instructions

Function Code (JavaScript)

// @ts-check

/*
A straightforward example of a function that applies a discount to cart items with quantity greater than 5.

The function reads the cart and checks each line item's quantity. For any item with quantity
greater than 5, it generates an update operation that reduces the price by $50.00 per unit.
*/

/**
 * @typedef {import("../generated/api").Input} Input
 * @typedef {import("../generated/api").CartTransformRunResult} CartTransformRunResult
 * @typedef {import("../generated/api").Operation} Operation
 */

/**
 * @type {CartTransformRunResult}
 */
const NO_CHANGES = {
  operations: [],
};

/**
 * @param {Input} input
 * @returns {CartTransformRunResult}
 */
export function cartTransformRun(input) {
  const operations = input.cart.lines.reduce(
    /** @param {Operation[]} acc */
    (acc, cartLine) => {
      const updateOperation = optionallyBuildUpdateOperation(cartLine);

      if (updateOperation) {
        return [...acc, { lineUpdate: updateOperation }];
      }

      return acc;
    },
    []
  );

  return operations.length > 0 ? { operations } : NO_CHANGES;
}

/**
 * @param {Input['cart']['lines'][number]} cartLine
 */
function optionallyBuildUpdateOperation(
  { id: cartLineId, quantity, cost }
) {
  if (quantity > 5) {
    return {
      cartLineId,
      price: {
        adjustment: {
          fixedPricePerUnit: {
            amount: cost.amountPerQuantity.amount - 50.00,
          },
        },
      },
    };
  }

  return null;
}

Performance Cost (JavaScript)

258187 instructions

Output JSON (Rust)

{
    "operations": [
      {
        "lineUpdate": {
          "cartLineId": "gid://shopify/CartLine/a8a95ef8-5c64-4052-9939-250ea091bc9c",
          "image": null,
          "price": {
            "adjustment": {
              "fixedPricePerUnit": {
                "amount": "579.95"
              }
            }
          },
          "title": null
        }
      }
    ]
  }

Output JSON (JavaScript)

{
    "operations": [
      {
        "lineUpdate": {
          "cartLineId": "gid://shopify/CartLine/a8a95ef8-5c64-4052-9939-250ea091bc9c",
          "price": {
            "adjustment": {
              "fixedPricePerUnit": {
                "amount": 579.95
              }
            }
          }
        }
      }
    ]
  }

cart.transform.run

Input Query (Rust)

query Input {
  cart {
    lines {
      id
      custom_image_attribute: attribute(key: "custom_image_attribute") {
        value
      }
      merchandise {
        __typename
        ... on ProductVariant {
          product {
            title
          }
        }
        ... on CustomProduct {
          title
        }
      }
    }
  }
}

Input Query (JavaScript)

query Input {
  cart {
    lines {
      id
      quantity
      custom_image_attribute: attribute(key: "custom_image_attribute") {
        value
      }
      merchandise {
        ... on ProductVariant {
          product {
            title
          }
        }
        ... on CustomProduct {
          title
        }
      }
    }
  }
}

Input Object (Rust)

{
    "cart": {
      "lines": [
        {
          "id": "gid://shopify/CartLine/02d86da8-a110-4d79-bd30-03f50e9a1ee0",
          "custom_image_attribute": {
            "value": "https://cdn.shopify.com/s/files/1/0746/5248/3814/files/396_5137_w450.jpg?v=1746497836"
          },
          "merchandise": {
            "__typename": "ProductVariant",
            "product": {
              "title": "The Collection Snowboard: Liquid"
            }
          }
        },
        {
          "id": "gid://shopify/CartLine/859a8af9-bbe0-41a2-adff-8060af179a5e",
          "custom_image_attribute": null,
          "merchandise": {
            "__typename": "ProductVariant",
            "product": {
              "title": "The Collection Snowboard: Liquid"
            }
          }
        }
      ]
    }
  }

Input Object (JavaScript)

{
    "cart": {
      "lines": [
        {
          "id": "gid://shopify/CartLine/02d86da8-a110-4d79-bd30-03f50e9a1ee0",
          "custom_image_attribute": {
            "value": "https://cdn.shopify.com/s/files/1/0746/5248/3814/files/396_5137_w450.jpg?v=1746497836"
          },
          "merchandise": {
            "__typename": "ProductVariant",
            "product": {
              "title": "The Collection Snowboard: Liquid"
            }
          }
        },
        {
          "id": "gid://shopify/CartLine/859a8af9-bbe0-41a2-adff-8060af179a5e",
          "custom_image_attribute": null,
          "merchandise": {
            "__typename": "ProductVariant",
            "product": {
              "title": "The Collection Snowboard: Liquid"
            }
          }
        }
      ]
    }
  }

Function Code (Rust)

use crate::schema;
use shopify_function::prelude::*;
use shopify_function::Result;

#[shopify_function]
fn cart_transform_run(input: schema::cart_transform_run::Input) -> Result<schema::CartTransformRunResult> {
    let cart_lines_with_custom_image: Vec<&schema::cart_transform_run::input::cart::Lines> = input
        .cart()
        .lines()
        .iter()
        .filter(|line| {
            line.custom_image_attribute()
                .and_then(|attr| attr.value())
                .is_some()
        })
        .collect();

    if cart_lines_with_custom_image.is_empty() {
        return Ok(schema::CartTransformRunResult {
            operations: vec![],
        });
    }

    let operations: Vec<schema::Operation> = cart_lines_with_custom_image
        .iter()
        .map(|line| {
            let image_url = line.custom_image_attribute()
                .and_then(|attr| attr.value())
                .map(|url| url.to_string())
                .unwrap_or_default();

            schema::Operation::LineUpdate(schema::LineUpdateOperation {
                cart_line_id: line.id().to_string(),
                image: Some(schema::ImageInput {
                    url: image_url,
                }),
                title: Some("Designed by ME".to_string()),
                price: None,
            })
        })
        .collect();

    Ok(schema::CartTransformRunResult {
        operations,
    })
}

Performance Cost (Rust)

31560 instructions

Function Code (JavaScript)

// @ts-check

/*
The function reads the cart. Any item with a custom image attribute will be used
to generate an update operation with a custom title and the specified image URL.
*/

/**
 * @typedef {import("../generated/api").Input} Input
 * @typedef {import("../generated/api").CartTransformRunResult} CartTransformRunResult
 * @typedef {import("../generated/api").Operation} Operation
 */

/**
 * @type {CartTransformRunResult}
 */
const NO_CHANGES = {
  operations: [],
};

/**
 * @param {Input} input
 * @returns {CartTransformRunResult}
 */
export function cartTransformRun(input) {
  const operations = input.cart.lines.reduce(
    /** @param {Operation[]} acc */
    (acc, cartLine) => {
      const updateOperation = optionallyBuildUpdateOperation(cartLine);

      if (updateOperation) {
        return [...acc, { lineUpdate: updateOperation }];
      }

      return acc;
    },
    []
  );

  return operations.length > 0 ? { operations } : NO_CHANGES;
}

/**
 * @param {Input['cart']['lines'][number]} cartLine
 */
function optionallyBuildUpdateOperation(cartLine) {
  if (cartLine.custom_image_attribute?.value) {
    return {
      cartLineId: cartLine.id,
      image: {
        url: cartLine.custom_image_attribute.value
      },
      title: "Designed by ME"
    };
  }

  return null;
}

Performance Cost (JavaScript)

220627 instructions

Output JSON (Rust)

{
  "operations": [
    {
      "lineUpdate": {
        "cartLineId": "gid://shopify/CartLine/02d86da8-a110-4d79-bd30-03f50e9a1ee0",
        "image": {
          "url": "https://cdn.shopify.com/s/files/1/0746/5248/3814/files/396_5137_w450.jpg?v=1746497836"
        },
        "price": null,
        "title": "Designed by ME"
      }
    }
  ]
}

Output JSON (JavaScript)

{
  "operations": [
    {
      "lineUpdate": {
        "cartLineId": "gid://shopify/CartLine/02d86da8-a110-4d79-bd30-03f50e9a1ee0",
        "image": {
          "url": "https://cdn.shopify.com/s/files/1/0746/5248/3814/files/396_5137_w450.jpg?v=1746497836"
        },
        "title": "Designed by ME"
      }
    }
  ]
}

cart.transform.run

Input Query (Rust)

query Input {
  cart {
    lines {
      id
      quantity
      merchandise {
        __typename
        ... on ProductVariant {
          sku
        }
      }
    }
    buyerIdentity {
      customer {
        isWholesale: hasAnyTag(tags: "Wholesale")
      }
    }
  }
}

Input Query (JavaScript)

query RunInput {
  cart {
    lines {
      id
      quantity
      merchandise {
        __typename
        ... on ProductVariant {
          sku
        }
      }
    }
    buyerIdentity {
      customer {
        isWholesale: hasAnyTag(tags: "Wholesale")
      }
    }
  }
}

Input Object (Rust)

{
  "cart": {
    "lines": [
      {
        "id": "gid://shopify/CartLine/1",
        "quantity": 1,
        "merchandise": {
          "__typename": "ProductVariant",
          "sku": "123"
        }
      },
      {
        "id": "gid://shopify/CartLine/2",
        "quantity": 1,
        "merchandise": {
          "__typename": "ProductVariant", 
          "sku": "123"
        }
      },
      {
        "id": "gid://shopify/CartLine/3",
        "quantity": 1,
        "merchandise": {
          "__typename": "ProductVariant",
          "sku": "456"
        }
      },
      {
        "id": "gid://shopify/CartLine/4",
        "quantity": 1,
        "merchandise": {
          "__typename": "ProductVariant",
          "sku": "789"
        }
      }
    ],
    "buyerIdentity": {
      "customer": {
        "isWholesale": true
      }
    }
  }
}

Input Object (JavaScript)

{
  "cart": {
    "lines": [
      {
        "id": "gid://shopify/CartLine/1",
        "quantity": 1,
        "merchandise": {
          "__typename": "ProductVariant",
          "sku": "123"
        }
      },
      {
        "id": "gid://shopify/CartLine/2",
        "quantity": 1,
        "merchandise": {
          "__typename": "ProductVariant", 
          "sku": "123"
        }
      },
      {
        "id": "gid://shopify/CartLine/3",
        "quantity": 1,
        "merchandise": {
          "__typename": "ProductVariant",
          "sku": "456"
        }
      },
      {
        "id": "gid://shopify/CartLine/4",
        "quantity": 1,
        "merchandise": {
          "__typename": "ProductVariant",
          "sku": "789"
        }
      }
    ],
    "buyerIdentity": {
      "customer": {
        "isWholesale": true
      }
    }
  }
}

Function Code (Rust)

use crate::schema;
use shopify_function::prelude::*;
use shopify_function::Result;
use std::collections::HashMap;

#[shopify_function]
fn cart_transform_run(input: schema::cart_transform_run::Input) -> Result<schema::CartTransformRunResult> {
    let is_wholesale = input
        .cart()
        .buyer_identity()
        .and_then(|bi| bi.customer())
        .map(|customer| customer.is_wholesale())
        .unwrap_or(&false);

    if !is_wholesale {
        return Ok(schema::CartTransformRunResult { operations: vec![] });
    }

    let lines = input.cart().lines();

    let mut sku_map: HashMap<String, Vec<&schema::cart_transform_run::input::cart::Lines>> = HashMap::new();
    for line in lines {
        let merch = &line.merchandise();

        if let schema::cart_transform_run::input::cart::lines::Merchandise::ProductVariant(variant) = merch {
            sku_map.entry(variant.sku().unwrap().to_string()).or_default().push(line);
        }
    }

    let mut operations = vec![];
    for (sku, grouped_lines) in sku_map {
        if grouped_lines.len() < 2 {
            continue;
        }

        let cart_lines: Vec<schema::CartLineInput> = grouped_lines
            .iter()
            .map(|line| schema::CartLineInput {
                cart_line_id: line.id().clone(),
                quantity: *line.quantity(),
            })
            .collect();

        let merge_op = schema::LinesMergeOperation {
            cart_lines,
            parent_variant_id: "gid://shopify/ProductVariant/789".to_string(),
            title: Some(format!("SKU {} Bundle", sku)),
            price: Some(schema::PriceAdjustment {
                percentage_decrease: Some(schema::PriceAdjustmentValue { value: Decimal::from(10.0) }),
            }),
            image: None,
            attributes: Some(Vec::new())
        };

        operations.push(schema::Operation::LinesMerge(merge_op));
    }

    Ok(schema::CartTransformRunResult { operations })
}

Performance Cost (Rust)

70140 instructions

Function Code (JavaScript)

// @ts-check

/**
 * @typedef {import("../generated/api").RunInput} RunInput
 * @typedef {import("../generated/api").CartTransformRunResult} CartTransformRunResult
 * @typedef {import("../generated/api").LinesMergeOperation} LinesMergeOperation
 */

/**
 * @typedef {Object} FunctionCartLine
 * @property {string} id
 * @property {number} quantity
 * @property {{ __typename: string, sku: string }} merchandise
 */

/**
 * @param {any[]} lines
 * @returns {FunctionCartLine[]}
 */
function productVariantLines(lines) {
  return lines.reduce((acc, line) => {
    if (line.merchandise.__typename === 'ProductVariant') {
      acc.push(/** @type {FunctionCartLine} */ (line));
    }
    return acc;
  }, []);
}

/**
 * @typedef {Object} GroupedLine
 * @property {FunctionCartLine[]} cartLines
 * @property {boolean} hasMultipleVariants
 */

/**
 * @param {FunctionCartLine[]} lines
 * @returns {Object.<string, GroupedLine>}
 */
function groupLinesBySku(lines) {
  return lines.reduce((acc, line) => {
    const existingLine = acc[line.merchandise.sku];
    if (existingLine) {
      existingLine.cartLines.push(line);
      existingLine.hasMultipleVariants = true;
    } else {
      acc[line.merchandise.sku] = {
        cartLines: [line],
        hasMultipleVariants: false,
      };
    }
    return acc;
  }, {});
}

/**
 * @param {Object.<string, GroupedLine>} groupedLines
 * @returns {LinesMergeOperation[]}
 */
function mergeOperations(groupedLines) {
  const operations = [];

  for (const sku in groupedLines) {
    const groupedLine = groupedLines[sku];

    // we only want to merge lines that have multiple variants;
    // single SKUs shouldn't have a merge operation
    if (!groupedLine.hasMultipleVariants) {
      continue;
    }

    // parentVariantId is hardcoded for example purposes. it should be a value
    // of a shop's existing (published) product variant, and could e.g. be supplied
    // via a metafield on the product or variant.
    // the title and discount percentage could similarly be supplied via a metafield.
    const mergeOperation = {
      cartLines: groupedLine.cartLines.map(line => ({ cartLineId: line.id, quantity: line.quantity })),
      parentVariantId: "gid://shopify/ProductVariant/789",
      title: `SKU ${sku} Bundle`,
      price: {
        percentageDecrease: {
          value: 10
        }
      }
    };
    
    operations.push(mergeOperation);
  };

  return operations;
}

/**
 * @type {CartTransformRunResult}
 */
const NO_CHANGES = {
  operations: [],
};

/**
 * @param {RunInput} input
 * @returns {CartTransformRunResult}
 */
export function cartTransformRun(input) {
  // we only run this transform for wholesale customers
  if (!input.cart.buyerIdentity?.customer?.isWholesale) {
    return NO_CHANGES;
  }

  const scopedLines = productVariantLines(input.cart.lines);
  // the transform only applies to cart lines that are product variants
  if (scopedLines.length === 0) {
    return NO_CHANGES;
  }

  const groupedLines = groupLinesBySku(scopedLines);
  const operations = mergeOperations(groupedLines);

  return {
    operations: operations.map(op => ({
      linesMerge: op,
    })),
  };
};

Performance Cost (JavaScript)

403254 instructions

Output JSON (Rust)

{
  "operations": [
    {
      "linesMerge": {
        "attributes": [],
        "cartLines": [
          {
            "cartLineId": "gid://shopify/CartLine/1",
            "quantity": 1
          },
          {
            "cartLineId": "gid://shopify/CartLine/2",
            "quantity": 1
          }
        ],
        "image": null,
        "parentVariantId": "gid://shopify/ProductVariant/789",
        "price": {
          "percentageDecrease": {
            "value": "10.0"
          }
        },
        "title": "SKU 123 Bundle"
      }
    }
  ]
}

Output JSON (JavaScript)

{
  "operations": [
    {
      "linesMerge": {
        "cartLines": [
          {
            "cartLineId": "gid://shopify/CartLine/1",
            "quantity": 1
          },
          {
            "cartLineId": "gid://shopify/CartLine/2", 
            "quantity": 1
          }
        ],
        "parentVariantId": "gid://shopify/ProductVariant/789",
        "title": "SKU 123 Bundle",
        "price": {
          "percentageDecrease": {
            "value": 10
          }
        }
      }
    }
  ]
}

cart.transform.run

Input Query (Rust)

query Input {
  cart {
    lines {
      id
      quantity
      merchandise {
        __typename
        ... on ProductVariant {
          product {
            beautyBundleComponent: metafield(namespace: "custom", key: "beauty-product-bundle-component-type") {
              value
              type
            }
          }
        }
      }
    }
  }
}

Input Query (JavaScript)

query RunInput {
  cart {
    lines {
      id
      quantity
      merchandise {
        __typename
        ... on ProductVariant {
          product {
            beautyBundleComponent: metafield(namespace: "custom", key: "beauty-product-bundle-component-type") {
              value
              type
            }
          }
        }
      }
    }
  }
}

Input Object (Rust)

{
  "cart": {
    "lines": [
      {
        "id": "gid://shopify/CartLine/1",
        "quantity": 2,
        "merchandise": {
          "__typename": "ProductVariant",
          "product": {
            "beautyBundleComponent": {
              "value": "beauty-product-bundle-component-cleanser",
              "type": "single_line_text_field"
            }
          }
        }
      },
      {
        "id": "gid://shopify/CartLine/2",
        "quantity": 1,
        "merchandise": {
          "__typename": "ProductVariant",
          "product": {
            "beautyBundleComponent": {
              "value": "beauty-product-bundle-component-toner",
              "type": "single_line_text_field"
            }
          }
        }
      },
      {
        "id": "gid://shopify/CartLine/3",
        "quantity": 1,
        "merchandise": {
          "__typename": "ProductVariant",
          "product": {
            "beautyBundleComponent": {
              "value": "beauty-product-bundle-component-moisturizer",
              "type": "single_line_text_field"
            }
          }
        }
      }
    ]
  }
}

Input Object (JavaScript)

{
  "cart": {
    "lines": [
      {
        "id": "gid://shopify/CartLine/1",
        "quantity": 2,
        "merchandise": {
          "__typename": "ProductVariant",
          "product": {
            "beautyBundleComponent": {
              "value": "beauty-product-bundle-component-cleanser",
              "type": "single_line_text_field"
            }
          }
        }
      },
      {
        "id": "gid://shopify/CartLine/2",
        "quantity": 1,
        "merchandise": {
          "__typename": "ProductVariant",
          "product": {
            "beautyBundleComponent": {
              "value": "beauty-product-bundle-component-toner",
              "type": "single_line_text_field"
            }
          }
        }
      },
      {
        "id": "gid://shopify/CartLine/3",
        "quantity": 1,
        "merchandise": {
          "__typename": "ProductVariant",
          "product": {
            "beautyBundleComponent": {
              "value": "beauty-product-bundle-component-moisturizer",
              "type": "single_line_text_field"
            }
          }
        }
      }
    ]
  }
}

Function Code (Rust)