shopify-mcp

Implementation Reference

• src/tools/getProductById.ts:25-167 (handler)

  The execute method of the getProductById tool that performs the GraphQL query to Shopify to retrieve and format product details by ID.

  execute: async (input: GetProductByIdInput) => {
    try {
      const { productId } = input;
  
      const query = gql`
        query GetProductById($id: ID!) {
          product(id: $id) {
            id
            title
            description
            handle
            status
            createdAt
            updatedAt
            totalInventory
            priceRangeV2 {
              minVariantPrice {
                amount
                currencyCode
              }
              maxVariantPrice {
                amount
                currencyCode
              }
            }
            images(first: 5) {
              edges {
                node {
                  id
                  url
                  altText
                  width
                  height
                }
              }
            }
            variants(first: 20) {
              edges {
                node {
                  id
                  title
                  price
                  inventoryQuantity
                  sku
                  selectedOptions {
                    name
                    value
                  }
                }
              }
            }
            collections(first: 5) {
              edges {
                node {
                  id
                  title
                }
              }
            }
            tags
            vendor
          }
        }
      `;
  
      const variables = {
        id: productId
      };
  
      const data = (await shopifyClient.request(query, variables)) as {
        product: any;
      };
  
      if (!data.product) {
        throw new Error(`Product with ID ${productId} not found`);
      }
  
      // Format product data
      const product = data.product;
  
      // Format variants
      const variants = product.variants.edges.map((variantEdge: any) => ({
        id: variantEdge.node.id,
        title: variantEdge.node.title,
        price: variantEdge.node.price,
        inventoryQuantity: variantEdge.node.inventoryQuantity,
        sku: variantEdge.node.sku,
        options: variantEdge.node.selectedOptions
      }));
  
      // Format images
      const images = product.images.edges.map((imageEdge: any) => ({
        id: imageEdge.node.id,
        url: imageEdge.node.url,
        altText: imageEdge.node.altText,
        width: imageEdge.node.width,
        height: imageEdge.node.height
      }));
  
      // Format collections
      const collections = product.collections.edges.map(
        (collectionEdge: any) => ({
          id: collectionEdge.node.id,
          title: collectionEdge.node.title
        })
      );
  
      const formattedProduct = {
        id: product.id,
        title: product.title,
        description: product.description,
        handle: product.handle,
        status: product.status,
        createdAt: product.createdAt,
        updatedAt: product.updatedAt,
        totalInventory: product.totalInventory,
        priceRange: {
          minPrice: {
            amount: product.priceRangeV2.minVariantPrice.amount,
            currencyCode: product.priceRangeV2.minVariantPrice.currencyCode
          },
          maxPrice: {
            amount: product.priceRangeV2.maxVariantPrice.amount,
            currencyCode: product.priceRangeV2.maxVariantPrice.currencyCode
          }
        },
        images,
        variants,
        collections,
        tags: product.tags,
        vendor: product.vendor
      };
  
      return { product: formattedProduct };
    } catch (error) {
      console.error("Error fetching product by ID:", error);
      throw new Error(
        `Failed to fetch product: ${
          error instanceof Error ? error.message : String(error)
        }`
      );
    }
  }

• src/tools/getProductById.ts:5-8 (schema)

  Zod input schema validation for the get-product-by-id tool.

  // Input schema for getProductById
  const GetProductByIdInputSchema = z.object({
    productId: z.string().min(1)
  });

• src/index.ts:96-107 (registration)

  Registration of the get-product-by-id tool in the MCP server using server.tool().

  server.tool(
    "get-product-by-id",
    {
      productId: z.string().min(1)
    },
    async (args) => {
      const result = await getProductById.execute(args);
      return {
        content: [{ type: "text", text: JSON.stringify(result) }]
      };
    }
  );

• src/index.ts:15-15 (registration)

  Import statement for the getProductById tool module.

  import { getProductById } from "./tools/getProductById.js";

• src/index.ts:64-64 (helper)

  Initialization of the getProductById tool with the Shopify GraphQL client.

  getProductById.initialize(shopifyClient);