@solution25/n8n-nodes-shopware 1.4.4 → 2.0.0

package/dist/nodes/Shopware/v1/actions/order/update.operation.js

@@ -6,6 +6,10 @@ const n8n_workflow_1 = require("n8n-workflow");
 const transport_1 = require("../../transport");
 const fields_1 = require("./fields");
 const utils_1 = require("../../helpers/utils");
+const params_1 = require("../../helpers/params");
+const payloadBuilders_1 = require("../../helpers/payloadBuilders");
+const pricing_1 = require("../../helpers/pricing");
+const validation_1 = require("../../helpers/validation");
 const properties = [
     {
         displayName: 'Order ID',
@@ -65,6 +69,20 @@ const properties = [
                                 default: '',
                                 description: 'Customer last name',
                             },
+                            {
+                                displayName: 'Zip Code',
+                                name: 'zipcode',
+                                type: 'string',
+                                default: '',
+                                description: 'Billing address postal code',
+                            },
+                            {
+                                displayName: 'State / Province',
+                                name: 'state',
+                                type: 'string',
+                                default: '',
+                                description: 'Optional state or province name/code for the billing address',
+                            },
                             {
                                 displayName: 'City',
                                 name: 'city',
@@ -111,17 +129,6 @@ const properties = [
                                 default: '',
                                 description: 'Delivery shipping method',
                             },
-                            {
-                                displayName: 'State',
-                                name: 'state',
-                                type: 'options',
-                                typeOptions: {
-                                    loadOptionsMethod: 'getDeliveryStates',
-                                },
-                                required: true,
-                                default: '',
-                                description: 'State of the delivery (e.g. Shipped)',
-                            },
                             {
                                 displayName: 'Use Customer Shipping Address',
                                 name: 'customerShippingAddress',
@@ -176,6 +183,20 @@ const properties = [
                                                 default: '',
                                                 description: 'Customer last name',
                                             },
+                                            {
+                                                displayName: 'Zip Code',
+                                                name: 'zipcode',
+                                                type: 'string',
+                                                default: '',
+                                                description: 'Shipping address postal code',
+                                            },
+                                            {
+                                                displayName: 'State / Province',
+                                                name: 'state',
+                                                type: 'string',
+                                                default: '',
+                                                description: 'Optional state or province name/code for the shipping address',
+                                            },
                                             {
                                                 displayName: 'City',
                                                 name: 'city',
@@ -230,7 +251,7 @@ const properties = [
                                 type: 'number',
                                 typeOptions: {
                                     maxValue: 999000000,
-                                    minValue: 0,
+                                    minValue: 1,
                                 },
                                 required: true,
                                 default: 1,
@@ -283,6 +304,20 @@ const properties = [
                                 default: '',
                                 description: 'Customer last name',
                             },
+                            {
+                                displayName: 'Zip Code',
+                                name: 'zipcode',
+                                type: 'string',
+                                default: '',
+                                description: 'Shipping address postal code',
+                            },
+                            {
+                                displayName: 'State / Province',
+                                name: 'state',
+                                type: 'string',
+                                default: '',
+                                description: 'Optional state or province name/code for the shipping address',
+                            },
                             {
                                 displayName: 'City',
                                 name: 'city',
@@ -384,174 +419,164 @@ const displayOptions = {
 };
 exports.description = (0, n8n_workflow_1.updateDisplayOptions)(displayOptions, properties);
 async function execute(items) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d;
     const returnData = [];
+    let prePaymentOrderStatesPromise;
+    const shippingMethodDataCache = new Map();
+    const countryStateCache = new Map();
     for (let i = 0; i < items.length; i++) {
         try {
-            const id = this.getNodeParameter('id', i);
+            const params = params_1.extractOrderUpdateParams.call(this, i);
+            const orderId = (0, validation_1.validateShopwareId)(this.getNode(), params.id, i, 'Order ID');
             const searchPrevOrderBody = {
-                filter: [{ type: 'equals', field: 'id', value: id }],
+                filter: [{ type: 'equals', field: 'id', value: orderId }],
                 associations: {
                     currency: {},
+                    lineItems: {},
+                    deliveries: {
+                        associations: {
+                            shippingOrderAddress: {},
+                            positions: {},
+                        },
+                    },
                 },
             };
             const prevOrder = (await transport_1.apiRequest.call(this, 'POST', `/search/order`, searchPrevOrderBody)).data[0];
             if (!prevOrder) {
                 throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Order does not exist', {
-                    description: 'There is no order with id ' + id,
+                    description: 'There is no order with id ' + orderId,
                     itemIndex: i,
                 });
             }
-            const { state: orderState, ...updateFields } = this.getNodeParameter('updateFields', i);
-            const { currency: currencyData, shippingCosts: shippingData, orderCustomer: prevOrderCustomer, ...previousOrderData } = prevOrder;
+            const { currency: currencyData, orderCustomer: prevOrderCustomer, ...previousOrderData } = prevOrder;
             const customerData = {};
-            const customerBillingAddress = (_a = updateFields.billingAddressUi) === null || _a === void 0 ? void 0 : _a.billingAddressValues;
-            const customerShippingAddress = (_b = updateFields.shippingAddressUi) === null || _b === void 0 ? void 0 : _b.shippingAddressValues;
-            if (customerBillingAddress) {
-                const prePaymentStates = await utils_1.getPrePaymentOrderStates.call(this);
+            if (params.billingAddress) {
+                prePaymentOrderStatesPromise !== null && prePaymentOrderStatesPromise !== void 0 ? prePaymentOrderStatesPromise : (prePaymentOrderStatesPromise = utils_1.getPrePaymentOrderStates.call(this));
+                const prePaymentStates = await prePaymentOrderStatesPromise;
                 if (prePaymentStates.includes(previousOrderData.stateId)) {
                     customerData.billingAddress = {
                         id: (0, utils_1.uuidv7)(),
-                        countryId: customerBillingAddress.country,
-                        firstName: customerBillingAddress.firstName,
-                        lastName: customerBillingAddress.lastName,
-                        city: customerBillingAddress.city,
-                        street: customerBillingAddress.street,
+                        countryId: params.billingAddress.country,
+                        countryStateId: await utils_1.resolveCountryStateId.call(this, params.billingAddress.country, params.billingAddress.state, countryStateCache, i, 'Billing state / province'),
+                        salutationId: prevOrderCustomer.salutationId,
+                        firstName: params.billingAddress.firstName,
+                        lastName: params.billingAddress.lastName,
+                        zipcode: (_a = params.billingAddress.zipcode) !== null && _a !== void 0 ? _a : '',
+                        city: params.billingAddress.city,
+                        street: params.billingAddress.street,
                     };
                 }
             }
-            if (customerShippingAddress) {
+            if (params.shippingAddress) {
                 customerData.shippingAddress = {
                     id: (0, utils_1.uuidv7)(),
-                    countryId: customerShippingAddress.country,
-                    firstName: customerShippingAddress.firstName,
-                    lastName: customerShippingAddress.lastName,
-                    city: customerShippingAddress.city,
-                    street: customerShippingAddress.street,
+                    countryId: params.shippingAddress.country,
+                    countryStateId: await utils_1.resolveCountryStateId.call(this, params.shippingAddress.country, params.shippingAddress.state, countryStateCache, i, 'Shipping state / province'),
+                    salutationId: prevOrderCustomer.salutationId,
+                    firstName: params.shippingAddress.firstName,
+                    lastName: params.shippingAddress.lastName,
+                    zipcode: (_b = params.shippingAddress.zipcode) !== null && _b !== void 0 ? _b : '',
+                    city: params.shippingAddress.city,
+                    street: params.shippingAddress.street,
                 };
             }
-            const nodeLineItems = (_c = updateFields.lineItems) === null || _c === void 0 ? void 0 : _c.lineItem;
-            let transactions = [];
-            const nodeTransactions = (_d = updateFields.transactions) === null || _d === void 0 ? void 0 : _d.transaction;
             let lineItems = [];
             let price = null;
-            if (nodeLineItems) {
-                lineItems = await Promise.all(nodeLineItems.map(async (lineItem) => {
-                    const { identifier, productId, label, states, unitPrice, taxRate } = await utils_1.getLineItemData.call(this, lineItem.productNumber, currencyData.id, i);
-                    const quantity = lineItem.quantity;
-                    const totalPrice = unitPrice * quantity;
-                    const tax = totalPrice * (taxRate / 100);
-                    const taxPrice = totalPrice + tax;
-                    const price = {
-                        unitPrice,
-                        totalPrice,
-                        quantity,
-                        calculatedTaxes: [
-                            {
-                                tax,
-                                taxRate,
-                                price: taxPrice,
-                            },
-                        ],
-                        taxRules: [
-                            {
-                                taxRate,
-                                percentage: 100,
-                            },
-                        ],
-                    };
-                    return {
-                        identifier,
-                        productId,
-                        quantity,
-                        label,
-                        states,
-                        price,
-                    };
+            let transactions = [];
+            if (params.nodeLineItems) {
+                const lineItemLookup = await utils_1.getLineItemDataBatch.call(this, params.nodeLineItems.map((lineItem) => lineItem.productNumber), currencyData.id, i);
+                lineItems = await Promise.all(params.nodeLineItems.map(async (lineItem) => {
+                    const itemData = lineItemLookup.get(lineItem.productNumber);
+                    if (!itemData) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No product found', {
+                            description: 'There is no product associated with product number ' + lineItem.productNumber,
+                            itemIndex: i,
+                        });
+                    }
+                    return (0, payloadBuilders_1.buildLineItemPayload)({ ...itemData, quantity: lineItem.quantity });
                 }));
-                const defaultTaxRate = await utils_1.getDefaultTaxRate.call(this);
-                const totalPrice = lineItems.reduce((acc, item) => acc + item.price.totalPrice, 0) +
-                    previousOrderData.amountNet;
-                const orderTax = totalPrice * (defaultTaxRate / 100);
-                const taxPrice = totalPrice + orderTax;
-                const quantity = lineItems.reduce((acc, item) => acc + item.quantity, 0);
-                price = {
-                    netPrice: totalPrice,
-                    totalPrice: taxPrice,
-                    calculatedTaxes: [
-                        {
-                            tax: orderTax,
-                            taxRate: defaultTaxRate,
-                            price: taxPrice,
-                        },
-                    ],
-                    taxRules: [
-                        {
-                            taxRate: defaultTaxRate,
-                            percentage: 100,
-                        },
-                    ],
-                    positionPrice: totalPrice,
-                    rawTotal: totalPrice,
-                    taxStatus: 'gross',
-                };
-                if (nodeTransactions && nodeTransactions.length > 0) {
-                    transactions = nodeTransactions.map((transaction) => {
-                        const amount = {
-                            unitPrice: totalPrice,
-                            totalPrice: taxPrice,
-                            quantity: quantity,
-                            calculatedTaxes: [
-                                {
-                                    tax: orderTax,
-                                    taxRate: defaultTaxRate,
-                                    price: taxPrice,
-                                },
-                            ],
-                            taxRules: [
-                                {
-                                    taxRate: defaultTaxRate,
-                                    percentage: 100,
-                                },
-                            ],
-                        };
-                        return {
-                            paymentMethodId: transaction.paymentMethod,
-                            stateId: transaction.state,
-                            amount,
-                        };
-                    });
+                const orderTotals = (0, pricing_1.calculateOrderTotals)(lineItems);
+                price = (0, payloadBuilders_1.buildOrderPrice)({
+                    netPrice: orderTotals.netPrice,
+                    totalPrice: orderTotals.totalPrice,
+                    calculatedTaxes: orderTotals.calculatedTaxes,
+                    taxRules: orderTotals.taxRules,
+                });
+                if (params.nodeTransactions && params.nodeTransactions.length > 0) {
+                    transactions = params.nodeTransactions.map((transaction) => (0, payloadBuilders_1.buildTransactionPayload)({
+                        paymentMethodId: transaction.paymentMethod,
+                        stateId: transaction.state,
+                        netPrice: orderTotals.netPrice,
+                        totalPrice: orderTotals.totalPrice,
+                        quantity: orderTotals.quantity,
+                        calculatedTaxes: orderTotals.calculatedTaxes,
+                        taxRules: orderTotals.taxRules,
+                    }));
                 }
             }
-            if (!nodeLineItems && nodeTransactions) {
+            if (!params.nodeLineItems && params.nodeTransactions) {
                 throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Missing line items for transaction', {
                     description: 'Line items are required for order transactions',
                     itemIndex: i,
                 });
             }
-            const addresses = [];
-            if (customerShippingAddress && customerData.shippingAddress) {
-                addresses.push({
+            const effectiveLineItems = lineItems.length > 0 ? lineItems : ((_c = prevOrder.lineItems) !== null && _c !== void 0 ? _c : []);
+            let customerShippingAddress = null;
+            if (params.shippingAddress && customerData.shippingAddress) {
+                customerShippingAddress = (0, payloadBuilders_1.buildOrderAddressPayload)({
                     id: customerData.shippingAddress.id,
                     countryId: customerData.shippingAddress.countryId,
+                    countryStateId: customerData.shippingAddress.countryStateId,
+                    salutationId: customerData.shippingAddress.salutationId,
                     firstName: customerData.shippingAddress.firstName,
                     lastName: customerData.shippingAddress.lastName,
+                    zipcode: customerData.shippingAddress.zipcode,
                     city: customerData.shippingAddress.city,
                     street: customerData.shippingAddress.street,
                 });
             }
-            let deliveries = [];
-            const nodeDeliveries = (_e = updateFields.deliveries) === null || _e === void 0 ? void 0 : _e.delivery;
-            let shippingCosts = null;
-            if (nodeDeliveries && nodeDeliveries.length > 0) {
-                deliveries = await Promise.all(nodeDeliveries.map(async (delivery) => {
-                    let shippingOrderAddressId;
+            const deliveries = [];
+            const shippingCosts = null;
+            if (params.nodeDeliveries && params.nodeDeliveries.length > 0) {
+                if (effectiveLineItems.length === 0) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Missing order line items for delivery update', {
+                        description: 'The order does not contain line items that can be used to rebuild delivery positions.',
+                        itemIndex: i,
+                    });
+                }
+                if (!prevOrder.deliveries || prevOrder.deliveries.length < params.nodeDeliveries.length) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Delivery update is invalid', {
+                        description: 'The order does not contain enough existing deliveries to update.',
+                        itemIndex: i,
+                    });
+                }
+                const existingCustomer = customerShippingAddress === null
+                    && params.nodeDeliveries.some((delivery) => delivery.customerShippingAddress)
+                    ? await utils_1.getCustomerByNumber.call(this, prevOrderCustomer.customerNumber, i)
+                    : null;
+                for (let deliveryIndex = 0; deliveryIndex < params.nodeDeliveries.length; deliveryIndex++) {
+                    const delivery = params.nodeDeliveries[deliveryIndex];
+                    const existingDelivery = prevOrder.deliveries[deliveryIndex];
+                    let shippingAddress;
                     if (delivery.customerShippingAddress) {
-                        if (addresses.length > 0) {
-                            shippingOrderAddressId = addresses[0].id;
+                        if (customerShippingAddress) {
+                            shippingAddress = {
+                                ...customerShippingAddress,
+                                id: existingDelivery.shippingOrderAddress.id,
+                            };
                         }
                         else {
-                            shippingOrderAddressId = (await utils_1.getCustomerByNumber.call(this, prevOrderCustomer.customerNumber, i)).defaultShippingAddressId;
+                            shippingAddress = {
+                                id: existingDelivery.shippingOrderAddress.id,
+                                countryId: existingCustomer.shippingAddress.countryId,
+                                countryStateId: existingCustomer.shippingAddress.countryStateId,
+                                salutationId: existingCustomer.shippingAddress.salutationId,
+                                firstName: existingCustomer.shippingAddress.firstName,
+                                lastName: existingCustomer.shippingAddress.lastName,
+                                zipcode: existingCustomer.shippingAddress.zipcode,
+                                street: existingCustomer.shippingAddress.street,
+                                city: existingCustomer.shippingAddress.city,
+                            };
                         }
                     }
                     else {
@@ -562,7 +587,7 @@ async function execute(items) {
                                 itemIndex: i,
                             });
                         }
-                        for (const key in address) {
+                        for (const key of ['country', 'firstName', 'lastName', 'city', 'street']) {
                             if (address[key] === '') {
                                 throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Missing required value for shipping address', {
                                     description: `Shipping address ${key} must be a valid value.`,
@@ -570,137 +595,83 @@ async function execute(items) {
                                 });
                             }
                         }
-                        shippingOrderAddressId = (0, utils_1.uuidv7)();
-                        addresses.push({
-                            id: shippingOrderAddressId,
+                        shippingAddress = (0, payloadBuilders_1.buildOrderAddressPayload)({
+                            id: existingDelivery.shippingOrderAddress.id,
                             countryId: address.country,
+                            countryStateId: await utils_1.resolveCountryStateId.call(this, address.country, address.state, countryStateCache, i, 'Delivery state / province'),
+                            salutationId: prevOrderCustomer.salutationId,
                             firstName: address.firstName,
                             lastName: address.lastName,
+                            zipcode: (_d = address.zipcode) !== null && _d !== void 0 ? _d : '',
                             city: address.city,
                             street: address.street,
                         });
                     }
-                    const { ['unitPrice']: shippingPrice, ['taxRate']: shippingTaxRate } = await utils_1.getShippingMethodData.call(this, delivery.shippingMethod, currencyData.id);
-                    const deliveryTime = await utils_1.getShippingDeliveryTime.call(this, delivery.shippingMethod);
-                    const shippingTax = shippingPrice * (shippingTaxRate / 100);
-                    const shippingTaxPrice = shippingPrice + shippingTax;
-                    const shippingCosts = {
-                        unitPrice: shippingPrice,
-                        totalPrice: shippingPrice,
-                        quantity: 1,
-                        calculatedTaxes: [
-                            {
-                                tax: shippingTax,
-                                taxRate: shippingTaxRate,
-                                price: shippingTaxPrice,
-                            },
-                        ],
-                        taxRules: [
-                            {
-                                taxRate: shippingTaxRate,
-                                percentage: 100,
-                            },
-                        ],
-                    };
-                    const shippingDateEarliest = new Date();
-                    const shippingDateLatest = new Date();
-                    switch (deliveryTime.unit) {
-                        case 'hour':
-                            shippingDateEarliest.setHours(shippingDateEarliest.getHours() + deliveryTime.min);
-                            shippingDateLatest.setHours(shippingDateLatest.getHours() + deliveryTime.max);
-                            break;
-                        case 'day':
-                            shippingDateEarliest.setDate(shippingDateEarliest.getDate() + deliveryTime.min);
-                            shippingDateLatest.setDate(shippingDateLatest.getDate() + deliveryTime.max);
-                            break;
-                        case 'week':
-                            shippingDateEarliest.setDate(shippingDateEarliest.getDate() + deliveryTime.min * 7);
-                            shippingDateLatest.setDate(shippingDateLatest.getDate() + deliveryTime.max * 7);
-                            break;
+                    await transport_1.apiRequest.call(this, 'PATCH', `/order-address/${existingDelivery.shippingOrderAddress.id}`, shippingAddress);
+                    const shippingMethodDataKey = `${delivery.shippingMethod}:${currencyData.id}`;
+                    if (!shippingMethodDataCache.has(shippingMethodDataKey)) {
+                        shippingMethodDataCache.set(shippingMethodDataKey, utils_1.getShippingMethodFullData.call(this, delivery.shippingMethod, currencyData.id));
                     }
-                    return {
-                        shippingOrderAddressId,
+                    const shippingMethodData = await shippingMethodDataCache.get(shippingMethodDataKey);
+                    const patchedDelivery = (0, payloadBuilders_1.buildDeliveryPayload)({
+                        deliveryId: existingDelivery.id,
+                        shippingAddress,
                         shippingMethodId: delivery.shippingMethod,
-                        stateId: delivery.state,
-                        shippingDateEarliest,
-                        shippingDateLatest,
-                        shippingCosts,
-                    };
-                }));
-                const deliveriesUnitPrice = deliveries.reduce((acc, delivery) => acc + delivery.shippingCosts.unitPrice, 0) +
-                    shippingData.unitPrice;
-                const deliveriesTax = deliveries.reduce((acc, delivery) => acc + delivery.shippingCosts.calculatedTaxes[0].tax, 0) + shippingData.calculatedTaxes[0].tax;
-                const deliveriesTaxRate = deliveries[0].shippingCosts.taxRules[0].taxRate;
-                const deliveriesTaxPrice = deliveriesUnitPrice + deliveriesTax;
-                shippingCosts = {
-                    unitPrice: deliveriesUnitPrice,
-                    totalPrice: deliveriesUnitPrice,
-                    quantity: 1,
-                    calculatedTaxes: [
-                        {
-                            tax: deliveriesTax,
-                            taxRate: deliveriesTaxRate,
-                            price: deliveriesTaxPrice,
-                        },
-                    ],
-                    taxRules: [
-                        {
-                            taxRate: deliveriesTaxRate,
-                            percentage: 100,
-                        },
-                    ],
-                };
+                        stateId: existingDelivery.stateId,
+                        shippingPrice: shippingMethodData.unitPrice,
+                        shippingTaxRate: shippingMethodData.taxRate,
+                        deliveryTime: shippingMethodData.deliveryTime,
+                        lineItems: effectiveLineItems,
+                        uuidFn: utils_1.uuidv7,
+                    });
+                    await transport_1.apiRequest.call(this, 'PATCH', `/order-delivery/${existingDelivery.id}`, {
+                        shippingMethodId: patchedDelivery.shippingMethodId,
+                        shippingCosts: patchedDelivery.shippingCosts,
+                        shippingDateEarliest: patchedDelivery.shippingDateEarliest,
+                        shippingDateLatest: patchedDelivery.shippingDateLatest,
+                    });
+                }
             }
-            let serializedBillingAddress = null;
-            if (customerData.billingAddress) {
-                serializedBillingAddress = {
-                    id: customerData.billingAddress.id,
-                    countryId: customerData.billingAddress.countryId,
-                    firstName: customerData.billingAddress.firstName,
-                    lastName: customerData.billingAddress.lastName,
-                    city: customerData.billingAddress.city,
-                    street: customerData.billingAddress.street,
-                };
+            else if (customerShippingAddress && prevOrder.deliveries && prevOrder.deliveries.length > 0) {
+                for (const delivery of prevOrder.deliveries) {
+                    await transport_1.apiRequest.call(this, 'PATCH', `/order-address/${delivery.shippingOrderAddress.id}`, {
+                        ...customerShippingAddress,
+                        id: delivery.shippingOrderAddress.id,
+                    });
+                }
             }
-            const updateBody = {
-                billingAddressId: customerData.billingAddress ? customerData.billingAddress.id : null,
-                billingAddress: serializedBillingAddress,
+            const updateBody = (0, payloadBuilders_1.buildOrderUpdatePayload)({
+                customerData,
                 lineItems,
                 price,
                 shippingCosts,
                 transactions,
                 deliveries,
-                addresses,
-            };
-            const searchBody = {
-                fields: fields_1.orderFields,
-                includes: {
-                    order: fields_1.orderFields,
-                },
-                filter: [{ type: 'equals', field: 'id', value: id }],
-            };
-            for (const key in updateBody) {
-                const typedKey = key;
-                if (Array.isArray(updateBody[typedKey]) &&
-                    updateBody[typedKey].length === 0) {
-                    delete updateBody[typedKey];
-                }
-                else if (updateBody[typedKey] === '' || updateBody[typedKey] === null) {
-                    delete updateBody[typedKey];
-                }
-            }
-            if (orderState) {
-                await transport_1.apiRequest.call(this, 'POST', `/_action/order/${previousOrderData.id}/state/${orderState}`);
-            }
-            if (orderState === '') {
+            });
+            (0, payloadBuilders_1.cleanPayload)(updateBody, true);
+            if (params.orderState === '') {
                 throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid order state', {
                     description: 'Please specify a valid order state from the list',
                     itemIndex: i,
                 });
             }
-            if (Object.keys(updateFields).length !== 0) {
-                await transport_1.apiRequest.call(this, 'PATCH', `/order/${id}`, updateBody);
+            if (params.orderState) {
+                await transport_1.apiRequest.call(this, 'POST', `/_action/order/${orderId}/state/${params.orderState}`);
+            }
+            if (Object.keys(updateBody).length !== 0) {
+                await transport_1.apiRequest.call(this, 'PATCH', `/order/${orderId}`, updateBody);
             }
+            const searchBody = {
+                fields: fields_1.orderFields,
+                includes: { order: fields_1.orderFields },
+                filter: [{ type: 'equals', field: 'id', value: orderId }],
+                associations: {
+                    currency: {},
+                    deliveries: {},
+                    transactions: {},
+                    lineItems: {},
+                },
+            };
             const response = await transport_1.apiRequest.call(this, 'POST', `/search/order`, searchBody);
             const executionData = this.helpers.constructExecutionMetaData((0, utils_1.wrapData)(response.data), {
                 itemData: { item: i },
@@ -712,7 +683,7 @@ async function execute(items) {
                 returnData.push({ json: { error: error.message } });
                 continue;
             }
-            if (error instanceof n8n_workflow_1.NodeOperationError) {
+            if (error instanceof n8n_workflow_1.NodeOperationError || error instanceof n8n_workflow_1.NodeApiError) {
                 throw error;
             }
             throw new n8n_workflow_1.NodeApiError(this.getNode(), error);