@labdigital/commercetools-mock 0.7.1 → 0.8.0

package/dist/index.js

@@ -820,6 +820,21 @@ var getBaseResourceProperties = () => {
     version: 0
   };
 };
+var nestedLookup = (obj, path) => {
+  if (!path || path === "") {
+    return obj;
+  }
+  const parts = path.split(".");
+  let val = obj;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (val == void 0) {
+      return void 0;
+    }
+    val = val[part];
+  }
+  return val;
+};
 var QueryParamsAsArray = (input) => {
   if (input == void 0) {
     return [];
@@ -2909,38 +2924,71 @@ var parseFilterExpression = (filter, staged) => {
 var getLexer2 = (value) => {
   return new import_perplex2.default(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 generateMatchFunc2 = (filter) => {
+var parseFilter = (filter) => {
   const lexer = getLexer2(filter);
   const parser = new import_pratt2.default(lexer).builder().nud("IDENTIFIER", 100, (t) => {
     return t.token.match;
   }).led(":", 100, ({ left, bp }) => {
-    const expr = parser.parse({ terminals: [bp - 1] });
-    if (Array.isArray(expr)) {
-      return (obj) => {
-        return expr.includes(obj);
-      };
+    let parsed = parser.parse({ terminals: [bp - 1] });
+    let expressions;
+    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 (typeof expr === "function") {
-      return (obj) => {
-        return expr(obj);
+    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) => {
+              return obj === e.value;
+            }
+          };
+        })
       };
     }
-    return (obj) => {
-      return obj === expr;
+    return {
+      source: left,
+      type: expressions[0].type,
+      children: expressions
     };
   }).nud("STRING", 20, (t) => {
-    return t.token.groups[1];
+    return {
+      type: "Symbol",
+      kind: "string",
+      value: t.token.groups[1]
+    };
   }).nud("INT", 5, (t) => {
-    return parseInt(t.token.match, 10);
+    return {
+      type: "Symbol",
+      kind: "int",
+      value: parseInt(t.token.match, 10)
+    };
   }).nud("STAR", 5, (t) => {
-    return null;
+    return {
+      type: "Symbol",
+      kind: "any",
+      value: null
+    };
   }).nud("EXISTS", 10, ({ bp }) => {
-    return (val) => {
-      return val !== void 0;
+    return {
+      type: "FilterExpression",
+      match: (obj) => {
+        return obj !== void 0;
+      }
     };
   }).nud("MISSING", 10, ({ bp }) => {
-    return (val) => {
-      return val === void 0;
+    return {
+      type: "FilterExpression",
+      match: (obj) => {
+        return obj === void 0;
+      }
     };
   }).led("COMMA", 200, ({ left, token, bp }) => {
     const expr = parser.parse({ terminals: [bp - 1] });
@@ -2949,38 +2997,74 @@ var generateMatchFunc2 = (filter) => {
     } 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 [left, expr];
+    return {
+      start: left.value,
+      stop: expr.value
+    };
   }).nud("RANGE", 20, ({ bp }) => {
-    lexer.next();
-    const [start, stop] = parser.parse();
-    console.log(start, stop);
-    if (start !== null && stop !== null) {
-      return (obj) => {
-        return obj >= start && obj <= stop;
-      };
-    } else if (start === null && stop !== null) {
-      return (obj) => {
-        return obj <= stop;
-      };
-    } else if (start !== null && stop === null) {
-      return (obj) => {
-        return obj >= start;
-      };
-    } else {
-      return (obj) => {
-        return true;
-      };
+    let ranges = parser.parse();
+    if (!Array.isArray(ranges)) {
+      ranges = [ranges];
     }
+    return ranges.map((range) => {
+      let func = void 0;
+      if (range.start !== null && range.stop !== null) {
+        func = (obj) => {
+          return obj >= range.start && obj <= range.stop;
+        };
+      } else if (range.start === null && range.stop !== null) {
+        func = (obj) => {
+          return obj <= range.stop;
+        };
+      } else if (range.start !== null && range.stop === null) {
+        func = (obj) => {
+          return obj >= range.start;
+        };
+      } else {
+        func = (obj) => {
+          return true;
+        };
+      }
+      return {
+        type: "RangeExpression",
+        start: range.start,
+        stop: range.stop,
+        match: func
+      };
+    });
   }).build();
-  const result = parser.parse();
-  if (typeof result !== "function") {
+  return parser.parse();
+};
+var generateMatchFunc2 = (filter) => {
+  const result = parseFilter(filter);
+  if (!result) {
     const lines = filter.split("\n");
     const column = lines[lines.length - 1].length;
     throw new Error(`Syntax error while parsing '${filter}'.`);
   }
-  return result;
+  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) => {
   return (p, markMatchingVariants) => {
@@ -3010,6 +3094,9 @@ 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) {
@@ -3026,21 +3113,6 @@ var resolveVariantValue = (obj, path) => {
   }
   return nestedLookup(obj, path);
 };
-var nestedLookup = (obj, path) => {
-  if (!path || path === "") {
-    return obj;
-  }
-  const parts = path.split(".");
-  let val = obj;
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (val == void 0) {
-      return void 0;
-    }
-    val = val[part];
-  }
-  return val;
-};
 var getVariants = (p, staged) => {
   var _a, _b, _c, _d;
   return [
@@ -3133,6 +3205,7 @@ var ProductProjectionSearch = class {
         );
       }
     }
+    const facets = this.getFacets(params, resources);
     if (params["filter.query"]) {
       try {
         const filters = params["filter.query"].map(
@@ -3166,7 +3239,7 @@ var ProductProjectionSearch = class {
       offset,
       limit,
       results: resources.map(this.transform),
-      facets: {}
+      facets
     };
   }
   transform(product) {
@@ -3184,6 +3257,145 @@ var ProductProjectionSearch = class {
       productType: product.productType
     };
   }
+  getFacets(params, products) {
+    if (!params.facet)
+      return {};
+    const staged = false;
+    const result = {};
+    for (const facet of params.facet) {
+      const expression = generateFacetFunc(facet);
+      if (expression.type === "TermExpression") {
+        result[facet] = this.termFacet(expression.source, products, staged);
+      }
+      if (expression.type === "RangeExpression") {
+        result[expression.source] = this.rangeFacet(
+          expression.source,
+          expression.children,
+          products,
+          staged
+        );
+      }
+      if (expression.type === "FilterExpression") {
+        result[expression.source] = this.filterFacet(
+          expression.source,
+          expression.children,
+          products,
+          staged
+        );
+      }
+    }
+    return result;
+  }
+  termFacet(facet, products, staged) {
+    const result = {
+      type: "terms",
+      dataType: "text",
+      missing: 0,
+      total: 0,
+      other: 0,
+      terms: []
+    };
+    const terms = {};
+    if (facet.startsWith("variants.")) {
+      products.forEach((p) => {
+        const variants = getVariants(p, staged);
+        variants.forEach((v) => {
+          result.total++;
+          let value = resolveVariantValue(v, facet);
+          if (value === void 0) {
+            result.missing++;
+          } else {
+            if (typeof value === "number") {
+              value = Number(value).toFixed(1);
+            }
+            terms[value] = value in terms ? terms[value] + 1 : 1;
+          }
+        });
+      });
+    } else {
+      products.forEach((p) => {
+        const value = nestedLookup(p, facet);
+        result.total++;
+        if (value === void 0) {
+          result.missing++;
+        } else {
+          terms[value] = value in terms ? terms[value] + 1 : 1;
+        }
+      });
+    }
+    for (const term in terms) {
+      result.terms.push({
+        term,
+        count: terms[term]
+      });
+    }
+    return result;
+  }
+  filterFacet(source, filters, products, staged) {
+    let count = 0;
+    if (source.startsWith("variants.")) {
+      for (const p of products) {
+        for (const v of getVariants(p, staged)) {
+          const val = resolveVariantValue(v, source);
+          if (filters == null ? void 0 : filters.some((f) => f.match(val))) {
+            count++;
+          }
+        }
+      }
+    } else {
+      throw new Error("not supported");
+    }
+    return {
+      type: "filter",
+      count
+    };
+  }
+  rangeFacet(source, ranges, products, staged) {
+    const counts = (ranges == null ? void 0 : ranges.map((range) => {
+      if (source.startsWith("variants.")) {
+        const values = [];
+        for (const p of products) {
+          for (const v of getVariants(p, staged)) {
+            const val = resolveVariantValue(v, source);
+            if (val === void 0) {
+              continue;
+            }
+            if (range.match(val)) {
+              values.push(val);
+            }
+          }
+        }
+        const numValues = values.length;
+        return {
+          type: "double",
+          from: range.start || 0,
+          fromStr: range.start !== null ? Number(range.start).toFixed(1) : "",
+          to: range.stop || 0,
+          toStr: range.stop !== null ? Number(range.stop).toFixed(1) : "",
+          count: numValues,
+          total: values.reduce((a, b) => a + b, 0),
+          min: numValues > 0 ? Math.min(...values) : 0,
+          max: numValues > 0 ? Math.max(...values) : 0,
+          mean: numValues > 0 ? mean(values) : 0
+        };
+      } else {
+        throw new Error("not supported");
+      }
+    })) || [];
+    const data = {
+      type: "range",
+      dataType: "number",
+      ranges: counts
+    };
+    return data;
+  }
+};
+var mean = (arr) => {
+  let total = 0;
+  for (let i = 0; i < arr.length; i++) {
+    total += arr[i];
+  }
+  return total / arr.length;
 };
 
 // src/repositories/product-projection.ts
@@ -3211,6 +3423,7 @@ var ProductProjectionRepository = class extends AbstractResourceRepository {
     const results = this._searchService.search(context.projectKey, {
       filter: QueryParamsAsArray(query.filter),
       "filter.query": QueryParamsAsArray(query["filter.query"]),
+      facet: QueryParamsAsArray(query.facet),
       offset: query.offset ? Number(query.offset) : void 0,
       limit: query.limit ? Number(query.limit) : void 0,
       expand: QueryParamsAsArray(query.expand)