@unchainedshop/core 4.3.5 → 4.4.0

package/src/directors/FailedRescheduler.ts

@@ -1,73 +0,0 @@
-import { defaultLogger } from '@unchainedshop/logger';
-import { subscribe } from '@unchainedshop/events';
-import { Work, WorkData, WorkerEventTypes } from '@unchainedshop/core-worker';
-
-export interface FailedReschedulerParams {
-  transformRetry?: (workData: WorkData, lastFailedWork: Work) => Promise<WorkData | null>;
-}
-
-export interface IScheduler<P> {
-  key: string;
-  label: string;
-  version: string;
-
-  actions: (
-    params: P,
-    unchainedAPI,
-  ) => {
-    start: () => void;
-    stop: () => void;
-  };
-}
-
-export const FailedRescheduler: IScheduler<FailedReschedulerParams> = {
-  key: 'shop.unchained.scheduler.failed',
-  label: 'Reschedule failed works',
-  version: '1.0.0',
-
-  actions: ({ transformRetry }, unchainedAPI) => {
-    const handleFinishedWork = async ({ payload: work }: { payload: Work }) => {
-      if (!work.success && work.retries > 0) {
-        const now = new Date();
-        const workDelayMs = work.scheduled.getTime() - work.created.getTime();
-
-        // In short: Double the delay of the old work or delay for 5 seconds
-        const scheduled =
-          workDelayMs > 1000
-            ? new Date(now.getTime() + workDelayMs * 2)
-            : new Date(now.setSeconds(now.getSeconds() + 5));
-
-        defaultLogger.error(
-          `${FailedRescheduler.key} -> Reschedule failed work ${work._id} ${
-            work.type
-          } for ${scheduled.toISOString()} (in ${Math.round(workDelayMs / 1000)}). Remaining retries: ${
-            work.retries
-          }`,
-        );
-
-        const newWorkData = {
-          type: work.type,
-          priority: work.priority,
-          originalWorkId: work.originalWorkId || work._id,
-          retries: work.retries - 1,
-          timeout: work.timeout,
-          input: work.input,
-          scheduled,
-        };
-        await unchainedAPI.modules.worker.addWork(
-          transformRetry ? await transformRetry(newWorkData, work) : newWorkData,
-        );
-      }
-    };
-
-    return {
-      start() {
-        subscribe<Work>(WorkerEventTypes.FINISHED, handleFinishedWork);
-      },
-
-      stop() {
-        /* */
-      },
-    };
-  },
-};

package/src/directors/FilterAdapter.ts

@@ -1,106 +0,0 @@
-import { Assortment } from '@unchainedshop/core-assortments';
-import { mongodb } from '@unchainedshop/mongodb';
-import { BaseAdapter, IBaseAdapter } from '@unchainedshop/utils';
-import { Product } from '@unchainedshop/core-products';
-import { Filter, SearchConfiguration, SearchQuery } from '@unchainedshop/core-filters';
-import { Modules } from '../modules.js';
-
-export interface FilterInputText {
-  locale: string;
-  title: string;
-  subtitle?: string;
-}
-
-export interface FilterContext {
-  filter?: Filter;
-  searchQuery: SearchQuery;
-}
-
-export interface SearchAssortmentsOptions extends SearchConfiguration {
-  assortmentSelector: mongodb.Filter<Assortment>;
-}
-
-export interface SearchProductsOptions extends SearchConfiguration {
-  productSelector: mongodb.Filter<Product>;
-}
-
-export interface TransformOptions {
-  key?: string;
-  value?: any;
-  userId?: string;
-  locale?: Intl.Locale;
-}
-
-export interface FilterAdapterActions {
-  aggregateProductIds: (params: { productIds: string[] }) => string[];
-
-  searchAssortments: (
-    params: {
-      assortmentIds?: string[];
-    },
-    options: SearchAssortmentsOptions,
-  ) => Promise<string[] | undefined>;
-
-  searchProducts: (
-    params: {
-      productIds?: string[];
-    },
-    options: SearchProductsOptions,
-  ) => Promise<string[] | undefined>;
-
-  transformFilterSelector: (
-    query: mongodb.Filter<Filter>,
-    options?: TransformOptions,
-  ) => Promise<mongodb.Filter<Filter>>;
-  transformProductSelector: (
-    query: mongodb.Filter<Product>,
-    options?: TransformOptions,
-  ) => Promise<mongodb.Filter<Product>>;
-  transformSortStage: (
-    sort: mongodb.FindOptions['sort'],
-    options?: TransformOptions,
-  ) => Promise<mongodb.FindOptions['sort']>;
-}
-
-export type IFilterAdapter = IBaseAdapter & {
-  orderIndex: number;
-
-  actions: (params: FilterContext & { modules: Modules }) => FilterAdapterActions;
-};
-
-export const FilterAdapter: Omit<IFilterAdapter, 'key' | 'label' | 'version'> = {
-  ...BaseAdapter,
-  orderIndex: 0,
-
-  actions: () => {
-    return {
-      // This function is called to check if a filter actually matches a certain productId
-      aggregateProductIds: ({ productIds }) => {
-        return productIds;
-      },
-
-      searchProducts: async ({ productIds }) => {
-        return productIds;
-      },
-
-      searchAssortments: async ({ assortmentIds }) => {
-        return assortmentIds;
-      },
-
-      transformSortStage: async (lastStage) => {
-        return lastStage;
-      },
-
-      // return a selector that is applied to Products.find to find relevant products
-      // if no key is provided, it expects either null for all products or a list of products that are relevant
-      transformProductSelector: async (lastSelector) => {
-        return lastSelector;
-      },
-
-      // return a selector that is applied to Filters.find to find relevant filters
-      transformFilterSelector: async (lastSelector) => {
-        return lastSelector;
-      },
-    };
-  },
-};

