@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc2

package/src/directors/WarehousingDirector.ts

@@ -0,0 +1,235 @@
+import { IBaseDirector, BaseDirector } from '@unchainedshop/utils';
+import { WarehousingProvider, TokenSurrogate } from '@unchainedshop/core-warehousing';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:core');
+
+import {
+  DeliveryDirector,
+  IWarehousingAdapter,
+  WarehousingContext,
+  WarehousingError,
+} from '../directors/index.js';
+
+export type EstimatedDispatch = {
+  shipping?: Date;
+  earliestDelivery?: Date;
+};
+
+export type EstimatedStock = { quantity: number } | null;
+
+export interface WarehousingInterface {
+  _id: string;
+  label: string;
+  version: string;
+}
+
+export type IWarehousingDirector = IBaseDirector<IWarehousingAdapter> & {
+  tokenMetadata: (
+    virtualProviders: WarehousingProvider[],
+    warehousingContext: WarehousingContext & { token: { chainTokenId: string } },
+    unchainedAPI,
+  ) => Promise<any>;
+
+  isInvalidateable: (
+    virtualProviders: WarehousingProvider[],
+    warehousingContext: WarehousingContext & { token: { chainTokenId: string } },
+    unchainedAPI,
+  ) => Promise<any>;
+
+  actions: (
+    warehousingProvider: WarehousingProvider,
+    warehousingContext: WarehousingContext,
+    unchainedAPI,
+  ) => Promise<{
+    configurationError: () => WarehousingError;
+    isActive: () => boolean;
+    estimatedStock: () => Promise<EstimatedStock>;
+    estimatedDispatch: () => Promise<EstimatedDispatch>;
+    tokenize: () => Promise<Array<TokenSurrogate>>;
+    tokenMetadata: (chainTokenId: string) => Promise<any>;
+    isInvalidateable: (chainTokenId: string) => Promise<boolean>;
+  }>;
+};
+
+const getReferenceDate = (context: WarehousingContext) => {
+  return context && context.referenceDate ? context.referenceDate : new Date();
+};
+
+const baseDirector = BaseDirector<IWarehousingAdapter>('WarehousingDirector', {
+  adapterSortKey: 'orderIndex',
+});
+
+export const WarehousingDirector: IWarehousingDirector = {
+  ...baseDirector,
+
+  actions: async (warehousingProvider, warehousingContext, unchainedAPI) => {
+    const Adapter = baseDirector.getAdapter(warehousingProvider.adapterKey);
+
+    if (!Adapter) {
+      throw new Error(`Warehousing Plugin ${warehousingProvider.adapterKey} not available`);
+    }
+    const context = {
+      warehousingProviderId: warehousingProvider._id,
+      ...warehousingContext,
+      ...unchainedAPI,
+    };
+    const adapter = Adapter.actions(warehousingProvider.configuration, context);
+
+    const throughputTime = async (referenceDate) => {
+      try {
+        const { quantity } = context;
+        const stock = await adapter.stock(referenceDate);
+        const notInStockQuantity = Math.max(quantity - stock, 0);
+        const productionTime = await adapter.productionTime(notInStockQuantity);
+        const commissioningTime = await adapter.commissioningTime(quantity);
+        return Math.max(commissioningTime + productionTime, 0);
+      } catch (error) {
+        logger.error(error);
+        return NaN;
+      }
+    };
+
+    return {
+      configurationError: () => {
+        try {
+          const error = adapter.configurationError();
+          return error;
+        } catch {
+          return WarehousingError.ADAPTER_NOT_FOUND;
+        }
+      },
+
+      isActive: () => {
+        try {
+          return adapter.isActive();
+        } catch (error) {
+          logger.error(error);
+          return false;
+        }
+      },
+
+      estimatedStock: async () => {
+        try {
+          const referenceDate = getReferenceDate(context);
+          const quantity = await adapter.stock(referenceDate);
+          return {
+            quantity,
+          };
+        } catch (error) {
+          logger.error(error);
+          return null;
+        }
+      },
+
+      estimatedDispatch: async () => {
+        try {
+          const { deliveryProvider } = context;
+          const referenceDate = getReferenceDate(context);
+
+          const warehousingThroughputTime = await throughputTime(referenceDate);
+          if (!Number.isFinite(warehousingThroughputTime)) {
+            return {
+              shipping: null,
+              earliestDelivery: null,
+            };
+          }
+
+          // Calculate shipping date
+          const shippingTimestamp = referenceDate.getTime() + warehousingThroughputTime;
+          const shipping = new Date(shippingTimestamp);
+
+          // Calculate earliest delivery date
+          const actions = await DeliveryDirector.actions(deliveryProvider, context, unchainedAPI);
+          const deliveryThroughputTime =
+            await actions.estimatedDeliveryThroughput(warehousingThroughputTime);
+          const earliestDelivery = Number.isFinite(deliveryThroughputTime)
+            ? new Date(shippingTimestamp + deliveryThroughputTime)
+            : null;
+
+          return {
+            shipping,
+            earliestDelivery,
+          };
+        } catch (error) {
+          logger.error(error);
+          return {};
+        }
+      },
+
+      tokenMetadata: async (chainTokenId) => {
+        try {
+          const referenceDate = getReferenceDate(context);
+          const tokenMetadata = await adapter.tokenMetadata(chainTokenId, referenceDate);
+          return tokenMetadata;
+        } catch (error) {
+          logger.error(error);
+          return {};
+        }
+      },
+
+      isInvalidateable: async (chainTokenId) => {
+        try {
+          const referenceDate = getReferenceDate(context);
+          const isInvalidateable = await adapter.isInvalidateable(chainTokenId, referenceDate);
+          return isInvalidateable;
+        } catch (error) {
+          logger.error(error);
+          return false;
+        }
+      },
+
+      tokenize: async () => {
+        try {
+          const tokens = await adapter.tokenize();
+          const { order, orderPosition } = warehousingContext;
+          return tokens.map((token) => {
+            return {
+              ...token,
+              userId: order.userId,
+              productId: orderPosition.productId,
+              orderPositionId: orderPosition._id,
+            };
+          });
+        } catch (error) {
+          logger.error(error);
+          return [];
+        }
+      },
+    };
+  },
+
+  async tokenMetadata(virtualProviders, warehousingContext, unchainedAPI) {
+    return virtualProviders.reduce(async (lastPromise, provider) => {
+      const last = await lastPromise;
+      if (last) return last;
+      const currentDirector = await WarehousingDirector.actions(
+        provider,
+        warehousingContext,
+        unchainedAPI,
+      );
+      const isActive = await currentDirector.isActive();
+      if (isActive) {
+        return currentDirector.tokenMetadata(warehousingContext.token.chainTokenId);
+      }
+      return null;
+    }, Promise.resolve(null));
+  },
+
+  async isInvalidateable(virtualProviders, warehousingContext, unchainedAPI) {
+    return virtualProviders.reduce(async (lastPromise, provider) => {
+      const last = await lastPromise;
+      if (last) return last;
+      const currentDirector = await WarehousingDirector.actions(
+        provider,
+        warehousingContext,
+        unchainedAPI,
+      );
+      const isActive = await currentDirector.isActive();
+      if (isActive) {
+        return currentDirector.isInvalidateable(warehousingContext.token.chainTokenId);
+      }
+      return null;
+    }, Promise.resolve(null));
+  },
+};

