@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc2

package/src/services/initCartProviders.ts

@@ -0,0 +1,86 @@
+import { Order } from '@unchainedshop/core-orders';
+import { deliverySettings } from '@unchainedshop/core-delivery';
+import { paymentSettings } from '@unchainedshop/core-payment';
+import { supportedDeliveryProvidersService } from './supportedDeliveryProviders.js';
+import { supportedPaymentProvidersService } from './supportedPaymentProviders.js';
+import { Modules } from '../modules.js';
+
+export async function initCartProvidersService(this: Modules, order: Order) {
+  let updatedOrder = order;
+
+  // Init delivery provider
+  const supportedDeliveryProviders = await supportedDeliveryProvidersService.bind(this)({
+    order: updatedOrder,
+  });
+
+  const orderDelivery = await this.orders.deliveries.findDelivery({
+    orderDeliveryId: updatedOrder.deliveryId,
+  });
+  const deliveryProviderId = orderDelivery?.deliveryProviderId;
+
+  const isAlreadyInitializedWithSupportedDeliveryProvider = supportedDeliveryProviders?.some(
+    (provider) => {
+      return provider._id === deliveryProviderId;
+    },
+  );
+
+  if (supportedDeliveryProviders?.length > 0 && !isAlreadyInitializedWithSupportedDeliveryProvider) {
+    const defaultOrderDeliveryProvider = await deliverySettings.determineDefaultProvider(
+      {
+        providers: supportedDeliveryProviders,
+        order: updatedOrder,
+      },
+      { modules: this },
+    );
+    if (defaultOrderDeliveryProvider) {
+      updatedOrder = await this.orders.setDeliveryProvider(
+        updatedOrder._id,
+        defaultOrderDeliveryProvider._id,
+      );
+    }
+  }
+
+  // Init payment provider
+  const supportedPaymentProviders = await supportedPaymentProvidersService.bind(this)({
+    order: updatedOrder,
+  });
+
+  const orderPayment = await this.orders.payments.findOrderPayment({
+    orderPaymentId: updatedOrder.paymentId,
+  });
+  const paymentProviderId = orderPayment?.paymentProviderId;
+
+  const isAlreadyInitializedWithSupportedPaymentProvider = supportedPaymentProviders?.some(
+    (provider) => {
+      return provider._id === paymentProviderId;
+    },
+  );
+
+  if (supportedPaymentProviders?.length > 0 && !isAlreadyInitializedWithSupportedPaymentProvider) {
+    const paymentCredentials = await this.payment.paymentCredentials.findPaymentCredentials(
+      { userId: updatedOrder.userId, isPreferred: true },
+      {
+        sort: {
+          created: -1,
+        },
+      },
+    );
+
+    const defaultOrderPaymentProvider = await paymentSettings.determineDefaultProvider(
+      {
+        providers: supportedPaymentProviders,
+        order: updatedOrder,
+        paymentCredentials,
+      },
+      { modules: this },
+    );
+
+    if (defaultOrderPaymentProvider) {
+      updatedOrder = await this.orders.setPaymentProvider(
+        updatedOrder._id,
+        defaultOrderPaymentProvider._id,
+      );
+    }
+  }
+  return updatedOrder;
+}

package/src/services/initializeEnrollment.ts

@@ -0,0 +1,38 @@
+import { Enrollment } from '@unchainedshop/core-enrollments';
+import { EnrollmentDirector } from '../core-index.js';
+import { processEnrollmentService } from './processEnrollment.js';
+import { Modules } from '../modules.js';
+
+export async function initializeEnrollmentService(
+  this: Modules,
+  enrollment: Enrollment,
+  params: { orderIdForFirstPeriod?: string; reason: string },
+) {
+  const director = await EnrollmentDirector.actions({ enrollment }, { modules: this });
+  const period = await director.nextPeriod();
+
+  let updatedEnrollment = enrollment;
+  if (period && (params.orderIdForFirstPeriod || period.isTrial)) {
+    updatedEnrollment = await this.enrollments.addEnrollmentPeriod(enrollment._id, {
+      ...period,
+      orderId: params.orderIdForFirstPeriod,
+    });
+  }
+
+  const processedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
+  const user = await this.users.findUserById(enrollment.userId);
+  const locale = this.users.userLocale(user);
+
+  await this.worker.addWork({
+    type: 'MESSAGE',
+    retries: 0,
+    input: {
+      reason: params.reason || 'status_change',
+      locale,
+      template: 'ENROLLMENT_STATUS',
+      enrollmentId: processedEnrollment._id,
+    },
+  });
+
+  return processedEnrollment;
+}

