@unchainedshop/api 4.3.6 → 4.4.0

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

@@ -1,27 +0,0 @@
-import { ProductDiscount as ProductDiscountType } from '@unchainedshop/core-products';
-import { ProductDiscountDirector } from '@unchainedshop/core';
-
-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(productDiscount.code),
-      isManualRemovalAllowed: await Interface.isManualRemovalAllowed(),
-    };
-  },
-
-  total(productDiscount: ProductDiscountType) {
-    const { total } = productDiscount;
-    if (total) {
-      return {
-        amount: total.amount,
-        currencyCode: total.currencyCode,
-      };
-    }
-    return null;
-  },
-};

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

@@ -1,27 +0,0 @@
-import { Context } from '../../../context.js';
-import { File } from '@unchainedshop/core-files';
-import { 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<{ forceLocale?: string }, Promise<ProductMediaText>>;
-  file: HelperType<never, Promise<File>>;
-}
-
-export const ProductMedia: ProductMediaHelperTypes = {
-  async texts(obj, { forceLocale }, requestContext) {
-    const { locale, loaders } = requestContext;
-    return loaders.productMediaTextLoader.load({
-      productMediaId: obj._id,
-      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
-    });
-  },
-
-  async file(obj, _, requestContext) {
-    const { loaders } = requestContext;
-    return loaders.fileLoader.load({
-      fileId: obj.mediaId,
-    });
-  },
-};

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

@@ -1,92 +0,0 @@
-import {
-  ProductConfiguration,
-  ProductPrice,
-  Product as ProductType,
-} from '@unchainedshop/core-products';
-import { Context } from '../../../context.js';
-import { Product } from './product-types.js';
-
-export const PlanProduct = {
-  ...Product,
-
-  async catalogPrice(
-    product: ProductType,
-    { quantity, currencyCode: forcedCurrencyCode }: { quantity?: number; currencyCode?: string },
-    requestContext: Context,
-  ): Promise<ProductPrice | null> {
-    const { modules, countryCode } = requestContext;
-    const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
-    return modules.products.prices.price(product, {
-      countryCode,
-      currencyCode,
-      quantity,
-    });
-  },
-
-  async simulatedPrice(
-    product: ProductType,
-    {
-      currencyCode: forcedCurrencyCode,
-      quantity,
-      useNetPrice,
-      configuration,
-    }: {
-      quantity?: number;
-      currencyCode?: string;
-      useNetPrice?: boolean;
-      configuration?: ProductConfiguration[];
-    },
-    requestContext: Context,
-  ): Promise<ProductPrice | null> {
-    const { countryCode, user, services } = requestContext;
-    const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
-
-    const pricingContext = {
-      product,
-      user,
-      countryCode,
-      currencyCode,
-      quantity: quantity || 1,
-      discounts: [],
-      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.currencyCode || requestContext.currencyCode,
-      countryCode: requestContext.countryCode,
-    };
-  },
-
-  async leveledCatalogPrices(
-    product: ProductType,
-    { currencyCode: forcedCurrencyCode }: { currencyCode?: string },
-    requestContext: Context,
-  ): Promise<
-    {
-      minQuantity: number;
-      maxQuantity: number;
-      price: ProductPrice;
-    }[]
-  > {
-    const { countryCode, modules } = requestContext;
-    const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
-    return modules.products.prices.catalogPricesLeveled(product, { currencyCode, countryCode });
-  },
-
-  salesUnit({ commerce }: ProductType): string | null {
-    return commerce?.salesUnit || null;
-  },
-  salesQuantityPerUnit({ commerce }: ProductType): string | null {
-    return commerce?.salesQuantityPerUnit || null;
-  },
-  defaultOrderQuantity({ commerce }: ProductType): number | null {
-    return commerce?.defaultOrderQuantity || null;
-  },
-};

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

@@ -1,37 +0,0 @@
-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';
-
-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<ProductVote[]>>;
-}
-export const ProductReview: ProductReviewHelperTypes = {
-  author: async (obj, _, { loaders }) => {
-    return loaders.userLoader.load({ userId: obj.authorId });
-  },
-
-  product: async (review, _, { loaders }) => {
-    const product = await loaders.productLoader.load({
-      productId: review.productId,
-    });
-    return product;
-  },
-
-  ownVotes: async (obj, _, { modules, userId }) => {
-    return modules.products.reviews.votes.ownVotes(obj, { userId: userId! });
-  },
-
-  voteCount: (obj, { type }, { modules }) => {
-    return modules.products.reviews.votes.userIdsThatVoted(obj, { type }).length;
-  },
-};

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