package/src/directors/WorkerAdapter.ts

@@ -0,0 +1,30 @@
+import { log, LogLevel } from '@unchainedshop/logger';
+import { IBaseAdapter } from '@unchainedshop/utils';
+import { WorkResult } from '@unchainedshop/core-worker';
+import { Modules } from '../modules.js';
+import { Services } from '../services/index.js';
+import { BulkImporter } from '../core-index.js';
+
+export type IWorkerAdapter<Input, Output> = IBaseAdapter & {
+  type: string;
+  external: boolean;
+  maxParallelAllocations?: number;
+
+  doWork: (
+    input: Input,
+    unchainedAPI: { modules: Modules; services: Services; bulkImporter: BulkImporter },
+    workId: string,
+  ) => Promise<WorkResult<Output>>;
+};
+
+export const WorkerAdapter: Omit<IWorkerAdapter<any, void>, 'key' | 'label' | 'type' | 'version'> = {
+  external: false,
+
+  async doWork() {
+    return { success: false, result: null };
+  },
+
+  log(message: string, { level = LogLevel.Debug, ...options } = {}) {
+    return log(message, { level, ...options });
+  },
+};

package/src/directors/WorkerDirector.ts

@@ -0,0 +1,154 @@
+import { Work, WorkData, WorkResult } from '@unchainedshop/core-worker';
+import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
+import { ScheduleData } from '@breejs/later';
+import { IWorkerAdapter } from './WorkerAdapter.js';
+import { Modules } from '../modules.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:core');
+
+export type WorkScheduleConfiguration = Pick<
+  WorkData,
+  'timeout' | 'retries' | 'priority' | 'worker' | 'scheduleId'
+> & {
+  type: string;
+  input?: (workData: Omit<WorkData, 'input'>) => Promise<Record<string, any> | null>;
+  schedule: ScheduleData;
+  scheduleId?: string;
+};
+
+export type IWorkerDirector = IBaseDirector<IWorkerAdapter<any, any>> & {
+  getActivePluginTypes: (options?: { external?: boolean }) => Array<string>;
+  getAdapterByType: (type: string) => IWorkerAdapter<any, any>;
+  disableAutoscheduling: (scheduleId: string) => void;
+  configureAutoscheduling: (workScheduleConfiguration: WorkScheduleConfiguration) => void;
+  getAutoSchedules: () => Array<[string, WorkScheduleConfiguration]>;
+  doWork: (work: Work, unchainedAPI) => Promise<WorkResult>;
+  processNextWork: (unchainedAPI: { modules: Modules }, workerId?: string) => Promise<Work>;
+};
+
+const AutoScheduleMap = new Map<string, WorkScheduleConfiguration>();
+
+const baseDirector = BaseDirector<IWorkerAdapter<any, any>>('WorkerDirector', {
+  adapterKeyField: 'key',
+});
+
+export const WorkerDirector: IWorkerDirector = {
+  ...baseDirector,
+
+  getActivePluginTypes: ({ external } = { external: null }) => {
+    return WorkerDirector.getAdapters()
+      .filter((adapter) => {
+        if (external === null || external === undefined) return true;
+        return Boolean(adapter.external) === external;
+      })
+      .map((adapter) => adapter.type);
+  },
+
+  registerAdapter: (Adapter) => {
+    if (WorkerDirector.getAdapterByType(Adapter.type))
+      throw new Error(
+        `WorkerDirector: There is already a adapter registered with type: ${Adapter.type}`,
+      );
+
+    baseDirector.registerAdapter(Adapter);
+  },
+
+  disableAutoscheduling: (type) => {
+    const config = AutoScheduleMap.get(type);
+    AutoScheduleMap.set(type, { ...config, schedule: null });
+  },
+
+  unregisterAdapter: (key) => {
+    const adapter = WorkerDirector.getAdapter(key);
+    const result = baseDirector.unregisterAdapter(key);
+    if (adapter) {
+      AutoScheduleMap.forEach((workItemConfiguration, scheduleId) => {
+        if (workItemConfiguration.type === adapter.type) {
+          AutoScheduleMap.delete(scheduleId);
+        }
+      });
+    }
+    return result;
+  },
+
+  configureAutoscheduling: (workItemConfiguration) => {
+    const adapter = WorkerDirector.getAdapterByType(workItemConfiguration.type);
+    AutoScheduleMap.set(
+      workItemConfiguration.scheduleId || workItemConfiguration.type,
+      workItemConfiguration,
+    );
+    logger.info(
+      `WorkerDirector -> Configured ${adapter.type} ${adapter.key}@${adapter.version} (${adapter.label}) for Autorun at ${JSON.stringify(workItemConfiguration.schedule?.schedules)}`,
+    );
+  },
+
+  getAutoSchedules: () => Array.from(AutoScheduleMap),
+
+  getAdapterByType: (type: string) => {
+    const adapters = WorkerDirector.getAdapters({
+      adapterFilter: (Adapter) => {
+        return type === Adapter.type;
+      },
+    });
+    return adapters?.[0];
+  },
+
+  doWork: async ({ type, input, _id: workId }, unchainedAPI) => {
+    const adapter = WorkerDirector.getAdapterByType(type);
+
+    if (!adapter) {
+      logger.info(`WorkerDirector: No registered adapter for type: ${type}`);
+    }
+
+    try {
+      const output = await adapter.doWork(input, unchainedAPI, workId);
+      return output;
+    } catch (error) {
+      // DO not use this as flow control. The adapter should catch expected errors and return status: FAILED
+      logger.debug('DO not use this as flow control.');
+      logger.info(`WorkerDirector -> Error doing work ${type}: ${error.message}`);
+
+      const errorOutput = { error, success: false };
+      return errorOutput;
+    }
+  },
+
+  processNextWork: async (unchainedAPI: { modules: Modules }, workerId?: string): Promise<Work> => {
+    const adapters = WorkerDirector.getAdapters();
+
+    const allocationMap = await unchainedAPI.modules.worker.allocationMap();
+
+    const types = adapters
+      .filter((adapter) => {
+        // Filter out the external
+        if (adapter.external) return false;
+        if (
+          adapter.maxParallelAllocations &&
+          adapter.maxParallelAllocations <= allocationMap[adapter.type]
+        )
+          return false;
+        return true;
+      })
+      .map((adapter) => adapter.type);
+
+    const worker = workerId ?? unchainedAPI.modules.worker.workerId;
+    const work = await unchainedAPI.modules.worker.allocateWork({
+      types,
+      worker,
+    });
+
+    if (work) {
+      const output = await WorkerDirector.doWork(work, unchainedAPI);
+
+      return await unchainedAPI.modules.worker.finishWork(work._id, {
+        ...output,
+        finished: work.finished || new Date(),
+        started: work.started,
+        worker,
+      });
+    }
+
+    return null;
+  },
+};

