@unchainedshop/api 3.0.0-rc1 → 3.0.0-rc10

package/src/loaders/index.ts

@@ -12,6 +12,7 @@ import {
   AssortmentMediaText,
 } from '@unchainedshop/core-assortments';
 import { File } from '@unchainedshop/core-files';
+
 export interface UnchainedLoaders {
   loaders: {
     productLoader: InstanceType<typeof DataLoader<{ productId: string }, Product>>;
@@ -54,28 +55,16 @@ export interface UnchainedLoaders {
   };
 }
 
-function getLocaleStrings(localeObj: Intl.Locale) {
-  return [localeObj.baseName, localeObj.language, systemLocale.baseName, systemLocale.language];
-}
-
-function findMatchingText(texts, localeStrings) {
-  return localeStrings.reduce((acc, localeString) => {
-    if (acc) return acc;
-    return texts.find((p) => p.locale.toLowerCase() === localeString.toLowerCase());
-  }, null);
-}
-
-function getFilteredQueries({ queries, texts, filterFn }) {
-  return queries.map(({ locale, ...queryParams }) => {
-    const localeObj = new Intl.Locale(locale);
-
-    const filteredTexts = texts.filter(filterFn(queryParams));
-    if (!filteredTexts.length) return null;
-
-    const localeStrings = getLocaleStrings(localeObj);
-    const filterText = findMatchingText(filteredTexts, localeStrings);
-    return filterText || filteredTexts[0];
-  });
+function getLocaleStrings(locale: string) {
+  const localeObj = new Intl.Locale(locale);
+  return [
+    ...new Set([
+      localeObj.baseName.toLowerCase(),
+      localeObj.language.toLowerCase(),
+      systemLocale.baseName.toLowerCase(),
+      systemLocale.language.toLowerCase(),
+    ]),
+  ];
 }
 
 const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['loaders']> => {
@@ -89,12 +78,11 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         includeLeaves: true,
       });
 
-      return queries.map(({ assortmentId }) => {
-        return assortments.find((assortment) => {
-          if (assortment._id !== assortmentId) return false;
-          return true;
-        });
-      });
+      const assortmentMap = {};
+      for (const assortment of assortments) {
+        assortmentMap[assortment._id] = assortment;
+      }
+      return queries.map((q) => assortmentMap[q.assortmentId]);
     }),
 
     assortmentTextLoader: new DataLoader(async (queries) => {
@@ -109,12 +97,18 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         },
       );
 
-      const filterFn =
-        ({ assortmentId }) =>
-        (text) =>
-          text.assortmentId === assortmentId;
-
-      return getFilteredQueries({ queries, texts, filterFn });
+      const queryLocales = [...new Set(queries.map((q) => q.locale.toLowerCase()))];
+      const textsMap = {};
+      const localeMap = Object.fromEntries(
+        queryLocales.flatMap((queryLocale) => {
+          return getLocaleStrings(queryLocale).map((locale) => [locale, queryLocale]);
+        }),
+      );
+      for (const text of texts) {
+        const locale = localeMap[text.locale.toLowerCase()];
+        textsMap[`${locale}:${text.assortmentId}`] = text;
+      }
+      return queries.map((q) => textsMap[`${q.locale.toLowerCase()}:${q.assortmentId}`]);
     }),
 
     assortmentMediaTextLoader: new DataLoader(async (queries) => {
@@ -129,12 +123,18 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         },
       );
 
-      const filterFn =
-        ({ assortmentMediaId }) =>
-        (text) =>
-          text.assortmentMediaId === assortmentMediaId;
-
-      return getFilteredQueries({ queries, texts, filterFn });
+      const queryLocales = [...new Set(queries.map((q) => q.locale.toLowerCase()))];
+      const textsMap = {};
+      const localeMap = Object.fromEntries(
+        queryLocales.flatMap((queryLocale) => {
+          return getLocaleStrings(queryLocale).map((locale) => [locale, queryLocale]);
+        }),
+      );
+      for (const text of texts) {
+        const locale = localeMap[text.locale.toLowerCase()];
+        textsMap[`${locale}:${text.assortmentMediaId}`] = text;
+      }
+      return queries.map((q) => textsMap[`${q.locale.toLowerCase()}:${q.assortmentMediaId}`]);
     }),
 
     assortmentMediasLoader: new DataLoader(async (queries) => {
@@ -143,11 +143,11 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         assortmentId: { $in: assortmentIds },
       });
 
