@unchainedshop/api 4.0.0-rc.14 → 4.0.0-rc.16

package/src/fastify/tempUploadHandler.ts

@@ -37,15 +37,12 @@ const tempUploadHandler: RouteHandlerMethod = async (
     const fileUploadAdapter = getFileAdapter();
     const rawUrl = await fileUploadAdapter.createDownloadURL(file);
     const url = context.modules.files.normalizeUrl(rawUrl, {});
-    const body = JSON.stringify({ fileId: file._id, url, expires: expires.toISOString() });
     res.status(200);
-    res.header('Content-Length', Buffer.byteLength(body));
-    res.header('Content-Type', 'application/json');
-    return res.send(body);
+    return res.send({ fileId: file._id, url, expires: expires.toISOString() });
   } catch (e) {
-    logger.error(e.message);
+    logger.error(e);
     res.status(503);
-    return res.send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    return res.send({ name: e.name, code: e.code, message: e.message });
   }
 };
 

package/src/mcp/tools/product/handlers/addProductMedia.ts

@@ -1,6 +1,6 @@
 import { Context } from '../../../../context.js';
 import { ProductNotFoundError } from '../../../../errors.js';
-import normalizeMediaUrl from '../../../utils/normalizeMediaUrl.js';
+import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
 import { Params } from '../schemas.js';
 
 export default async function addProductMedia(context: Context, params: Params<'ADD_MEDIA'>) {
@@ -39,8 +39,7 @@ export default async function addProductMedia(context: Context, params: Params<'
   if (file.expires && new Date(file.expires).getTime() < Date.now()) {
     throw new Error(`File upload expired: ${fileId}`);
   }
-
-  const linked = await services.files.linkFile({ fileId, size, type });
-  const media = await normalizeMediaUrl([{ ...linked, mediaId: linked._id }], context);
-  return { media };
+  await services.files.linkFile({ fileId, size, type });
+  const updatedProduct = await getNormalizedProductDetails(productId, context);
+  return { product: updatedProduct };
 }

package/src/mcp/tools/product/handlers/updateProduct.ts

@@ -1,6 +1,8 @@
 import { Context } from '../../../../context.js';
 import { ProductTypes } from '@unchainedshop/core-products';
 import {
+  CountryNotFoundError,
+  CurrencyNotFoundError,
   ProductNotFoundError,
   ProductWrongStatusError,
   ProductWrongTypeError,
@@ -9,7 +11,7 @@ import { getNormalizedProductDetails } from '../../../utils/getNormalizedProduct
 import { Params } from '../schemas.js';
 
 export default async function updateProduct(context: Context, params: Params<'UPDATE'>) {
-  const { modules } = context;
+  const { modules, loaders } = context;
   const { productId, product } = params;
 
   const existingProduct = await modules.products.findProduct({ productId });
@@ -64,6 +66,15 @@ export default async function updateProduct(context: Context, params: Params<'UP
   }
 
   if (product.commerce !== undefined) {
+    await Promise.all(
+      product.commerce.pricing.map(async ({ countryCode, currencyCode }) => {
+        const currency = await loaders.currencyLoader.load({ isoCode: currencyCode });
+        if (!currency) throw new CurrencyNotFoundError({ currencyCode });
+
+        const country = await loaders.countryLoader.load({ isoCode: countryCode });
+        if (!country) throw new CountryNotFoundError({ countryCode });
+      }),
+    );
     updateData.commerce = product.commerce;
   }
 

package/src/mcp/tools/product/schemas.ts

@@ -111,15 +111,19 @@ export const ProductSchema = z.object({
               .min(2)
               .max(2)
               .describe(
-                'ISO country code (e.g., US, DE) make sure the country exists in the system before using it. if it does not exists prompt the user to add the country. NEVER add it automatically',
+                'ISO country code (e.g., US, DE) make sure the country/countryCode exists in the system before using it. if it does not exists prompt the user to add the country. NEVER add it automatically',
               ),
           }),
         )
         .nonempty()
-        .describe('List of price configurations'),
+        .describe(
+          "List of price configurations always use countryCode and currencyCodes that are already registered in the system, don't use non existing iso codes.",
+        ),
     })
     .optional()
