@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc2

package/src/directors/FilterDirector.ts

@@ -0,0 +1,309 @@
+import { mongodb } from '@unchainedshop/mongodb';
+import { BaseDirector, IBaseDirector, intersectSet } from '@unchainedshop/utils';
+import { FilterAdapterActions, FilterContext, IFilterAdapter } from './FilterAdapter.js';
+import {
+  Filter,
+  filtersSettings,
+  FilterType,
+  SearchConfiguration,
+  SearchFilterQuery,
+  SearchQuery,
+} from '@unchainedshop/core-filters';
+import { Product } from '@unchainedshop/core-products';
+import { Modules } from '../modules.js';
+
+export const parseQueryArray = (query: SearchFilterQuery): Record<string, Array<string>> =>
+  (query || []).reduce(
+    (accumulator, { key, value }) => ({
+      ...accumulator,
+      [key]: accumulator[key] ? accumulator[key].concat(value) : [value],
+    }),
+    {},
+  );
+
+export type IFilterDirector = IBaseDirector<IFilterAdapter> & {
+  actions: (filterContext: FilterContext, unchainedAPI) => Promise<FilterAdapterActions>;
+  invalidateProductIdCache: (filter: Filter, unchainedAPI) => Promise<void>;
+  findProductIds: (
+    filter: Filter,
+    { value }: { value?: boolean | string },
+    unchainedAPI: { modules: Modules },
+  ) => Promise<Array<string>>;
+  buildProductIdMap: (
+    filter: Filter,
+    unchainedAPI: { modules: Modules },
+  ) => Promise<[Array<string>, Record<string, Array<string>>]>;
+  filterProductIds: (
+    filter: Filter,
+    { values, forceLiveCollection }: { values: Array<string>; forceLiveCollection?: boolean },
+    unchainedAPI: { modules: Modules },
+  ) => Promise<Array<string>>;
+
+  filterFacets: (
+    filter: Filter,
+    params: {
+      searchQuery: SearchQuery;
+      forceLiveCollection?: boolean;
+      allProductIds: Array<string>;
+      otherFilters: Array<Filter>;
+    },
+    unchainedAPI: { modules: Modules },
+  ) => Promise<{
+    examinedProductIdSet: Set<string>;
+    filteredByOtherFiltersSet: Set<string>;
+    filteredByThisFilterSet: Set<string>;
+  }>;
+
+  productFacetedSearch: (
+    productIds: Array<string>,
+    searchConfiguration: SearchConfiguration,
+    unchainedAPI: { modules: Modules },
+  ) => Promise<Array<string>>;
+};
+
+const baseDirector = BaseDirector<IFilterAdapter>('FilterDirector', {
+  adapterSortKey: 'orderIndex',
+});
+
+export const FilterDirector: IFilterDirector = {
+  ...baseDirector,
+
+  actions: async (filterContext, unchainedAPI) => {
+    const context = { ...filterContext, ...unchainedAPI };
+    const adapters = baseDirector.getAdapters().map((Adapter) => Adapter.actions(context));
+
+    const reduceAdapters = <V>(
+      reducer: (currentValue: Promise<V>, adapter: FilterAdapterActions, index: number) => Promise<V>,
+      initialValue: V,
+    ) => {
+      if (adapters.length === 0) {
+        return null;
+      }
+      return adapters.reduce(async (lastSearchPromise, adapter, index) => {
+        return reducer(lastSearchPromise, adapter, index);
+      }, Promise.resolve(initialValue));
+    };
+
+    return {
+      aggregateProductIds: (params) => {
+        const reducedProductIds = adapters.reduce(
+          (productIds, adapter) => adapter.aggregateProductIds({ productIds }),
+          params.productIds,
+        );
+        return reducedProductIds;
+      },
+
+      searchAssortments: async (params) => {
+        return reduceAdapters<Array<string>>(async (lastSearchPromise, adapter) => {
+          const assortmentIds = await lastSearchPromise;
+          return adapter.searchAssortments({ assortmentIds });
+        }, params.assortmentIds);
+      },
+
+      searchProducts: async (params) => {
+        return reduceAdapters<Array<string>>(async (lastSearchPromise, adapter) => {
+          const productIds = await lastSearchPromise;
+          return adapter.searchProducts({ productIds });
+        }, params.productIds);
+      },
+
+      transformProductSelector: async (defaultSelector, options) => {
+        return reduceAdapters<mongodb.Filter<Product>>(async (lastSelector, adapter) => {
+          return adapter.transformProductSelector(await lastSelector, options);
+        }, defaultSelector || null);
+      },
+
+      transformSortStage: async (defaultStage, options) => {
+        return reduceAdapters<mongodb.FindOptions<Product>['sort']>(async (lastSortStage, adapter) => {
+          return adapter.transformSortStage(await lastSortStage, options);
+        }, defaultStage || null);
+      },
+
+      transformFilterSelector: async (defaultSelector) => {
+        return reduceAdapters<mongodb.Filter<Filter>>(async (lastSelector, adapter) => {
+          return adapter.transformFilterSelector(await lastSelector);
+        }, defaultSelector || null);
+      },
+    };
+  },
+
+  async findProductIds(
+    filter: Filter,
+    { value }: { value?: boolean | string },
+    unchainedAPI: { modules: Modules },
+  ) {
+    const { modules } = unchainedAPI;
+    const director = await FilterDirector.actions({ filter, searchQuery: {} }, unchainedAPI);
+    const productSelector = await director.transformProductSelector(
+      modules.products.search.buildActiveDraftStatusFilter(),
+      {
+        key: filter.key,
+        value,
+      },
+    );
+
+    if (!productSelector) return [];
+    return modules.products.findProductIds({
+      productSelector,
+      includeDrafts: true,
+    });
+  },
+
+  async buildProductIdMap(
+    filter: Filter,
+    unchainedAPI: { modules: Modules },
+  ): Promise<[Array<string>, Record<string, Array<string>>]> {
+    const allProductIds = await this.findProductIds(filter, {}, unchainedAPI);
+    const productIdsMap =
+      filter.type === FilterType.SWITCH
+        ? {
+            true: await this.findProductIds(filter, { value: true }, unchainedAPI),
+            false: await this.findProductIds(filter, { value: false }, unchainedAPI),
+          }
+        : await (filter.options || []).reduce(async (accumulatorPromise, option) => {
+            const accumulator = await accumulatorPromise;
+            return {
+              ...accumulator,
+              [option]: await this.findProductIds(filter, { value: option }, unchainedAPI),
+            };
+          }, Promise.resolve({}));
+
+    return [allProductIds, productIdsMap];
+  },
+
+  async filterProductIds(
+    filter: Filter,
+    { values, forceLiveCollection }: { values: Array<string>; forceLiveCollection?: boolean },
+    unchainedAPI: { modules: Modules },
+  ) {
+    const [allProductIds, keyToProductIdMap]: [Array<string>, Record<string, Array<string>>] =
+      (!forceLiveCollection && (await filtersSettings.getCachedProductIds(filter._id))) ||
+      (await this.buildProductIdMap(filter, unchainedAPI));
+
+    const filteredKeys = unchainedAPI.modules.filters.parse(
+      filter,
+      values,
+      Object.keys(keyToProductIdMap),
+    );
+    return filteredKeys.reduce((accumulator, key) => {
+      const additionalValues = key === undefined ? allProductIds : keyToProductIdMap[key];
+      return [...accumulator, ...(additionalValues || [])];
+    }, []);
+  },
+
+  async productFacetedSearch(
+    productIds: Array<string>,
+    searchConfiguration: SearchConfiguration,
+    unchainedAPI: { modules: Modules },
+  ): Promise<Array<string>> {
+    const { searchQuery, filterSelector, forceLiveCollection } = searchConfiguration;
+    const { modules } = unchainedAPI;
+    if (!searchQuery || !searchQuery.filterQuery) return productIds;
+
+    const parsedFilterQuery = parseQueryArray(searchQuery.filterQuery);
+
+    const filters = filterSelector
+      ? await modules.filters.findFilters({
+          ...filterSelector,
+          limit: 0,
+          includeInactive: true,
+        })
+      : [];
+
+    const intersectedProductIds = await filters.reduce(
+      async (productIdSetPromise: Promise<Set<string>>, filter) => {
+        const productIdSet = await productIdSetPromise;
+
+        if (!parsedFilterQuery[filter.key]) return productIdSet;
+
+        const values = parsedFilterQuery[filter.key];
+
+        const filterOptionProductIds = await this.filterProductIds(
+          filter,
+          {
+            values,
+            forceLiveCollection,
+          },
+          unchainedAPI,
+        );
+
+        return intersectSet(productIdSet, new Set(filterOptionProductIds));
+      },
+      Promise.resolve(new Set(productIds)),
+    );
+
+    return [...intersectedProductIds];
+  },
+
+  async filterFacets(filter, params, unchainedAPI) {
+    const { allProductIds, searchQuery, forceLiveCollection, otherFilters } = params;
+
+    const filterQueryParsed = parseQueryArray(searchQuery?.filterQuery);
+
+    // The examinedProductIdSet is a set of product id's that:
+    // - Fit this filter generally
+    // - Are part of the preselected product id array
+    const filteredProductIds = await this.filterProductIds(
+      filter,
+      {
+        values: [undefined],
+        forceLiveCollection,
+      },
+      unchainedAPI,
+    );
+
+    const examinedProductIdSet = intersectSet(new Set(allProductIds), new Set(filteredProductIds));
+    const values = filterQueryParsed[filter.key];
+
+    // The filteredProductIdSet is a set of product id's that:
+    // - Are filtered by all other filters
+    // - Are filtered by the currently selected value of this filter
+    // or if there is no currently selected value:
+    // - Is the same like examinedProductIdSet
+    const filteredByOtherFiltersSet = await otherFilters
+      .filter((otherFilter) => otherFilter.key !== filter.key)
+      .reduce(
+        async (productIdSetPromise, otherFilter) => {
+          if (otherFilter.key === filter.key) return productIdSetPromise;
+          if (!filterQueryParsed[otherFilter.key]) return productIdSetPromise;
+          const productIdSet = await productIdSetPromise;
+          const otherFilterProductIds = await this.filterProductIds(
+            otherFilter,
+            {
+              values: filterQueryParsed[otherFilter.key],
+              forceLiveCollection,
+            },
+            unchainedAPI,
+          );
+          return intersectSet(productIdSet, new Set(otherFilterProductIds));
+        },
+        Promise.resolve(new Set(examinedProductIdSet)),
+      );
+
+    const filterProductIdsForValues = values
+      ? await this.filterProductIds(
+          filter,
+          {
+            values,
+            forceLiveCollection,
+          },
+          unchainedAPI,
+        )
+      : filteredProductIds;
+
+    const filteredByThisFilterSet = new Set<string>(filterProductIdsForValues);
+
+    return {
+      examinedProductIdSet,
+      filteredByOtherFiltersSet,
+      filteredByThisFilterSet,
+    };
+  },
+
+  async invalidateProductIdCache(filter: Filter, unchainedAPI: { modules: Modules }) {
+    if (!filter) return;
+
+    const [productIds, productIdMap] = await this.buildProductIdMap(filter, unchainedAPI);
+    await filtersSettings.setCachedProductIds(filter._id, productIds, productIdMap);
+  },
+};

