update-product-price

Instructions

Implementation Reference

• src/index.ts:193-218 (registration)

  MCP tool registration including input schema (zod), description, and thin wrapper handler calling ShopifyClient.updateProductPrice

  server.tool(
    "update-product-price",
    "Update the price of a product by its ID for all variants",
    {
      productId: z.string()
        .describe("ID of the product to update"),
      price: z.string()
      .describe("Price of the product to update to"),
    },
    async ({ productId, price }) => {
      const client = new ShopifyClient();
      try {
        const response = await client.updateProductPrice(
          SHOPIFY_ACCESS_TOKEN,
          MYSHOPIFY_DOMAIN,
          productId,
          price
        );
        return {
          content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
        };
      } catch (error) {
        return handleError("Failed to update product price", error);
      }
    }
  );

• src/ShopifyClient/ShopifyClient.ts:1441-1531 (handler)

  Core implementation of the price update via GraphQL productUpdate mutation, updating price for all product variants.

  async updateProductPrice(
    accessToken: string,
    shop: string,
    productId: string,
    price: string
  ): Promise<UpdateProductPriceResponse> {
    const myshopifyDomain = await this.getMyShopifyDomain(accessToken, shop);
    
    const graphqlQuery = gql`
      mutation productUpdate($input: ProductInput!) {
        productUpdate(input: $input) {
          product {
            id
            priceRangeV2 {
              minVariantPrice {
                amount
                currencyCode
              }
              maxVariantPrice {
                amount
                currencyCode
              }
            }
            variants(first: 100) {
              edges {
                node {
                  id
                  price
                }
              }
            }
          }
          userErrors {
            field
            message
          }
        }
      }
    `;
  
    const variables = {
      input: {
        id: productId,
        variants: {
          price: price
        }
      }
    };
  
    const res = await this.shopifyGraphqlRequest<{
      data: {
        productUpdate: {
          product: {
            id: string;
            priceRangeV2: {
              minVariantPrice: {amount: string; currencyCode: string};
              maxVariantPrice: {amount: string; currencyCode: string};
            };
            variants: {
              edges: Array<{
                node: {
                  id: string;
                  price: string;
                };
              }>;
            };
          };
          userErrors: Array<{field: string; message: string}>;
        };
      };
    }>({
      url: `https://${myshopifyDomain}/admin/api/${this.SHOPIFY_API_VERSION}/graphql.json`,
      accessToken,
      query: graphqlQuery,
      variables
    });
  
    const data = res.data.data;
    
    if (data.productUpdate.userErrors.length > 0) {
      return {
        success: false,
        errors: data.productUpdate.userErrors
      };
    }
  
    return {
      success: true,
      product: data.productUpdate.product
    };
  }

• src/index.ts:196-201 (schema)

  Zod input schema for the tool parameters: productId (string) and price (string).

  {
    productId: z.string()
      .describe("ID of the product to update"),
    price: z.string()
    .describe("Price of the product to update to"),
  },

• src/ShopifyClient/ShopifyClientPort.ts:167-180 (schema)

  TypeScript type definition for the output response of updateProductPrice, including success flag, errors, and updated product details.

  export type UpdateProductPriceResponse ={
    success: boolean;
    errors?: Array<{field: string; message: string}>;
    product?: {
      id: string;
      variants: {
        edges: Array<{
          node: {
            price: string;
          };
        }>;
      };
    };
  }

• src/ShopifyClient/ShopifyClientPort.ts:1061-1066 (schema)

  Interface method signature in ShopifyClientPort defining the updateProductPrice method.

  updateProductPrice(
    accessToken: string,
    shop: string,
    productId: string,
    price: string
  ): Promise<UpdateProductPriceResponse>;