@unchainedshop/core 4.0.0-rc.2 → 4.0.0-rc.21

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

@@ -0,0 +1,175 @@
+import { z } from 'zod';
+import { Modules } from '../../../modules.js';
+import { Services } from '../../../services/index.js';
+import upsertVariations, { ProductVariationSchema } from './upsertVariations.js';
+import upsertMedia, { MediaSchema } from './upsertMedia.js';
+import createProduct, { ProductCreatePayloadSchema } from './create.js';
+import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
+
+export const ProductUpdateSpecificationSchema = z.object({
+  type: z.string().optional(),
+  sequence: z.number().optional(),
+  status: z.string().optional().nullable(), // or null!
+  published: z.string().datetime().optional().nullable(), // or null!
+  tags: z.array(z.string()).optional(),
+  commerce: z
+    .object({
+      pricing: z.array(
+        z.object({
+          amount: z.number(),
+          maxQuantity: z.number().optional(),
+          isTaxable: z.boolean().optional(),
+          isNetPrice: z.boolean().optional(),
+          currencyCode: z.string(),
+          countryCode: z.string(),
+        }),
+      ),
+    })
+    .optional(),
+  warehousing: z
+    .object({
+      sku: z.string().optional(),
+      baseUnit: z.string().optional(),
+    })
+    .optional(),
+  supply: z
+    .object({
+      weightInGram: z.number().optional(),
+      heightInMillimeters: z.number().optional(),
+      lengthInMillimeters: z.number().optional(),
+      widthInMillimeters: z.number().optional(),
+    })
+    .optional(),
+  bundleItems: z
+    .array(
+      z.object({
+        productId: z.string(),
+        quantity: z.number(),
+        configuration: z.array(
+          z.object({
+            key: z.string(),
+            value: z.string(),
+          }),
+        ),
+      }),
+    )
+    .optional(),
+  meta: z.record(z.unknown()).optional(),
+  content: z
+    .record(
+      z.string(), // locale
+      z.object({
+        title: z.string().optional(),
+        subtitle: z.string().optional(),
+        slug: z.string().optional(),
+        description: z.string().optional(),
+        brand: z.string().optional(),
+        vendor: z.string().optional(),
+        labels: z.array(z.string()).optional(),
+      }),
+    )
+    .optional(),
+  variationResolvers: z
+    .array(
+      z.object({
+        vector: z.record(z.string()),
+        productId: z.string(),
+      }),
+    )
+    .optional(),
+});
+
+export const ProductUpdatePayloadSchema = z.object({
+  _id: z.string(),
+  specification: ProductUpdateSpecificationSchema.optional(),
+  media: z.array(MediaSchema).optional(),
+  variations: z.array(ProductVariationSchema).optional(),
+});
+
+const transformSpecification = (specification: z.infer<typeof ProductUpdateSpecificationSchema>) => {
+  const {
+    variationResolvers: assignments,
+    content, // eslint-disable-line
+    supply,
+    warehousing,
+    ...productData
+  } = specification;
+
+  const tags = productData?.tags ? convertTagsToLowerCase(productData.tags!)! : [];
+  const proxy = assignments ? { assignments } : undefined;
+
+  return {
+    ...productData,
+    published: productData.published ? new Date(productData.published) : undefined,
+    tags,
+    warehousing,
+    supply,
+    proxy,
+  };
+};
+
+export default async function updateProduct(
+  payload: z.infer<typeof ProductUpdatePayloadSchema>,
+  { 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 && payload.specification) {
+      return createProduct(
+        payload as z.infer<typeof ProductCreatePayloadSchema>,
+        { logger, createShouldUpsertIfIDExists: false },
+        unchainedAPI,
+      );
+    }
+    throw new Error(`Can't update non-existing product ${_id}`);
+  }
+
+  if (specification) {
+    const productData = transformSpecification(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,
+  };
+}
+
+updateProduct.payloadSchema = ProductUpdatePayloadSchema;

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

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+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, { AssetSchema } from '../../upsertAsset.js';
+
+export const MediaSchema = z.object({
+  _id: z.string().optional(),
+  asset: AssetSchema,
+  content: z
+    .record(
+      z.string(), // locale
+      z.object({
+        title: z.string().optional(),
+        subtitle: z.string().optional(),
+      }),
+    )
+    .optional(),
+  tags: z.array(z.string()).optional(),
+  sortKey: z.number().optional(),
+});
+
+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 }: { media: z.infer<typeof MediaSchema>[]; productId: string },
+  unchainedAPI: { modules: Modules; services: Services },
+) {
+  const { modules } = unchainedAPI;
+
+  const productMediaObjects = await Promise.all(
+    media.map(async ({ asset, content, ...mediaData }) => {
+      const tags = mediaData?.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,110 @@
+import { z } from 'zod';
+import { ProductVariation } from '@unchainedshop/core-products';
+import { Modules } from '../../../modules.js';
+
+const ProductVariationOptionSchema = z.object({
+  value: z.string(),
+  content: z
+    .record(
+      z.string(), // locale
+      z.object({
+        title: z.string().optional(),
+        subtitle: z.string().optional(),
+      }),
+    )
+    .optional(),
+});
+
+export const ProductVariationSchema = z.object({
+  _id: z.string().optional(),
+  key: z.string(),
+  type: z.string(),
+  options: z.array(ProductVariationOptionSchema),
+  content: z
+    .record(
+      z.string(), // locale
+      z.object({
+        title: z.string().optional(),
+        subtitle: z.string().optional(),
+      }),
+    )
+    .optional(),
+});
+
+const upsert = async (
+  productVariation: Omit<ProductVariation, '_id' | 'created'> &
+    Pick<Partial<ProductVariation>, '_id' | 'created'>,
+  unchainedAPI: { modules: Modules },
+) => {
+  const { modules } = unchainedAPI;
+  try {
+    const newVariation = (await modules.products.variations.create(
+      productVariation,
+    )) as ProductVariation;
+    return newVariation;
+  } catch {
+    return (await modules.products.variations.update(
+      productVariation._id!,
+      productVariation,
+    )) as ProductVariation;
+  }
+};
+
+export default async function upsertVariations(
+  { variations, productId }: { variations: z.infer<typeof ProductVariationSchema>[]; productId: string },
+  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: string[]): string[] | null => {
+  if (Array.isArray(tags)) return tags.map((tag) => tag.toLowerCase());
+  return null;
+};

package/src/bulk-importer/index.ts

@@ -0,0 +1,3 @@
+import { default as createBulkImporterFactory } from './createBulkImporter.js';
+export * from './createBulkImporter.js';
+export default createBulkImporterFactory;

package/src/bulk-importer/upsertAsset.ts

@@ -0,0 +1,50 @@
+import { Modules } from '../modules.js';
+import { Services } from '../services/index.js';
+import { z } from 'zod';
+
+export const AssetSchema = z.object({
+  _id: z.string().optional(),
+  url: z.string(),
+  meta: z.record(z.unknown()).optional(),
+  fileName: z.string(),
+  headers: z.record(z.string()).optional(),
+});
+
+const upsertAsset = async (
+  directoryName: string,
+  asset: z.infer<typeof AssetSchema>,
+  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,7 @@
 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/index.js';
 
 import {
   WorkerDirector,
@@ -17,18 +18,19 @@ import {
   QuotationDirector,
   WarehousingDirector,
 } from './directors/index.js';
+import { IBaseAdapter } from '@unchainedshop/utils';
 
+export * from './bulk-importer/index.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 +51,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);
 
@@ -82,7 +85,7 @@ export const getAllAdapters = () => {
   const quotation = QuotationDirector.getAdapters();
   const warehousing = WarehousingDirector.getAdapters();
 
-  return [].concat(
+  return ([] as IBaseAdapter[]).concat(
     worker,
     delivery,
     deliveryPricing,

package/src/directors/BaseDiscountAdapter.test.ts

@@ -32,7 +32,7 @@ describe('BaseDiscountAdapter instantiation', () => {
 
     it('release', async () => {
       const result = await adapter.actions(context);
-      assert.equal(await result.release(), null);
+      assert.equal(await result.release(), undefined);
     });
 
     it('isValidForCodeTriggering', async () => {

package/src/directors/BaseDiscountAdapter.ts

@@ -6,13 +6,13 @@ import { Modules } from '../modules.js';
 export interface DiscountContext {
   code?: string;
   orderDiscount?: OrderDiscount;
-  order?: Order;
+  order: Order;
 }
 
 export type IDiscountAdapter<DiscountConfiguration> = IBaseAdapter & {
   orderIndex: number;
 
-  isManualAdditionAllowed: (code: string) => Promise<boolean>;
+  isManualAdditionAllowed: (code?: string) => Promise<boolean>;
   isManualRemovalAllowed: () => Promise<boolean>;
 
   actions: (params: {
@@ -27,9 +27,9 @@ export interface DiscountAdapterActions<DiscountConfiguration> {
   discountForPricingAdapterKey: (params: {
     pricingAdapterKey: string;
     calculationSheet: IPricingSheet<PricingCalculation>;
-  }) => DiscountConfiguration;
+  }) => DiscountConfiguration | null;
 
-  reserve: (params: { code: string }) => Promise<any>;
+  reserve: (params: { code?: string }) => Promise<any>;
   release: () => Promise<void>;
 }
 
@@ -67,7 +67,7 @@ export const BaseDiscountAdapter: Omit<IDiscountAdapter<unknown>, 'key' | 'label
 
     // return void, allows you to free up any reservations in backend systems
     release: async () => {
-      return null;
+      return;
     },
 
     // return true if a discount is valid to be part of the order.

package/src/directors/BaseDiscountDirector.ts

@@ -11,7 +11,7 @@ export type IDiscountDirector<DiscountConfiguration> = IBaseDirector<
   ) => Promise<{
     resolveDiscountAdapterFromStaticCode: (params: {
       code: string;
-    }) => Promise<IDiscountAdapter<DiscountConfiguration>>;
+    }) => Promise<IDiscountAdapter<DiscountConfiguration> | null>;
     findSystemDiscounts: () => Promise<string[]>;
   }>;
 };
@@ -46,7 +46,7 @@ export const BaseDiscountDirector = <DiscountConfigurationType>(
               }),
           );
 
-          return discounts.find(({ isValid }) => isValid === true)?.Adapter;
+          return discounts.find(({ isValid }) => isValid === true)?.Adapter || null;
         },
 
         async findSystemDiscounts() {

package/src/directors/BasePricingAdapter.ts

@@ -4,7 +4,7 @@ import { Discount } from './BasePricingDirector.js';
 import { Order, OrderDiscount } from '@unchainedshop/core-orders';
 
 interface IDiscountableItem {
-  _id?: string;
+  _id: string;
   orderId?: string;
 }
 
@@ -26,7 +26,7 @@ export interface IPricingAdapterActions<
   Calculation extends PricingCalculation,
   Sheet extends IPricingSheet<Calculation>,
 > {
-  calculate: () => Promise<Calculation[]>;
+  calculate: () => Promise<Calculation[] | null>;
   resultSheet: () => Sheet;
 }
 

package/src/directors/BasePricingDirector.ts

@@ -70,7 +70,7 @@ export const BasePricingDirector = <
     async rebuildCalculation(this: typeof director, pricingContext, unchainedAPI) {
       const context = await this.buildPricingContext(pricingContext, unchainedAPI);
 
-      let calculation: Calculation[] = [];
+      let calculation: Calculation[] | null = [];
 
       const Adapters = baseDirector.getAdapters({
         adapterFilter: (Adapter) => {
@@ -78,52 +78,55 @@ export const BasePricingDirector = <
         },
       });
 
-      calculation = await Adapters.reduce(async (previousPromise, Adapter) => {
-        const resolvedCalculation = await previousPromise;
-        if (!resolvedCalculation) return null;
-
-        const discounts: Discount<any>[] = await Promise.all(
-          context.discounts.map(async (orderDiscount) => {
-            const order = await unchainedAPI.modules.orders.findOrder({
-              orderId: orderDiscount.orderId,
-            });
-            const DiscountAdapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
-            if (!DiscountAdapter) return null;
-
-            const adapter = await DiscountAdapter.actions({
-              context: { order, orderDiscount, code: orderDiscount.code, ...unchainedAPI },
+      calculation = await Adapters.reduce(
+        async (previousPromise, Adapter) => {
+          const resolvedCalculation = await previousPromise;
+          if (!resolvedCalculation) return null;
+
+          const discounts: (Discount<any> | null)[] = await Promise.all(
+            context.discounts.map(async (orderDiscount) => {
+              const order = await unchainedAPI.modules.orders.findOrder({
+                orderId: orderDiscount.orderId,
+              });
+              const DiscountAdapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
+              if (!DiscountAdapter) return null;
+
+              const adapter = await DiscountAdapter.actions({
+                context: { order, orderDiscount, code: orderDiscount.code, ...unchainedAPI },
+              });
+
+              const configuration = adapter.discountForPricingAdapterKey({
+                pricingAdapterKey: Adapter.key,
+                calculationSheet: this.calculationSheet(pricingContext, resolvedCalculation),
+              });
+
+              return {
+                discountId: orderDiscount._id,
+                configuration,
+              };
+            }),
+          );
+
+          try {
+            const adapter = Adapter.actions({
+              context,
+              calculationSheet: this.calculationSheet(pricingContext, resolvedCalculation),
+              discounts: discounts.filter((d) => d?.configuration !== null) as Discount<any>[],
             });
 
-            const configuration = adapter.discountForPricingAdapterKey({
-              pricingAdapterKey: Adapter.key,
-              calculationSheet: this.calculationSheet(pricingContext, calculation),
-            });
+            const nextCalculationResult = await adapter.calculate();
+            if (!nextCalculationResult) return null;
+            calculation = resolvedCalculation.concat(nextCalculationResult);
+            return calculation;
+          } catch (error) {
+            logger.error(error);
+          }
+          return resolvedCalculation;
+        },
+        Promise.resolve([] as Calculation[]),
+      );
 
-            return {
-              discountId: orderDiscount._id,
-              configuration,
-            };
-          }),
-        );
-
-        try {
-          const adapter = Adapter.actions({
-            context,
-            calculationSheet: this.calculationSheet(pricingContext, calculation),
-            discounts: discounts.filter((d) => d?.configuration !== null),
-          });
-
-          const nextCalculationResult = await adapter.calculate();
-          if (!nextCalculationResult) return null;
-          calculation = resolvedCalculation.concat(nextCalculationResult);
-          return calculation;
-        } catch (error) {
-          logger.error(error);
-        }
-        return resolvedCalculation;
-      }, Promise.resolve([]));
-
-      return calculation;
+      return calculation || ([] as Calculation[]);
     },
   };
 

package/src/directors/BasePricingSheet.ts

@@ -93,7 +93,7 @@ export const BasePricingSheet = <Calculation extends PricingCalculation>(
         (oldCalculation, filterKey) =>
           oldCalculation.filter(
             (row: Calculation) =>
-              !!row && (filter[filterKey] === undefined || row[filterKey] === filter[filterKey]),
+              !!row && (filter![filterKey] === undefined || row[filterKey] === filter![filterKey]),
           ),
         this.calculation,
       );