@@ -1,72 +0,0 @@
-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 { PlanProduct } from './product-plan-types.js';
-import { WarehousingProvider } from '@unchainedshop/core-warehousing';
-
-export const SimpleProduct = {
-  ...PlanProduct,
-
-  async simulatedDispatches(
-    obj: Product,
-    params: { referenceDate: Date; quantity: number; deliveryProviderType: DeliveryProviderType },
-    requestContext: Context,
-  ): Promise<
-    {
-      deliveryProvider?: DeliveryProvider;
-      warehousingProvider?: WarehousingProvider;
-      shipping?: Date;
-      earliestDelivery?: Date;
-    }[]
-  > {
-    const { referenceDate, quantity } = params;
-    const { services } = requestContext;
-    return services.products.simulateProductDispatching({
-      product: obj,
-      quantity,
-      referenceDate,
-    });
-  },
-
-  async simulatedStocks(
-    obj: Product,
-    params: {
-      referenceDate: Date;
-      deliveryProviderType: DeliveryProviderType;
-    },
-    requestContext: Context,
-  ): Promise<
-    {
-      deliveryProvider?: DeliveryProvider;
-      warehousingProvider?: WarehousingProvider;
-      quantity?: number;
-    }[]
-  > {
-    const { services } = requestContext;
-    const { referenceDate } = params;
-    return services.products.simulateProductInventory({
-      product: obj,
-      referenceDate,
-    });
-  },
-
-  baseUnit({ warehousing }): string {
-    return warehousing?.baseUnit;
-  },
-
-  sku({ warehousing }): string {
-    return warehousing?.sku;
-  },
-
-  dimensions({ supply }): ProductSupply | null {
-    if (!supply) return null;
-    const { weightInGram, heightInMillimeters, lengthInMillimeters, widthInMillimeters } = supply;
-    return {
-      weightInGram,
-      heightInMillimeters,
-      lengthInMillimeters,
-      widthInMillimeters,
-    };
-  },
-};

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

@@ -1,72 +0,0 @@
-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 { PlanProduct } from './product-plan-types.js';
-import { checkAction } from '../../../acl.js';
-import { actions } from '../../../roles/index.js';
-
-export const TokenizedProduct = {
-  ...PlanProduct,
-
-  contractAddress({ tokenization }: Product): string | null {
-    return tokenization?.contractAddress || null;
-  },
-
-  contractConfiguration({ tokenization }: Product): ProductContractConfiguration | null {
-    if (!tokenization) return null;
-    return {
-      supply: tokenization.supply,
-      tokenId: tokenization.tokenId,
-      ercMetadataProperties: tokenization.ercMetadataProperties,
-    };
-  },
-
-  contractStandard({ tokenization }: Product): ProductContractStandard | null {
-    return tokenization?.contractStandard || null;
-  },
-
-  async simulatedStocks(
-    obj: Product,
-    params: {
-      referenceDate: Date;
-    },
-    requestContext: Context,
-  ): Promise<
-    {
-      deliveryProvider?: DeliveryProvider;
-      warehousingProvider?: WarehousingProvider;
-      quantity?: number;
-    }[]
-  > {
-    const { services } = requestContext;
-    const { referenceDate } = params;
-    return services.products.simulateProductInventory({
-      product: obj,
-      referenceDate,
-    });
-  },
-
-  async tokens(product: Product, params: never, requestContext: Context) {
-    await checkAction(requestContext, actions.viewTokens, [undefined, params]);
-    const tokens = await requestContext.modules.warehousing.findTokens({
-      productId: product._id,
-    });
-    return tokens;
-  },
-  async tokensCount(product: Product, params: never, requestContext: Context) {
-    await checkAction(requestContext, actions.viewTokens, [undefined, params]);
-    return requestContext.modules.warehousing.tokensCount({
-      productId: product._id,
-    });
-  },
-};
-
-delete (TokenizedProduct as any).salesUnit;
-delete (TokenizedProduct as any).salesQuantityPerUnit;
-delete (TokenizedProduct as any).defaultOrderQuantity;

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