-    .describe('Commerce info - Available for ALL except CONFIGURABLE_PRODUCT & BUNDLE_PRODUCT'),
+    .describe(
+      "Commerce info - Available for ALL except CONFIGURABLE_PRODUCT. always use countryCode and currencyCodes that are already registered in the system, don't use non existing iso codes.",
+    ),
 });
 
 export const actionValidators = {

package/src/mcp/utils/getNormalizedProductDetails.ts

@@ -1,6 +1,9 @@
 import { ProductTypes } from '@unchainedshop/core-products';
 import { Context } from '../../context.js';
 import normalizeMediaUrl from './normalizeMediaUrl.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:api:mcp');
 
 export async function getNormalizedProductDetails(productId: string, context: Context) {
   const { modules, locale, loaders } = context;
@@ -84,7 +87,7 @@ export async function getNormalizedProductDetails(productId: string, context: Co
     });
   } catch {
     // Pricing might not be available for all products
-    console.warn('Pricing not available for product:', product._id);
+    logger.warn('Pricing not available for product:', product._id);
   }
 
   const productMedias = await modules.products.media.findProductMedias({ productId });

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/checkoutCart.ts

@@ -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/updateCart.ts

@@ -19,7 +19,7 @@ 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,
     countryCode: context.countryCode,
