@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc2

package/src/services/activateEnrollment.ts

@@ -0,0 +1,30 @@
+import { Enrollment, EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { Modules } from '../modules.js';
+import { processEnrollmentService } from './processEnrollment.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',
+  });
+
+  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,
+      template: 'ENROLLMENT_STATUS',
+      enrollmentId: updatedEnrollment._id,
+    },
+  });
+
+  return updatedEnrollment;
+}

package/src/services/calculateDiscountTotal.ts

@@ -0,0 +1,71 @@
+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 || [],
+    currency: order.currency,
+  }).total({ category: DeliveryPricingRowCategory.Discount, discountId: orderDiscountId });
+
+  // Payment discounts
+  const orderPayment = await this.orders.payments.findOrderPayment({
+    orderPaymentId: order.paymentId,
+  });
+  const orderPaymentDiscountSum = PaymentPricingSheet({
+    calculation: orderPayment.calculation || [],
+    currency: order.currency,
+  }).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 || [],
+      currency: order.currency,
+      quantity: orderPosition.quantity,
+    }).total({
+      category: ProductPricingRowCategory.Discount,
+      discountId: orderDiscountId,
+    }),
+  );
+
+  // order discounts
+  const orderDiscountSum = OrderPricingSheet({
+    calculation: order.calculation,
+    currency: order.currency,
+  }).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,
+    currency: order.currency,
+  };
+}

package/src/services/checkoutOrder.ts

@@ -0,0 +1,43 @@
+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';
+
+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.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
+    await this.users.updateLastBillingAddress(processedOrder.userId, processedOrder.billingAddress);
+    await this.users.updateLastContact(processedOrder.userId, processedOrder.contact);
+
+    // Then eventually build next cart
+    const user = await this.users.findUserById(processedOrder.userId);
+    const locale = this.users.userLocale(user);
+    await nextUserCartService.bind(this)({
+      user,
+      countryCode: locale.region,
+    });
+
+    return processedOrder;
+  } finally {
+    await lock.release();
+  }
+}

package/src/services/confirmOrder.ts

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,16 @@
+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 });
+  const stream = fileAdapter.createDownloadStream(file, { modules: this });
+  return stream;
+}

package/src/services/createEnrollmentFromCheckout.ts

@@ -0,0 +1,66 @@
+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: Array<{
+      orderPosition: OrderPosition;
+      product: Product;
+    }>;
+    context: {
+      paymentContext?: any;
+      deliveryContext?: any;
+    };
+  },
+): Promise<Array<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.currency,
+    delivery: {
+      deliveryProviderId: delivery.deliveryProviderId,
+      context: delivery.context,
+    },
+    orderIdForFirstPeriod: orderId,
+    payment: {
+      paymentProviderId: payment.paymentProviderId,
+      context: payment.context,
+    },
+    userId: order.userId,
+    meta: order.context,
+    ...context,
+  };
+
+  return 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',
+      });
+    }),
+  );
+}

package/src/services/createManualOrderDiscount.ts

@@ -0,0 +1,56 @@
+import { Order, OrderDiscount } 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 },
+): Promise<OrderDiscount> {
+  // 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;
+  }
+}

package/src/services/createSignedURL.ts

@@ -0,0 +1,20 @@
+import { getFileFromFileData, getFileAdapter, SignedFileUpload } from '@unchainedshop/core-files';
+import { Modules } from '../modules.js';
+
+export async function createSignedURLService(
+  this: Modules,
+  { directoryName, fileName, meta }: { directoryName: string; fileName: string; meta?: any },
+) {
+  const fileUploadAdapter = getFileAdapter();
+  const preparedFileData = await fileUploadAdapter.createSignedURL(directoryName, fileName, {
+    modules: this,
+  });
+  const fileData = getFileFromFileData(preparedFileData, meta);
+  const fileId = await this.files.create(fileData);
+  const file = await this.files.findFile({ fileId });
+
+  return {
+    ...file,
+    putURL: preparedFileData.putURL as string,
+  } as SignedFileUpload;
+}

package/src/services/deleteUser.ts

