@unchainedshop/api 1.1.3

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

@@ -0,0 +1,75 @@
+import { ConfigurableProductHelperTypes } from '@unchainedshop/types/products';
+import { Product } from './product-types';
+
+export const ConfigurableProduct: ConfigurableProductHelperTypes = {
+  ...Product,
+
+  assignments: async (obj, params, { modules }) => {
+    return modules.products.proxyAssignments(obj, params);
+  },
+
+  products: async (obj, { vectors, includeInactive }, { modules }) => {
+    return modules.products.proxyProducts(obj, vectors, {
+      includeInactive,
+    });
+  },
+
+  catalogPriceRange: async (
+    obj,
+    { quantity, vectors, currency: forcedCurrencyCode, includeInactive },
+    requestContext,
+  ) => {
+    const { countryContext, modules } = requestContext;
+    const currencyCode =
+      forcedCurrencyCode ||
+      (await requestContext.services.countries.resolveDefaultCurrencyCode(
+        {
+          isoCode: countryContext,
+        },
+        requestContext,
+      ));
+    return modules.products.prices.catalogPriceRange(obj, {
+      quantity,
+      vectors,
+      includeInactive,
+      country: countryContext,
+      currency: currencyCode,
+    });
+  },
+
+  variations: async (obj, { limit = 10, offset = 0 }, { modules }) => {
+    return modules.products.variations.findProductVariations({
+      productId: obj._id,
+      limit,
+      offset,
+    });
+  },
+
+  async simulatedPriceRange(
+    obj,
+    { currency: forcedCurrencyCode, quantity, useNetPrice, vectors, includeInactive },
+    requestContext,
+  ) {
+    const { countryContext, modules } = requestContext;
+    const currency =
+      forcedCurrencyCode ||
+      (await requestContext.services.countries.resolveDefaultCurrencyCode(
+        {
+          isoCode: countryContext,
+        },
+        requestContext,
+      ));
+    return modules.products.prices.simulatedPriceRange(
+      obj,
+      {
+        quantity,
+        currency,
+        country: countryContext,
+        useNetPrice,
+        vectors,
+        includeInactive,
+      },
+      requestContext,
+    );
+  },
+};

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

@@ -0,0 +1,51 @@
+import { Context } from '@unchainedshop/types/api';
+import { ProductDiscount as ProductDiscountType } from '@unchainedshop/types/products';
+import crypto from 'crypto';
+
+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);
+    if (!Interface) return null;
+    return {
+      _id: Interface.key,
+      label: Interface.label,
+      version: Interface.version,
+      isManualAdditionAllowed: await Interface.isManualAdditionAllowed(obj.code),
+      isManualRemovalAllowed: await Interface.isManualRemovalAllowed(),
+    };
+  },
+
+  total: (obj) => {
+    const { total } = obj;
+    if (total) {
+      return {
+        _id: crypto
+          .createHash('sha256')
+          .update([`${obj._id}`, total.amount, total.currency].join(''))
+          .digest('hex'),
+        amount: total.amount,
+        currency: total.currency,
+      };
+    }
+    return null;
+  },
+};

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

@@ -0,0 +1,14 @@
+import { ProductMediaHelperTypes } from '@unchainedshop/types/products.media';
+
+export const ProductMedia: ProductMediaHelperTypes = {
+  texts: async (obj, { forceLocale }, { modules, localeContext }) => {
+    return modules.products.media.texts.findLocalizedMediaText({
+      productMediaId: obj._id,
+      locale: forceLocale || localeContext.normalized,
+    });
+  },
+
+  file: async (obj, _, { modules }) => {
+    return modules.files.findFile({ fileId: obj.mediaId });
+  },
+};

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