@@ -1,152 +0,0 @@
-import { ProductText, Product as ProductType } from '@unchainedshop/core-products';
-import { ProductStatus, ProductTypes } from '@unchainedshop/core-products';
-import { objectInvert } from '@unchainedshop/utils';
-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';
-
-export const Product = {
-  __resolveType: (product: ProductType): string => {
-    const invertedProductTypes = objectInvert(ProductTypes);
-    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: {
-      forceLocale?: string;
-    },
-    { modules, loaders }: Context,
-  ): Promise<
-    {
-      links: AssortmentPathLink[];
-    }[]
-  > {
-    return modules.assortments.breadcrumbs(
-      {
-        productId: product._id,
-      },
-      {
-        resolveAssortmentProducts: async (productId) =>
-          loaders.assortmentProductsLoader.load({
-            productId,
-          }),
-        resolveAssortmentLinks: async (childAssortmentId) =>
-          loaders.assortmentLinksLoader.load({
-            childAssortmentId,
-          }),
-      },
-    );
-  },
-
-  async media(
-    product: ProductType,
-    params: {
-      limit: number;
-      offset: number;
-      tags?: string[];
-    },
-    { loaders, modules }: Context,
-  ): Promise<ProductMedia[]> {
-    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(
-    product: ProductType,
-    {
-      limit = 10,
-      offset = 0,
-      sort,
-      queryString,
-    }: {
-      queryString?: string;
-      limit?: number;
-      offset?: number;
-      sort?: SortOption[];
-    },
-    { modules }: Context,
-  ): Promise<ProductReview[]> {
-    return modules.products.reviews.findProductReviews({
-      productId: product._id,
-      limit,
-      offset,
-      sort,
-      queryString,
-    });
-  },
-  async reviewsCount(
-    product: ProductType,
-    params: {
-      queryString?: string;
-    },
-    { modules }: Context,
-  ): Promise<number> {
-    return modules.products.reviews.count({ ...params, productId: product._id });
-  },
-
-  async siblings(
-    product: ProductType,
-    params: {
-      assortmentId?: string;
-      limit: number;
-      offset: number;
-      includeInactive: boolean;
-    },
-    { modules }: Context,
-  ): Promise<(typeof product)[]> {
-    const { assortmentId, limit, offset, includeInactive = false } = params;
-
-    const productId = product._id;
-    const assortmentIds = assortmentId
-      ? [assortmentId]
-      : await modules.assortments.products.findAssortmentIds({ productId });
-
-    if (!assortmentIds.length) return [];
-
-    const productIds = await modules.assortments.products.findSiblings({
-      productId,
-      assortmentIds,
-    });
-
-    return modules.products.findProducts({
-      productIds,
-      includeDrafts: includeInactive,
-      limit,
-      offset,
-    });
-  },
-
-  status(product: ProductType, _, { modules }: Context): ProductStatus {
-    return modules.products.normalizedStatus(product);
-  },
-
-  async texts(
-    product: ProductType,
-    {
-      forceLocale,
-    }: {
-      forceLocale?: string;
-    },
-    { locale, loaders }: Context,
-  ): Promise<ProductText> {
-    return loaders.productTextLoader.load({
-      productId: product._id,
-      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
-    });
-  },
-};

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

@@ -1,33 +0,0 @@
-import { Context } from '../../../context.js';
-import { Product, ProductAssignment, ProductConfiguration } from '@unchainedshop/core-products';
-
-export type AssignmentHelperType<T> = (
-  data: { product: Product; assignment: ProductAssignment },
-  _: never,
-  context: Context,
-) => T;
-
-export interface ProductVariationAssignmentHelperTypes {
-  _id: AssignmentHelperType<string>;
-  vectors: AssignmentHelperType<({ product: Product } & ProductConfiguration)[]>;
-  product: AssignmentHelperType<Promise<Product>>;
-}
-
-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 }, _, { loaders }) => {
-    const product = await loaders.productLoader.load({
-      productId: assignment.productId,
-    });
-    return product;
-  },
-};

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

