@labdigital/commercetools-mock 0.7.1 → 0.9.1

package/dist/index.global.js

@@ -44420,7 +44420,7 @@ ${this.pendingMocks().join("\n")}`
           function maxBy(array, iteratee2) {
             return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseGt) : undefined2;
           }
-          function mean(array) {
+          function mean2(array) {
             return baseMean(array, identity);
           }
           function meanBy(array, iteratee2) {
@@ -44689,7 +44689,7 @@ ${this.pendingMocks().join("\n")}`
           lodash.lte = lte;
           lodash.max = max;
           lodash.maxBy = maxBy;
-          lodash.mean = mean;
+          lodash.mean = mean2;
           lodash.meanBy = meanBy;
           lodash.min = min;
           lodash.minBy = minBy;
@@ -45032,7 +45032,7 @@ ${this.pendingMocks().join("\n")}`
     return obj[val.value];
   };
   var getLexer = (value) => {
-    return new import_perplex.default(value).token("AND", /and(?![-_a-z0-9]+)/i).token("OR", /or(?![-_a-z0-9]+)/i).token("NOT", /not(?![-_a-z0-9]+)/i).token("WITHIN", /within(?![-_a-z0-9]+)/i).token("IN", /in(?![-_a-z0-9]+)/i).token("MATCHES_IGNORE_CASE", /matches\s+ignore\s+case(?![-_a-z0-9]+)/i).token("CONTAINS", /contains(?![-_a-z0-9]+)/i).token("ALL", /all(?![-_a-z0-9]+)/i).token("ANY", /any(?![-_a-z0-9]+)/i).token("EMPTY", /empty(?![-_a-z0-9]+)/i).token("IS", /is(?![-_a-z0-9]+)/i).token("DEFINED", /defined(?![-_a-z0-9]+)/i).token("FLOAT", /\d+\.\d+/).token("INT", /\d+/).token("VARIABLE", /:([-_A-Za-z0-9]+)/).token("IDENTIFIER", /[-_A-Za-z0-9]+/).token("STRING", /"((?:\\.|[^"\\])*)"/).token("STRING", /'((?:\\.|[^'\\])*)'/).token("COMMA", ",").token("(", "(").token(")", ")").token(">=", ">=").token("<=", "<=").token(">", ">").token("<", "<").token("!=", "!=").token("=", "=").token('"', '"').token("WS", /\s+/, true);
+    return new import_perplex.default(value).token("AND", /and(?![-_a-z0-9]+)/i).token("OR", /or(?![-_a-z0-9]+)/i).token("NOT", /not(?![-_a-z0-9]+)/i).token("WITHIN", /within(?![-_a-z0-9]+)/i).token("IN", /in(?![-_a-z0-9]+)/i).token("MATCHES_IGNORE_CASE", /matches\s+ignore\s+case(?![-_a-z0-9]+)/i).token("CONTAINS", /contains(?![-_a-z0-9]+)/i).token("ALL", /all(?![-_a-z0-9]+)/i).token("ANY", /any(?![-_a-z0-9]+)/i).token("EMPTY", /empty(?![-_a-z0-9]+)/i).token("IS", /is(?![-_a-z0-9]+)/i).token("DEFINED", /defined(?![-_a-z0-9]+)/i).token("FLOAT", /\d+\.\d+/).token("INT", /\d+/).token("VARIABLE", /:([-_A-Za-z0-9]+)/).token("BOOLEAN", /(true|false)/).token("IDENTIFIER", /[-_A-Za-z0-9]+/).token("STRING", /"((?:\\.|[^"\\])*)"/).token("STRING", /'((?:\\.|[^'\\])*)'/).token("COMMA", ",").token("(", "(").token(")", ")").token(">=", ">=").token("<=", "<=").token(">", ">").token("<", "<").token("!=", "!=").token("=", "=").token('"', '"').token("WS", /\s+/, true);
   };
   var generateMatchFunc = (predicate) => {
     const lexer = getLexer(predicate);
@@ -45042,6 +45042,12 @@ ${this.pendingMocks().join("\n")}`
         value: t.token.match,
         pos: t.token.strpos()
       };