package/src/services/invalidateFilterCache.ts

@@ -0,0 +1,16 @@
+import { Modules } from '../modules.js';
+import { FilterDirector } from '../core-index.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:core');
+
+export async function invalidateFilterCacheService(this: Modules) {
+  logger.debug('Filters: Start invalidating filter caches');
+
+  const filters = await this.filters.findFilters({ includeInactive: true });
+
+  await filters.reduce(async (lastPromise, filter) => {
+    await lastPromise;
+    return FilterDirector.invalidateProductIdCache(filter, { modules: this });
+  }, Promise.resolve(undefined));
+}

package/src/services/linkFileService.ts

@@ -0,0 +1,22 @@
+import { FileDirector } from '@unchainedshop/file-upload';
+import { Modules } from '../modules.js';
+
+export async function linkFileService(
+  this: Modules,
+  { fileId, size, type }: { fileId: string; size: number; type?: string },
+) {
+  const file = await this.files.findFile({ fileId });
+  if (file?.expires) {
+    await this.files.update(file._id, {
+      size: size || file.size,
+      type: type || file.type,
+      expires: null,
+    });
+    const callback = FileDirector.getFileUploadCallback(file.path);
+    if (callback) {
+      await callback(file, { modules: this });
+    }
+    return this.files.findFile({ fileId });
+  }
+  return file;
+}

package/src/services/loadFilterOptions.ts

@@ -0,0 +1,50 @@
+import { FilterType, Filter, SearchQuery } from '@unchainedshop/core-filters';
+import { intersectSet } from '@unchainedshop/utils';
+import { Modules } from '../modules.js';
+import { FilterDirector, parseQueryArray } from '../directors/FilterDirector.js';
+
+export async function loadFilterOptionsService(
+  this: Modules,
+  filter: Filter,
+  params: {
+    searchQuery: SearchQuery;
+    forceLiveCollection: boolean;
+    productIdSet: Set<string>;
+  },
+) {
+  const { forceLiveCollection, productIdSet, searchQuery } = params;
+
+  const filterQueryParsed = parseQueryArray(searchQuery?.filterQuery);
+  const values = filterQueryParsed[filter.key];
+
+  const allOptions = (filter.type === FilterType.SWITCH && ['true', 'false']) || filter.options || [];
+  const mappedOptions = await Promise.all(
+    allOptions.map(async (value) => {
+      const filterOptionProductIds = await FilterDirector.filterProductIds(
+        filter,
+        {
+          values: [value],
+          forceLiveCollection,
+        },
+        { modules: this },
+      );
+      const filteredProductIdSet = intersectSet(productIdSet, new Set(filterOptionProductIds));
+
+      const normalizedValues = values && this.filters.parse(filter, values, [value]);
+      const isSelected = normalizedValues && normalizedValues.indexOf(value) !== -1;
+
+      if (!filteredProductIdSet.size && !isSelected) {
+        return null;
+      }
+
+      return {
+        filteredProductIdSet,
+        searchQuery,
+        value,
+        filter,
+        isSelected,
+      };
+    }),
+  );
+  return mappedOptions.filter(Boolean);
+}

package/src/services/loadFilters.ts