@@ -1,40 +0,0 @@
-import { Context } from '../../../context.js';
-import { Product, ProductConfiguration } from '@unchainedshop/core-products';
-import { ProductVariation } from '@unchainedshop/core-products';
-
-export type AssignmentVectorHelperType<T> = (
-  data: { product: Product } & ProductConfiguration,
-  _: never,
-  context: Context,
-) => T;
-
-export interface ProductVariationAssignmentVectorHelperTypes {
-  _id: AssignmentVectorHelperType<string>;
-  option: AssignmentVectorHelperType<Promise<{ _id: string; productVariationOption: string } | null>>;
-  variation: AssignmentVectorHelperType<Promise<ProductVariation | null>>;
-}
-
-export const ProductVariationAssignmentVector: ProductVariationAssignmentVectorHelperTypes = {
-  _id: ({ product, key, value }) => `${product._id}:${key}=${value}`,
-
-  option: async (obj, _, { loaders }) => {
-    const productVariation = await loaders.productVariationByKeyLoader.load({
-      productId: obj.product._id,
-      key: obj.key,
-    });
-    if (!productVariation) {
-      return null;
-    }
-    return {
-      _id: `${productVariation._id}:${obj.value}`,
-      productVariationOption: obj.value,
-    };
-  },
-
-  variation: (obj, _, { loaders }) => {
-    return loaders.productVariationByKeyLoader.load({
-      productId: obj?.product?._id,
-      key: obj?.key,
-    });
-  },
-};

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

@@ -1,30 +0,0 @@
-import { Context } from '../../../context.js';
-import { ProductVariationText } from '@unchainedshop/core-products';
-
-export type OptionHelperType<P, T> = (
-  option: { _id: string; productVariationOption: string },
-  params: P,
-  context: Context,
-) => T;
-
-export interface ProductVariationOptionHelperTypes {
-  _id: OptionHelperType<never, string>;
-  texts: OptionHelperType<{ forceLocale?: string }, Promise<ProductVariationText>>;
-  value: OptionHelperType<never, string>;
-}
-export const ProductVariationOption: ProductVariationOptionHelperTypes = {
-  _id: (obj) => {
-    return `${obj._id}:${obj.productVariationOption}`;
-  },
-  value: (obj) => {
-    return obj.productVariationOption;
-  },
-
-  texts: async (obj, { forceLocale }, { loaders, locale }) => {
-    return loaders.productVariationTextLoader.load({
-      productVariationId: obj._id,
-      productVariationOptionValue: obj.productVariationOption,
-      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
-    });
-  },
-};

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

@@ -1,37 +0,0 @@
-import { Context } from '../../../context.js';
-import {
-  ProductVariation as ProductVariationType,
-  ProductVariationText,
-} from '@unchainedshop/core-products';
-
-export type HelperType<P, T> = (
-  productVariation: ProductVariationType,
-  params: P,
-  context: Context,
-) => T;
-
-export interface ProductVariationHelperTypes {
-  options: HelperType<
-    never,
-    {
-      _id: string;
-      productVariationOption: string;
-    }[]
-  >;
-  texts: HelperType<{ forceLocale?: string }, Promise<ProductVariationText>>;
-}
-export const ProductVariation: ProductVariationHelperTypes = {
-  options: (obj) => {
-    return (obj.options || []).map((option) => ({
-      _id: obj._id,
-      productVariationOption: option,
-    }));
-  },
-
-  texts: async (obj, { forceLocale }, { loaders, locale }) => {
-    return loaders.productVariationTextLoader.load({
-      productVariationId: obj._id,
-      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
-    });
-  },
-};

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

@@ -1,71 +0,0 @@
-import { Context } from '../../context.js';
-import { SearchConfiguration } from '@unchainedshop/core-filters';
-
-export interface SearchResultData {
-  searchConfiguration: SearchConfiguration & { productSelector: any };
-  totalProductIds: string[];
-  aggregatedTotalProductIds: string[];
-  aggregatedFilteredProductIds: 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 || {}, {
-      locale: context.locale,
-      userId: context.userId,
-      productIds: relevantProductIds,
-      forceLiveCollection: searchConfiguration.forceLiveCollection,
-    });
-  },
-};