@unchainedshop/core-enrollments 1.1.3

package/src/director/EnrollmentDirector.ts

@@ -0,0 +1,67 @@
+import {
+  EnrollmentData,
+  IEnrollmentAdapter,
+  IEnrollmentDirector,
+} from '@unchainedshop/types/enrollments';
+import { ProductPlan } from '@unchainedshop/types/products';
+import { log, LogLevel } from '@unchainedshop/logger';
+import { BaseDirector } from '@unchainedshop/utils';
+
+const baseDirector = BaseDirector<IEnrollmentAdapter>('EnrollmentDirector', {
+  adapterSortKey: 'orderIndex',
+});
+
+const findAppropriateAdapters = (productPlan?: ProductPlan) =>
+  baseDirector.getAdapters({
+    adapterFilter: (Adapter: IEnrollmentAdapter) => {
+      const activated = Adapter.isActivatedFor(productPlan);
+      if (!activated) {
+        log(`Enrollment Director -> ${Adapter.key} (${Adapter.version}) skipped`, {
+          level: LogLevel.Warning,
+        });
+      }
+      return activated;
+    },
+  });
+
+export const EnrollmentDirector: IEnrollmentDirector = {
+  ...baseDirector,
+
+  transformOrderItemToEnrollment: async ({ orderPosition, product }, doc, requestContext) => {
+    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,
+      requestContext,
+    );
+
+    const enrollmentData: EnrollmentData = {
+      ...doc,
+      ...enrollmentPlan,
+      configuration: [],
+    };
+
+    return enrollmentData;
+  },
+
+  actions: async (enrollmentContext, requestContext) => {
+    const context = { ...enrollmentContext, ...requestContext };
+
+    // 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/director/EnrollmentError.ts

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

package/src/enrollments-index.ts

@@ -0,0 +1,8 @@
+export { configureEnrollmentsModule } from './module/configureEnrollmentsModule';
+
+export { EnrollmentAdapter } from './director/EnrollmentAdapter';
+export { EnrollmentDirector } from './director/EnrollmentDirector';
+
+export { EnrollmentStatus } from './db/EnrollmentStatus';
+
+export { enrollmentsSettings } from './enrollments-settings';

package/src/enrollments-settings.js

@@ -0,0 +1,22 @@
+import later from 'later';
+import { generateRandomHash } from '@unchainedshop/utils';
+
+const everyHourSchedule = later.parse.text('every 59 minutes');
+const emptyObject = () => {
+  return {};
+};
+
+export const enrollmentsSettings = {
+  autoSchedulingSchedule: null,
+  autoSchedulingInput: null,
+  enrollmentNumberHashFn: null,
+  configureSettings({
+    autoSchedulingSchedule = everyHourSchedule,
+    autoSchedulingInput = emptyObject,
+    enrollmentNumberHashFn = generateRandomHash,
+  } = {}) {
+    this.autoSchedulingSchedule = autoSchedulingSchedule;
+    this.autoSchedulingInput = autoSchedulingInput || emptyObject;
+    this.enrollmentNumberHashFn = enrollmentNumberHashFn;
+  },
+};

package/src/module/configureEnrollmentsModule.ts

@@ -0,0 +1,502 @@
+import { Context, SortOption } from '@unchainedshop/types/api';
+import { ModuleInput, ModuleMutations } from '@unchainedshop/types/common';
+import {
+  Enrollment,
+  EnrollmentQuery,
+  EnrollmentsModule,
+  EnrollmentsSettingsOptions,
+} from '@unchainedshop/types/enrollments';
+import { Locale } from 'locale';
+import { emit, registerEvents } from '@unchainedshop/events';
+import { log } from '@unchainedshop/logger';
+import { generateDbFilterById, generateDbMutations, buildSortOptions } from '@unchainedshop/utils';
+import { EnrollmentsCollection } from '../db/EnrollmentsCollection';
+import { EnrollmentsSchema } from '../db/EnrollmentsSchema';
+import { EnrollmentStatus } from '../db/EnrollmentStatus';
+import { EnrollmentDirector } from '../enrollments-index';
+import { enrollmentsSettings } from '../enrollments-settings';
+
+const ENROLLMENT_EVENTS: string[] = [
+  'ENROLLMENT_ADD_PERIOD',
+  'ENROLLMENT_CREATE',
+  'ENROLLMENT_REMOVE',
+  'ENROLLMENT_UPDATE',
+];
+
+const buildFindSelector = ({ queryString, status, userId }: EnrollmentQuery) => {
+  const selector: {
+    deleted: Date;
+    status?: any;
+    $text?: { $search?: string };
+    userId?: string;
+  } = {
+    deleted: null,
+  };
+  if (status) selector.status = { $in: status };
+  if (userId) selector.userId = userId;
+
+  if (queryString) selector.$text = { $search: queryString };
+
+  return selector;
+};
+
+export const configureEnrollmentsModule = async ({
+  db,
+  options: enrollmentOptions = {},
+}: ModuleInput<EnrollmentsSettingsOptions>): Promise<EnrollmentsModule> => {
+  registerEvents(ENROLLMENT_EVENTS);
+
+  enrollmentsSettings.configureSettings(enrollmentOptions);
+
+  const Enrollments = await EnrollmentsCollection(db);
+
+  const mutations = generateDbMutations<Enrollment>(
+    Enrollments,
+    EnrollmentsSchema,
+  ) as ModuleMutations<Enrollment>;
+
+  const findNewEnrollmentNumber = async (enrollment: Enrollment, index = 0): Promise<string> => {
+    const newHashID = enrollmentsSettings.enrollmentNumberHashFn(enrollment, index);
+    if ((await Enrollments.countDocuments({ enrollmentNumber: newHashID }, { limit: 1 })) === 0) {
+      return newHashID;
+    }
+    return findNewEnrollmentNumber(enrollment, index + 1);
+  };
+
+  const findNextStatus = async (
+    enrollment: Enrollment,
+    requestContext: Context,
+  ): Promise<EnrollmentStatus> => {
+    let status = enrollment.status as EnrollmentStatus;
+    const director = await EnrollmentDirector.actions({ enrollment }, requestContext);
+
+    if (status === EnrollmentStatus.INITIAL || status === EnrollmentStatus.PAUSED) {
+      if (await director.isValidForActivation()) {
+        status = EnrollmentStatus.ACTIVE;
+      }
+    } else if (status === EnrollmentStatus.ACTIVE) {
+      if (await director.isOverdue()) {
+        status = EnrollmentStatus.PAUSED;
+      }
+    } else if (requestContext.modules.enrollments.isExpired(enrollment, {})) {
+      status = EnrollmentStatus.TERMINATED;
+    }
+
+    return status;
+  };
+
+  const updateStatus: EnrollmentsModule['updateStatus'] = async (
+    enrollmentId,
+    { status, info = '' },
+    requestContext,
+  ) => {
+    const selector = generateDbFilterById(enrollmentId);
+    const enrollment = await Enrollments.findOne(selector, {});
+
+    if (enrollment.status === status) return enrollment;
+
+    const date = new Date();
+    const modifier: {
+      $set: Partial<Enrollment>;
+      $push: { log: Enrollment['log'][0] };
+    } = {
+      $set: { status, updated: new Date(), updatedBy: requestContext.userId },
+      $push: {
+        log: {
+          date,
+          status,
+          info,
+        },
+      },
+    };
+
+    switch (status) {
+      case EnrollmentStatus.ACTIVE:
+        modifier.$set.enrollmentNumber = await findNewEnrollmentNumber(enrollment);
+        break;
+      case EnrollmentStatus.TERMINATED:
+        modifier.$set.expires = enrollment.periods?.pop()?.end || new Date();
+        break;
+      default:
+        break;
+    }
+
+    log(`New Status: ${status}`, { enrollmentId });
+
+    await Enrollments.updateOne(selector, modifier);
+
+    const updatedEnrollment = await Enrollments.findOne(selector, {});
+
+    emit('ENROLLMENT_UPDATE', { enrollment, field: 'status' });
+
+    return updatedEnrollment;
+  };
+
+  const reactivateEnrollment = async (enrollment: Enrollment) => {
+    return enrollment;
+  };
+
+  const processEnrollment = async (
+    enrollment: Enrollment,
+    params: { enrollmentContext?: any; orderIdForFirstPeriod?: string },
+    requestContext: Context,
+  ) => {
+    let status = await findNextStatus(enrollment, requestContext);
+
+    if (status === EnrollmentStatus.ACTIVE) {
+      const nextEnrollment = await reactivateEnrollment(enrollment);
+      status = await findNextStatus(nextEnrollment, requestContext);
+    }
+
+    return updateStatus(enrollment._id, { status, info: 'enrollment processed' }, requestContext);
+  };
+
+  const initializeEnrollment = async (
+    enrollment: Enrollment,
+    params: { orderIdForFirstPeriod?: string; reason: string },
+    requestContext: Context,
+  ) => {
+    const { modules, userId } = requestContext;
+
+    // const user = await modules.users.findUserById(enrollment.userId);
+    // const locale = modules.users.userLocale(user, requestContext);
+    // const reason = "new_enrollment";
+
+    const director = await EnrollmentDirector.actions({ enrollment }, requestContext);
+    const period = await director.nextPeriod();
+
+    if (period && (params.orderIdForFirstPeriod || period.isTrial)) {
+      const intializedEnrollment = await modules.enrollments.addEnrollmentPeriod(
+        enrollment._id,
+        { ...period, orderId: params.orderIdForFirstPeriod },
+        userId,
+      );
+
+      return processEnrollment(intializedEnrollment, params, requestContext);
+    }
+
+    return processEnrollment(enrollment, params, requestContext);
+  };
+
+  const sendStatusToCustomer = async (
+    enrollment: Enrollment,
+    params: { locale?: Locale; reason?: string },
+    requestContext: Context,
+  ) => {
+    const { modules, userId } = requestContext;
+
+    let { locale } = params;
+    if (!locale) {
+      const user = await modules.users.findUserById(enrollment.userId);
+      locale = modules.users.userLocale(user, requestContext);
+    }
+
+    await modules.worker.addWork(
+      {
+        type: 'MESSAGE',
+        retries: 0,
+        input: {
+          reason: params.reason || 'status_change',
+          locale,
+          template: 'ENROLLMENT_STATUS',
+          enrollmentId: enrollment._id,
+        },
+      },
+      userId,
+    );
+
+    return enrollment;
+  };
+
+  const updateEnrollmentField =
+    (fieldKey: string) => async (enrollmentId: string, fieldValue: any, userId?: string) => {
+      log(`Update enrollment field ${fieldKey.toUpperCase()}`, {
+        enrollmentId,
+        userId,
+      });
+
+      await mutations.update(enrollmentId, { $set: { [fieldKey]: fieldValue } }, userId);
+
+      const enrollment = await Enrollments.findOne(generateDbFilterById(enrollmentId), {});
+
+      emit('ENROLLMENT_UPDATE', { enrollment, field: fieldKey });
+
+      return enrollment;
+    };
+
+  return {
+    // Queries
+    count: async (query: EnrollmentQuery) => {
+      const enrollmentCount = await Enrollments.countDocuments(buildFindSelector(query));
+      return enrollmentCount;
+    },
+
+    findEnrollment: async ({ enrollmentId, orderId }, options) => {
+      const selector = enrollmentId
+        ? generateDbFilterById(enrollmentId)
+        : { 'periods.orderId': orderId };
+
+      return Enrollments.findOne(selector, options);
+    },
+
+    findEnrollments: async ({
+      limit,
+      offset,
+      sort,
+      ...query
+    }: EnrollmentQuery & { limit?: number; offset?: number; sort?: Array<SortOption> }) => {
+      const enrollments = Enrollments.find(buildFindSelector(query), {
+        skip: offset,
+        limit,
+        sort: buildSortOptions(sort),
+      });
+
+      return enrollments.toArray();
+    },
+
+    // Transformations
+    normalizedStatus: (enrollment) => {
+      return enrollment.status === null
+        ? EnrollmentStatus.INITIAL
+        : (enrollment.status as EnrollmentStatus);
+    },
+
+    isExpired: (enrollment, { referenceDate }) => {
+      const relevantDate = referenceDate ? new Date(referenceDate) : new Date();
+      const expiryDate = new Date(enrollment.expires);
+      const isExpired = relevantDate.getTime() > expiryDate.getTime();
+      return isExpired;
+    },
+
+    // Processing
+    terminateEnrollment: async (enrollment, { enrollmentContext }, requestContext) => {
+      if (enrollment.status === EnrollmentStatus.TERMINATED) return enrollment;
+
+      let updatedEnrollment = await updateStatus(
+        enrollment._id,
+        {
+          status: EnrollmentStatus.TERMINATED,
+          info: 'terminated manually',
+        },
+        requestContext,
+      );
+
+      updatedEnrollment = await processEnrollment(
+        updatedEnrollment,
+        { enrollmentContext },
+        requestContext,
+      );
+
+      return sendStatusToCustomer(updatedEnrollment, {}, requestContext);
+    },
+
+    activateEnrollment: async (enrollment, { enrollmentContext }, requestContext) => {
+      if (enrollment.status === EnrollmentStatus.TERMINATED) return enrollment;
+
+      let updatedEnrollment = await updateStatus(
+        enrollment._id,
+        {
+          status: EnrollmentStatus.ACTIVE,
+          info: 'activated manually',
+        },
+        requestContext,
+      );
+
+      updatedEnrollment = await processEnrollment(
+        updatedEnrollment,
+        { enrollmentContext },
+        requestContext,
+      );
+
+      return sendStatusToCustomer(updatedEnrollment, {}, requestContext);
+    },
+
+    // Mutations
+    addEnrollmentPeriod: async (enrollmentId, period, userId) => {
+      const { start, end, orderId, isTrial } = period;
+      const selector = generateDbFilterById(enrollmentId);
+      await Enrollments.updateOne(selector, {
+        $push: {
+          periods: {
+            start,
+            end,
+            orderId,
+            isTrial,
+          },
+        },
+        $set: {
+          updated: new Date(),
+          updatedBy: userId,
+        },
+      });
+      const enrollment = await Enrollments.findOne(selector, {});
+
+      emit('ENROLLMENT_ADD_PERIOD', { enrollment });
+
+      return enrollment;
+    },
+
+    create: async (
+      { countryCode, currencyCode, orderIdForFirstPeriod, ...enrollmentData },
+      requestContext,
+    ) => {
+      const { userId, services } = requestContext;
+
+      log('Create Enrollment', { userId });
+
+      const currency =
+        currencyCode ||
+        (await services.countries.resolveDefaultCurrencyCode(
+          {
+            isoCode: countryCode,
+          },
+          requestContext,
+        ));
+
+      const enrollmentId = await mutations.create(
+        {
+          ...enrollmentData,
+          status: EnrollmentStatus.INITIAL,
+          periods: [],
+          currencyCode: currency,
+          countryCode,
+          configuration: enrollmentData.configuration || [],
+          log: [],
+        },
+        userId,
+      );
+
+      const newEnrollment = await Enrollments.findOne(generateDbFilterById(enrollmentId), {});
+
+      const reason = 'new_enrollment';
+
+      const initializedEnrollment = await initializeEnrollment(
+        newEnrollment,
+        {
+          orderIdForFirstPeriod,
+          reason,
+        },
+        requestContext,
+      );
+
+      const enrollment = await sendStatusToCustomer(
+        initializedEnrollment,
+        {
+          reason,
+        },
+        requestContext,
+      );
+
+      emit('ENROLLMENT_CREATE', { enrollment });
+
+      return enrollment;
+    },
+
+    createFromCheckout: async (order, { items, context }, requestContext) => {
+      const { modules } = requestContext;
+      const orderId = order._id;
+
+      const payment = await modules.orders.payments.findOrderPayment({
+        orderPaymentId: order.paymentId,
+      });
+      const delivery = await modules.orders.deliveries.findDelivery({
+        orderDeliveryId: order.deliveryId,
+      });
+
+      const template = {
+        billingAddress: order.billingAddress,
+        contact: order.contact,
+        countryCode: order.countryCode,
+        currencyCode: order.currency,
+        delivery: {
+          deliveryProviderId: delivery.deliveryProviderId,
+          context: delivery.context,
+        },
+        orderIdForFirstPeriod: orderId,
+        payment: {
+          paymentProviderId: payment.paymentProviderId,
+          context: payment.context,
+        },
+        userId: order.userId,
+
+        // TODO: Check with pascal
+        meta: order.context,
+
+        ...context,
+      };
+
+      const enrollments = await Promise.all(
+        items.map(async (item) => {
+          const enrollmentData = await EnrollmentDirector.transformOrderItemToEnrollment(
+            item,
+            template,
+            requestContext,
+          );
+
+          return modules.enrollments.create(enrollmentData, requestContext);
+        }),
+      );
+
+      return enrollments;
+    },
+
+    delete: async (enrollmentId, userId) => {
+      const deletedCount = await mutations.delete(enrollmentId, userId);
+      emit('ORDER_REMOVE', { enrollmentId });
+      return deletedCount;
+    },
+
+    removeEnrollmentPeriodByOrderId: async (enrollmentId, orderId, userId) => {
+      const selector = generateDbFilterById(enrollmentId);
+      await Enrollments.updateOne(selector, {
+        $set: {
+          updated: new Date(),
+          updatedBy: userId,
+        },
+
+        $pull: {
+          periods: { orderId: { $in: [orderId, undefined, null] } },
+        },
+      });
+
+      return Enrollments.findOne(selector, {});
+    },
+
+    updateBillingAddress: updateEnrollmentField('billingAddress'),
+    updateContact: updateEnrollmentField('contact'),
+    updateContext: updateEnrollmentField('context'),
+    updateDelivery: updateEnrollmentField('delivery'),
+    updatePayment: updateEnrollmentField('payment'),
+
+    updatePlan: async (enrollmentId, plan, requestContext) => {
+      const { userId } = requestContext;
+
+      log(`Update enrollment plan fields`, {
+        enrollmentId,
+        userId,
+      });
+
+      await mutations.update(
+        enrollmentId,
+        {
+          productId: plan.productId,
+          quantity: plan.quantity,
+          configuration: plan.configuration,
+        },
+        userId,
+      );
+
+      const selector = generateDbFilterById(enrollmentId);
+      const enrollment = await Enrollments.findOne(selector, {});
+
+      emit('ENROLLMENT_UPDATE', { enrollment, field: 'plan' });
+
+      const reason = 'updated_plan';
+      const initializedEnrollment = await initializeEnrollment(enrollment, { reason }, requestContext);
+
+      return sendStatusToCustomer(initializedEnrollment, { reason }, requestContext);
+    },
+
+    updateStatus,
+  };
+};

package/tests/enrollments-index.test.ts

@@ -0,0 +1,91 @@
+import { assert } from 'chai';
+import { initDb } from 'meteor/unchained:mongodb';
+import { configureUsersModule } from 'meteor/unchained:core-users';
+import { configureEnrollmentsModule } from 'meteor/unchained:core-enrollments';
+import { EnrollmentsModule } from '@unchainedshop/types/enrollments';
+import { Context } from '@unchainedshop/types/api';
+import { User, UsersModule } from '@unchainedshop/types/user';
+
+describe('Test exports', () => {
+  const context: {
+    modules: { enrollments: EnrollmentsModule; users: UsersModule };
+    services: { countries: { resolveDefaultCurrencyCode: () => string } };
+  } = {
+    modules: {
+      enrollments: null,
+      users: null,
+    },
+    services: {
+      countries: {
+        resolveDefaultCurrencyCode: () => 'CHF',
+      },
+    },
+  };
+  let user: User
+
+  before(async () => {
+    const db = await initDb();
+    const enrollmentsModule = await configureEnrollmentsModule({ db }).catch(
+      (error) => {
+        console.error(error);
+
+        throw error;
+      }
+    );
+
+    const usersModules = await configureUsersModule({ db }).catch((error) => {
+      console.error(error);
+
+      throw error;
+    });
+
+    context.modules.enrollments = enrollmentsModule;
+    context.modules.users = usersModules;
+  });
+
+  it('Insert enrollment', async () => {
+    let enrollment = await context.modules.enrollments.create(
+      {
+        billingAddress: {
+          lastName: 'Mustermann',
+          firstName: 'Max',
+          addressLine: 'Teststreet 11',
+          city: 'Zürich',
+          postalCode: '8009',
+          company: 'Unchained Commerce',
+          countryCode: 'CH',
+        },
+        countryCode: 'CH',
+        currencyCode: 'CHF',
+        contact: {},
+        productId: 'Product-123',
+        quantity: 2,
+        userId: 'Test-User-1',
+        payment: {
+          paymentProviderId: 'payment-provider-1',
+          context: {},
+        },
+        delivery: {
+          deliveryProviderId: 'delivery-provider-1',
+          context: {},
+        },
+      },
+      context as Context
+    );
+
+    assert.ok(enrollment);
+    const enrollmentId = enrollment._id;
+    enrollment = await context.modules.enrollments.findEnrollment({
+      enrollmentId,
+    });
+
+    assert.ok(enrollment);
+
+    const deletedCount = await context.modules.enrollments
+      .delete(enrollmentId, 'Test-User-1')
+      .catch((error) => {
+        return 0;
+      });
+    assert.equal(deletedCount, 1);
+  });
+});