@unchainedshop/api 4.3.6 → 4.4.0

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

@@ -48,7 +48,6 @@ async function aggregateOrders(modules, dateField, dateRange, options) {
         pipeline.push({ $sort: { date: 1 } });
         return modules.orders.aggregateOrders({ pipeline });
     }
-    // Just count total orders
     pipeline.push({ $count: 'count' });
     const result = await modules.orders.aggregateOrders({ pipeline });
     return result[0]?.count ?? 0;
@@ -65,4 +64,3 @@ export const OrderStatistics = {
     confirmRecords: async ({ dateRange }, _p, { modules }) => aggregateOrders(modules, 'confirmed', dateRange, { includeAmount: true }),
     fulfilledRecords: async ({ dateRange }, _p, { modules }) => aggregateOrders(modules, 'fullfilled', dateRange, { includeAmount: true }),
 };
-//# sourceMappingURL=order-statistics-types.js.map

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

@@ -1,11 +1,11 @@
-import { Context } from '../../../context.js';
-import { Country } from '@unchainedshop/core-countries';
-import { Currency } from '@unchainedshop/core-currencies';
-import { DeliveryProvider } from '@unchainedshop/core-delivery';
-import { Enrollment } from '@unchainedshop/core-enrollments';
-import { Order as OrderType, OrderPosition, OrderPayment, OrderDiscount, OrderDelivery } from '@unchainedshop/core-orders';
-import { User } from '@unchainedshop/core-users';
-import { Price } from '@unchainedshop/utils';
+import type { Context } from '../../../context.ts';
+import type { Country } from '@unchainedshop/core-countries';
+import type { Currency } from '@unchainedshop/core-currencies';
+import type { DeliveryProvider } from '@unchainedshop/core-delivery';
+import type { Enrollment } from '@unchainedshop/core-enrollments';
+import type { Order as OrderType, OrderPosition, OrderPayment, OrderDiscount, OrderDelivery } from '@unchainedshop/core-orders';
+import type { User } from '@unchainedshop/core-users';
+import type { Price } from '@unchainedshop/utils';
 export declare const Order: {
     supportedDeliveryProviders(order: OrderType, _: any, context: Context): Promise<DeliveryProvider[]>;
     supportedPaymentProviders(order: OrderType, _: any, context: Context): Promise<import("@unchainedshop/core-payment").PaymentProvider[]>;
@@ -23,4 +23,3 @@ export declare const Order: {
     }): Price | null;
     user(order: OrderType, _: any, { loaders }: Context): Promise<User>;
 };
-//# sourceMappingURL=order-types.d.ts.map

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

@@ -21,9 +21,9 @@ export const Order = {
     },
     async delivery(order, _, { modules }) {
         const orderDelivery = order.deliveryId &&
-            modules.orders.deliveries.findDelivery({
+            (await modules.orders.deliveries.findDelivery({
                 orderDeliveryId: order.deliveryId,
-            });
+            }));
         if (!orderDelivery)
             return null;
         return orderDelivery;
@@ -70,4 +70,3 @@ export const Order = {
         return loaders.userLoader.load({ userId: order.userId });
     },
 };
-//# sourceMappingURL=order-types.js.map

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

@@ -1,6 +1,6 @@
-import { Context } from '../../../context.js';
-import { PaymentCredentials as PaymentCredentialsType, PaymentProvider } from '@unchainedshop/core-payment';
-import { User } from '@unchainedshop/core-users';
+import type { Context } from '../../../context.ts';
+import type { PaymentCredentials as PaymentCredentialsType, PaymentProvider } from '@unchainedshop/core-payment';
+import type { User } from '@unchainedshop/core-users';
 export type HelperType<P, T> = (credentials: PaymentCredentialsType, params: P, context: Context) => T;
 export interface PaymentCredentialsHelperTypes {
     user: HelperType<never, Promise<User>>;
@@ -8,4 +8,3 @@ export interface PaymentCredentialsHelperTypes {
     isValid: HelperType<never, Promise<boolean>>;
 }
 export declare const PaymentCredentials: PaymentCredentialsHelperTypes;
-//# sourceMappingURL=payment-credentials-types.d.ts.map

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

@@ -17,4 +17,3 @@ export const PaymentCredentials = {
         return actions.validate();
     },
 };
-//# sourceMappingURL=payment-credentials-types.js.map

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