package/src/directors/FilterDirector.ts

@@ -1,315 +0,0 @@
-import { mongodb } from '@unchainedshop/mongodb';
-import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
-import { FilterAdapterActions, FilterContext, IFilterAdapter } from './FilterAdapter.js';
-import {
-  Filter,
-  filtersSettings,
-  FilterType,
-  SearchConfiguration,
-  SearchFilterQuery,
-  SearchQuery,
-} from '@unchainedshop/core-filters';
-import { Product } from '@unchainedshop/core-products';
-import { Modules } from '../modules.js';
-
-export const parseQueryArray = (query?: SearchFilterQuery): Record<string, string[]> =>
-  (query || []).reduce(
-    (accumulator, { key, value }) => ({
-      ...accumulator,
-      [key]: accumulator[key] ? accumulator[key].concat(value) : [value],
-    }),
-    {},
-  );
-
-export type IFilterDirector = IBaseDirector<IFilterAdapter> & {
-  actions: (
-    filterContext: FilterContext,
-    unchainedAPI: { modules: Modules },
-  ) => Promise<FilterAdapterActions>;
-  invalidateProductIdCache: (filter: Filter, unchainedAPI: { modules: Modules }) => Promise<void>;
-  findProductIds: (
-    filter: Filter,
-    { value }: { value?: boolean | string },
-    unchainedAPI: { modules: Modules },
-  ) => Promise<string[]>;
-  buildProductIdMap: (
-    filter: Filter,
-    unchainedAPI: { modules: Modules },
-  ) => Promise<[string[], Record<string, string[]>]>;
-  filterProductIds: (
-    filter: Filter,
-    { values, forceLiveCollection }: { values: string[]; forceLiveCollection?: boolean },
-    unchainedAPI: { modules: Modules },
-  ) => Promise<string[]>;
-
-  filterFacets: (
-    filter: Filter,
-    params: {
-      searchQuery: SearchQuery;
-      forceLiveCollection?: boolean;
-      allProductIds: string[];
-      otherFilters: Filter[];
-    },
-    unchainedAPI: { modules: Modules },
-  ) => Promise<{
-    examinedProductIdSet: Set<string>;
-    filteredByOtherFiltersSet: Set<string>;
-    filteredByThisFilterSet: Set<string>;
-  }>;
-
-  productFacetedSearch: (
-    productIds: string[],
-    searchConfiguration: SearchConfiguration,
-    unchainedAPI: { modules: Modules },
-  ) => Promise<string[]>;
-};
-
-const baseDirector = BaseDirector<IFilterAdapter>('FilterDirector', {
-  adapterSortKey: 'orderIndex',
-});
-
-export const FilterDirector: IFilterDirector = {
-  ...baseDirector,
-
-  actions: async (filterContext, unchainedAPI) => {
-    const context = { ...filterContext, ...unchainedAPI };
-    const adapters = baseDirector.getAdapters().map((Adapter) => Adapter.actions(context));
-
-    const reduceAdapters = <V>(
-      reducer: (currentValue: Promise<V>, adapter: FilterAdapterActions, index: number) => Promise<V>,
-      initialValue: V,
-    ) => {
-      if (adapters.length === 0) {
-        return initialValue;
-      }
-      return adapters.reduce(async (lastSearchPromise, adapter, index) => {
-        return reducer(lastSearchPromise, adapter, index);
-      }, Promise.resolve(initialValue));
-    };
-
-    return {
-      aggregateProductIds: (params) => {
-        return adapters.reduce(
-          (productIds, adapter) => adapter.aggregateProductIds({ productIds }),
-          params.productIds,
-        );
-      },
-
-      searchAssortments: async (params, options) => {
-        return reduceAdapters<string[] | undefined>(async (lastSearchPromise, adapter) => {
-          const assortmentIds = await lastSearchPromise;
-          return adapter.searchAssortments({ assortmentIds }, options);
-        }, params.assortmentIds);
-      },
-
-      searchProducts: async (params, options) => {
-        return reduceAdapters<string[] | undefined>(async (lastSearchPromise, adapter) => {
-          const productIds = await lastSearchPromise;
-          return adapter.searchProducts({ productIds }, options);
-        }, params.productIds);
-      },
-
-      transformProductSelector: async (defaultSelector, options) => {
-        return reduceAdapters<mongodb.Filter<Product>>(async (lastSelector, adapter) => {
-          return adapter.transformProductSelector(await lastSelector, options);
-        }, defaultSelector);
-      },
-
-      transformSortStage: async (defaultStage, options) => {
-        return reduceAdapters<mongodb.FindOptions['sort']>(async (lastSortStage, adapter) => {
-          return adapter.transformSortStage(await lastSortStage, options);
-        }, defaultStage);
-      },
-
-      transformFilterSelector: async (defaultSelector, options) => {
-        return reduceAdapters<mongodb.Filter<Filter>>(async (lastSelector, adapter) => {
-          return adapter.transformFilterSelector(await lastSelector, options);
-        }, defaultSelector);
-      },
-    };
-  },
-
-  async findProductIds(
-    filter: Filter,
-    { value }: { value?: boolean | string },
-    unchainedAPI: { modules: Modules },
-  ) {
-    const { modules } = unchainedAPI;
-    const director = await FilterDirector.actions({ filter, searchQuery: {} }, unchainedAPI);
-    const productSelector = await director.transformProductSelector(
-      modules.products.search.buildActiveDraftStatusFilter(),
-      {
-        key: filter.key,
-        value,
-      },
-    );
-
-    if (!productSelector) return [];
-    return modules.products.findProductIds({
-      productSelector,
-      includeDrafts: true,
-    });
-  },
-
-  async buildProductIdMap(
-    filter: Filter,
-    unchainedAPI: { modules: Modules },
-  ): Promise<[string[], Record<string, string[]>]> {
-    const allProductIds = await this.findProductIds(filter, {}, unchainedAPI);
-    const productIdsMap =
-      filter.type === FilterType.SWITCH
-        ? {
-            true: await this.findProductIds(filter, { value: true }, unchainedAPI),
-            false: await this.findProductIds(filter, { value: { $in: [null, false] } }, unchainedAPI),
-          }
-        : await (filter.options || []).reduce(async (accumulatorPromise, option) => {
-            const accumulator = await accumulatorPromise;
-            return {
-              ...accumulator,
-              [option]: await this.findProductIds(filter, { value: option }, unchainedAPI),
-            };
-          }, Promise.resolve({}));
-
-    return [allProductIds, productIdsMap];
-  },
-
-  async filterProductIds(
-    filter: Filter,
-    { values, forceLiveCollection }: { values: string[]; forceLiveCollection?: boolean },
-    unchainedAPI: { modules: Modules },
-  ) {
-    const [allProductIds, keyToProductIdMap]: [string[], Record<string, string[]>] =
-      (!forceLiveCollection && (await filtersSettings.getCachedProductIds(filter._id))) ||
-      (await this.buildProductIdMap(filter, unchainedAPI));
-
-    const filteredKeys = unchainedAPI.modules.filters.parse(
-      filter,
-      values,
-      Object.keys(keyToProductIdMap),
-    );
-    const result: string[] = [];
-    for (const key of filteredKeys) {
-      const additionalValues = key === undefined ? allProductIds : keyToProductIdMap[key];
-      if (additionalValues) {
-        result.push(...additionalValues);
-      }
-    }
-    return result;
-  },
-
-  async productFacetedSearch(
-    productIds: string[],
-    searchConfiguration: SearchConfiguration,
-    unchainedAPI: { modules: Modules },
-  ): Promise<string[]> {
-    const { searchQuery, filterSelector, forceLiveCollection } = searchConfiguration;
-    const { modules } = unchainedAPI;
-    if (!searchQuery || !searchQuery.filterQuery) return productIds;
-
-    const parsedFilterQuery = parseQueryArray(searchQuery.filterQuery);
-
-    const filters = filterSelector
-      ? await modules.filters.findFilters({
-          ...filterSelector,
-          limit: 0,
-          includeInactive: true,
-        })
-      : [];
-
-    const intersectedProductIds = await filters.reduce(
-      async (productIdSetPromise: Promise<Set<string>>, filter) => {
-        const productIdSet = await productIdSetPromise;
-
-        if (!parsedFilterQuery[filter.key]) return productIdSet;
-
-        const values = parsedFilterQuery[filter.key];
-
-        const filterOptionProductIds = await this.filterProductIds(
-          filter,
-          {
-            values,
-            forceLiveCollection,
-          },
-          unchainedAPI,
-        );
-
-        return productIdSet.intersection(new Set(filterOptionProductIds));
-      },
-      Promise.resolve(new Set(productIds)),
-    );
-
-    return [...intersectedProductIds];
-  },
-
-  async filterFacets(filter, params, unchainedAPI) {
-    const { allProductIds, searchQuery, forceLiveCollection, otherFilters } = params;
-
-    const filterQueryParsed = parseQueryArray(searchQuery.filterQuery);
-
-    // The examinedProductIdSet is a set of product id's that:
-    // - Fit this filter generally
-    // - Are part of the preselected product id array
-    const filteredProductIds = await this.filterProductIds(
-      filter,
-      {
-        values: [undefined],
-        forceLiveCollection,
-      },
-      unchainedAPI,
-    );
-
-    const examinedProductIdSet = new Set(allProductIds).intersection(new Set(filteredProductIds));
-    const values = filterQueryParsed[filter.key];
-
-    // The filteredProductIdSet is a set of product id's that:
-    // - Are filtered by all other filters
-    // - Are filtered by the currently selected value of this filter
-    // or if there is no currently selected value:
-    // - Is the same like examinedProductIdSet
-    const filteredByOtherFiltersSet = await otherFilters
-      .filter((otherFilter) => otherFilter.key !== filter.key)
-      .reduce(
-        async (productIdSetPromise, otherFilter) => {
-          if (otherFilter.key === filter.key) return productIdSetPromise;
-          if (!filterQueryParsed[otherFilter.key]) return productIdSetPromise;
-          const productIdSet = await productIdSetPromise;
-          const otherFilterProductIds = await this.filterProductIds(
-            otherFilter,
-            {
-              values: filterQueryParsed[otherFilter.key],
-              forceLiveCollection,
-            },
-            unchainedAPI,
-          );
-          return productIdSet.intersection(new Set(otherFilterProductIds));
-        },
-        Promise.resolve(new Set(examinedProductIdSet)),
-      );
-
-    const filterProductIdsForValues = values
-      ? await this.filterProductIds(
-          filter,
-          {
-            values,
-            forceLiveCollection,
-          },
-          unchainedAPI,
-        )
-      : filteredProductIds;
-
-    const filteredByThisFilterSet = new Set<string>(filterProductIdsForValues);
-
-    return {
-      examinedProductIdSet,
-      filteredByOtherFiltersSet,
-      filteredByThisFilterSet,
-    };
-  },
-
-  async invalidateProductIdCache(filter: Filter, unchainedAPI: { modules: Modules }) {
-    if (!filter) return;
-
-    const [productIds, productIdMap] = await this.buildProductIdMap(filter, unchainedAPI);
-    await filtersSettings.setCachedProductIds(filter._id, productIds, productIdMap);
-  },
-};