-      return queries.map((q) => {
-        return assortmentMediaItems.filter((i) => {
-          return i.assortmentId === q.assortmentId;
-        });
-      });
+      const assortmentMediaMap = {};
+      for (const assortmentMedia of assortmentMediaItems) {
+        assortmentMediaMap[assortmentMedia._id] = assortmentMedia;
+      }
+      return queries.map((q) => assortmentMediaMap[q.assortmentId]);
     }),
 
     assortmentLinkLoader: new DataLoader(async (queries) => {
@@ -157,10 +157,11 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         parentAssortmentIds,
       });
 
-      return queries.map(({ parentAssortmentId, childAssortmentId }) => {
+      // TODO: Optimize
+      return queries.map((q) => {
         return links.find((link) => {
-          if (link.parentAssortmentId !== parentAssortmentId) return false;
-          if (childAssortmentId && link.childAssortmentId !== childAssortmentId) return false;
+          if (link.parentAssortmentId !== q.parentAssortmentId) return false;
+          if (q.childAssortmentId && link.childAssortmentId !== q.childAssortmentId) return false;
           return true;
         });
       });
@@ -183,16 +184,17 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
           assortmentIds,
         }));
 
-      return queries.map(({ parentAssortmentId, assortmentId }) => {
-        if (parentAssortmentId) {
+      // TODO: Optimize
+      return queries.map((q) => {
+        if (q.parentAssortmentId) {
           return linksByParentAssortmentId.filter(
-            (link) => link.parentAssortmentId === parentAssortmentId,
+            (link) => link.parentAssortmentId === q.parentAssortmentId,
           );
         }
-        if (assortmentId) {
+        if (q.assortmentId) {
           return linksByAssortmentId.filter(
             (link) =>
-              link.parentAssortmentId === assortmentId || link.childAssortmentId === assortmentId,
+              link.parentAssortmentId === q.assortmentId || link.childAssortmentId === q.assortmentId,
           );
         }
         return [];
@@ -206,10 +208,11 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         assortmentIds,
       });
 
-      return queries.map(({ assortmentId, productId }) => {
+      // TODO: Optimize
+      return queries.map((q) => {
         return assortmentProducts.find((assortmentProduct) => {
-          if (assortmentProduct.assortmentId !== assortmentId) return false;
-          if (assortmentProduct.productId !== productId) return false;
+          if (assortmentProduct.assortmentId !== q.assortmentId) return false;
+          if (assortmentProduct.productId !== q.productId) return false;
           return true;
         });
       });
@@ -223,12 +226,12 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         includeInactive: true,
       });
 
-      return queries.map(({ filterId }) => {
-        return filters.find((product) => {
-          if (product._id !== filterId) return false;
-          return true;
-        });
-      });
+      const filterMap = {};
+      for (const filter of filters) {
+        filterMap[filter._id] = filter;
+      }
+
+      return queries.map((q) => filterMap[q.filterId]);
     }),
 
     filterTextLoader: new DataLoader(async (queries) => {
@@ -243,11 +246,20 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         },
       );
 
-      const filterFn =
-        ({ filterId, filterOptionValue }) =>
-        (text) =>
-          text.filterId === filterId && text.filterOptionValue === filterOptionValue;
-      return getFilteredQueries({ queries, texts, filterFn });
+      const queryLocales = [...new Set(queries.map((q) => q.locale.toLowerCase()))];
+      const textsMap = {};
+      const localeMap = Object.fromEntries(
+        queryLocales.flatMap((queryLocale) => {
+          return getLocaleStrings(queryLocale).map((locale) => [locale, queryLocale]);
+        }),
+      );
+      for (const text of texts) {
+        const locale = localeMap[text.locale.toLowerCase()];
+        textsMap[`${locale}:${text.filterId}:${text.filterOptionValue}`] = text;
+      }
+      return queries.map(
+        (q) => textsMap[`${q.locale.toLowerCase()}:${q.filterId}:${q.filterOptionValue}`],
+      );
     }),
 
     productLoader: new DataLoader(async (queries) => {
@@ -260,12 +272,12 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         },
       });
 