@@ -1,5 +1,5 @@
-import { Context } from '../../../context.js';
-import { PaymentProvider as PaymentProviderType } from '@unchainedshop/core-payment';
+import type { Context } from '../../../context.ts';
+import type { PaymentProvider as PaymentProviderType } from '@unchainedshop/core-payment';
 export declare const PaymentProvider: {
     interface(provider: PaymentProviderType): {
         _id: string;
@@ -21,4 +21,3 @@ export declare const PaymentProvider: {
         isNetPrice: any;
     } | null>;
 };
-//# sourceMappingURL=payment-provider-types.d.ts.map

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

@@ -1,4 +1,4 @@
-import { PaymentDirector, PaymentPricingDirector } from '@unchainedshop/core';
+import { PaymentDirector, PaymentPricingDirector, } from '@unchainedshop/core';
 export const PaymentProvider = {
     interface(provider) {
         const Adapter = PaymentDirector.getAdapter(provider.adapterKey);
@@ -44,4 +44,3 @@ export const PaymentProvider = {
         };
     },
 };
-//# sourceMappingURL=payment-provider-types.js.map

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

@@ -12,4 +12,3 @@ export declare const Price: {
     currencyCode(obj: PriceType): string | undefined;
     amount(obj: PriceType): string | 0;
 };
-//# sourceMappingURL=price-types.d.ts.map

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

@@ -10,27 +10,8 @@ export const Price = {
     },
     amount(obj) {
         if (obj.amount) {
-            /*
-            Why toFixed(0) Is Actually Reliable
-            For integer rounding specifically:
-      
-            Half-values are exact: Numbers like 0.5, 1.5, 2.5 can be represented exactly in binary floating-point (they're powers of 2), so they round correctly.
-            Floating-point errors are tiny: Even with calculation errors, they're usually on the order of 0.0000000001, which won't affect rounding to the nearest integer.
-            Integer boundaries are far apart: Unlike toFixed(2) where the difference between 1.004 and 1.005 matters, for toFixed(0) you need errors approaching 0.5 to cause problems.
-      
-            Theoretical Edge Cases
-            The only cases where toFixed(0) might fail would be:
-            javascript// Extremely contrived calculation that should equal exactly 0.5
-            // but might be 0.49999999999999994 (would round to 0 instead of 1)
-      
-            // Very large numbers where precision is lost entirely
-            (9007199254740992.5).toFixed(0)  // Might have issues past MAX_SAFE_INTEGER
-      
-            // But in practice, these are incredibly rare
-            */
             return Math.round(obj.amount).toFixed(0);
         }
         return 0;
     },
 };
-//# sourceMappingURL=price-types.js.map

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

@@ -1,6 +1,6 @@
-import { Product } from '@unchainedshop/core-products';
-import { Context } from '../../../context.js';
-import { AssortmentPathLink, AssortmentProduct } from '@unchainedshop/core-assortments';
+import type { Product } from '@unchainedshop/core-products';
+import type { Context } from '../../../context.ts';
+import type { AssortmentPathLink, AssortmentProduct } from '@unchainedshop/core-assortments';
 export type HelperType<P, T> = (product: Product, params: P, context: Context) => T;
 export interface ProductAssortmentPathHelperTypes {
     assortmentProduct: (data: {
@@ -10,4 +10,3 @@ export interface ProductAssortmentPathHelperTypes {
     }, _: never, context: Context) => Promise<AssortmentProduct>;
 }
 export declare const ProductAssortmentPath: ProductAssortmentPathHelperTypes;
-//# sourceMappingURL=product-assortment-path-types.d.ts.map

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

@@ -6,4 +6,3 @@ export const ProductAssortmentPath = {
         });
     },
 };
-//# sourceMappingURL=product-assortment-path-types.js.map

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

@@ -1,7 +1,6 @@
-import { Product, ProductBundleItem as ProductBundleItemType } from '@unchainedshop/core-products';
-import { Context } from '../../../context.js';
+import type { Product, ProductBundleItem as ProductBundleItemType } from '@unchainedshop/core-products';
+import type { Context } from '../../../context.ts';
 export interface ProductBundleItemHelperTypes {
     product: (bundleItem: ProductBundleItemType, _: never, context: Context) => Promise<Product>;
 }
 export declare const ProductBundleItem: ProductBundleItemHelperTypes;
-//# sourceMappingURL=product-bundle-item-types.d.ts.map

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