@@ -0,0 +1,33 @@
+import { Modules } from '../modules.js';
+
+export async function deleteUserService(this: Modules, { userId }: { userId: string }) {
+  const user = await this.users.markDeleted(userId);
+
+  if (!user) return null;
+
+  await this.bookmarks.deleteByUserId(userId);
+  await this.quotations.deleteRequestedUserQuotations(userId);
+  await this.enrollments.deleteInactiveUserEnrollments(userId);
+
+  const carts = await this.orders.findOrders({ userId, status: null });
+
+  for (const userCart of carts) {
+    await this.orders.positions.deleteOrderPositions(userCart?._id);
+    await this.orders.payments.deleteOrderPayments(userCart?._id);
+    await this.orders.deliveries.deleteOrderDeliveries(userCart?._id);
+    await this.orders.discounts.deleteOrderDiscounts(userCart?._id);
+    await this.orders.delete(userCart?._id);
+  }
+
+  const ordersCount = await this.orders.count({ userId, includeCarts: true });
+  const quotationsCount = await this.quotations.count({ userId });
+  const reviewsCount = await this.products.reviews.count({ authorId: userId });
+  const enrollmentsCount = await this.enrollments.count({ userId });
+  const tokens = await this.warehousing.findTokensForUser({ userId });
+
+  if (!ordersCount && !reviewsCount && !enrollmentsCount && !quotationsCount && !tokens?.length) {
+    await this.users.deletePermanently({ userId });
+  }
+
+  return user;
+}

package/src/services/discountedEntities.ts

@@ -0,0 +1,81 @@
+import { Order, OrderDiscount } from '@unchainedshop/core-orders';
+import {
+  DeliveryPricingSheet,
+  OrderPricingDiscount,
+  OrderPricingSheet,
+  PaymentPricingSheet,
+  ProductPricingSheet,
+} from '../directors/index.js';
+import { Modules } from '../modules.js';
+
+export async function discountedEntitiesService(
+  this: Modules,
+  order: Order,
+  orderDiscount: OrderDiscount,
+): Promise<Array<OrderPricingDiscount>> {
+  // Delivery discounts
+  const orderDelivery = await this.orders.deliveries.findDelivery({
+    orderDeliveryId: order.deliveryId,
+  });
+
+  const deliveryPricingSheet = DeliveryPricingSheet({
+    calculation: orderDelivery.calculation || [],
+    currency: order.currency,
+  });
+  const orderDeliveryDiscounts = deliveryPricingSheet
+    .discountPrices(orderDiscount._id)
+    .map((discount) => ({
+      delivery: orderDelivery,
+      ...discount,
+    }));
+
+  // Payment discounts
+  const orderPayment = await this.orders.payments.findOrderPayment({
+    orderPaymentId: order.paymentId,
+  });
+  const paymentPricingSheet = PaymentPricingSheet({
+    calculation: orderPayment.calculation || [],
+    currency: order.currency,
+  });
+  const orderPaymentDiscounts = paymentPricingSheet
+    .discountPrices(orderDiscount._id)
+    .map((discount) => ({
+      payment: orderPayment,
+      ...discount,
+    }));
+
+  // Position discounts
+  const orderPositions = await this.orders.positions.findOrderPositions({
+    orderId: order._id,
+  });
+  const orderPositionDiscounts = orderPositions.flatMap((orderPosition) =>
+    ProductPricingSheet({
+      calculation: orderPosition.calculation,
+      currency: order.currency,
+      quantity: orderPosition.quantity,
+    })
+      .discountPrices(orderDiscount._id)
+      .map((discount) => ({
+        item: orderPosition,
+        ...discount,
+      })),
+  );
+
+  // order discounts
+  const orderDiscounts = OrderPricingSheet({
+    calculation: order.calculation || [],
+    currency: order.currency,
+  })
+    .discountPrices(orderDiscount._id)
+    .map((discount) => ({ order, ...discount }));
+
+  // All discounts
+  const discounted = [
+    ...orderPaymentDiscounts,
+    ...orderDeliveryDiscounts,
+    ...orderPositionDiscounts,
+    ...orderDiscounts,
+  ].filter(Boolean);
+
+  return discounted;
+}

package/src/services/ercMetadata.ts

@@ -0,0 +1,33 @@
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+import { WarehousingDirector } from '../directors/WarehousingDirector.js';
+import { Modules } from '../modules.js';
+
+export async function ercMetadataService(
+  this: Modules,
+  { productId, chainTokenId, locale }: { productId: string; chainTokenId: string; locale: Intl.Locale },
+) {
+  const product = await this.products.findProduct({
+    productId,
+  });
+
+  const [token] = await this.warehousing.findTokens({
+    chainTokenId,
+    contractAddress: product?.tokenization?.contractAddress,
+  });
+
+  const virtualProviders = await this.warehousing.findProviders({
+    type: WarehousingProviderType.VIRTUAL,
+  });
+
+  return await WarehousingDirector.tokenMetadata(
+    virtualProviders,
+    {
+      product,
+      token,
+      locale,
+      quantity: token?.quantity || 1,
+      referenceDate: new Date(),
+    },
+    { modules: this },
+  );
+}

