@labdigital/commercetools-mock 2.2.0 → 2.4.0

package/dist/index.cjs

@@ -2760,6 +2760,22 @@ var CategoryRepository = class extends AbstractResourceRepository {
     changeSlug: (context, resource, { slug }) => {
       resource.slug = slug;
     },
+    changeName: (context, resource, { name }) => {
+      resource.name = name;
+    },
+    changeParent: (context, resource, { parent }) => {
+      const category = this._storage.getByResourceIdentifier(
+        context.projectKey,
+        parent
+      );
+      if (!category) {
+        throw new Error("No category found for reference");
+      }
+      resource.parent = {
+        typeId: "category",
+        id: category.id
+      };
+    },
     setKey: (context, resource, { key }) => {
       resource.key = key;
     },
@@ -3807,20 +3823,63 @@ var ProductRepository = class extends AbstractResourceRepository {
         id: draft.productType.id || ""
       };
     }
+    const categoryReferences = [];
+    draft.categories?.forEach((category) => {
+      if (category) {
+        categoryReferences.push(
+          getReferenceFromResourceIdentifier(
+            category,
+            context.projectKey,
+            this._storage
+          )
+        );
+      } else {
+        throw new CommercetoolsError(
+          {
+            code: "InvalidJsonInput",
+            message: "Request body does not contain valid JSON.",
+            detailedErrorMessage: "categories: JSON object expected."
+          },
+          400
+        );
+      }
+    });
+    let taxCategoryReference = void 0;
+    if (draft.taxCategory) {
+      taxCategoryReference = getReferenceFromResourceIdentifier(
+        draft.taxCategory,
+        context.projectKey,
+        this._storage
+      );
+    }
+    let productStateReference = void 0;
+    if (draft.state) {
+      productStateReference = getReferenceFromResourceIdentifier(
+        draft.state,
+        context.projectKey,
+        this._storage
+      );
+    }
     const productData = {
       name: draft.name,
       slug: draft.slug,
-      categories: [],
+      description: draft.description,
+      categories: categoryReferences,
       masterVariant: variantFromDraft(1, draft.masterVariant),
       variants: draft.variants?.map(
         (variant, index) => variantFromDraft(index + 2, variant)
       ) ?? [],
+      metaTitle: draft.metaTitle,
+      metaDescription: draft.metaDescription,
+      metaKeywords: draft.metaKeywords,
       searchKeywords: draft.searchKeywords ?? {}
     };
     const resource = {
       ...getBaseResourceProperties(),
       key: draft.key,
       productType,
+      taxCategory: taxCategoryReference,
+      state: productStateReference,
       masterData: {
         current: productData,
         staged: productData,
@@ -3881,6 +3940,47 @@ var ProductRepository = class extends AbstractResourceRepository {
       checkForStagedChanges(resource);
       return resource;
     },
+    setAttributeInAllVariants: (context, resource, { name, value, staged }) => {
+      const setAttrInAllVariants = (data) => {
+        if (!data.masterVariant.attributes) {
+          data.masterVariant.attributes = [];
+        }
+        const existingAttr = data.masterVariant.attributes?.find(
+          (attr) => attr.name === name
+        );
+        if (existingAttr) {
+          existingAttr.value = value;
+        } else {
+          data.masterVariant.attributes.push({
+            name,
+            value
+          });
+        }
+        data.variants.forEach((variant) => {
+          if (!variant.attributes) {
+            variant.attributes = [];
+          }
+          const existingAttr2 = variant.attributes.find(
+            (attr) => attr.name === name
+          );
+          if (existingAttr2) {
+            existingAttr2.value = value;
+          } else {
+            variant.attributes.push({
+              name,
+              value
+            });
+          }
+        });
+      };
+      const onlyStaged = staged !== void 0 ? staged : true;
+      setAttrInAllVariants(resource.masterData.staged);
+      if (!onlyStaged) {
+        setAttrInAllVariants(resource.masterData.current);
+      }
+      checkForStagedChanges(resource);
+      return resource;
+    },
     setDescription: (context, resource, { description, staged }) => {
       const onlyStaged = staged !== void 0 ? staged : true;
       resource.masterData.staged.description = description;
@@ -4012,7 +4112,7 @@ var ProductRepository = class extends AbstractResourceRepository {
       return resource;
     },
     addPrice: (context, resource, { variantId, sku, price, staged }) => {
-      const addVariantPrice = (data) => {
+      const addVariantPrice = (data, priceToAdd2) => {
         const { variant, isMasterVariant, variantIndex } = getVariant(
           data,
           variantId,
@@ -4024,9 +4124,9 @@ var ProductRepository = class extends AbstractResourceRepository {
           );
         }
         if (variant.prices === void 0) {
-          variant.prices = [priceFromDraft(price)];
+          variant.prices = [priceToAdd2];
         } else {
-          variant.prices.push(priceFromDraft(price));
+          variant.prices.push(priceToAdd2);
         }
         if (isMasterVariant) {
           data.masterVariant = variant;
@@ -4034,10 +4134,11 @@ var ProductRepository = class extends AbstractResourceRepository {
           data.variants[variantIndex] = variant;
         }
       };
+      const priceToAdd = priceFromDraft(price);
       const onlyStaged = staged !== void 0 ? staged : true;
-      addVariantPrice(resource.masterData.staged);
+      addVariantPrice(resource.masterData.staged, priceToAdd);
       if (!onlyStaged) {
-        addVariantPrice(resource.masterData.current);
+        addVariantPrice(resource.masterData.current, priceToAdd);
       }
       checkForStagedChanges(resource);
       return resource;
@@ -4118,21 +4219,270 @@ var ProductRepository = class extends AbstractResourceRepository {
       }
       checkForStagedChanges(resource);
       return resource;
+    },
+    changeName: (context, resource, { name, staged }) => {
+      const onlyStaged = staged !== void 0 ? staged : true;
+      resource.masterData.staged.name = name;
+      if (!onlyStaged) {
+        resource.masterData.current.name = name;
+      }
+      checkForStagedChanges(resource);
+      return resource;
+    },
+    changeSlug: (context, resource, { slug, staged }) => {
+      const onlyStaged = staged !== void 0 ? staged : true;
+      resource.masterData.staged.slug = slug;
+      if (!onlyStaged) {
+        resource.masterData.current.slug = slug;
+      }
+      checkForStagedChanges(resource);
+      return resource;
+    },
+    setMetaTitle: (context, resource, { metaTitle, staged }) => {
+      const onlyStaged = staged !== void 0 ? staged : true;
+      resource.masterData.staged.metaTitle = metaTitle;
+      if (!onlyStaged) {
+        resource.masterData.current.metaTitle = metaTitle;
+      }
+      checkForStagedChanges(resource);
+      return resource;
+    },
+    setMetaDescription: (context, resource, { metaDescription, staged }) => {
+      const onlyStaged = staged !== void 0 ? staged : true;
+      resource.masterData.staged.metaDescription = metaDescription;
+      if (!onlyStaged) {
+        resource.masterData.current.metaDescription = metaDescription;
+      }
+      checkForStagedChanges(resource);
+      return resource;
+    },
+    setMetaKeywords: (context, resource, { metaKeywords, staged }) => {
+      const onlyStaged = staged !== void 0 ? staged : true;
+      resource.masterData.staged.metaKeywords = metaKeywords;
+      if (!onlyStaged) {
+        resource.masterData.current.metaKeywords = metaKeywords;
+      }
+      checkForStagedChanges(resource);
+      return resource;
+    },
+    addVariant: (context, resource, {
+      sku,
+      key,
+      prices,
+      images,
+      attributes,
+      staged,
+      assets
+    }) => {
+      const variantDraft = {
+        sku,
+        key,
+        prices,
+        images,
+        attributes,
+        assets
+      };
+      const dataStaged = resource.masterData.staged;
+      const allVariants = [
+        dataStaged.masterVariant,
+        ...dataStaged.variants ?? []
+      ];
+      const maxId = allVariants.reduce(
+        (max, element) => element.id > max ? element.id : max,
+        0
+      );
+      const variant = variantFromDraft(maxId + 1, variantDraft);
+      dataStaged.variants.push(variant);
+      const onlyStaged = staged !== void 0 ? staged : true;
+      if (!onlyStaged) {
+        resource.masterData.current.variants.push(variant);
+      }
+      checkForStagedChanges(resource);
+      return resource;
+    },
+    removeVariant: (context, resource, { id, sku, staged }) => {
+      const removeVariant = (data) => {
+        const { variant, isMasterVariant, variantIndex } = getVariant(
+          data,
+          id,
+          sku
+        );
+        if (!variant) {
+          throw new Error(
+            `Variant with id ${id} or sku ${sku} not found on product ${resource.id}`
+          );
+        }
+        if (isMasterVariant) {
+          throw new Error(
+            `Can not remove the variant [ID:${id}] for [Product:${resource.id}] since it's the master variant`
+          );
+        }
+        data.variants.splice(variantIndex, 1);
+      };
+      const onlyStaged = staged !== void 0 ? staged : true;
+      removeVariant(resource.masterData.staged);
+      if (!onlyStaged) {
+        removeVariant(resource.masterData.current);
+      }
+      checkForStagedChanges(resource);
+      return resource;
+    },
+    changeMasterVariant: (context, resource, { variantId, sku, staged }) => {
+      const setMaster = (data) => {
+        const { variant, isMasterVariant, variantIndex } = getVariant(
+          data,
+          variantId,
+          sku
+        );
+        if (!variant) {
+          throw new Error(
+            `Variant with id ${variantId} or sku ${sku} not found on product ${resource.id}`
+          );
+        }
+        if (!isMasterVariant) {
+          const masterVariantPrev = data.masterVariant;
+          data.masterVariant = variant;
+          data.variants.splice(variantIndex, 1);
+          data.variants.push(masterVariantPrev);
+        }
+      };
+      const onlyStaged = staged !== void 0 ? staged : true;
+      setMaster(resource.masterData.staged);
+      if (!onlyStaged) {
+        setMaster(resource.masterData.current);
+      }
+      checkForStagedChanges(resource);
+      return resource;
+    },
+    setTaxCategory: (context, resource, { taxCategory }) => {
+      let taxCategoryReference = void 0;
+      if (taxCategory) {
+        taxCategoryReference = getReferenceFromResourceIdentifier(
+          taxCategory,
+          context.projectKey,
+          this._storage
+        );
+      } else {
+        throw new CommercetoolsError(
+          {
+            code: "InvalidJsonInput",
+            message: "Request body does not contain valid JSON.",
+            detailedErrorMessage: "actions -> taxCategory: Missing required value"
+          },
+          400
+        );
+      }
+      resource.taxCategory = taxCategoryReference;
+      return resource;
+    },
+    addToCategory: (context, resource, { category, staged, orderHint }) => {
+      const addCategory = (data) => {
+        if (category) {
+          data.categories.push(
+            getReferenceFromResourceIdentifier(
+              category,
+              context.projectKey,
+              this._storage
+            )
+          );
+        } else {
+          throw new CommercetoolsError(
+            {
+              code: "InvalidJsonInput",
+              message: "Request body does not contain valid JSON.",
+              detailedErrorMessage: "actions -> category: Missing required value"
+            },
+            400
+          );
+        }
+      };
+      const onlyStaged = staged !== void 0 ? staged : true;
+      addCategory(resource.masterData.staged);
+      if (!onlyStaged) {
+        addCategory(resource.masterData.current);
+      }
+      checkForStagedChanges(resource);
+      return resource;
+    },
+    removeFromCategory: (context, resource, { category, staged }) => {
+      const removeCategory = (data) => {
+        if (category) {
+          const resolvedCategory = getReferenceFromResourceIdentifier(
+            category,
+            context.projectKey,
+            this._storage
+          );
+          const foundCategory = data.categories.find(
+            (productCategory) => {
+              if (productCategory.id == resolvedCategory.id) {
+                return productCategory;
+              }
+              return false;
+            }
+          );
+          if (!foundCategory) {
+            throw new CommercetoolsError(
+              {
+                code: "InvalidOperation",
+                message: `Cannot remove from category '${resolvedCategory.id}' because product '${resource.masterData.current.name}' is not in that category.`
+              },
+              400
+            );
+          }
+          data.categories = data.categories.filter(
+            (productCategory) => {
+              if (productCategory.id == resolvedCategory.id) {
+                return false;
+              }
+              return true;
+            }
+          );
+        } else {
+          throw new CommercetoolsError(
+            {
+              code: "InvalidJsonInput",
+              message: "Request body does not contain valid JSON.",
+              detailedErrorMessage: "actions -> category: Missing required value"
+            },
+            400
+          );
+        }
+      };
+      const onlyStaged = staged !== void 0 ? staged : true;
+      removeCategory(resource.masterData.staged);
+      if (!onlyStaged) {
+        removeCategory(resource.masterData.current);
+      }
+      checkForStagedChanges(resource);
+      return resource;
+    },
+    transitionState: (context, resource, { state, force }) => {
+      let productStateReference = void 0;
+      if (state) {
+        productStateReference = getReferenceFromResourceIdentifier(
+          state,
+          context.projectKey,
+          this._storage
+        );
+        resource.state = productStateReference;
+      } else {
+        throw new CommercetoolsError(
+          {
+            code: "InvalidJsonInput",
+            message: "Request body does not contain valid JSON.",
+            detailedErrorMessage: "actions -> state: Missing required value"
+          },
+          400
+        );
+      }
+      return resource;
     }
-    // 'changeName': () => {},
-    // 'changeSlug': () => {},
-    // 'addVariant': () => {},
-    // 'removeVariant': () => {},
-    // 'changeMasterVariant': () => {},
     // 'setPrices': () => {},
     // 'setProductPriceCustomType': () => {},
     // 'setProductPriceCustomField': () => {},
     // 'setDiscountedPrice': () => {},
     // 'setAttributeInAllVariants': () => {},
-    // 'addToCategory': () => {},
     // 'setCategoryOrderHint': () => {},
-    // 'removeFromCategory': () => {},
-    // 'setTaxCategory': () => {},
     // 'setSku': () => {},
     // 'setProductVariantKey': () => {},
     // 'setImageLabel': () => {},
@@ -4147,12 +4497,8 @@ var ProductRepository = class extends AbstractResourceRepository {
     // 'setAssetCustomType': () => {},
     // 'setAssetCustomField': () => {},
     // 'setSearchKeywords': () => {},
-    // 'setMetaTitle': () => {},
-    // 'setMetaDescription': () => {},
-    // 'setMetaKeywords': () => {},
     // 'revertStagedChanges': () => {},
     // 'revertStagedVariantChanges': () => {},
-    // 'transitionState': () => {},
   };
 };
 var checkForStagedChanges = (product) => {
@@ -4186,6 +4532,7 @@ var getVariant = (productData, variantId, sku) => {
 var variantFromDraft = (variantId, variant) => ({
   id: variantId,
   sku: variant?.sku,
+  key: variant?.key,
   attributes: variant?.attributes ?? [],
   prices: variant?.prices?.map(priceFromDraft),
   assets: [],
@@ -4193,6 +4540,7 @@ var variantFromDraft = (variantId, variant) => ({
 });
 var priceFromDraft = (draft) => ({
   id: (0, import_uuid6.v4)(),
+  key: draft.key,
   country: draft.country,
   value: createTypedMoney(draft.value)
 });