@unchainedshop/api 3.0.0-alpha7 → 3.0.0-rc10

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

@@ -1,5 +1,5 @@
 import { Product, ProductBundleItem as ProductBundleItemType } from '@unchainedshop/core-products';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 export interface ProductBundleItemHelperTypes {
   product: (bundleItem: ProductBundleItemType, _: never, context: Context) => Promise<Product>;

package/src/resolvers/type/product/product-catalog-price-types.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 '../../../types.js';
+import { Context } from '../../../context.js';
 
 export type ProductCatalogHelperType<P, T> = (
   productPrice: ProductPrice,

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

@@ -3,9 +3,9 @@ import {
   ProductAssignment,
   ProductConfiguration,
   ProductPriceRange,
+  ProductVariation,
 } from '@unchainedshop/core-products';
-import { Context } from '@unchainedshop/api';
-import { ProductVariation } from '@unchainedshop/core-products';
+import { Context } from '../../../context.js';
 import { Product } from './product-types.js';
 
 export const ConfigurableProduct = {
@@ -103,21 +103,48 @@ export const ConfigurableProduct = {
     },
     requestContext: Context,
   ): Promise<ProductPriceRange> {
-    const { countryContext, modules } = requestContext;
+    const { countryContext, modules, services } = requestContext;
     const currency = forcedCurrencyCode || requestContext.currencyContext;
 
-    return modules.products.prices.simulatedPriceRange(
-      product,
-      {
-        quantity,
-        currency,
-        userId: requestContext.userId,
-        country: countryContext,
-        useNetPrice,
-        vectors,
-        includeInactive,
-      },
-      requestContext,
-    );
+    const products = await modules.products.proxyProducts(product, vectors, {
+      includeInactive,
+    });
+
+    const filteredPrices = (
+      await Promise.all(
+        products.map(async (proxyProduct) => {
+          const pricingContext = {
+            product: proxyProduct,
+            user: requestContext.user,
+            country: countryContext,
+            currency,
+            quantity,
+          };
+
+          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.currency,
+          };
+        }),
+      )
+    ).filter(Boolean);
+
+    if (!filteredPrices.length) return null;
+
+    const { minPrice, maxPrice } = modules.products.prices.priceRange({
+      productId: product._id as string,
+      prices: filteredPrices,
+    });
+
+    return {
+      minPrice,
+      maxPrice,
+    };
   },
 };

package/src/resolvers/type/product/product-discount.ts

@@ -1,47 +1,23 @@
-import crypto from 'crypto';
-import { Context } from '@unchainedshop/api';
 import { ProductDiscount as ProductDiscountType } from '@unchainedshop/core-products';
+import { ProductDiscountDirector } from '@unchainedshop/core';
 
