@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc10

package/src/services/simulateProductInventory.ts

@@ -0,0 +1,56 @@
+import { DeliveryProvider } from '@unchainedshop/core-delivery';
+import { Modules } from '../modules.js';
+import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.js';
+import { Product } from '@unchainedshop/core-products';
+import { EstimatedStock, WarehousingDirector } from '../directors/WarehousingDirector.js';
+import { WarehousingContext } from '../directors/WarehousingAdapter.js';
+import { WarehousingProvider } from '@unchainedshop/core-warehousing';
+
+export async function simulateProductInventoryService(
+  this: Modules,
+  {
+    deliveryProviders,
+    product,
+    referenceDate,
+  }: {
+    product: Product;
+    deliveryProviders: DeliveryProvider[];
+    referenceDate?: Date;
+  },
+) {
+  return deliveryProviders.reduce<
+    Promise<Array<WarehousingContext & EstimatedStock & { warehousingProvider: WarehousingProvider }>>
+  >(async (oldResult, deliveryProvider) => {
+    const result = await oldResult;
+
+    const warehousingProviders: WarehousingProvider[] = await supportedWarehousingProvidersService.bind(
+      this,
+    )({
+      product,
+      deliveryProvider,
+    });
+
+    const mappedWarehousingProviders = await Promise.all(
+      warehousingProviders.map(async (warehousingProvider) => {
+        const warehousingContext: WarehousingContext = {
+          deliveryProvider,
+          product,
+          referenceDate,
+        };
+
+        const director = await WarehousingDirector.actions(warehousingProvider, warehousingContext, {
+          modules: this,
+        });
+        const stock = await director.estimatedStock();
+
+        return {
+          warehousingProvider,
+          ...warehousingContext,
+          ...stock,
+        };
+      }),
+    );
+
+    return result.concat(result, mappedWarehousingProviders);
+  }, Promise.resolve([]));
+}

package/src/services/simulateProductPricing.ts

@@ -0,0 +1,20 @@
+import { Product, ProductConfiguration } from '@unchainedshop/core-products';
+import { ProductPricingDirector } from '../core-index.js';
+import { User } from '@unchainedshop/core-users';
+import { Modules } from '../modules.js';
+
+export async function simulateProductPricingService(
+  this: Modules,
+  pricingContext: {
+    product: Product;
+    user: User;
+    country: string;
+    currency: string;
+    quantity: number;
+    configuration?: Array<ProductConfiguration>;
+  },
+) {
+  const calculated = await ProductPricingDirector.rebuildCalculation(pricingContext, { modules: this });
+  if (!calculated || !calculated.length) return null;
+  return ProductPricingDirector.calculationSheet(pricingContext, calculated);
+}

package/src/services/supportedDeliveryProviders.ts

@@ -0,0 +1,24 @@
+import { DeliveryProvider, deliverySettings } from '@unchainedshop/core-delivery';
+import { Modules } from '../modules.js';
+import { DeliveryContext, DeliveryDirector } from '../directors/index.js';
+
+export async function supportedDeliveryProvidersService(this: Modules, params: DeliveryContext) {
+  const allProviders = await this.delivery.findProviders({});
+
+  const providers = (
+    await Promise.all(
+      allProviders.map(async (provider: DeliveryProvider) => {
+        const adapter = await DeliveryDirector.actions(provider, params, { modules: this });
+        return adapter.isActive() ? [provider] : [];
+      }),
+    )
+  ).flat();
+
+  return deliverySettings.filterSupportedProviders(
+    {
+      providers,
+      order: params.order,
+    },
+    { modules: this },
+  );
+}

package/src/services/supportedPaymentProviders.ts

