@unchainedshop/api 4.4.0 → 4.5.0

package/lib/resolvers/mutations/accounts/createWebAuthnCredentialCreationOptions.d.ts

@@ -2,7 +2,4 @@ import type { Context } from '../../../context.ts';
 export default function createWebAuthnCredentialCreationOptions(root: never, { extensionOptions, username }: {
     username: string;
     extensionOptions: any;
-}, { modules, userId, getHeader }: Context): Promise<(Omit<import("fido2-lib").PublicKeyCredentialCreationOptions, "challenge" | "requestId"> & {
-    challenge: string;
-    requestId: number;
-}) | null>;
+}, { modules, userId, getHeader }: Context): Promise<import("@unchainedshop/core-users").WebAuthnCredentialCreationOptions>;

package/lib/resolvers/mutations/accounts/createWebAuthnCredentialRequestOptions.d.ts

@@ -2,7 +2,4 @@ import type { Context } from '../../../context.ts';
 export default function createWebAuthnCredentialRequestOptions(root: never, { extensionOptions, username }: {
     username: string;
     extensionOptions: any;
-}, { modules, userId, getHeader }: Context): Promise<(Omit<import("fido2-lib").PublicKeyCredentialRequestOptions, "challenge" | "requestId"> & {
-    challenge: string;
-    requestId: number;
-}) | null>;
+}, { modules, userId, getHeader }: Context): Promise<import("@unchainedshop/core-users").WebAuthnCredentialRequestOptions>;

package/lib/resolvers/mutations/accounts/loginAsGuest.js

@@ -1,9 +1,7 @@
 import { log } from '@unchainedshop/logger';
