@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc2

package/src/directors/DeliveryDirector.ts

@@ -0,0 +1,135 @@
+import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
+import {
+  DeliveryAdapterActions,
+  DeliveryContext,
+  IDeliveryAdapter,
+  DeliveryError,
+} from './DeliveryAdapter.js';
+import { DeliveryProvider } from '@unchainedshop/core-delivery';
+import { OrderDelivery, OrderDeliveryStatus } from '@unchainedshop/core-orders';
+import { Modules } from '../modules.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:core');
+
+export type IDeliveryDirector = IBaseDirector<IDeliveryAdapter> & {
+  sendOrderDelivery: (
+    orderDelivery: OrderDelivery,
+    transactionContext: Record<string, any>,
+    unchainedAPI: { modules: Modules },
+  ) => Promise<OrderDelivery>;
+  actions: (
+    deliveryProvider: DeliveryProvider,
+    deliveryContext: DeliveryContext,
+    unchainedAPI: { modules: Modules },
+  ) => Promise<DeliveryAdapterActions>;
+};
+
+const baseDirector = BaseDirector<IDeliveryAdapter>('DeliveryDirector');
+
+export const DeliveryDirector: IDeliveryDirector = {
+  ...baseDirector,
+
+  actions: async (deliveryProvider, deliveryContext, unchainedAPI) => {
+    const Adapter = baseDirector.getAdapter(deliveryProvider.adapterKey);
+
+    const context = { ...deliveryContext, ...unchainedAPI };
+    const adapter = Adapter?.actions(deliveryProvider.configuration, context);
+
+    return {
+      configurationError: () => {
+        try {
+          return adapter.configurationError();
+        } catch {
+          return DeliveryError.ADAPTER_NOT_FOUND;
+        }
+      },
+
+      estimatedDeliveryThroughput: async (warehousingThroughputTime) => {
+        try {
+          const throughput = await adapter.estimatedDeliveryThroughput(warehousingThroughputTime);
+          return throughput;
+        } catch (error) {
+          logger.warn('Delivery Director -> Error while estimating delivery throughput', {
+            ...error,
+          });
+          return null;
+        }
+      },
+
+      isActive: () => {
+        try {
+          return adapter.isActive();
+        } catch (error) {
+          logger.warn('Delivery Director -> Error while checking if is active', {
+            ...error,
+          });
+          return false;
+        }
+      },
+
+      isAutoReleaseAllowed: () => {
+        try {
+          return adapter.isAutoReleaseAllowed();
+        } catch (error) {
+          logger.warn('Delivery Director -> Error while checking if auto release is allowed', {
+            ...error,
+          });
+          return false;
+        }
+      },
+
+      send: async () => {
+        return adapter.send();
+      },
+
+      pickUpLocationById: async (locationId) => {
+        return adapter.pickUpLocationById(locationId);
+      },
+
+      pickUpLocations: async () => {
+        return adapter.pickUpLocations();
+      },
+    };
+  },
+
+  sendOrderDelivery: async (orderDelivery, transactionContext, unchainedAPI) => {
+    if (
+      unchainedAPI.modules.orders.deliveries.normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN
+    )
+      return orderDelivery;
+
+    const order = await unchainedAPI.modules.orders.findOrder({ orderId: orderDelivery.orderId });
+    const deliveryProvider = await unchainedAPI.modules.delivery.findProvider({
+      deliveryProviderId: orderDelivery.deliveryProviderId,
+    });
+    const deliveryProviderId = deliveryProvider._id;
+    const address = orderDelivery.context?.address || order || order.billingAddress;
+    const provider = await await unchainedAPI.modules.delivery.findProvider({ deliveryProviderId });
+
+    const adapter = await DeliveryDirector.actions(
+      provider,
+      {
+        order,
+        orderDelivery,
+        transactionContext: {
+          ...(transactionContext || {}),
+          ...(orderDelivery.context || {}),
+          ...(address || {}),
+        },
+      },
+      unchainedAPI,
+    );
+
+    const arbitraryResponseData = await adapter.send();
+
+    if (arbitraryResponseData) {
+      return await unchainedAPI.modules.orders.deliveries.updateStatus(orderDelivery._id, {
+        status: OrderDeliveryStatus.DELIVERED,
+        info: JSON.stringify(arbitraryResponseData),
+      });
+    }
+
+    return orderDelivery;
+  },
+};

package/src/directors/DeliveryPricingAdapter.ts

