@unchainedshop/api 4.0.0-rc.13 → 4.0.0-rc.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/api",
-  "version": "4.0.0-rc.13",
+  "version": "4.0.0-rc.15",
   "main": "lib/api-index.js",
   "types": "lib/api-index.d.ts",
   "type": "module",
@@ -31,7 +31,6 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "peerDependencies": {
-    "@ethereumjs/util": ">= 10 < 11",
     "fastify": ">= 5.2 < 6",
     "@fastify/cookie": ">= 11 < 12",
     "@fastify/session": ">= 11 < 12",
@@ -42,7 +41,9 @@
     "express-session": ">= 1.18 < 2",
     "multer": ">= 2 < 3",
     "graphql-yoga": ">= 5.9 < 6",
-    "passport": ">= 0.7 < 1"
+    "passport": ">= 0.7 < 1",
+    "@noble/curves": "^2.0.0",
+    "@noble/hashes": "^2.0.0"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/sdk": {
@@ -54,9 +55,6 @@
     "connect-mongo": {
       "optional": false
     },
-    "@ethereumjs/util": {
-      "optional": true
-    },
     "fastify": {
       "optional": true
     },
@@ -80,14 +78,20 @@
     },
     "passport": {
       "optional": true
+    },
+    "@noble/curves": {
+      "optional": true
+    },
+    "@noble/hashes": {
+      "optional": true
     }
   },
   "dependencies": {
-    "@unchainedshop/core": "^4.0.0-rc.13",
-    "@unchainedshop/events": "^4.0.0-rc.13",
-    "@unchainedshop/logger": "^4.0.0-rc.13",
-    "@unchainedshop/roles": "^4.0.0-rc.13",
-    "@unchainedshop/utils": "^4.0.0-rc.13",
+    "@unchainedshop/core": "^4.0.0-rc.15",
+    "@unchainedshop/events": "^4.0.0-rc.15",
+    "@unchainedshop/logger": "^4.0.0-rc.15",
+    "@unchainedshop/roles": "^4.0.0-rc.15",
+    "@unchainedshop/utils": "^4.0.0-rc.15",
     "accounting": "0.4.1",
     "dataloader": "^2.2.3",
     "expiry-map": "^2.0.0",
@@ -97,7 +101,8 @@
     "zod": "^3.25.76"
   },
   "devDependencies": {
-    "@ethereumjs/util": "^10.0.0",
+    "@noble/curves": "^2.0.0",
+    "@noble/hashes": "^2.0.0",
     "@fastify/cookie": "^11.0.2",
     "@fastify/multipart": "^9.0.3",
     "@fastify/session": "^11.1.0",

package/src/express/createERCMetadataMiddleware.ts

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import { createLogger } from '@unchainedshop/logger';
 import { Context } from '../context.js';
 import { Request, RequestHandler } from 'express';
@@ -25,16 +24,20 @@ const ercMetadataMiddleware: RequestHandler = async (
 
     const { services, modules, loaders, locale } = req.unchainedContext;
     const url = new URL(req.url, ROOT_URL);
-    const parsedPath = path.parse(url.pathname);
 
-    if (parsedPath.ext !== '.json') throw new Error('Invalid ERC Metadata URI');
+    // Replace path.parse with URL/string methods
+    const pathname = url.pathname;
+    if (!pathname.toLowerCase().endsWith('.json')) throw new Error('Invalid ERC Metadata URI');
+
+    const fileName = pathname.split('/').pop();
+    const chainTokenId = fileName.slice(0, fileName.lastIndexOf('.'));
 
     const [, productId, localeOrTokenFilename, tokenFileName] = url.pathname.split('/');
 
     const product = await loaders.productLoader.load({ productId });
 
     const [token] = await modules.warehousing.findTokens({
-      chainTokenId: parsedPath.name,
+      chainTokenId,
       contractAddress: product?.tokenization?.contractAddress,
     });
 
@@ -49,11 +52,10 @@ const ercMetadataMiddleware: RequestHandler = async (
     }
 
     const body = JSON.stringify(ercMetadata);
-    res.writeHead(200, {
-      'Content-Length': Buffer.byteLength(body),
-      'Content-Type': 'text/plain',
-    });
-    res.end(body);
+    res.status(200);
+    res.setHeader('Content-Type', 'application/json');
+    res.setHeader('Content-Length', new TextEncoder().encode(body).length);
+    return res.send(body);
   } catch (e) {
     logger.error(e.message);
     res.writeHead(503);

package/src/fastify/bulkImportHandler.ts

@@ -46,7 +46,7 @@ const bulkImportHandler: RouteHandlerMethod = async (
 
     const body = JSON.stringify(work);
     res.status(200);
-    res.header('Content-Length', Buffer.byteLength(body));
+    res.header('Content-Length', new TextEncoder().encode(body).length);
     res.header('Content-Type', 'application/json');
     return res.send(body);
   } catch (e) {

package/src/fastify/ercMetadataHandler.ts

@@ -41,7 +41,7 @@ const ercMetadataHandler: RouteHandlerMethod = async (
 
     const body = JSON.stringify(ercMetadata);
     res.status(200);
-    res.header('Content-Length', Buffer.byteLength(body));
+    res.header('Content-Length', new TextEncoder().encode(body).length);
     res.header('Content-Type', 'application/json');
     return res.send(body);
   } catch (e) {

package/src/fastify/tempUploadHandler.ts

@@ -39,7 +39,7 @@ const tempUploadHandler: RouteHandlerMethod = async (
     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-Length', new TextEncoder().encode(body).length);
     res.header('Content-Type', 'application/json');
     return res.send(body);
   } catch (e) {

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

@@ -183,10 +183,9 @@ export const actionValidators = {
       .optional()
       .describe('Filter events by specific event types (e.g., USER_CREATED, ORDER_PLACED)'),
     created: z
-      .string()
-      .datetime()
+      .object(DateRangeSchema)
       .optional()
-      .describe('ISO 8601 timestamp to filter events created on or after this date/time'),
+      .describe('Date range filter for when events are emitted/created'),
   }),
 
   EVENT_COUNT: z.object({
@@ -196,10 +195,9 @@ export const actionValidators = {
       .optional()
       .describe('Filter events by specific event types (e.g., USER_CREATED, ORDER_PLACED)'),
     created: z
-      .string()
-      .datetime()
+      .object(DateRangeSchema)
       .optional()
-      .describe('ISO 8601 timestamp to filter events created on or after this date/time'),
+      .describe('Date range filter for when events are emitted/created'),
   }),
 
   EVENT_STATISTICS: z.object({

package/src/mcp/tools/system/types.ts

@@ -30,11 +30,17 @@ export interface EventListOptions {
   queryString?: string;
   types?: string[];
   sort?: SortOption[];
-  created?: Date;
+  created?: {
+    start?: Date;
+    end?: Date;
+  };
 }
 
 export interface EventCountOptions {
   queryString?: string;
-  created?: Date;
+  created?: {
+    start?: Date;
+    end?: Date;
+  };
   types?: string[];
 }

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

@@ -2,6 +2,93 @@ 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}` },
@@ -11,6 +98,14 @@ export default async function verifyWeb3Address(
     userId,
   });
 
+  // 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(),
   );
@@ -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();

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/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/orders/orderStatistics.ts

@@ -5,12 +5,12 @@ import { DateFilterInput } from '@unchainedshop/utils';
 export default async function orderStatistics(
   root: never,
   params: { dateRange?: DateFilterInput },
-  { modules, userId }: Context,
+  { userId }: Context,
 ) {
+  const { dateRange } = params || {};
   log(`query orderStatistics `, {
     userId,
     ...(params?.dateRange || {}),
   });
-
-  return modules.orders.getReport(params);
+  return { dateRange };
 }

package/src/resolvers/type/index.ts

@@ -67,6 +67,7 @@ import { Token } from './token-types.js';
 import { Web3Address } from './web3-address.js';
 import { LoginMethodResponse } from './login-method-response-types.js';
 import { ProductSearchResult } from './product-search-result-types.js';
+import { OrderStatistics } from './order/order-statistics-types.js';
 
 const types = {
   Assortment,
@@ -138,6 +139,7 @@ const types = {
   Media,
   Web3Address,
   LoginMethodResponse,
+  OrderStatistics,
 };
 
 export default types;