@unchainedshop/api 4.4.0 → 4.5.0

package/lib/resolvers/type/index.d.ts

@@ -96,7 +96,7 @@ declare const types: {
             limit: number;
             offset: number;
             includeInactive: boolean;
-        }, { modules }: import("../../context.ts").Context): Promise<(typeof product)[]>;
+        }, { services }: import("../../context.ts").Context): Promise<(typeof product)[]>;
         status(product: import("@unchainedshop/core-products").Product, _: any, { modules }: import("../../context.ts").Context): import("@unchainedshop/core-products").ProductStatus;
         texts(product: import("@unchainedshop/core-products").Product, { forceLocale, }: {
             forceLocale?: string;
@@ -156,7 +156,7 @@ declare const types: {
             limit: number;
             offset: number;
             includeInactive: boolean;
-        }, { modules }: import("../../context.ts").Context): Promise<(typeof product)[]>;
+        }, { services }: import("../../context.ts").Context): Promise<(typeof product)[]>;
         status(product: import("@unchainedshop/core-products").Product, _: any, { modules }: import("../../context.ts").Context): import("@unchainedshop/core-products").ProductStatus;
         texts(product: import("@unchainedshop/core-products").Product, { forceLocale, }: {
             forceLocale?: string;
@@ -174,13 +174,7 @@ declare const types: {
             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: import("@unchainedshop/core-delivery").DeliveryProvider) => Promise<"DeliveryProviderPickUp" | "DeliveryProviderShipping">;
     };
     DeliveryProviderPickUp: {
@@ -192,13 +186,7 @@ declare const types: {
             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>;
     };
     DeliveryProviderShipping: {
         isActive(deliveryProvider: any, _: any, context: import("../../context.ts").Context): Promise<boolean>;
@@ -208,13 +196,7 @@ declare const types: {
             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>;
     };
     Dimensions: {
         weight({ weightInGram }: {
@@ -414,13 +396,7 @@ declare const types: {
     };
     OrderItem: {
         discounts(orderPosition: import("@unchainedshop/core-orders").OrderPosition, _: any, context: import("../../context.ts").Context): Promise<import("@unchainedshop/core-orders").OrderPositionDiscount[]>;
-        dispatches(orderPosition: import("@unchainedshop/core-orders").OrderPosition, _: never, { modules, loaders }: import("../../context.ts").Context): Promise<{
-            _id: string;
-            deliveryProvider: import("@unchainedshop/core-delivery").DeliveryProvider;
-            warehousingProvider: import("@unchainedshop/core-warehousing").WarehousingProvider;
-            shipping: Date;
-            earliestDelivery: Date;
-        }[] | null>;
+        dispatches(orderPosition: import("@unchainedshop/core-orders").OrderPosition, _: never, { services }: import("../../context.ts").Context): Promise<import("@unchainedshop/core/lib/services/resolveOrderItemDispatches.js").OrderItemDispatch[] | null>;
         order(orderPosition: import("@unchainedshop/core-orders").OrderPosition, _: any, { loaders }: import("../../context.ts").Context): Promise<import("@unchainedshop/core-orders").Order>;
         originalProduct(orderPosition: import("@unchainedshop/core-orders").OrderPosition, _: any, { loaders }: import("../../context.ts").Context): Promise<import("@unchainedshop/core-products").Product>;
         product(orderPosition: import("@unchainedshop/core-orders").OrderPosition, _: any, { loaders }: import("../../context.ts").Context): Promise<import("@unchainedshop/core-products").Product>;
@@ -506,13 +482,7 @@ declare const types: {
             orderId: any;
             useNetPrice: any;
             context: any;
-        }, requestContext: import("../../context.ts").Context): Promise<{
-            amount: number;
-            currencyCode: string;
-            countryCode: string;
-            isTaxable: boolean;
-            isNetPrice: any;
-        } | null>;
+        }, requestContext: import("../../context.ts").Context): Promise<import("@unchainedshop/core/lib/services/simulatePaymentPricing.js").SimulatedPaymentPrice | null>;
     };
     PlanProduct: {
         catalogPrice(product: import("@unchainedshop/core-products").Product, { quantity, currencyCode: forcedCurrencyCode }: {
@@ -561,7 +531,7 @@ declare const types: {
             limit: number;
             offset: number;
             includeInactive: boolean;
-        }, { modules }: import("../../context.ts").Context): Promise<(typeof product)[]>;
+        }, { services }: import("../../context.ts").Context): Promise<(typeof product)[]>;
         status(product: import("@unchainedshop/core-products").Product, _: any, { modules }: import("../../context.ts").Context): import("@unchainedshop/core-products").ProductStatus;
         texts(product: import("@unchainedshop/core-products").Product, { forceLocale, }: {
             forceLocale?: string;
@@ -600,7 +570,7 @@ declare const types: {
             limit: number;
             offset: number;
             includeInactive: boolean;
-        }, { modules }: import("../../context.ts").Context): Promise<(typeof product)[]>;
+        }, { services }: import("../../context.ts").Context): Promise<(typeof product)[]>;
         status(product: import("@unchainedshop/core-products").Product, _: any, { modules }: import("../../context.ts").Context): import("@unchainedshop/core-products").ProductStatus;
         texts(product: import("@unchainedshop/core-products").Product, { forceLocale, }: {
             forceLocale?: string;
@@ -732,7 +702,7 @@ declare const types: {
             limit: number;
             offset: number;
             includeInactive: boolean;
-        }, { modules }: import("../../context.ts").Context): Promise<(typeof product)[]>;
+        }, { services }: import("../../context.ts").Context): Promise<(typeof product)[]>;
         status(product: import("@unchainedshop/core-products").Product, _: any, { modules }: import("../../context.ts").Context): import("@unchainedshop/core-products").ProductStatus;
         texts(product: import("@unchainedshop/core-products").Product, { forceLocale, }: {
             forceLocale?: string;
@@ -797,7 +767,7 @@ declare const types: {
             limit: number;
             offset: number;
             includeInactive: boolean;
-        }, { modules }: import("../../context.ts").Context): Promise<(typeof product)[]>;
+        }, { services }: import("../../context.ts").Context): Promise<(typeof product)[]>;
         status(product: import("@unchainedshop/core-products").Product, _: any, { modules }: import("../../context.ts").Context): import("@unchainedshop/core-products").ProductStatus;
         texts(product: import("@unchainedshop/core-products").Product, { forceLocale, }: {
             forceLocale?: string;
@@ -806,11 +776,11 @@ declare const types: {
     Token: {
         product: (token: import("@unchainedshop/core-warehousing").TokenSurrogate, params: never, { loaders }: import("../../context.ts").Context) => Promise<import("@unchainedshop/core-products").Product>;
         user: (token: import("@unchainedshop/core-warehousing").TokenSurrogate, params: never, { loaders }: import("../../context.ts").Context) => Promise<import("@unchainedshop/core-users").User | null>;
-        status: (token: import("@unchainedshop/core-warehousing").TokenSurrogate, params: never, { modules }: import("../../context.ts").Context) => Promise<"DECENTRALIZED" | "EXPORTING" | "CENTRALIZED">;
+        status: (token: import("@unchainedshop/core-warehousing").TokenSurrogate, params: never, { services }: import("../../context.ts").Context) => Promise<import("@unchainedshop/core-warehousing").TokenStatus>;
         ercMetadata: (token: import("@unchainedshop/core-warehousing").TokenSurrogate, { forceLocale }: {
             forceLocale: string;
         }, context: import("../../context.ts").Context) => Promise<any>;
-        isInvalidateable: (token: import("@unchainedshop/core-warehousing").TokenSurrogate, _params: never, context: import("../../context.ts").Context) => Promise<boolean>;
+        isInvalidateable: (token: import("@unchainedshop/core-warehousing").TokenSurrogate, _params: never, { services }: import("../../context.ts").Context) => Promise<boolean>;
         accessKey: (token: import("@unchainedshop/core-warehousing").TokenSurrogate, params: never, requestContext: import("../../context.ts").Context) => Promise<string | null>;
     };
     User: import("./user-types.ts").UserHelperTypes;
@@ -838,7 +808,16 @@ declare const types: {
             aaguid: string;
             counter: number;
             mdsMetadata: any;
-        }, _: never, { modules }: import("../../context.ts").Context): Promise<any>;
+        }, _: never, { modules }: import("../../context.ts").Context): Promise<{
+            [key: string]: unknown;
+            description?: string;
+            icon?: string;
+            authenticatorGetInfo?: {
+                versions?: string[];
+                extensions?: string[];
+                options?: Record<string, boolean>;
+            };
+        } | null>;
     };
     WarehousingProvider: import("./warehousing-provider-types.ts").WarehousingProviderHelperTypes;
     Work: import("./work-types.ts").WorkHelperTypes;