@@ -0,0 +1,87 @@
+import { DeliveryPricingSheet } from './DeliveryPricingSheet.js';
+import {
+  BasePricingAdapterContext,
+  IPricingAdapter,
+  IPricingSheet,
+  BasePricingAdapter,
+} from '../directors/index.js';
+import { DeliveryProvider } from '@unchainedshop/core-delivery';
+import { PricingCalculation } from '@unchainedshop/utils';
+import { OrderDelivery, OrderDiscount, Order } from '@unchainedshop/core-orders';
+import { User } from '@unchainedshop/core-users';
+import { Modules } from '../modules.js';
+
+export interface DeliveryPricingCalculation extends PricingCalculation {
+  discountId?: string;
+  isNetPrice: boolean;
+  isTaxable: boolean;
+  rate?: number;
+}
+
+export type IDeliveryPricingSheet = IPricingSheet<DeliveryPricingCalculation> & {
+  addFee: (params: { amount: number; isTaxable: boolean; isNetPrice: boolean; meta?: any }) => void;
+  addTax: (params: {
+    amount: number;
+    rate: number;
+    baseCategory?: string;
+    discountId?: string;
+    meta?: any;
+  }) => void;
+  addDiscount: (params: {
+    amount: number;
+    isTaxable: boolean;
+    isNetPrice: boolean;
+    discountId: string;
+    meta?: any;
+  }) => void;
+};
+
+export interface DeliveryPricingAdapterContext extends BasePricingAdapterContext {
+  country?: string;
+  currency?: string;
+  provider: DeliveryProvider;
+  providerContext?: any;
+  order: Order;
+  orderDelivery: OrderDelivery;
+  user: User;
+  discounts: Array<OrderDiscount>;
+}
+
+export type IDeliveryPricingAdapter<DiscountConfiguration = unknown> = IPricingAdapter<
+  DeliveryPricingAdapterContext & { modules: Modules },
+  DeliveryPricingCalculation,
+  IDeliveryPricingSheet,
+  DiscountConfiguration
+>;
+
+const basePricingAdapter = BasePricingAdapter<
+  DeliveryPricingAdapterContext,
+  DeliveryPricingCalculation
+>();
+
+export const DeliveryPricingAdapter: IDeliveryPricingAdapter = {
+  ...basePricingAdapter,
+
+  isActivatedFor: () => {
+    return false;
+  },
+
+  actions: (params) => {
+    const { context } = params;
+    const { currency } = context;
+    const baseActions = basePricingAdapter.actions(params);
+    const resultSheet = DeliveryPricingSheet({ currency });
+
+    return {
+      ...baseActions,
+      calculate: async () => {
+        const resultRaw = resultSheet.getRawPricingSheet();
+        resultRaw.forEach(({ amount, category }) =>
+          basePricingAdapter.log(`Delivery Calculation -> ${category} ${amount}`),
+        );
+        return resultRaw;
+      },
+      resultSheet: () => resultSheet,
+    };
+  },
+};

package/src/directors/DeliveryPricingDirector.ts

@@ -0,0 +1,92 @@
+import { DeliveryPricingSheet, BasePricingDirector, IPricingDirector } from '../directors/index.js';
+
+import {
+  DeliveryPricingAdapterContext,
+  DeliveryPricingCalculation,
+  IDeliveryPricingAdapter,
+  IDeliveryPricingSheet,
+} from './DeliveryPricingAdapter.js';
+import { DeliveryProvider } from '@unchainedshop/core-delivery';
+
+import type { Order } from '@unchainedshop/core-orders';
+import type { User } from '@unchainedshop/core-users';
+import type { OrderDelivery } from '@unchainedshop/core-orders';
+
+export type DeliveryPricingContext =
+  | {
+      currency: string;
+      country?: string;
+      provider: DeliveryProvider;
+      providerContext?: any;
+      order: Order;
+      user: User;
+    }
+  | { currency: string; item: OrderDelivery };
+
+export type IDeliveryPricingDirector<DiscountConfiguration = unknown> = IPricingDirector<
+  DeliveryPricingContext,
+  DeliveryPricingCalculation,
+  DeliveryPricingAdapterContext,
+  IDeliveryPricingSheet,
+  IDeliveryPricingAdapter<DiscountConfiguration>
+>;
+
+const baseDirector = BasePricingDirector<
+  DeliveryPricingContext,
+  DeliveryPricingAdapterContext,
+  DeliveryPricingCalculation,
+  IDeliveryPricingAdapter
+>('DeliveryPricingDirector');
+
+export const DeliveryPricingDirector: IDeliveryPricingDirector<any> = {
+  ...baseDirector,
+
+  async buildPricingContext(context, unchainedAPI) {
+    const { modules } = unchainedAPI;
+
+    if ('item' in context) {
+      const { item, currency } = context;
+      const order = await modules.orders.findOrder({
+        orderId: item.orderId,
+      });
+      const provider = await modules.delivery.findProvider({
+        deliveryProviderId: item.deliveryProviderId,
+      });
+      const user = await modules.users.findUserById(order.userId);
+      const discounts = await modules.orders.discounts.findOrderDiscounts({
+        orderId: item.orderId,
+      });
+
+      return {
+        ...unchainedAPI,
+        country: order.countryCode,
+        currency,
+        order,
+        provider,
+        user,
+        discounts,
+        orderDelivery: item,
+        providerContext: null,
+      };
+    }
+
+    return {
+      ...unchainedAPI,
+      country: context.country,
+      currency: context.currency,
+      order: context.order,
+      provider: context.provider,
+      user: context.user,
+      discounts: [],
+      orderDelivery: null,
+      providerContext: context.providerContext,
+    };
+  },
+
+  calculationSheet(pricingContext, calculation) {
+    return DeliveryPricingSheet({
+      calculation,
+      currency: pricingContext.currency,
+    });
+  },
+};