@@ -6,4 +6,3 @@ export const ProductBundleItem = {
         return product;
     },
 };
-//# sourceMappingURL=product-bundle-item-types.js.map

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

@@ -1,19 +1,19 @@
-import { ProductBundleItem } from '@unchainedshop/core-products';
+import type { ProductBundleItem } from '@unchainedshop/core-products';
 export declare const BundleProduct: {
     bundleItems(product: any): ProductBundleItem[];
     catalogPrice(product: import("@unchainedshop/core-products").Product, { quantity, currencyCode: forcedCurrencyCode }: {
         quantity?: number;
         currencyCode?: string;
-    }, requestContext: import("../../../context.js").Context): Promise<import("@unchainedshop/core-products").ProductPrice | null>;
+    }, requestContext: import("../../../context.ts").Context): Promise<import("@unchainedshop/core-products").ProductPrice | null>;
     simulatedPrice(product: import("@unchainedshop/core-products").Product, { currencyCode: forcedCurrencyCode, quantity, useNetPrice, configuration, }: {
         quantity?: number;
         currencyCode?: string;
         useNetPrice?: boolean;
         configuration?: import("@unchainedshop/core-products").ProductConfiguration[];
-    }, requestContext: import("../../../context.js").Context): Promise<import("@unchainedshop/core-products").ProductPrice | null>;
+    }, requestContext: import("../../../context.ts").Context): Promise<import("@unchainedshop/core-products").ProductPrice | null>;
     leveledCatalogPrices(product: import("@unchainedshop/core-products").Product, { currencyCode: forcedCurrencyCode }: {
         currencyCode?: string;
-    }, requestContext: import("../../../context.js").Context): Promise<{
+    }, requestContext: import("../../../context.ts").Context): Promise<{
         minQuantity: number;
         maxQuantity: number;
         price: import("@unchainedshop/core-products").ProductPrice;
@@ -22,35 +22,34 @@ export declare const BundleProduct: {
     salesQuantityPerUnit({ commerce }: import("@unchainedshop/core-products").Product): string | null;
     defaultOrderQuantity({ commerce }: import("@unchainedshop/core-products").Product): number | null;
     __resolveType: (product: import("@unchainedshop/core-products").Product) => string;
-    proxies(product: import("@unchainedshop/core-products").Product, _: never, context: import("../../../context.js").Context): Promise<import("@unchainedshop/core-products").Product[]>;
+    proxies(product: import("@unchainedshop/core-products").Product, _: never, context: import("../../../context.ts").Context): Promise<import("@unchainedshop/core-products").Product[]>;
     assortmentPaths(product: import("@unchainedshop/core-products").Product, params: {
         forceLocale?: string;
-    }, { modules, loaders }: import("../../../context.js").Context): Promise<{
+    }, { modules, loaders }: import("../../../context.ts").Context): Promise<{
         links: import("@unchainedshop/core-assortments").AssortmentPathLink[];
     }[]>;
     media(product: import("@unchainedshop/core-products").Product, params: {
         limit: number;
         offset: number;
         tags?: string[];
-    }, { loaders, modules }: import("../../../context.js").Context): Promise<import("@unchainedshop/core-products").ProductMedia[]>;
+    }, { loaders, modules }: import("../../../context.ts").Context): Promise<import("@unchainedshop/core-products").ProductMedia[]>;
     reviews(product: import("@unchainedshop/core-products").Product, { limit, offset, sort, queryString, }: {
         queryString?: string;
         limit?: number;
         offset?: number;
         sort?: import("@unchainedshop/utils").SortOption[];
-    }, { modules }: import("../../../context.js").Context): Promise<import("@unchainedshop/core-products").ProductReview[]>;
+    }, { modules }: import("../../../context.ts").Context): Promise<import("@unchainedshop/core-products").ProductReview[]>;
     reviewsCount(product: import("@unchainedshop/core-products").Product, params: {
         queryString?: string;
-    }, { modules }: import("../../../context.js").Context): Promise<number>;
+    }, { modules }: import("../../../context.ts").Context): Promise<number>;
     siblings(product: import("@unchainedshop/core-products").Product, params: {
         assortmentId?: string;
         limit: number;
         offset: number;
         includeInactive: boolean;
-    }, { modules }: import("../../../context.js").Context): Promise<(typeof product)[]>;
-    status(product: import("@unchainedshop/core-products").Product, _: any, { modules }: import("../../../context.js").Context): import("@unchainedshop/core-products").ProductStatus;
+    }, { modules }: 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;
-    }, { locale, loaders }: import("../../../context.js").Context): Promise<import("@unchainedshop/core-products").ProductText>;
+    }, { locale, loaders }: import("../../../context.ts").Context): Promise<import("@unchainedshop/core-products").ProductText>;
 };
