Correct, this was a draft order update mutation, and yes, we are running processes in parallel. I'll share some relevant portions of the code with some annotations.
The gist of the app is this. We mark some items are "pre-order" using additional attributes on the Order. When an order has pre-order items in it, it gets sent to our app to:
- copy an order for as many pre-order line items that are present — i.e. if an order has 2 pre-order items, the app makes 2 draft orders
- remove the necessary line items from the newly created draft orders — i.e. one draft order has 1 preorder item, the other draft order has the other preorder item
- complete the draft orders
- remove the pre-order line items from the original order
The app fails at the second step for one order, but not another.
// get an order the has preorder items
get(order.id)
.then((order: Order | null) => {
if (!order) {
return { error: "Order not found" };
}
// filter out the line items that are NOT preorder items
const lineItems = order.lineItems.nodes.filter((
lineItem: DraftOrder.LineItem,
) => preordersFromAttrs(order.customAttributes).includes(lineItem.name)
);
// this is running in parallel
return Promise.all(
lineItems
.map(async (
lineItem: DraftOrder.LineItem,
) => (
// creates a new draft order based off of the order
await DraftOrder.fromOrder(order.id)
.then((result: Result<DraftOrder.DraftOrder, string>) =>
(
console.log(JSON.stringify(result)),
"ok" in result
// this is where it will fail for one line item but not another
// it takes the one line item, and updates the Draft Order
// so that it only has 1 line item in it
// see code in next block
? DraftOrder.preparePreorderFulfillmentOrder(
result.ok,
[lineItem.name],
)
: result)
)
// if all good, complete the order
.then((result: Result<string, string>) =>
"ok" in result ? DraftOrder.complete(result.ok) : result
)
// update tags
.then((result: Result<string, string>) =>
"ok" in result
? tag(result.ok, [
`__preorder_app:parent_${order.legacyResourceId}`,
])
: result
))
),
)
// after Promise.all, so no longer parallel
.then((
results: Result<Order, string>[],
) => (console.log(
"createPreorderFulfillmentOrders after Promise.all",
results,
),
results[0])
);
});
Though the processes are running in parallel, the mutations on each individual draft order are happening sequentially.
Here is the mutation that is failing:
const preparePreorderFulfillmentOrderMutation: string = `
mutation preparePreorderFulfillmentOrder($id: ID!, $input: DraftOrderInput!) {
draftOrderUpdate(id: $id, input: $input) {
draftOrder {
id
}
userErrors {
field
message
}
}
}
`;
// this updates the Draft Order so that there is only 1 line item in it
// the pre-order item from the Promise.all map
const preparePreorderFulfillmentOrder = (
draftOrder: DraftOrder,
preorders: string[],
): Promise<Result<string, string>> =>
Shopify.request(
JSON.stringify({
query: preparePreorderFulfillmentOrderMutation,
variables: {
id: draftOrder.id,
input: {
lineItems: draftOrder.lineItems.nodes
.filter((lineItem: LineItem) => preorders.includes(lineItem.name))
.map((lineItem: LineItem) => (console.log("preparePreorderFulfillmentOrder map", lineItem), {
appliedDiscount: {
description: "Preorder fulfillment",
value: 100.0,
valueType: "PERCENTAGE",
},
quantity: lineItem.quantity,
variantId: lineItem.variant.id,
})),
tags: draftOrder.tags
.filter((tag: string) => !tag.match("__preorder*"))
.concat("__preorder_app:preorder_fulfillment"),
},
},
}),
).then(
// ...just ensure that we return an "ok" in our results
);
Apologies for so much!
You say,
"but is it possible that your integration/workflow is making multiple requests for the same API resource around the same time while trying to update the draft order? "
I'll experiment with just adding a delay between the Draft Order creation and the Draft Order update and see if it that works
Shopify Discussion
Partners and Developers