package/src/directors/DeliveryPricingSheet.ts

@@ -0,0 +1,86 @@
+import { BasePricingSheet, IBasePricingSheet, PricingSheetParams } from '../directors/index.js';
+import { DeliveryPricingCalculation, IDeliveryPricingSheet } from './DeliveryPricingAdapter.js';
+
+export enum DeliveryPricingRowCategory {
+  Delivery = 'DELIVERY',
+  Discount = 'DISCOUNT',
+  Tax = 'TAX',
+  Item = 'ITEM', // Propably unused
+}
+
+export const DeliveryPricingSheet = (
+  params: PricingSheetParams<DeliveryPricingCalculation>,
+): IDeliveryPricingSheet => {
+  const basePricingSheet: IBasePricingSheet<DeliveryPricingCalculation> = BasePricingSheet(params);
+
+  const pricingSheet: IDeliveryPricingSheet = {
+    ...basePricingSheet,
+
+    addDiscount({ amount, isTaxable, isNetPrice, discountId, meta }) {
+      basePricingSheet.calculation.push({
+        category: DeliveryPricingRowCategory.Discount,
+        amount,
+        isTaxable,
+        isNetPrice,
+        discountId,
+        meta,
+      });
+    },
+
+    addFee({ amount, isTaxable, isNetPrice, meta }) {
+      basePricingSheet.calculation.push({
+        amount,
+        category: DeliveryPricingRowCategory.Delivery,
+        isNetPrice,
+        isTaxable,
+        meta,
+      });
+    },
+
+    addTax({ amount, rate, meta }) {
+      basePricingSheet.calculation.push({
+        amount,
+        category: DeliveryPricingRowCategory.Tax,
+        isNetPrice: false,
+        isTaxable: false,
+        meta,
+        rate,
+      });
+    },
+
+    taxSum(filter) {
+      return basePricingSheet.sum({
+        category: DeliveryPricingRowCategory.Tax,
+        ...(filter || {}),
+      });
+    },
+
+    discountPrices(explicitDiscountId) {
+      const discountIds = pricingSheet
+        .filterBy({
+          category: DeliveryPricingRowCategory.Discount,
+          discountId: explicitDiscountId,
+        })
+        .map(({ discountId }) => discountId);
+
+      return [...new Set(discountIds)]
+        .map((discountId) => {
+          const { currency, amount } = basePricingSheet.total({
+            category: DeliveryPricingRowCategory.Discount,
+            discountId,
+          });
+          if (!amount) {
+            return null;
+          }
+          return {
+            discountId,
+            amount: Math.round(amount),
+            currency,
+          };
+        })
+        .filter(Boolean);
+    },
+  };
+
+  return pricingSheet;
+};

package/src/directors/EnrollmentAdapter.ts