@@ -0,0 +1,25 @@
+import { PaymentProvider, paymentSettings } from '@unchainedshop/core-payment';
+import { PaymentDirector } from '../directors/PaymentDirector.js';
+import { PaymentContext } from '../directors/PaymentAdapter.js';
+import { Modules } from '../modules.js';
+
+export async function supportedPaymentProvidersService(this: Modules, params: PaymentContext) {
+  const allProviders = await this.payment.paymentProviders.findProviders({});
+
+  const providers = (
+    await Promise.all(
+      allProviders.map(async (provider: PaymentProvider) => {
+        const adapter = await PaymentDirector.actions(provider, params, { modules: this });
+        return adapter.isActive() ? [provider] : [];
+      }),
+    )
+  ).flat();
+
+  return paymentSettings.filterSupportedProviders(
+    {
+      providers,
+      order: params.order,
+    },
+    { modules: this },
+  );
+}

package/src/services/supportedWarehousingProviders.ts

@@ -0,0 +1,18 @@
+import { WarehousingProvider } from '@unchainedshop/core-warehousing';
+import { WarehousingContext, WarehousingDirector } from '../directors/index.js';
+import { Modules } from '../modules.js';
+
+export async function supportedWarehousingProvidersService(this: Modules, params: WarehousingContext) {
+  const allProviders = await this.warehousing.findProviders({});
+
+  const providers = (
+    await Promise.all(
+      allProviders.map(async (provider: WarehousingProvider) => {
+        const adapter = await WarehousingDirector.actions(provider, params, { modules: this });
+        return adapter.isActive() ? [provider] : [];
+      }),
+    )
+  ).flat();
+
+  return providers;
+}

package/src/services/terminateEnrollment.ts

@@ -0,0 +1,29 @@
+import { Enrollment, EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { processEnrollmentService } from './processEnrollment.js';
+
+export async function terminateEnrollmentService(enrollment: Enrollment) {
+  if (enrollment.status === EnrollmentStatus.TERMINATED) return enrollment;
+
+  let updatedEnrollment = await this.enrollments.updateStatus(enrollment._id, {
+    status: EnrollmentStatus.TERMINATED,
+    info: 'terminated manually',
+  });
+
+  updatedEnrollment = 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: 'status_change',
+      locale: locale.baseName,
+      template: 'ENROLLMENT_STATUS',
+      enrollmentId: updatedEnrollment._id,
+    },
+  });
+
+  return updatedEnrollment;
+}

package/src/services/updateCalculation.ts