@@ -0,0 +1,83 @@
+import { PlanProductHelperTypes, ProductPrice } from '@unchainedshop/types/products';
+import { Product } from './product-types';
+
+export const PlanProduct: PlanProductHelperTypes = {
+  ...Product,
+
+  catalogPrice: async (product, { quantity, currency: forcedCurrencyCode }, requestContext) => {
+    const { modules, countryContext } = requestContext;
+    const currencyCode =
+      forcedCurrencyCode ||
+      (await requestContext.services.countries.resolveDefaultCurrencyCode(
+        {
+          isoCode: countryContext,
+        },
+        requestContext,
+      ));
+    return modules.products.prices.price(product, {
+      country: countryContext,
+      currency: currencyCode,
+      quantity,
+    });
+  },
+
+  simulatedPrice: async (
+    obj,
+    { currency: forcedCurrencyCode, quantity, useNetPrice },
+    requestContext,
+  ) => {
+    const { countryContext, modules } = requestContext;
+    const currency =
+      forcedCurrencyCode ||
+      (await requestContext.services.countries.resolveDefaultCurrencyCode(
+        {
+          isoCode: countryContext,
+        },
+        requestContext,
+      ));
+    return modules.products.prices.userPrice(
+      obj,
+      { quantity, currency, country: countryContext, useNetPrice },
+      requestContext,
+    );
+  },
+
+  leveledCatalogPrices: async (obj, { currency: forcedCurrencyCode }, requestContext) => {
+    const { countryContext, modules } = requestContext;
+    const currency =
+      forcedCurrencyCode ||
+      (await requestContext.services.countries.resolveDefaultCurrencyCode(
+        {
+          isoCode: countryContext,
+        },
+        requestContext,
+      ));
+    return modules.products.prices.catalogPricesLeveled(obj, { currency, country: countryContext });
+  },
+
+  simulatedDiscounts: async () => {
+    // const { modules, countryContext } = requestContext;
+    // return modules.products.prices.userDiscounts(
+    //   {
+    //     quantity,
+    //     country: countryContext,
+    //   },
+    //   requestContext
+    // );
+    return [] as Array<{
+      _id: string;
+      interface: any;
+      total: ProductPrice;
+    }>;
+  },
+
+  salesUnit(obj) {
+    return obj.commerce && obj.commerce.salesUnit;
+  },
+  salesQuantityPerUnit(obj) {
+    return obj.commerce && obj.commerce.salesQuantityPerUnit;
+  },
+  defaultOrderQuantity(obj) {
+    return obj.commerce && obj.commerce.defaultOrderQuantity;
+  },
+};

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

@@ -0,0 +1,34 @@
+import { Context } from '@unchainedshop/types/api';
+import { Product } from '@unchainedshop/types/products';
+import {
+  ProductReview as ProductReviewType,
+  ProductReviewVoteType,
+  ProductVote,
+} from '@unchainedshop/types/products.reviews';
+import { User } from '@unchainedshop/types/user';
+
+type HelperType<P, T> = (product: ProductReviewType, params: P, context: Context) => T;
+
+export interface ProductReviewHelperTypes {
+  author: HelperType<never, Promise<User>>;
+  product: HelperType<never, Promise<Product>>;
+  voteCount: HelperType<{ type: ProductReviewVoteType }, number>;
+  ownVotes: HelperType<never, Promise<Array<ProductVote>>>;
+}
+export const ProductReview: ProductReviewHelperTypes = {
+  author: async (obj, _, { modules }) => {
+    return modules.users.findUserById(obj.authorId);
+  },
+
+  product: async (obj, _, { modules }) => {
+    return modules.products.findProduct({ productId: obj.productId });
+  },
+
+  ownVotes: async (obj, _, { modules, userId }) => {
+    return modules.products.reviews.votes.ownVotes(obj, { userId });
+  },
+
+  voteCount: (obj, { type }, { modules }) => {
+    return modules.products.reviews.votes.userIdsThatVoted(obj, { type }).length;
+  },
+};

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

@@ -0,0 +1,113 @@
+import { SimpleProductHelperTypes } from '@unchainedshop/types/products';
+import { WarehousingContext } from '@unchainedshop/types/warehousing';
+import { PlanProduct } from './product-plan-types';
+
+export const SimpleProduct: SimpleProductHelperTypes = {
+  ...PlanProduct,
+
+  simulatedDispatches: async (obj, params, requestContext) => {
+    const { deliveryProviderType, referenceDate, quantity } = params;
+    const { 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 {
+            ...warehousingContext,
+            ...dispatch,
+          };
+        }),
+      );
+
+      return result.concat(result, mappedWarehousingProviders);
+    }, Promise.resolve([]));
+  },
+
+  simulatedStocks: async (obj, params, requestContext) => {
+    const { modules } = 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 {
+            ...warehousingContext,
+            ...stock,
+          };
+        }),
+      );
+
+      return result.concat(result, mappedWarehousingProviders);
+    }, Promise.resolve([]));
+  },
+
+  baseUnit: (obj) => {
+    return obj.warehousing && obj.warehousing.baseUnit;
+  },
+  sku: (obj) => {
+    return obj.warehousing && obj.warehousing.sku;
+  },
+  dimensions: ({ supply }) => {
+    if (!supply) return null;
+    const { weightInGram, heightInMillimeters, lengthInMillimeters, widthInMillimeters } = supply;
+    return {
+      weightInGram,
+      heightInMillimeters,
+      lengthInMillimeters,
+      widthInMillimeters,
+    };
+  },
+};

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

