@unchainedshop/core 4.3.6 → 4.4.0

package/src/factory/registerVirtualWarehousing.ts

@@ -1,100 +0,0 @@
-import {
-  TokenSurrogate,
-  WarehousingConfiguration,
-  WarehousingProviderType,
-} from '@unchainedshop/core-warehousing';
-import { WarehousingAdapter, WarehousingContext, WarehousingDirector } from '../core-index.js';
-
-export default function registerVirtualWarehousing<Metadata = Record<string, any>>({
-  adapterId,
-  orderIndex = 0,
-  stock,
-  tokenize,
-  tokenMetadata,
-  isInvalidateable,
-}: {
-  adapterId: string;
-  orderIndex?: number;
-  stock?:
-    | number
-    | ((
-        referenceDate: Date,
-        configuration: WarehousingConfiguration,
-        context: WarehousingContext,
-      ) => Promise<number>);
-
-  tokenize: (
-    configuration: WarehousingConfiguration,
-    context: WarehousingContext,
-  ) => Promise<Omit<TokenSurrogate, 'userId' | 'productId' | 'orderPositionId'>[]>;
-
-  tokenMetadata?: (
-    serialNumber: string,
-    referenceDate: Date,
-    configuration: WarehousingConfiguration,
-    context: WarehousingContext,
-  ) => Promise<Metadata>;
-
-  isInvalidateable?: (
-    serialNumber: string,
-    referenceDate: Date,
-    configuration: WarehousingConfiguration,
-    context: WarehousingContext,
-  ) => Promise<boolean>;
-}) {
-  WarehousingDirector.registerAdapter({
-    ...WarehousingAdapter,
-
-    key: 'shop.unchained.warehousing.virtual.' + adapterId,
-    label: 'Virtual Wareshousing: ' + adapterId,
-    version: '1.0.0',
-    orderIndex,
-
-    initialConfiguration: [{ key: 'shipping-hub', value: 'Shipping Hub' }],
-
-    typeSupported: (type) => {
-      return type === WarehousingProviderType.VIRTUAL;
-    },
-
-    actions: (configuration, context) => {
-      return {
-        ...WarehousingAdapter.actions(configuration, context),
-
-        isActive() {
-          return true;
-        },
-
-        configurationError() {
-          return null;
-        },
-
-        stock: async (referenceDate) => {
-          if (typeof stock === 'number') {
-            return stock;
-          } else if (typeof stock === 'function') {
-            return stock(referenceDate, configuration, context);
-          }
-          return 99999;
-        },
-
-        async tokenize() {
-          return tokenize(configuration, context);
-        },
-
-        async tokenMetadata(serialNumber, referenceDate) {
-          if (tokenMetadata) {
-            return tokenMetadata(serialNumber, referenceDate, configuration, context);
-          }
-          return null;
-        },
-
-        async isInvalidateable(serialNumber, referenceDate) {
-          if (isInvalidateable) {
-            return isInvalidateable(serialNumber, referenceDate, configuration, context);
-          }
-          return false;
-        },
-      };
-    },
-  });
-}

package/src/factory/registerWorker.ts

@@ -1,46 +0,0 @@
-import { WorkerAdapter, WorkerDirector } from '../core-index.js';
-
-export default function registerWorker<Input = any, Result = any>({
-  type,
-  external,
-  maxParallelAllocations,
-  process,
-}: {
-  type: string;
-  external?: boolean;
-  maxParallelAllocations?: number;
-  process?: (input: Input, workId: string) => Promise<Result>;
-}) {
-  WorkerDirector.registerAdapter({
-    ...WorkerAdapter,
-
-    key: 'shop.unchained.worker.' + type.toLowerCase(),
-    label: 'Worker: ' + type,
-    version: '1.0',
-    external: external ?? false,
-    maxParallelAllocations,
-    type,
-
-    async doWork(input, _, workId) {
-      if (!process) {
-        return { success: false };
-      }
-      try {
-        const result = await process(input, workId);
-        return {
-          success: true,
-          result,
-        };
-      } catch (err) {
-        return {
-          success: false,
-          error: {
-            name: err.name,
-            message: err.message,
-            cause: err.cause,
-          },
-        };
-      }
-    },
-  });
-}

package/src/modules.ts

