@unchainedshop/api 3.1.13 → 4.0.0-rc.10

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

@@ -11,41 +11,41 @@ export const PlanProduct = {
 
   async catalogPrice(
     product: ProductType,
-    { quantity, currency: forcedCurrencyCode }: { quantity?: number; currency?: string },
+    { quantity, currencyCode: forcedCurrencyCode }: { quantity?: number; currencyCode?: string },
     requestContext: Context,
   ): Promise<ProductPrice> {
-    const { modules, countryContext } = requestContext;
-    const currency = forcedCurrencyCode || requestContext.currencyContext;
+    const { modules, countryCode } = requestContext;
+    const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
     return modules.products.prices.price(product, {
-      country: countryContext,
-      currency,
+      countryCode,
+      currencyCode,
       quantity,
     });
   },
 
   async simulatedPrice(
-    obj: ProductType,
+    product: ProductType,
     {
-      currency: forcedCurrencyCode,
+      currencyCode: forcedCurrencyCode,
       quantity,
       useNetPrice,
       configuration,
     }: {
       quantity?: number;
-      currency?: string;
+      currencyCode?: string;
       useNetPrice?: boolean;
-      configuration?: Array<ProductConfiguration>;
+      configuration?: ProductConfiguration[];
     },
     requestContext: Context,
   ): Promise<ProductPrice> {
-    const { countryContext, user, services } = requestContext;
-    const currency = forcedCurrencyCode || requestContext.currencyContext;
+    const { countryCode, user, services } = requestContext;
+    const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
 
     const pricingContext = {
-      product: obj,
+      product,
       user,
-      country: countryContext,
-      currency,
+      countryCode,
+      currencyCode,
       quantity,
       configuration,
     };
@@ -58,24 +58,24 @@ export const PlanProduct = {
       ...unitPrice,
       isNetPrice: useNetPrice,
       isTaxable: pricing.taxSum() > 0,
-      currencyCode: pricing.currency,
+      currencyCode: pricing.currencyCode,
     };
   },
 
   async leveledCatalogPrices(
-    obj: ProductType,
-    { currency: forcedCurrencyCode }: { currency?: string },
+    product: ProductType,
+    { currencyCode: forcedCurrencyCode }: { currencyCode?: string },
     requestContext: Context,
   ): Promise<
-    Array<{
+    {
       minQuantity: number;
       maxQuantity: number;
       price: ProductPrice;
-    }>
+    }[]
   > {
-    const { countryContext, modules } = requestContext;
-    const currency = forcedCurrencyCode || requestContext.currencyContext;
-    return modules.products.prices.catalogPricesLeveled(obj, { currency, country: countryContext });
+    const { countryCode, modules } = requestContext;
+    const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
+    return modules.products.prices.catalogPricesLeveled(product, { currencyCode, countryCode });
   },
 
   salesUnit({ commerce }: ProductType): string {

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

@@ -13,12 +13,11 @@ export interface ProductReviewHelperTypes {
   author: HelperType<never, Promise<User>>;
   product: HelperType<never, Promise<Product>>;
   voteCount: HelperType<{ type: ProductReviewVoteType }, number>;
-  ownVotes: HelperType<never, Promise<Array<ProductVote>>>;
+  ownVotes: HelperType<never, Promise<ProductVote[]>>;
 }
 export const ProductReview: ProductReviewHelperTypes = {
-  author: async (obj, _, { modules }) => {
-    // TODO: use loader
-    return modules.users.findUserById(obj.authorId);
+  author: async (obj, _, { loaders }) => {
+    return loaders.userLoader.load({ userId: obj.authorId });
   },
 
   product: async (review, _, { loaders }) => {

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

@@ -13,21 +13,16 @@ export const SimpleProduct = {
     params: { referenceDate: Date; quantity: number; deliveryProviderType: DeliveryProviderType },
     requestContext: Context,
   ): Promise<
-    Array<{
+    {
       deliveryProvider?: DeliveryProvider;
       warehousingProvider?: WarehousingProvider;
       shipping?: Date;
       earliestDelivery?: Date;
-    }>
+    }[]
   > {
     const { referenceDate, quantity } = params;
-    const { services, modules } = requestContext;
-
-    // TODO: use loader?
-    const deliveryProviders = await modules.delivery.findProviders({});
-
+    const { services } = requestContext;
     return services.products.simulateProductDispatching({
-      deliveryProviders,
       product: obj,
       quantity,
       referenceDate,
@@ -42,22 +37,15 @@ export const SimpleProduct = {
     },
     requestContext: Context,
   ): Promise<
-    Array<{
+    {
       deliveryProvider?: DeliveryProvider;
       warehousingProvider?: WarehousingProvider;
       quantity?: number;
-    }>
+    }[]
   > {
-    const { modules, services } = requestContext;
-    const { referenceDate, deliveryProviderType } = params;
-
-    // TODO: use loader?
-    const deliveryProviders = await modules.delivery.findProviders({
-      type: deliveryProviderType,
-    });
-
+    const { services } = requestContext;
+    const { referenceDate } = params;
     return services.products.simulateProductInventory({
-      deliveryProviders,
       product: obj,
       referenceDate,
     });

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

@@ -38,20 +38,15 @@ export const TokenizedProduct = {
     },
     requestContext: Context,
   ): Promise<
-    Array<{
+    {
       deliveryProvider?: DeliveryProvider;
       warehousingProvider?: WarehousingProvider;
       quantity?: number;
-    }>
+    }[]
   > {
-    const { modules, services } = requestContext;
+    const { services } = requestContext;
     const { referenceDate } = params;
-
-    // TODO: use loader?
-    const deliveryProviders = await modules.delivery.findProviders({});
-
     return services.products.simulateProductInventory({
-      deliveryProviders,
       product: obj,
       referenceDate,
     });
@@ -59,8 +54,6 @@ export const TokenizedProduct = {
 
   async tokens(product: Product, params: never, requestContext: Context) {
     await checkAction(requestContext, actions.viewTokens, [undefined, params]);
-
-    // TODO: use loader?
     const tokens = await requestContext.modules.warehousing.findTokens({
       productId: product._id,
     });

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

@@ -13,6 +13,10 @@ export const Product = {
     return invertedProductTypes[product.type];
   },
 
+  async proxies(product: ProductType, _: never, context: Context): Promise<ProductType[]> {
+    return context.loaders.productProxiesLoader.load({ productId: product._id });
+  },
+
   async assortmentPaths(
     product: ProductType,
     params: {
@@ -20,9 +24,9 @@ export const Product = {
     },
     { modules, loaders }: Context,
   ): Promise<
-    Array<{
-      links: Array<AssortmentPathLink>;
-    }>
+    {
+      links: AssortmentPathLink[];
+    }[]
   > {
     return modules.assortments.breadcrumbs(
       {
@@ -41,16 +45,15 @@ export const Product = {
     );
   },
 
-  // TODO: Use a loader!
   async media(
     product: ProductType,
     params: {
       limit: number;
       offset: number;
-      tags?: Array<string>;
+      tags?: string[];
     },
     { loaders, modules }: Context,
-  ): Promise<Array<ProductMedia>> {
+  ): Promise<ProductMedia[]> {
     if (params.offset || params.tags) {
       return modules.products.media.findProductMedias({
         productId: product._id,
@@ -74,11 +77,10 @@ export const Product = {
       queryString?: string;
       limit?: number;
       offset?: number;
-      sort?: Array<SortOption>;
+      sort?: SortOption[];
     },
     { modules }: Context,
-  ): Promise<Array<ProductReview>> {
-    // TODO: use loader?
+  ): Promise<ProductReview[]> {
     return modules.products.reviews.findProductReviews({
       productId: product._id,
       limit,
@@ -107,7 +109,7 @@ export const Product = {
       includeInactive: boolean;
     },
     { modules }: Context,
-  ): Promise<Array<typeof product>> {
+  ): Promise<(typeof product)[]> {
     const { assortmentId, limit, offset, includeInactive = false } = params;
 
     const productId = product._id;
@@ -141,12 +143,11 @@ export const Product = {
     }: {
       forceLocale?: string;
     },
-    requestContext: Context,
+    { locale, loaders }: Context,
   ): Promise<ProductText> {
-    const { localeContext, loaders } = requestContext;
     return loaders.productTextLoader.load({
       productId: product._id,
-      locale: forceLocale || localeContext.baseName,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
     });
   },
 };

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

@@ -9,13 +9,13 @@ export type AssignmentHelperType<T> = (
 
 export interface ProductVariationAssignmentHelperTypes {
   _id: AssignmentHelperType<string>;
-  vectors: AssignmentHelperType<Array<{ product: Product } & ProductConfiguration>>;
+  vectors: AssignmentHelperType<({ product: Product } & ProductConfiguration)[]>;
   product: AssignmentHelperType<Promise<Product>>;
 }
 
 export const ProductVariationAssignment: ProductVariationAssignmentHelperTypes = {
   _id: ({ product, assignment }) => {
-    return `${product._id}:${Object.values(assignment.vector).join('-')}`;
+    return `${product?._id}:${Object.values(assignment.vector).join('-')}`;
   },
   vectors: ({ assignment, product }) => {
     return Object.keys(assignment.vector || {}).map((key) => ({

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

@@ -18,19 +18,22 @@ export const ProductVariationAssignmentVector: ProductVariationAssignmentVectorH
   _id: ({ product, key, value }) => `${product._id}:${key}=${value}`,
 
   option: async (obj, _, { modules }) => {
-    // TODO: use loader?
+    // TODO: use product variation loader
     const productVariation = await modules.products.variations.findProductVariationByKey({
-      key: obj.key,
       productId: obj.product._id,
+      key: obj.key,
     });
+    if (!productVariation) {
+      return null;
+    }
     return {
-      _id: productVariation._id,
+      _id: `${productVariation._id}:${obj.value}`,
       productVariationOption: obj.value,
     };
   },
 
   variation: (obj, _, { modules }) => {
-    // TODO: use loader?
+    // TODO: use product variation loader
     return modules.products.variations.findProductVariationByKey({
       productId: obj?.product?._id,
       key: obj?.key,

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

@@ -20,12 +20,12 @@ export const ProductVariationOption: ProductVariationOptionHelperTypes = {
     return obj.productVariationOption;
   },
 
-  texts: async (obj, { forceLocale }, { modules, localeContext }) => {
-    // TODO: use loader
+  texts: async (obj, { forceLocale }, { modules, locale }) => {
+    // TODO: use variation text loader
     return modules.products.variations.texts.findLocalizedVariationText({
-      locale: forceLocale || localeContext.baseName,
       productVariationId: obj._id,
       productVariationOptionValue: obj.productVariationOption,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
     });
   },
 };

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

@@ -13,10 +13,10 @@ export type HelperType<P, T> = (
 export interface ProductVariationHelperTypes {
   options: HelperType<
     never,
-    Array<{
+    {
       _id: string;
       productVariationOption: string;
-    }>
+    }[]
   >;
   texts: HelperType<{ forceLocale?: string }, Promise<ProductVariationText>>;
 }
@@ -28,11 +28,11 @@ export const ProductVariation: ProductVariationHelperTypes = {
     }));
   },
 
-  texts: async (obj, { forceLocale }, { modules, localeContext }) => {
-    // TODO: use loader
+  texts: async (obj, { forceLocale }, { modules, locale }) => {
+    // TODO: use variation text loader
     return modules.products.variations.texts.findLocalizedVariationText({
       productVariationId: obj._id,
-      locale: forceLocale || localeContext.baseName,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
     });
   },
 };

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

@@ -1,12 +1,12 @@
 import { Context } from '../../context.js';
 import { SearchConfiguration } from '@unchainedshop/core-filters';
 
-type SearchResultData = {
+export interface SearchResultData {
   searchConfiguration: SearchConfiguration & { productSelector: any };
-  totalProductIds: Array<string>;
-  aggregatedTotalProductIds: Array<string>;
-  aggregatedFilteredProductIds: Array<string>;
-};
+  totalProductIds: string[];
+  aggregatedTotalProductIds: string[];
+  aggregatedFilteredProductIds: string[];
+}
 
 export const ProductSearchResult = {
   productsCount: async (

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

@@ -1,40 +1,26 @@
 import { Quotation as QuotationType } from '@unchainedshop/core-quotations';
 import { Context } from '../../context.js';
-import { User } from '@unchainedshop/core-users';
-import { Product } from '@unchainedshop/core-products';
-import { Country } from '@unchainedshop/core-countries';
-import { Currency } from '@unchainedshop/core-currencies';
 
-type HelperType<P, T> = (quotation: QuotationType, params: P, context: Context) => T;
+export const Quotation = {
+  country: async (obj: QuotationType, _: never, { loaders }: Context) =>
+    loaders.countryLoader.load({ isoCode: obj.countryCode }),
 
-type QuotationHelperTypes = {
-  country: HelperType<never, Promise<Country>>;
-  currency: HelperType<never, Promise<Currency>>;
-  isExpired: HelperType<{ referenceDate: Date }, boolean>;
-  status: HelperType<never, string>;
-  product: HelperType<never, Promise<Product>>;
-  user: HelperType<never, Promise<User>>;
-};
-
-export const Quotation: QuotationHelperTypes = {
-  // TODO: use loader
-  country: async (obj, _, { modules }) => modules.countries.findCountry({ isoCode: obj.countryCode }),
-
-  // TODO: use loader
-  currency: async (obj, _, { modules }) => modules.currencies.findCurrency({ isoCode: obj.currency }),
+  currency: async (obj: QuotationType, _: never, { loaders }: Context) =>
+    loaders.currencyLoader.load({ isoCode: obj.currencyCode }),
 
-  isExpired: (obj, { referenceDate }, { modules }) =>
+  isExpired: (obj: QuotationType, { referenceDate }: { referenceDate: Date }, { modules }: Context) =>
     modules.quotations.isExpired(obj, { referenceDate }),
 
-  product: async (obj, _, { loaders }) => {
+  product: async (obj: QuotationType, _: never, { loaders }: Context) => {
     const product = await loaders.productLoader.load({
       productId: obj.productId,
     });
     return product;
   },
 
-  status: (obj, _, { modules }) => modules.quotations.normalizedStatus(obj),
+  status: (obj: QuotationType, _: never, { modules }: Context) =>
+    modules.quotations.normalizedStatus(obj),
 
-  // TODO: use loader
-  user: (obj, _, { modules }) => modules.users.findUserById(obj.userId),
+  user: async (obj: QuotationType, _: never, { loaders }: Context) =>
+    loaders.userLoader.load({ userId: obj.userId }),
 };

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

@@ -10,7 +10,7 @@ export interface ShopHelperTypes {
   _id: () => string;
   country: HelperType<Country>;
   language: HelperType<Language>;
-  userRoles: HelperType<Array<string>>;
+  userRoles: HelperType<string[]>;
 }
 
 export const Shop: ShopHelperTypes = {
@@ -18,13 +18,11 @@ export const Shop: ShopHelperTypes = {
     return 'root';
   },
 
-  language: async (_root, _params, { localeContext, modules }) => {
-    // TODO: use loader
-    return modules.languages.findLanguage({ isoCode: localeContext.language });
+  language: async (_root, _params, { locale, loaders }) => {
+    return loaders.languageLoader.load({ isoCode: locale.language });
   },
-  country: async (_root, _params, { countryContext, modules }) => {
-    // TODO: use loader
-    return modules.countries.findCountry({ isoCode: countryContext });
+  country: async (_root, _params, { countryCode, loaders }) => {
+    return loaders.countryLoader.load({ isoCode: countryCode });
   },
 
   userRoles: async (_root, _params, context) => {

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

@@ -6,22 +6,19 @@ import { actions } from '../../roles/index.js';
 import { WarehousingDirector } from '@unchainedshop/core';
 
 export const Token = {
-  product: async (token: TokenSurrogate, params: never, { modules }: Context) => {
-    // TODO: use loader
-    return modules.products.findProduct({ productId: token.productId });
+  product: async (token: TokenSurrogate, params: never, { loaders }: Context) => {
+    return loaders.productLoader.load({ productId: token.productId });
   },
 
-  user: async (token: TokenSurrogate, params: never, { modules }: Context) => {
+  user: async (token: TokenSurrogate, params: never, { loaders }: Context) => {
     if (!token.userId) return null;
-    // TODO: use loader
-    return modules.users.findUserById(token.userId);
+    return loaders.userLoader.load({ userId: token.userId });
   },
 
   status: async (token: TokenSurrogate, params: never, { modules }: Context) => {
     if (token.walletAddress && !token.userId) {
       return TokenStatus.DECENTRALIZED;
     }
-    // TODO: use loader?
     const workItems = await modules.worker.findWorkQueue({
       types: ['EXPORT_TOKEN'],
       status: [WorkStatus.NEW, WorkStatus.ALLOCATED],
@@ -35,37 +32,23 @@ export const Token = {
     { forceLocale }: { forceLocale: string },
     context: Context,
   ) => {
-    const { modules } = context;
-    // TODO: use loader
-    const product = await modules.products.findProduct({ productId: token.productId });
+    const { loaders, services } = context;
+    const product = await loaders.productLoader.load({ productId: token.productId });
 
-    // TODO: use loader
-    const virtualProviders = await context.modules.warehousing.findProviders({
-      type: WarehousingProviderType.VIRTUAL,
+    return services.warehousing.ercMetadata({
+      product,
+      token,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : context.locale,
     });
-
-    return WarehousingDirector.tokenMetadata(
-      virtualProviders,
-      {
-        product,
-        token,
-        locale: forceLocale ? new Intl.Locale(forceLocale) : context.localeContext,
-        quantity: token?.quantity || 1,
-        referenceDate: new Date(),
-      },
-      context,
-    );
   },
 
   isInvalidateable: async (token: TokenSurrogate, _params: never, context: Context) => {
-    const { modules } = context;
-    // TODO: use loader
-    const product = await modules.products.findProduct({ productId: token.productId });
+    const { loaders } = context;
+    const product = await loaders.productLoader.load({ productId: token.productId });
 
-    // TODO: use loader
-    const virtualProviders = await context.modules.warehousing.findProviders({
-      type: WarehousingProviderType.VIRTUAL,
-    });
+    const virtualProviders = (await context.modules.warehousing.allProviders()).filter(
+      ({ type }) => type === WarehousingProviderType.VIRTUAL,
+    );
 
     const isInvalidateable = await WarehousingDirector.isInvalidateable(
       virtualProviders,