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

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

@@ -1,12 +1,115 @@
+import { z } from 'zod';
 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';
+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: any,
+  payload: z.infer<typeof ProductUpdatePayloadSchema>,
   { logger, updateShouldUpsertIfIDNotExists },
   unchainedAPI: { modules: Modules; services: Services },
 ) {
@@ -14,14 +117,18 @@ export default async function updateProduct(
   const { specification, media, variations, _id } = payload;
 
   if (!(await modules.products.productExists({ productId: _id }))) {
-    if (updateShouldUpsertIfIDNotExists) {
-      return createProduct(payload, { logger, createShouldUpsertIfIDExists: false }, unchainedAPI);
+    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 = transformSpecificationToProductStructure(specification);
+    const productData = transformSpecification(specification);
     logger.debug('update product object', productData);
     await modules.products.update(_id, {
       ...productData,
@@ -64,3 +171,5 @@ export default async function updateProduct(
     success: true,
   };
 }
+
+updateProduct.payloadSchema = ProductUpdatePayloadSchema;

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

@@ -1,8 +1,25 @@
+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 from '../../upsertAsset.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 {
@@ -16,14 +33,14 @@ const upsertProductMedia = async (productMedia: ProductMedia, { modules }: { mod
 };
 
 export default async function upsertMedia(
-  { media, productId },
+  { 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 = convertTagsToLowerCase(mediaData?.tags);
+      const tags = mediaData?.tags ? convertTagsToLowerCase(mediaData?.tags)! : [];
       const file = await upsertAsset(
         'product-media',
         { meta: { ...(asset.meta || {}), productId }, ...asset },

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

@@ -1,18 +1,57 @@
+import { z } from 'zod';
 import { ProductVariation } from '@unchainedshop/core-products';
 import { Modules } from '../../../modules.js';
 
-const upsert = async (productVariation: ProductVariation, unchainedAPI: { modules: Modules }) => {
+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);
+    const newVariation = (await modules.products.variations.create(
+      productVariation,
+    )) as ProductVariation;
     return newVariation;
   } catch {
-    return modules.products.variations.update(productVariation._id, productVariation);
+    return (await modules.products.variations.update(
+      productVariation._id!,
+      productVariation,
+    )) as ProductVariation;
   }
 };
 
 export default async function upsertVariations(
-  { variations, productId },
+  { variations, productId }: { variations: z.infer<typeof ProductVariationSchema>[]; productId: string },
   unchainedAPI: { modules: Modules },
 ) {
   const { modules } = unchainedAPI;

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

@@ -1,4 +1,4 @@
-export default (tags) => {
+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

@@ -1,10 +1,18 @@
-import type { File } from '@unchainedshop/core-files';
 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: File & { fileName: string; headers?: Record<string, unknown> },
+  asset: z.infer<typeof AssetSchema>,
   unchainedAPI: { modules: Modules; services: Services },
 ) => {
   const { modules, services } = unchainedAPI;

package/src/core-index.ts

@@ -1,10 +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/createBulkImporter.js';
+import createBulkImporterFactory, { BulkImporter, BulkImportHandler } from './bulk-importer/index.js';
 
 import {
   WorkerDirector,
@@ -21,8 +18,9 @@ import {
   QuotationDirector,
   WarehousingDirector,
 } from './directors/index.js';
+import { IBaseAdapter } from '@unchainedshop/utils';
 
-export * from './bulk-importer/createBulkImporter.js';
+export * from './bulk-importer/index.js';
 export * from './services/index.js';
 export * from './directors/index.js';
 export * from './factory/index.js';
@@ -87,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,
       );

package/src/directors/BaseWorker.ts

@@ -83,7 +83,7 @@ export const BaseWorker: IWorker<WorkerParams> = {
               retries: workConfig.retries || 0,
             };
             if (workConfig.input) {
-              workData.input = await workConfig.input(workData);
+              workData.input = (await workConfig.input(workData)) || {};
               // A work input fn can skip auto scheduling a new record
               // when it explicitly returns a falsish input instead of a dictionary
               if (!workData.input) return null;

package/src/directors/DeliveryAdapter.ts

@@ -19,11 +19,11 @@ export enum DeliveryError {
 }
 
 export interface DeliveryAdapterActions {
-  configurationError: (transactionContext?: any) => DeliveryError;
-  estimatedDeliveryThroughput: (warehousingThroughputTime: number) => Promise<number>;
+  configurationError: (transactionContext?: any) => DeliveryError | null;
+  estimatedDeliveryThroughput: (warehousingThroughputTime: number) => Promise<number | null>;
   isActive: () => boolean;
   isAutoReleaseAllowed: () => boolean;
-  pickUpLocationById: (locationId: string) => Promise<DeliveryLocation>;
+  pickUpLocationById: (locationId: string) => Promise<DeliveryLocation | null>;
   pickUpLocations: () => Promise<DeliveryLocation[]>;
   send: () => Promise<boolean | Work>;
 }