@@ -28,23 +28,23 @@ export default async function updateCart(root: never, params: UpdateCartParams,
   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

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

@@ -0,0 +1,51 @@
+import { Context } from '../../../context.js';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { log } from '@unchainedshop/logger';
+import {
+  InvalidIdError,
+  OrderDeliveryTypeError,
+  OrderNotFoundError,
+  OrderWrongStatusError,
+} from '../../../errors.js';
+
+export default async function updateCartDeliveryPickUp(
+  root: never,
+  params: { orderId: string; deliveryProviderId: string; orderPickUpLocationId: string; meta: any },
+  context: Context,
+) {
+  const { modules, services, userId, user } = context;
+  const { orderId, deliveryProviderId, orderPickUpLocationId, meta } = params;
+  log(`mutation updateCartDeliveryPickUp provider ${deliveryProviderId}`, {
+    userId,
+  });
+
+  if (!deliveryProviderId) throw new InvalidIdError({ deliveryProviderId });
+
+  let order = await services.orders.findOrInitCart({
+    orderId,
+    user,
+    countryCode: context.countryCode,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
+  if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
+
+  const provider = await modules.delivery.findProvider({
+    deliveryProviderId,
+  });
+  const deliveryProviderType = provider?.type;
+
+  if (deliveryProviderType !== DeliveryProviderType.PICKUP)
+    throw new OrderDeliveryTypeError({
+      orderId: order._id,
+      received: deliveryProviderType,
+      required: DeliveryProviderType.PICKUP,
+    });
+
+  order = (await modules.orders.setDeliveryProvider(order._id, deliveryProviderId)) || order;
+
+  await modules.orders.deliveries.updateContext(order.deliveryId, {
+    orderPickUpLocationId,
+    meta,
+  });
+  return services.orders.updateCalculation(order._id);
+}

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

@@ -0,0 +1,51 @@
+import { Context } from '../../../context.js';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { log } from '@unchainedshop/logger';
+import {
+  InvalidIdError,
+  OrderDeliveryTypeError,
+  OrderNotFoundError,
+  OrderWrongStatusError,
+} from '../../../errors.js';
+
+export default async function updateCartDeliveryShipping(
+  root: never,
+  params: { orderId: string; deliveryProviderId: string; address: any; meta: any },
+  context: Context,
+) {
+  const { modules, services, userId, user } = context;
+  const { orderId, deliveryProviderId, address, meta } = params;
+  log(`mutation updateCartDeliveryShipping provider ${deliveryProviderId}`, {
+    userId,
+  });
+
+  if (!deliveryProviderId) throw new InvalidIdError({ deliveryProviderId });
+
+  let order = await services.orders.findOrInitCart({
+    orderId,
+    user,
+    countryCode: context.countryCode,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
+  if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
+
+  const provider = await modules.delivery.findProvider({
+    deliveryProviderId,
+  });
+  const deliveryProviderType = provider?.type;
+
+  if (deliveryProviderType !== DeliveryProviderType.SHIPPING)
+    throw new OrderDeliveryTypeError({
+      orderId: order._id,
+      received: deliveryProviderType,
+      required: DeliveryProviderType.SHIPPING,
+    });
+
+  order = (await modules.orders.setDeliveryProvider(order._id, deliveryProviderId)) || order;
+
+  await modules.orders.deliveries.updateContext(order.deliveryId, {
+    address,
+    meta,
+  });
+  return services.orders.updateCalculation(order._id);
+}

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

@@ -0,0 +1,50 @@
+import { Context } from '../../../context.js';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { log } from '@unchainedshop/logger';
+import {
+  InvalidIdError,
+  OrderNotFoundError,
+  OrderPaymentTypeError,
+  OrderWrongStatusError,
+} from '../../../errors.js';
+
+export default async function updateCartPaymentGeneric(
+  root: never,
+  params: { orderId: string; paymentProviderId: string; meta?: any },
+  context: Context,
+) {
+  const { modules, services, userId, user } = context;
+  const { orderId, paymentProviderId, meta } = params;
+  log(`mutation updateCartPaymentGeneric provider ${paymentProviderId}`, {
+    userId,
+  });
+
+  if (!paymentProviderId) throw new InvalidIdError({ paymentProviderId });
+
+  let order = await services.orders.findOrInitCart({
+    orderId,
+    user,
+    countryCode: context.countryCode,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
+  if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
+
+  const provider = await modules.payment.paymentProviders.findProvider({
+    paymentProviderId,
+  });
+  const paymentProviderType = provider?.type;
+
+  if (paymentProviderType !== PaymentProviderType.GENERIC)
+    throw new OrderPaymentTypeError({
+      orderId: order._id,
+      received: paymentProviderType,
+      required: PaymentProviderType.GENERIC,
+    });
+
+  order = (await modules.orders.setPaymentProvider(order._id, paymentProviderId)) || order;
+
+  await modules.orders.payments.updateContext(order.paymentId, {
+    meta,
+  });
+  return services.orders.updateCalculation(order._id);
+}

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

@@ -0,0 +1,50 @@
+import { Context } from '../../../context.js';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { log } from '@unchainedshop/logger';
+import {
+  InvalidIdError,
+  OrderNotFoundError,
+  OrderPaymentTypeError,
+  OrderWrongStatusError,
+} from '../../../errors.js';
+
+export default async function updateCartPaymentInvoice(
+  root: never,
+  params: { orderId: string; paymentProviderId: string; meta?: any },
+  context: Context,
+) {
+  const { modules, services, userId, user } = context;
+  const { orderId, paymentProviderId, meta } = params;
+  log(`mutation updateCartPaymentInvoice provider ${paymentProviderId}`, {
+    userId,
+  });
+
+  if (!paymentProviderId) throw new InvalidIdError({ paymentProviderId });
+
+  let order = await services.orders.findOrInitCart({
+    orderId,
+    user,
+    countryCode: context.countryCode,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
+  if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
+
+  const provider = await modules.payment.paymentProviders.findProvider({
+    paymentProviderId,
+  });
+  const paymentProviderType = provider?.type;
+
+  if (paymentProviderType !== PaymentProviderType.INVOICE)
+    throw new OrderPaymentTypeError({
+      orderId: order._id,
+      received: paymentProviderType,
+      required: PaymentProviderType.INVOICE,
+    });
+
+  order = (await modules.orders.setPaymentProvider(order._id, paymentProviderId)) || order;
+
+  await modules.orders.payments.updateContext(order.paymentId, {
+    meta,
+  });
+  return services.orders.updateCalculation(order._id);
+}

package/src/resolvers/mutations/products/updateProductCommerce.ts

@@ -1,6 +1,6 @@
 import { log } from '@unchainedshop/logger';
-import { ProductCommerce } from '@unchainedshop/core-products';
-import { ProductNotFoundError, InvalidIdError } from '../../../errors.js';
+import { ProductCommerce, ProductTypes } from '@unchainedshop/core-products';
+import { ProductNotFoundError, InvalidIdError, ProductWrongTypeError } from '../../../errors.js';
 import { Context } from '../../../context.js';
 
 export default async function updateProductCommerce(
@@ -12,8 +12,16 @@ export default async function updateProductCommerce(
 
   if (!productId) throw new InvalidIdError({ productId });
 
-  if (!(await modules.products.productExists({ productId })))
-    throw new ProductNotFoundError({ productId });
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  if (product.type === ProductTypes.ConfigurableProduct) {
+    throw new ProductWrongTypeError({
+      productId: productId,
+      received: product.type,
+      required: { not: ProductTypes.ConfigurableProduct },
+    });
+  }
 
   await modules.products.update(productId, { commerce });
 

package/src/resolvers/queries/shopInfo.ts

@@ -1,3 +1,4 @@
+import { readFile } from 'fs/promises';
 import { Context } from '../../context.js';
 import { log } from '@unchainedshop/logger';
 
@@ -10,14 +11,23 @@ export default function shopInfo(
   adminUiConfig?: Record<string, any>;
   vapidPublicKey?: string;
 } {
-  const { adminUiConfig } = context;
+  const { adminUiConfig, modules } = context;
   log('query shopInfo', { userId: context.userId });
 
   return {
     version: context.version,
     adminUiConfig: {
-      customProperties: adminUiConfig?.customProperties ?? [],
-      singleSignOnURL: adminUiConfig?.singleSignOnURL,
+      customProperties: async () => {
+        try {
+          const raw = await readFile(process.env.UNCHAINED_ADMIN_UI_CUSTOM_PROPERTIES, 'utf-8');
+          const parsed = JSON.parse(raw);
+          return parsed;
+        } catch {
+          return adminUiConfig?.customProperties ?? [];
+        }
+      },
+      singleSignOnURL:
+        process.env.UNCHAINED_ADMIN_UI_SINGLE_SIGN_ON_URL || adminUiConfig?.singleSignOnURL,
       externalLinks: () => {
         try {
           const parsed = JSON.parse(process.env.EXTERNAL_LINKS);
@@ -26,6 +36,42 @@ export default function shopInfo(
           return [];
         }
       },
+      productTags: async () => {
+        const existingProductTags = await modules.products.existingTags();
+        const envTags = (process.env.UNCHAINED_ADMIN_UI_DEFAULT_PRODUCT_TAGS || '')
+          .split(',')
+          .map((t) => t.trim())
+          .filter(Boolean);
+        const normalizedDefaultTags = envTags?.length
+          ? envTags
+          : (adminUiConfig?.defaultProductTags || []).filter(Boolean);
+        const normalizedTags = Array.from(new Set(normalizedDefaultTags.concat(existingProductTags)));
+        return normalizedTags;
+      },
+      assortmentTags: async () => {
+        const existingAssortmentTags = await modules.assortments.existingTags();
+        const envTags = (process.env.UNCHAINED_ADMIN_UI_DEFAULT_ASSORTMENT_TAGS || '')
+          .split(',')
+          .map((t) => t.trim())
+          .filter(Boolean);
+        const normalizedDefaultTags = envTags?.length
+          ? envTags
+          : (adminUiConfig?.defaultAssortmentTags || []).filter(Boolean);
+        const normalizedTags = Array.from(new Set(normalizedDefaultTags.concat(existingAssortmentTags)));
+        return normalizedTags;
+      },
+      userTags: async () => {
+        const existingUserTags = await modules.users.existingTags();
+        const envTags = (process.env.UNCHAINED_ADMIN_UI_DEFAULT_USER_TAGS || '')
+          .split(',')
+          .map((t) => t.trim())
+          .filter(Boolean);
+        const normalizedDefaultTags = envTags?.length
+          ? envTags
+          : (adminUiConfig?.defaultUserTags || []).filter(Boolean);
+        const normalizedTags = Array.from(new Set(normalizedDefaultTags.concat(existingUserTags)));
+        return normalizedTags;
+      },
     },
     vapidPublicKey: process.env?.PUSH_NOTIFICATION_PUBLIC_KEY,
   };

package/src/resolvers/type/media-types.ts

@@ -2,6 +2,9 @@ import { File as FileType, getFileAdapter } from '@unchainedshop/core-files';
 import { Context } from '../../context.js';
 import { checkAction } from '../../acl.js';
 import { actions } from '../../roles/index.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:api');
 export interface MediaHelperTypes {
   url: (language: FileType, params: Record<string, any>, context: Context) => Promise<string>;
 }
@@ -16,7 +19,7 @@ export const Media: MediaHelperTypes = {
       const url = await fileUploadAdapter.createDownloadURL(file, params?.expires);
       return modules.files.normalizeUrl(url, params);
     } catch (e) {
-      console.error(e);
+      logger.error(e);
       return null;
     }
   },

package/src/resolvers/type/order/order-payment-types.ts

@@ -5,7 +5,6 @@ import { objectInvert } from '@unchainedshop/utils';
 
 const OrderPaymentMap = {
   OrderPaymentGeneric: PaymentProviderType.GENERIC,
-  OrderPaymentCard: PaymentProviderType.CARD,
   OrderPaymentInvoice: PaymentProviderType.INVOICE,
 };
 

package/src/resolvers/type/price-types.ts

@@ -1,5 +1,3 @@
-import accounting from 'accounting';
-
 export interface PriceType {
   isTaxable?: boolean;
   isNetPrice?: boolean;
@@ -21,7 +19,11 @@ export const Price = {
   },
   amount(obj: PriceType) {
     if (obj.amount) {
-      return accounting.toFixed(obj.amount, 0);
+      return Number(obj.amount).toLocaleString(undefined, {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 0,
+        useGrouping: false,
+      });
     }
     return 0;
   },

package/src/resolvers/type/product/product-bundle-types.ts

@@ -1,8 +1,8 @@
 import { ProductBundleItem } from '@unchainedshop/core-products';
-import { Product } from './product-types.js';
+import { PlanProduct } from './product-plan-types.js';
 
 export const BundleProduct = {
-  ...Product,
+  ...PlanProduct,
 
   bundleItems(product): ProductBundleItem[] {
     return product.bundleItems ? product.bundleItems : [];

package/src/resolvers/type/shop-types.ts

@@ -5,7 +5,6 @@ import { checkAction } from '../../acl.js';
 import { allRoles, actions } from '../../roles/index.js';
 
 type HelperType<T> = (root: never, params: never, context: Context) => Promise<T>;
-
 export interface ShopHelperTypes {
   _id: () => string;
   country: HelperType<Country>;

package/src/schema/mutation.ts

@@ -226,12 +226,44 @@ export default [
       doesn’t exists new delivery provider will be created with the provided ID.
       """
       setOrderDeliveryProvider(orderId: ID!, deliveryProviderId: ID!): Order!
+        @deprecated(reason: "Use updateCart or updateCartDelivery* mutations instead")
 
       """
       Change the payment method/provider to an order. If the payment provider
       doesn’t exists new payment provider will be created with the provided ID.
       """
       setOrderPaymentProvider(orderId: ID!, paymentProviderId: ID!): Order!
+        @deprecated(reason: "Use updateCart or updateCartPayment* mutations instead")
+
+      """
+      Update the cart by changing the delivery provider and using a shipping specific configuration
+      """
+      updateCartDeliveryShipping(
+        orderId: ID
+        deliveryProviderId: ID!
+        address: AddressInput
+        meta: JSON
+      ): Order!
+
+      """
+      Update the cart by changing the delivery provider and using a pick up specific configuration
+      """
+      updateCartDeliveryPickUp(
+        orderId: ID
+        deliveryProviderId: ID!
+        orderPickUpLocationId: ID!
+        meta: JSON
+      ): Order!
+
+      """
+      Update the cart by changing the payment provider and using an invoice-type specific configuration
+      """
+      updateCartPaymentInvoice(orderId: ID, paymentProviderId: ID!, meta: JSON): Order!
+
+      """
+      Update the cart by changing the payment provider and using a generic specific configuration
+      """
+      updateCartPaymentGeneric(orderId: ID, paymentProviderId: ID!, meta: JSON): Order!
 
       """
       Update a Shipping Delivery Provider's specific configuration
@@ -240,7 +272,7 @@ export default [
         orderDeliveryId: ID!
         address: AddressInput
         meta: JSON
-      ): OrderDeliveryShipping!
+      ): OrderDeliveryShipping! @deprecated(reason: "Use updateCartDeliveryShipping instead")
 
       """
       Update a Pick Up Delivery Provider's specific configuration
@@ -249,22 +281,19 @@ export default [
         orderDeliveryId: ID!
         orderPickUpLocationId: ID!
         meta: JSON
-      ): OrderDeliveryPickUp!
-
-      """
-      Update a Card Payment Provider's specific configuration
-      """
-      updateOrderPaymentCard(orderPaymentId: ID!, meta: JSON): OrderPaymentCard!
+      ): OrderDeliveryPickUp! @deprecated(reason: "Use updateCartDeliveryPickUp instead")
 
       """
       Update an Invoice Payment Provider's specific configuration
       """
       updateOrderPaymentInvoice(orderPaymentId: ID!, meta: JSON): OrderPaymentInvoice!
+        @deprecated(reason: "Use updateCartPaymentInvoice instead")
 
       """
       Update a Generic Payment Provider's specific configuration
       """
       updateOrderPaymentGeneric(orderPaymentId: ID!, meta: JSON): OrderPaymentGeneric!
+        @deprecated(reason: "Use updateCartPaymentGeneric instead")
 
       """
       Remove an order while it's still open