@unchainedshop/core-delivery 3.0.0-alpha7 → 3.0.0-rc2

package/src/module/configureDeliveryModule.ts

@@ -1,78 +1,7 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { DeliveryContext, DeliveryInterface, DeliveryProvider, DeliveryProviderType } from '../types.js';
 import { emit, registerEvents } from '@unchainedshop/events';
 import { mongodb, generateDbFilterById, generateDbObjectId, ModuleInput } from '@unchainedshop/mongodb';
-import { DeliveryPricingSheet } from '../director/DeliveryPricingSheet.js';
-import { DeliveryProvidersCollection } from '../db/DeliveryProvidersCollection.js';
+import { DeliveryProvidersCollection, DeliveryProvider } from '../db/DeliveryProvidersCollection.js';
 import { deliverySettings, DeliverySettingsOptions } from '../delivery-settings.js';
-import { DeliveryDirector } from '../director/DeliveryDirector.js';
-import { DeliveryPricingContext, DeliveryPricingDirector } from '../director/DeliveryPricingDirector.js';
-
-import { DeliveryError } from '../delivery-index.js';
-import { Order } from '@unchainedshop/core-orders';
-import {
-  DeliveryPricingCalculation,
-  IDeliveryPricingSheet,
-} from '../director/DeliveryPricingAdapter.js';
-
-export type DeliveryModule = {
-  // Queries
-  count: (query: mongodb.Filter<DeliveryProvider>) => Promise<number>;
-  create: (doc: DeliveryProvider) => Promise<DeliveryProvider>;
-  update: (_id: string, doc: DeliveryProvider) => Promise<DeliveryProvider>;
-  delete: (_id: string) => Promise<DeliveryProvider>;
-
-  findProvider: (
-    query: {
-      deliveryProviderId: string;
-    } & mongodb.Filter<DeliveryProvider>,
-    options?: mongodb.FindOptions,
-  ) => Promise<DeliveryProvider>;
-  findProviders: (
-    query: mongodb.Filter<DeliveryProvider>,
-    options?: mongodb.FindOptions,
-  ) => Promise<Array<DeliveryProvider>>;
-
-  providerExists: (query: { deliveryProviderId: string }) => Promise<boolean>;
-
-  pricingSheet: (params: {
-    calculation: Array<DeliveryPricingCalculation>;
-    currency: string;
-  }) => IDeliveryPricingSheet;
-
-  // Delivery adapter
-  findInterface: (params: DeliveryProvider) => DeliveryInterface;
-  findInterfaces: (params: { type: DeliveryProviderType }) => Array<DeliveryInterface>;
-  findSupported: (
-    params: { order: Order },
-    unchainedAPI: UnchainedCore,
-  ) => Promise<Array<DeliveryProvider>>;
-  determineDefault: (
-    deliveryProviders: Array<DeliveryProvider>,
-    params: { order: Order },
-    unchainedAPI: UnchainedCore,
-  ) => Promise<DeliveryProvider>;
-
-  isActive: (deliveryProvider: DeliveryProvider, unchainedAPI: UnchainedCore) => Promise<boolean>;
-  configurationError: (
-    deliveryProvider: DeliveryProvider,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<DeliveryError>;
-
-  isAutoReleaseAllowed: (
-    deliveryProvider: DeliveryProvider,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<boolean>;
-  calculate: (
-    pricingContext: DeliveryPricingContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<Array<DeliveryPricingCalculation>>;
-  send: (
-    deliveryProviderId: string,
-    deliveryContext: DeliveryContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<any>;
-};
 
 const DELIVERY_PROVIDER_EVENTS: string[] = [
   'DELIVERY_PROVIDER_CREATE',
@@ -80,11 +9,11 @@ const DELIVERY_PROVIDER_EVENTS: string[] = [
   'DELIVERY_PROVIDER_REMOVE',
 ];
 
-const asyncFilter = async (arr, predicate) => {
-  const results = await Promise.all(arr.map(predicate));
-
-  return arr.filter((_v, index) => results[index]);
-};
+export interface DeliveryInterface {
+  _id: string;
+  label: string;
+  version: string;
+}
 
 export const buildFindSelector = ({ type }: mongodb.Filter<DeliveryProvider> = {}) => {
   return { ...(type ? { type } : {}), deleted: null };
@@ -93,43 +22,44 @@ export const buildFindSelector = ({ type }: mongodb.Filter<DeliveryProvider> = {
 export const configureDeliveryModule = async ({
   db,
   options: deliveryOptions = {},
-}: ModuleInput<DeliverySettingsOptions>): Promise<DeliveryModule> => {
+}: ModuleInput<DeliverySettingsOptions>) => {
   registerEvents(DELIVERY_PROVIDER_EVENTS);
 
   deliverySettings.configureSettings(deliveryOptions);
 
   const DeliveryProviders = await DeliveryProvidersCollection(db);
 
-  const getDeliveryAdapter = async (
-    deliveryProviderId: string,
-    deliveryContext: DeliveryContext,
-    unchainedAPI: UnchainedCore,
-  ) => {
-    const provider = await DeliveryProviders.findOne(generateDbFilterById(deliveryProviderId), {});
-
-    return DeliveryDirector.actions(provider, deliveryContext, unchainedAPI);
-  };
-
   return {
     // Queries
-    count: async (query) => {
+    count: async (query: mongodb.Filter<DeliveryProvider>): Promise<number> => {
       const providerCount = await DeliveryProviders.countDocuments(buildFindSelector(query));
       return providerCount;
     },
 
-    findProvider: async ({ deliveryProviderId, ...query }, options) => {
+    findProvider: async (
+      {
+        deliveryProviderId,
+        ...query
+      }: {
+        deliveryProviderId: string;
+      } & mongodb.Filter<DeliveryProvider>,
+      options?: mongodb.FindOptions<DeliveryProvider>,
+    ): Promise<DeliveryProvider> => {
       return DeliveryProviders.findOne(
         deliveryProviderId ? generateDbFilterById(deliveryProviderId) : query,
         options,
       );
     },
 
-    findProviders: async (query, options = { sort: { created: 1 } }) => {
+    findProviders: async (
+      query: mongodb.Filter<DeliveryProvider>,
+      options: mongodb.FindOptions<DeliveryProvider> = { sort: { created: 1 } },
+    ): Promise<Array<DeliveryProvider>> => {
       const providers = DeliveryProviders.find(buildFindSelector(query), options);
       return providers.toArray();
     },
 
-    providerExists: async ({ deliveryProviderId }) => {
+    providerExists: async ({ deliveryProviderId }: { deliveryProviderId: string }): Promise<boolean> => {
       const providerCount = await DeliveryProviders.countDocuments(
         generateDbFilterById(deliveryProviderId, { deleted: null }),
         { limit: 1 },
@@ -137,110 +67,19 @@ export const configureDeliveryModule = async ({
       return !!providerCount;
     },
 
-    // Delivery Adapter
-
-    findInterface: (paymentProvider) => {
-      const Adapter = DeliveryDirector.getAdapter(paymentProvider.adapterKey);
-      if (!Adapter) return null;
-      return {
-        _id: Adapter.key,
-        label: Adapter.label,
-        version: Adapter.version,
-      };
-    },
-
-    findInterfaces: ({ type }) => {
-      return DeliveryDirector.getAdapters({
-        adapterFilter: (Adapter) => Adapter.typeSupported(type),
-      }).map((Adapter) => ({
-        _id: Adapter.key,
-        label: Adapter.label,
-        version: Adapter.version,
-      }));
-    },
-
-    findSupported: async (deliveryContext, unchainedAPI) => {
-      const foundProviders = await DeliveryProviders.find(buildFindSelector({})).toArray();
-      const providers: DeliveryProvider[] = await asyncFilter(
-        foundProviders,
-        async (provider: DeliveryProvider) => {
-          try {
-            const director = await DeliveryDirector.actions(provider, deliveryContext, unchainedAPI);
-            return director.isActive();
-          } catch {
-            return false;
-          }
-        },
-      );
-
-      return deliverySettings.filterSupportedProviders(
-        {
-          providers,
-          order: deliveryContext.order,
-        },
-        unchainedAPI,
-      );
-    },
-
-    determineDefault: async (deliveryProviders, deliveryContext, unchainedAPI) => {
-      return deliverySettings.determineDefaultProvider(
-        {
-          providers: deliveryProviders,
-          ...deliveryContext,
-        },
-        unchainedAPI,
-      );
-    },
-
-    configurationError: async (deliveryProvider, unchainedAPI) => {
-      const director = await DeliveryDirector.actions(deliveryProvider, {}, unchainedAPI);
-      return director.configurationError();
-    },
-
-    isActive: async (deliveryProvider, unchainedAPI) => {
-      const director = await DeliveryDirector.actions(deliveryProvider, {}, unchainedAPI);
-      return Boolean(director.isActive());
-    },
-
-    isAutoReleaseAllowed: async (deliveryProvider, unchainedAPI) => {
-      const director = await DeliveryDirector.actions(deliveryProvider, {}, unchainedAPI);
-      return Boolean(director.isAutoReleaseAllowed());
-    },
-
-    calculate: async (pricingContext, unchainedAPI) => {
-      const pricing = await DeliveryPricingDirector.actions(pricingContext, unchainedAPI);
-      return pricing.calculate();
-    },
-
-    send: async (deliveryProviderId, deliveryContext, unchainedAPI) => {
-      const adapter = await getDeliveryAdapter(deliveryProviderId, deliveryContext, unchainedAPI);
-      return adapter.send();
-    },
-
-    pricingSheet: (params) => {
-      return DeliveryPricingSheet(params);
-    },
-
     // Mutations
-    create: async (doc) => {
-      const Adapter = DeliveryDirector.getAdapter(doc.adapterKey);
-      if (!Adapter) return null;
-
+    create: async (doc: DeliveryProvider): Promise<DeliveryProvider> => {
       const { insertedId: deliveryProviderId } = await DeliveryProviders.insertOne({
         _id: generateDbObjectId(),
         created: new Date(),
-        configuration: Adapter.initialConfiguration,
         ...doc,
       });
-      const deliveryProvider = await DeliveryProviders.findOne(
-        generateDbFilterById(deliveryProviderId),
-        {},
-      );
+      const deliveryProvider = await DeliveryProviders.findOne({ _id: deliveryProviderId }, {});
       await emit('DELIVERY_PROVIDER_CREATE', { deliveryProvider });
       return deliveryProvider;
     },
 
-    update: async (_id: string, doc: DeliveryProvider) => {
+    update: async (_id: string, doc: DeliveryProvider): Promise<DeliveryProvider> => {
       const deliveryProvider = await DeliveryProviders.findOneAndUpdate(
         generateDbFilterById(_id),
         {
@@ -255,7 +94,7 @@ export const configureDeliveryModule = async ({
       return deliveryProvider;
     },
 
-    delete: async (_id) => {
+    delete: async (_id: string): Promise<DeliveryProvider> => {
       const deliveryProvider = await DeliveryProviders.findOneAndUpdate(
         generateDbFilterById(_id),
         {
@@ -270,3 +109,5 @@ export const configureDeliveryModule = async ({
     },
   };
 };
+
+export type DeliveryModule = Awaited<ReturnType<typeof configureDeliveryModule>>;

package/tsconfig.json

@@ -1,11 +1,9 @@
 {
   "extends": "../shared/base.tsconfig.json",
   "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "lib",
+    "declarationDir": "./lib",
+    "rootDir": "./src",
+    "outDir": "./lib"
   },
-  "exclude": ["**/*.test.ts", "**/*.test.js", "tests"],
-  "include": [
-    "./src"
-  ]
-}
+  "exclude": ["**/*.test.ts", "**/*.test.js", "tests", "lib"]
+}

package/src/director/DeliveryAdapter.ts

@@ -1,56 +0,0 @@
-import { log, LogLevel } from '@unchainedshop/logger';
-import { DeliveryError } from './DeliveryError.js';
-import { IDeliveryAdapter } from '../types.js';
-
-export const DeliveryAdapter: Omit<IDeliveryAdapter, 'key' | 'label' | 'version'> = {
-  initialConfiguration: [],
-
-  typeSupported: () => {
-    return false;
-  },
-
-  actions: () => {
-    return {
-      configurationError: () => {
-        return DeliveryError.NOT_IMPLEMENTED;
-      },
-
-      estimatedDeliveryThroughput: async () => {
-        return 0;
-      },
-
-      isActive: () => {
-        return false;
-      },
-
-      isAutoReleaseAllowed: () => {
-        // if you return false here,
-        // the order will need manual confirmation before
-        // unchained will try to invoke send()
-        return true;
-      },
-
-      send: async () => {
-        // if you return true, the status will be changed to DELIVERED
-
-        // if you return false, the order delivery status stays the
-        // same but the order status might change
-
-        // if you throw an error, you cancel the whole checkout process
-        return false;
-      },
-
-      pickUpLocationById: async () => {
-        return null;
-      },
-
-      pickUpLocations: async () => {
-        return [];
-      },
-    };
-  },
-
-  log: (message: string, { level = LogLevel.Debug, ...options } = {}) => {
-    return log(message, { level, ...options });
-  },
-};

package/src/director/DeliveryDirector.ts

@@ -1,76 +0,0 @@
-import { log, LogLevel } from '@unchainedshop/logger';
-import { BaseDirector } from '@unchainedshop/utils';
-import { DeliveryError } from './DeliveryError.js';
-import { IDeliveryAdapter, IDeliveryDirector } from '../types.js';
-
-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) {
-          log('Delivery Director -> Error while estimating delivery throughput', {
-            level: LogLevel.Warning,
-            ...error,
-          });
-          return null;
-        }
-      },
-
-      isActive: () => {
-        try {
-          return adapter.isActive();
-        } catch (error) {
-          log('Delivery Director -> Error while checking if is active', {
-            level: LogLevel.Warning,
-            ...error,
-          });
-          return false;
-        }
-      },
-
-      isAutoReleaseAllowed: () => {
-        try {
-          return adapter.isAutoReleaseAllowed();
-        } catch (error) {
-          log('Delivery Director -> Error while checking if auto release is allowed', {
-            level: LogLevel.Warning,
-            ...error,
-          });
-          return false;
-        }
-      },
-
-      send: async () => {
-        return adapter.send();
-      },
-
-      pickUpLocationById: async (locationId) => {
-        return adapter.pickUpLocationById(locationId);
-      },
-
-      pickUpLocations: async () => {
-        return adapter.pickUpLocations();
-      },
-    };
-  },
-};

package/src/director/DeliveryError.ts

@@ -1,6 +0,0 @@
-export enum DeliveryError {
-  ADAPTER_NOT_FOUND = 'ADAPTER_NOT_FOUND',
-  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',
-  INCOMPLETE_CONFIGURATION = 'INCOMPLETE_CONFIGURATION',
-  WRONG_CREDENTIALS = 'WRONG_CREDENTIALS',
-}

package/src/director/DeliveryPricingAdapter.ts

@@ -1,86 +0,0 @@
-import { BasePricingAdapter } from '@unchainedshop/utils';
-import { DeliveryPricingSheet } from './DeliveryPricingSheet.js';
-import {
-  BasePricingAdapterContext,
-  IPricingAdapter,
-  IPricingSheet,
-  PricingCalculation,
-} from '@unchainedshop/utils';
-import { DeliveryProvider } from '../types.js';
-import { OrderDelivery, OrderDiscount, Order } from '@unchainedshop/core-orders';
-import { User } from '@unchainedshop/core-users';
-
-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,
-  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/director/DeliveryPricingDirector.ts

@@ -1,99 +0,0 @@
-import { BasePricingDirector } from '@unchainedshop/utils';
-import { DeliveryPricingSheet } from './DeliveryPricingSheet.js';
-import { DeliveryProvider } from '../types.js';
-import { Order } from '@unchainedshop/core-orders';
-import { User } from '@unchainedshop/core-users';
-import { OrderDelivery } from '@unchainedshop/core-orders';
-import { IPricingDirector } from '@unchainedshop/utils';
-import {
-  DeliveryPricingAdapterContext,
-  DeliveryPricingCalculation,
-  IDeliveryPricingAdapter,
-  IDeliveryPricingSheet,
-} from './DeliveryPricingAdapter.js';
-
-export type DeliveryPricingContext =
-  | {
-      country?: string;
-      currency?: string;
-      provider: DeliveryProvider;
-      providerContext?: any;
-      order: Order;
-      user: User;
-    }
-  | { 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 = {
-  ...baseDirector,
-
-  async buildPricingContext(context, unchainedAPI) {
-    const { modules } = unchainedAPI;
-
-    if ('item' in context) {
-      const { item } = 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.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,
-    };
-  },
-
-  async actions(pricingContext, unchainedAPI) {
-    const actions = await baseDirector.actions(pricingContext, unchainedAPI, this.buildPricingContext);
-    return {
-      ...actions,
-      calculationSheet() {
-        const context = actions.getContext();
-        return DeliveryPricingSheet({
-          calculation: actions.getCalculation(),
-          currency: context.currency,
-        });
-      },
-    };
-  },
-};