@@ -0,0 +1,52 @@
+import { SearchQuery, defaultFilterSelector } from '@unchainedshop/core-filters';
+import { Modules } from '../modules.js';
+import { FilterDirector } from '../directors/FilterDirector.js';
+
+export async function loadFiltersService(
+  this: Modules,
+  searchQuery: SearchQuery,
+  { productIds, forceLiveCollection }: { productIds: Array<string>; forceLiveCollection: boolean },
+) {
+  const filterActions = await FilterDirector.actions({ searchQuery }, { modules: this });
+  const filterSelector = await filterActions.transformFilterSelector(defaultFilterSelector(searchQuery));
+
+  if (!filterSelector) return [];
+
+  const otherFilters = await this.filters.findFilters({
+    ...filterSelector,
+    limit: 0,
+    includeInactive: true,
+  });
+
+  const extractedFilterIds = (filterSelector?._id as any)?.$in || [];
+  const sortedFilters = otherFilters.sort((left, right) => {
+    const leftIndex = extractedFilterIds.indexOf(left._id);
+    const rightIndex = extractedFilterIds.indexOf(right._id);
+    return leftIndex - rightIndex;
+  });
+
+  return Promise.all(
+    sortedFilters.map(async (filter) => {
+      const { examinedProductIdSet, filteredByOtherFiltersSet, filteredByThisFilterSet } =
+        await FilterDirector.filterFacets(
+          filter,
+          {
+            searchQuery,
+            forceLiveCollection,
+            allProductIds: productIds,
+            otherFilters,
+          },
+          { modules: this },
+        );
+
+      return {
+        forceLiveCollection,
+        searchQuery,
+        filter,
+        examinedProductIdSet,
+        filteredByOtherFiltersSet,
+        filteredByThisFilterSet,
+      };
+    }),
+  );
+}

package/src/services/migrateBookmarks.ts

@@ -0,0 +1,39 @@
+import { Modules } from '../modules.js';
+
+const hashBookmark = (bookmark) => {
+  return `${bookmark.productId}:${bookmark.userId}:${JSON.stringify(bookmark.meta || {})}`;
+};
+
+export async function migrateBookmarksService(
+  this: Modules,
+  {
+    fromUserId,
+    toUserId,
+    shouldMerge,
+  }: {
+    fromUserId: string;
+    toUserId: string;
+    shouldMerge: boolean;
+    countryContext: string;
+  },
+) {
+  const fromBookmarks = await this.bookmarks.findBookmarks({ userId: fromUserId });
+  if (!fromBookmarks) {
+    // No bookmarks no copy needed
+    return;
+  }
+  if (!shouldMerge) {
+    await this.bookmarks.deleteByUserId(toUserId);
+    await this.bookmarks.replaceUserId(fromUserId, toUserId);
+  } else {
+    const toBookmarks = await this.bookmarks.findBookmarks({ userId: toUserId });
+    const toBookmarkHashes = toBookmarks.map(hashBookmark);
+    const newBookmarkIds = fromBookmarks
+      .filter((fromBookmark) => {
+        const hash = hashBookmark(fromBookmark);
+        return !toBookmarkHashes.includes(hash);
+      })
+      .map((bookmark) => bookmark._id);
+    await this.bookmarks.replaceUserId(fromUserId, toUserId, newBookmarkIds);
+  }
+}

package/src/services/migrateOrderCart.ts

@@ -0,0 +1,52 @@
+import { updateCalculationService } from './updateCalculation.js';
+import { Modules } from '../modules.js';
+
+export async function migrateOrderCartsService(
+  this: Modules,
+  {
+    fromUserId,
+    toUserId,
+    shouldMerge,
+    countryContext,
+  }: {
+    fromUserId: string;
+    toUserId: string;
+    shouldMerge: boolean;
+    countryContext: string;
+  },
+) {
+  const fromCart = await this.orders.cart({
+    countryContext,
+    userId: fromUserId,
+  });
+  const toCart = await this.orders.cart({
+    countryContext,
+    userId: toUserId,
+  });
+
+  if (!fromCart) {
+    // No cart, don't copy
+    return toCart;
+  }
+
+  if (!toCart || !shouldMerge) {
+    // No destination cart, move whole cart
+    this.orders.setCartOwner({ orderId: fromCart._id, userId: toUserId });
+    return updateCalculationService.bind(this)(fromCart._id);
+  }
+
+  // Move positions
+  this.orders.moveCartPositions({ fromOrderId: fromCart._id, toOrderId: toCart._id });
+
+  // Move billing address if target order has none
+  if (fromCart.billingAddress && !toCart.billingAddress) {
+    await this.orders.updateBillingAddress(toCart._id, fromCart.billingAddress);
+  }
+
+  // Move contact data if target order has none
+  if (fromCart.contact && !toCart.contact) {
+    await this.orders.updateContact(toCart._id, fromCart.contact);
+  }
+
+  return updateCalculationService.bind(this)(toCart._id);
+}