-      return queries.map(({ productId }) => {
-        return products.find((product) => {
-          if (product._id !== productId) return false;
-          return true;
-        });
-      });
+      const productMap = {};
+      for (const product of products) {
+        productMap[product._id] = product;
+      }
+
+      return queries.map((q) => productMap[q.productId]);
     }),
 
     productLoaderBySKU: new DataLoader(async (queries) => {
@@ -278,17 +290,16 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         },
       });
 
-      return queries.map(({ sku }) => {
-        return products.find((product) => {
-          if (product.warehousing?.sku !== sku) return false;
-          return true;
-        });
-      });
+      const productMap = {};
+      for (const product of products) {
+        productMap[product.warehousing!.sku!] = product;
+      }
+
+      return queries.map((q) => productMap[q.sku]);
     }),
 
     productTextLoader: new DataLoader(async (queries) => {
-      const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
-
+      const productIds = [...new Set(queries.map((q) => q.productId))].filter(Boolean);
       const texts = await unchainedAPI.modules.products.texts.findTexts(
         { productId: { $in: productIds } },
         {
@@ -297,13 +308,18 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
           },
         },
       );
-
-      const filterFn =
-        ({ productId }) =>
-        (text) =>
-          text.productId === productId;
-
-      return getFilteredQueries({ queries, texts, filterFn });
+      const queryLocales = [...new Set(queries.map((q) => q.locale.toLowerCase()))];
+      const textsMap = {};
+      const localeMap = Object.fromEntries(
+        queryLocales.flatMap((queryLocale) => {
+          return getLocaleStrings(queryLocale).map((locale) => [locale, queryLocale]);
+        }),
+      );
+      for (const text of texts) {
+        const locale = localeMap[text.locale.toLowerCase()];
+        textsMap[`${locale}:${text.productId}`] = text;
+      }
+      return queries.map((q) => textsMap[`${q.locale.toLowerCase()}:${q.productId}`]);
     }),
 
     productMediaTextLoader: new DataLoader(async (queries) => {
@@ -318,12 +334,18 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         },
       );
 
-      const filterFn =
-        ({ productMediaId }) =>
-        (text) =>
-          text.productMediaId === productMediaId;
-
-      return getFilteredQueries({ queries, texts, filterFn });
+      const queryLocales = [...new Set(queries.map((q) => q.locale.toLowerCase()))];
+      const textsMap = {};
+      const localeMap = Object.fromEntries(
+        queryLocales.flatMap((queryLocale) => {
+          return getLocaleStrings(queryLocale).map((locale) => [locale, queryLocale]);
+        }),
+      );
+      for (const text of texts) {
+        const locale = localeMap[text.locale.toLowerCase()];
+        textsMap[`${locale}:${text.productMediaId}`] = text;
+      }
+      return queries.map((q) => textsMap[`${q.locale.toLowerCase()}:${q.productMediaId}`]);
     }),
 
     productMediasLoader: new DataLoader(async (queries) => {
@@ -331,11 +353,16 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
       const productMediaItems = await unchainedAPI.modules.products.media.findProductMedias({
         productId: { $in: productIds },
       });
-      return queries.map((q) => {
-        return productMediaItems.filter((i) => {
-          return i.productId === q.productId;
-        });
-      });
+
+      const productMediaMap = {};
+      for (const productMedia of productMediaItems) {
+        if (!productMediaMap[productMedia.productId]) {
+          productMediaMap[productMedia.productId] = [productMedia];
+        } else {
+          productMediaMap[productMedia.productId].push(productMedia);
+        }
+      }
+      return queries.map((q) => productMediaMap[q.productId] || []);
     }),
 
     fileLoader: new DataLoader(async (queries) => {
@@ -345,12 +372,12 @@ const loaders = async (unchainedAPI: UnchainedCore): Promise<UnchainedLoaders['l
         _id: { $in: fileIds },
       });
 
-      return queries.map(({ fileId }) => {
-        return files.find((file) => {
-          if (file._id !== fileId) return false;
-          return true;
-        });
-      });
+      const fileMap = {};
+      for (const file of files) {
+        fileMap[file._id] = file;
+      }
+
+      return queries.map((q) => fileMap[q.fileId]);
     }),
   };
 };