package/src/directors/MessagingDirector.test.ts

@@ -0,0 +1,5 @@
+describe('MessagingDirector', () => {
+  it('Stub', () => {
+    expect(true).toBe(true);
+  });
+});

package/src/directors/MessagingDirector.ts

@@ -0,0 +1,59 @@
+import { log } from '@unchainedshop/logger';
+
+export type EmailTemplateType = {
+  type: 'EMAIL';
+  input: {
+    from: string;
+    to: string;
+    cc?: string;
+    subject: string;
+    text: string;
+    html?: string;
+    attachments?: Array<
+      | { filename: string; path: string }
+      | {
+          filename: string;
+          content: string;
+          contentType: string;
+          encoding: string;
+        }
+      | { href: string; filename: string }
+    >;
+  };
+};
+
+export type SMSTemplateType = {
+  type: 'SMS';
+  input: {
+    from: string;
+    to: string;
+    text: string;
+  };
+};
+
+export type ArbitraryTemplateType = {
+  type: string;
+  input: any;
+};
+
+export type TemplateResolver<T = { [x: string]: any }> = (
+  params: { template: string } & T,
+  unchainedAPI,
+) => Promise<Array<EmailTemplateType | SMSTemplateType | ArbitraryTemplateType>>;
+
+export type IMessagingDirector = {
+  registerTemplate: (templateName: string, templateResolver: TemplateResolver) => void;
+  getTemplate: (templateName: string) => TemplateResolver;
+};
+
+const TemplateResolvers = new Map<string, TemplateResolver>();
+
+export const MessagingDirector: IMessagingDirector = {
+  registerTemplate: (templateName, templateResolver) => {
+    log(`MessagingDirector -> Registered template resolver for ${templateName}`);
+
+    TemplateResolvers.set(templateName, templateResolver);
+  },
+
+  getTemplate: (templateName) => TemplateResolvers.get(templateName),
+};