@@ -0,0 +1,143 @@
+import { OrderDiscountTrigger } from '@unchainedshop/core-orders';
+import { initCartProvidersService } from './initCartProviders.js';
+import { Modules } from '../modules.js';
+import { updateSchedulingService } from './updateScheduling.js';
+import {
+  OrderDiscountDirector,
+  OrderPricingDirector,
+  DeliveryPricingDirector,
+  ProductPricingDirector,
+  PaymentPricingDirector,
+} from '../directors/index.js';
+
+export async function updateCalculationService(this: Modules, orderId: string) {
+  const order = await this.orders.findOrder({ orderId });
+
+  // Don't recalculate orders, only carts
+  if (order.status !== null) return order;
+
+  // 1. go through existing order-discounts and check if discount still valid,
+  // those who are not valid anymore should get removed
+  const discounts = await this.orders.discounts.findOrderDiscounts({
+    orderId: order._id,
+  });
+
+  await Promise.all(
+    discounts.map(async (orderDiscount) => {
+      const Adapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
+      if (!Adapter) return null;
+      const adapter = await Adapter.actions({
+        context: { order, orderDiscount, code: orderDiscount.code, modules: this },
+      });
+
+      const isValid =
+        orderDiscount.trigger === OrderDiscountTrigger.SYSTEM
+          ? await adapter.isValidForSystemTriggering()
+          : await adapter.isValidForCodeTriggering({
+              code: orderDiscount.code,
+            });
+
+      if (!isValid) {
+        if (orderDiscount.trigger === OrderDiscountTrigger.USER) {
+          await adapter.release();
+        }
+        await this.orders.discounts.delete(orderDiscount._id);
+      }
+    }),
+  );
+
+  // 2. run auto-system discount
+  const cleanedDiscounts = await this.orders.discounts.findOrderDiscounts({
+    orderId: order._id,
+  });
+
+  const currentDiscountKeys = cleanedDiscounts.map(({ discountKey }) => discountKey);
+  const director = await OrderDiscountDirector.actions({ order, code: null }, { modules: this });
+  const systemDiscounts = await director.findSystemDiscounts();
+  await Promise.all(
+    systemDiscounts
+      .filter((key) => currentDiscountKeys.indexOf(key) === -1)
+      .map(async (discountKey) =>
+        this.orders.discounts.create({
+          orderId: order._id,
+          discountKey,
+          trigger: OrderDiscountTrigger.SYSTEM,
+        }),
+      ),
+  );
+
+  let orderPositions = await this.orders.positions.findOrderPositions({
+    orderId,
+  });
+  orderPositions = await Promise.all(
+    orderPositions.map(async (orderPosition) => {
+      const positionCalculation = await ProductPricingDirector.rebuildCalculation(
+        {
+          currency: order.currency,
+          quantity: orderPosition.quantity,
+          item: orderPosition,
+          configuration: orderPosition.configuration,
+        },
+        { modules: this },
+      );
+      return this.orders.positions.updateCalculation(orderPosition._id, positionCalculation);
+    }),
+  );
+
+  let orderDelivery = await this.orders.deliveries.findDelivery({
+    orderDeliveryId: order.deliveryId,
+  });
+  if (orderDelivery) {
+    const deliveryCalculation = await DeliveryPricingDirector.rebuildCalculation(
+      {
+        currency: order.currency,
+        item: orderDelivery,
+      },
+      { modules: this },
+    );
+    orderDelivery = await this.orders.deliveries.updateCalculation(
+      orderDelivery._id,
+      deliveryCalculation,
+    );
+  }
+  let orderPayment = await this.orders.payments.findOrderPayment({
+    orderPaymentId: order.paymentId,
+  });
+  if (orderPayment) {
+    const paymentCalculation = await PaymentPricingDirector.rebuildCalculation(
+      {
+        currency: order.currency,
+        item: orderPayment,
+      },
+      { modules: this },
+    );
+    orderPayment = await this.orders.payments.updateCalculation(orderPayment._id, paymentCalculation);
+  }
+
+  orderPositions = await updateSchedulingService.bind(this)({
+    order,
+    orderPositions,
+    orderDelivery,
+  });
+
+  const calculation = await OrderPricingDirector.rebuildCalculation(
+    { currency: order.currency, order, orderPositions, orderDelivery, orderPayment },
+    { modules: this },
+  );
+
+  const updatedOrder = await this.orders.updateCalculationSheet(orderId, calculation);
+
+  /*
+       // We have to do initCartProviders after calculation, only then filterSupportedProviders will work correctly and has access to recent pricing
+       // initCartProviders calls updateCalculation anyways recursively when a new payment or delivery provider gets set
+       // Thus, if for example a discount change leads to a free delivery and free payment due to free items amount, the following happens in the stack:
+        // 1. create discount
+        // 2. update calculation -> order pricing updated to items 0
+        // 3. initCartProviders with updated order -> filterSupportedProviders -> delivery provider is invalid -> set new delivery provider
+        // 4. update calculation -> order pricing updated to items 0 and delivery 0
+        // 5. initCartProviders with updated order -> filterSupportedProviders -> payment provider is invalid -> set new payment provider
+        // 6. update calculation -> order pricing updated to items 0, delivery 0, payment 0
+        // 7. initCartProviders with updated order -> all providers are valid -> return order
+    */
+  return initCartProvidersService.bind(this)(updatedOrder);
+}

package/src/services/updateScheduling.ts