package/src/directors/IntervalWorker.ts

@@ -1,75 +0,0 @@
-import later, { ScheduleData } from '@breejs/later';
-import { BaseWorker, IWorker } from './BaseWorker.js';
-import { createLogger } from '@unchainedshop/logger';
-
-const { NODE_ENV } = process.env;
-
-const logger = createLogger('unchained:worker:interval');
-
-export interface IntervalWorkerParams {
-  workerId?: string;
-  batchCount?: number;
-  schedule?: ScheduleData;
-}
-
-const defaultSchedule = later.parse.text(
-  NODE_ENV !== 'production' ? 'every 2 seconds' : 'every 30 seconds',
-);
-
-export const scheduleToInterval = (schedule: ScheduleData) => {
-  const referenceDate = new Date(1000);
-  const nextDates = later.schedule(schedule).next(2, referenceDate) as Date[];
-
-  if (!nextDates || nextDates.length < 2) {
-    throw new Error('Schedule must produce at least 2 consecutive dates');
-  }
-
-  const [one, two] = nextDates;
-  const diff = new Date(two).getTime() - new Date(one).getTime();
-  return Math.min(1000 * 60 * 60, diff); // at least once every hour!
-};
-
-export const IntervalWorker: IWorker<IntervalWorkerParams> = {
-  ...BaseWorker,
-
-  key: 'shop.unchained.worker.cron',
-  label: 'Allocates work on fixed intervals with native node setInterval',
-  version: '1.0.0',
-  type: 'CRON',
-
-  actions: ({ workerId, batchCount = 10, schedule = defaultSchedule }, unchainedAPI) => {
-    const baseWorkerActions = BaseWorker.actions({ workerId, worker: IntervalWorker }, unchainedAPI);
-
-    const intervalDelay = scheduleToInterval(schedule);
-    let intervalHandle: NodeJS.Timeout | null = null;
-
-    return {
-      ...baseWorkerActions,
-
-      start() {
-        // Prevent multiple intervals from running
-        if (intervalHandle) {
-          return;
-        }
-
-        intervalHandle = setInterval(async () => {
-          try {
-            await baseWorkerActions.process({
-              maxWorkItemCount: batchCount,
-              referenceDate: IntervalWorker.getFloorDate(),
-            });
-          } catch (error) {
-            logger.error(error);
-          }
-        }, intervalDelay);
-      },
-
-      stop() {
-        if (intervalHandle) {
-          clearInterval(intervalHandle);
-          intervalHandle = null;
-        }
-      },
-    };
-  },
-};