package/src/directors/OrderDiscountAdapter.ts

@@ -0,0 +1,10 @@
+import {
+  BaseDiscountAdapter,
+  IDiscountAdapter,
+  OrderDiscountConfiguration,
+} from '../directors/index.js';
+
+export const OrderDiscountAdapter: Omit<
+  IDiscountAdapter<OrderDiscountConfiguration, any>,
+  'key' | 'label' | 'version'
+> = BaseDiscountAdapter;

package/src/directors/OrderDiscountConfiguration.ts

@@ -0,0 +1,5 @@
+export interface OrderDiscountConfiguration {
+  fixedRate?: number;
+  rate?: number;
+  isNetPrice?: boolean;
+}

package/src/directors/OrderDiscountDirector.ts

@@ -0,0 +1,6 @@
+import { BaseDiscountDirector } from './BaseDiscountDirector.js';
+import { OrderDiscountConfiguration } from './OrderDiscountConfiguration.js';
+
+export const OrderDiscountDirector = BaseDiscountDirector<OrderDiscountConfiguration, any>(
+  'OrderDiscountDirector',
+);

package/src/directors/OrderPricingAdapter.ts

@@ -0,0 +1,63 @@
+import {
+  IOrderPricingSheet,
+  OrderPricingCalculation,
+  OrderPricingSheet,
+  BasePricingAdapter,
+  IPricingAdapter,
+  BasePricingAdapterContext,
+} from '../directors/index.js';
+import {
+  Order,
+  OrderDelivery,
+  OrderDiscount,
+  OrderPayment,
+  OrderPosition,
+} from '@unchainedshop/core-orders';
+import { User } from '@unchainedshop/core-users';
+import { Modules } from '../modules.js';
+
+export interface OrderPricingAdapterContext extends BasePricingAdapterContext {
+  currency?: string;
+  discounts: Array<OrderDiscount>;
+  order: Order;
+  orderDelivery: OrderDelivery;
+  orderPositions: Array<OrderPosition>;
+  orderPayment: OrderPayment;
+  user: User;
+}
+
+export type IOrderPricingAdapter<DiscountConfiguration = unknown> = IPricingAdapter<
+  OrderPricingAdapterContext & { modules: Modules },
+  OrderPricingCalculation,
+  IOrderPricingSheet,
+  DiscountConfiguration
+>;
+
+const basePricingAdapter = BasePricingAdapter<OrderPricingAdapterContext, OrderPricingCalculation>();
+
+export const OrderPricingAdapter: IOrderPricingAdapter = {
+  ...basePricingAdapter,
+
+  isActivatedFor: () => {
+    return false;
+  },
+
+  actions: (params) => {
+    const { context } = params;
+    const { currency } = context;
+    const baseActions = basePricingAdapter.actions(params);
+    const resultSheet = OrderPricingSheet({ currency });
+
+    return {
+      ...baseActions,
+      calculate: async () => {
+        const resultRaw = resultSheet.getRawPricingSheet();
+        resultRaw.forEach(({ amount, category }) =>
+          basePricingAdapter.log(`Order Pricing Calculation -> ${category} ${amount}`),
+        );
+        return resultRaw;
+      },
+      resultSheet: () => resultSheet,
+    };
+  },
+};