package/src/directors/index.ts

@@ -0,0 +1,49 @@
+export * from './BasePricingAdapter.js';
+export * from './BasePricingDirector.js';
+export * from './BasePricingSheet.js';
+
+export * from './BaseDiscountAdapter.js';
+export * from './BaseDiscountDirector.js';
+
+export * from './DeliveryAdapter.js';
+export * from './DeliveryDirector.js';
+export * from './DeliveryPricingAdapter.js';
+export * from './DeliveryPricingDirector.js';
+export * from './DeliveryPricingSheet.js';
+
+export * from './PaymentAdapter.js';
+export * from './PaymentDirector.js';
+export * from './PaymentPricingAdapter.js';
+export * from './PaymentPricingDirector.js';
+export * from './PaymentPricingSheet.js';
+
+export * from './EnrollmentAdapter.js';
+export * from './EnrollmentDirector.js';
+
+export * from './FilterAdapter.js';
+export * from './FilterDirector.js';
+
+export * from './ProductDiscountAdapter.js';
+export * from './ProductDiscountDirector.js';
+export * from './ProductDiscountConfiguration.js';
+export * from './ProductPricingAdapter.js';
+export * from './ProductPricingDirector.js';
+export * from './ProductPricingSheet.js';
+
+export * from './OrderDiscountConfiguration.js';
+export * from './OrderDiscountAdapter.js';
+export * from './OrderDiscountDirector.js';
+export * from './OrderPricingAdapter.js';
+export * from './OrderPricingDirector.js';
+export * from './OrderPricingSheet.js';
+
+export * from './WarehousingDirector.js';
+export * from './WarehousingAdapter.js';
+
+export * from './WorkerAdapter.js';
+export * from './WorkerDirector.js';
+
+export * from './QuotationAdapter.js';
+export * from './QuotationDirector.js';
+
+export * from './MessagingDirector.js';