package/src/directors/MessagingDirector.test.ts

@@ -1,8 +0,0 @@
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-
-describe('MessagingDirector', () => {
-  it('Stub', () => {
-    assert(true);
-  });
-});

package/src/directors/MessagingDirector.ts

@@ -1,52 +0,0 @@
-export interface EmailTemplateType {
-  type: 'EMAIL';
-  input: {
-    from: string;
-    to: string;
-    cc?: string;
-    subject: string;
-    text: string;
-    html?: string;
-    attachments?: (
-      | { filename: string; path: string }
-      | {
-          filename: string;
-          content: string;
-          contentType: string;
-          encoding: string;
-        }
-      | { href: string; filename: string }
-    )[];
-  };
-}
-
-export interface SMSTemplateType {
-  type: 'TWILIO' | 'BULKGATE' | 'BUDGETSMS';
-  input: {
-    from: string;
-    to: string;
-    text: string;
-  };
-}
-
-export interface ArbitraryTemplateType {
-  type: string;
-  input: any;
-}
-
-export type TemplateResolver<T = Record<string, any>> = (
-  params: { template: string } & T,
-  unchainedAPI,
-) => Promise<(EmailTemplateType | SMSTemplateType | ArbitraryTemplateType)[]>;
-
-const TemplateResolvers = new Map<string, TemplateResolver>();
-
-export const MessagingDirector = {
-  registerTemplate: (templateName: string, templateResolver: TemplateResolver) => {
-    TemplateResolvers.set(templateName, templateResolver);
-  },
-
-  getTemplate: (templateName: string) => TemplateResolvers.get(templateName),
-
-  getRegisteredTemplates: () => Array.from(TemplateResolvers.keys()),
-};

package/src/directors/OrderDiscountAdapter.ts

@@ -1,10 +0,0 @@
-import {
-  BaseDiscountAdapter,
-  IDiscountAdapter,
-  OrderDiscountConfiguration,
-} from '../directors/index.js';
-
-export const OrderDiscountAdapter = BaseDiscountAdapter as Omit<
-  IDiscountAdapter<OrderDiscountConfiguration>,
-  'key' | 'label' | 'version'
->;

package/src/directors/OrderDiscountConfiguration.ts

@@ -1,5 +0,0 @@
-export interface OrderDiscountConfiguration {
-  fixedRate?: number;
-  rate?: number;
-  isNetPrice?: boolean;
-}

package/src/directors/OrderDiscountDirector.ts

@@ -1,5 +0,0 @@
-import { BaseDiscountDirector } from './BaseDiscountDirector.js';
-import { OrderDiscountConfiguration } from './OrderDiscountConfiguration.js';
-
-export const OrderDiscountDirector =
-  BaseDiscountDirector<OrderDiscountConfiguration>('OrderDiscountDirector');