-//# sourceMappingURL=product-bundle-types.d.ts.map

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

@@ -1,8 +1,7 @@
-import { PlanProduct } from './product-plan-types.js';
+import { PlanProduct } from "./product-plan-types.js";
 export const BundleProduct = {
     ...PlanProduct,
     bundleItems(product) {
         return product.bundleItems ? product.bundleItems : [];
     },
 };
-//# sourceMappingURL=product-bundle-types.js.map

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

@@ -1,7 +1,7 @@
-import { Country } from '@unchainedshop/core-countries';
-import { Currency } from '@unchainedshop/core-currencies';
-import { ProductPrice } from '@unchainedshop/core-products';
-import { Context } from '../../../context.js';
+import type { Country } from '@unchainedshop/core-countries';
+import type { Currency } from '@unchainedshop/core-currencies';
+import type { ProductPrice } from '@unchainedshop/core-products';
+import type { Context } from '../../../context.ts';
 export type ProductCatalogHelperType<P, T> = (productPrice: ProductPrice, params: P, context: Context) => T;
 export interface ProductCatalogPriceHelperTypes {
     isTaxable: ProductCatalogHelperType<never, boolean>;
@@ -10,4 +10,3 @@ export interface ProductCatalogPriceHelperTypes {
     currency: ProductCatalogHelperType<never, Promise<Currency>>;
 }
 export declare const ProductCatalogPrice: ProductCatalogPriceHelperTypes;
-//# sourceMappingURL=product-catalog-price-types.d.ts.map

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

@@ -12,4 +12,3 @@ export const ProductCatalogPrice = {
         return loaders.currencyLoader.load({ isoCode: currencyCode });
     },
 };
-//# sourceMappingURL=product-catalog-price-types.js.map

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

@@ -1,5 +1,4 @@
-import { Product as ProductType } from '@unchainedshop/core-products';
+import { type Product as IProduct } from '@unchainedshop/core-products';
 export declare const ConfigurableOrBundleProduct: {
-    __resolveType: (product: ProductType) => string;
+    __resolveType: (product: IProduct) => string;
 };
-//# sourceMappingURL=product-configurable-or-bundle-product-types.d.ts.map

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

@@ -1,9 +1,17 @@
-import { ProductTypes } from '@unchainedshop/core-products';
-import { objectInvert } from '@unchainedshop/utils';
+import { ProductType } from '@unchainedshop/core-products';
 export const ConfigurableOrBundleProduct = {
     __resolveType: (product) => {
-        const invertedProductTypes = objectInvert(ProductTypes);
-        return invertedProductTypes[product.type];
+        switch (product.type) {
+            case ProductType.CONFIGURABLE_PRODUCT:
+                return 'ConfigurableProduct';
+            case ProductType.BUNDLE_PRODUCT:
+                return 'BundleProduct';
+            case ProductType.PLAN_PRODUCT:
+                return 'PlanProduct';
+            case ProductType.TOKENIZED_PRODUCT:
+                return 'TokenizedProduct';
+            default:
+                return 'SimpleProduct';
+        }
     },
 };
-//# sourceMappingURL=product-configurable-or-bundle-product-types.js.map

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