+    }).nud("BOOLEAN", 1, (t) => {
+      return {
+        type: "boolean",
+        value: t.token.match === "true" ? true : false,
+        pos: t.token.strpos()
+      };
     }).nud("VARIABLE", 100, (t) => {
       return {
         type: "var",
@@ -45736,6 +45742,21 @@ ${this.pendingMocks().join("\n")}`
       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 [];
@@ -45844,10 +45865,41 @@ ${this.pendingMocks().join("\n")}`
     };
   };
   var createTypedMoney = (value) => {
+    let fractionDigits = 2;
+    switch (value.currencyCode.toUpperCase()) {
+      case "BHD":
+      case "IQD":
+      case "JOD":
+      case "KWD":
+      case "LYD":
+      case "OMR":
+      case "TND":
+        fractionDigits = 3;
+        break;
+      case "CVE":
+      case "DJF":
+      case "GNF":
+      case "IDR":
+      case "JPY":
+      case "KMF":
+      case "KRW":
+      case "PYG":
+      case "RWF":
+      case "UGX":
+      case "VND":
+      case "VUV":
+      case "XAF":
+      case "XOF":
+      case "XPF":
+        fractionDigits = 0;
+        break;
+      default:
+        fractionDigits = 2;
+    }
     return {
       type: "centPrecision",
-      fractionDigits: 2,
-      ...value
+      ...value,
+      fractionDigits
     };
   };
   var resolveStoreReference = (ref, projectKey, storage) => {
@@ -46055,7 +46107,14 @@ ${this.pendingMocks().join("\n")}`
       if (!(0, import_deep_equal.default)(modifiedResource, resource)) {
         this.save(context, modifiedResource);
       }
-      return modifiedResource;
+      const result = this.postProcessResource(modifiedResource);
+      if (!result) {
+        throw new Error("invalid post process action");
+      }
+      return result;
+    }
+    postProcessResource(resource) {
+      return resource;
     }
   };
   var AbstractResourceRepository = class extends AbstractRepository {
@@ -46064,31 +46123,36 @@ ${this.pendingMocks().join("\n")}`
       this._storage.assertStorage(this.getTypeId());
     }
     query(context, params = {}) {
-      return this._storage.query(context.projectKey, this.getTypeId(), {
+      const result = this._storage.query(context.projectKey, this.getTypeId(), {
         expand: params.expand,
         where: params.where,
         offset: params.offset,
         limit: params.limit
       });
+      result.results = result.results.map(this.postProcessResource);
+      return result;
     }
     get(context, id, params = {}) {
-      return this._storage.get(context.projectKey, this.getTypeId(), id, params);
+      const resource = this._storage.get(context.projectKey, this.getTypeId(), id, params);
+      return this.postProcessResource(resource);
     }
     getByKey(context, key, params = {}) {
-      return this._storage.getByKey(
+      const resource = this._storage.getByKey(
         context.projectKey,
         this.getTypeId(),
         key,
         params
       );
+      return this.postProcessResource(resource);
     }
     delete(context, id, params = {}) {
-      return this._storage.delete(
+      const resource = this._storage.delete(
         context.projectKey,
         this.getTypeId(),
         id,
         params
       );
+      return this.postProcessResource(resource);
     }
     save(context, resource) {
       const current = this.get(context, resource.id);
@@ -47369,6 +47433,25 @@ ${this.pendingMocks().join("\n")}`
     }
   };
 
+  // src/lib/masking.ts
+  var maskSecretValue = (resource, path) => {
+    const parts = path.split(".");
+    const clone = JSON.parse(JSON.stringify(resource));
+    let val = clone;
+    const target = parts.pop();
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      val = val[part];
+      if (val === void 0) {
+        return resource;
+      }
+    }
+    if (val && target && val[target]) {
+      val[target] = "****";
+    }
+    return clone;
+  };
+
   // src/repositories/extension.ts
   var ExtensionRepository = class extends AbstractResourceRepository {
     constructor() {
@@ -47391,6 +47474,23 @@ ${this.pendingMocks().join("\n")}`
     getTypeId() {
       return "extension";
     }
+    postProcessResource(resource) {
+      var _a;
+      if (resource) {
+        if (resource.destination.type === "HTTP" && ((_a = resource.destination.authentication) == null ? void 0 : _a.type) === "AuthorizationHeader") {
+          return maskSecretValue(
+            resource,
+            "destination.authentication.headerValue"
+          );
+        } else if (resource.destination.type == "AWSLambda") {
+          return maskSecretValue(
+            resource,
+            "destination.accessSecret"
+          );
+        }
+      }
+      return resource;
+    }
     create(context, draft) {
       const resource = {
         ...getBaseResourceProperties(),
@@ -47820,38 +47920,71 @@ ${this.pendingMocks().join("\n")}`
   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);
-        };
-      }
-      if (typeof expr === "function") {
-        return (obj) => {
-          return expr(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 (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] });
@@ -47860,38 +47993,74 @@ ${this.pendingMocks().join("\n")}`
       } 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) => {
@@ -47921,6 +48090,9 @@ ${this.pendingMocks().join("\n")}`
     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) {
@@ -47937,21 +48109,6 @@ ${this.pendingMocks().join("\n")}`
     }
     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 [
@@ -48044,6 +48201,7 @@ ${this.pendingMocks().join("\n")}`
           );
         }
       }
+      const facets = this.getFacets(params, resources);
       if (params["filter.query"]) {
         try {
           const filters = params["filter.query"].map(
@@ -48077,7 +48235,7 @@ ${this.pendingMocks().join("\n")}`
         offset,
         limit,
         results: resources.map(this.transform),
-        facets: {}
+        facets
       };
     }
     transform(product) {
@@ -48088,6 +48246,9 @@ ${this.pendingMocks().join("\n")}`
         lastModifiedAt: product.lastModifiedAt,
         version: product.version,
         name: obj.name,
+        key: product.key,
+        description: obj.description,
+        metaDescription: obj.metaDescription,
         slug: obj.slug,
         categories: obj.categories,
         masterVariant: obj.masterVariant,
@@ -48095,6 +48256,145 @@ ${this.pendingMocks().join("\n")}`
         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
@@ -48122,6 +48422,7 @@ ${this.pendingMocks().join("\n")}`
       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)
@@ -48470,25 +48771,6 @@ ${this.pendingMocks().join("\n")}`
     }
   };
 
-  // src/lib/masking.ts
-  var maskSecretValue = (resource, path) => {
-    const parts = path.split(".");
-    const clone = JSON.parse(JSON.stringify(resource));
-    let val = clone;
-    const target = parts.pop();
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
-      val = val[part];
-      if (val === void 0) {
-        return resource;
-      }
-    }
-    if (val && target && val[target]) {
-      val[target] = "****";
-    }
-    return clone;
-  };
-
   // src/repositories/project.ts
   var ProjectRepository = class extends AbstractRepository {
     constructor() {
@@ -48546,11 +48828,16 @@ ${this.pendingMocks().join("\n")}`
     }
     get(context) {
       const resource = this._storage.getProject(context.projectKey);
-      const masked = maskSecretValue(
-        resource,
-        "externalOAuth.authorizationHeader"
-      );
-      return masked;
+      return this.postProcessResource(resource);
+    }
+    postProcessResource(resource) {
+      if (resource) {
+        return maskSecretValue(
+          resource,
+          "externalOAuth.authorizationHeader"
+        );
+      }
+      return resource;
     }
     save(context, resource) {
       const current = this.get(context);
@@ -48819,6 +49106,14 @@ ${this.pendingMocks().join("\n")}`
         },
         setRoles: (context, resource, { roles }) => {
           resource.roles = roles;
+        },
+        setTransitions: (context, resource, { transitions }) => {
+          resource.transitions = transitions == null ? void 0 : transitions.map((resourceId) => {
+            return {
+              id: resourceId.id || "",
+              typeId: "state"
+            };
+          });
         }
       };
     }