-import moniker from 'moniker';
-import { generateDbObjectId } from '@unchainedshop/mongodb';
 export default async function loginAsGuest(root, _, context) {
     log('mutation loginAsGuest');
-    const guestname = `${moniker.choose()}-${generateDbObjectId(5)}`;
+    const guestname = `guest-${crypto.randomUUID()}`;
     const guestUserId = await context.modules.users.createUser({
         email: `${guestname}@unchained.local`,
         guest: true,

package/lib/resolvers/mutations/accounts/removeWeb3Address.d.ts

@@ -1,4 +1,4 @@
 import type { Context } from '../../../context.ts';
 export default function removeWeb3Address(root: never, { address }: {
     address: string;
-}, { modules, userId, user }: Context): Promise<import("mongodb").WithId<import("@unchainedshop/core-users").User> | null>;
+}, { modules, userId, user }: Context): Promise<import("@unchainedshop/core-users").User>;

package/lib/resolvers/mutations/accounts/removeWeb3Address.js

@@ -4,13 +4,9 @@ export default async function removeWeb3Address(root, { address }, { modules, us
     log(`mutation removeWeb3Address ${address} ${user?.username}`, {
         userId,
     });
-    const foundCredentials = user?.services?.web3?.find((service) => service.address.toLowerCase() === address.toLowerCase());
-    if (!foundCredentials) {
+    const updatedUser = await modules.users.removeWeb3Address(userId, address);
+    if (!updatedUser) {
         throw new UserWeb3AddressNotFoundError({ userId, address });
     }
-    return modules.users.updateUser({ _id: userId }, {
-        $pull: {
-            'services.web3': { address: foundCredentials.address },
-        },
-    }, {});
+    return updatedUser;
 }

package/lib/resolvers/mutations/accounts/removeWebAuthnCredentials.d.ts

@@ -1,4 +1,4 @@
 import type { Context } from '../../../context.ts';
 export default function removeWebAuthnCredentials(root: never, { credentialsId }: {
     credentialsId: string;
-}, { modules, userId, user }: Context): Promise<import("mongodb").WithId<import("@unchainedshop/core-users").User> | null>;
+}, { modules, userId, user }: Context): Promise<import("@unchainedshop/core-users").User | null>;

package/lib/resolvers/mutations/accounts/removeWebAuthnCredentials.js

@@ -8,9 +8,5 @@ export default async function removeWebAuthnCredentials(root, { credentialsId },
     if (!foundCredentials) {
         throw new UserWebAuthnCredentialsNotFoundError({ userId, credentialsId });
     }
-    return modules.users.updateUser({ _id: userId }, {
-        $pull: {
-            'services.webAuthn': { id: credentialsId },
-        },
-    }, {});
+    return modules.users.removeWebAuthnCredential(userId, credentialsId);
 }

package/lib/resolvers/mutations/accounts/verifyWeb3Address.d.ts

@@ -1,5 +1,5 @@
 import type { Context } from '../../../context.ts';
-export default function verifyWeb3Address(root: never, { address, hash }: {
+export default function verifyWeb3Address(_root: never, { address, hash }: {
     address: string;
     hash: `0x${string}`;
-}, { modules, userId, user }: Context): Promise<import("mongodb").WithId<import("@unchainedshop/core-users").User> | null>;
+}, { modules, userId, user }: Context): Promise<import("@unchainedshop/core-users").User>;

package/lib/resolvers/mutations/accounts/verifyWeb3Address.js

@@ -1,100 +1,19 @@
 import { log } from '@unchainedshop/logger';
 import { UserWeb3AddressNotFoundError, UserWeb3AddressSignatureError } from "../../../errors.js";
-let secp256k1;
-let keccak_256;
-let bytesToHex;
-let hexToBytes;
-async function loadNoblePackages() {
-    try {
-        const curves = await import('@noble/curves/secp256k1.js');
-        const hashes = await import('@noble/hashes/sha3.js');
-        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;
-    }
-}
-function fromRPCSig(sig) {
-    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]);
-    if (v >= 35n) {
-        v = v - 35n - 2n * 1n;
-    }
-    else if (v >= 27n) {
-        v = v - 27n;
-    }
-    return { v, r, s };
-}
-function hashPersonalMessage(message) {
-    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, v, r, s) {
-    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);
-}
-function publicToAddress(publicKey) {
-    const hash = keccak_256(publicKey);
-    return hash.slice(-20);
-}
-export default async function verifyWeb3Address(root, { address, hash }, { modules, userId, user }) {
+export default async function verifyWeb3Address(_root, { address, hash }, { modules, userId, user }) {
     log(`mutation verifyWeb3Address ${address} ${user?.username}`, {
         userId,
     });
-    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());
+    const foundCredentials = modules.users.findWeb3Address(user, address);
     if (!foundCredentials) {
         throw new UserWeb3AddressNotFoundError({ userId, address });
     }
-    const messageHash = hashPersonalMessage(hexToBytes(Buffer.from(foundCredentials.nonce, 'utf8').toString('hex')));
-    const sigParams = fromRPCSig(hash);
-    const publicKey = ecrecover(messageHash, sigParams.v, sigParams.r, sigParams.s);
-    const sender = publicToAddress(publicKey);
-    const recoveredAddr = `0x${bytesToHex(sender)}`;
-    const isSignatureCorrectForAddress = recoveredAddr.toLowerCase() === foundCredentials.address.toLowerCase();
-    if (!isSignatureCorrectForAddress) {
+    if (!foundCredentials.nonce) {
         throw new UserWeb3AddressSignatureError({ userId, address: foundCredentials.address });
     }
-    const web3Services = user?.services?.web3.map((service) => {
-        if (foundCredentials.address === service.address) {
-            return {
-                ...service,
-                nonce: undefined,
-                verified: true,
-            };
-        }
-        return service;
-    });
-    return modules.users.updateUser({ _id: userId }, {
-        $set: {
-            'services.web3': web3Services,
-        },
-    }, {});
+    const updatedUser = await modules.users.verifyWeb3SignatureAndUpdate(user, { address: foundCredentials.address, nonce: foundCredentials.nonce }, hash);
+    if (!updatedUser) {
+        throw new UserWeb3AddressSignatureError({ userId, address: foundCredentials.address });
+    }
+    return updatedUser;
 }

package/lib/resolvers/mutations/filters/removeFilter.d.ts

@@ -1,4 +1,4 @@
 import type { Context } from '../../../context.ts';
-export default function removeFilter(root: never, { filterId }: {
+export default function removeFilter(_root: never, { filterId }: {
     filterId: string;
-}, context: Context): Promise<import("mongodb").WithId<import("@unchainedshop/core-filters").Filter>>;
+}, context: Context): Promise<import("@unchainedshop/core-filters").Filter | null>;

package/lib/resolvers/mutations/filters/removeFilter.js

@@ -1,14 +1,12 @@
 import { log } from '@unchainedshop/logger';
 import { FilterNotFoundError, InvalidIdError } from "../../../errors.js";
-export default async function removeFilter(root, { filterId }, context) {
-    const { modules, userId } = context;
+export default async function removeFilter(_root, { filterId }, context) {
+    const { modules, services, userId } = context;
     log(`mutation removeFilter ${filterId}`, { userId });
     if (!filterId)
         throw new InvalidIdError({ filterId });
     const filter = await modules.filters.findFilter({ filterId });
     if (!filter)
         throw new FilterNotFoundError({ filterId });
-    await modules.assortments.filters.deleteMany({ filterId });
-    await modules.filters.delete(filterId);
-    return filter;
+    return services.filters.removeFilter({ filter });
 }

package/lib/resolvers/mutations/orders/addMultipleCartProducts.js

@@ -1,53 +1,45 @@
 import { log } from '@unchainedshop/logger';
 import { ProductNotFoundError, OrderQuantityTooLowError, OrderWrongStatusError, OrderNotFoundError, } from "../../../errors.js";
-import { ordersSettings } from '@unchainedshop/core-orders';
 export default async function addMultipleCartProducts(root, params, context) {
-    const { modules, services, userId, user } = context;
+    const { modules, services, userId, user, locale, countryCode } = context;
     const { orderId, items } = params;
     log(`mutation addMultipleCartProducts ${JSON.stringify(items)}`, {
         userId,
         orderId,
     });
-    const itemsWithProducts = await Promise.all(items.map(async ({ productId, ...item }) => {
-        const originalProduct = await modules.products.findProduct({ productId });
-        if (!originalProduct)
+    for (const { productId, quantity } of items) {
+        const product = await modules.products.findProduct({ productId });
+        if (!product)
             throw new ProductNotFoundError({ productId });
-        return {
-            ...item,
-            originalProduct,
-        };
-    }));
+        if (quantity < 1)
+            throw new OrderQuantityTooLowError({ quantity, productId });
+    }
     const order = await services.orders.findOrInitCart({
         orderId,
         user: user,
-        countryCode: context.countryCode,
+        countryCode,
     });
     if (!order)
         throw new OrderNotFoundError({ orderId });
     if (!modules.orders.isCart(order))
         throw new OrderWrongStatusError({ status: order.status });
-    for (const { originalProduct, quantity, configuration } of itemsWithProducts) {
-        if (quantity < 1)
-            throw new OrderQuantityTooLowError({
-                quantity,
-                productId: originalProduct._id,
-            });
-        const product = await modules.products.resolveOrderableProduct(originalProduct, {
-            configuration,
-        });
-        await ordersSettings.validateOrderPosition({
-            order,
-            product,
-            configuration,
-            quantityDiff: quantity,
-        }, context);
-        await modules.orders.positions.addProductItem({
-            quantity,
-            configuration,
-            originalProductId: originalProduct._id,
-            productId: product._id,
+    try {
+        await services.orders.addMultipleCartProducts({
             orderId: order._id,
+            items,
+            context: { localeContext: locale, userId, countryCode },
         });
     }
+    catch (error) {
+        if (error.message?.startsWith('Product not found:')) {
+            const productId = error.message.split(': ')[1];
+            throw new ProductNotFoundError({ productId });
+        }
+        if (error.message?.startsWith('Invalid quantity')) {
+            const productId = error.message.split(': ')[1];
+            throw new OrderQuantityTooLowError({ quantity: 0, productId });
+        }
+        throw error;
+    }
     return services.orders.updateCalculation(order._id);
 }

package/lib/resolvers/mutations/orders/removeCartDiscount.d.ts

@@ -1,4 +1,4 @@
 import type { Context } from '../../../context.ts';
-export default function removeCartDiscount(root: never, { discountId }: {
+export default function removeCartDiscount(_root: never, { discountId }: {
     discountId: string;
-}, requestContext: Context): Promise<import("mongodb").WithId<import("@unchainedshop/core-orders").OrderDiscount> | null>;
+}, requestContext: Context): Promise<import("@unchainedshop/core-orders").OrderDiscount>;

package/lib/resolvers/mutations/orders/removeCartDiscount.js

@@ -1,9 +1,7 @@
 import { log } from '@unchainedshop/logger';
 import { OrderDiscountNotFoundError, OrderWrongStatusError, InvalidIdError, OrderNotFoundError, } from "../../../errors.js";
-import { OrderDiscountTrigger } from '@unchainedshop/core-orders';
-import { OrderDiscountDirector } from '@unchainedshop/core';
-export default async function removeCartDiscount(root, { discountId }, requestContext) {
-    const { modules, services, userId } = requestContext;
+export default async function removeCartDiscount(_root, { discountId }, requestContext) {
+    const { modules, services, userId, locale } = requestContext;
     log(`mutation removeCartDiscount ${discountId}`, { userId });
     if (!discountId)
         throw new InvalidIdError({ discountId });
@@ -20,16 +18,13 @@ export default async function removeCartDiscount(root, { discountId }, requestCo
     if (!modules.orders.isCart(order)) {
         throw new OrderWrongStatusError({ status: order.status });
     }
-    if (orderDiscount.trigger === OrderDiscountTrigger.USER) {
-        const Adapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
-        if (Adapter) {
-            const adapter = await Adapter.actions({
-                context: { order, orderDiscount, code: orderDiscount.code, ...requestContext },
-            });
-            await adapter.release();
-        }
-    }
-    const deletedDiscount = await modules.orders.discounts.delete(discountId);
+    const deletedDiscount = await services.orders.removeCartDiscount({
+        order,
+        orderDiscount,
+        requestContext: { localeContext: locale, userId },
+    });
+    if (!deletedDiscount)
+        throw new OrderDiscountNotFoundError({ orderDiscount });
     await services.orders.updateCalculation(order._id);
     return deletedDiscount;
 }

package/lib/resolvers/mutations/orders/updateCart.js

@@ -13,14 +13,8 @@ export default async function updateCart(root, params, context) {
         throw new OrderNotFoundError({ orderId });
     if (!modules.orders.isCart(order))
         throw new OrderWrongStatusError({ status: order.status });
-    if (meta) {
-        await modules.orders.updateContext(order._id, meta);
-    }
-    if (billingAddress) {
-        await modules.orders.updateBillingAddress(order._id, billingAddress);
-    }
-    if (contact) {
-        await modules.orders.updateContact(order._id, contact);
+    if (meta || billingAddress || contact) {
+        await modules.orders.updateCartFields(order._id, { meta, billingAddress, contact });
     }
     if (paymentProviderId) {
         await modules.orders.setPaymentProvider(order._id, paymentProviderId);

package/lib/resolvers/mutations/users/removeUser.js

@@ -8,7 +8,7 @@ export default async function removeUser(root, params, unchainedAPI) {
     if (!(await modules.users.userExists({ userId: normalizedUserId })))
         throw new UserNotFoundError({ userId: normalizedUserId });
     if (removeUserReviews) {
-        await modules.products.reviews.deleteMany({ authorId: normalizedUserId });
+        await modules.products.reviews.deleteByAuthorId(normalizedUserId);
     }
     return services.users.deleteUser({ userId: normalizedUserId });
 }

package/lib/resolvers/mutations/warehousing/exportToken.js

@@ -1,5 +1,4 @@
 import { log } from '@unchainedshop/logger';
-import { WorkStatus } from '@unchainedshop/core-worker';
 import { InvalidIdError, TokenNotFoundError, TokenWrongStatusError } from "../../../errors.js";
 export default async function exportToken(root, { tokenId, quantity, recipientWalletAddress, }, { modules, userId }) {
     log(`mutation exportToken ${tokenId}`, {
@@ -13,21 +12,14 @@ export default async function exportToken(root, { tokenId, quantity, recipientWa
     if (token.walletAddress && !token.userId) {
         throw new TokenWrongStatusError({ tokenId });
     }
-    const workItems = await modules.worker.findWorkQueue({
-        types: ['EXPORT_TOKEN'],
-        status: [WorkStatus.NEW, WorkStatus.ALLOCATED],
-    });
-    const existingWork = workItems.find((item) => item.input?.token?._id === token._id);
-    if (!existingWork) {
-        await modules.worker.addWork({
-            type: 'EXPORT_TOKEN',
-            retries: 5,
-            input: {
-                token,
-                quantity,
-                recipientWalletAddress,
-            },
-        });
-    }
+    await modules.worker.addWorkIfNotExists({
+        type: 'EXPORT_TOKEN',
+        retries: 5,
+        input: {
+            token,
+            quantity,
+            recipientWalletAddress,
+        },
+    }, (item) => item.input?.token?._id === token._id);
     return modules.warehousing.findToken({ tokenId });
 }

package/lib/resolvers/queries/payment/paymentProvidersCount.d.ts

@@ -1,5 +1,5 @@
 import type { Context } from '../../../context.ts';
-import type { PaymentProvider } from '@unchainedshop/core-payment';
-export default function paymentProvidersCount(root: never, params: {
-    type?: PaymentProvider | null;
+import type { PaymentProviderType } from '@unchainedshop/core-payment';
+export default function paymentProvidersCount(_root: never, params: {
+    type?: PaymentProviderType | null;
 }, { modules, userId }: Context): Promise<number>;

package/lib/resolvers/queries/payment/paymentProvidersCount.js

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-export default async function paymentProvidersCount(root, params, { modules, userId }) {
+export default async function paymentProvidersCount(_root, params, { modules, userId }) {
     log(`query paymentProvidersCount ${params.type}`, { userId });
     return modules.payment.paymentProviders.count(params.type
         ? {

package/lib/resolvers/queries/shopInfo.js

@@ -1,5 +1,6 @@
 import { readFile } from 'fs/promises';
 import { log } from '@unchainedshop/logger';
+import { getConfiguredTags } from "../../utils/getConfiguredTags.js";
 export default function shopInfo(root, _, context) {
     const { adminUiConfig, modules } = context;
     log('query shopInfo', { userId: context.userId });
@@ -30,42 +31,9 @@ export default function shopInfo(root, _, context) {
                     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;
-            },
+            productTags: () => getConfiguredTags(() => modules.products.existingTags(), 'UNCHAINED_ADMIN_UI_DEFAULT_PRODUCT_TAGS', adminUiConfig?.defaultProductTags),
+            assortmentTags: () => getConfiguredTags(() => modules.assortments.existingTags(), 'UNCHAINED_ADMIN_UI_DEFAULT_ASSORTMENT_TAGS', adminUiConfig?.defaultAssortmentTags),
+            userTags: () => getConfiguredTags(() => modules.users.existingTags(), 'UNCHAINED_ADMIN_UI_DEFAULT_USER_TAGS', adminUiConfig?.defaultUserTags),
         },
         vapidPublicKey: process.env?.PUSH_NOTIFICATION_PUBLIC_KEY,
     };

package/lib/resolvers/type/delivery-provider-interface.d.ts

@@ -7,11 +7,5 @@ export declare const DeliveryProviderInterface: {
         label: string;
         version: string;
     } | null;
-    simulatedPrice(deliveryProvider: any, args: any, context: Context): Promise<{
-        amount: number;
-        currencyCode: string;
-        countryCode: string;
-        isTaxable: boolean;
-        isNetPrice: any;
-    } | null>;
+    simulatedPrice(deliveryProvider: any, args: any, requestContext: Context): Promise<import("@unchainedshop/core/lib/services/simulateDeliveryPricing.js").SimulatedDeliveryPrice | null>;
 };

package/lib/resolvers/type/delivery-provider-interface.js

@@ -1,4 +1,4 @@
-import { DeliveryDirector, DeliveryPricingDirector } from '@unchainedshop/core';
+import { DeliveryDirector } from '@unchainedshop/core';
 export const DeliveryProviderInterface = {
     async isActive(deliveryProvider, _, context) {
         const director = await DeliveryDirector.actions(deliveryProvider, {}, context);
@@ -18,30 +18,20 @@ export const DeliveryProviderInterface = {
             version: Adapter.version,
         };
     },
-    async simulatedPrice(deliveryProvider, args, context) {
-        const { loaders, countryCode, user } = context;
+    async simulatedPrice(deliveryProvider, args, requestContext) {
+        const { loaders, services, countryCode, user } = requestContext;
         const { currencyCode: forcedCurrencyCode, orderId, useNetPrice, context: providerContext } = args;
-        const order = await loaders.orderLoader.load({ orderId });
-        const currencyCode = forcedCurrencyCode || order?.currencyCode || context.currencyCode;
-        const pricingContext = {
+        if (!user)
+            return null;
+        const order = orderId ? await loaders.orderLoader.load({ orderId }) : undefined;
+        const currencyCode = forcedCurrencyCode || order?.currencyCode || requestContext.currencyCode;
+        return services.delivery.simulateDeliveryPricing({
             countryCode,
             currencyCode,
             provider: deliveryProvider,
             order,
             providerContext,
-            user: user,
-        };
-        const calculated = await DeliveryPricingDirector.rebuildCalculation(pricingContext, context);
-        if (!calculated?.length)
-            return null;
-        const pricing = DeliveryPricingDirector.calculationSheet(pricingContext, calculated);
-        const orderPrice = pricing.total({ useNetPrice });
-        return {
-            amount: orderPrice.amount,
-            currencyCode: orderPrice.currencyCode,
-            countryCode,
-            isTaxable: pricing.taxSum() > 0,
-            isNetPrice: useNetPrice,
-        };
+            user,
+        }, { useNetPrice });
     },
 };

package/lib/resolvers/type/delivery-provider-pickup-types.d.ts

@@ -9,11 +9,5 @@ export declare const DeliveryProviderPickUp: {
         label: string;
         version: string;
     } | null;
-    simulatedPrice(deliveryProvider: any, args: any, context: Context): Promise<{
-        amount: number;
-        currencyCode: string;
-        countryCode: string;
-        isTaxable: boolean;
-        isNetPrice: any;
-    } | null>;
+    simulatedPrice(deliveryProvider: any, args: any, requestContext: Context): Promise<import("@unchainedshop/core/lib/services/simulateDeliveryPricing.js").SimulatedDeliveryPrice | null>;
 };

package/lib/resolvers/type/delivery-provider-shipping-types.d.ts

@@ -6,11 +6,5 @@ export declare const DeliveryProviderShipping: {
         label: string;
         version: string;
     } | null;
-    simulatedPrice(deliveryProvider: any, args: any, context: import("../../context.ts").Context): Promise<{
-        amount: number;
-        currencyCode: string;
-        countryCode: string;
-        isTaxable: boolean;
-        isNetPrice: any;
-    } | null>;
+    simulatedPrice(deliveryProvider: any, args: any, requestContext: import("../../context.ts").Context): Promise<import("@unchainedshop/core/lib/services/simulateDeliveryPricing.js").SimulatedDeliveryPrice | null>;
 };

package/lib/resolvers/type/delivery-provider-types.d.ts

@@ -7,12 +7,6 @@ export declare const DeliveryProvider: {
         label: string;
         version: string;
     } | null;
-    simulatedPrice(deliveryProvider: any, args: any, context: import("../../context.ts").Context): Promise<{
-        amount: number;
-        currencyCode: string;
-        countryCode: string;
-        isTaxable: boolean;
-        isNetPrice: any;
-    } | null>;
+    simulatedPrice(deliveryProvider: any, args: any, requestContext: import("../../context.ts").Context): Promise<import("@unchainedshop/core/lib/services/simulateDeliveryPricing.js").SimulatedDeliveryPrice | null>;
     __resolveType: (provider: DeliveryProviderActual) => Promise<"DeliveryProviderPickUp" | "DeliveryProviderShipping">;
 };