complete-draft-order

Instructions

Implementation Reference

• src/index.ts:456-481 (registration)

  MCP tool registration for 'complete-draft-order', including input schema (Zod) and thin handler that instantiates ShopifyClient and calls completeDraftOrder

  server.tool(
    "complete-draft-order",
    "Complete a draft order",
    {
      draftOrderId: z.string().describe("ID of the draft order to complete"),
      variantId: z.string().describe("ID of the variant in the draft order"),
    },
    async ({ draftOrderId, variantId }) => {
      const client = new ShopifyClient();
      try {
        const completedOrder = await client.completeDraftOrder(
          SHOPIFY_ACCESS_TOKEN,
          MYSHOPIFY_DOMAIN,
          draftOrderId,
          variantId
        );
        return {
          content: [
            { type: "text", text: JSON.stringify(completedOrder, null, 2) },
          ],
        };
      } catch (error) {
        return handleError("Failed to complete draft order", error);
      }
    }
  );

• src/ShopifyClient/ShopifyClientPort.ts:547-551 (schema)

  Type definition for the response of completeDraftOrder

  export type CompleteDraftOrderResponse = {
    draftOrderId: string;
    draftOrderName: string;
    orderId: string;
  };

• src/ShopifyClient/ShopifyClientPort.ts:1059-1064 (schema)

  Interface definition for ShopifyClientPort.completeDraftOrder method signature

  completeDraftOrder(
    accessToken: string,
    shop: string,
    draftOrderId: string,
    variantId: string
  ): Promise<CompleteDraftOrderResponse>;

• src/ShopifyClient/ShopifyClient.ts:1292-1385 (handler)

  Core implementation of completeDraftOrder: validates variant availability via loadVariantsByIds, executes Shopify GraphQL mutation 'draftOrderComplete', handles errors, and returns order details.

  async completeDraftOrder(
    accessToken: string,
    shop: string,
    draftOrderId: string,
    variantId: string
  ): Promise<CompleteDraftOrderResponse> {
    // First, load the variant to check if it's available for sale
    const variantResult = await this.loadVariantsByIds(accessToken, shop, [
      variantId,
    ]);
  
    if (!variantResult.variants || variantResult.variants.length === 0) {
      throw new ShopifyProductVariantNotFoundError({
        contextData: {
          shop,
          variantId,
        },
      });
    }
  
    const variant = variantResult.variants[0];
  
    if (!variant.availableForSale) {
      throw new ShopifyProductVariantNotAvailableForSaleError({
        contextData: {
          shop,
          variantId,
        },
      });
    }
  
    const myshopifyDomain = await this.getMyShopifyDomain(accessToken, shop);
  
    const graphqlQuery = gql`
      mutation draftOrderComplete($id: ID!) {
        draftOrderComplete(id: $id) {
          draftOrder {
            id
            name
            order {
              id
            }
          }
          userErrors {
            field
            message
          }
        }
      }
    `;
  
    const res = await this.shopifyGraphqlRequest<{
      data: {
        draftOrderComplete: {
          draftOrder: {
            id: string;
            name: string;
            order: {
              id: string;
            };
          };
          userErrors: Array<{
            field: string[];
            message: string;
          }>;
        };
      };
    }>({
      url: `https://${myshopifyDomain}/admin/api/${this.SHOPIFY_API_VERSION}/graphql.json`,
      accessToken,
      query: graphqlQuery,
      variables: {
        id: draftOrderId,
      },
    });
  
    const draftOrder = res.data.data.draftOrderComplete.draftOrder;
    const order = draftOrder.order;
    const userErrors = res.data.data.draftOrderComplete.userErrors;
  
    if (userErrors && userErrors.length > 0) {
      throw getGraphqlShopifyUserError(userErrors, {
        shop,
        draftOrderId,
        variantId,
      });
    }
  
    return {
      draftOrderId: draftOrder.id,
      orderId: order.id,
      draftOrderName: draftOrder.name,
    };
  }