package/src/resolvers/mutations/accounts/addWebAuthnCredentials.ts

@@ -1,5 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { Context } from '../../../context.js';
+import { WebAuthnDisabledError } from '../../../errors.js';
 
 export default async function addWebAuthnCredentials(
   root: never,
@@ -15,6 +16,8 @@ export default async function addWebAuthnCredentials(
     credentials,
   );
 
+  if (!webAuthnService) throw new WebAuthnDisabledError();
+
   return modules.users.updateUser(
     { _id: userId },
     {

package/src/resolvers/mutations/accounts/createWebAuthnCredentialRequestOptions.ts

@@ -16,11 +16,11 @@ export default async function createWebAuthnCredentialRequestOptions(
     extensionOptions,
   );
 
-  if (username) {
+  if (username && options) {
     const user = await modules.users.findUserByUsername(username);
     options.allowCredentials = user?.services?.webAuthn?.map(({ id, type }) => ({
       id,
-      type: type || options.type || 'public-key',
+      type: type || 'public-key',
     }));
   }
 

package/src/resolvers/mutations/accounts/loginWithWebAuthn.ts

@@ -1,5 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { Context } from '../../../context.js';
+import { WebAuthnDisabledError } from '../../../errors.js';
 
 export default async function loginWithWebAuthn(
   root: never,
@@ -16,12 +17,14 @@ export default async function loginWithWebAuthn(
   let user = await context.modules.users.findUserByUsername(username);
   if (!user) throw new Error('User not found');
 
-  await context.modules.users.webAuthn.verifyCredentialRequest(
+  const verification = await context.modules.users.webAuthn.verifyCredentialRequest(
     user.services?.webAuthn,
     user.username,
     params.webAuthnPublicKeyCredentials,
   );
 
+  if (!verification) throw new WebAuthnDisabledError();
+
   user = await context.modules.users.updateHeartbeat(user._id, {
     remoteAddress: context.remoteAddress,
     remotePort: context.remotePort,

package/src/resolvers/mutations/accounts/resetPassword.ts

@@ -14,55 +14,22 @@ export default async function resetPassword(
   if (!params.newPassword) {
     throw new Error('Password is required');
   }
-  let user = await modules.users.findUserByResetToken(params.token);
-
-  if (!user) throw new InvalidResetTokenError({});
 
   try {
-    await modules.users.setPassword(user._id, params.newPassword);
-
-    // TODO: Verify E-Mail after reset!
-    // if (resetTicket.address) {
-    //   // Try verifying the E-Mail along the way
-    //   try {
-    //     const updatedUser = await modules.users.updateUser(
-    //       {
-    //         _id: userWithNewPassword.id,
-    //         emails: {
-    //           $elemMatch: {
-    //             address: emailRegexOperator(resetTicket.address),
-    //             verified: false,
-    //           },
-    //         },
-    //       },
-    //       {
-    //         $set: {
-    //           'emails.$[email].verified': true,
-    //         },
-    //       },
-    //       {
-    //         arrayFilters: [{ 'email.address': resetTicket.address }],
-    //       },
-    //     );
-    //     if (updatedUser) {
-    //       await modules.accounts.emit('VerifyEmailSuccess', updatedUser);
-    //     }
-    //   } catch (e) {
-    //     /* */
-    //   }
-    // }
+    let user = await modules.users.resetPassword(params.token, params.newPassword);
+    if (!user) throw new InvalidResetTokenError({});
+
+    user = await context.modules.users.updateHeartbeat(user._id, {
+      remoteAddress: context.remoteAddress,
+      remotePort: context.remotePort,
+      userAgent: context.userAgent,
+      locale: context.localeContext.baseName,
+      countryCode: context.countryContext,
+    });
+
+    return context.login(user);
   } catch (e) {
-    if (e.cause === 'PASSWORD_INVALID') throw new PasswordInvalidError({ userId: user._id });
+    if (e.cause === 'PASSWORD_INVALID') throw new PasswordInvalidError({});
     else throw e;
   }
-
-  user = await context.modules.users.updateHeartbeat(user._id, {
-    remoteAddress: context.remoteAddress,
-    remotePort: context.remotePort,
-    userAgent: context.userAgent,
-    locale: context.localeContext.baseName,
-    countryCode: context.countryContext,
-  });
-
-  return context.login(user);
 }

package/src/resolvers/mutations/accounts/verifyWeb3Address.ts

@@ -1,5 +1,4 @@
 import { log } from '@unchainedshop/logger';
-import { recoverPersonalSignature } from '@metamask/eth-sig-util';
 import { UserWeb3AddressNotFoundError, UserWeb3AddressSignatureError } from '../../../errors.js';
 import { Context } from '../../../context.js';
 
@@ -21,6 +20,10 @@ export default async function verifyWeb3Address(
 
   const msg = `0x${Buffer.from(foundCredentials.nonce, 'utf8').toString('hex')}`;
 
+  // eslint-disable-next-line
+  // @ts-ignore
+  const { recoverPersonalSignature } = await import('@metamask/eth-sig-util');
+
   const recoveredAddr = recoverPersonalSignature({
     data: msg,
     signature: hash,

package/src/resolvers/mutations/countries/updateCountry.ts

@@ -5,7 +5,7 @@ import { Context } from '../../../context.js';
 
 export default async function updateCountry(
   root: never,
-  { country, countryId }: { country: Country & { defaultCurrencyId: string }; countryId: string },
+  { country, countryId }: { country: Country; countryId: string },
   { userId, modules }: Context,
 ) {
   log(`mutation updateCountry ${countryId}`, { userId });
@@ -15,12 +15,7 @@ export default async function updateCountry(
   if (!(await modules.countries.countryExists({ countryId })))
     throw new CountryNotFoundError({ countryId });
 
-  const currencyObject = await modules.currencies.findCurrency({
-    currencyId: country.defaultCurrencyId,
-  });
-  const defaultCurrencyCode = country?.defaultCurrencyCode || currencyObject?.isoCode;
-
-  await modules.countries.update(countryId, { ...country, defaultCurrencyCode });
+  await modules.countries.update(countryId, country);
 
   return modules.countries.findCountry({ countryId });
 }

package/src/resolvers/mutations/orders/addCartDiscount.ts

@@ -1,10 +1,10 @@
 import { Context } from '../../../context.js';
 import { log } from '@unchainedshop/logger';
-import { getOrderCart } from '../utils/getOrderCart.js';
 import {
   OrderWrongStatusError,
   OrderDiscountCodeAlreadyPresentError,
   OrderDiscountCodeNotValidError,
+  OrderNotFoundError,
 } from '../../../errors.js';
 
 export default async function addCartDiscount(
@@ -16,7 +16,12 @@ export default async function addCartDiscount(
 
   log(`mutation addCartDiscount ${code} ${orderId}`, { userId, orderId });
 
-  const order = await getOrderCart({ orderId, user }, context);
+  const order = await services.orders.findOrInitCart({
+    orderId,
+    user,
+    countryCode: context.countryContext,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
 
   if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
 

package/src/resolvers/mutations/orders/addCartProduct.ts

@@ -5,8 +5,8 @@ import {
   OrderQuantityTooLowError,
   InvalidIdError,
   OrderWrongStatusError,
+  OrderNotFoundError,
 } from '../../../errors.js';
-import { getOrderCart } from '../utils/getOrderCart.js';
 import { ordersSettings } from '@unchainedshop/core-orders';
 
 export default async function addCartProduct(
@@ -29,7 +29,13 @@ export default async function addCartProduct(
   const originalProduct = await modules.products.findProduct({ productId: originalProductId });
   if (!originalProduct) throw new ProductNotFoundError({ productId: originalProductId });
 
-  const order = await getOrderCart({ orderId, user }, context);
+  const order = await services.orders.findOrInitCart({
+    orderId,
+    user,
+    countryCode: context.countryContext,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
+
   if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
 
   const product = await modules.products.resolveOrderableProduct(originalProduct, { configuration });

package/src/resolvers/mutations/orders/addCartQuotation.ts

@@ -8,8 +8,8 @@ import {
   InvalidIdError,
   OrderWrongStatusError,
   ProductNotFoundError,
+  OrderNotFoundError,
 } from '../../../errors.js';
-import { getOrderCart } from '../utils/getOrderCart.js';
 import { QuotationDirector } from '@unchainedshop/core';
 
 export default async function addCartQuotation(
@@ -43,7 +43,12 @@ export default async function addCartQuotation(
     throw new QuotationWrongStatusError({ status: quotation.status });
   }
 
-  const order = await getOrderCart({ orderId, user }, context);
+  const order = await services.orders.findOrInitCart({
+    orderId,
+    user,
+    countryCode: context.countryContext,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
   if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
 
   if (

package/src/resolvers/mutations/orders/addMultipleCartProducts.ts

@@ -4,8 +4,8 @@ import {
   ProductNotFoundError,
   OrderQuantityTooLowError,
   OrderWrongStatusError,
+  OrderNotFoundError,
 } from '../../../errors.js';
-import { getOrderCart } from '../utils/getOrderCart.js';
 import { ordersSettings } from '@unchainedshop/core-orders';
 
 export default async function addMultipleCartProducts(
@@ -41,7 +41,12 @@ export default async function addMultipleCartProducts(
     }),
   );
 
-  const order = await getOrderCart({ orderId, user }, context);
+  const order = await services.orders.findOrInitCart({
+    orderId,
+    user,
+    countryCode: context.countryContext,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
   if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
 
   // Reduce is used to wait for each product to be added before processing the next (sequential processing)

package/src/resolvers/mutations/orders/checkoutCart.ts

@@ -1,6 +1,5 @@
 import { Context } from '../../../context.js';
-import { OrderCheckoutError } from '../../../errors.js';
-import { getOrderCart } from '../utils/getOrderCart.js';
+import { OrderCheckoutError, OrderNotFoundError } from '../../../errors.js';
 import { createLogger, log } from '@unchainedshop/logger';
 
 const logger = createLogger('unchained:api');
@@ -20,11 +19,16 @@ export default async function checkoutCart(
   log('mutation checkoutCart', { orderId: forceOrderId, userId });
 
   // Do not check for order status here! The checkout method will act accordingly
-  let order = await getOrderCart({ orderId: forceOrderId, user }, context);
+  const order = await services.orders.findOrInitCart({
+    orderId: forceOrderId,
+    user,
+    countryCode: context.countryContext,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId: forceOrderId });
 
   try {
-    order = await services.orders.checkoutOrder(order._id, transactionContext);
-    return order;
+    const checkedOutOrder = await services.orders.checkoutOrder(order._id, transactionContext);
+    return checkedOutOrder;
   } catch (error) {
     logger.error(error.message, { userId, orderId: order._id });
     throw new OrderCheckoutError({