@labdigital/commercetools-mock 2.30.0 → 2.31.0

package/dist/index.js

@@ -3953,6 +3953,9 @@ var OrderUpdateHandler = class extends AbstractUpdateHandler {
   changePaymentState(context, resource, { paymentState }) {
     resource.paymentState = paymentState;
   }
+  changeShipmentState(context, resource, { shipmentState }) {
+    resource.shipmentState = shipmentState;
+  }
   setBillingAddress(context, resource, { address }) {
     resource.billingAddress = createAddress(
       address,
@@ -4504,19 +4507,346 @@ var PaymentRepository = class extends AbstractResourceRepository {
   }
 };
 
-// src/lib/searchQueryTypeChecker.ts
-var validateSearchQuery = (query) => {
-  if (isSearchAndExpression(query)) {
-    query.and.forEach((expr) => validateSearchQuery(expr));
-  } else if (isSearchOrExpression(query)) {
-    query.or.forEach((expr) => validateSearchQuery(expr));
-  } else if (isSearchNotExpression(query)) {
-    validateSearchQuery(query.not);
-  } else if (isSearchFilterExpression(query) || isSearchRangeExpression(query) || isSearchExactExpression(query) || isSearchExistsExpression(query) || isSearchFullTextExpression(query) || isSearchFullTextPrefixExpression(query) || isSearchPrefixExpression(query) || isSearchWildCardExpression(query) || isSearchAnyValue(query)) {
-    return;
-  } else {
-    throw new Error("Unsupported search query expression");
+// src/lib/projectionSearchFilter.ts
+var parseFilterExpression = (filter) => {
+  const exprFunc = generateMatchFunc2(filter);
+  const [source] = filter.split(":", 1);
+  if (source.startsWith("variants.")) {
+    return filterVariants(source, exprFunc);
+  }
+  return filterProduct(source, exprFunc);
+};
+var getLexer2 = (value) => new Lexer(value).token("MISSING", /missing(?![-_a-z0-9]+)/i).token("EXISTS", /exists(?![-_a-z0-9]+)/i).token("RANGE", /range(?![-_a-z0-9]+)/i).token("TO", /to(?![-_a-z0-9]+)/i).token("IDENTIFIER", /[-_.a-z]+/i).token("FLOAT", /\d+\.\d+/).token("INT", /\d+/).token("STRING", /"((?:\\.|[^"\\])*)"/).token("STRING", /'((?:\\.|[^'\\])*)'/).token("COMMA", ",").token("STAR", "*").token("(", "(").token(":", ":").token(")", ")").token('"', '"').token("WS", /\s+/, true);
+var parseFilter = (filter) => {
+  const lexer = getLexer2(filter);
+  const parser = new Parser(lexer).builder().nud("IDENTIFIER", 100, (t) => t.token.match).led(":", 100, ({ left, bp }) => {
+    const parsed = parser.parse({ terminals: [bp - 1] });
+    const expressions = !Array.isArray(parsed) ? [parsed] : parsed;
+    const unique = new Set(expressions.map((expr) => expr.type));
+    if (unique.size > 1) {
+      throw new Error("Invalid expression");
+    }
+    if (expressions.some((expr) => expr.type == "Symbol")) {
+      return {
+        source: left,
+        type: "FilterExpression",
+        children: expressions.map((e) => {
+          if (e.type != "Symbol") {
+            throw new Error("Invalid expression");
+          }
+          return {
+            type: "FilterExpression",
+            match: (obj) => obj === e.value
+          };
+        })
+      };
+    }
+    return {
+      source: left,
+      type: expressions[0].type,
+      children: expressions
+    };
+  }).nud(
+    "STRING",
+    20,
+    (t) => ({
+      type: "Symbol",
+      kind: "string",
+      // @ts-ignore
+      value: t.token.groups[1]
+    })
+  ).nud(
+    "INT",
+    5,
+    (t) => ({
+      type: "Symbol",
+      kind: "int",
+      value: parseInt(t.token.match, 10)
+    })
+  ).nud("STAR", 5, (_) => ({
+    type: "Symbol",
+    kind: "any",
+    value: null
+  })).nud(
+    "EXISTS",
+    10,
+    ({ bp }) => ({
+      type: "FilterExpression",
+      match: (obj) => obj !== void 0
+    })
+  ).nud(
+    "MISSING",
+    10,
+    ({ bp }) => ({
+      type: "FilterExpression",
+      match: (obj) => obj === void 0
+    })
+  ).led("COMMA", 200, ({ left, token, bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    if (Array.isArray(expr)) {
+      return [left, ...expr];
+    } else {
+      return [left, expr];
+    }
+  }).nud("(", 100, (t) => {
+    const expr = parser.parse({ terminals: [")"] });
+    lexer.expect(")");
+    return expr;
+  }).bp(")", 0).led("TO", 20, ({ left, bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    return {
+      start: left.value,
+      stop: expr.value
+    };
+  }).nud("RANGE", 20, ({ bp }) => {
+    let ranges = parser.parse();
+    if (!Array.isArray(ranges)) {
+      ranges = [ranges];
+    }
+    return ranges.map((range) => {
+      let func;
+      if (range.start !== null && range.stop !== null) {
+        func = (obj) => obj >= range.start && obj <= range.stop;
+      } else if (range.start === null && range.stop !== null) {
+        func = (obj) => obj <= range.stop;
+      } else if (range.start !== null && range.stop === null) {
+        func = (obj) => obj >= range.start;
+      } else {
+        func = (obj) => true;
+      }
+      return {
+        type: "RangeExpression",
+        start: range.start,
+        stop: range.stop,
+        match: func
+      };
+    });
+  }).build();
+  return parser.parse();
+};
+var generateMatchFunc2 = (filter) => {
+  const result = parseFilter(filter);
+  if (!result) {
+    throw new Error(`Syntax error while parsing '${filter}'.`);
+  }
+  if (result.type == "TermExpression") {
+    throw new Error(`Syntax error while parsing '${filter}'.`);
+  }
+  return (obj) => {
+    if (!result.children)
+      return false;
+    return result.children.some((c) => c.match(obj));
+  };
+};
+var generateFacetFunc = (filter) => {
+  if (!filter.includes(":")) {
+    return {
+      source: filter,
+      type: "TermExpression"
+    };
+  }
+  return parseFilter(filter);
+};
+var filterProduct = (source, exprFunc) => (p, markMatchingVariants) => {
+  const value = nestedLookup(p, source);
+  return exprFunc(value);
+};
+var filterVariants = (source, exprFunc) => (p, markMatchingVariants) => {
+  const [, ...paths] = source.split(".");
+  const path = paths.join(".");
+  const variants = getVariants(p);
+  for (const variant of variants) {
+    const value = resolveVariantValue(variant, path);
+    if (exprFunc(value)) {
+      if (markMatchingVariants) {
+        for (const v of variants) {
+          v.isMatchingVariant = false;
+        }
+        variant.isMatchingVariant = true;
+      }
+      return true;
+    }
+  }
+  return false;
+};
+var resolveVariantValue = (obj, path) => {
+  if (path === void 0) {
+    return obj;
+  }
+  if (path.startsWith("variants.")) {
+    path = path.substring(path.indexOf(".") + 1);
+  }
+  if (path.startsWith("attributes.")) {
+    const [, attrName, ...rest] = path.split(".");
+    if (!obj.attributes) {
+      return void 0;
+    }
+    for (const attr of obj.attributes) {
+      if (attr.name === attrName) {
+        return nestedLookup(attr.value, rest.join("."));
+      }
+    }
+  }
+  if (path === "price.centAmount") {
+    return obj.prices && obj.prices.length > 0 ? obj.prices[0].value.centAmount : void 0;
+  }
+  return nestedLookup(obj, path);
+};
+var getVariants = (p) => [
+  p.masterVariant,
+  ...p.variants ?? []
+];
+
+// src/lib/productSearchFilter.ts
+var parseSearchQuery = (searchQuery) => {
+  if (isSearchAndExpression(searchQuery)) {
+    return (obj, markMatchingVariant) => searchQuery.and.every((expr) => {
+      const filterFunc = parseSearchQuery(expr);
+      return filterFunc(obj, markMatchingVariant);
+    });
+  }
+  if (isSearchOrExpression(searchQuery)) {
+    return (obj, markMatchingVariant) => searchQuery.or.some((expr) => {
+      const filterFunc = parseSearchQuery(expr);
+      return filterFunc(obj, markMatchingVariant);
+    });
+  }
+  if (isSearchNotExpression(searchQuery)) {
+    return (obj, markMatchingVariant) => !parseSearchQuery(searchQuery.not)(obj, markMatchingVariant);
+  }
+  if (isSearchFilterExpression(searchQuery)) {
+    return (obj, markMatchingVariant) => searchQuery.filter.every((expr) => {
+      const filterFunc = parseSearchQuery(expr);
+      return filterFunc(obj, markMatchingVariant);
+    });
+  }
+  if (isSearchRangeExpression(searchQuery)) {
+    const generateRangeMatchFunc = (value) => {
+      const rangeFilters = [];
+      if (searchQuery.range.gte) {
+        rangeFilters.push(value >= searchQuery.range.gte);
+      }
+      if (searchQuery.range.gt) {
+        rangeFilters.push(value > searchQuery.range.gt);
+      }
+      if (searchQuery.range.lte) {
+        rangeFilters.push(value <= searchQuery.range.lte);
+      }
+      if (searchQuery.range.lt) {
+        rangeFilters.push(value < searchQuery.range.lt);
+      }
+      return rangeFilters.every((filter) => filter);
+    };
+    return generateFieldMatchFunc(generateRangeMatchFunc, searchQuery.range);
+  }
+  if (isSearchExactExpression(searchQuery)) {
+    return generateFieldMatchFunc(
+      (value) => value === searchQuery.exact.value,
+      searchQuery.exact
+    );
+  }
+  if (isSearchExistsExpression(searchQuery)) {
+    return generateFieldMatchFunc((value) => !!value, searchQuery.exists);
+  }
+  if (isSearchFullTextExpression(searchQuery)) {
+    return generateFieldMatchFunc(
+      (value) => value.includes(searchQuery.fullText.value),
+      searchQuery.fullText
+    );
+  }
+  if (isSearchFullTextPrefixExpression(searchQuery)) {
+    return generateFieldMatchFunc(
+      (value) => value.startsWith(searchQuery.fullTextPrefix.value),
+      searchQuery.fullTextPrefix
+    );
+  }
+  if (isSearchPrefixExpression(searchQuery)) {
+    return generateFieldMatchFunc(
+      (value) => value.startsWith(searchQuery.prefix.value),
+      searchQuery.prefix
+    );
+  }
+  if (isSearchWildCardExpression(searchQuery)) {
+    const generateWildcardMatchFunc = (value) => {
+      const wildCardValues = searchQuery.wildcard.value.split("*").filter((v) => !!v);
+      if (searchQuery.wildcard.caseInsensitive) {
+        return wildCardValues.every(
+          (wildCardValue) => value.toLowerCase().includes(wildCardValue.toLowerCase())
+        );
+      }
+      return wildCardValues.every(
+        (wildCardValue) => value.includes(wildCardValue)
+      );
+    };
+    return generateFieldMatchFunc(
+      generateWildcardMatchFunc,
+      searchQuery.wildcard
+    );
+  }
+  throw new Error("Unsupported search query expression");
+};
+var generateFieldMatchFunc = (matchFunc, searchQuery) => {
+  const generateMatchFunc3 = (obj, markMatchingVariants) => {
+    if (searchQuery.field.startsWith("variants.")) {
+      const variantField = searchQuery.field.substring(
+        searchQuery.field.indexOf(".") + 1
+      );
+      const variants = getVariants(obj);
+      for (const variant of variants) {
+        const value = resolveFieldValue(variant, {
+          ...searchQuery,
+          field: variantField
+        });
+        if (matchFunc(value)) {
+          if (markMatchingVariants) {
+            for (const v of variants) {
+              v.isMatchingVariant = false;
+            }
+            variant.isMatchingVariant = true;
+          }
+          return true;
+        }
+      }
+      return false;
+    }
+    return matchFunc(resolveFieldValue(obj, searchQuery));
+  };
+  return generateMatchFunc3;
+};
+var resolveFieldValue = (obj, searchQuery) => {
+  if (searchQuery.field === void 0) {
+    throw new Error("Missing field path in query expression");
   }
+  let fieldPath = searchQuery.field;
+  const language = "language" in searchQuery ? searchQuery.language : void 0;
+  if (fieldPath.startsWith("variants.")) {
+    fieldPath = fieldPath.substring(fieldPath.indexOf(".") + 1);
+  }
+  if (fieldPath.startsWith("attributes.")) {
+    const [, attrName, ...rest] = fieldPath.split(".");
+    if (!obj.attributes) {
+      return void 0;
+    }
+    for (const attr of obj.attributes) {
+      if (attr.name === attrName) {
+        return nestedLookupByLanguage(attr.value, rest.join("."), language);
+      }
+    }
+  }
+  if (fieldPath === "prices.currentCentAmount") {
+    return obj.prices && obj.prices.length > 0 ? obj.prices[0].value.centAmount : void 0;
+  }
+  return nestedLookupByLanguage(obj, fieldPath, language);
+};
+var nestedLookupByLanguage = (obj, path, language) => {
+  const value = nestedLookup(obj, path);
+  if (language && value && typeof value === "object") {
+    const matchingLanguageKey = Object.keys(value).find(
+      (key) => key.toLowerCase().startsWith(language.toLowerCase())
+    );
+    return matchingLanguageKey ? value[matchingLanguageKey] : void 0;
+  }
+  return value;
 };
 var isSearchAndExpression = (expr) => expr.and !== void 0;
 var isSearchOrExpression = (expr) => expr.or !== void 0;
@@ -4529,6 +4859,32 @@ var isSearchFullTextExpression = (expr) => expr.fullText !== void 0;
 var isSearchFullTextPrefixExpression = (expr) => expr.fullTextPrefix !== void 0;
 var isSearchPrefixExpression = (expr) => expr.prefix !== void 0;
 var isSearchWildCardExpression = (expr) => expr.wildcard !== void 0;
+
+// src/lib/searchQueryTypeChecker.ts
+var validateSearchQuery = (query) => {
+  if (isSearchAndExpression2(query)) {
+    query.and.forEach((expr) => validateSearchQuery(expr));
+  } else if (isSearchOrExpression2(query)) {
+    query.or.forEach((expr) => validateSearchQuery(expr));
+  } else if (isSearchNotExpression2(query)) {
+    validateSearchQuery(query.not);
+  } else if (isSearchFilterExpression2(query) || isSearchRangeExpression2(query) || isSearchExactExpression2(query) || isSearchExistsExpression2(query) || isSearchFullTextExpression2(query) || isSearchFullTextPrefixExpression2(query) || isSearchPrefixExpression2(query) || isSearchWildCardExpression2(query) || isSearchAnyValue(query)) {
+    return;
+  } else {
+    throw new Error("Unsupported search query expression");
+  }
+};
+var isSearchAndExpression2 = (expr) => expr.and !== void 0;
+var isSearchOrExpression2 = (expr) => expr.or !== void 0;
+var isSearchNotExpression2 = (expr) => expr.not !== void 0;
+var isSearchFilterExpression2 = (expr) => expr.filter !== void 0;
+var isSearchRangeExpression2 = (expr) => expr.range !== void 0;
+var isSearchExactExpression2 = (expr) => expr.exact !== void 0;
+var isSearchExistsExpression2 = (expr) => expr.exists !== void 0;
+var isSearchFullTextExpression2 = (expr) => expr.fullText !== void 0;
+var isSearchFullTextPrefixExpression2 = (expr) => expr.fullTextPrefix !== void 0;
+var isSearchPrefixExpression2 = (expr) => expr.prefix !== void 0;
+var isSearchWildCardExpression2 = (expr) => expr.wildcard !== void 0;
 var isSearchAnyValue = (expr) => expr.value !== void 0;
 
 // src/priceSelector.ts
@@ -4589,7 +4945,7 @@ var ProductSearch = class {
     this._storage = storage;
   }
   search(projectKey, params) {
-    const resources = this._storage.all(projectKey, "product").map(
+    let resources = this._storage.all(projectKey, "product").map(
       (r) => this.transform(r, params.productProjectionParameters?.staged ?? false)
     ).filter((p) => {
       if (!params.productProjectionParameters?.staged) {
@@ -4597,9 +4953,14 @@ var ProductSearch = class {
       }
       return true;
     });
+    const markMatchingVariant = params.markMatchingVariants ?? false;
     if (params.query) {
       try {
         validateSearchQuery(params.query);
+        const matchFunc = parseSearchQuery(params.query);
+        resources = resources.filter(
+          (resource) => matchFunc(resource, markMatchingVariant)
+        );
       } catch (err) {
         console.error(err);
         throw new CommercetoolsError(
@@ -5576,196 +5937,6 @@ var ProductDiscountUpdateHandler = class extends AbstractUpdateHandler {
   }
 };
 
-// src/lib/projectionSearchFilter.ts
-var parseFilterExpression = (filter) => {
-  const exprFunc = generateMatchFunc2(filter);
-  const [source] = filter.split(":", 1);
-  if (source.startsWith("variants.")) {
-    return filterVariants(source, exprFunc);
-  }
-  return filterProduct(source, exprFunc);
-};
-var getLexer2 = (value) => new Lexer(value).token("MISSING", /missing(?![-_a-z0-9]+)/i).token("EXISTS", /exists(?![-_a-z0-9]+)/i).token("RANGE", /range(?![-_a-z0-9]+)/i).token("TO", /to(?![-_a-z0-9]+)/i).token("IDENTIFIER", /[-_.a-z]+/i).token("FLOAT", /\d+\.\d+/).token("INT", /\d+/).token("STRING", /"((?:\\.|[^"\\])*)"/).token("STRING", /'((?:\\.|[^'\\])*)'/).token("COMMA", ",").token("STAR", "*").token("(", "(").token(":", ":").token(")", ")").token('"', '"').token("WS", /\s+/, true);
-var parseFilter = (filter) => {
-  const lexer = getLexer2(filter);
-  const parser = new Parser(lexer).builder().nud("IDENTIFIER", 100, (t) => t.token.match).led(":", 100, ({ left, bp }) => {
-    const parsed = parser.parse({ terminals: [bp - 1] });
-    const expressions = !Array.isArray(parsed) ? [parsed] : parsed;
-    const unique = new Set(expressions.map((expr) => expr.type));
-    if (unique.size > 1) {
-      throw new Error("Invalid expression");
-    }
-    if (expressions.some((expr) => expr.type == "Symbol")) {
-      return {
-        source: left,
-        type: "FilterExpression",
-        children: expressions.map((e) => {
-          if (e.type != "Symbol") {
-            throw new Error("Invalid expression");
-          }
-          return {
-            type: "FilterExpression",
-            match: (obj) => obj === e.value
-          };
-        })
-      };
-    }
-    return {
-      source: left,
-      type: expressions[0].type,
-      children: expressions
-    };
-  }).nud(
-    "STRING",
-    20,
-    (t) => ({
-      type: "Symbol",
-      kind: "string",
-      // @ts-ignore
-      value: t.token.groups[1]
-    })
-  ).nud(
-    "INT",
-    5,
-    (t) => ({
-      type: "Symbol",
-      kind: "int",
-      value: parseInt(t.token.match, 10)
-    })
-  ).nud("STAR", 5, (_) => ({
-    type: "Symbol",
-    kind: "any",
-    value: null
-  })).nud(
-    "EXISTS",
-    10,
-    ({ bp }) => ({
-      type: "FilterExpression",
-      match: (obj) => obj !== void 0
-    })
-  ).nud(
-    "MISSING",
-    10,
-    ({ bp }) => ({
-      type: "FilterExpression",
-      match: (obj) => obj === void 0
-    })
-  ).led("COMMA", 200, ({ left, token, bp }) => {
-    const expr = parser.parse({ terminals: [bp - 1] });
-    if (Array.isArray(expr)) {
-      return [left, ...expr];
-    } else {
-      return [left, expr];
-    }
-  }).nud("(", 100, (t) => {
-    const expr = parser.parse({ terminals: [")"] });
-    lexer.expect(")");
-    return expr;
-  }).bp(")", 0).led("TO", 20, ({ left, bp }) => {
-    const expr = parser.parse({ terminals: [bp - 1] });
-    return {
-      start: left.value,
-      stop: expr.value
-    };
-  }).nud("RANGE", 20, ({ bp }) => {
-    let ranges = parser.parse();
-    if (!Array.isArray(ranges)) {
-      ranges = [ranges];
-    }
-    return ranges.map((range) => {
-      let func;
-      if (range.start !== null && range.stop !== null) {
-        func = (obj) => obj >= range.start && obj <= range.stop;
-      } else if (range.start === null && range.stop !== null) {
-        func = (obj) => obj <= range.stop;
-      } else if (range.start !== null && range.stop === null) {
-        func = (obj) => obj >= range.start;
-      } else {
-        func = (obj) => true;
-      }
-      return {
-        type: "RangeExpression",
-        start: range.start,
-        stop: range.stop,
-        match: func
-      };
-    });
-  }).build();
-  return parser.parse();
-};
-var generateMatchFunc2 = (filter) => {
-  const result = parseFilter(filter);
-  if (!result) {
-    throw new Error(`Syntax error while parsing '${filter}'.`);
-  }
-  if (result.type == "TermExpression") {
-    throw new Error(`Syntax error while parsing '${filter}'.`);
-  }
-  return (obj) => {
-    if (!result.children)
-      return false;
-    return result.children.some((c) => c.match(obj));
-  };
-};
-var generateFacetFunc = (filter) => {
-  if (!filter.includes(":")) {
-    return {
-      source: filter,
-      type: "TermExpression"
-    };
-  }
-  return parseFilter(filter);
-};
-var filterProduct = (source, exprFunc) => (p, markMatchingVariants) => {
-  const value = nestedLookup(p, source);
-  return exprFunc(value);
-};
-var filterVariants = (source, exprFunc) => (p, markMatchingVariants) => {
-  const [, ...paths] = source.split(".");
-  const path = paths.join(".");
-  const variants = getVariants(p);
-  for (const variant of variants) {
-    const value = resolveVariantValue(variant, path);
-    if (exprFunc(value)) {
-      if (markMatchingVariants) {
-        for (const v of variants) {
-          v.isMatchingVariant = false;
-        }
-        variant.isMatchingVariant = true;
-      }
-      return true;
-    }
-  }
-  return false;
-};
-var resolveVariantValue = (obj, path) => {
-  if (path === void 0) {
-    return obj;
-  }
-  if (path.startsWith("variants.")) {
-    path = path.substring(path.indexOf(".") + 1);
-  }
-  if (path.startsWith("attributes.")) {
-    const [, attrName, ...rest] = path.split(".");
-    if (!obj.attributes) {
-      return void 0;
-    }
-    for (const attr of obj.attributes) {
-      if (attr.name === attrName) {
-        return nestedLookup(attr.value, rest.join("."));
-      }
-    }
-  }
-  if (path === "price.centAmount") {
-    return obj.prices && obj.prices.length > 0 ? obj.prices[0].value.centAmount : void 0;
-  }
-  return nestedLookup(obj, path);
-};
-var getVariants = (p) => [
-  p.masterVariant,
-  ...p.variants ?? []
-];
-
 // src/product-projection-search.ts
 var ProductProjectionSearch = class {
   _storage;