@@ -0,0 +1,64 @@
+import { Order, OrderDelivery, OrderPosition } from '@unchainedshop/core-orders';
+import { WarehousingDirector } from '../directors/index.js';
+import { Modules } from '../modules.js';
+import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.js';
+
+export async function updateSchedulingService(
+  this: Modules,
+  {
+    orderPositions,
+    order,
+    orderDelivery,
+  }: { orderPositions: OrderPosition[]; order: Order; orderDelivery: OrderDelivery },
+) {
+  const deliveryProvider =
+    orderDelivery &&
+    (await this.delivery.findProvider({
+      deliveryProviderId: orderDelivery.deliveryProviderId,
+    }));
+
+  return (await Promise.all(
+    orderPositions.map(async (orderPosition) => {
+      // scheduling (store in db for auditing)
+      const product = await this.products.findProduct({
+        productId: orderPosition.productId,
+      });
+
+      const { countryCode, userId } = order;
+
+      const scheduling = await Promise.all(
+        (
+          await supportedWarehousingProvidersService.bind(this)({
+            product,
+            deliveryProvider,
+          })
+        ).map(async (warehousingProvider) => {
+          const context = {
+            warehousingProvider,
+            deliveryProvider,
+            product,
+            item: orderPosition,
+            delivery: deliveryProvider,
+            order,
+            userId,
+            country: countryCode,
+            referenceDate: order.ordered,
+            quantity: orderPosition.quantity,
+          };
+
+          const director = await WarehousingDirector.actions(warehousingProvider, context, {
+            modules: this,
+          });
+          const dispatch = await director.estimatedDispatch();
+
+          return {
+            warehousingProviderId: warehousingProvider._id,
+            ...dispatch,
+          };
+        }),
+      );
+
+      return this.orders.positions.updateScheduling(orderPosition._id, scheduling);
+    }),
+  )) as Array<OrderPosition>;
+}

package/src/services/updateUserAvatarAfterUpload.ts

@@ -0,0 +1,30 @@
+import { File } from '@unchainedshop/core-files';
+import { removeFilesService } from './removeFiles.js';
+import { Modules } from '../modules.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:core');
+
+export async function updateUserAvatarAfterUploadService(this: Modules, { file }: { file: File }) {
+  const { userId } = file.meta as { userId: string };
+
+  const files = await this.files.findFiles({
+    _id: { $ne: file._id },
+    path: file.path,
+    'meta.userId': userId,
+  });
+  const fileIds = files.map((f) => f._id);
+
+  try {
+    if (fileIds?.length) {
+      await removeFilesService.bind(this)({
+        fileIds,
+      });
+    }
+  } catch (e: unknown) {
+    // cleanup error, not critical
+    logger.warn(`could not clean up all old avatars: ${(e as Error).message}`);
+  }
+
+  await this.users.updateAvatar(userId, file._id);
+}

package/src/services/uploadFileFromStream.ts

@@ -0,0 +1,15 @@
+import { getFileFromFileData, getFileAdapter, File } from '@unchainedshop/core-files';
+import { Modules } from '../modules.js';
+
+export async function uploadFileFromStreamService(
+  this: Modules,
+  { directoryName, rawFile, meta }: { directoryName: string; rawFile: any; meta?: any },
+): Promise<File> {
+  const fileUploadAdapter = getFileAdapter();
+  const uploadFileData = await fileUploadAdapter.uploadFileFromStream(directoryName, rawFile, {
+    modules: this,
+  });
+  const fileData = getFileFromFileData(uploadFileData, meta);
+  const fileId = await this.files.create(fileData);
+  return this.files.findFile({ fileId });
+}

package/src/services/uploadFileFromURL.ts