package/src/directors/periodForReferenceDate.test.ts

@@ -0,0 +1,23 @@
+import { periodForReferenceDate } from './EnrollmentAdapter.js';
+
+describe('periodForReferenceDate', () => {
+  it('Should return 1 week interval from When passed a given date', () => {
+    expect(periodForReferenceDate(new Date('2022-12-03T17:00:00.000Z'))).toEqual({
+      start: new Date('2022-12-03T17:00:00.000Z'),
+      end: new Date('2022-12-10T17:00:00.000Z'),
+    });
+  });
+  it('Should return 2 week interval from When passed 2 as interval', () => {
+    expect(periodForReferenceDate(new Date('2022-12-03T17:00:00.000Z'), 2)).toEqual({
+      start: new Date('2022-12-03T17:00:00.000Z'),
+      end: new Date('2022-12-17T17:00:00.000Z'),
+    });
+  });
+
+  it('Should return 2 HOURS when interval is set to HOURS', () => {
+    expect(periodForReferenceDate(new Date('2022-12-03T17:00:00.000Z'), 2, 'HOURS')).toEqual({
+      start: new Date('2022-12-03T17:00:00.000Z'),
+      end: new Date('2022-12-03T19:00:00.000Z'),
+    });
+  });
+});

package/src/modules.ts

@@ -0,0 +1,215 @@
+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 { configureMessagingModule, MessagingModule } from '@unchainedshop/core-messaging';
+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;
+  messaging: MessagingModule;
+  orders: OrdersModule;
+  payment: PaymentModule;
+  products: ProductsModule;
+  quotations: QuotationsModule;
+  users: UsersModule;
+  warehousing: WarehousingModule;
+  worker: WorkerModule;
+}
+
+export interface ModuleOptions {
+  assortments?: AssortmentsSettingsOptions;
+  products?: ProductsSettingsOptions;
+  delivery?: DeliverySettingsOptions;
+  filters?: FiltersSettingsOptions;
+  enrollments?: EnrollmentsSettingsOptions;
+  orders?: OrdersSettingsOptions;
+  quotations?: QuotationsSettingsOptions;
+  files?: FilesSettingsOptions;
+  payment?: PaymentSettingsOptions;
+  worker?: WorkerSettingsOptions;
+  users?: UserSettingsOptions;
+}
+
+const initModules = async (
+  {
+    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 messaging = await configureMessagingModule({
+    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,
+  });
+  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,
+    messaging,
+    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;
+};
+
+export default initModules;