@unchainedshop/core 4.0.0-rc.14 → 4.0.0-rc.16

package/src/bulk-importer/handlers/filter/update.ts

@@ -0,0 +1,67 @@
+import { Modules } from '../../../modules.js';
+import createFilter from './create.js';
+
+export default async function updateFilter(
+  payload: any,
+  { logger, updateShouldUpsertIfIDNotExists }: { logger: any; updateShouldUpsertIfIDNotExists: boolean },
+  unchainedAPI: { modules: Modules },
+) {
+  const { modules } = unchainedAPI;
+  const { specification, _id } = payload;
+
+  if (!(await modules.filters.filterExists({ filterId: _id }))) {
+    if (updateShouldUpsertIfIDNotExists) {
+      return createFilter(payload, { logger, createShouldUpsertIfIDExists: false }, unchainedAPI);
+    }
+    throw new Error(`Can't update non-existing filter ${_id}`);
+  }
+
+  const { content, options, ...filterData } = specification;
+
+  if (specification) {
+    logger.debug('update filter object', specification);
+    await modules.filters.update(_id, {
+      ...filterData,
+      options: options?.map((option) => option.value) || [],
+    });
+  }
+
+  if (content) {
+    logger.debug('replace localized content for filter', content);
+    await modules.filters.texts.updateTexts(
+      { filterId: _id },
+      Object.entries(content).map(([locale, localizedData]: [string, any]) => {
+        return {
+          locale,
+          ...localizedData,
+        };
+      }),
+    );
+  }
+
+  if (options) {
+    logger.debug('replace localized content for filter options', content);
+    await Promise.all(
+      options.map(async ({ content: optionContent, value: optionValue }) => {
+        if (optionContent) {
+          await modules.filters.texts.updateTexts(
+            { filterId: _id, filterOptionValue: optionValue },
+            Object.entries(optionContent).map(([locale, localizedData]: [string, any]) => {
+              return {
+                locale,
+                ...localizedData,
+              };
+            }),
+          );
+        }
+      }),
+    );
+  }
+
+  return {
+    entity: 'FILTER',
+    operation: 'update',
+    _id,
+    success: true,
+  };
+}

package/src/bulk-importer/handlers/product/create.ts

@@ -0,0 +1,70 @@
+import { Modules } from '../../../modules.js';
+import { Services } from '../../../services/index.js';
+import upsertVariations from './upsertVariations.js';
+import upsertMedia from './upsertMedia.js';
+import transformSpecificationToProductStructure from './transformSpecificationToProductStructure.js';
+
+export default async function createProduct(
+  payload: any,
+  { logger, createShouldUpsertIfIDExists },
+  unchainedAPI: { modules: Modules; services: Services },
+) {
+  const { modules } = unchainedAPI;
+  const { specification, media, variations, _id } = payload;
+
+  if (!specification) throw new Error(`Specification is required when creating new product ${_id}`);
+
+  if (!specification.content) throw new Error(`Content is required when creating new product ${_id}`);
+
+  const productData = transformSpecificationToProductStructure(specification);
+  logger.debug('create product object', productData);
+  try {
+    await modules.products.create({
+      ...productData,
+      _id,
+    });
+  } catch (e) {
+    if (!createShouldUpsertIfIDExists) throw e;
+
+    logger.debug('entity already exists, falling back to update', specification);
+    await modules.products.update(_id, {
+      ...productData,
+    });
+  }
+
+  if (!(await modules.products.productExists({ productId: _id }))) {
+    throw new Error(`Can't create product ${_id}, fields missing?`);
+  }
+
+  if (specification.content) {
+    logger.debug('create localized content for product', specification.content);
+    await modules.products.texts.updateTexts(
+      _id,
+      Object.entries(specification.content).map(([locale, localizedData]: [string, any]) => {
+        return {
+          locale,
+          ...localizedData,
+        };
+      }),
+    );
+  }
+
+  logger.debug('create product variations', variations);
+  await upsertVariations(
+    {
+      variations: variations || [],
+      productId: _id,
+    },
+    unchainedAPI,
+  );
+
+  logger.debug('create product media', media);
+  await upsertMedia({ media: media || [], productId: _id }, unchainedAPI);
+
+  return {
+    entity: 'PRODUCT',
+    operation: 'create',
+    _id,
+    success: true,
+  };
+}

package/src/bulk-importer/handlers/product/index.ts