@@ -0,0 +1,68 @@
+import { ProductHelperTypes } from '@unchainedshop/types/products';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { objectInvert } from '@unchainedshop/utils';
+
+export const Product: ProductHelperTypes = {
+  __resolveType: (obj) => {
+    const invertedProductTypes = objectInvert(ProductTypes);
+    return invertedProductTypes[obj.type];
+  },
+
+  assortmentPaths: async (obj, _, { modules }) => {
+    return modules.assortments.breadcrumbs({
+      productId: obj._id,
+    });
+  },
+
+  media: async (obj, params, { modules }) => {
+    return modules.products.media.findProductMedias({
+      productId: obj._id,
+      ...params,
+    });
+  },
+
+  reviews: async (obj, { limit = 10, offset = 0, sort, queryString }, { modules }) => {
+    return modules.products.reviews.findProductReviews({
+      productId: obj._id,
+      limit,
+      offset,
+      sort,
+      queryString,
+    });
+  },
+
+  siblings: async (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.findProductSiblings({
+      productId,
+      assortmentIds,
+    });
+
+    return modules.products.findProducts({
+      productIds,
+      includeDrafts: includeInactive,
+      limit,
+      offset,
+    });
+  },
+
+  status(obj, _, { modules }) {
+    return modules.products.normalizedStatus(obj);
+  },
+
+  async texts(obj, { forceLocale }, requestContext) {
+    const { localeContext, loaders } = requestContext;
+    return loaders.productTextLoader.load({
+      productId: obj._id,
+      locale: forceLocale || localeContext.normalized,
+    });
+  },
+};

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

@@ -0,0 +1,19 @@
+import { ProductVariationAssignmentHelperTypes } from '@unchainedshop/types/products.variations';
+
+export const ProductVariationAssignment: ProductVariationAssignmentHelperTypes = {
+  _id: ({ product, assignment }) => {
+    return `${product._id}:${Object.values(assignment.vector).join('-')}`;
+  },
+  vectors: ({ assignment, product }) => {
+    return Object.keys(assignment.vector || {}).map((key) => ({
+      key,
+      value: assignment.vector[key],
+      product,
+    }));
+  },
+  product: async ({ assignment }, _, { modules }) => {
+    return modules.products.findProduct({
+      productId: assignment.productId,
+    });
+  },
+};

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

@@ -0,0 +1,20 @@
+import { ProductVariationAssignmentVectorHelperTypes } from '@unchainedshop/types/products.variations';
+
+export const ProductVariationAssignmentVector: ProductVariationAssignmentVectorHelperTypes = {
+  _id: ({ product, key, value }) => `${product._id}:${key}=${value}`,
+
+  option: async (obj, _, { modules }) => {
+    const productVariation = await modules.products.variations.findProductVariationByKey({
+      key: obj.key,
+      productId: obj.product._id,
+    });
+    return modules.products.variations.option(productVariation, obj.value);
+  },
+
+  variation: (obj, _, { modules }) => {
+    return modules.products.variations.findProductVariationByKey({
+      productId: obj?.product?._id,
+      key: obj?.key,
+    });
+  },
+};

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

@@ -0,0 +1,18 @@
+import { ProductVariationOptionHelperTypes } from '@unchainedshop/types/products.variations';
+
+export const ProductVariationOption: ProductVariationOptionHelperTypes = {
+  _id: (obj) => {
+    return `${obj._id}:${obj.productVariationOption}`;
+  },
+  value: (obj) => {
+    return obj.productVariationOption;
+  },
+
+  texts: async (obj, { forceLocale }, { modules, localeContext }) => {
+    return modules.products.variations.texts.findLocalizedVariationText({
+      locale: forceLocale || localeContext.normalized,
+      productVariationId: obj._id,
+      productVariationOptionValue: obj.productVariationOption,
+    });
+  },
+};

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