@@ -1,5 +1,5 @@
-import { Product as ProductType, ProductAssignment, ProductConfiguration, ProductPriceRange, ProductVariation } from '@unchainedshop/core-products';
-import { Context } from '../../../context.js';
+import type { Product as ProductType, ProductAssignment, ProductConfiguration, ProductPriceRange, ProductVariation } from '@unchainedshop/core-products';
+import type { Context } from '../../../context.ts';
 export declare const ConfigurableProduct: {
     assignments(product: ProductType, params: {
         includeInactive: boolean;
@@ -60,4 +60,3 @@ export declare const ConfigurableProduct: {
         forceLocale?: string;
     }, { locale, loaders }: Context): Promise<import("@unchainedshop/core-products").ProductText>;
 };
-//# sourceMappingURL=product-configurable-types.d.ts.map

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

@@ -1,4 +1,4 @@
-import { Product } from './product-types.js';
+import { Product } from "./product-types.js";
 export const ConfigurableProduct = {
     ...Product,
     async assignments(product, params, { modules }) {
@@ -64,4 +64,3 @@ export const ConfigurableProduct = {
         };
     },
 };
-//# sourceMappingURL=product-configurable-types.js.map

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

@@ -1,4 +1,4 @@
-import { ProductDiscount as ProductDiscountType } from '@unchainedshop/core-products';
+import type { ProductDiscount as ProductDiscountType } from '@unchainedshop/core-products';
 export declare const ProductDiscount: {
     interface: (productDiscount: ProductDiscountType) => Promise<{
         _id: string;
@@ -12,4 +12,3 @@ export declare const ProductDiscount: {
         currencyCode: string;
     } | null;
 };
-//# sourceMappingURL=product-discount.d.ts.map

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

@@ -23,4 +23,3 @@ export const ProductDiscount = {
         return null;
     },
 };
-//# sourceMappingURL=product-discount.js.map

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

@@ -1,6 +1,6 @@
-import { Context } from '../../../context.js';
-import { File } from '@unchainedshop/core-files';
-import { ProductMedia as ProductMediaType, ProductMediaText } from '@unchainedshop/core-products';
+import type { Context } from '../../../context.ts';
+import type { File } from '@unchainedshop/core-files';
+import type { ProductMedia as ProductMediaType, ProductMediaText } from '@unchainedshop/core-products';
 export type HelperType<P, T> = (productMedia: ProductMediaType, params: P, context: Context) => T;
 export interface ProductMediaHelperTypes {
     texts: HelperType<{
@@ -9,4 +9,3 @@ export interface ProductMediaHelperTypes {
     file: HelperType<never, Promise<File>>;
 }
 export declare const ProductMedia: ProductMediaHelperTypes;
-//# sourceMappingURL=product-media-types.d.ts.map

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

@@ -13,4 +13,3 @@ export const ProductMedia = {
         });
     },
 };
-//# sourceMappingURL=product-media-types.js.map

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

