@unchainedshop/core-delivery 1.1.3

package/src/director/DeliveryPricingDirector.ts

@@ -0,0 +1,68 @@
+import {
+  DeliveryPricingAdapterContext,
+  DeliveryPricingCalculation,
+  DeliveryPricingContext,
+  IDeliveryPricingAdapter,
+  IDeliveryPricingDirector,
+} from '@unchainedshop/types/delivery.pricing';
+import { BasePricingDirector } from '@unchainedshop/utils';
+import { DeliveryPricingSheet } from './DeliveryPricingSheet';
+
+const baseDirector = BasePricingDirector<
+  DeliveryPricingContext,
+  DeliveryPricingAdapterContext,
+  DeliveryPricingCalculation,
+  IDeliveryPricingAdapter
+>('DeliveryPricingDirector');
+
+export const DeliveryPricingDirector: IDeliveryPricingDirector = {
+  ...baseDirector,
+
+  async buildPricingContext({ item, ...context }, requestContext) {
+    const { modules } = requestContext;
+
+    if (!item)
+      return {
+        discounts: [],
+        ...context,
+        ...requestContext,
+      };
+
+    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 {
+      country: order.countryCode,
+      currency: order.currency,
+      ...context,
+      ...requestContext,
+      order,
+      orderDelivery: item,
+      provider,
+      user,
+      discounts,
+    };
+  },
+
+  async actions(pricingContext, requestContext) {
+    const actions = await baseDirector.actions(pricingContext, requestContext, this.buildPricingContext);
+    return {
+      ...actions,
+      calculationSheet() {
+        const context = actions.getContext();
+        return DeliveryPricingSheet({
+          calculation: actions.getCalculation(),
+          currency: context.currency,
+        });
+      },
+    };
+  },
+};

package/src/director/DeliveryPricingSheet.ts

@@ -0,0 +1,112 @@
+import { BasePricingSheet } from '@unchainedshop/utils';
+import {
+  DeliveryPricingCalculation,
+  DeliveryPricingRowCategory,
+  IDeliveryPricingSheet,
+} from '@unchainedshop/types/delivery.pricing';
+import { IBasePricingSheet, PricingSheetParams } from '@unchainedshop/types/pricing';
+
+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() {
+      return basePricingSheet.sum({
+        category: DeliveryPricingRowCategory.Tax,
+      });
+    },
+
+    feeSum() {
+      return basePricingSheet.sum({
+        category: DeliveryPricingRowCategory.Delivery,
+      });
+    },
+
+    discountSum(discountId) {
+      return basePricingSheet.sum({
+        category: DeliveryPricingRowCategory.Discount,
+        discountId,
+      });
+    },
+
+    discountPrices(explicitDiscountId) {
+      const discountIds = pricingSheet
+        .getDiscountRows(explicitDiscountId)
+        .map(({ discountId }) => discountId);
+
+      return [...new Set(discountIds)]
+        .map((discountId) => {
+          const amount = basePricingSheet.sum({
+            category: DeliveryPricingRowCategory.Discount,
+            discountId,
+          });
+          if (!amount) {
+            return null;
+          }
+          return {
+            discountId,
+            amount: Math.round(amount),
+            currency: basePricingSheet.currency,
+          };
+        })
+        .filter(Boolean);
+    },
+
+    getFeeRows() {
+      return basePricingSheet.filterBy({
+        category: DeliveryPricingRowCategory.Item,
+      });
+    },
+
+    getDiscountRows(discountId) {
+      return basePricingSheet.filterBy({
+        category: DeliveryPricingRowCategory.Discount,
+        discountId,
+      });
+    },
+
+    getTaxRows() {
+      return basePricingSheet.filterBy({
+        category: DeliveryPricingRowCategory.Tax,
+      });
+    },
+  };
+
+  return pricingSheet;
+};

package/src/director/DeliveryProviderType.ts

@@ -0,0 +1,4 @@
+export enum DeliveryProviderType {
+  SHIPPING = 'SHIPPING',
+  PICKUP = 'PICKUP',
+}

package/src/module/configureDeliveryModule.ts