@@ -1,207 +0,0 @@
-import {
-  AssortmentsModule,
-  AssortmentsSettingsOptions,
-  configureAssortmentsModule,
-} from '@unchainedshop/core-assortments';
-import { BookmarksModule, configureBookmarksModule } from '@unchainedshop/core-bookmarks';
-import { configureCountriesModule, CountriesModule } from '@unchainedshop/core-countries';
-import { configureCurrenciesModule, CurrenciesModule } from '@unchainedshop/core-currencies';
-import {
-  configureDeliveryModule,
-  DeliveryModule,
-  DeliverySettingsOptions,
-} from '@unchainedshop/core-delivery';
-import {
-  configureEnrollmentsModule,
-  EnrollmentsModule,
-  EnrollmentsSettingsOptions,
-} from '@unchainedshop/core-enrollments';
-import { configureEventsModule, EventsModule } from '@unchainedshop/core-events';
-import { configureFilesModule, FilesModule, FilesSettingsOptions } from '@unchainedshop/core-files';
-import {
-  configureFiltersModule,
-  FiltersModule,
-  FiltersSettingsOptions,
-} from '@unchainedshop/core-filters';
-import { configureLanguagesModule, LanguagesModule } from '@unchainedshop/core-languages';
-import { configureOrdersModule, OrdersModule, OrdersSettingsOptions } from '@unchainedshop/core-orders';
-import {
-  configurePaymentModule,
-  PaymentModule,
-  PaymentSettingsOptions,
-} from '@unchainedshop/core-payment';
-import {
-  configureProductsModule,
-  ProductsModule,
-  ProductsSettingsOptions,
-} from '@unchainedshop/core-products';
-import {
-  configureQuotationsModule,
-  QuotationsModule,
-  QuotationsSettingsOptions,
-} from '@unchainedshop/core-quotations';
-import { configureUsersModule, UserSettingsOptions, UsersModule } from '@unchainedshop/core-users';
-import { configureWarehousingModule, WarehousingModule } from '@unchainedshop/core-warehousing';
-import { configureWorkerModule, WorkerModule, WorkerSettingsOptions } from '@unchainedshop/core-worker';
-import { MigrationRepository, ModuleInput, mongodb } from '@unchainedshop/mongodb';
-
-export interface Modules {
-  assortments: AssortmentsModule;
-  bookmarks: BookmarksModule;
-  countries: CountriesModule;
-  currencies: CurrenciesModule;
-  delivery: DeliveryModule;
-  enrollments: EnrollmentsModule;
-  events: EventsModule;
-  files: FilesModule;
-  filters: FiltersModule;
-  languages: LanguagesModule;
-  orders: OrdersModule;
-  payment: PaymentModule;
-  products: ProductsModule;
-  quotations: QuotationsModule;
-  users: UsersModule;
-  warehousing: WarehousingModule;
-  worker: WorkerModule;
-}
-
-export interface ModuleOptions {
-  assortments?: AssortmentsSettingsOptions;
-  products?: ProductsSettingsOptions;
-  delivery?: DeliverySettingsOptions;
-  payment?: PaymentSettingsOptions;
-  filters?: FiltersSettingsOptions;
-  enrollments?: EnrollmentsSettingsOptions;
-  orders?: OrdersSettingsOptions;
-  quotations?: QuotationsSettingsOptions;
-  files?: FilesSettingsOptions;
-  worker?: WorkerSettingsOptions;
-  users?: UserSettingsOptions;
-}
-
-export default async function initModules(
-  {
-    db,
-    migrationRepository,
-    options,
-  }: {
-    db: mongodb.Db;
-    migrationRepository: MigrationRepository<unknown>;
-    options: ModuleOptions;
-  },
-  customModules: Record<
-    string,
-    {
-      configure: (params: ModuleInput<any>) => any;
-    }
-  >,
-): Promise<Modules> {
-  const assortments = await configureAssortmentsModule({
-    db,
-    options: options.assortments,
-    migrationRepository,
-  });
-  const bookmarks = await configureBookmarksModule({
-    db,
-    migrationRepository,
-  });
-  const countries = await configureCountriesModule({
-    db,
-    migrationRepository,
-  });
-  const currencies = await configureCurrenciesModule({
-    db,
-    migrationRepository,
-  });
-  const delivery = await configureDeliveryModule({
-    db,
-    options: options.delivery,
-    migrationRepository,
-  });
-  const enrollments = await configureEnrollmentsModule({
-    db,
-    options: options.enrollments,
-    migrationRepository,
-  });
-  const events = await configureEventsModule({
-    db,
-    migrationRepository,
-  });
-  const files = await configureFilesModule({
-    db,
-    options: options.files,
-    migrationRepository,
-  });
-  const filters = await configureFiltersModule({
-    db,
-    options: options.filters,
-    migrationRepository,
-  });
-  const languages = await configureLanguagesModule({
-    db,
-    migrationRepository,
-  });
-  const orders = await configureOrdersModule({
-    db,
-    options: options.orders,
-    migrationRepository,
-  });
-  const payment = await configurePaymentModule({
-    db,
-    options: options.payment,
-    migrationRepository,
-  });
-  const products = await configureProductsModule({
-    db,
-    migrationRepository,
-    options: options.products,
-  });
-  const quotations = await configureQuotationsModule({
-    db,
-    options: options.quotations,
-    migrationRepository,
-  });
-  const users = await configureUsersModule({
-    db,
-    options: options.users,
-    migrationRepository,
-  });
-  const warehousing = await configureWarehousingModule({
-    db,
-    migrationRepository,
-  });
-  const worker = await configureWorkerModule({
-    db,
-    options: options.worker,
-    migrationRepository,
-  });
-
-  const modules = {
-    assortments,
-    bookmarks,
-    countries,
-    currencies,
-    delivery,
-    enrollments,
-    events,
-    files,
-    filters,
-    languages,
-    orders,
-    payment,
-    products,
-    quotations,
-    users,
-    warehousing,
-    worker,
-  };
-  for (const [key, customModule] of Object.entries(customModules)) {
-    modules[key] = await customModule.configure({
-      db,
-      options: options[key],
-      migrationRepository,
-    });
-  }
-
-  return modules;
-}