@@ -0,0 +1,3 @@
+export { default as create } from './create.js';
+export { default as update } from './update.js';
+export { default as remove } from './remove.js';

package/src/bulk-importer/handlers/product/remove.ts

@@ -0,0 +1,21 @@
+import { Modules } from '../../../modules.js';
+import { Services } from '../../../services/index.js';
+
+export default async function removeProduct(
+  payload: any,
+  { logger },
+  unchainedAPI: { modules: Modules; services: Services },
+) {
+  const { services } = unchainedAPI;
+  const { _id } = payload;
+  logger.debug(`remove product ${_id}`);
+
+  await services.products.removeProduct({ productId: _id });
+
+  return {
+    entity: 'PRODUCT',
+    operation: 'remove',
+    _id,
+    success: true,
+  };
+}

package/src/bulk-importer/handlers/product/transformSpecificationToProductStructure.ts

@@ -0,0 +1,22 @@
+import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
+
+export default (specification) => {
+  const {
+    variationResolvers: assignments,
+    content, // eslint-disable-line
+    warehousing: warehousingEmbeddedSupply,
+    ...productData
+  } = specification;
+
+  const { dimensions: supply, ...warehousing } = warehousingEmbeddedSupply || {};
+  const tags = convertTagsToLowerCase(productData?.tags);
+  const proxy = assignments ? { assignments } : undefined;
+
+  return {
+    ...productData,
+    tags,
+    warehousing,
+    supply,
+    proxy,
+  };
+};

package/src/bulk-importer/handlers/product/update.ts

@@ -0,0 +1,66 @@
+import { Modules } from '../../../modules.js';
+import { Services } from '../../../services/index.js';
+import upsertVariations from './upsertVariations.js';
+import upsertMedia from './upsertMedia.js';
+import transformSpecificationToProductStructure from './transformSpecificationToProductStructure.js';
+import createProduct from './create.js';
+
+export default async function updateProduct(
+  payload: any,
+  { logger, updateShouldUpsertIfIDNotExists },
+  unchainedAPI: { modules: Modules; services: Services },
+) {
+  const { modules } = unchainedAPI;
+  const { specification, media, variations, _id } = payload;
+
+  if (!(await modules.products.productExists({ productId: _id }))) {
+    if (updateShouldUpsertIfIDNotExists) {
+      return createProduct(payload, { logger, createShouldUpsertIfIDExists: false }, unchainedAPI);
+    }
+    throw new Error(`Can't update non-existing product ${_id}`);
+  }
+
+  if (specification) {
+    const productData = transformSpecificationToProductStructure(specification);
+    logger.debug('update product object', productData);
+    await modules.products.update(_id, {
+      ...productData,
+    });
+
+    if (specification.content) {
+      logger.debug('replace localized content for product', specification.content);
+      await modules.products.texts.updateTexts(
+        _id,
+        Object.entries(specification.content).map(([locale, localizedData]: [string, any]) => {
+          return {
+            locale,
+            ...localizedData,
+          };
+        }),
+      );
+    }
+  }
+
+  if (variations) {
+    logger.debug('replace variations', variations);
+    await upsertVariations(
+      {
+        variations: variations || [],
+        productId: _id,
+      },
+      unchainedAPI,
+    );
+  }
+
+  if (media) {
+    logger.debug('replace product media', media);
+    await upsertMedia({ media, productId: _id }, unchainedAPI);
+  }
+
+  return {
+    entity: 'PRODUCT',
+    operation: 'update',
+    _id,
+    success: true,
+  };
+}

package/src/bulk-importer/handlers/product/upsertMedia.ts