@@ -0,0 +1,206 @@
+import { Context } from '@unchainedshop/types/api';
+import { ModuleInput, ModuleMutations } from '@unchainedshop/types/common';
+import {
+  DeliveryContext,
+  DeliveryModule,
+  DeliveryProvider,
+  DeliveryProviderQuery,
+  DeliverySettingsOptions,
+} from '@unchainedshop/types/delivery';
+import { PaymentProvider } from '@unchainedshop/types/payments';
+import { emit, registerEvents } from '@unchainedshop/events';
+import { generateDbFilterById, generateDbMutations } from '@unchainedshop/utils';
+import { DeliveryPricingSheet } from '../director/DeliveryPricingSheet';
+import { DeliveryProvidersCollection } from '../db/DeliveryProvidersCollection';
+import { DeliveryProvidersSchema } from '../db/DeliveryProvidersSchema';
+import { deliverySettings } from '../delivery-settings';
+import { DeliveryDirector } from '../director/DeliveryDirector';
+import { DeliveryPricingDirector } from '../director/DeliveryPricingDirector';
+
+const DELIVERY_PROVIDER_EVENTS: string[] = [
+  'DELIVERY_PROVIDER_CREATE',
+  'DELIVERY_PROVIDER_UPDATE',
+  'DELIVERY_PROVIDER_REMOVE',
+];
+
+const asyncFilter = async (arr, predicate) => {
+  const results = await Promise.all(arr.map(predicate));
+
+  return arr.filter((_v, index) => results[index]);
+};
+
+const buildFindSelector = ({ type }: DeliveryProviderQuery = {}) => {
+  return { ...(type ? { type } : {}), deleted: null };
+};
+
+export const configureDeliveryModule = async ({
+  db,
+  options: deliveryOptions = {},
+}: ModuleInput<DeliverySettingsOptions>): Promise<DeliveryModule> => {
+  registerEvents(DELIVERY_PROVIDER_EVENTS);
+
+  deliverySettings.configureSettings(deliveryOptions);
+
+  const DeliveryProviders = await DeliveryProvidersCollection(db);
+
+  const mutations = generateDbMutations<DeliveryProvider>(
+    DeliveryProviders,
+    DeliveryProvidersSchema,
+  ) as ModuleMutations<DeliveryProvider>;
+
+  const getDeliveryAdapter = async (
+    deliveryProviderId: string,
+    deliveryContext: DeliveryContext,
+    requestContext: Context,
+  ) => {
+    const provider = await DeliveryProviders.findOne(generateDbFilterById(deliveryProviderId), {});
+
+    return DeliveryDirector.actions(provider, deliveryContext, requestContext);
+  };
+
+  return {
+    // Queries
+    count: async (query) => {
+      const providerCount = await DeliveryProviders.countDocuments(buildFindSelector(query));
+      return providerCount;
+    },
+
+    findProvider: async ({ deliveryProviderId, ...query }, options) => {
+      return DeliveryProviders.findOne(
+        deliveryProviderId ? generateDbFilterById(deliveryProviderId) : query,
+        options,
+      );
+    },
+
+    findProviders: async (query, options) => {
+      const providers = DeliveryProviders.find(buildFindSelector(query), options);
+      return providers.toArray();
+    },
+
+    providerExists: async ({ deliveryProviderId }) => {
+      const providerCount = await DeliveryProviders.countDocuments(
+        generateDbFilterById(deliveryProviderId, { deleted: null }),
+        { limit: 1 },
+      );
+      return !!providerCount;
+    },
+
+    // Delivery Adapter
+
+    findInterface: (deliveryProvider) => {
+      return DeliveryDirector.getAdapter(deliveryProvider.adapterKey);
+    },
+
+    findInterfaces: ({ type }) => {
+      return DeliveryDirector.getAdapters({
+        adapterFilter: (Adapter) => Adapter.typeSupported(type),
+      }).map((Adapter) => ({
+        _id: Adapter.key,
+        label: Adapter.label,
+        version: Adapter.version,
+      }));
+    },
+
+    findSupported: async (deliveryContext, requestContext) => {
+      const foundProviders = await DeliveryProviders.find(buildFindSelector({})).toArray();
+      const providers: PaymentProvider[] = await asyncFilter(
+        foundProviders,
+        async (provider: DeliveryProvider) => {
+          try {
+            const director = await DeliveryDirector.actions(provider, deliveryContext, requestContext);
+            return director.isActive();
+          } catch {
+            return false;
+          }
+        },
+      );
+
+      return deliverySettings.filterSupportedProviders(
+        {
+          providers,
+          order: deliveryContext.order,
+        },
+        requestContext,
+      );
+    },
+
+    determineDefault: async (deliveryProviders, deliveryContext, requestContext) => {
+      return deliverySettings.determineDefaultProvider(
+        {
+          providers: deliveryProviders,
+          ...deliveryContext,
+        },
+        requestContext,
+      );
+    },
+
+    configurationError: async (deliveryProvider, requestContext) => {
+      const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
+      return director.configurationError();
+    },
+
+    isActive: async (deliveryProvider, requestContext) => {
+      const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
+      return Boolean(director.isActive());
+    },
+
+    isAutoReleaseAllowed: async (deliveryProvider, requestContext) => {
+      const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
+      return Boolean(director.isAutoReleaseAllowed());
+    },
+
+    calculate: async (pricingContext, requestContext) => {
+      const pricing = await DeliveryPricingDirector.actions(pricingContext, requestContext);
+      return pricing.calculate();
+    },
+
+    send: async (deliveryProviderId, deliveryContext, requestContext) => {
+      const adapter = await getDeliveryAdapter(deliveryProviderId, deliveryContext, requestContext);
+      return adapter.send();
+    },
+
+    pricingSheet: (params) => {
+      return DeliveryPricingSheet(params);
+    },
+
+    // Mutations
+    create: async (doc, userId) => {
+      const Adapter = DeliveryDirector.getAdapter(doc.adapterKey);
+      if (!Adapter) return null;
+
+      const deliveryProviderId = await mutations.create(
+        {
+          configuration: Adapter.initialConfiguration,
+          ...doc,
+        },
+        userId,
+      );
+      const deliveryProvider = await DeliveryProviders.findOne(
+        generateDbFilterById(deliveryProviderId),
+        {},
+      );
+      emit('DELIVERY_PROVIDER_CREATE', { deliveryProvider });
+      return deliveryProvider;
+    },
+
+    update: async (_id: string, doc: DeliveryProvider, userId: string) => {
+      await mutations.update(_id, doc, userId);
+      const deliveryProvider = await DeliveryProviders.findOne(generateDbFilterById(_id), {});
+      emit('DELIVERY_PROVIDER_UPDATE', { deliveryProvider });
+      return deliveryProvider;
+    },
+
+    delete: async (_id, userId) => {
+      await mutations.delete(_id, userId);
+      const deliveryProvider = await DeliveryProviders.findOne(generateDbFilterById(_id), {});
+      emit('DELIVERY_PROVIDER_REMOVE', { deliveryProvider });
+      return deliveryProvider;
+    },
+
+    deletePermanently: async (_id, userId) => {
+      const deliveryProvider = await DeliveryProviders.findOne(generateDbFilterById(_id), {});
+      await mutations.deletePermanently(_id, userId);
+      return deliveryProvider;
+    },
+  };
+};

package/tests/delivery-index.test.ts

@@ -0,0 +1,22 @@
+import { assert } from 'chai';
+import { initDb } from 'meteor/unchained:mongodb';
+import { configureDeliveryModule } from '../src/delivery-index';
+
+describe('Test exports', () => {
+  let module;
+
+  before(async () => {
+    const db = await initDb();
+    module = await configureDeliveryModule({ db });
+  });
+
+  it('Check Delivery module', async () => {
+    assert.ok(module);
+    assert.isFunction(module.findProvider);
+    assert.isFunction(module.findDelivery);
+    assert.isFunction(module.providerExists);
+    assert.isFunction(module.create);
+    assert.isFunction(module.update);
+    assert.isFunction(module.delete);
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": ["esnext"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noImplicitReturns": true,
+    "noUnusedLocals": false,
+    "outDir": "lib",
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "target": "esnext",
+    "types": ["node"],
+    "baseUrl": ".", // This must be specified if "paths" is.
+    "paths": {
+      "meteor/unchained:*": ["node_modules/@unchainedshop/types/index.d.ts"]
+    }
+  },
+  "include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.build.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["node", "mocha"]
+  },
+  "include": ["src", "tests", "plugins"]
+}