package/src/services/activateEnrollment.ts

@@ -1,26 +0,0 @@
-import { Enrollment, EnrollmentStatus } from '@unchainedshop/core-enrollments';
-import { Modules } from '../modules.js';
-import { processEnrollmentService } from './processEnrollment.js';
-import { addMessageService } from './addMessage.js';
-
-export async function activateEnrollmentService(this: Modules, enrollment: Enrollment) {
-  if (enrollment.status === EnrollmentStatus.TERMINATED) return enrollment;
-
-  let updatedEnrollment = (await this.enrollments.updateStatus(enrollment._id, {
-    status: EnrollmentStatus.ACTIVE,
-    info: 'activated manually',
-  })) as Enrollment;
-
-  updatedEnrollment = (await processEnrollmentService.bind(this)(updatedEnrollment)) as Enrollment;
-
-  const user = await this.users.findUserById(enrollment.userId);
-  const locale = this.users.userLocale(user);
-
-  await addMessageService.bind(this)('ENROLLMENT_STATUS', {
-    reason: 'status_change',
-    locale: locale.baseName,
-    enrollmentId: updatedEnrollment!._id,
-  });
-
-  return updatedEnrollment!;
-}

package/src/services/addMessage.ts

@@ -1,20 +0,0 @@
-import { Work } from '@unchainedshop/core-worker';
-import { MessagingDirector } from '../core-index.js';
-import { Modules } from '../modules.js';
-
-export async function addMessageService<T = Record<string, any>>(
-  this: Modules,
-  template: string,
-  input: T,
-): Promise<Work | null> {
-  const templateResolver = MessagingDirector.getTemplate(template); // Validate template exists
-  if (!templateResolver) return null;
-  return this.worker.addWork({
-    type: 'MESSAGE',
-    input: {
-      template,
-      ...input,
-    },
-    retries: 0,
-  });
-}

package/src/services/calculateDiscountTotal.ts