-type HelperType<T> = (product: ProductDiscountType, _: never, context: Context) => T;
-
-export interface ProductDiscountHelperTypes {
-  interface: HelperType<
-    Promise<{
-      _id: string;
-      label: string;
-      version: string;
-      isManualAdditionAllowed: boolean;
-      isManualRemovalAllowed: boolean;
-    } | null>
-  >;
-  total: HelperType<{
-    _id: string;
-    amount: number;
-    currency: string;
-  } | null>;
-}
-
-export const ProductDiscount: ProductDiscountHelperTypes = {
-  interface: async (obj, _, { modules }) => {
-    const Interface = modules.products.interface(obj);
+export const ProductDiscount = {
+  interface: async (productDiscount: ProductDiscountType) => {
+    const Interface = ProductDiscountDirector.getAdapter(productDiscount.discountKey);
     if (!Interface) return null;
     return {
       _id: Interface.key,
       label: Interface.label,
       version: Interface.version,
-      isManualAdditionAllowed: await Interface.isManualAdditionAllowed(obj.code),
+      isManualAdditionAllowed: await Interface.isManualAdditionAllowed(productDiscount.code),
       isManualRemovalAllowed: await Interface.isManualRemovalAllowed(),
     };
   },
 
-  total: (obj) => {
-    const { total } = obj;
-    if (total) {
+  total(productDiscount: ProductDiscountType) {
+    const { total } = productDiscount;
+    if (productDiscount.total) {
       return {
-        _id: crypto
-          .createHash('sha256')
-          .update([`${obj._id}`, total.amount, total.currency].join(''))
-          .digest('hex'),
         amount: total.amount,
         currency: total.currency,
       };

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

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { File } from '@unchainedshop/core-files';
 import { ProductMedia as ProductMediaType, ProductMediaText } from '@unchainedshop/core-products';
 

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

@@ -3,7 +3,7 @@ import {
   ProductPrice,
   Product as ProductType,
 } from '@unchainedshop/core-products';
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { Product } from './product-types.js';
 
 export const PlanProduct = {
@@ -38,21 +38,28 @@ export const PlanProduct = {
     },
     requestContext: Context,
   ): Promise<ProductPrice> {
-    const { countryContext, modules } = requestContext;
+    const { countryContext, user, services } = requestContext;
     const currency = forcedCurrencyCode || requestContext.currencyContext;
 
-    return modules.products.prices.userPrice(
-      obj,
-      {
-        quantity,
-        userId: requestContext.userId,
-        currency,
-        country: countryContext,
-        useNetPrice,
-        configuration,
-      },
-      requestContext,
-    );
+    const pricingContext = {
+      product: obj,
+      user,
+      country: countryContext,
+      currency,
+      quantity,
+      configuration,
+    };
+
+    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.currency,
+    };
   },
 
   async leveledCatalogPrices(

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

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { Product } from '@unchainedshop/core-products';
 import {
   ProductReview as ProductReviewType,

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

@@ -1,9 +1,9 @@
 import { Product, ProductSupply } from '@unchainedshop/core-products';
-import { WarehousingContext, WarehousingProvider } from '@unchainedshop/core-warehousing';
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { DeliveryProviderType } from '@unchainedshop/core-delivery';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { PlanProduct } from './product-plan-types.js';
+import { WarehousingProvider } from '@unchainedshop/core-warehousing';
 
 export const SimpleProduct = {
   ...PlanProduct,
@@ -14,56 +14,23 @@ export const SimpleProduct = {
     requestContext: Context,
   ): Promise<
     Array<{
-      _id: string;
       deliveryProvider?: DeliveryProvider;
       warehousingProvider?: WarehousingProvider;
       shipping?: Date;
       earliestDelivery?: Date;
     }>
   > {
-    const { deliveryProviderType, referenceDate, quantity } = params;
-    const { modules } = requestContext;
+    const { referenceDate, quantity } = params;
+    const { services, modules } = requestContext;
 
-    const deliveryProviders = await modules.delivery.findProviders({
-      type: deliveryProviderType,
-    });
-
-    return deliveryProviders.reduce(async (oldResult, deliveryProvider) => {
-      const result = await oldResult;
-
-      const warehousingProviders = await modules.warehousing.findSupported(
-        {
-          product: obj,
-          deliveryProvider,
-        },
-        requestContext,
-      );
-
-      const mappedWarehousingProviders = await Promise.all(
-        warehousingProviders.map(async (warehousingProvider) => {
-          const warehousingContext: WarehousingContext = {
-            deliveryProvider,
-            product: obj,
-            quantity,
-            referenceDate,
-          };
-
-          const dispatch = await modules.warehousing.estimatedDispatch(
-            warehousingProvider,
-            warehousingContext,
-            requestContext,
-          );
-
-          return {
-            warehousingProvider,
-            ...warehousingContext,
-            ...dispatch,
-          };
-        }),
-      );
+    const deliveryProviders = await modules.delivery.findProviders({});
 
-      return result.concat(result, mappedWarehousingProviders);
-    }, Promise.resolve([]));
+    return services.products.simulateProductDispatching({
+      deliveryProviders,
+      product: obj,
+      quantity,
+      referenceDate,
+    });
   },
 
   async simulatedStocks(
@@ -75,54 +42,23 @@ export const SimpleProduct = {
     requestContext: Context,
   ): Promise<
     Array<{
-      _id: string;
       deliveryProvider?: DeliveryProvider;
       warehousingProvider?: WarehousingProvider;
       quantity?: number;
     }>
   > {
-    const { modules } = requestContext;
+    const { modules, services } = requestContext;
     const { referenceDate, deliveryProviderType } = params;
 
     const deliveryProviders = await modules.delivery.findProviders({
       type: deliveryProviderType,
     });
 
-    return deliveryProviders.reduce(async (oldResult, deliveryProvider) => {
-      const result = await oldResult;
-
-      const warehousingProviders = await modules.warehousing.findSupported(
-        {
-          product: obj,
-          deliveryProvider,
-        },
-        requestContext,
-      );
-
-      const mappedWarehousingProviders = await Promise.all(
-        warehousingProviders.map(async (warehousingProvider) => {
-          const warehousingContext: WarehousingContext = {
-            deliveryProvider,
-            product: obj,
-            referenceDate,
-          };
-
-          const stock = await modules.warehousing.estimatedStock(
-            warehousingProvider,
-            warehousingContext,
-            requestContext,
-          );
-
-          return {
-            warehousingProvider,
-            ...warehousingContext,
-            ...stock,
-          };
-        }),
-      );
-
-      return result.concat(result, mappedWarehousingProviders);
-    }, Promise.resolve([]));
+    return services.products.simulateProductInventory({
+      deliveryProviders,
+      product: obj,
+      referenceDate,
+    });
   },
 
   baseUnit({ warehousing }): string {

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

@@ -3,9 +3,10 @@ import {
   ProductContractConfiguration,
   ProductContractStandard,
 } from '@unchainedshop/core-products';
-import { WarehousingContext, WarehousingProvider } from '@unchainedshop/core-warehousing';
-import { Context } from '@unchainedshop/api';
+import { WarehousingProvider } from '@unchainedshop/core-warehousing';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
+
+import { Context } from '../../../context.js';
 import { PlanProduct } from './product-plan-types.js';
 import { checkAction } from '../../../acl.js';
 import { actions } from '../../../roles/index.js';
@@ -38,52 +39,21 @@ export const TokenizedProduct = {
     requestContext: Context,
   ): Promise<
     Array<{
-      _id: string;
       deliveryProvider?: DeliveryProvider;
       warehousingProvider?: WarehousingProvider;
       quantity?: number;
     }>
   > {
-    const { modules } = requestContext;
+    const { modules, services } = requestContext;
     const { referenceDate } = params;
 
     const deliveryProviders = await modules.delivery.findProviders({});
 
-    return deliveryProviders.reduce(async (oldResult, deliveryProvider) => {
-      const result = await oldResult;
-
-      const warehousingProviders = await modules.warehousing.findSupported(
-        {
-          product: obj,
-          deliveryProvider,
-        },
-        requestContext,
-      );
-
-      const mappedWarehousingProviders = await Promise.all(
-        warehousingProviders.map(async (warehousingProvider) => {
-          const warehousingContext: WarehousingContext = {
-            deliveryProvider,
-            product: obj,
-            referenceDate,
-          };
-
-          const stock = await modules.warehousing.estimatedStock(
-            warehousingProvider,
-            warehousingContext,
-            requestContext,
-          );
-
-          return {
-            warehousingProvider,
-            ...warehousingContext,
-            ...stock,
-          };
-        }),
-      );
-
-      return result.concat(result, mappedWarehousingProviders);
-    }, Promise.resolve([]));
+    return services.products.simulateProductInventory({
+      deliveryProviders,
+      product: obj,
+      referenceDate,
+    });
   },
 
   async tokens(product: Product, params: never, requestContext: Context) {

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

@@ -5,7 +5,7 @@ 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 '../../../types.js';
+import { Context } from '../../../context.js';
 
 export const Product = {
   __resolveType: (product: ProductType): string => {
@@ -37,12 +37,18 @@ export const Product = {
       offset: number;
       tags?: Array<string>;
     },
-    { modules }: Context,
+    { loaders, modules }: Context,
   ): Promise<Array<ProductMedia>> {
-    return modules.products.media.findProductMedias({
-      productId: product._id,
-      ...params,
-    });
+    if (params.offset || params.tags) {
+      return modules.products.media.findProductMedias({
+        productId: product._id,
+        ...params,
+      });
+    }
+    return (await loaders.productMediasLoader.load({ productId: product._id })).slice(
+      params.offset,
+      params.offset + params.limit,
+    );
   },
 
   async reviews(

package/src/resolvers/type/product/product-variation-assignment-types.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { Product, ProductAssignment, ProductConfiguration } from '@unchainedshop/core-products';
 
 export type AssignmentHelperType<T> = (

package/src/resolvers/type/product/product-variation-assignment-vector.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { Product, ProductConfiguration } from '@unchainedshop/core-products';
 import { ProductVariation } from '@unchainedshop/core-products';
 

package/src/resolvers/type/product/product-variation-option-types.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { ProductVariationText } from '@unchainedshop/core-products';
 
 export type OptionHelperType<P, T> = (

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

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import {
   ProductVariation as ProductVariationType,
   ProductVariationText,

package/src/resolvers/type/product-search-result-types.ts

@@ -0,0 +1,69 @@
+import { Context } from '../../context.js';
+import { SearchConfiguration } from '@unchainedshop/core-filters';
+
+type SearchResultData = {
+  searchConfiguration: SearchConfiguration & { productSelector: any };
+  totalProductIds: Array<string>;
+  aggregatedTotalProductIds: Array<string>;
+  aggregatedFilteredProductIds: Array<string>;
+};
+
+export const ProductSearchResult = {
+  productsCount: async (
+    { searchConfiguration, aggregatedTotalProductIds }: SearchResultData,
+    _: never,
+    context: Context,
+  ) => {
+    if (aggregatedTotalProductIds?.length < 1) return 0;
+
+    const { modules } = context;
+    return modules.products.search.countFilteredProducts({
+      productSelector: searchConfiguration.productSelector,
+      productIds: aggregatedTotalProductIds,
+    });
+  },
+
+  filteredProductsCount: async (
+    { searchConfiguration, aggregatedFilteredProductIds }: SearchResultData,
+    _: never,
+    context: Context,
+  ) => {
+    if (aggregatedFilteredProductIds?.length < 1) return 0;
+
+    const { modules } = context;
+    return modules.products.search.countFilteredProducts({
+      productSelector: searchConfiguration.productSelector,
+      productIds: aggregatedFilteredProductIds,
+    });
+  },
+
+  products: async (
+    { searchConfiguration, aggregatedFilteredProductIds }: SearchResultData,
+    { offset, limit },
+    context: Context,
+  ) => {
+    if (aggregatedFilteredProductIds?.length < 1) return [];
+
+    const { modules } = context;
+    return modules.products.search.findFilteredProducts({
+      limit,
+      offset,
+      productIds: aggregatedFilteredProductIds,
+      productSelector: searchConfiguration.productSelector,
+      sort: searchConfiguration.sortStage,
+    });
+  },
+
+  async filters({ searchConfiguration, totalProductIds }: SearchResultData, _: never, context: Context) {
+    const { modules, services } = context;
+    const relevantProductIds = await modules.products.findProductIds({
+      productSelector: searchConfiguration.productSelector,
+      productIds: totalProductIds,
+      includeDrafts: searchConfiguration.searchQuery.includeInactive,
+    });
+    return services.filters.loadFilters(searchConfiguration.searchQuery, {
+      productIds: relevantProductIds,
+      forceLiveCollection: searchConfiguration.forceLiveCollection,
+    });
+  },
+};

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

@@ -1,5 +1,5 @@
 import { Quotation as QuotationType } from '@unchainedshop/core-quotations';
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../context.js';
 import { User } from '@unchainedshop/core-users';
 import { Product } from '@unchainedshop/core-products';
 import { Country } from '@unchainedshop/core-countries';

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

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../context.js';
 import { Country } from '@unchainedshop/core-countries';
 import { Language } from '@unchainedshop/core-languages';
 import { checkAction } from '../../acl.js';

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

@@ -1,8 +1,9 @@
-import { Context } from '@unchainedshop/api';
-import { TokenStatus, TokenSurrogate } from '@unchainedshop/core-warehousing';
+import { Context } from '../../context.js';
+import { TokenSurrogate, TokenStatus, WarehousingProviderType } from '@unchainedshop/core-warehousing';
 import { WorkStatus } from '@unchainedshop/core-worker';
 import { checkAction } from '../../acl.js';
 import { actions } from '../../roles/index.js';
+import { WarehousingDirector } from '@unchainedshop/core';
 
 export const Token = {
   product: async (token: TokenSurrogate, params: never, { modules }: Context) => {
@@ -33,28 +34,38 @@ export const Token = {
   ) => {
     const { modules } = context;
     const product = await modules.products.findProduct({ productId: token.productId });
-    const ercMetadata = await modules.warehousing.tokenMetadata(
-      token.chainTokenId,
+
+    const virtualProviders = await context.modules.warehousing.findProviders({
+      type: WarehousingProviderType.VIRTUAL,
+    });
+
+    return WarehousingDirector.tokenMetadata(
+      virtualProviders,
       {
-        token,
         product,
-        locale: new Intl.Locale(forceLocale),
+        token,
+        locale: forceLocale ? new Intl.Locale(forceLocale) : context.localeContext,
+        quantity: token?.quantity || 1,
         referenceDate: new Date(),
       },
       context,
     );
-
-    return ercMetadata;
   },
 
   isInvalidateable: async (token: TokenSurrogate, _params: never, context: Context) => {
     const { modules } = context;
     const product = await modules.products.findProduct({ productId: token.productId });
-    const isInvalidateable = await modules.warehousing.isInvalidateable(
-      token.chainTokenId,
+
+    const virtualProviders = await context.modules.warehousing.findProviders({
+      type: WarehousingProviderType.VIRTUAL,
+    });
+
+    const isInvalidateable = await WarehousingDirector.isInvalidateable(
+      virtualProviders,
       {
         token,
         product,
+        quantity: token?.quantity || 1,
         referenceDate: new Date(),
       },
       context,