@@ -0,0 +1,109 @@
+import { IBaseAdapter } from '@unchainedshop/utils';
+import { log, LogLevel } from '@unchainedshop/logger';
+import { add } from 'date-fns/add';
+import { Enrollment, EnrollmentPeriod, EnrollmentPlan } from '@unchainedshop/core-enrollments';
+import type { Product, ProductPlan } from '@unchainedshop/core-products';
+import type { OrderPosition } from '@unchainedshop/core-orders';
+
+export type EnrollmentContext = {
+  enrollment: Enrollment;
+};
+
+export interface EnrollmentAdapterActions {
+  configurationForOrder: (params: {
+    period: EnrollmentPeriod;
+    products: Array<Product>;
+  }) => Promise<any>;
+  isOverdue: () => Promise<boolean>;
+  isValidForActivation: () => Promise<boolean>;
+  nextPeriod: () => Promise<EnrollmentPeriod>;
+}
+
+export type IEnrollmentAdapter = IBaseAdapter & {
+  isActivatedFor: (productPlan?: ProductPlan) => boolean;
+
+  transformOrderItemToEnrollmentPlan: (
+    orderPosition: OrderPosition,
+    unchainedAPI,
+  ) => Promise<EnrollmentPlan>;
+
+  actions: (params: EnrollmentContext) => EnrollmentAdapterActions;
+};
+export const periodForReferenceDate = (referenceDate: Date, intervalCount = 1, interval = 'WEEKS') => {
+  const lowerCaseInterval = interval.toLowerCase();
+
+  const start = new Date(referenceDate);
+  if (lowerCaseInterval === 'hours') {
+    start.setMinutes(0, 0, 0);
+  } else {
+    start.setSeconds(0, 0);
+  }
+
+  return {
+    start,
+    end: add(start, {
+      [lowerCaseInterval]: intervalCount,
+    }),
+  };
+};
+
+export const EnrollmentAdapter: Omit<IEnrollmentAdapter, 'key' | 'label' | 'version'> = {
+  isActivatedFor: () => {
+    return false;
+  },
+
+  transformOrderItemToEnrollmentPlan: async (item) => {
+    return {
+      configuration: item.configuration,
+      productId: item.productId,
+      quantity: item.quantity,
+    };
+  },
+
+  actions: (context) => {
+    return {
+      configurationForOrder: async () => {
+        throw new Error(`Not implemented on EnrollmentAdapter`);
+      },
+
+      isOverdue: async () => false,
+      isValidForActivation: async () => false,
+
+      nextPeriod: async () => {
+        const { enrollment } = context;
+        const product = await (context as any).modules.products.findProduct({
+          productId: enrollment.productId,
+        });
+        const plan = product?.plan;
+        const referenceDate = new Date();
+        if (!plan) return null;
+
+        if (plan.trialIntervalCount && !enrollment?.periods?.length) {
+          return {
+            ...periodForReferenceDate(referenceDate, plan.trialIntervalCount, plan.trialInterval),
+            isTrial: true,
+          };
+        }
+
+        const lastEnd = enrollment?.periods?.reduce((acc, item) => {
+          if (!acc) return item.end;
+          const endDate = new Date(item.end);
+          if (acc.getTime() < endDate.getTime()) {
+            return endDate;
+          }
+          return acc;
+        }, referenceDate);
+
+        return {
+          ...periodForReferenceDate(lastEnd, plan.billingIntervalCount, plan.billingInterval),
+          isTrial: false,
+        };
+      },
+    };
+  },
+
+  // eslint-disable-next-line
+  log(message: string, { level = LogLevel.Debug, ...options } = {}) {
+    return log(message, { level, ...options });
+  },
+};

package/src/directors/EnrollmentDirector.ts

@@ -0,0 +1,70 @@
+import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
+import { EnrollmentAdapterActions, EnrollmentContext, IEnrollmentAdapter } from './EnrollmentAdapter.js';
+import type { OrderPosition } from '@unchainedshop/core-orders';
+import type { Product, ProductPlan } from '@unchainedshop/core-products';
+import { Enrollment } from '@unchainedshop/core-enrollments';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:core');
+
+export type IEnrollmentDirector = IBaseDirector<IEnrollmentAdapter> & {
+  transformOrderItemToEnrollment: (
+    item: { orderPosition: OrderPosition; product: Product },
+    doc: Omit<Enrollment, 'configuration' | 'productId' | 'quantity' | 'status' | 'periods' | 'log'>,
+    unchainedAPI,
+  ) => Promise<Omit<Enrollment, 'status' | 'periods' | 'log'>>;
+
+  actions: (enrollmentContext: EnrollmentContext, unchainedAPI) => Promise<EnrollmentAdapterActions>;
+};
+
+const baseDirector = BaseDirector<IEnrollmentAdapter>('EnrollmentDirector', {
+  adapterSortKey: 'orderIndex',
+});
+
+const findAppropriateAdapters = (productPlan?: ProductPlan) =>
+  baseDirector.getAdapters({
+    adapterFilter: (Adapter: IEnrollmentAdapter) => {
+      const activated = Adapter.isActivatedFor(productPlan);
+      if (!activated) {
+        logger.warn(`Enrollment Director -> ${Adapter.key} (${Adapter.version}) skipped`);
+      }
+      return activated;
+    },
+  });
+
+export const EnrollmentDirector: IEnrollmentDirector = {
+  ...baseDirector,
+
+  transformOrderItemToEnrollment: async ({ orderPosition, product }, doc, unchainedAPI) => {
+    const Adapter = findAppropriateAdapters(product.plan)?.[0];
+    if (!Adapter) {
+      throw new Error('No suitable enrollment plugin available for this item');
+    }
+
+    const enrollmentPlan = await Adapter.transformOrderItemToEnrollmentPlan(orderPosition, unchainedAPI);
+
+    return {
+      ...doc,
+      ...enrollmentPlan,
+      configuration: [],
+    };
+  },
+
+  actions: async (enrollmentContext, unchainedAPI) => {
+    const context = { ...enrollmentContext, ...unchainedAPI };
+
+    // Resolve adapter
+    const product = await context.modules.products.findProduct({
+      productId: context.enrollment.productId,
+    });
+
+    const Adapter = findAppropriateAdapters(product?.plan)?.[0];
+
+    if (!Adapter) {
+      throw new Error('No suitable enrollment plugin available for this plan configuration');
+    }
+    const adapter = Adapter.actions(context);
+
+    return adapter;
+  },
+};

