@unchainedshop/api 4.0.0-rc.2 → 4.0.0-rc.21

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

@@ -2,16 +2,111 @@ import { log } from '@unchainedshop/logger';
 import { UserWeb3AddressNotFoundError, UserWeb3AddressSignatureError } from '../../../errors.js';
 import { Context } from '../../../context.js';
 
+import type { keccak_256 as Keccak256Type } from '@noble/hashes/sha3.js';
+import type { bytesToHex as BytesToHex, hexToBytes as HexToBytes } from '@noble/hashes/utils.js';
+import type { secp256k1 as Secp256k1Type } from '@noble/curves/secp256k1.js';
+
+// Dynamic imports for optional peer dependencies
+let secp256k1: typeof Secp256k1Type;
+let keccak_256: typeof Keccak256Type;
+let bytesToHex: typeof BytesToHex;
+let hexToBytes: typeof HexToBytes;
+
+async function loadNoblePackages() {
+  try {
+    // eslint-disable-next-line
+  // @ts-ignore
+    const curves = await import('@noble/curves/secp256k1.js');
+
+    // eslint-disable-next-line
+  // @ts-ignore
+    const hashes = await import('@noble/hashes/sha3.js');
+
+    // eslint-disable-next-line
+  // @ts-ignore
+    const utils = await import('@noble/hashes/utils.js');
+
+    if (!curves || !hashes || !utils) {
+      throw new Error('Missing required @noble packages for Web3 signature verification');
+    }
+
+    secp256k1 = curves.secp256k1;
+    keccak_256 = hashes.keccak_256;
+    bytesToHex = utils.bytesToHex;
+    hexToBytes = utils.hexToBytes;
+
+    return true;
+  } catch (error) {
+    log('Failed to load @noble packages for Web3 verification', { error: error.message });
+    return false;
+  }
+}
+
+// Inline utility functions to replace @ethereumjs/util
+function fromRPCSig(sig: string): { v: bigint; r: Uint8Array; s: Uint8Array } {
+  const bytes = hexToBytes(sig.startsWith('0x') ? sig.slice(2) : sig);
+  if (bytes.length !== 65) throw new Error('Invalid signature length');
+
+  const r = bytes.slice(0, 32);
+  const s = bytes.slice(32, 64);
+  let v = BigInt(bytes[64]);
+
+  // Handle EIP-155 encoding
+  if (v >= 35n) {
+    v = v - 35n - 2n * 1n; // chainId = 1 for mainnet, adjust if needed
+  } else if (v >= 27n) {
+    v = v - 27n;
+  }
+
+  return { v, r, s };
+}
+
+function hashPersonalMessage(message: Uint8Array): Uint8Array {
+  const prefix = new TextEncoder().encode('\x19Ethereum Signed Message:\n');
+  const lengthBytes = new TextEncoder().encode(message.length.toString());
+  const combined = new Uint8Array(prefix.length + lengthBytes.length + message.length);
+  combined.set(prefix, 0);
+  combined.set(lengthBytes, prefix.length);
+  combined.set(message, prefix.length + lengthBytes.length);
+  return keccak_256(combined);
+}
+
+function ecrecover(msgHash: Uint8Array, v: bigint, r: Uint8Array, s: Uint8Array): Uint8Array {
+  const recovery = Number(v);
+  const signature = new Uint8Array(64);
+  signature.set(r, 0);
+  signature.set(s, 32);
+
+  const publicKey = secp256k1.Signature.fromBytes(signature)
+    .addRecoveryBit(recovery)
+    .recoverPublicKey(msgHash);
+
+  return publicKey.toBytes(false).slice(1); // Remove the 0x04 prefix for uncompressed key
+}
+
+function publicToAddress(publicKey: Uint8Array): Uint8Array {
+  const hash = keccak_256(publicKey);
+  return hash.slice(-20); // Take last 20 bytes
+}
+
 export default async function verifyWeb3Address(
   root: never,
   { address, hash }: { address: string; hash: `0x${string}` },
   { modules, userId, user }: Context,
 ) {
-  log(`mutation verifyWeb3Address ${address} ${user.username}`, {
+  log(`mutation verifyWeb3Address ${address} ${user?.username}`, {
     userId,
   });
 
-  const foundCredentials = user.services?.web3?.find(
+  // Load noble packages dynamically
+  const packagesLoaded = await loadNoblePackages();
+  if (!packagesLoaded) {
+    throw new Error(
+      'Web3 signature verification is not available. Please install the required @noble packages: @noble/curves, @noble/hashes',
+    );
+  }
+
+  const foundCredentials = user?.services?.web3?.find(
     (service) => service.address.toLowerCase() === address.toLowerCase(),
   );
   if (!foundCredentials) {
@@ -20,17 +115,15 @@ export default async function verifyWeb3Address(
 
   // eslint-disable-next-line
   // @ts-ignore
-  const { bufferToHex, fromRpcSig, ecrecover, toBuffer, hashPersonalMessage, publicToAddress } =
-    await import('@ethereumjs/util');
-
-  const message = `0x${Buffer.from(foundCredentials.nonce, 'utf8').toString('hex')}`;
-  const messageHash = hashPersonalMessage(toBuffer(message));
+  const messageHash = hashPersonalMessage(
+    hexToBytes(`0x${Buffer.from(foundCredentials.nonce, 'utf8').toString('hex')}`),
+  );
 
-  const sigParams = fromRpcSig(hash);
+  const sigParams = fromRPCSig(hash);
   const publicKey = ecrecover(messageHash, sigParams.v, sigParams.r, sigParams.s);
 
   const sender = publicToAddress(publicKey);
-  const recoveredAddr = bufferToHex(sender);
+  const recoveredAddr = `0x${bytesToHex(sender)}`;
 
   const isSignatureCorrectForAddress =
     recoveredAddr.toLowerCase() === foundCredentials.address.toLowerCase();
@@ -39,7 +132,7 @@ export default async function verifyWeb3Address(
     throw new UserWeb3AddressSignatureError({ userId, address: foundCredentials.address });
   }
 
-  const web3Services: any[] = user.services.web3.map((service) => {
+  const web3Services: any[] = user?.services?.web3.map((service) => {
     if (foundCredentials.address === service.address) {
       return {
         ...service,

package/src/resolvers/mutations/assortments/removeAssortment.ts

@@ -11,10 +11,8 @@ export default async function removeAssortment(
 
   if (!assortmentId) throw new InvalidIdError({ assortmentId });
 
-  const assortment = await modules.assortments.findAssortment({ assortmentId });
-  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+  const deletedAssortment = await modules.assortments.delete(assortmentId);
+  if (!deletedAssortment) throw new AssortmentNotFoundError({ assortmentId });
 
-  await modules.assortments.delete(assortmentId);
-
-  return assortment;
+  return deletedAssortment;
 }

package/src/resolvers/mutations/delivery/createDeliveryProvider.ts

@@ -6,7 +6,7 @@ import { DeliveryDirector } from '@unchainedshop/core';
 
 export default async function createDeliveryProvider(
   root: never,
-  { deliveryProvider }: { deliveryProvider: DeliveryProvider },
+  { deliveryProvider }: { deliveryProvider: Pick<DeliveryProvider, 'type' | 'adapterKey'> },
   { modules, userId }: Context,
 ) {
   log('mutation createDeliveryProvider', { userId });

package/src/resolvers/mutations/enrollments/createEnrollment.ts

@@ -45,7 +45,7 @@ export default async function createEnrollment(
     payment,
     productId,
     quantity,
-    userId,
+    userId: userId!,
   });
 
   return await services.enrollments.initializeEnrollment(enrollment, {

package/src/resolvers/mutations/enrollments/updateEnrollment.ts

@@ -38,23 +38,26 @@ export default async function updateEnrollment(
   }
 
   if (meta) {
-    enrollment = await modules.enrollments.updateContext(enrollmentId, meta);
+    enrollment = (await modules.enrollments.updateContext(enrollmentId, meta)) as Enrollment;
   }
 
   if (billingAddress) {
-    enrollment = await modules.enrollments.updateBillingAddress(enrollmentId, billingAddress);
+    enrollment = (await modules.enrollments.updateBillingAddress(
+      enrollmentId,
+      billingAddress,
+    )) as Enrollment;
   }
 
   if (contact) {
-    enrollment = await modules.enrollments.updateContact(enrollmentId, contact);
+    enrollment = (await modules.enrollments.updateContact(enrollmentId, contact)) as Enrollment;
   }
 
   if (payment) {
-    enrollment = await modules.enrollments.updatePayment(enrollmentId, payment);
+    enrollment = (await modules.enrollments.updatePayment(enrollmentId, payment)) as Enrollment;
   }
 
   if (delivery) {
-    enrollment = await modules.enrollments.updateDelivery(enrollmentId, delivery);
+    enrollment = (await modules.enrollments.updateDelivery(enrollmentId, delivery)) as Enrollment;
   }
 
   if (plan) {
@@ -64,7 +67,7 @@ export default async function updateEnrollment(
         'TODO: Unchained currently does not support order splitting for enrollments, therefore updates to quantity, product and configuration of a enrollment is forbidden for non initial enrollments',
       );
     }
-    enrollment = await modules.enrollments.updatePlan(enrollmentId, plan);
+    enrollment = (await modules.enrollments.updatePlan(enrollmentId, plan)) as Enrollment;
     enrollment = await services.enrollments.initializeEnrollment(enrollment, { reason: 'updated_plan' });
   }
 

package/src/resolvers/mutations/filters/createFilter.ts

@@ -2,6 +2,7 @@ import { log } from '@unchainedshop/logger';
 import { Filter } from '@unchainedshop/core-filters';
 import { Context } from '../../../context.js';
 import { FilterDirector, FilterInputText } from '@unchainedshop/core';
+import { DuplicateFilterKeyError } from '../../../errors.js';
 
 export default async function createFilter(
   root: never,
@@ -10,13 +11,17 @@ export default async function createFilter(
 ) {
   const { modules, userId } = context;
   log('mutation createFilter', { userId });
+  try {
+    const newFilter = await modules.filters.create(filter);
 
-  const newFilter = await modules.filters.create(filter);
+    await FilterDirector.invalidateProductIdCache(newFilter, context);
 
-  await FilterDirector.invalidateProductIdCache(newFilter, context);
-
-  if (texts) {
-    await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts);
+    if (texts) {
+      await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts);
+    }
+    return newFilter;
+  } catch (e) {
+    if (e?.message?.includes('duplicate')) throw new DuplicateFilterKeyError({ filter });
+    else throw e;
   }
-  return newFilter;
 }

package/src/resolvers/mutations/filters/createFilterOption.ts

@@ -18,7 +18,7 @@ export default async function createFilterOption(
   if (!(await modules.filters.filterExists({ filterId }))) throw new FilterNotFoundError({ filterId });
 
   const filter = await modules.filters.createFilterOption(filterId, { value: option });
-  await FilterDirector.invalidateProductIdCache(filter, context);
+  await FilterDirector.invalidateProductIdCache(filter!, context);
 
   if (texts) {
     await modules.filters.texts.updateTexts({ filterId, filterOptionValue: option }, texts);

package/src/resolvers/mutations/filters/removeFilterOption.ts

@@ -19,7 +19,7 @@ export default async function removeFilterOption(
     filterId,
     filterOptionValue,
   });
-  await FilterDirector.invalidateProductIdCache(filter, context);
+  await FilterDirector.invalidateProductIdCache(filter!, context);
 
   return filter;
 }

package/src/resolvers/mutations/filters/updateFilter.ts

@@ -18,7 +18,7 @@ export default async function updateFilter(
   if (!(await modules.filters.filterExists({ filterId }))) throw new FilterNotFoundError({ filterId });
 
   const updatedFilter = await modules.filters.update(filterId, filter);
-  await FilterDirector.invalidateProductIdCache(updatedFilter, context);
+  await FilterDirector.invalidateProductIdCache(updatedFilter!, context);
 
   return updatedFilter;
 }

package/src/resolvers/mutations/index.ts

@@ -138,7 +138,6 @@ import removePaymentCredentials from './payment/removePaymentCredentials.js';
 import updateOrderDeliveryShipping from './orders/updateOrderDeliveryShipping.js';
 import updateOrderDeliveryPickUp from './orders/updateOrderDeliveryPickUp.js';
 import updateOrderPaymentGeneric from './orders/updateOrderPaymentGeneric.js';
-import updateOrderPaymentCard from './orders/updateOrderPaymentCard.js';
 import updateOrderPaymentInvoice from './orders/updateOrderPaymentInvoice.js';
 import signPaymentProviderForCredentialRegistration from './payment/signPaymentProviderForCredentialRegistration.js';
 import signPaymentProviderForCheckout from './orders/signPaymentProviderForCheckout.js';
@@ -153,6 +152,10 @@ import rejectOrder from './orders/rejectOrder.js';
 import removePushSubscription from './users/removePushSubscription.js';
 import addPushSubscription from './users/addPushSubscription.js';
 import removeUserProductReviews from './users/removeUserProductReviews.js';
+import updateCartDeliveryPickUp from './orders/updateCartDeliveryPickUp.js';
+import updateCartDeliveryShipping from './orders/updateCartDeliveryShipping.js';
+import updateCartPaymentGeneric from './orders/updateCartPaymentGeneric.js';
+import updateCartPaymentInvoice from './orders/updateCartPaymentInvoice.js';
 
 export default {
   logout: acl(actions.logout)(logout),
@@ -244,12 +247,15 @@ export default {
   updateCartItem: acl(actions.updateOrderItem)(updateCartItem),
   removeCartItem: acl(actions.updateOrderItem)(removeCartItem),
   removeCartDiscount: acl(actions.updateOrderDiscount)(removeCartDiscount),
+  updateCartDeliveryPickUp: acl(actions.updateCart)(updateCartDeliveryPickUp),
+  updateCartDeliveryShipping: acl(actions.updateCart)(updateCartDeliveryShipping),
+  updateCartPaymentGeneric: acl(actions.updateCart)(updateCartPaymentGeneric),
+  updateCartPaymentInvoice: acl(actions.updateCart)(updateCartPaymentInvoice),
   setOrderPaymentProvider: acl(actions.updateOrder)(setOrderPaymentProvider),
   setOrderDeliveryProvider: acl(actions.updateOrder)(setOrderDeliveryProvider),
   updateOrderDeliveryShipping: acl(actions.updateOrderDelivery)(updateOrderDeliveryShipping),
   updateOrderDeliveryPickUp: acl(actions.updateOrderDelivery)(updateOrderDeliveryPickUp),
   updateOrderPaymentGeneric: acl(actions.updateOrderPayment)(updateOrderPaymentGeneric),
-  updateOrderPaymentCard: acl(actions.updateOrderPayment)(updateOrderPaymentCard),
   updateOrderPaymentInvoice: acl(actions.updateOrderPayment)(updateOrderPaymentInvoice),
   removeOrder: acl(actions.updateOrder)(removeOrder),
   confirmOrder: acl(actions.markOrderConfirmed)(confirmOrder),

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

@@ -18,7 +18,7 @@ export default async function addCartDiscount(
 
   const order = await services.orders.findOrInitCart({
     orderId,
-    user,
+    user: user!,
     countryCode: context.countryCode,
   });
   if (!order) throw new OrderNotFoundError({ orderId });

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

@@ -31,7 +31,7 @@ export default async function addCartProduct(
 
   const order = await services.orders.findOrInitCart({
     orderId,
-    user,
+    user: user!,
     countryCode: context.countryCode,
   });
   if (!order) throw new OrderNotFoundError({ orderId });

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

@@ -9,6 +9,7 @@ import {
   OrderWrongStatusError,
   ProductNotFoundError,
   OrderNotFoundError,
+  QuotationItemConfigurationError,
 } from '../../../errors.js';
 import { QuotationDirector } from '@unchainedshop/core';
 
@@ -45,7 +46,7 @@ export default async function addCartQuotation(
 
   const order = await services.orders.findOrInitCart({
     orderId,
-    user,
+    user: user!,
     countryCode: context.countryCode,
   });
   if (!order) throw new OrderNotFoundError({ orderId });
@@ -64,8 +65,10 @@ export default async function addCartQuotation(
     configuration,
   });
 
+  if (!quotationConfiguration) throw new QuotationItemConfigurationError({ configuration });
+
   const updatedOrderPosition = await modules.orders.positions.addProductItem({
-    quantity: quotationConfiguration.quantity,
+    quantity: quotationConfiguration.quantity || 1,
     configuration: quotationConfiguration.configuration,
     quotationId,
     productId: quotation.productId,

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

@@ -43,48 +43,41 @@ export default async function addMultipleCartProducts(
 
   const order = await services.orders.findOrInitCart({
     orderId,
-    user,
+    user: user!,
     countryCode: context.countryCode,
   });
   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)
-  await itemsWithProducts.reduce(
-    async (positionsPromise, { originalProduct, quantity, configuration }) => {
-      const positions = await positionsPromise;
-      if (quantity < 1)
-        throw new OrderQuantityTooLowError({
-          quantity,
-          productId: originalProduct._id,
-        });
-
-      const product = await modules.products.resolveOrderableProduct(originalProduct, {
-        configuration,
+  for (const { originalProduct, quantity, configuration } of itemsWithProducts) {
+    if (quantity < 1)
+      throw new OrderQuantityTooLowError({
+        quantity,
+        productId: originalProduct._id,
       });
 
-      await ordersSettings.validateOrderPosition(
-        {
-          order,
-          product,
-          configuration,
-          quantityDiff: quantity,
-        },
-        context,
-      );
+    const product = await modules.products.resolveOrderableProduct(originalProduct, {
+      configuration,
+    });
 
-      const position = await modules.orders.positions.addProductItem({
-        quantity,
+    await ordersSettings.validateOrderPosition(
+      {
+        order,
+        product,
         configuration,
-        originalProductId: originalProduct._id,
-        productId: product._id,
-        orderId: order._id,
-      });
-      positions.push(position);
-      return positions;
-    },
-    Promise.resolve([]),
-  );
+        quantityDiff: quantity,
+      },
+      context,
+    );
+
+    await modules.orders.positions.addProductItem({
+      quantity,
+      configuration,
+      originalProductId: originalProduct._id,
+      productId: product._id,
+      orderId: order._id,
+    });
+  }
 
   return services.orders.updateCalculation(order._id);
 }

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

@@ -21,7 +21,7 @@ export default async function checkoutCart(
   // Do not check for order status here! The checkout method will act accordingly
   const order = await services.orders.findOrInitCart({
     orderId: forceOrderId,
-    user,
+    user: user!,
     countryCode: context.countryCode,
   });
   if (!order) throw new OrderNotFoundError({ orderId: forceOrderId });
@@ -30,7 +30,7 @@ export default async function checkoutCart(
     const checkedOutOrder = await services.orders.checkoutOrder(order._id, transactionContext);
     return checkedOutOrder;
   } catch (error) {
-    logger.error(error.message, { userId, orderId: order._id });
+    logger.error(error, { userId, orderId: order._id });
     throw new OrderCheckoutError({
       userId,
       orderId: order._id,

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

@@ -14,7 +14,7 @@ export default async function createCart(
   if (order) throw new OrderNumberAlreadyExistsError({ orderNumber });
 
   return services.orders.nextUserCart({
-    user,
+    user: user!,
     orderNumber,
     countryCode: context.countryCode,
     forceCartCreation: true,

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

@@ -6,6 +6,7 @@ import {
   OrderWrongDeliveryStatusError,
   OrderWrongStatusError,
   InvalidIdError,
+  OrderDeliveryNotFoundError,
 } from '../../../errors.js';
 
 export default async function deliverOrder(
@@ -25,9 +26,13 @@ export default async function deliverOrder(
     throw new OrderWrongStatusError({ status: order.status });
   }
 
-  const orderDelivery = await modules.orders.deliveries.findDelivery({
-    orderDeliveryId: order.deliveryId,
-  });
+  const orderDelivery =
+    order.deliveryId &&
+    (await modules.orders.deliveries.findDelivery({
+      orderDeliveryId: order.deliveryId,
+    }));
+
+  if (!orderDelivery) throw new OrderDeliveryNotFoundError({ orderDeliveryId: order.deliveryId });
 
   if (
     modules.orders.deliveries.normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN &&

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

@@ -13,7 +13,7 @@ export default async function emptyCart(
 
   const order = await services.orders.findOrInitCart({
     orderId,
-    user,
+    user: user!,
     countryCode: context.countryCode,
   });
   if (!order) throw new OrderNotFoundError({ orderId });

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

@@ -6,6 +6,7 @@ import {
   OrderWrongPaymentStatusError,
   OrderWrongStatusError,
   InvalidIdError,
+  OrderPaymentNotFoundError,
 } from '../../../errors.js';
 
 export default async function payOrder(root: never, { orderId }: { orderId: string }, context: Context) {
@@ -22,9 +23,13 @@ export default async function payOrder(root: never, { orderId }: { orderId: stri
     throw new OrderWrongStatusError({ status: order.status });
   }
 
-  const payment = await modules.orders.payments.findOrderPayment({
-    orderPaymentId: order.paymentId,
-  });
+  const payment =
+    order.paymentId &&
+    (await modules.orders.payments.findOrderPayment({
+      orderPaymentId: order.paymentId,
+    }));
+
+  if (!payment) throw new OrderPaymentNotFoundError({ orderPaymentId: order.paymentId });
 
   if (modules.orders.payments.normalizedStatus(payment) !== OrderPaymentStatus.OPEN) {
     throw new OrderWrongPaymentStatusError({

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

@@ -1,7 +1,12 @@
 import { log } from '@unchainedshop/logger';
 import { Context } from '../../../context.js';
 
-import { OrderDiscountNotFoundError, OrderWrongStatusError, InvalidIdError } from '../../../errors.js';
+import {
+  OrderDiscountNotFoundError,
+  OrderWrongStatusError,
+  InvalidIdError,
+  OrderNotFoundError,
+} from '../../../errors.js';
 import { OrderDiscountTrigger } from '@unchainedshop/core-orders';
 import { OrderDiscountDirector } from '@unchainedshop/core';
 
@@ -24,8 +29,11 @@ export default async function removeCartDiscount(
   const order = await modules.orders.findOrder({
     orderId: orderDiscount.orderId,
   });
+
+  if (!order) throw new OrderNotFoundError({ orderId: orderDiscount.orderId });
+
   if (!modules.orders.isCart(order)) {
-    throw new OrderWrongStatusError({ status: order.status });
+    throw new OrderWrongStatusError({ status: order!.status });
   }
 
   if (orderDiscount.trigger === OrderDiscountTrigger.USER) {

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

@@ -1,6 +1,11 @@
 import { log } from '@unchainedshop/logger';
 import { Context } from '../../../context.js';
-import { OrderItemNotFoundError, OrderWrongStatusError, InvalidIdError } from '../../../errors.js';
+import {
+  OrderItemNotFoundError,
+  OrderWrongStatusError,
+  InvalidIdError,
+  OrderNotFoundError,
+} from '../../../errors.js';
 
 export default async function removeCartItem(
   root: never,
@@ -20,6 +25,8 @@ export default async function removeCartItem(
 
   const order = await modules.orders.findOrder({ orderId: orderItem.orderId });
 
+  if (!order) throw new OrderNotFoundError({ orderId: orderItem.orderId });
+
   if (!modules.orders.isCart(order)) {
     throw new OrderWrongStatusError({ status: order.status });
   }

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

@@ -7,6 +7,7 @@ import {
   OrderPaymentNotFoundError,
   OrderPaymentTypeError,
   OrderWrongPaymentStatusError,
+  PaymentProviderNotFoundError,
   UserNoCartError,
 } from '../../../errors.js';
 import { PaymentDirector } from '@unchainedshop/core';
@@ -33,18 +34,23 @@ export default async function signPaymentProviderForCheckout(
   } else {
     const order = await modules.orders.cart({
       countryCode: context.countryCode,
-      userId,
+      userId: userId!,
     });
     if (!order) throw new UserNoCartError({ userId });
-    orderPayment = await modules.orders.payments.findOrderPayment({
-      orderPaymentId: order.paymentId,
-    });
+    orderPayment =
+      order.paymentId &&
+      (await modules.orders.payments.findOrderPayment({
+        orderPaymentId: order.paymentId,
+      }));
     if (!orderPayment) throw new OrderPaymentNotFoundError({ orderPaymentId });
   }
 
   const provider = await modules.payment.paymentProviders.findProvider({
     paymentProviderId: orderPayment.paymentProviderId,
   });
+
+  if (!provider) throw new PaymentProviderNotFoundError({ id: orderPayment.paymentProviderId });
+
   const providerType = provider?.type;
 
   if (providerType !== PaymentProviderType.GENERIC)

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

@@ -19,32 +19,32 @@ export default async function updateCart(root: never, params: UpdateCartParams,
 
   log('mutation updateCart', { userId });
 
-  let order = await services.orders.findOrInitCart({
+  const order = await services.orders.findOrInitCart({
     orderId,
-    user,
+    user: user!,
     countryCode: context.countryCode,
   });
   if (!order) throw new OrderNotFoundError({ orderId });
   if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
 
   if (meta) {
-    order = await modules.orders.updateContext(order._id, meta);
+    await modules.orders.updateContext(order._id, meta);
   }
 
   if (billingAddress) {
-    order = await modules.orders.updateBillingAddress(order._id, billingAddress);
+    await modules.orders.updateBillingAddress(order._id, billingAddress);
   }
 
   if (contact) {
-    order = await modules.orders.updateContact(order._id, contact);
+    await modules.orders.updateContact(order._id, contact);
   }
 
   if (paymentProviderId) {
-    order = await modules.orders.setPaymentProvider(order._id, paymentProviderId);
+    await modules.orders.setPaymentProvider(order._id, paymentProviderId);
   }
 
   if (deliveryProviderId) {
-    order = await modules.orders.setDeliveryProvider(order._id, deliveryProviderId);
+    await modules.orders.setDeliveryProvider(order._id, deliveryProviderId);
   }
 
   // Recalculate, then return