@@ -0,0 +1,29 @@
+import { getFileFromFileData, getFileAdapter, File } from '@unchainedshop/core-files';
+import { Modules } from '../modules.js';
+
+export async function uploadFileFromURLService(
+  this: Modules,
+  {
+    directoryName,
+    fileInput,
+    meta,
+  }: {
+    directoryName: string;
+    fileInput: {
+      fileLink: string;
+      fileName: string;
+      fileId?: string;
+      headers?: Record<string, unknown>;
+    };
+    meta?: any;
+  },
+): Promise<File> {
+  const fileUploadAdapter = getFileAdapter();
+
+  const uploadFileData = await fileUploadAdapter.uploadFileFromURL(directoryName, fileInput, {
+    modules: this,
+  });
+  const fileData = getFileFromFileData(uploadFileData, meta);
+  const fileId = await this.files.create(fileData);
+  return this.files.findFile({ fileId });
+}

package/src/services/validateOrder.ts

@@ -0,0 +1,53 @@
+import { Order, ordersSettings } from '@unchainedshop/core-orders';
+import { Modules } from '../modules.js';
+
+export async function validateOrderService(this: Modules, order: Order) {
+  const errors = [];
+  if (!order.contact) errors.push(new Error('Contact data not provided'));
+  if (!order.billingAddress) errors.push(new Error('Billing address not provided'));
+  if (!(await this.orders.deliveries.findDelivery({ orderDeliveryId: order.deliveryId })))
+    errors.push('No delivery provider selected');
+  if (!(await this.orders.payments.findOrderPayment({ orderPaymentId: order.paymentId })))
+    errors.push('No payment provider selected');
+
+  const orderPositions = await this.orders.positions.findOrderPositions({ orderId: order._id });
+  if (orderPositions.length === 0) {
+    const NoItemsError = new Error('No items to checkout');
+    NoItemsError.name = 'NoItemsError';
+    return [NoItemsError];
+  }
+  await Promise.all(
+    orderPositions.map(async (orderPosition) => {
+      const product = await this.products.findProduct({
+        productId: orderPosition.productId,
+      });
+
+      try {
+        await ordersSettings.validateOrderPosition(
+          {
+            order,
+            product,
+            configuration: orderPosition.configuration,
+            quantityDiff: 0,
+          },
+          { modules: this },
+        );
+      } catch (e) {
+        errors.push(e);
+      }
+
+      const quotation =
+        orderPosition.quotationId &&
+        (await this.quotations.findQuotation({
+          quotationId: orderPosition.quotationId,
+        }));
+      if (quotation && !this.quotations.isProposalValid(quotation)) {
+        errors.push(new Error('Quotation expired or fullfiled, please request a new offer'));
+      }
+    }),
+  );
+
+  if (errors.length > 0) {
+    throw new Error(errors[0]);
+  }
+}

package/src/services/verifyQuotation.ts

@@ -0,0 +1,18 @@
+import { Quotation, QuotationStatus } from '@unchainedshop/core-quotations';
+import { processQuotationService } from './processQuotation.js';
+import { Modules } from '../modules.js';
+
+export async function verifyQuotationService(
+  this: Modules,
+  quotation: Quotation,
+  { quotationContext }: { quotationContext?: any },
+) {
+  if (quotation.status !== QuotationStatus.REQUESTED) return quotation;
+
+  const updatedQuotation = await this.quotations.updateStatus(quotation._id, {
+    status: QuotationStatus.PROCESSING,
+    info: 'verified elligibility manually',
+  });
+
+  return await processQuotationService.bind(this)(updatedQuotation, { quotationContext });
+}

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/lib/types.d.ts

@@ -1,4 +0,0 @@
-export interface BulkImporter {
-    createBulkImporter: (options: any) => any;
-}
-//# sourceMappingURL=types.d.ts.map

package/lib/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,kBAAkB,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,GAAG,CAAC;CAC3C"}

package/lib/types.js

@@ -1,5 +0,0 @@
-export {};
-/*
- * Module
- */
-//# sourceMappingURL=types.js.map

package/lib/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";AAIA;;GAEG"}

package/src/types.ts

@@ -1,7 +0,0 @@
-export interface BulkImporter {
-  createBulkImporter: (options: any) => any;
-}
-
-/*
- * Module
- */