@@ -0,0 +1,64 @@
+import { ProductMedia } from '@unchainedshop/core-products';
+import { Modules } from '../../../modules.js';
+import { Services } from '../../../services/index.js';
+import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
+import upsertAsset from '../../upsertAsset.js';
+
+const upsertProductMedia = async (productMedia: ProductMedia, { modules }: { modules: Modules }) => {
+  try {
+    const productMediaObj = await modules.products.media.create(productMedia);
+    return productMediaObj;
+  } catch {
+    const { _id, ...productMediaData } = productMedia;
+    const productMediaId = _id;
+    return modules.products.media.update(productMediaId, productMediaData);
+  }
+};
+
+export default async function upsertMedia(
+  { media, productId },
+  unchainedAPI: { modules: Modules; services: Services },
+) {
+  const { modules } = unchainedAPI;
+
+  const productMediaObjects = await Promise.all(
+    media.map(async ({ asset, content, ...mediaData }) => {
+      const tags = convertTagsToLowerCase(mediaData?.tags);
+      const file = await upsertAsset(
+        'product-media',
+        { meta: { ...(asset.meta || {}), productId }, ...asset },
+        unchainedAPI,
+      );
+      if (!file) throw new Error(`Unable to create binary ${asset._id}`);
+      const fileId = file._id;
+      const productMedia = await upsertProductMedia(
+        {
+          ...mediaData,
+          tags,
+          productId,
+          mediaId: file._id,
+        } as ProductMedia,
+        unchainedAPI,
+      );
+      if (!productMedia) throw new Error(`Unable to create product media object for file ${fileId}`);
+
+      if (content) {
+        await modules.products.media.texts.updateMediaTexts(
+          productMedia._id,
+          Object.entries(content).map(([locale, localizedData]: [string, any]) => {
+            return {
+              locale,
+              ...localizedData,
+            };
+          }),
+        );
+      }
+      return productMedia;
+    }),
+  );
+
+  await modules.products.media.deleteMediaFiles({
+    productId,
+    excludedProductMediaIds: productMediaObjects.map((obj) => obj._id),
+  });
+}

package/src/bulk-importer/handlers/product/upsertVariations.ts

@@ -0,0 +1,71 @@
+import { ProductVariation } from '@unchainedshop/core-products';
+import { Modules } from '../../../modules.js';
+
+const upsert = async (productVariation: ProductVariation, unchainedAPI: { modules: Modules }) => {
+  const { modules } = unchainedAPI;
+  try {
+    const newVariation = await modules.products.variations.create(productVariation);
+    return newVariation;
+  } catch {
+    return modules.products.variations.update(productVariation._id, productVariation);
+  }
+};
+
+export default async function upsertVariations(
+  { variations, productId },
+  unchainedAPI: { modules: Modules },
+) {
+  const { modules } = unchainedAPI;
+
+  const upsertedProductVariationIds = await Promise.all(
+    variations.map(async ({ content, options, ...variationsRest }) => {
+      const variation = await upsert(
+        {
+          ...variationsRest,
+          options: options.map((option) => option.value),
+          productId,
+        },
+        unchainedAPI,
+      );
+
+      await Promise.all(
+        options.map(async ({ content: optionContent, value: optionValue }) => {
+          if (optionContent) {
+            await modules.products.variations.texts.updateVariationTexts(
+              variation._id,
+              Object.entries(optionContent).map(([locale, localizedData]: [string, any]) => {
+                return {
+                  locale,
+                  ...localizedData,
+                };
+              }),
+              optionValue,
+            );
+          }
+        }),
+      );
+      if (content) {
+        await modules.products.variations.texts.updateVariationTexts(
+          variation._id,
+          Object.entries(content).map(([locale, localizedData]: [string, any]) => {
+            return {
+              locale,
+              ...localizedData,
+            };
+          }),
+        );
+      }
+      return variation._id;
+    }),
+  );
+  const allVariations = await modules.products.variations.findProductVariations({
+    productId,
+  });
+  await Promise.all(
+    allVariations.map(async (variation) => {
+      if (!upsertedProductVariationIds.includes(variation._id)) {
+        await modules.products.variations.delete(variation._id);
+      }
+    }),
+  );
+}

package/src/bulk-importer/handlers/utils/convertTagsToLowerCase.ts

@@ -0,0 +1,4 @@
+export default (tags) => {
+  if (Array.isArray(tags)) return tags.map((tag) => tag.toLowerCase());
+  return null;
+};

package/src/bulk-importer/upsertAsset.ts

@@ -0,0 +1,42 @@
+import type { File } from '@unchainedshop/core-files';
+import { Modules } from '../modules.js';
+import { Services } from '../services/index.js';
+
+const upsertAsset = async (
+  directoryName: string,
+  asset: File & { fileName: string; headers?: Record<string, unknown> },
+  unchainedAPI: { modules: Modules; services: Services },
+) => {
+  const { modules, services } = unchainedAPI;
+  const { _id: fileId, fileName, url, meta, headers, ...assetData } = asset;
+
+  try {
+    const existingFile = fileId && (await modules.files.findFile({ fileId }));
+    if (existingFile) {
+      if (JSON.stringify(meta) === JSON.stringify(existingFile.meta)) {
+        return existingFile;
+      }
+      await modules.files.update(fileId, { meta, ...assetData });
+      const updatedFile = await modules.files.findFile({ fileId });
+      return updatedFile;
+    }
+
+    const assetObject = await services.files.uploadFileFromURL({
+      directoryName,
+      fileInput: {
+        fileLink: url,
+        fileName,
+        fileId,
+        headers,
+      },
+      meta,
+    });
+
+    if (!assetObject) throw new Error('Media not created');
+    return assetObject;
+  } catch {
+    return null;
+  }
+};
+
+export default upsertAsset;