@@ -1,5 +1,5 @@
-import { ProductConfiguration, ProductPrice, Product as ProductType } from '@unchainedshop/core-products';
-import { Context } from '../../../context.js';
+import type { ProductConfiguration, ProductPrice, Product as ProductType } from '@unchainedshop/core-products';
+import type { Context } from '../../../context.ts';
 export declare const PlanProduct: {
     catalogPrice(product: ProductType, { quantity, currencyCode: forcedCurrencyCode }: {
         quantity?: number;
@@ -53,4 +53,3 @@ export declare const PlanProduct: {
         forceLocale?: string;
     }, { locale, loaders }: Context): Promise<import("@unchainedshop/core-products").ProductText>;
 };
-//# sourceMappingURL=product-plan-types.d.ts.map

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

@@ -1,4 +1,4 @@
-import { Product } from './product-types.js';
+import { Product } from "./product-types.js";
 export const PlanProduct = {
     ...Product,
     async catalogPrice(product, { quantity, currencyCode: forcedCurrencyCode }, requestContext) {
@@ -49,4 +49,3 @@ export const PlanProduct = {
         return commerce?.defaultOrderQuantity || null;
     },
 };
-//# sourceMappingURL=product-plan-types.js.map

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

@@ -1,7 +1,7 @@
-import { Context } from '../../../context.js';
-import { Product } from '@unchainedshop/core-products';
-import { ProductReview as ProductReviewType, ProductReviewVoteType, ProductVote } from '@unchainedshop/core-products';
-import { User } from '@unchainedshop/core-users';
+import type { Context } from '../../../context.ts';
+import type { Product } from '@unchainedshop/core-products';
+import { type ProductReview as ProductReviewType, ProductReviewVoteType, type ProductVote } from '@unchainedshop/core-products';
+import type { User } from '@unchainedshop/core-users';
 type HelperType<P, T> = (product: ProductReviewType, params: P, context: Context) => T;
 export interface ProductReviewHelperTypes {
     author: HelperType<never, Promise<User>>;
@@ -13,4 +13,3 @@ export interface ProductReviewHelperTypes {
 }
 export declare const ProductReview: ProductReviewHelperTypes;
 export {};
-//# sourceMappingURL=product-review-types.d.ts.map

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

@@ -1,3 +1,4 @@
+import { ProductReviewVoteType, } from '@unchainedshop/core-products';
 export const ProductReview = {
     author: async (obj, _, { loaders }) => {
         return loaders.userLoader.load({ userId: obj.authorId });
@@ -15,4 +16,3 @@ export const ProductReview = {
         return modules.products.reviews.votes.userIdsThatVoted(obj, { type }).length;
     },
 };
-//# sourceMappingURL=product-review-types.js.map

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

@@ -1,8 +1,8 @@
-import { Product, ProductSupply } from '@unchainedshop/core-products';
-import { Context } from '../../../context.js';
-import { DeliveryProviderType } from '@unchainedshop/core-delivery';
-import { DeliveryProvider } from '@unchainedshop/core-delivery';
-import { WarehousingProvider } from '@unchainedshop/core-warehousing';
+import type { Product, ProductSupply } from '@unchainedshop/core-products';
+import type { Context } from '../../../context.ts';
+import type { DeliveryProviderType } from '@unchainedshop/core-delivery';
+import type { DeliveryProvider } from '@unchainedshop/core-delivery';
+import type { WarehousingProvider } from '@unchainedshop/core-warehousing';
 export declare const SimpleProduct: {
     simulatedDispatches(obj: Product, params: {
         referenceDate: Date;
@@ -83,4 +83,3 @@ export declare const SimpleProduct: {
         forceLocale?: string;
     }, { locale, loaders }: Context): Promise<import("@unchainedshop/core-products").ProductText>;
 };
-//# sourceMappingURL=product-simple-types.d.ts.map

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

@@ -1,4 +1,4 @@
-import { PlanProduct } from './product-plan-types.js';
+import { PlanProduct } from "./product-plan-types.js";
 export const SimpleProduct = {
     ...PlanProduct,
     async simulatedDispatches(obj, params, requestContext) {
@@ -36,4 +36,3 @@ export const SimpleProduct = {
         };
     },
 };
-//# sourceMappingURL=product-simple-types.js.map

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

@@ -1,7 +1,7 @@
-import { Product, ProductContractConfiguration, ProductContractStandard } from '@unchainedshop/core-products';
-import { WarehousingProvider } from '@unchainedshop/core-warehousing';
-import { DeliveryProvider } from '@unchainedshop/core-delivery';
-import { Context } from '../../../context.js';
+import type { Product, ProductContractConfiguration, ProductContractStandard } from '@unchainedshop/core-products';
+import type { WarehousingProvider } from '@unchainedshop/core-warehousing';
+import type { DeliveryProvider } from '@unchainedshop/core-delivery';
+import type { Context } from '../../../context.ts';
 export declare const TokenizedProduct: {
     contractAddress({ tokenization }: Product): string | null;
     contractConfiguration({ tokenization }: Product): ProductContractConfiguration | null;
@@ -67,4 +67,3 @@ export declare const TokenizedProduct: {
         forceLocale?: string;
     }, { locale, loaders }: Context): Promise<import("@unchainedshop/core-products").ProductText>;
 };
-//# sourceMappingURL=product-tokenized-types.d.ts.map

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

@@ -1,6 +1,6 @@
-import { PlanProduct } from './product-plan-types.js';
-import { checkAction } from '../../../acl.js';
-import { actions } from '../../../roles/index.js';
+import { PlanProduct } from "./product-plan-types.js";
+import { checkAction } from "../../../acl.js";
+import { actions } from "../../../roles/index.js";
 export const TokenizedProduct = {
     ...PlanProduct,
     contractAddress({ tokenization }) {
@@ -43,4 +43,3 @@ export const TokenizedProduct = {
 delete TokenizedProduct.salesUnit;
 delete TokenizedProduct.salesQuantityPerUnit;
 delete TokenizedProduct.defaultOrderQuantity;
-//# sourceMappingURL=product-tokenized-types.js.map

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

@@ -1,41 +1,39 @@
-import { ProductText, Product as ProductType } from '@unchainedshop/core-products';
-import { ProductStatus } from '@unchainedshop/core-products';
-import { SortOption } from '@unchainedshop/utils';
-import { AssortmentPathLink } from '@unchainedshop/core-assortments';
-import { ProductMedia } from '@unchainedshop/core-products';
-import { ProductReview } from '@unchainedshop/core-products';
-import { Context } from '../../../context.js';
+import { type ProductText, ProductStatus, type Product as IProduct } from '@unchainedshop/core-products';
+import type { SortOption } from '@unchainedshop/utils';
+import type { AssortmentPathLink } from '@unchainedshop/core-assortments';
+import type { ProductMedia } from '@unchainedshop/core-products';
+import type { ProductReview } from '@unchainedshop/core-products';
+import type { Context } from '../../../context.ts';
 export declare const Product: {
-    __resolveType: (product: ProductType) => string;
-    proxies(product: ProductType, _: never, context: Context): Promise<ProductType[]>;
-    assortmentPaths(product: ProductType, params: {
+    __resolveType: (product: IProduct) => string;
+    proxies(product: IProduct, _: never, context: Context): Promise<IProduct[]>;
+    assortmentPaths(product: IProduct, params: {
         forceLocale?: string;
     }, { modules, loaders }: Context): Promise<{
         links: AssortmentPathLink[];
     }[]>;
-    media(product: ProductType, params: {
+    media(product: IProduct, params: {
         limit: number;
         offset: number;
         tags?: string[];
     }, { loaders, modules }: Context): Promise<ProductMedia[]>;
-    reviews(product: ProductType, { limit, offset, sort, queryString, }: {
+    reviews(product: IProduct, { limit, offset, sort, queryString, }: {
         queryString?: string;
         limit?: number;
         offset?: number;
         sort?: SortOption[];
     }, { modules }: Context): Promise<ProductReview[]>;
-    reviewsCount(product: ProductType, params: {
+    reviewsCount(product: IProduct, params: {
         queryString?: string;
     }, { modules }: Context): Promise<number>;
-    siblings(product: ProductType, params: {
+    siblings(product: IProduct, params: {
         assortmentId?: string;
         limit: number;
         offset: number;
         includeInactive: boolean;
     }, { modules }: Context): Promise<(typeof product)[]>;
-    status(product: ProductType, _: any, { modules }: Context): ProductStatus;
-    texts(product: ProductType, { forceLocale, }: {
+    status(product: IProduct, _: any, { modules }: Context): ProductStatus;
+    texts(product: IProduct, { forceLocale, }: {
         forceLocale?: string;
     }, { locale, loaders }: Context): Promise<ProductText>;
 };
-//# sourceMappingURL=product-types.d.ts.map

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

@@ -1,9 +1,18 @@
-import { ProductTypes } from '@unchainedshop/core-products';
-import { objectInvert } from '@unchainedshop/utils';
+import { ProductStatus, ProductType, } from '@unchainedshop/core-products';
 export const Product = {
     __resolveType: (product) => {
-        const invertedProductTypes = objectInvert(ProductTypes);
-        return invertedProductTypes[product.type];
+        switch (product.type) {
+            case ProductType.CONFIGURABLE_PRODUCT:
+                return 'ConfigurableProduct';
+            case ProductType.BUNDLE_PRODUCT:
+                return 'BundleProduct';
+            case ProductType.PLAN_PRODUCT:
+                return 'PlanProduct';
+            case ProductType.TOKENIZED_PRODUCT:
+                return 'TokenizedProduct';
+            default:
+                return 'SimpleProduct';
+        }
     },
     async proxies(product, _, context) {
         return context.loaders.productProxiesLoader.load({ productId: product._id });
@@ -70,4 +79,3 @@ export const Product = {
         });
     },
 };
-//# sourceMappingURL=product-types.js.map

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

@@ -1,5 +1,5 @@
-import { Context } from '../../../context.js';
-import { Product, ProductAssignment, ProductConfiguration } from '@unchainedshop/core-products';
+import type { Context } from '../../../context.ts';
+import type { Product, ProductAssignment, ProductConfiguration } from '@unchainedshop/core-products';
 export type AssignmentHelperType<T> = (data: {
     product: Product;
     assignment: ProductAssignment;
@@ -12,4 +12,3 @@ export interface ProductVariationAssignmentHelperTypes {
     product: AssignmentHelperType<Promise<Product>>;
 }
 export declare const ProductVariationAssignment: ProductVariationAssignmentHelperTypes;
-//# sourceMappingURL=product-variation-assignment-types.d.ts.map

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

@@ -16,4 +16,3 @@ export const ProductVariationAssignment = {
         return product;
     },
 };
-//# sourceMappingURL=product-variation-assignment-types.js.map