package/src/services/migrateUserData.ts

@@ -0,0 +1,22 @@
+import { userSettings } from '@unchainedshop/core-users';
+import { migrateBookmarksService } from './migrateBookmarks.js';
+import { migrateOrderCartsService } from './migrateOrderCart.js';
+
+export async function migrateUserDataService(userIdBeforeLogin: string, userId: string) {
+  const user = await this.users.findUserById(userId);
+  const userBeforeLogin = await this.users.findUserById(userIdBeforeLogin);
+
+  await migrateOrderCartsService.bind(this)({
+    fromUserId: userIdBeforeLogin,
+    toUserId: userId,
+    shouldMerge: userSettings.mergeUserCartsOnLogin,
+    countryContext: userBeforeLogin.lastLogin?.countryCode || user.lastLogin?.countryCode,
+  });
+
+  await migrateBookmarksService.bind(this)({
+    fromUserId: userIdBeforeLogin,
+    toUserId: userId,
+    shouldMerge: userSettings.mergeUserCartsOnLogin,
+    countryContext: userBeforeLogin.lastLogin?.countryCode || user.lastLogin?.countryCode,
+  });
+}

package/src/services/nextUserCart.ts

@@ -0,0 +1,52 @@
+import { resolveBestCurrency } from '@unchainedshop/utils';
+import { User } from '@unchainedshop/core-users';
+import { ordersSettings } from '@unchainedshop/core-orders';
+import { initCartProvidersService } from './initCartProviders.js';
+import { Modules } from '../modules.js';
+
+export async function nextUserCartService(
+  this: Modules,
+  {
+    user,
+    orderNumber,
+    countryCode,
+    forceCartCreation,
+  }: {
+    user: User;
+    orderNumber?: string;
+    countryCode?: string;
+    forceCartCreation?: boolean;
+  },
+) {
+  const cart = await this.orders.cart({
+    countryContext: countryCode || user.lastLogin?.countryCode,
+    orderNumber,
+    userId: user._id,
+  });
+  if (cart) return cart;
+
+  const shouldCreateNewCart = forceCartCreation || ordersSettings.ensureUserHasCart;
+  if (!shouldCreateNewCart) return null;
+
+  const countryObject = await this.countries.findCountry({ isoCode: countryCode });
+  const currencies = await this.currencies.findCurrencies({ includeInactive: false });
+  const currency = resolveBestCurrency(countryObject.defaultCurrencyCode, currencies);
+
+  const order = await this.orders.create({
+    userId: user._id,
+    orderNumber,
+    currency,
+    countryCode,
+    billingAddress: user.lastBillingAddress || user.profile?.address,
+    contact:
+      user.lastContact ||
+      (!user.guest
+        ? {
+            telNumber: user.profile?.phoneMobile,
+            emailAddress: this.users.primaryEmail(user)?.address,
+          }
+        : {}),
+  });
+
+  return initCartProvidersService.bind(this)(order);
+}

package/src/services/processEnrollment.ts

@@ -0,0 +1,37 @@
+import { Enrollment, EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { Modules } from '../modules.js';
+import { EnrollmentDirector } from '../core-index.js';
+
+const findNextStatus = async (enrollment: Enrollment, modules: Modules): Promise<EnrollmentStatus> => {
+  let status = enrollment.status;
+  const director = await EnrollmentDirector.actions({ enrollment }, { modules });
+
+  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 (modules.enrollments.isExpired(enrollment, {})) {
+    status = EnrollmentStatus.TERMINATED;
+  }
+
+  return status;
+};
+
+export async function processEnrollmentService(this: Modules, enrollment: Enrollment) {
+  const status = await findNextStatus(enrollment, this);
+
+  if (status === EnrollmentStatus.ACTIVE) {
+    // const nextEnrollment = await reactivateEnrollment(enrollment);
+    // TODO: Reactivate!
+    // status = await findNextStatus(nextEnrollment, unchainedAPI);
+  }
+
+  return this.enrollments.updateStatus(enrollment._id, {
+    status,
+    info: 'enrollment processed',
+  });
+}