package/src/core-index.ts

@@ -1,6 +1,10 @@
 import { mongodb, MigrationRepository, ModuleInput } from '@unchainedshop/mongodb';
 import initServices, { CustomServices, Services } from './services/index.js';
 import initModules, { Modules, ModuleOptions } from './modules.js';
+import createBulkImporterFactory, {
+  BulkImporter,
+  BulkImportHandler,
+} from './bulk-importer/createBulkImporter.js';
 
 import {
   WorkerDirector,
@@ -18,17 +22,17 @@ import {
   WarehousingDirector,
 } from './directors/index.js';
 
+export * from './bulk-importer/createBulkImporter.js';
 export * from './services/index.js';
 export * from './directors/index.js';
-
-export interface BulkImporter {
-  createBulkImporter: (options: any) => any;
-}
+export * from './factory/index.js';
 
 export interface UnchainedCoreOptions {
   db: mongodb.Db;
   migrationRepository: MigrationRepository<UnchainedCore>;
-  bulkImporter: any;
+  bulkImporter?: {
+    handlers?: Record<string, BulkImportHandler<UnchainedCore>>;
+  };
   modules?: Record<
     string,
     {
@@ -49,13 +53,14 @@ export interface UnchainedCore {
 export const initCore = async ({
   db,
   migrationRepository,
-  bulkImporter,
+  bulkImporter: bulkImporterOptions = {},
   modules: customModules = {},
   services: customServices = {},
   options = {},
 }: UnchainedCoreOptions): Promise<UnchainedCore> => {
   // Configure custom modules
 
+  const bulkImporter = createBulkImporterFactory(db, bulkImporterOptions);
   const modules = await initModules({ db, migrationRepository, options }, customModules);
   const services = initServices(modules, customServices);
 

package/src/directors/FilterAdapter.ts

@@ -41,7 +41,7 @@ export interface FilterAdapterActions {
       sortStage: mongodb.FindOptions['sort'];
       locale: Intl.Locale;
     },
-  ) => Promise<string[]>;
+  ) => Promise<string[] | null>;
 
   transformFilterSelector: (
     query: mongodb.Filter<Filter>,

package/src/directors/FilterDirector.ts

@@ -80,7 +80,7 @@ export const FilterDirector: IFilterDirector = {
       initialValue: V,
     ) => {
       if (adapters.length === 0) {
-        return null;
+        return initialValue;
       }
       return adapters.reduce(async (lastSearchPromise, adapter, index) => {
         return reducer(lastSearchPromise, adapter, index);
@@ -89,11 +89,10 @@ export const FilterDirector: IFilterDirector = {
 
     return {
       aggregateProductIds: (params) => {
-        const reducedProductIds = adapters.reduce(
+        return adapters.reduce(
           (productIds, adapter) => adapter.aggregateProductIds({ productIds }),
           params.productIds,
         );
-        return reducedProductIds;
       },
 
       searchAssortments: async (params, options) => {
@@ -113,19 +112,19 @@ export const FilterDirector: IFilterDirector = {
       transformProductSelector: async (defaultSelector, options) => {
         return reduceAdapters<mongodb.Filter<Product>>(async (lastSelector, adapter) => {
           return adapter.transformProductSelector(await lastSelector, options);
-        }, defaultSelector || null);
+        }, defaultSelector);
       },
 
       transformSortStage: async (defaultStage, options) => {
         return reduceAdapters<mongodb.FindOptions<Product>['sort']>(async (lastSortStage, adapter) => {
           return adapter.transformSortStage(await lastSortStage, options);
-        }, defaultStage || null);
+        }, defaultStage);
       },
 
       transformFilterSelector: async (defaultSelector) => {
         return reduceAdapters<mongodb.Filter<Filter>>(async (lastSelector, adapter) => {
           return adapter.transformFilterSelector(await lastSelector);
-        }, defaultSelector || null);
+        }, defaultSelector);
       },
     };
   },
@@ -161,7 +160,7 @@ export const FilterDirector: IFilterDirector = {
       filter.type === FilterType.SWITCH
         ? {
             true: await this.findProductIds(filter, { value: true }, unchainedAPI),
-            false: await this.findProductIds(filter, { value: false }, unchainedAPI),
+            false: await this.findProductIds(filter, { value: { $in: [null, false] } }, unchainedAPI),
           }
         : await (filter.options || []).reduce(async (accumulatorPromise, option) => {
             const accumulator = await accumulatorPromise;

package/src/directors/PaymentDirector.ts

@@ -101,7 +101,7 @@ export const PaymentDirector: IPaymentDirector = {
         try {
           return adapter.isActive(paymentContext.transactionContext);
         } catch (error) {
-          logger.error(error.message);
+          logger.error(error);
           return false;
         }
       },
@@ -110,7 +110,7 @@ export const PaymentDirector: IPaymentDirector = {
         try {
           return adapter.isPayLaterAllowed(paymentContext.transactionContext);
         } catch (error) {
-          logger.error(error.message);
+          logger.error(error);
           return false;
         }
       },

package/src/directors/WorkerAdapter.ts

@@ -1,8 +1,8 @@
 import { BaseAdapter, IBaseAdapter } from '@unchainedshop/utils';
 import { WorkResult } from '@unchainedshop/core-worker';
-import { Modules } from '../modules.js';
+import { ModuleOptions, Modules } from '../modules.js';
 import { Services } from '../services/index.js';
-import { BulkImporter } from '../core-index.js';
+import { BulkImporter } from '../bulk-importer/createBulkImporter.js';
 
 export type IWorkerAdapter<Input, Output> = IBaseAdapter & {
   type: string;
@@ -11,7 +11,12 @@ export type IWorkerAdapter<Input, Output> = IBaseAdapter & {
 
   doWork: (
     input: Input,
-    unchainedAPI: { modules: Modules; services: Services; bulkImporter: BulkImporter },
+    unchainedAPI: {
+      modules: Modules;
+      services: Services;
+      bulkImporter: BulkImporter;
+      options: ModuleOptions;
+    },
     workId: string,
   ) => Promise<WorkResult<Output>>;
 };

package/src/factory/index.ts

@@ -0,0 +1,3 @@
+import registerProductDiscoverabilityFilter from './registerProductDiscoverabilityFilter.js';
+
+export { registerProductDiscoverabilityFilter };

package/src/factory/registerProductDiscoverabilityFilter.ts

@@ -0,0 +1,36 @@
+import { FilterAdapter, FilterDirector } from '../core-index.js';
+
+export default function registerProductDiscoverabilityFilter({
+  orderIndex = 0,
+  hiddenTagValue = 'hidden',
+}: {
+  orderIndex?: number;
+  hiddenTagValue?: string;
+}) {
+  FilterDirector.registerAdapter({
+    ...FilterAdapter,
+
+    key: `shop.unchained.filters.product-discoverability-${crypto.randomUUID()}`,
+    label: 'Product Discoverability Filter',
+    version: '1.0.0',
+    orderIndex,
+
+    actions: (params) => {
+      return {
+        ...FilterAdapter.actions(params),
+
+        transformProductSelector: async (lastSelector, options) => {
+          const { key } = options || {};
+
+          if (!key) {
+            const newSelector = { ...lastSelector };
+            if (!newSelector.$and) newSelector.$and = [];
+            newSelector.$and.push({ tags: { $ne: hiddenTagValue } });
+            return newSelector;
+          }
+          return lastSelector;
+        },
+      };
+    },
+  });
+}

package/src/modules.ts

@@ -154,6 +154,7 @@ const initModules = async (
   const products = await configureProductsModule({
     db,
     migrationRepository,
+    options: options.products,
   });
   const quotations = await configureQuotationsModule({
     db,

package/src/services/activateEnrollment.ts

@@ -1,6 +1,7 @@
 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;
@@ -15,15 +16,10 @@ export async function activateEnrollmentService(this: Modules, enrollment: Enrol
   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,
-    },
+  await addMessageService.bind(this)('ENROLLMENT_STATUS', {
+    reason: 'status_change',
+    locale: locale.baseName,
+    enrollmentId: updatedEnrollment._id,
   });
 
   return updatedEnrollment;