@@ -1,71 +0,0 @@
-import { Order, OrderDiscount } from '@unchainedshop/core-orders';
-import { Modules } from '../modules.js';
-import {
-  OrderPricingRowCategory,
-  OrderPricingSheet,
-  DeliveryPricingRowCategory,
-  DeliveryPricingSheet,
-  ProductPricingRowCategory,
-  ProductPricingSheet,
-  PaymentPricingRowCategory,
-  PaymentPricingSheet,
-} from '../directors/index.js';
-
-export async function calculateDiscountTotalService(
-  this: Modules,
-  order: Order,
-  orderDiscount: OrderDiscount,
-) {
-  const orderDiscountId = orderDiscount._id;
-
-  // Delivery discounts
-  const orderDelivery = await this.orders.deliveries.findDelivery({
-    orderDeliveryId: order.deliveryId!,
-  });
-  const orderDeliveryDiscountSum = DeliveryPricingSheet({
-    calculation: orderDelivery?.calculation || [],
-    currencyCode: order.currencyCode,
-  }).total({ category: DeliveryPricingRowCategory.Discount, discountId: orderDiscountId });
-
-  // Payment discounts
-  const orderPayment = await this.orders.payments.findOrderPayment({
-    orderPaymentId: order.paymentId!,
-  });
-  const orderPaymentDiscountSum = PaymentPricingSheet({
-    calculation: orderPayment?.calculation || [],
-    currencyCode: order.currencyCode,
-  }).total({ category: PaymentPricingRowCategory.Discount, discountId: orderDiscountId });
-
-  // Position discounts
-  const orderPositions = await this.orders.positions.findOrderPositions({
-    orderId: order._id,
-  });
-  const orderPositionDiscounts = orderPositions.map((orderPosition) =>
-    ProductPricingSheet({
-      calculation: orderPosition.calculation || [],
-      currencyCode: order.currencyCode,
-      quantity: orderPosition.quantity,
-    }).total({
-      category: ProductPricingRowCategory.Discount,
-      discountId: orderDiscountId,
-    }),
-  );
-
-  // order discounts
-  const orderDiscountSum = OrderPricingSheet({
-    calculation: order.calculation,
-    currencyCode: order.currencyCode,
-  }).total({ category: OrderPricingRowCategory.Discounts, discountId: orderDiscountId });
-
-  const prices = [
-    orderDeliveryDiscountSum.amount,
-    orderPaymentDiscountSum.amount,
-    ...orderPositionDiscounts.map((positionDiscount) => positionDiscount.amount),
-    orderDiscountSum.amount,
-  ];
-  const amount = prices.reduce((oldValue, price) => oldValue + (price || 0), 0);
-  return {
-    amount,
-    currencyCode: order.currencyCode,
-  };
-}

package/src/services/checkoutOrder.ts

@@ -1,48 +0,0 @@
-import { OrderStatus } from '@unchainedshop/core-orders';
-import { Modules } from '../modules.js';
-import { nextUserCartService } from './nextUserCart.js';
-import { validateOrderService } from './validateOrder.js';
-import { processOrderService } from './processOrder.js';
-import { User } from '@unchainedshop/core-users';
-
-export async function checkoutOrderService(
-  this: Modules,
-  orderId: string,
-  transactionContext: {
-    paymentContext?: any;
-    deliveryContext?: any;
-    comment?: string;
-    nextStatus?: OrderStatus;
-  },
-) {
-  const order = await this.orders.findOrder({ orderId });
-  if (!order) return null;
-  if (order.status !== null) return order;
-
-  await validateOrderService.bind(this)(order);
-
-  const lock = await this.orders.acquireLock(order._id, 'checkout');
-
-  try {
-    const processedOrder = await processOrderService.bind(this)(order, transactionContext);
-
-    // After checkout, store last checkout information on user
-    if (processedOrder.billingAddress) {
-      await this.users.updateLastBillingAddress(processedOrder.userId, processedOrder.billingAddress);
-    }
-    if (processedOrder.contact) {
-      await this.users.updateLastContact(processedOrder.userId, processedOrder.contact);
-    }
-    // Then eventually build next cart
-    const user = (await this.users.findUserById(processedOrder.userId)) as User;
-    const locale = this.users.userLocale(user);
-    await nextUserCartService.bind(this)({
-      user,
-      countryCode: locale?.region || processedOrder.countryCode,
-    });
-
-    return processedOrder;
-  } finally {
-    await lock.release();
-  }
-}

package/src/services/confirmOrder.ts

@@ -1,26 +0,0 @@
-import { Order, OrderStatus } from '@unchainedshop/core-orders';
-import { Modules } from '../modules.js';
-import { processOrderService } from './processOrder.js';
-
-export async function confirmOrderService(
-  this: Modules,
-  order: Order,
-  transactionContext: {
-    paymentContext?: any;
-    deliveryContext?: any;
-    comment?: string;
-    nextStatus?: OrderStatus;
-  },
-) {
-  if (order.status !== OrderStatus.PENDING) return order;
-
-  const lock = await this.orders.acquireLock(order._id, 'confirm-reject', 1500);
-  try {
-    return await processOrderService.bind(this)(order, {
-      ...transactionContext,
-      nextStatus: OrderStatus.CONFIRMED,
-    });
-  } finally {
-    await lock.release();
-  }
-}

package/src/services/createDownloadStream.ts