package/src/directors/FilterAdapter.ts

@@ -0,0 +1,103 @@
+import { log, LogLevel } from '@unchainedshop/logger';
+import { Assortment } from '@unchainedshop/core-assortments';
+import { mongodb } from '@unchainedshop/mongodb';
+import { IBaseAdapter } from '@unchainedshop/utils';
+import { Product } from '@unchainedshop/core-products';
+import { Filter, SearchQuery } from '@unchainedshop/core-filters';
+import { Modules } from '../modules.js';
+
+export type FilterInputText = { locale: string; title: string; subtitle?: string };
+
+export enum FilterError {
+  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',
+}
+
+export type FilterContext = {
+  filter?: Filter;
+  searchQuery: SearchQuery;
+};
+
+export interface FilterAdapterActions {
+  aggregateProductIds: (params: { productIds: Array<string> }) => Array<string>;
+
+  searchAssortments: (
+    params: {
+      assortmentIds: Array<string>;
+    },
+    options?: {
+      filterSelector: mongodb.Filter<Filter>;
+      assortmentSelector: mongodb.Filter<Assortment>;
+      sortStage: mongodb.FindOptions['sort'];
+    },
+  ) => Promise<Array<string>>;
+
+  searchProducts: (
+    params: {
+      productIds: Array<string>;
+    },
+    options?: {
+      filterSelector: mongodb.Filter<Filter>;
+      productSelector: mongodb.Filter<Product>;
+      sortStage: mongodb.FindOptions['sort'];
+    },
+  ) => Promise<Array<string>>;
+
+  transformFilterSelector: (
+    query: mongodb.Filter<Filter>,
+    options?: any,
+  ) => Promise<mongodb.Filter<Filter>>;
+  transformProductSelector: (
+    query: mongodb.Filter<Product>,
+    options?: { key?: string; value?: any },
+  ) => Promise<mongodb.Filter<Product>>;
+  transformSortStage: (
+    sort: mongodb.FindOptions['sort'],
+    options?: { key: string; value?: any },
+  ) => Promise<mongodb.FindOptions['sort']>;
+}
+
+export type IFilterAdapter = IBaseAdapter & {
+  orderIndex: number;
+
+  actions: (params: FilterContext & { modules: Modules }) => FilterAdapterActions;
+};
+
+export const FilterAdapter: Omit<IFilterAdapter, 'key' | 'label' | 'version'> = {
+  orderIndex: 0,
+
+  actions: () => {
+    return {
+      // This function is called to check if a filter actually matches a certain productId
+      aggregateProductIds: ({ productIds }) => {
+        return productIds;
+      },
+
+      searchProducts: async ({ productIds }) => {
+        return productIds;
+      },
+
+      searchAssortments: async ({ assortmentIds }) => {
+        return assortmentIds;
+      },
+
+      transformSortStage: async (lastStage) => {
+        return lastStage;
+      },
+
+      // return a selector that is applied to Products.find to find relevant products
+      // if no key is provided, it expects either null for all products or a list of products that are relevant
+      transformProductSelector: async (lastSelector) => {
+        return lastSelector;
+      },
+
+      // return a selector that is applied to Filters.find to find relevant filters
+      transformFilterSelector: async (lastSelector) => {
+        return lastSelector;
+      },
+    };
+  },
+
+  log(message: string, { level = LogLevel.Debug, ...options } = {}) {
+    return log(message, { level, ...options });
+  },
+};