package/src/services/fullfillQuotation.ts

@@ -0,0 +1,14 @@
+import { Quotation, QuotationStatus } from '@unchainedshop/core-quotations';
+import { Modules } from '../modules.js';
+import { processQuotationService } from './processQuotation.js';
+
+export async function fullfillQuotationService(this: Modules, quotation: Quotation, info) {
+  if (quotation.status === QuotationStatus.FULLFILLED) return quotation;
+
+  const updatedQuotation = await this.quotations.updateStatus(quotation._id, {
+    status: QuotationStatus.FULLFILLED,
+    info: JSON.stringify(info),
+  });
+
+  return processQuotationService.bind(this)(updatedQuotation, {});
+}

package/src/services/index.ts

@@ -0,0 +1,154 @@
+import { migrateUserDataService } from './migrateUserData.js';
+import { updateUserAvatarAfterUploadService } from './updateUserAvatarAfterUpload.js';
+import { linkFileService } from './linkFileService.js';
+import { createSignedURLService } from './createSignedURL.js';
+import { uploadFileFromURLService } from './uploadFileFromURL.js';
+import { uploadFileFromStreamService } from './uploadFileFromStream.js';
+import { removeFilesService } from './removeFiles.js';
+import { createDownloadStreamService } from './createDownloadStream.js';
+import { migrateBookmarksService } from './migrateBookmarks.js';
+import { migrateOrderCartsService } from './migrateOrderCart.js';
+import { nextUserCartService } from './nextUserCart.js';
+import { removeProductService } from './removeProduct.js';
+import { initCartProvidersService } from './initCartProviders.js';
+import { updateCalculationService } from './updateCalculation.js';
+import { supportedDeliveryProvidersService } from './supportedDeliveryProviders.js';
+import { deleteUserService } from './deleteUser.js';
+import { supportedPaymentProvidersService } from './supportedPaymentProviders.js';
+import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.js';
+import { createEnrollmentFromCheckoutService } from './createEnrollmentFromCheckout.js';
+import { searchAssortmentsService } from './searchAssortments.js';
+import { searchProductsService } from './searchProducts.js';
+import { calculateDiscountTotalService } from './calculateDiscountTotal.js';
+import { registerPaymentCredentialsService } from './registerPaymentCredentials.js';
+import { processOrderService } from './processOrder.js';
+import { checkoutOrderService } from './checkoutOrder.js';
+import { confirmOrderService } from './confirmOrder.js';
+import { rejectOrderService } from './rejectOrder.js';
+import { discountedEntitiesService } from './discountedEntities.js';
+import { createManualOrderDiscountService } from './createManualOrderDiscount.js';
+import { initializeEnrollmentService } from './initializeEnrollment.js';
+import { activateEnrollmentService } from './activateEnrollment.js';
+import { terminateEnrollmentService } from './terminateEnrollment.js';
+import { invalidateFilterCacheService } from './invalidateFilterCache.js';
+import { fullfillQuotationService } from './fullfillQuotation.js';
+import { processQuotationService } from './processQuotation.js';
+import { proposeQuotationService } from './proposeQuotation.js';
+import { rejectQuotationService } from './rejectQuotation.js';
+import { verifyQuotationService } from './verifyQuotation.js';
+import { loadFiltersService } from './loadFilters.js';
+import { loadFilterOptionsService } from './loadFilterOptions.js';
+import { ercMetadataService } from './ercMetadata.js';
+import { Modules } from '../modules.js';
+
+// TODO: Auto-Inject Unchained API as last parameter
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy
+
+function bindMethodsToModules(modules: Modules) {
+  return {
+    get(target, prop, receiver) {
+      const value = target[prop];
+      if (value instanceof Function) {
+        return value.bind(modules);
+      } else if (value instanceof Object) {
+        return new Proxy(value, bindMethodsToModules(modules));
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+  };
+}
+
+export interface ServiceInterface {
+  (this: Modules, ...args: any[]): any;
+}
+
+export type Bound<T extends ServiceInterface> = OmitThisParameter<T>;
+
+export default function initServices(
+  modules: Modules,
+  customServices: Record<string, ServiceInterface> = {},
+) {
+  const services = {
+    bookmarks: {
+      migrateBookmarks: migrateBookmarksService as Bound<typeof migrateBookmarksService>,
+    },
+    files: {
+      linkFile: linkFileService as Bound<typeof linkFileService>,
+      createSignedURL: createSignedURLService as Bound<typeof createSignedURLService>,
+      uploadFileFromURL: uploadFileFromURLService as Bound<typeof uploadFileFromURLService>,
+      uploadFileFromStream: uploadFileFromStreamService as Bound<typeof uploadFileFromStreamService>,
+      removeFiles: removeFilesService as Bound<typeof removeFilesService>,
+      createDownloadStream: createDownloadStreamService as Bound<typeof createDownloadStreamService>,
+    },
+    orders: {
+      registerPaymentCredentials: registerPaymentCredentialsService as Bound<
+        typeof registerPaymentCredentialsService
+      >,
+      calculateDiscountTotal: calculateDiscountTotalService as Bound<
+        typeof calculateDiscountTotalService
+      >,
+      migrateOrderCarts: migrateOrderCartsService as Bound<typeof migrateOrderCartsService>,
+      nextUserCart: nextUserCartService as Bound<typeof nextUserCartService>,
+      initCartProviders: initCartProvidersService as Bound<typeof initCartProvidersService>,
+      updateCalculation: updateCalculationService as Bound<typeof updateCalculationService>,
+      supportedDeliveryProviders: supportedDeliveryProvidersService as Bound<
+        typeof supportedDeliveryProvidersService
+      >,
+      supportedPaymentProviders: supportedPaymentProvidersService as Bound<
+        typeof supportedPaymentProvidersService
+      >,
+      supportedWarehousingProviders: supportedWarehousingProvidersService as Bound<
+        typeof supportedWarehousingProvidersService
+      >,
+      processOrder: processOrderService as Bound<typeof processOrderService>,
+      checkoutOrder: checkoutOrderService as Bound<typeof checkoutOrderService>,
+      confirmOrder: confirmOrderService as Bound<typeof confirmOrderService>,
+      rejectOrder: rejectOrderService as Bound<typeof rejectOrderService>,
+      discountedEntities: discountedEntitiesService as Bound<typeof discountedEntitiesService>,
+      createManualOrderDiscount: createManualOrderDiscountService as Bound<
+        typeof createManualOrderDiscountService
+      >,
+    },
+    products: {
+      removeProduct: removeProductService as Bound<typeof removeProductService>,
+    },
+    users: {
+      migrateUserData: migrateUserDataService as Bound<typeof migrateUserDataService>,
+      updateUserAvatarAfterUpload: updateUserAvatarAfterUploadService as Bound<
+        typeof updateUserAvatarAfterUploadService
+      >,
+      deleteUser: deleteUserService as Bound<typeof deleteUserService>,
+    },
+    enrollments: {
+      createEnrollmentFromCheckout: createEnrollmentFromCheckoutService as Bound<
+        typeof createEnrollmentFromCheckoutService
+      >,
+      processEnrollment: processOrderService as Bound<typeof processOrderService>,
+      initializeEnrollment: initializeEnrollmentService as Bound<typeof initializeEnrollmentService>,
+      activateEnrollment: activateEnrollmentService as Bound<typeof activateEnrollmentService>,
+      terminateEnrollment: terminateEnrollmentService as Bound<typeof terminateEnrollmentService>,
+    },
+    quotations: {
+      fullfillQuotation: fullfillQuotationService as Bound<typeof fullfillQuotationService>,
+      processQuotation: processQuotationService as Bound<typeof processQuotationService>,
+      proposeQuotation: proposeQuotationService as Bound<typeof proposeQuotationService>,
+      rejectQuotation: rejectQuotationService as Bound<typeof rejectQuotationService>,
+      verifyQuotation: verifyQuotationService as Bound<typeof verifyQuotationService>,
+    },
+    filters: {
+      searchAssortments: searchAssortmentsService as Bound<typeof searchAssortmentsService>,
+      searchProducts: searchProductsService as Bound<typeof searchProductsService>,
+      invalidateFilterCache: invalidateFilterCacheService as Bound<typeof invalidateFilterCacheService>,
+      loadFilters: loadFiltersService as Bound<typeof loadFiltersService>,
+      loadFilterOptions: loadFilterOptionsService as Bound<typeof loadFilterOptionsService>,
+    },
+    warehousing: {
+      ercMetadata: ercMetadataService as Bound<typeof ercMetadataService>,
+    },
+  };
+
+  // This Proxy Binds all services to the Modules Object
+  return new Proxy<typeof services>({ ...services, ...customServices }, bindMethodsToModules(modules));
+}
+
+export type Services = ReturnType<typeof initServices>;