@@ -1,17 +0,0 @@
-import { getFileAdapter } from '@unchainedshop/core-files';
-import { Modules } from '../modules.js';
-
-export async function createDownloadStreamService(
-  this: Modules,
-  {
-    fileId,
-  }: {
-    fileId: string;
-  },
-) {
-  const fileAdapter = getFileAdapter();
-  const file = await this.files.findFile({ fileId });
-  if (!file) return null;
-  const stream = fileAdapter.createDownloadStream(file, { modules: this });
-  return stream;
-}

package/src/services/createEnrollmentFromCheckout.ts

@@ -1,68 +0,0 @@
-import { Order, OrderPosition } from '@unchainedshop/core-orders';
-import { Product } from '@unchainedshop/core-products';
-import { Enrollment } from '@unchainedshop/core-enrollments';
-import { Modules } from '../modules.js';
-import { EnrollmentDirector } from '../directors/index.js';
-import { initializeEnrollmentService } from './initializeEnrollment.js';
-
-export async function createEnrollmentFromCheckoutService(
-  this: Modules,
-  order: Order,
-  {
-    items,
-    context,
-  }: {
-    items: {
-      orderPosition: OrderPosition;
-      product: Product;
-    }[];
-    context: {
-      paymentContext?: any;
-      deliveryContext?: any;
-    };
-  },
-): Promise<Enrollment[]> {
-  const orderId = order._id;
-
-  const payment = await this.orders.payments.findOrderPayment({
-    orderPaymentId: order.paymentId!,
-  });
-  const delivery = await this.orders.deliveries.findDelivery({
-    orderDeliveryId: order.deliveryId!,
-  });
-
-  const template = {
-    billingAddress: order.billingAddress!,
-    contact: order.contact!,
-    countryCode: order.countryCode,
-    currencyCode: order.currencyCode,
-    delivery: {
-      deliveryProviderId: delivery!.deliveryProviderId,
-      context: delivery!.context,
-    },
-    orderIdForFirstPeriod: orderId,
-    payment: {
-      paymentProviderId: payment!.paymentProviderId,
-      context: payment!.context,
-    },
-    userId: order.userId,
-    meta: order.context,
-    ...context,
-  };
-
-  return (
-    await Promise.all(
-      items.map(async (item) => {
-        const enrollmentData = await EnrollmentDirector.transformOrderItemToEnrollment(item, template, {
-          modules: this,
-        });
-
-        const enrollment = await this.enrollments.create(enrollmentData);
-        return await initializeEnrollmentService.bind(this)(enrollment, {
-          orderIdForFirstPeriod: enrollment.orderIdForFirstPeriod,
-          reason: 'new_enrollment',
-        });
-      }),
-    )
-  ).filter(Boolean) as Enrollment[];
-}

package/src/services/createManualOrderDiscount.ts

@@ -1,56 +0,0 @@
-import { Order } from '@unchainedshop/core-orders';
-import { OrderDiscountDirector } from '../directors/OrderDiscountDirector.js';
-import { Modules } from '../modules.js';
-
-export async function createManualOrderDiscountService(
-  this: Modules,
-  { order, code }: { code: string; order: Order },
-) {
-  // Use an already existing discount if available!
-  const spareDiscount = await this.orders.discounts.findSpareDiscount({ code });
-  if (spareDiscount) {
-    const Adapter = OrderDiscountDirector.getAdapter(spareDiscount.discountKey);
-    if (!Adapter) return null;
-
-    const actions = await Adapter.actions({
-      context: { order, orderDiscount: spareDiscount, code, modules: this },
-    });
-    const reservation = await actions.reserve({
-      code,
-    });
-
-    return this.orders.discounts.update(spareDiscount._id, { orderId: order._id, reservation });
-  }
-
-  const director = await OrderDiscountDirector.actions({ order, code }, { modules: this });
-  const Adapter = await director.resolveDiscountAdapterFromStaticCode({
-    code,
-  });
-
-  if (!Adapter) return null;
-
-  const newDiscount = await this.orders.discounts.create({
-    orderId: order._id,
-    code,
-    discountKey: Adapter.key,
-  });
-
-  const adapter = await Adapter.actions({
-    context: { order, orderDiscount: newDiscount, code: newDiscount.code, modules: this },
-  });
-
-  try {
-    const reservation = await adapter.reserve({
-      code: newDiscount.code,
-    });
-    const reservedDiscount = this.orders.discounts.update(newDiscount._id, {
-      orderId: newDiscount.orderId,
-      reservation,
-    });
-    return reservedDiscount;
-  } catch (error) {
-    await adapter.release();
-    await this.orders.discounts.delete(newDiscount._id);
-    throw error;
-  }
-}