package/src/directors/OrderPricingDirector.ts

@@ -0,0 +1,74 @@
+import {
+  IOrderPricingSheet,
+  OrderPricingCalculation,
+  OrderPricingSheet,
+  IOrderPricingAdapter,
+  OrderPricingAdapterContext,
+  BasePricingDirector,
+  PricingDiscount,
+  IPricingDirector,
+} from '../directors/index.js';
+import { Order, OrderDelivery, OrderPayment, OrderPosition } from '@unchainedshop/core-orders';
+
+export interface OrderPricingContext {
+  currency: string;
+  order: Order;
+  orderDelivery: OrderDelivery;
+  orderPositions: Array<OrderPosition>;
+  orderPayment: OrderPayment;
+}
+
+export type OrderPricingDiscount = PricingDiscount & {
+  delivery?: OrderDelivery;
+  item?: OrderPosition;
+  order?: Order;
+  payment?: OrderPayment;
+};
+
+export type IOrderPricingDirector<DiscountConfiguration = unknown> = IPricingDirector<
+  OrderPricingContext,
+  OrderPricingCalculation,
+  OrderPricingAdapterContext,
+  IOrderPricingSheet,
+  IOrderPricingAdapter<DiscountConfiguration>
+>;
+
+const baseDirector = BasePricingDirector<
+  OrderPricingContext,
+  OrderPricingAdapterContext,
+  OrderPricingCalculation,
+  IOrderPricingAdapter
+>('OrderPricingDirector');
+
+export const OrderPricingDirector: IOrderPricingDirector<any> = {
+  ...baseDirector,
+
+  buildPricingContext: async (context, unchainedAPI) => {
+    const { modules } = unchainedAPI;
+    const { order, currency } = context;
+
+    const user = await modules.users.findUserById(order.userId);
+    const discounts = await modules.orders.discounts.findOrderDiscounts({
+      orderId: order._id,
+    });
+
+    return {
+      ...unchainedAPI,
+      country: order.countryCode,
+      currency,
+      discounts,
+      order,
+      orderDelivery: context.orderDelivery,
+      orderPayment: context.orderPayment,
+      orderPositions: context.orderPositions,
+      user,
+    };
+  },
+
+  calculationSheet(pricingContext, calculation) {
+    return OrderPricingSheet({
+      calculation,
+      currency: pricingContext.currency,
+    });
+  },
+};

