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

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

@@ -1,14 +1,43 @@
-import upsertAssortmentProducts from './upsertAssortmentProducts.js';
-import upsertAssortmentChildren from './upsertAssortmentChildren.js';
-import upsertAssortmentFilters from './upsertAssortmentFilters.js';
-import upsertMedia from './upsertMedia.js';
+import { z } from 'zod';
+import upsertAssortmentProducts, { AssortmentProductSchema } from './upsertAssortmentProducts.js';
+import upsertAssortmentChildren, { AssortmentLinkSchema } from './upsertAssortmentChildren.js';
+import upsertAssortmentFilters, { AssortmentFilterSchema } from './upsertAssortmentFilters.js';
+import upsertMedia, { MediaSchema } from './upsertMedia.js';
 import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
-import createAssortment from './create.js';
+import createAssortment, { AssortmentCreatePayloadSchema } from './create.js';
 import { Modules } from '../../../modules.js';
 import { Services } from '../../../services/index.js';
 
+export const AssortmentUpdatePayloadSchema = z.object({
+  _id: z.string(),
+  specification: z
+    .object({
+      isActive: z.boolean().optional(),
+      isBase: z.boolean().optional(),
+      isRoot: z.boolean().optional(),
+      sequence: z.number().optional(),
+      tags: z.array(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(),
+          }),
+        )
+        .optional(),
+    })
+    .optional(),
+  media: z.array(MediaSchema).optional(),
+  products: z.array(AssortmentProductSchema).optional(),
+  children: z.array(AssortmentLinkSchema).optional(),
+  filters: z.array(AssortmentFilterSchema).optional(),
+});
+
 export default async function updateAssortment(
-  payload: any,
+  payload: z.infer<typeof AssortmentUpdatePayloadSchema>,
   { logger, createShouldUpsertIfIDExists, updateShouldUpsertIfIDNotExists },
   unchainedAPI: { modules: Modules; services: Services },
 ) {
@@ -16,8 +45,19 @@ export default async function updateAssortment(
   const { media, specification, products, children, filters, _id } = payload;
 
   if (!(await modules.assortments.assortmentExists({ assortmentId: _id }))) {
-    if (updateShouldUpsertIfIDNotExists) {
-      return createAssortment(payload, { logger, createShouldUpsertIfIDExists }, unchainedAPI);
+    if (updateShouldUpsertIfIDNotExists && specification) {
+      return createAssortment(
+        {
+          _id,
+          specification,
+          media,
+          products,
+          children,
+          filters,
+        } as z.infer<typeof AssortmentCreatePayloadSchema>,
+        { logger, createShouldUpsertIfIDExists },
+        unchainedAPI,
+      );
     }
     throw new Error(`Can't update non-existing assortment ${_id}`);
   }
@@ -25,7 +65,9 @@ export default async function updateAssortment(
   if (specification) {
     logger.debug('update assortment object', specification);
 
-    specification.tags = convertTagsToLowerCase(specification?.tags);
+    if (specification.tags) {
+      specification.tags = convertTagsToLowerCase(specification.tags!)!;
+    }
 
     await unchainedAPI.modules.assortments.update(_id, { ...specification });
 
@@ -87,3 +129,5 @@ export default async function updateAssortment(
     success: true,
   };
 }
+
+updateAssortment.payloadSchema = AssortmentUpdatePayloadSchema;

package/src/bulk-importer/handlers/assortment/upsertAssortmentChildren.ts

@@ -1,8 +1,25 @@
-import { AssortmentLink } from '@unchainedshop/core-assortments';
+import { z } from 'zod';
 import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
 import { Modules } from '../../../modules.js';
 
-const upsert = async (assortmentLink: AssortmentLink, { modules }: { modules: Modules }) => {
+export const AssortmentLinkSchema = z.object({
+  _id: z.string().optional(),
+  assortmentId: z.string(),
+  tags: z.array(z.string()).optional(),
+  sortKey: z.number().optional(),
+  meta: z.record(z.unknown()).optional(),
+});
+
+const upsert = async (
+  assortmentLink: {
+    _id?: string;
+    parentAssortmentId: string;
+    childAssortmentId: string;
+    tags: string[];
+    sortKey?: number;
+  },
+  { modules }: { modules: Modules },
+) => {
   if (
     !(await modules.assortments.assortmentExists({
       assortmentId: assortmentLink.childAssortmentId,
@@ -14,33 +31,41 @@ const upsert = async (assortmentLink: AssortmentLink, { modules }: { modules: Mo
     const newAssortmentLink = await modules.assortments.links.create(assortmentLink, {
       skipInvalidation: true,
     });
-    return newAssortmentLink;
+    return newAssortmentLink!;
   } catch {
-    return modules.assortments.links.update(assortmentLink._id, assortmentLink, {
+    return (await modules.assortments.links.update(assortmentLink._id!, assortmentLink, {
       skipInvalidation: true,
-    });
+    }))!;
   }
 };
 
 export default async (
-  { children, assortmentId: parentAssortmentId },
+  {
+    children,
+    assortmentId: parentAssortmentId,
+  }: {
+    children: z.infer<typeof AssortmentLinkSchema>[];
+    assortmentId: string;
+  },
   unchainedAPI: { modules: Modules },
 ) => {
   const { modules } = unchainedAPI;
   const assortmentLinkIds = await Promise.all(
-    children.map(async ({ assortmentId: childAssortmentId, ...childrenRest }) => {
-      const tags = convertTagsToLowerCase(childrenRest?.tags);
-      const assortmentLink = await upsert(
-        {
-          ...childrenRest,
-          tags,
-          parentAssortmentId,
-          childAssortmentId,
-        } as AssortmentLink,
-        unchainedAPI,
-      );
-      return assortmentLink._id;
-    }),
+    children.map(
+      async ({ assortmentId: childAssortmentId, sortKey, tags: tagsMixedCase }, sortKeyForced) => {
+        const tags = tagsMixedCase ? convertTagsToLowerCase(tagsMixedCase)! : [];
+        const assortmentLink = await upsert(
+          {
+            sortKey: sortKey ?? sortKeyForced,
+            tags,
+            parentAssortmentId,
+            childAssortmentId,
+          },
+          unchainedAPI,
+        );
+        return assortmentLink._id;
+      },
+    ),
   );
   await modules.assortments.links.deleteMany(
     {

package/src/bulk-importer/handlers/assortment/upsertAssortmentFilters.ts

@@ -1,8 +1,25 @@
-import { AssortmentFilter } from '@unchainedshop/core-assortments';
+import { z } from 'zod';
 import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
 import { Modules } from '../../../modules.js';
 
-const upsert = async (assortmentFilter: AssortmentFilter, { modules }: { modules: Modules }) => {
+export const AssortmentFilterSchema = z.object({
+  _id: z.string().optional(),
+  filterId: z.string(),
+  tags: z.array(z.string()).optional(),
+  sortKey: z.number().optional(),
+  meta: z.record(z.unknown()).optional(),
+});
+
+const upsert = async (
+  assortmentFilter: {
+    _id?: string;
+    filterId: string;
+    tags: string[];
+    assortmentId: string;
+    sortKey: number;
+  },
+  { modules }: { modules: Modules },
+) => {
   if (
     !(await modules.filters.filterExists({
       filterId: assortmentFilter.filterId,
@@ -14,24 +31,35 @@ const upsert = async (assortmentFilter: AssortmentFilter, { modules }: { modules
     const newAssortmentFilter = await modules.assortments.filters.create(assortmentFilter);
     return newAssortmentFilter;
   } catch {
-    return modules.assortments.filters.update(assortmentFilter._id, assortmentFilter);
+    return await modules.assortments.filters.update(assortmentFilter._id!, assortmentFilter);
   }
 };
 
-export default async ({ filters, assortmentId }, unchainedAPI: { modules: Modules }) => {
+export default async (
+  {
+    filters,
+    assortmentId,
+  }: {
+    filters: z.infer<typeof AssortmentFilterSchema>[];
+    assortmentId: string;
+  },
+  unchainedAPI: { modules: Modules },
+) => {
   const { modules } = unchainedAPI;
   const assortmentFilterIds = await Promise.all(
-    filters.map(async (filter: AssortmentFilter) => {
-      const tags = convertTagsToLowerCase(filter?.tags);
+    filters.map(async ({ tags: tagsMixedCase, sortKey, ...rest }, forcedSortKey) => {
+      const tags = tagsMixedCase ? convertTagsToLowerCase(tagsMixedCase)! : [];
+
       const assortmentFilter = await upsert(
         {
-          ...filter,
-          tags,
+          ...rest,
           assortmentId,
+          tags,
+          sortKey: sortKey ?? forcedSortKey,
         },
         unchainedAPI,
       );
-      return assortmentFilter._id;
+      return assortmentFilter!._id;
     }),
   );
 

package/src/bulk-importer/handlers/assortment/upsertAssortmentProducts.ts

@@ -1,8 +1,26 @@
+import { z } from 'zod';
 import { AssortmentProduct } from '@unchainedshop/core-assortments';
 import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
 import { Modules } from '../../../modules.js';
 
-const upsert = async (assortmentProduct: AssortmentProduct, unchainedAPI: { modules: Modules }) => {
+export const AssortmentProductSchema = z.object({
+  _id: z.string().optional(),
+  productId: z.string(),
+  tags: z.array(z.string()).optional(),
+  sortKey: z.number().optional(),
+  meta: z.record(z.any()).optional(),
+});
+
+const upsert = async (
+  assortmentProduct: {
+    _id?: string;
+    productId: string;
+    tags: string[];
+    assortmentId: string;
+    sortKey: number;
+  },
+  unchainedAPI: { modules: Modules },
+) => {
   const { modules } = unchainedAPI;
   if (
     !(await modules.products.productExists({
@@ -12,26 +30,34 @@ const upsert = async (assortmentProduct: AssortmentProduct, unchainedAPI: { modu
     throw new Error(`Can't link non-existing product ${assortmentProduct.productId}`);
   }
   try {
-    const newAssortmentProduct = await modules.assortments.products.create(assortmentProduct, {
+    const newAssortmentProduct = (await modules.assortments.products.create(assortmentProduct, {
       skipInvalidation: true,
-    });
+    })) as AssortmentProduct;
     return newAssortmentProduct;
   } catch {
-    return modules.assortments.products.update(assortmentProduct._id, assortmentProduct, {
+    return (await modules.assortments.products.update(assortmentProduct._id!, assortmentProduct, {
       skipInvalidation: true,
-    });
+    })) as AssortmentProduct;
   }
 };
 
-export default async ({ products, assortmentId }, unchainedAPI: { modules: Modules }) => {
+export default async (
+  {
+    products,
+    assortmentId,
+  }: { products: z.infer<typeof AssortmentProductSchema>[]; assortmentId: string },
+  unchainedAPI: { modules: Modules },
+) => {
   const { modules } = unchainedAPI;
   const assortmentProductIds = await Promise.all(
-    products.map(async (product: AssortmentProduct) => {
-      const tags = convertTagsToLowerCase(product?.tags);
+    products.map(async ({ tags: tagsMixedCase, sortKey, ...rest }, forcedSortKey) => {
+      const tags = tagsMixedCase ? convertTagsToLowerCase(tagsMixedCase)! : [];
+
       const assortmentProduct = await upsert(
         {
-          ...product,
+          ...rest,
           tags,
+          sortKey: sortKey ?? forcedSortKey,
           assortmentId,
         },
         unchainedAPI,

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

@@ -1,20 +1,38 @@
+import { z } from 'zod';
 import { Services } from '../../../services/index.js';
 import { Modules } from '../../../modules.js';
-import upsertAsset from '../../upsertAsset.js';
+import upsertAsset, { AssetSchema } from '../../upsertAsset.js';
+import { AssortmentMediaType } from '@unchainedshop/core-assortments';
+
+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 upsertMediaObject = async (media, unchainedAPI: { modules: Modules; services: Services }) => {
   const { modules } = unchainedAPI;
   try {
-    const assortmentMedia = await modules.assortments.media.create(media);
+    const assortmentMedia = (await modules.assortments.media.create(media)) as AssortmentMediaType;
     return assortmentMedia;
   } catch {
     const { _id, ...mediaData } = media;
-    return modules.assortments.media.update(_id, mediaData);
+    return (await modules.assortments.media.update(_id, mediaData)) as AssortmentMediaType;
   }
 };
 
 export default async (
-  { media, assortmentId },
+  { media, assortmentId }: { media: z.infer<typeof MediaSchema>[]; assortmentId: string },
   unchainedAPI: { modules: Modules; services: Services },
 ) => {
   const { modules } = unchainedAPI;
@@ -36,7 +54,7 @@ export default async (
         unchainedAPI,
       );
 
-      if (!mediaObject) throw new Error(`Unable to create media object ${mediaObject._id}`);
+      if (!mediaObject) throw new Error(`Unable to create media object ${mediaData._id}`);
 
       if (content) {
         await modules.assortments.media.texts.updateMediaTexts(

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

@@ -1,5 +1,33 @@
+import { z } from 'zod';
 import { Modules } from '../../../modules.js';
 
+export const LocalizedContentSchema = z.record(
+  z.string(), // locale
+  z.object({
+    title: z.string().optional(),
+    subtitle: z.string().optional(),
+  }),
+);
+
+export const FilterCreatePayloadSchema = z.object({
+  _id: z.string(),
+  specification: z.object({
+    type: z.string(),
+    key: z.string(),
+    isActive: z.boolean().optional(),
+    options: z
+      .array(
+        z.object({
+          value: z.string(),
+          content: LocalizedContentSchema.optional(),
+        }),
+      )
+      .optional(),
+    meta: z.record(z.unknown()).optional(),
+    content: LocalizedContentSchema,
+  }),
+});
+
 export default async function createFilter(
   payload: any,
   { logger, createShouldUpsertIfIDExists },

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

@@ -1,7 +1,12 @@
+import { z } from 'zod';
 import { Modules } from '../../../modules.js';
 
+export const FilterRemovePayloadSchema = z.object({
+  _id: z.string(),
+});
+
 export default async function removeFilter(
-  payload: any,
+  payload: z.infer<typeof FilterRemovePayloadSchema>,
   { logger },
   unchainedAPI: { modules: Modules },
 ) {

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

@@ -1,5 +1,32 @@
-import { Modules } from '../../../modules.js';
+import { z } from 'zod';
 import createFilter from './create.js';
+import { Modules } from '../../../modules.js';
+
+export const LocalizedContentSchema = z.record(
+  z.string(), // locale
+  z.object({
+    title: z.string().optional(),
+    subtitle: z.string().optional(),
+  }),
+);
+export const FilterUpdatePayloadSchema = z.object({
+  _id: z.string(),
+  specification: z.object({
+    type: z.string(),
+    key: z.string(),
+    isActive: z.boolean().optional(),
+    options: z
+      .array(
+        z.object({
+          value: z.string(),
+          content: LocalizedContentSchema.optional(),
+        }),
+      )
+      .optional(),
+    meta: z.record(z.unknown()).optional(),
+    content: LocalizedContentSchema,
+  }),
+});
 
 export default async function updateFilter(
   payload: any,

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

@@ -1,22 +1,120 @@
+import { z } from 'zod';
 import { Modules } from '../../../modules.js';
 import { Services } from '../../../services/index.js';
-import upsertVariations from './upsertVariations.js';
+import upsertVariations, { ProductVariationSchema } from './upsertVariations.js';
 import upsertMedia from './upsertMedia.js';
-import transformSpecificationToProductStructure from './transformSpecificationToProductStructure.js';
+import { MediaSchema } from '../assortment/upsertMedia.js';
+import convertTagsToLowerCase from '../utils/convertTagsToLowerCase.js';
+
+export const ProductCreateSpecificationSchema = z.object({
+  type: z.string(),
+  sequence: z.number(),
+  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(),
+    }),
+  ),
+  variationResolvers: z
+    .array(
+      z.object({
+        vector: z.record(z.string()),
+        productId: z.string(),
+      }),
+    )
+    .optional(),
+});
+
+export const ProductCreatePayloadSchema = z.object({
+  _id: z.string(),
+  specification: ProductCreateSpecificationSchema,
+  media: z.array(MediaSchema).optional(),
+  variations: z.array(ProductVariationSchema).optional(),
+});
+
+const transformSpecification = (specification: z.infer<typeof ProductCreateSpecificationSchema>) => {
+  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 createProduct(
-  payload: any,
+  payload: z.infer<typeof ProductCreatePayloadSchema>,
   { 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);
+  const productData = transformSpecification(specification);
   logger.debug('create product object', productData);
   try {
     await modules.products.create({
@@ -33,7 +131,7 @@ export default async function createProduct(
   }
 
   if (!(await modules.products.productExists({ productId: _id }))) {
-    throw new Error(`Can't create product ${_id}, fields missing?`);
+    throw new Error(`Can't create product ${_id}`);
   }
 
   if (specification.content) {
@@ -68,3 +166,5 @@ export default async function createProduct(
     success: true,
   };
 }
+
+createProduct.payloadSchema = ProductCreatePayloadSchema;

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

@@ -1,8 +1,12 @@
+import { z } from 'zod';
 import { Modules } from '../../../modules.js';
 import { Services } from '../../../services/index.js';
 
+export const ProductRemovePayloadSchema = z.object({
+  _id: z.string(),
+});
 export default async function removeProduct(
-  payload: any,
+  payload: z.infer<typeof ProductRemovePayloadSchema>,
   { logger },
   unchainedAPI: { modules: Modules; services: Services },
 ) {
@@ -19,3 +23,5 @@ export default async function removeProduct(
     success: true,
   };
 }
+
+removeProduct.payloadSchema = ProductRemovePayloadSchema;