@@ -857,34 +836,34 @@ declare const types: {
     OrderStatistics: {
         newCount: ({ dateRange }: {
             dateRange: any;
-        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<any>;
+        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<number>;
         checkoutCount: ({ dateRange }: {
             dateRange: any;
-        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<any>;
+        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<number>;
         rejectCount: ({ dateRange }: {
             dateRange: any;
-        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<any>;
+        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<number>;
         confirmCount: ({ dateRange }: {
             dateRange: any;
-        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<any>;
+        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<number>;
         fulfillCount: ({ dateRange }: {
             dateRange: any;
-        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<any>;
+        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<number>;
         newRecords: ({ dateRange }: {
             dateRange: any;
-        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<any>;
+        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<import("@unchainedshop/core-orders").OrderStatisticsRecord[]>;
         checkoutRecords: ({ dateRange }: {
             dateRange: any;
-        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<any>;
+        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<import("@unchainedshop/core-orders").OrderStatisticsRecord[]>;
         rejectRecords: ({ dateRange }: {
             dateRange: any;
-        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<any>;
+        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<import("@unchainedshop/core-orders").OrderStatisticsRecord[]>;
         confirmRecords: ({ dateRange }: {
             dateRange: any;
-        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<any>;
+        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<import("@unchainedshop/core-orders").OrderStatisticsRecord[]>;
         fulfilledRecords: ({ dateRange }: {
             dateRange: any;
-        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<any>;
+        }, _p: any, { modules }: import("../../context.ts").Context) => Promise<import("@unchainedshop/core-orders").OrderStatisticsRecord[]>;
     };
 };
 export default types;

package/lib/resolvers/type/media-types.d.ts

@@ -1,4 +1,4 @@
-import { type File as FileType } from '@unchainedshop/core-files';
+import type { File as FileType } from '@unchainedshop/core-files';
 import type { Context } from '../../context.ts';
 export interface MediaHelperTypes {
     url: (language: FileType, params: Record<string, any>, context: Context) => Promise<string | null>;

package/lib/resolvers/type/media-types.js

@@ -1,20 +1,22 @@
-import { getFileAdapter } from '@unchainedshop/core-files';
 import { checkAction } from "../../acl.js";
 import { actions } from "../../roles/index.js";
 import { createLogger } from '@unchainedshop/logger';
 const logger = createLogger('unchained:api');
 export const Media = {
     url: async (file, params, context) => {
-        const { modules } = context;
+        const { services } = context;
         try {
             await checkAction(context, actions.downloadFile, [file, params]);
             if (!file)
                 return null;
-            const fileUploadAdapter = getFileAdapter();
-            const url = await fileUploadAdapter.createDownloadURL(file, params?.expires);
+            const url = await services.files.createFileDownloadURL({
+                file,
+                expires: params?.expires,
+                params,
+            });
             if (!url)
                 throw new Error('Could not create download URL');
-            return modules.files.normalizeUrl(url, params);
+            return url;
         }
         catch (e) {
             logger.error(e);

package/lib/resolvers/type/order/order-item-types.d.ts

@@ -1,20 +1,13 @@
 import type { Context } from '../../../context.ts';
-import type { DeliveryProvider } from '@unchainedshop/core-delivery';
 import type { Order } from '@unchainedshop/core-orders';
 import type { OrderPosition, OrderPositionDiscount } from '@unchainedshop/core-orders';
 import type { Product } from '@unchainedshop/core-products';
 import type { Quotation } from '@unchainedshop/core-quotations';
-import type { TokenSurrogate, WarehousingProvider } from '@unchainedshop/core-warehousing';
+import type { TokenSurrogate } from '@unchainedshop/core-warehousing';
 import type { Price } from '@unchainedshop/utils';
 export declare const OrderItem: {
     discounts(orderPosition: OrderPosition, _: any, context: Context): Promise<OrderPositionDiscount[]>;
-    dispatches(orderPosition: OrderPosition, _: never, { modules, loaders }: Context): Promise<{
-        _id: string;
-        deliveryProvider: DeliveryProvider;
-        warehousingProvider: WarehousingProvider;
-        shipping: Date;
-        earliestDelivery: Date;
-    }[] | null>;
+    dispatches(orderPosition: OrderPosition, _: never, { services }: Context): Promise<import("@unchainedshop/core/lib/services/resolveOrderItemDispatches.js").OrderItemDispatch[] | null>;
     order(orderPosition: OrderPosition, _: any, { loaders }: Context): Promise<Order>;
     originalProduct(orderPosition: OrderPosition, _: any, { loaders }: Context): Promise<Product>;
     product(orderPosition: OrderPosition, _: any, { loaders }: Context): Promise<Product>;

package/lib/resolvers/type/order/order-item-types.js

@@ -20,43 +20,8 @@ export const OrderItem = {
         }
         return [];
     },
-    async dispatches(orderPosition, _, { modules, loaders }) {
-        const scheduling = orderPosition.scheduling || [];
-        const order = await loaders.orderLoader.load({
-            orderId: orderPosition.orderId,
-        });
-        const { countryCode, userId } = order;
-        const orderDelivery = order.deliveryId &&
-            (await modules.orders.deliveries.findDelivery({
-                orderDeliveryId: order.deliveryId,
-            }));
-        if (!orderDelivery)
-            return null;
-        const deliveryProvider = await loaders.deliveryProviderLoader.load({
-            deliveryProviderId: orderDelivery.deliveryProviderId,
-        });
-        const product = await loaders.productLoader.load({
-            productId: orderPosition.productId,
-        });
-        if (!deliveryProvider || !product)
-            return null;
-        return Promise.all(scheduling.map(async (schedule) => {
-            const warehousingProvider = await loaders.warehousingProviderLoader.load({
-                warehousingProviderId: schedule.warehousingProviderId,
-            });
-            const context = {
-                warehousingProvider,
-                deliveryProvider,
-                product,
-                quantity: orderPosition.quantity,
-                countryCode,
-                userId,
-            };
-            return {
-                ...context,
-                ...schedule,
-            };
-        }));
+    async dispatches(orderPosition, _, { services }) {
+        return services.orders.resolveOrderItemDispatches({ orderPosition });
     },
     async order(orderPosition, _, { loaders }) {
         return loaders.orderLoader.load({

package/lib/resolvers/type/order/order-statistics-types.d.ts

@@ -2,32 +2,32 @@ import type { Context } from '../../../context.ts';
 export declare const OrderStatistics: {
     newCount: ({ dateRange }: {
         dateRange: any;
-    }, _p: any, { modules }: Context) => Promise<any>;
+    }, _p: any, { modules }: Context) => Promise<number>;
     checkoutCount: ({ dateRange }: {
         dateRange: any;
-    }, _p: any, { modules }: Context) => Promise<any>;
+    }, _p: any, { modules }: Context) => Promise<number>;
     rejectCount: ({ dateRange }: {
         dateRange: any;
-    }, _p: any, { modules }: Context) => Promise<any>;
+    }, _p: any, { modules }: Context) => Promise<number>;
     confirmCount: ({ dateRange }: {
         dateRange: any;
-    }, _p: any, { modules }: Context) => Promise<any>;
+    }, _p: any, { modules }: Context) => Promise<number>;
     fulfillCount: ({ dateRange }: {
         dateRange: any;
-    }, _p: any, { modules }: Context) => Promise<any>;
+    }, _p: any, { modules }: Context) => Promise<number>;
     newRecords: ({ dateRange }: {
         dateRange: any;
-    }, _p: any, { modules }: Context) => Promise<any>;
+    }, _p: any, { modules }: Context) => Promise<import("@unchainedshop/core-orders").OrderStatisticsRecord[]>;
     checkoutRecords: ({ dateRange }: {
         dateRange: any;
-    }, _p: any, { modules }: Context) => Promise<any>;
+    }, _p: any, { modules }: Context) => Promise<import("@unchainedshop/core-orders").OrderStatisticsRecord[]>;
     rejectRecords: ({ dateRange }: {
         dateRange: any;
-    }, _p: any, { modules }: Context) => Promise<any>;
+    }, _p: any, { modules }: Context) => Promise<import("@unchainedshop/core-orders").OrderStatisticsRecord[]>;
     confirmRecords: ({ dateRange }: {
         dateRange: any;
-    }, _p: any, { modules }: Context) => Promise<any>;
+    }, _p: any, { modules }: Context) => Promise<import("@unchainedshop/core-orders").OrderStatisticsRecord[]>;
     fulfilledRecords: ({ dateRange }: {
         dateRange: any;
-    }, _p: any, { modules }: Context) => Promise<any>;
+    }, _p: any, { modules }: Context) => Promise<import("@unchainedshop/core-orders").OrderStatisticsRecord[]>;
 };

package/lib/resolvers/type/order/order-statistics-types.js

@@ -1,66 +1,12 @@
-function buildDateMatch(dateField, dateRange) {
-    if (!dateRange?.start && !dateRange?.end)
-        return { [dateField]: { $exists: true } };
-    const rangeMatch = {};
-    if (dateRange?.start)
-        rangeMatch.$gte = new Date(dateRange.start);
-    if (dateRange?.end)
-        rangeMatch.$lte = new Date(dateRange.end);
-    return { [dateField]: rangeMatch };
-}
-async function aggregateOrders(modules, dateField, dateRange, options) {
-    const match = buildDateMatch(dateField, dateRange);
-    const pipeline = [{ $match: match }];
-    if (options?.includeCarts) {
-        match.status = null;
-        match.orderNumber = null;
-    }
-    if (options?.includeAmount) {
-        pipeline.push({
-            $addFields: {
-                orderTotal: {
-                    $reduce: {
-                        input: { $ifNull: ['$calculation', []] },
-                        initialValue: 0,
-                        in: { $add: ['$$value', { $ifNull: ['$$this.amount', 0] }] },
-                    },
-                },
-            },
-        });
-        pipeline.push({
-            $group: {
-                _id: {
-                    date: { $dateToString: { format: '%Y-%m-%d', date: `$${dateField}` } },
-                    currency: '$currencyCode',
-                },
-                totalAmount: { $sum: '$orderTotal' },
-                count: { $sum: 1 },
-            },
-        });
-        pipeline.push({
-            $project: {
-                _id: 0,
-                date: '$_id.date',
-                total: { amount: '$totalAmount', currencyCode: '$_id.currency' },
-                count: 1,
-            },
-        });
-        pipeline.push({ $sort: { date: 1 } });
-        return modules.orders.aggregateOrders({ pipeline });
-    }
-    pipeline.push({ $count: 'count' });
-    const result = await modules.orders.aggregateOrders({ pipeline });
-    return result[0]?.count ?? 0;
-}
 export const OrderStatistics = {
-    newCount: async ({ dateRange }, _p, { modules }) => aggregateOrders(modules, 'created', dateRange, { includeCarts: true }),
-    checkoutCount: async ({ dateRange }, _p, { modules }) => aggregateOrders(modules, 'ordered', dateRange),
-    rejectCount: async ({ dateRange }, _p, { modules }) => aggregateOrders(modules, 'rejected', dateRange),
-    confirmCount: async ({ dateRange }, _p, { modules }) => aggregateOrders(modules, 'confirmed', dateRange),
-    fulfillCount: async ({ dateRange }, _p, { modules }) => aggregateOrders(modules, 'fullfilled', dateRange),
-    newRecords: async ({ dateRange }, _p, { modules }) => aggregateOrders(modules, 'created', dateRange, { includeAmount: true, includeCarts: true }),
-    checkoutRecords: async ({ dateRange }, _p, { modules }) => aggregateOrders(modules, 'ordered', dateRange, { includeAmount: true }),
-    rejectRecords: async ({ dateRange }, _p, { modules }) => aggregateOrders(modules, 'rejected', dateRange, { includeAmount: true }),
-    confirmRecords: async ({ dateRange }, _p, { modules }) => aggregateOrders(modules, 'confirmed', dateRange, { includeAmount: true }),
-    fulfilledRecords: async ({ dateRange }, _p, { modules }) => aggregateOrders(modules, 'fullfilled', dateRange, { includeAmount: true }),
+    newCount: async ({ dateRange }, _p, { modules }) => modules.orders.statistics.countByDateField('created', dateRange, { includeCarts: true }),
+    checkoutCount: async ({ dateRange }, _p, { modules }) => modules.orders.statistics.countByDateField('ordered', dateRange),
+    rejectCount: async ({ dateRange }, _p, { modules }) => modules.orders.statistics.countByDateField('rejected', dateRange),
+    confirmCount: async ({ dateRange }, _p, { modules }) => modules.orders.statistics.countByDateField('confirmed', dateRange),
+    fulfillCount: async ({ dateRange }, _p, { modules }) => modules.orders.statistics.countByDateField('fullfilled', dateRange),
+    newRecords: async ({ dateRange }, _p, { modules }) => modules.orders.statistics.aggregateByDateField('created', dateRange, { includeCarts: true }),
+    checkoutRecords: async ({ dateRange }, _p, { modules }) => modules.orders.statistics.aggregateByDateField('ordered', dateRange),
+    rejectRecords: async ({ dateRange }, _p, { modules }) => modules.orders.statistics.aggregateByDateField('rejected', dateRange),
+    confirmRecords: async ({ dateRange }, _p, { modules }) => modules.orders.statistics.aggregateByDateField('confirmed', dateRange),
+    fulfilledRecords: async ({ dateRange }, _p, { modules }) => modules.orders.statistics.aggregateByDateField('fullfilled', dateRange),
 };

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

@@ -13,11 +13,5 @@ export declare const PaymentProvider: {
         orderId: any;
         useNetPrice: any;
         context: any;
-    }, requestContext: Context): Promise<{
-        amount: number;
-        currencyCode: string;
-        countryCode: string;
-        isTaxable: boolean;
-        isNetPrice: any;
-    } | null>;
+    }, requestContext: Context): Promise<import("@unchainedshop/core/lib/services/simulatePaymentPricing.js").SimulatedPaymentPrice | null>;
 };

package/lib/resolvers/type/payment/payment-provider-types.js

@@ -1,4 +1,4 @@
-import { PaymentDirector, PaymentPricingDirector, } from '@unchainedshop/core';
+import { PaymentDirector } from '@unchainedshop/core';
 export const PaymentProvider = {
     interface(provider) {
         const Adapter = PaymentDirector.getAdapter(provider.adapterKey);
@@ -19,28 +19,18 @@ export const PaymentProvider = {
         return adapter.isActive();
     },
     async simulatedPrice(paymentProvider, { currencyCode: forcedCurrencyCode, orderId, useNetPrice, context: providerContext }, requestContext) {
-        const { loaders, countryCode, user } = requestContext;
-        const order = await loaders.orderLoader.load({ orderId });
+        const { loaders, services, countryCode, user } = requestContext;
+        if (!user)
+            return null;
+        const order = orderId ? await loaders.orderLoader.load({ orderId }) : undefined;
         const currencyCode = forcedCurrencyCode || order?.currencyCode || requestContext.currencyCode;
-        const pricingContext = {
+        return services.payment.simulatePaymentPricing({
             countryCode,
             currencyCode,
             provider: paymentProvider,
             order,
             providerContext,
             user,
-        };
-        const calculated = await PaymentPricingDirector.rebuildCalculation(pricingContext, requestContext);
-        if (!calculated || !calculated.length)
-            return null;
-        const pricing = PaymentPricingDirector.calculationSheet(pricingContext, calculated);
-        const orderPrice = pricing.total({ useNetPrice });
-        return {
-            amount: orderPrice.amount,
-            currencyCode: orderPrice.currencyCode,
-            countryCode,
-            isTaxable: pricing.taxSum() > 0,
-            isNetPrice: useNetPrice,
-        };
+        }, { useNetPrice });
     },
 };

package/lib/resolvers/type/price-types.d.ts

@@ -3,7 +3,6 @@ export interface PriceType {
     isNetPrice?: boolean;
     countryCode?: string;
     currencyCode?: string;
-    currency?: string;
     amount: number;
 }
 export declare const Price: {

package/lib/resolvers/type/product/product-bundle-types.d.ts

@@ -47,7 +47,7 @@ export declare const BundleProduct: {
         limit: number;
         offset: number;
         includeInactive: boolean;
-    }, { modules }: import("../../../context.ts").Context): Promise<(typeof product)[]>;
+    }, { services }: import("../../../context.ts").Context): Promise<(typeof product)[]>;
     status(product: import("@unchainedshop/core-products").Product, _: any, { modules }: import("../../../context.ts").Context): import("@unchainedshop/core-products").ProductStatus;
     texts(product: import("@unchainedshop/core-products").Product, { forceLocale, }: {
         forceLocale?: string;

package/lib/resolvers/type/product/product-configurable-types.d.ts

@@ -54,7 +54,7 @@ export declare const ConfigurableProduct: {
         limit: number;
         offset: number;
         includeInactive: boolean;
-    }, { modules }: Context): Promise<(typeof product)[]>;
+    }, { services }: Context): Promise<(typeof product)[]>;
     status(product: ProductType, _: any, { modules }: Context): import("@unchainedshop/core-products").ProductStatus;
     texts(product: ProductType, { forceLocale, }: {
         forceLocale?: string;

package/lib/resolvers/type/product/product-configurable-types.js

@@ -27,40 +27,17 @@ export const ConfigurableProduct = {
         });
     },
     async simulatedPriceRange(product, { currencyCode: forcedCurrencyCode, quantity, useNetPrice, vectors, includeInactive, }, requestContext) {
-        const { countryCode, modules, services } = requestContext;
+        const { countryCode, services } = requestContext;
         const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
-        const products = await modules.products.proxyProducts(product, vectors, {
+        return services.products.simulateConfigurablePriceRange({
+            product,
+            currencyCode,
+            countryCode,
+            quantity,
+            useNetPrice,
+            vectors,
             includeInactive,
+            user: requestContext.user,
         });
-        const filteredPrices = (await Promise.all(products.map(async (proxyProduct) => {
-            const pricingContext = {
-                product: proxyProduct,
-                user: requestContext.user,
-                countryCode,
-                discounts: [],
-                currencyCode,
-                quantity: quantity || 1,
-            };
-            const pricing = await services.products.simulateProductPricing(pricingContext);
-            if (!pricing)
-                return null;
-            const unitPrice = pricing.unitPrice({ useNetPrice });
-            return {
-                ...unitPrice,
-                isNetPrice: useNetPrice,
-                isTaxable: pricing.taxSum() > 0,
-                currencyCode: pricing.currencyCode,
-            };
-        }))).filter(Boolean);
-        if (!filteredPrices.length)
-            return null;
-        const { minPrice, maxPrice } = modules.products.prices.priceRange({
-            productId: product._id,
-            prices: filteredPrices,
-        });
-        return {
-            minPrice,
-            maxPrice,
-        };
     },
 };

package/lib/resolvers/type/product/product-plan-types.d.ts

@@ -47,7 +47,7 @@ export declare const PlanProduct: {
         limit: number;
         offset: number;
         includeInactive: boolean;
-    }, { modules }: Context): Promise<(typeof product)[]>;
+    }, { services }: Context): Promise<(typeof product)[]>;
     status(product: ProductType, _: any, { modules }: Context): import("@unchainedshop/core-products").ProductStatus;
     texts(product: ProductType, { forceLocale, }: {
         forceLocale?: string;

package/lib/resolvers/type/product/product-simple-types.d.ts

@@ -77,7 +77,7 @@ export declare const SimpleProduct: {
         limit: number;
         offset: number;
         includeInactive: boolean;
-    }, { modules }: Context): Promise<(typeof product)[]>;
+    }, { services }: Context): Promise<(typeof product)[]>;
     status(product: Product, _: any, { modules }: Context): import("@unchainedshop/core-products").ProductStatus;
     texts(product: Product, { forceLocale, }: {
         forceLocale?: string;

package/lib/resolvers/type/product/product-tokenized-types.d.ts

@@ -61,7 +61,7 @@ export declare const TokenizedProduct: {
         limit: number;
         offset: number;
         includeInactive: boolean;
-    }, { modules }: Context): Promise<(typeof product)[]>;
+    }, { services }: Context): Promise<(typeof product)[]>;
     status(product: Product, _: any, { modules }: Context): import("@unchainedshop/core-products").ProductStatus;
     texts(product: Product, { forceLocale, }: {
         forceLocale?: string;

package/lib/resolvers/type/product/product-types.d.ts

@@ -31,7 +31,7 @@ export declare const Product: {
         limit: number;
         offset: number;
         includeInactive: boolean;
-    }, { modules }: Context): Promise<(typeof product)[]>;
+    }, { services }: Context): Promise<(typeof product)[]>;
     status(product: IProduct, _: any, { modules }: Context): ProductStatus;
     texts(product: IProduct, { forceLocale, }: {
         forceLocale?: string;

package/lib/resolvers/type/product/product-types.js

@@ -50,23 +50,13 @@ export const Product = {
     async reviewsCount(product, params, { modules }) {
         return modules.products.reviews.count({ ...params, productId: product._id });
     },
-    async siblings(product, params, { modules }) {
-        const { assortmentId, limit, offset, includeInactive = false } = params;
-        const productId = product._id;
-        const assortmentIds = assortmentId
-            ? [assortmentId]
-            : await modules.assortments.products.findAssortmentIds({ productId });
-        if (!assortmentIds.length)
-            return [];
-        const productIds = await modules.assortments.products.findSiblings({
-            productId,
-            assortmentIds,
-        });
-        return modules.products.findProducts({
-            productIds,
-            includeDrafts: includeInactive,
-            limit,
-            offset,
+    async siblings(product, params, { services }) {
+        return services.products.findProductSiblings({
+            product,
+            assortmentId: params.assortmentId,
+            limit: params.limit,
+            offset: params.offset,
+            includeInactive: params.includeInactive,
         });
     },
     status(product, _, { modules }) {