package/src/directors/OrderPricingSheet.ts

@@ -0,0 +1,147 @@
+import { PricingCalculation } from '@unchainedshop/utils';
+
+import {
+  BasePricingSheet,
+  IPricingSheet,
+  IBasePricingSheet,
+  PricingSheetParams,
+} from '../directors/index.js';
+
+export interface OrderPricingCalculation extends PricingCalculation {
+  discountId?: string;
+}
+
+export enum OrderPricingRowCategory {
+  Items = 'ITEMS',
+  Discounts = 'DISCOUNTS',
+  Taxes = 'TAXES',
+  Delivery = 'DELIVERY',
+  Payment = 'PAYMENT',
+}
+
+export interface IOrderPricingSheet extends IPricingSheet<OrderPricingCalculation> {
+  addDelivery: (params: { amount: number; taxAmount: number; meta?: any }) => void;
+  addDiscount: (params: { amount: number; taxAmount: number; discountId: string; meta?: any }) => void;
+  addItems: (params: { amount: number; taxAmount: number; meta?: any }) => void;
+  addPayment: (params: { amount: number; taxAmount: number; meta?: any }) => void;
+}
+
+export const OrderPricingSheet = (
+  params: PricingSheetParams<OrderPricingCalculation>,
+): IOrderPricingSheet => {
+  const basePricingSheet: IBasePricingSheet<OrderPricingCalculation> = BasePricingSheet(params);
+
+  const addTaxIfAvailabile = (category: string, taxAmount?: number, meta?: any, discountId?: string) => {
+    if (taxAmount) {
+      basePricingSheet.calculation.push({
+        category: OrderPricingRowCategory.Taxes,
+        amount: taxAmount,
+        baseCategory: category,
+        discountId,
+        meta,
+      });
+    }
+  };
+
+  const pricingSheet: IOrderPricingSheet = {
+    ...basePricingSheet,
+
+    addItems({ amount, taxAmount, meta }) {
+      basePricingSheet.calculation.push({
+        category: OrderPricingRowCategory.Items,
+        amount,
+        meta,
+      });
+
+      addTaxIfAvailabile(OrderPricingRowCategory.Items, taxAmount, meta);
+    },
+
+    addDiscount({ amount, taxAmount, discountId, meta }) {
+      basePricingSheet.calculation.push({
+        category: OrderPricingRowCategory.Discounts,
+        amount,
+        discountId,
+        meta,
+      });
+
+      addTaxIfAvailabile(OrderPricingRowCategory.Discounts, taxAmount, meta, discountId);
+    },
+
+    addDelivery({ amount, taxAmount, meta }) {
+      basePricingSheet.calculation.push({
+        category: OrderPricingRowCategory.Delivery,
+        amount,
+        meta,
+      });
+
+      addTaxIfAvailabile(OrderPricingRowCategory.Delivery, taxAmount, meta);
+    },
+
+    addPayment({ amount, taxAmount, meta }) {
+      basePricingSheet.calculation.push({
+        category: OrderPricingRowCategory.Payment,
+        amount,
+        meta,
+      });
+
+      addTaxIfAvailabile(OrderPricingRowCategory.Payment, taxAmount, meta);
+    },
+
+    taxSum(filter) {
+      return basePricingSheet.sum({
+        category: OrderPricingRowCategory.Taxes,
+        ...(filter || {}),
+      });
+    },
+
+    gross() {
+      // tax is included 2 times, this is only true for Order Pricing!
+      return basePricingSheet.sum() - this.taxSum();
+    },
+
+    net() {
+      return basePricingSheet.sum() - this.taxSum() - this.taxSum();
+    },
+
+    total({ category, useNetPrice, discountId } = { useNetPrice: false }) {
+      const taxAmount = this.taxSum({ baseCategory: category, discountId });
+      const amount = this.sum({ category, discountId }) - taxAmount;
+
+      // Sum does not contain taxes when filtering by category, it's net in that case and gross if there is no category
+      const netAmount = !category ? amount - taxAmount : amount;
+
+      return {
+        amount: Math.round(useNetPrice ? netAmount : netAmount + taxAmount),
+        currency: this.currency,
+      };
+    },
+
+    discountPrices(explicitDiscountId) {
+      const discountIds = pricingSheet
+        .filterBy({
+          category: OrderPricingRowCategory.Discounts,
+          discountId: explicitDiscountId,
+        })
+        .map(({ discountId }) => discountId);
+
+      return [...new Set(discountIds)]
+        .map((discountId) => {
+          const amount = basePricingSheet.sum({
+            category: OrderPricingRowCategory.Discounts,
+            discountId,
+          });
+          if (!amount) {
+            return null;
+          }
+          return {
+            discountId,
+            amount: Math.round(amount),
+            currency: basePricingSheet.currency,
+          };
+        })
+        .filter(Boolean);
+    },
+  };
+
+  return pricingSheet;
+};