@@ -0,0 +1,14 @@
+import { ProductVariationHelperTypes } from '@unchainedshop/types/products.variations';
+
+export const ProductVariation: ProductVariationHelperTypes = {
+  options: (obj, _, { modules }) => {
+    return (obj.options || []).map((option) => modules.products.variations.option(obj, option));
+  },
+
+  texts: async (obj, { forceLocale }, { modules, localeContext }) => {
+    return modules.products.variations.texts.findLocalizedVariationText({
+      productVariationId: obj._id,
+      locale: forceLocale || localeContext.normalized,
+    });
+  },
+};

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

@@ -0,0 +1,52 @@
+import { Quotation as QuotationType } from '@unchainedshop/types/quotations';
+import { Context } from '@unchainedshop/types/api';
+import { User } from '@unchainedshop/types/user';
+import { Product } from '@unchainedshop/types/products';
+import { Country } from '@unchainedshop/types/countries';
+import { Currency } from '@unchainedshop/types/currencies';
+import { File } from '@unchainedshop/types/files';
+
+type HelperType<P, T> = (quotation: QuotationType, params: P, context: Context) => T;
+
+type QuotationHelperTypes = {
+  country: HelperType<never, Promise<Country>>;
+  currency: HelperType<never, Promise<Currency>>;
+  documents: HelperType<{ type: string }, Promise<Array<File>>>;
+  isExpired: HelperType<{ referenceDate: Date }, boolean>;
+  status: HelperType<never, string>;
+  product: HelperType<never, Promise<Product>>;
+  user: HelperType<never, Promise<User>>;
+};
+
+export const Quotation: QuotationHelperTypes = {
+  country: async (obj, _, { modules }) => modules.countries.findCountry({ isoCode: obj.countryCode }),
+
+  currency: async (obj, _, { modules }) => modules.currencies.findCurrency({ isoCode: obj.currency }),
+
+  documents: (obj, { type }, { modules }) =>
+    modules.files.findFilesByMetaData(
+      {
+        meta: {
+          quotationId: obj._id,
+          type,
+        },
+      },
+      {
+        sort: {
+          'meta.date': -1,
+        },
+      },
+    ),
+
+  isExpired: (obj, { referenceDate }, { modules }) =>
+    modules.quotations.isExpired(obj, { referenceDate }),
+
+  product: (obj, _, { modules }) =>
+    modules.products.findProduct({
+      productId: obj.productId,
+    }),
+
+  status: (obj, _, { modules }) => modules.quotations.normalizedStatus(obj),
+
+  user: (obj, _, { modules }) => modules.users.findUserById(obj.userId),
+};

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

@@ -0,0 +1,34 @@
+import { Context } from '@unchainedshop/types/api';
+import { Country } from '@unchainedshop/types/countries';
+import { Language } from '@unchainedshop/types/languages';
+import { checkAction } from '../../acl';
+import { allRoles, actions } from '../../roles';
+
+type HelperType<T> = (root: never, params: never, context: Context) => Promise<T>;
+
+interface ShopHelperTypes {
+  _id: () => string;
+  country: HelperType<Country>;
+  language: HelperType<Language>;
+  userRoles: HelperType<Array<string>>;
+}
+
+export const Shop: ShopHelperTypes = {
+  _id() {
+    return 'root';
+  },
+
+  language: async (_root, _params, { localeContext, modules }) => {
+    return modules.languages.findLanguage({ isoCode: localeContext.language });
+  },
+  country: async (_root, _params, { countryContext, modules }) => {
+    return modules.countries.findCountry({ isoCode: countryContext });
+  },
+
+  userRoles: async (_root, _params, context) => {
+    await checkAction(context, (actions as any).manageUsers);
+    return Object.values(allRoles)
+      .map(({ name }) => name)
+      .filter((name) => name.substring(0, 2) !== '__');
+  },
+};

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

@@ -0,0 +1,28 @@
+import { DeliveryProvider } from '@unchainedshop/types/delivery';
+import { Product } from '@unchainedshop/types/products';
+import { WarehousingProvider } from '@unchainedshop/types/warehousing';
+import crypto from 'crypto';
+
+export const Stock = {
+  _id: (params: {
+    product: Product;
+    deliveryProvider: DeliveryProvider;
+    warehousingProvider: WarehousingProvider;
+    referenceDate: Date;
+    country: string;
+    userId?: string;
+  }) =>
+    crypto
+      .createHash('sha256')
+      .update(
+        [
+          params.product._id,
+          params.deliveryProvider._id,
+          params.warehousingProvider._id,
+          params.referenceDate,
+          params.country,
+          params.userId || 'ANONYMOUS',
+        ].join(''),
+      )
+      .digest('hex'),
+};