@labdigital/commercetools-mock 0.6.5 → 0.8.0

package/dist/index.js

@@ -1,8 +1,4837 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-'use strict'
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CommercetoolsMock: () => CommercetoolsMock,
+  getBaseResourceProperties: () => getBaseResourceProperties
+});
+module.exports = __toCommonJS(src_exports);
 
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./commercetools-mock.cjs.production.min.js')
-} else {
-  module.exports = require('./commercetools-mock.cjs.development.js')
-}
+// src/ctMock.ts
+var import_nock = __toESM(require("nock"));
+var import_express6 = __toESM(require("express"));
+var import_supertest = __toESM(require("supertest"));
+var import_morgan = __toESM(require("morgan"));
+
+// src/storage.ts
+var import_assert = __toESM(require("assert"));
+
+// src/lib/expandParser.ts
+var parseExpandClause = (clause) => {
+  const result = {
+    element: clause,
+    index: void 0,
+    rest: void 0
+  };
+  const pos = clause.indexOf(".");
+  if (pos > 0) {
+    result.element = clause.substring(0, pos);
+    result.rest = clause.substring(pos + 1);
+  }
+  const match = result.element.match(/\[([^\]+])]/);
+  if (match) {
+    result.index = match[1] === "*" ? "*" : parseInt(match[1], 10);
+    result.element = result.element.substring(0, match.index);
+  }
+  return result;
+};
+
+// src/lib/predicateParser.ts
+var import_perplex = __toESM(require("perplex"));
+var import_pratt = require("pratt");
+
+// src/lib/haversine.ts
+var haversineDistance = (src, dst) => {
+  const RADIUS_OF_EARTH_IN_KM = 6371;
+  const toRadian = (deg) => deg * (Math.PI / 180);
+  const dLat = toRadian(dst.latitude - src.latitude);
+  const dLon = toRadian(dst.longitude - src.longitude);
+  var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(toRadian(src.latitude)) * Math.cos(toRadian(dst.latitude)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+  var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  return RADIUS_OF_EARTH_IN_KM * c * 1e3;
+};
+
+// src/lib/predicateParser.ts
+var PredicateError = class {
+  constructor(message) {
+    this.message = message;
+  }
+};
+var parseQueryExpression = (predicate) => {
+  if (Array.isArray(predicate)) {
+    const callbacks = predicate.map((item) => generateMatchFunc(item));
+    return (target, variables) => {
+      return callbacks.every((callback) => callback(target, variables));
+    };
+  } else {
+    return generateMatchFunc(predicate);
+  }
+};
+var validateSymbol = (val) => {
+  var _a, _b;
+  if (!val.type) {
+    throw new PredicateError("Internal error");
+  }
+  if (val.type === "identifier") {
+    const char = val.value.charAt(0);
+    const line = (_a = val.pos) == null ? void 0 : _a.start.line;
+    const column = (_b = val.pos) == null ? void 0 : _b.start.column;
+    throw new PredicateError(
+      `Invalid input '${char}', expected input parameter or primitive value (line ${line}, column ${column})`
+    );
+  }
+};
+var resolveSymbol = (val, vars) => {
+  if (val.type === "var") {
+    if (!(val.value in vars)) {
+      throw new PredicateError(`Missing parameter value for ${val.value}`);
+    }
+    return vars[val.value];
+  }
+  return val.value;
+};
+var resolveValue = (obj, val) => {
+  if (val.type !== "identifier") {
+    throw new PredicateError("Internal error");
+  }
+  if (!(val.value in obj)) {
+    if (Array.isArray(obj)) {
+      return Object.values(obj).filter((v) => val.value in v).map((v) => v[val.value]);
+    }
+    throw new PredicateError(`The field '${val.value}' does not exist.`);
+  }
+  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);
+};
+var generateMatchFunc = (predicate) => {
+  const lexer = getLexer(predicate);
+  const parser = new import_pratt.Parser(lexer).builder().nud("IDENTIFIER", 100, (t) => {
+    return {
+      type: "identifier",
+      value: t.token.match,
+      pos: t.token.strpos()
+    };
+  }).nud("VARIABLE", 100, (t) => {
+    return {
+      type: "var",
+      value: t.token.groups[1],
+      pos: t.token.strpos()
+    };
+  }).nud("STRING", 100, (t) => {
+    return {
+      type: "string",
+      value: t.token.groups[1],
+      pos: t.token.strpos()
+    };
+  }).nud("INT", 1, (t) => {
+    return {
+      type: "int",
+      value: parseInt(t.token.match, 10),
+      pos: t.token.strpos()
+    };
+  }).nud("FLOAT", 1, (t) => {
+    return {
+      type: "float",
+      value: parseFloat(t.token.match),
+      pos: t.token.strpos()
+    };
+  }).nud("NOT", 100, ({ bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    return (obj) => {
+      return !expr(obj);
+    };
+  }).nud("EMPTY", 10, ({ bp }) => {
+    return "empty";
+  }).nud("DEFINED", 10, ({ bp }) => {
+    return "defined";
+  }).led("AND", 5, ({ left, bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    return (obj) => {
+      return left(obj) && expr(obj);
+    };
+  }).led("OR", 5, ({ left, token, bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    return (obj, vars) => {
+      return left(obj, vars) || expr(obj, vars);
+    };
+  }).led("COMMA", 1, ({ 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: [")"] });
+    return expr;
+  }).led("(", 100, ({ left, bp }) => {
+    const expr = parser.parse();
+    lexer.expect(")");
+    return (obj, vars) => {
+      const value = resolveValue(obj, left);
+      if (value) {
+        return expr(value);
+      }
+      return false;
+    };
+  }).bp(")", 0).led("=", 20, ({ left, bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    validateSymbol(expr);
+    return (obj, vars) => {
+      const resolvedValue = resolveValue(obj, left);
+      const resolvedSymbol = resolveSymbol(expr, vars);
+      if (Array.isArray(resolvedValue)) {
+        return !!resolvedValue.some((elem) => elem === resolvedSymbol);
+      }
+      return resolvedValue === resolvedSymbol;
+    };
+  }).led("!=", 20, ({ left, bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    validateSymbol(expr);
+    return (obj, vars) => {
+      return resolveValue(obj, left) !== resolveSymbol(expr, vars);
+    };
+  }).led(">", 20, ({ left, bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    validateSymbol(expr);
+    return (obj, vars) => {
+      return resolveValue(obj, left) > resolveSymbol(expr, vars);
+    };
+  }).led(">=", 20, ({ left, bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    validateSymbol(expr);
+    return (obj, vars) => {
+      return resolveValue(obj, left) >= resolveSymbol(expr, vars);
+    };
+  }).led("<", 20, ({ left, bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    validateSymbol(expr);
+    return (obj, vars) => {
+      return resolveValue(obj, left) < resolveSymbol(expr, vars);
+    };
+  }).led("<=", 20, ({ left, bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    validateSymbol(expr);
+    return (obj, vars) => {
+      return resolveValue(obj, left) <= resolveSymbol(expr, vars);
+    };
+  }).led("IS", 20, ({ left, bp }) => {
+    let invert = false;
+    const next = lexer.peek();
+    if (next.type === "NOT") {
+      invert = true;
+      lexer.next();
+    }
+    const expr = parser.parse({ terminals: [bp - 1] });
+    switch (expr) {
+      case "empty": {
+        if (!invert) {
+          return (obj, vars) => {
+            const val = resolveValue(obj, left);
+            return val.length === 0;
+          };
+        } else {
+          return (obj, vars) => {
+            const val = resolveValue(obj, left);
+            return val.length !== 0;
+          };
+        }
+      }
+      case "defined": {
+        if (!invert) {
+          return (obj, vars) => {
+            const val = resolveValue(obj, left);
+            return val !== void 0;
+          };
+        } else {
+          return (obj, vars) => {
+            const val = resolveValue(obj, left);
+            return val === void 0;
+          };
+        }
+      }
+      default: {
+        throw new Error("Unexpected");
+      }
+    }
+  }).led("IN", 20, ({ left, bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    return (obj, vars) => {
+      let symbols = expr;
+      if (!Array.isArray(symbols)) {
+        symbols = [expr];
+      }
+      const inValues = symbols.map(
+        (item) => resolveSymbol(item, vars)
+      );
+      return inValues.includes(resolveValue(obj, left));
+    };
+  }).led("MATCHES_IGNORE_CASE", 20, ({ left, bp }) => {
+    const expr = parser.parse({ terminals: [bp - 1] });
+    validateSymbol(expr);
+    return (obj, vars) => {
+      const value = resolveValue(obj, left);
+      const other = resolveSymbol(expr, vars);
+      if (typeof value != "string") {
+        throw new PredicateError(
+          `The field '${left.value}' does not support this expression.`
+        );
+      }
+      return value.toLowerCase() === other.toLowerCase();
+    };
+  }).led("WITHIN", 20, ({ left, bp }) => {
+    const type = lexer.next();
+    if (type.match !== "circle") {
+      throw new PredicateError(
+        `Invalid input '${type.match}', expected circle`
+      );
+    }
+    lexer.expect("(");
+    const expr = parser.parse({ terminals: [")"] });
+    return (obj, vars) => {
+      const value = resolveValue(obj, left);
+      if (!value)
+        return false;
+      const maxDistance = resolveSymbol(expr[2], vars);
+      const distance = haversineDistance(
+        {
+          longitude: value[0],
+          latitude: value[1]
+        },
+        {
+          longitude: resolveSymbol(expr[0], vars),
+          latitude: resolveSymbol(expr[1], vars)
+        }
+      );
+      return distance <= maxDistance;
+    };
+  }).led("CONTAINS", 20, ({ left, bp }) => {
+    const keyword = lexer.next();
+    let expr = parser.parse();
+    if (!Array.isArray(expr)) {
+      expr = [expr];
+    }
+    return (obj, vars) => {
+      const value = resolveValue(obj, left);
+      if (!Array.isArray(value)) {
+        throw new PredicateError(
+          `The field '${left.value}' does not support this expression.`
+        );
+      }
+      const array = expr.map((item) => resolveSymbol(item, vars));
+      if (keyword.type === "ALL") {
+        return array.every((item) => value.includes(item));
+      } else {
+        return array.some((item) => value.includes(item));
+      }
+    };
+  }).build();
+  const result = parser.parse();
+  if (typeof result !== "function") {
+    const lines = predicate.split("\n");
+    const column = lines[lines.length - 1].length;
+    throw new PredicateError(
+      `Unexpected end of input, expected SphereIdentifierChar, comparison operator, not, in, contains, is, within or matches (line ${lines.length}, column ${column})`
+    );
+  }
+  return result;
+};
+
+// src/exceptions.ts
+var CommercetoolsError = class extends Error {
+  constructor(info, statusCode = 400) {
+    super(info.message);
+    this.info = info;
+    this.statusCode = statusCode || 500;
+  }
+};
+
+// src/storage.ts
+var AbstractStorage = class {
+};
+var InMemoryStorage = class extends AbstractStorage {
+  constructor() {
+    super(...arguments);
+    this.resources = {};
+    this.projects = {};
+    this.addProject = (projectKey) => {
+      if (!this.projects[projectKey]) {
+        this.projects[projectKey] = {
+          key: projectKey,
+          name: "",
+          countries: [],
+          currencies: [],
+          languages: [],
+          createdAt: "2018-10-04T11:32:12.603Z",
+          trialUntil: "2018-12",
+          carts: {
+            countryTaxRateFallbackEnabled: false,
+            deleteDaysAfterLastModification: 90
+          },
+          messages: { enabled: false, deleteDaysAfterCreation: 15 },
+          shippingRateInputType: void 0,
+          externalOAuth: void 0,
+          searchIndexing: {
+            products: {
+              status: "Deactivated"
+            },
+            orders: {
+              status: "Deactivated"
+            }
+          },
+          version: 1
+        };
+      }
+      return this.projects[projectKey];
+    };
+    this.saveProject = (project) => {
+      this.projects[project.key] = project;
+      return project;
+    };
+    this.getProject = (projectKey) => {
+      return this.addProject(projectKey);
+    };
+    this.expand = (projectKey, obj, clause) => {
+      if (!clause)
+        return obj;
+      const newObj = JSON.parse(JSON.stringify(obj));
+      if (Array.isArray(clause)) {
+        clause.forEach((c) => {
+          this._resolveResource(projectKey, newObj, c);
+        });
+      } else {
+        this._resolveResource(projectKey, newObj, clause);
+      }
+      return newObj;
+    };
+    this._resolveResource = (projectKey, obj, expand) => {
+      const params = parseExpandClause(expand);
+      if (!params.index) {
+        const reference = obj[params.element];
+        if (reference === void 0) {
+          return;
+        }
+        this._resolveReference(projectKey, reference, params.rest);
+      } else if (params.index === "*") {
+        const reference = obj[params.element];
+        if (reference === void 0 || !Array.isArray(reference))
+          return;
+        reference.forEach((itemRef) => {
+          this._resolveReference(projectKey, itemRef, params.rest);
+        });
+      } else {
+        const reference = obj[params.element][params.index];
+        if (reference === void 0)
+          return;
+        this._resolveReference(projectKey, reference, params.rest);
+      }
+    };
+  }
+  forProjectKey(projectKey) {
+    this.addProject(projectKey);
+    let projectStorage = this.resources[projectKey];
+    if (!projectStorage) {
+      projectStorage = this.resources[projectKey] = {
+        cart: /* @__PURE__ */ new Map(),
+        "cart-discount": /* @__PURE__ */ new Map(),
+        category: /* @__PURE__ */ new Map(),
+        channel: /* @__PURE__ */ new Map(),
+        customer: /* @__PURE__ */ new Map(),
+        "customer-group": /* @__PURE__ */ new Map(),
+        "discount-code": /* @__PURE__ */ new Map(),
+        extension: /* @__PURE__ */ new Map(),
+        "inventory-entry": /* @__PURE__ */ new Map(),
+        "key-value-document": /* @__PURE__ */ new Map(),
+        order: /* @__PURE__ */ new Map(),
+        "order-edit": /* @__PURE__ */ new Map(),
+        payment: /* @__PURE__ */ new Map(),
+        product: /* @__PURE__ */ new Map(),
+        "product-discount": /* @__PURE__ */ new Map(),
+        "product-price": /* @__PURE__ */ new Map(),
+        "product-selection": /* @__PURE__ */ new Map(),
+        "product-type": /* @__PURE__ */ new Map(),
+        "product-projection": /* @__PURE__ */ new Map(),
+        review: /* @__PURE__ */ new Map(),
+        "shipping-method": /* @__PURE__ */ new Map(),
+        state: /* @__PURE__ */ new Map(),
+        store: /* @__PURE__ */ new Map(),
+        "shopping-list": /* @__PURE__ */ new Map(),
+        "standalone-price": /* @__PURE__ */ new Map(),
+        subscription: /* @__PURE__ */ new Map(),
+        "tax-category": /* @__PURE__ */ new Map(),
+        type: /* @__PURE__ */ new Map(),
+        zone: /* @__PURE__ */ new Map()
+      };
+    }
+    return projectStorage;
+  }
+  clear() {
+    for (const [, projectStorage] of Object.entries(this.resources)) {
+      for (const [, value] of Object.entries(projectStorage)) {
+        value == null ? void 0 : value.clear();
+      }
+    }
+  }
+  assertStorage(typeId) {
+  }
+  all(projectKey, typeId) {
+    const store = this.forProjectKey(projectKey)[typeId];
+    if (store) {
+      return Array.from(store.values());
+    }
+    return [];
+  }
+  add(projectKey, typeId, obj, params = {}) {
+    var _a;
+    const store = this.forProjectKey(projectKey);
+    (_a = store[typeId]) == null ? void 0 : _a.set(obj.id, obj);
+    const resource = this.get(projectKey, typeId, obj.id, params);
+    (0, import_assert.default)(resource, `resource of type ${typeId} with id ${obj.id} not created`);
+    return resource;
+  }
+  get(projectKey, typeId, id, params = {}) {
+    var _a;
+    const resource = (_a = this.forProjectKey(projectKey)[typeId]) == null ? void 0 : _a.get(id);
+    if (resource) {
+      return this.expand(projectKey, resource, params.expand);
+    }
+    return null;
+  }
+  getByKey(projectKey, typeId, key, params = {}) {
+    const store = this.forProjectKey(projectKey);
+    const resourceStore = store[typeId];
+    if (!store) {
+      throw new Error("No type");
+    }
+    const resources = Array.from(resourceStore.values());
+    const resource = resources.find((e) => e.key === key);
+    if (resource) {
+      return this.expand(projectKey, resource, params.expand);
+    }
+    return null;
+  }
+  delete(projectKey, typeId, id, params = {}) {
+    var _a;
+    const resource = this.get(projectKey, typeId, id);
+    if (resource) {
+      (_a = this.forProjectKey(projectKey)[typeId]) == null ? void 0 : _a.delete(id);
+      return this.expand(projectKey, resource, params.expand);
+    }
+    return resource;
+  }
+  query(projectKey, typeId, params) {
+    const store = this.forProjectKey(projectKey)[typeId];
+    if (!store) {
+      throw new Error("No type");
+    }
+    let resources = Array.from(store.values());
+    if (params.where) {
+      try {
+        const filterFunc = parseQueryExpression(params.where);
+        resources = resources.filter((resource) => filterFunc(resource, {}));
+      } catch (err) {
+        throw new CommercetoolsError(
+          {
+            code: "InvalidInput",
+            message: err.message
+          },
+          400
+        );
+      }
+    }
+    const totalResources = resources.length;
+    const offset = params.offset || 0;
+    const limit = params.limit || 20;
+    resources = resources.slice(offset, offset + limit);
+    if (params.expand !== void 0) {
+      resources = resources.map((resource) => {
+        return this.expand(projectKey, resource, params.expand);
+      });
+    }
+    return {
+      count: totalResources,
+      total: resources.length,
+      offset,
+      limit,
+      results: resources
+    };
+  }
+  search(projectKey, typeId, params) {
+    const store = this.forProjectKey(projectKey)[typeId];
+    if (!store) {
+      throw new Error("No type");
+    }
+    let resources = Array.from(store.values());
+    if (params.where) {
+      try {
+        const filterFunc = parseQueryExpression(params.where);
+        resources = resources.filter((resource) => filterFunc(resource, {}));
+      } catch (err) {
+        throw new CommercetoolsError(
+          {
+            code: "InvalidInput",
+            message: err.message
+          },
+          400
+        );
+      }
+    }
+    const totalResources = resources.length;
+    const offset = params.offset || 0;
+    const limit = params.limit || 20;
+    resources = resources.slice(offset, offset + limit);
+    if (params.expand !== void 0) {
+      resources = resources.map((resource) => {
+        return this.expand(projectKey, resource, params.expand);
+      });
+    }
+    return {
+      count: totalResources,
+      total: resources.length,
+      offset,
+      limit,
+      results: resources
+    };
+  }
+  getByResourceIdentifier(projectKey, identifier) {
+    if (identifier.id) {
+      const resource = this.get(projectKey, identifier.typeId, identifier.id);
+      if (resource) {
+        return resource;
+      }
+      console.error(
+        `No resource found with typeId=${identifier.typeId}, id=${identifier.id}`
+      );
+      return void 0;
+    }
+    if (identifier.key) {
+      const store = this.forProjectKey(projectKey)[identifier.typeId];
+      if (store) {
+        const resource = Array.from(store.values()).find(
+          (r) => r.key === identifier.key
+        );
+        if (resource) {
+          return resource;
+        }
+      } else {
+        throw new Error(
+          `No storage found for resource type: ${identifier.typeId}`
+        );
+      }
+    }
+    return void 0;
+  }
+  _resolveReference(projectKey, reference, expand) {
+    if (reference === void 0)
+      return;
+    if (reference.typeId !== void 0 && (reference.id !== void 0 || reference.key !== void 0)) {
+      reference.obj = this.getByResourceIdentifier(projectKey, {
+        typeId: reference.typeId,
+        id: reference.id,
+        key: reference.key
+      });
+      if (expand) {
+        this._resolveResource(projectKey, reference.obj, expand);
+      }
+    } else {
+      if (expand) {
+        this._resolveResource(projectKey, reference, expand);
+      }
+    }
+  }
+};
+
+// src/oauth/server.ts
+var import_basic_auth = __toESM(require("basic-auth"));
+var import_body_parser = __toESM(require("body-parser"));
+var import_express = __toESM(require("express"));
+
+// src/oauth/store.ts
+var import_crypto = require("crypto");
+var OAuth2Store = class {
+  constructor(validate = true) {
+    this.tokens = [];
+    this.validate = true;
+    this.validate = validate;
+  }
+  getClientToken(clientId, clientSecret, scope) {
+    const token = {
+      access_token: (0, import_crypto.randomBytes)(16).toString("base64"),
+      token_type: "Bearer",
+      expires_in: 172800,
+      scope: scope || "todo"
+    };
+    this.tokens.push(token);
+    return token;
+  }
+  validateToken(token) {
+    if (!this.validate)
+      return true;
+    const foundToken = this.tokens.find((t) => t.access_token === token);
+    if (foundToken) {
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/oauth/helpers.ts
+var getBearerToken = (request) => {
+  var _a;
+  const authHeader = request.header("Authorization");
+  const match = authHeader == null ? void 0 : authHeader.match(/^Bearer\s(?<token>[^\s]+)$/);
+  if (match) {
+    return (_a = match.groups) == null ? void 0 : _a.token;
+  }
+  return void 0;
+};
+
+// src/oauth/server.ts
+var OAuth2Server = class {
+  constructor(options) {
+    this.store = new OAuth2Store(options.validate);
+  }
+  createRouter() {
+    const router = import_express.default.Router();
+    router.use(import_body_parser.default.urlencoded({ extended: true }));
+    router.post("/token", this.tokenHandler.bind(this));
+    return router;
+  }
+  createMiddleware() {
+    return async (request, response, next) => {
+      const token = getBearerToken(request);
+      if (!token) {
+        next(
+          new CommercetoolsError(
+            {
+              code: "access_denied",
+              message: "This endpoint requires an access token. You can get one from the authorization server."
+            },
+            401
+          )
+        );
+      }
+      if (!token || !this.store.validateToken(token)) {
+        next(
+          new CommercetoolsError(
+            {
+              code: "invalid_token",
+              message: "invalid_token"
+            },
+            401
+          )
+        );
+      }
+      next();
+    };
+  }
+  async tokenHandler(request, response, next) {
+    var _a;
+    const authHeader = request.header("Authorization");
+    if (!authHeader) {
+      return next(
+        new CommercetoolsError(
+          {
+            code: "invalid_client",
+            message: "Please provide valid client credentials using HTTP Basic Authentication."
+          },
+          401
+        )
+      );
+    }
+    const credentials = import_basic_auth.default.parse(authHeader);
+    if (!credentials) {
+      return next(
+        new CommercetoolsError(
+          {
+            code: "invalid_client",
+            message: "Please provide valid client credentials using HTTP Basic Authentication."
+          },
+          400
+        )
+      );
+    }
+    const grantType = request.query.grant_type || request.body.grant_type;
+    if (!grantType) {
+      return next(
+        new CommercetoolsError(
+          {
+            code: "invalid_request",
+            message: "Missing required parameter: grant_type."
+          },
+          400
+        )
+      );
+    }
+    if (grantType === "client_credentials") {
+      const token = this.store.getClientToken(
+        credentials.name,
+        credentials.pass,
+        (_a = request.query.scope) == null ? void 0 : _a.toString()
+      );
+      return response.status(200).send(token);
+    } else {
+      return next(
+        new CommercetoolsError(
+          {
+            code: "unsupported_grant_type",
+            message: `Invalid parameter: grant_type: Invalid grant type: ${grantType}`
+          },
+          400
+        )
+      );
+    }
+  }
+};
+
+// src/helpers.ts
+var import_uuid = require("uuid");
+var getBaseResourceProperties = () => {
+  return {
+    id: (0, import_uuid.v4)(),
+    createdAt: new Date().toISOString(),
+    lastModifiedAt: new Date().toISOString(),
+    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 [];
+  }
+  if (Array.isArray(input)) {
+    return input;
+  }
+  return [input];
+};
+
+// src/projectAPI.ts
+var ProjectAPI = class {
+  constructor(projectKey, services, storage) {
+    this.projectKey = projectKey;
+    this._storage = storage;
+    this._services = services;
+  }
+  add(typeId, resource) {
+    const service = this._services[typeId];
+    if (service) {
+      this._storage.add(this.projectKey, typeId, {
+        ...getBaseResourceProperties(),
+        ...resource
+      });
+    } else {
+      throw new Error(`Service for ${typeId} not implemented yet`);
+    }
+  }
+  get(typeId, id, params) {
+    return this._storage.get(
+      this.projectKey,
+      typeId,
+      id,
+      params
+    );
+  }
+  getRepository(typeId) {
+    const service = this._services[typeId];
+    if (service !== void 0) {
+      return service.repository;
+    }
+    throw new Error("No such repository");
+  }
+};
+
+// src/lib/proxy.ts
+var copyHeaders = (headers) => {
+  const validHeaders = ["accept", "host", "authorization"];
+  const result = {};
+  Object.entries(headers).forEach(([key, value]) => {
+    if (validHeaders.includes(key.toLowerCase())) {
+      result[key] = value;
+    }
+  });
+  return result;
+};
+
+// src/constants.ts
+var DEFAULT_API_HOSTNAME = /^https:\/\/api\..*?\.commercetools.com:443$/;
+var DEFAULT_AUTH_HOSTNAME = /^https:\/\/auth\..*?\.commercetools.com:443$/;
+
+// src/services/abstract.ts
+var import_express2 = require("express");
+
+// src/repositories/helpers.ts
+var import_uuid2 = require("uuid");
+var createAddress = (base, projectKey, storage) => {
+  if (!base)
+    return void 0;
+  if (!(base == null ? void 0 : base.country)) {
+    throw new Error("Country is required");
+  }
+  return {
+    ...base
+  };
+};
+var createCustomFields = (draft, projectKey, storage) => {
+  if (!draft)
+    return void 0;
+  if (!draft.type)
+    return void 0;
+  if (!draft.type.typeId)
+    return void 0;
+  if (!draft.fields)
+    return void 0;
+  const typeResource = storage.getByResourceIdentifier(
+    projectKey,
+    draft.type
+  );
+  if (!typeResource) {
+    throw new Error(
+      `No type '${draft.type.typeId}' with id=${draft.type.id} or key=${draft.type.key}`
+    );
+  }
+  return {
+    type: {
+      typeId: draft.type.typeId,
+      id: typeResource.id
+    },
+    fields: draft.fields
+  };
+};
+var createPrice = (draft) => {
+  return {
+    id: (0, import_uuid2.v4)(),
+    value: createTypedMoney(draft.value)
+  };
+};
+var createTypedMoney = (value) => {
+  return {
+    type: "centPrecision",
+    fractionDigits: 2,
+    ...value
+  };
+};
+var resolveStoreReference = (ref, projectKey, storage) => {
+  if (!ref)
+    return void 0;
+  const resource = storage.getByResourceIdentifier(projectKey, ref);
+  if (!resource) {
+    throw new Error("No such store");
+  }
+  const store = resource;
+  return {
+    typeId: "store",
+    key: store.key
+  };
+};
+var getReferenceFromResourceIdentifier = (resourceIdentifier, projectKey, storage) => {
+  if (!resourceIdentifier.id && !resourceIdentifier.key) {
+    throw new CommercetoolsError(
+      {
+        code: "InvalidJsonInput",
+        message: `${resourceIdentifier.typeId}: ResourceIdentifier requires an 'id' xor a 'key'`
+      },
+      400
+    );
+  }
+  const resource = storage.getByResourceIdentifier(
+    projectKey,
+    resourceIdentifier
+  );
+  if (!resource) {
+    const errIdentifier = resourceIdentifier.key ? `key '${resourceIdentifier.key}'` : `identifier '${resourceIdentifier.key}'`;
+    throw new CommercetoolsError(
+      {
+        code: "ReferencedResourceNotFound",
+        typeId: resourceIdentifier.typeId,
+        message: `The referenced object of type '${resourceIdentifier.typeId}' with '${errIdentifier}' was not found. It either doesn't exist, or it can't be accessed from this endpoint (e.g., if the endpoint filters by store or customer account).`
+      },
+      400
+    );
+  }
+  return {
+    typeId: resourceIdentifier.typeId,
+    id: resource == null ? void 0 : resource.id
+  };
+};
+var getRepositoryContext = (request) => {
+  return {
+    projectKey: request.params.projectKey,
+    storeKey: request.params.storeKey
+  };
+};
+
+// src/services/abstract.ts
+var AbstractService = class {
+  constructor(parent) {
+    this.createStatusCode = 201;
+    this.registerRoutes(parent);
+  }
+  extraRoutes(router) {
+  }
+  registerRoutes(parent) {
+    const basePath = this.getBasePath();
+    const router = (0, import_express2.Router)({ mergeParams: true });
+    this.extraRoutes(router);
+    router.get("/", this.get.bind(this));
+    router.get("/key=:key", this.getWithKey.bind(this));
+    router.get("/:id", this.getWithId.bind(this));
+    router.delete("/key=:key", this.deletewithKey.bind(this));
+    router.delete("/:id", this.deletewithId.bind(this));
+    router.post("/", this.post.bind(this));
+    router.post("/key=:key", this.postWithKey.bind(this));
+    router.post("/:id", this.postWithId.bind(this));
+    parent.use(`/${basePath}`, router);
+  }
+  get(request, response) {
+    const limit = this._parseParam(request.query.limit);
+    const offset = this._parseParam(request.query.offset);
+    const result = this.repository.query(getRepositoryContext(request), {
+      expand: this._parseParam(request.query.expand),
+      where: this._parseParam(request.query.where),
+      limit: limit !== void 0 ? Number(limit) : void 0,
+      offset: offset !== void 0 ? Number(offset) : void 0
+    });
+    return response.status(200).send(result);
+  }
+  getWithId(request, response) {
+    const result = this._expandWithId(request, request.params["id"]);
+    if (!result) {
+      return response.status(404).send();
+    }
+    return response.status(200).send(result);
+  }
+  getWithKey(request, response) {
+    const result = this.repository.getByKey(
+      getRepositoryContext(request),
+      request.params["key"],
+      { expand: this._parseParam(request.query.expand) }
+    );
+    if (!result)
+      return response.status(404).send();
+    return response.status(200).send(result);
+  }
+  deletewithId(request, response) {
+    const result = this.repository.delete(
+      getRepositoryContext(request),
+      request.params["id"],
+      {
+        expand: this._parseParam(request.query.expand)
+      }
+    );
+    if (!result) {
+      return response.status(404).send("Not found");
+    }
+    return response.status(200).send(result);
+  }
+  deletewithKey(request, response) {
+    return response.status(500).send("Not implemented");
+  }
+  post(request, response) {
+    const draft = request.body;
+    const resource = this.repository.create(
+      getRepositoryContext(request),
+      draft
+    );
+    const result = this._expandWithId(request, resource.id);
+    return response.status(this.createStatusCode).send(result);
+  }
+  postWithId(request, response) {
+    const updateRequest = request.body;
+    const resource = this.repository.get(
+      getRepositoryContext(request),
+      request.params["id"]
+    );
+    if (!resource) {
+      return response.status(404).send("Not found");
+    }
+    if (resource.version !== updateRequest.version) {
+      return response.status(409).send("Concurrent modification");
+    }
+    const updatedResource = this.repository.processUpdateActions(
+      getRepositoryContext(request),
+      resource,
+      updateRequest.actions
+    );
+    const result = this._expandWithId(request, updatedResource.id);
+    return response.status(200).send(result);
+  }
+  postWithKey(request, response) {
+    return response.status(500).send("Not implemented");
+  }
+  _expandWithId(request, resourceId) {
+    const result = this.repository.get(
+      getRepositoryContext(request),
+      resourceId,
+      {
+        expand: this._parseParam(request.query.expand)
+      }
+    );
+    return result;
+  }
+  _parseParam(value) {
+    if (Array.isArray(value)) {
+      return value;
+    } else if (value !== void 0) {
+      return [`${value}`];
+    }
+    return void 0;
+  }
+};
+
+// src/repositories/abstract.ts
+var import_deep_equal = __toESM(require("deep-equal"));
+
+// src/repositories/errors.ts
+var checkConcurrentModification = (resource, expectedVersion) => {
+  if (resource.version === expectedVersion)
+    return;
+  const identifier = resource.id ? resource.id : resource.key;
+  throw new CommercetoolsError(
+    {
+      message: `Object ${identifier} has a different version than expected. Expected: ${expectedVersion} - Actual: ${resource.version}.`,
+      currentVersion: resource.version,
+      code: "ConcurrentModification"
+    },
+    409
+  );
+};
+
+// src/repositories/abstract.ts
+var AbstractRepository = class {
+  constructor(storage) {
+    this.actions = {};
+    this._storage = storage;
+  }
+  processUpdateActions(context, resource, actions) {
+    const modifiedResource = JSON.parse(JSON.stringify(resource));
+    actions.forEach((action) => {
+      const updateFunc = this.actions[action.action];
+      if (!updateFunc) {
+        console.error(`No mock implemented for update action ${action.action}`);
+        return;
+      }
+      updateFunc(context, modifiedResource, action);
+    });
+    if (!(0, import_deep_equal.default)(modifiedResource, resource)) {
+      this.save(context, modifiedResource);
+    }
+    return modifiedResource;
+  }
+};
+var AbstractResourceRepository = class extends AbstractRepository {
+  constructor(storage) {
+    super(storage);
+    this._storage.assertStorage(this.getTypeId());
+  }
+  query(context, params = {}) {
+    return this._storage.query(context.projectKey, this.getTypeId(), {
+      expand: params.expand,
+      where: params.where,
+      offset: params.offset,
+      limit: params.limit
+    });
+  }
+  get(context, id, params = {}) {
+    return this._storage.get(context.projectKey, this.getTypeId(), id, params);
+  }
+  getByKey(context, key, params = {}) {
+    return this._storage.getByKey(
+      context.projectKey,
+      this.getTypeId(),
+      key,
+      params
+    );
+  }
+  delete(context, id, params = {}) {
+    return this._storage.delete(
+      context.projectKey,
+      this.getTypeId(),
+      id,
+      params
+    );
+  }
+  save(context, resource) {
+    const current = this.get(context, resource.id);
+    if (current) {
+      checkConcurrentModification(current, resource.version);
+    } else {
+      if (resource.version !== 0) {
+        throw new CommercetoolsError(
+          {
+            code: "InvalidOperation",
+            message: "version on create must be 0"
+          },
+          400
+        );
+      }
+    }
+    resource.version += 1;
+    this._storage.add(context.projectKey, this.getTypeId(), resource);
+  }
+};
+
+// src/repositories/cart-discount.ts
+var CartDiscountRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      setKey: (context, resource, { key }) => {
+        resource.key = key;
+      },
+      setDescription: (context, resource, { description }) => {
+        resource.description = description;
+      },
+      setValidFrom: (context, resource, { validFrom }) => {
+        resource.validFrom = validFrom;
+      },
+      setValidUntil: (context, resource, { validUntil }) => {
+        resource.validUntil = validUntil;
+      },
+      setValidFromAndUntil: (context, resource, { validFrom, validUntil }) => {
+        resource.validFrom = validFrom;
+        resource.validUntil = validUntil;
+      },
+      changeSortOrder: (context, resource, { sortOrder }) => {
+        resource.sortOrder = sortOrder;
+      },
+      changeIsActive: (context, resource, { isActive }) => {
+        resource.isActive = isActive;
+      }
+    };
+  }
+  getTypeId() {
+    return "cart-discount";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      description: draft.description,
+      cartPredicate: draft.cartPredicate,
+      isActive: draft.isActive || false,
+      name: draft.name,
+      references: [],
+      target: draft.target,
+      requiresDiscountCode: draft.requiresDiscountCode || false,
+      sortOrder: draft.sortOrder,
+      stackingMode: draft.stackingMode || "Stacking",
+      validFrom: draft.validFrom,
+      validUntil: draft.validUntil,
+      value: this.transformValueDraft(draft.value)
+    };
+    this.save(context, resource);
+    return resource;
+  }
+  transformValueDraft(value) {
+    switch (value.type) {
+      case "absolute": {
+        return {
+          type: "absolute",
+          money: value.money.map(createTypedMoney)
+        };
+      }
+      case "fixed": {
+        return {
+          type: "fixed",
+          money: value.money.map(createTypedMoney)
+        };
+      }
+      case "giftLineItem": {
+        return {
+          ...value
+        };
+      }
+      case "relative": {
+        return {
+          ...value
+        };
+      }
+    }
+    return value;
+  }
+};
+
+// src/services/cart-discount.ts
+var CartDiscountService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new CartDiscountRepository(storage);
+  }
+  getBasePath() {
+    return "cart-discounts";
+  }
+};
+
+// src/repositories/cart.ts
+var import_uuid3 = require("uuid");
+var CartRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      addLineItem: (context, resource, { productId, variantId, sku, quantity = 1 }) => {
+        var _a;
+        let product = null;
+        let variant;
+        if (productId && variantId) {
+          product = this._storage.get(
+            context.projectKey,
+            "product",
+            productId,
+            {}
+          );
+        } else if (sku) {
+          const items = this._storage.query(context.projectKey, "product", {
+            where: [
+              `masterData(current(masterVariant(sku="${sku}"))) or masterData(current(variants(sku="${sku}")))`
+            ]
+          });
+          if (items.count === 1) {
+            product = items.results[0];
+          }
+        }
+        if (!product) {
+          throw new CommercetoolsError({
+            code: "General",
+            message: sku ? `A product containing a variant with SKU '${sku}' not found.` : `A product with ID '${productId}' not found.`
+          });
+        }
+        variant = [
+          product.masterData.current.masterVariant,
+          ...product.masterData.current.variants
+        ].find((x) => {
+          if (sku)
+            return x.sku === sku;
+          if (variantId)
+            return x.id === variantId;
+          return false;
+        });
+        if (!variant) {
+          throw new CommercetoolsError({
+            code: "General",
+            message: sku ? `A variant with SKU '${sku}' for product '${product.id}' not found.` : `A variant with ID '${variantId}' for product '${product.id}' not found.`
+          });
+        }
+        const alreadyAdded = resource.lineItems.some(
+          (x) => x.productId === (product == null ? void 0 : product.id) && x.variant.id === (variant == null ? void 0 : variant.id)
+        );
+        if (alreadyAdded) {
+          resource.lineItems.map((x) => {
+            if (x.productId === (product == null ? void 0 : product.id) && x.variant.id === (variant == null ? void 0 : variant.id)) {
+              x.quantity += quantity;
+              x.totalPrice.centAmount = calculateLineItemTotalPrice(x);
+            }
+            return x;
+          });
+        } else {
+          if (!((_a = variant.prices) == null ? void 0 : _a.length)) {
+            throw new CommercetoolsError({
+              code: "General",
+              message: `A product with ID '${productId}' doesn't have any prices.`
+            });
+          }
+          const currency = resource.totalPrice.currencyCode;
+          const price = selectPrice({
+            prices: variant.prices,
+            currency,
+            country: resource.country
+          });
+          if (!price) {
+            throw new Error(
+              `No valid price found for ${productId} for country ${resource.country} and currency ${currency}`
+            );
+          }
+          resource.lineItems.push({
+            id: (0, import_uuid3.v4)(),
+            productId: product.id,
+            productKey: product.key,
+            name: product.masterData.current.name,
+            productSlug: product.masterData.current.slug,
+            productType: product.productType,
+            variant,
+            price,
+            totalPrice: {
+              ...price.value,
+              centAmount: price.value.centAmount * quantity
+            },
+            quantity,
+            discountedPricePerQuantity: [],
+            lineItemMode: "Standard",
+            priceMode: "Platform",
+            state: []
+          });
+        }
+        resource.totalPrice.centAmount = calculateCartTotalPrice(resource);
+      },
+      removeLineItem: (context, resource, { lineItemId, quantity }) => {
+        const lineItem = resource.lineItems.find((x) => x.id === lineItemId);
+        if (!lineItem) {
+          throw new CommercetoolsError({
+            code: "General",
+            message: `A line item with ID '${lineItemId}' not found.`
+          });
+        }
+        const shouldDelete = !quantity || quantity >= lineItem.quantity;
+        if (shouldDelete) {
+          resource.lineItems = resource.lineItems.filter((x) => x.id !== lineItemId);
+        } else {
+          resource.lineItems.map((x) => {
+            if (x.id === lineItemId && quantity) {
+              x.quantity -= quantity;
+              x.totalPrice.centAmount = calculateLineItemTotalPrice(x);
+            }
+            return x;
+          });
+        }
+        resource.totalPrice.centAmount = calculateCartTotalPrice(resource);
+      },
+      setBillingAddress: (context, resource, { address }) => {
+        resource.billingAddress = address;
+      },
+      setShippingMethod: (context, resource, { shippingMethod }) => {
+        const resolvedType = this._storage.getByResourceIdentifier(
+          context.projectKey,
+          shippingMethod
+        );
+        if (!resolvedType) {
+          throw new Error(`Type ${shippingMethod} not found`);
+        }
+        resource.shippingInfo = {
+          shippingMethod: {
+            typeId: "shipping-method",
+            id: resolvedType.id
+          }
+        };
+      },
+      setCountry: (context, resource, { country }) => {
+        resource.country = country;
+      },
+      setCustomerEmail: (context, resource, { email }) => {
+        resource.customerEmail = email;
+      },
+      setCustomField: (context, resource, { name, value }) => {
+        if (!resource.custom) {
+          throw new Error("Resource has no custom field");
+        }
+        resource.custom.fields[name] = value;
+      },
+      setCustomType: (context, resource, { type, fields }) => {
+        if (!type) {
+          resource.custom = void 0;
+        } else {
+          const resolvedType = this._storage.getByResourceIdentifier(
+            context.projectKey,
+            type
+          );
+          if (!resolvedType) {
+            throw new Error(`Type ${type} not found`);
+          }
+          resource.custom = {
+            type: {
+              typeId: "type",
+              id: resolvedType.id
+            },
+            fields: fields || []
+          };
+        }
+      },
+      setLocale: (context, resource, { locale }) => {
+        resource.locale = locale;
+      },
+      setShippingAddress: (context, resource, { address }) => {
+        resource.shippingAddress = address;
+      }
+    };
+    this.draftLineItemtoLineItem = (projectKey, draftLineItem, currency, country) => {
+      const { productId, quantity, variantId, sku } = draftLineItem;
+      let product = null;
+      let variant;
+      if (productId && variantId) {
+        product = this._storage.get(projectKey, "product", productId, {});
+      } else if (sku) {
+        const items = this._storage.query(projectKey, "product", {
+          where: [
+            `masterData(current(masterVariant(sku="${sku}"))) or masterData(current(variants(sku="${sku}")))`
+          ]
+        });
+        if (items.count === 1) {
+          product = items.results[0];
+        }
+      }
+      if (!product) {
+        throw new CommercetoolsError({
+          code: "General",
+          message: sku ? `A product containing a variant with SKU '${sku}' not found.` : `A product with ID '${productId}' not found.`
+        });
+      }
+      variant = [
+        product.masterData.current.masterVariant,
+        ...product.masterData.current.variants
+      ].find((x) => {
+        if (sku)
+          return x.sku === sku;
+        if (variantId)
+          return x.id === variantId;
+        return false;
+      });
+      if (!variant) {
+        throw new Error(
+          sku ? `A variant with SKU '${sku}' for product '${product.id}' not found.` : `A variant with ID '${variantId}' for product '${product.id}' not found.`
+        );
+      }
+      const quant = quantity ?? 1;
+      const price = selectPrice({ prices: variant.prices, currency, country });
+      if (!price) {
+        throw new Error(
+          `No valid price found for ${productId} for country ${country} and currency ${currency}`
+        );
+      }
+      return {
+        id: (0, import_uuid3.v4)(),
+        productId: product.id,
+        productKey: product.key,
+        name: product.masterData.current.name,
+        productSlug: product.masterData.current.slug,
+        productType: product.productType,
+        variant,
+        price,
+        totalPrice: {
+          ...price.value,
+          centAmount: price.value.centAmount * quant
+        },
+        quantity: quant,
+        discountedPricePerQuantity: [],
+        lineItemMode: "Standard",
+        priceMode: "Platform",
+        state: []
+      };
+    };
+  }
+  getTypeId() {
+    return "cart";
+  }
+  create(context, draft) {
+    var _a;
+    const lineItems = ((_a = draft.lineItems) == null ? void 0 : _a.map(
+      (draftLineItem) => this.draftLineItemtoLineItem(
+        context.projectKey,
+        draftLineItem,
+        draft.currency,
+        draft.country
+      )
+    )) ?? [];
+    const resource = {
+      ...getBaseResourceProperties(),
+      cartState: "Active",
+      lineItems,
+      customLineItems: [],
+      totalPrice: {
+        type: "centPrecision",
+        centAmount: 0,
+        currencyCode: draft.currency,
+        fractionDigits: 0
+      },
+      taxMode: draft.taxMode ?? "Platform",
+      taxRoundingMode: draft.taxRoundingMode ?? "HalfEven",
+      taxCalculationMode: draft.taxCalculationMode ?? "LineItemLevel",
+      refusedGifts: [],
+      locale: draft.locale,
+      country: draft.country,
+      origin: draft.origin ?? "Customer",
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      )
+    };
+    resource.totalPrice.centAmount = calculateCartTotalPrice(resource);
+    this.save(context, resource);
+    return resource;
+  }
+  getActiveCart(projectKey) {
+    const results = this._storage.query(projectKey, this.getTypeId(), {
+      where: [`cartState="Active"`]
+    });
+    if (results.count > 0) {
+      return results.results[0];
+    }
+    return;
+  }
+};
+var selectPrice = ({
+  prices,
+  currency,
+  country
+}) => {
+  if (!prices) {
+    return void 0;
+  }
+  return prices.find((price) => {
+    const countryMatch = !price.country || price.country === country;
+    const currencyMatch = price.value.currencyCode === currency;
+    return countryMatch && currencyMatch;
+  });
+};
+var calculateLineItemTotalPrice = (lineItem) => lineItem.price.value.centAmount * lineItem.quantity;
+var calculateCartTotalPrice = (cart) => cart.lineItems.reduce((cur, item) => cur + item.totalPrice.centAmount, 0);
+
+// src/repositories/order.ts
+var import_assert2 = __toESM(require("assert"));
+var OrderRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      addPayment: (context, resource, { payment }) => {
+        const resolvedPayment = this._storage.getByResourceIdentifier(
+          context.projectKey,
+          payment
+        );
+        if (!resolvedPayment) {
+          throw new Error(`Payment ${payment.id} not found`);
+        }
+        if (!resource.paymentInfo) {
+          resource.paymentInfo = {
+            payments: []
+          };
+        }
+        resource.paymentInfo.payments.push({
+          typeId: "payment",
+          id: payment.id
+        });
+      },
+      changeOrderState: (context, resource, { orderState }) => {
+        resource.orderState = orderState;
+      },
+      changePaymentState: (context, resource, { paymentState }) => {
+        resource.paymentState = paymentState;
+      },
+      transitionState: (context, resource, { state }) => {
+        const resolvedType = this._storage.getByResourceIdentifier(
+          context.projectKey,
+          state
+        );
+        if (!resolvedType) {
+          throw new Error(
+            `No state found with key=${state.key} or id=${state.key}`
+          );
+        }
+        resource.state = { typeId: "state", id: resolvedType.id };
+      },
+      setBillingAddress: (context, resource, { address }) => {
+        resource.billingAddress = address;
+      },
+      setCustomerEmail: (context, resource, { email }) => {
+        resource.customerEmail = email;
+      },
+      setCustomField: (context, resource, { name, value }) => {
+        if (!resource.custom) {
+          throw new Error("Resource has no custom field");
+        }
+        resource.custom.fields[name] = value;
+      },
+      setCustomType: (context, resource, { type, fields }) => {
+        if (!type) {
+          resource.custom = void 0;
+        } else {
+          const resolvedType = this._storage.getByResourceIdentifier(
+            context.projectKey,
+            type
+          );
+          if (!resolvedType) {
+            throw new Error(`Type ${type} not found`);
+          }
+          resource.custom = {
+            type: {
+              typeId: "type",
+              id: resolvedType.id
+            },
+            fields: fields || []
+          };
+        }
+      },
+      setLocale: (context, resource, { locale }) => {
+        resource.locale = locale;
+      },
+      setOrderNumber: (context, resource, { orderNumber }) => {
+        resource.orderNumber = orderNumber;
+      },
+      setShippingAddress: (context, resource, { address }) => {
+        resource.shippingAddress = address;
+      },
+      setStore: (context, resource, { store }) => {
+        if (!store)
+          return;
+        const resolvedType = this._storage.getByResourceIdentifier(
+          context.projectKey,
+          store
+        );
+        if (!resolvedType) {
+          throw new Error(`No store found with key=${store.key}`);
+        }
+        const storeReference = resolvedType;
+        resource.store = {
+          typeId: "store",
+          key: storeReference.key
+        };
+      }
+    };
+  }
+  getTypeId() {
+    return "order";
+  }
+  create(context, draft) {
+    (0, import_assert2.default)(draft.cart, "draft.cart is missing");
+    return this.createFromCart(
+      context,
+      {
+        id: draft.cart.id,
+        typeId: "cart"
+      },
+      draft.orderNumber
+    );
+  }
+  createFromCart(context, cartReference, orderNumber) {
+    const cart = this._storage.getByResourceIdentifier(
+      context.projectKey,
+      cartReference
+    );
+    if (!cart) {
+      throw new Error("Cannot find cart");
+    }
+    const resource = {
+      ...getBaseResourceProperties(),
+      orderNumber,
+      cart: cartReference,
+      orderState: "Open",
+      lineItems: [],
+      customLineItems: [],
+      totalPrice: cart.totalPrice,
+      refusedGifts: [],
+      origin: "Customer",
+      syncInfo: [],
+      store: context.storeKey ? {
+        key: context.storeKey,
+        typeId: "store"
+      } : void 0,
+      lastMessageSequenceNumber: 0
+    };
+    this.save(context, resource);
+    return resource;
+  }
+  import(context, draft) {
+    var _a, _b;
+    (0, import_assert2.default)(this, "OrderRepository not valid");
+    const resource = {
+      ...getBaseResourceProperties(),
+      billingAddress: draft.billingAddress,
+      shippingAddress: draft.shippingAddress,
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      ),
+      customerEmail: draft.customerEmail,
+      lastMessageSequenceNumber: 0,
+      orderNumber: draft.orderNumber,
+      orderState: draft.orderState || "Open",
+      origin: draft.origin || "Customer",
+      paymentState: draft.paymentState,
+      refusedGifts: [],
+      store: resolveStoreReference(
+        draft.store,
+        context.projectKey,
+        this._storage
+      ),
+      syncInfo: [],
+      lineItems: ((_a = draft.lineItems) == null ? void 0 : _a.map(
+        (item) => this.lineItemFromImportDraft.bind(this)(context, item)
+      )) || [],
+      customLineItems: ((_b = draft.customLineItems) == null ? void 0 : _b.map(
+        (item) => this.customLineItemFromImportDraft.bind(this)(context, item)
+      )) || [],
+      totalPrice: {
+        type: "centPrecision",
+        ...draft.totalPrice,
+        fractionDigits: 2
+      }
+    };
+    this.save(context, resource);
+    return resource;
+  }
+  lineItemFromImportDraft(context, draft) {
+    let product;
+    let variant;
+    if (draft.variant.sku) {
+      variant = {
+        id: 0,
+        sku: draft.variant.sku
+      };
+      var items = this._storage.query(context.projectKey, "product", {
+        where: [
+          `masterData(current(masterVariant(sku="${draft.variant.sku}"))) or masterData(current(variants(sku="${draft.variant.sku}")))`
+        ]
+      });
+      if (items.count !== 1) {
+        throw new CommercetoolsError({
+          code: "General",
+          message: `A product containing a variant with SKU '${draft.variant.sku}' not found.`
+        });
+      }
+      product = items.results[0];
+      if (product.masterData.current.masterVariant.sku === draft.variant.sku) {
+        variant = product.masterData.current.masterVariant;
+      } else {
+        variant = product.masterData.current.variants.find(
+          (v) => v.sku === draft.variant.sku
+        );
+      }
+      if (!variant) {
+        throw new Error("Internal state error");
+      }
+    } else {
+      throw new Error("No product found");
+    }
+    const lineItem = {
+      ...getBaseResourceProperties(),
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      ),
+      discountedPricePerQuantity: [],
+      lineItemMode: "Standard",
+      name: draft.name,
+      price: createPrice(draft.price),
+      priceMode: "Platform",
+      productId: product.id,
+      productType: product.productType,
+      quantity: draft.quantity,
+      state: draft.state || [],
+      taxRate: draft.taxRate,
+      totalPrice: createTypedMoney(draft.price.value),
+      variant: {
+        id: variant.id,
+        sku: variant.sku,
+        price: createPrice(draft.price)
+      }
+    };
+    return lineItem;
+  }
+  customLineItemFromImportDraft(context, draft) {
+    const lineItem = {
+      ...getBaseResourceProperties(),
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      ),
+      discountedPricePerQuantity: [],
+      money: createTypedMoney(draft.money),
+      name: draft.name,
+      quantity: draft.quantity,
+      slug: draft.slug,
+      state: [],
+      totalPrice: createTypedMoney(draft.money)
+    };
+    return lineItem;
+  }
+  getWithOrderNumber(context, orderNumber, params = {}) {
+    const result = this._storage.query(context.projectKey, this.getTypeId(), {
+      ...params,
+      where: [`orderNumber="${orderNumber}"`]
+    });
+    if (result.count === 1) {
+      return result.results[0];
+    }
+    if (result.count > 1) {
+      throw new Error("Duplicate order numbers");
+    }
+    return;
+  }
+};
+
+// src/services/cart.ts
+var CartService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new CartRepository(storage);
+    this.orderRepository = new OrderRepository(storage);
+  }
+  getBasePath() {
+    return "carts";
+  }
+  extraRoutes(parent) {
+    parent.post("/replicate", (request, response) => {
+      const context = getRepositoryContext(request);
+      const cartOrOrder = request.body.reference.typeId === "order" ? this.orderRepository.get(context, request.body.reference.id) : this.repository.get(context, request.body.reference.id);
+      if (!cartOrOrder) {
+        return response.status(400).send();
+      }
+      const cartDraft = {
+        ...cartOrOrder,
+        currency: cartOrOrder.totalPrice.currencyCode,
+        discountCodes: [],
+        lineItems: cartOrOrder.lineItems.map((lineItem) => {
+          return {
+            ...lineItem,
+            variantId: lineItem.variant.id,
+            sku: lineItem.variant.sku
+          };
+        })
+      };
+      const newCart = this.repository.create(context, cartDraft);
+      return response.status(200).send(newCart);
+    });
+  }
+};
+
+// src/repositories/category.ts
+var import_uuid4 = require("uuid");
+var CategoryRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      changeAssetName: (context, resource, { assetId, assetKey, name }) => {
+        var _a;
+        (_a = resource.assets) == null ? void 0 : _a.forEach((asset) => {
+          if (assetId && assetId === asset.id) {
+            asset.name = name;
+          }
+          if (assetKey && assetKey === asset.key) {
+            asset.name = name;
+          }
+        });
+      },
+      changeSlug: (context, resource, { slug }) => {
+        resource.slug = slug;
+      },
+      setKey: (context, resource, { key }) => {
+        resource.key = key;
+      },
+      setAssetDescription: (context, resource, { assetId, assetKey, description }) => {
+        var _a;
+        (_a = resource.assets) == null ? void 0 : _a.forEach((asset) => {
+          if (assetId && assetId === asset.id) {
+            asset.description = description;
+          }
+          if (assetKey && assetKey === asset.key) {
+            asset.description = description;
+          }
+        });
+      },
+      setAssetSources: (context, resource, { assetId, assetKey, sources }) => {
+        var _a;
+        (_a = resource.assets) == null ? void 0 : _a.forEach((asset) => {
+          if (assetId && assetId === asset.id) {
+            asset.sources = sources;
+          }
+          if (assetKey && assetKey === asset.key) {
+            asset.sources = sources;
+          }
+        });
+      },
+      setDescription: (context, resource, { description }) => {
+        resource.description = description;
+      },
+      setMetaDescription: (context, resource, { metaDescription }) => {
+        resource.metaDescription = metaDescription;
+      },
+      setMetaKeywords: (context, resource, { metaKeywords }) => {
+        resource.metaKeywords = metaKeywords;
+      },
+      setMetaTitle: (context, resource, { metaTitle }) => {
+        resource.metaTitle = metaTitle;
+      },
+      setCustomType: (context, resource, { type, fields }) => {
+        if (type) {
+          resource.custom = createCustomFields(
+            { type, fields },
+            context.projectKey,
+            this._storage
+          );
+        } else {
+          resource.custom = void 0;
+        }
+      },
+      setCustomField: (context, resource, { name, value }) => {
+        if (!resource.custom) {
+          return;
+        }
+        if (value === null) {
+          delete resource.custom.fields[name];
+        } else {
+          resource.custom.fields[name] = value;
+        }
+      }
+    };
+  }
+  getTypeId() {
+    return "category";
+  }
+  create(context, draft) {
+    var _a;
+    const resource = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      name: draft.name,
+      slug: draft.slug,
+      orderHint: draft.orderHint || "",
+      externalId: draft.externalId || "",
+      parent: draft.parent ? { typeId: "category", id: draft.parent.id } : void 0,
+      ancestors: [],
+      assets: ((_a = draft.assets) == null ? void 0 : _a.map((d) => {
+        return {
+          id: (0, import_uuid4.v4)(),
+          name: d.name,
+          description: d.description,
+          sources: d.sources,
+          tags: d.tags,
+          key: d.key,
+          custom: createCustomFields(
+            draft.custom,
+            context.projectKey,
+            this._storage
+          )
+        };
+      })) || [],
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      )
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/category.ts
+var CategoryServices = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new CategoryRepository(storage);
+  }
+  getBasePath() {
+    return "categories";
+  }
+};
+
+// src/repositories/channel.ts
+var ChannelRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      changeKey: (context, resource, { key }) => {
+        resource.key = key;
+      },
+      changeName: (context, resource, { name }) => {
+        resource.name = name;
+      },
+      changeDescription: (context, resource, { description }) => {
+        resource.description = description;
+      },
+      setAddress: (context, resource, { address }) => {
+        resource.address = createAddress(
+          address,
+          context.projectKey,
+          this._storage
+        );
+      },
+      setGeoLocation: (context, resource, { geoLocation }) => {
+        resource.geoLocation = geoLocation;
+      },
+      setCustomType: (context, resource, { type, fields }) => {
+        if (type) {
+          resource.custom = createCustomFields(
+            { type, fields },
+            context.projectKey,
+            this._storage
+          );
+        } else {
+          resource.custom = void 0;
+        }
+      },
+      setCustomField: (context, resource, { name, value }) => {
+        if (!resource.custom) {
+          return;
+        }
+        if (value === null) {
+          delete resource.custom.fields[name];
+        } else {
+          resource.custom.fields[name] = value;
+        }
+      }
+    };
+  }
+  getTypeId() {
+    return "channel";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      name: draft.name,
+      description: draft.description,
+      roles: draft.roles || [],
+      geoLocation: draft.geoLocation,
+      address: createAddress(draft.address, context.projectKey, this._storage),
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      )
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/channel.ts
+var ChannelService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new ChannelRepository(storage);
+  }
+  getBasePath() {
+    return "channels";
+  }
+};
+
+// src/repositories/customer-group.ts
+var CustomerGroupRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      setKey: (context, resource, { key }) => {
+        resource.key = key;
+      },
+      changeName: (context, resource, { name }) => {
+        resource.name = name;
+      },
+      setCustomType: (context, resource, { type, fields }) => {
+        if (type) {
+          resource.custom = createCustomFields(
+            { type, fields },
+            context.projectKey,
+            this._storage
+          );
+        } else {
+          resource.custom = void 0;
+        }
+      },
+      setCustomField: (context, resource, { name, value }) => {
+        if (!resource.custom) {
+          return;
+        }
+        if (value === null) {
+          delete resource.custom.fields[name];
+        } else {
+          resource.custom.fields[name] = value;
+        }
+      }
+    };
+  }
+  getTypeId() {
+    return "customer";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      name: draft.groupName,
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      )
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/customer-group.ts
+var CustomerGroupService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new CustomerGroupRepository(storage);
+  }
+  getBasePath() {
+    return "customer-groups";
+  }
+};
+
+// src/repositories/customer.ts
+var CustomerRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      changeEmail: (_context, resource, { email }) => {
+        resource.email = email;
+      }
+    };
+  }
+  getTypeId() {
+    return "customer";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      email: draft.email,
+      password: draft.password ? Buffer.from(draft.password).toString("base64") : void 0,
+      isEmailVerified: draft.isEmailVerified || false,
+      addresses: []
+    };
+    this.save(context, resource);
+    return resource;
+  }
+  getMe(context) {
+    const results = this._storage.query(
+      context.projectKey,
+      this.getTypeId(),
+      {}
+    );
+    if (results.count > 0) {
+      return results.results[0];
+    }
+    return;
+  }
+};
+
+// src/services/customer.ts
+var import_uuid5 = require("uuid");
+var CustomerService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new CustomerRepository(storage);
+  }
+  getBasePath() {
+    return "customers";
+  }
+  extraRoutes(parent) {
+    parent.post("/password-token", (request, response) => {
+      const customer = this.repository.query(getRepositoryContext(request), {
+        where: [`email="${request.body.email}"`]
+      });
+      const ttlMinutes = request.params.ttlMinutes ? +request.params.ttlMinutes : 34560;
+      const { version, ...rest } = getBaseResourceProperties();
+      return response.status(200).send({
+        ...rest,
+        customerId: customer.results[0].id,
+        expiresAt: new Date(Date.now() + ttlMinutes * 60).toISOString(),
+        value: (0, import_uuid5.v4)()
+      });
+    });
+  }
+};
+
+// src/repositories/custom-object.ts
+var CustomObjectRepository = class extends AbstractResourceRepository {
+  getTypeId() {
+    return "key-value-document";
+  }
+  create(context, draft) {
+    const current = this.getWithContainerAndKey(
+      context,
+      draft.container,
+      draft.key
+    );
+    const baseProperties = getBaseResourceProperties();
+    if (current) {
+      baseProperties.id = current.id;
+      if (!draft.version) {
+        draft.version = current.version;
+      }
+      checkConcurrentModification(current, draft.version);
+      if (draft.value === current.value) {
+        return current;
+      }
+      baseProperties.version = current.version;
+    } else {
+      if (draft.version) {
+        baseProperties.version = draft.version;
+      }
+    }
+    const resource = {
+      ...baseProperties,
+      container: draft.container,
+      key: draft.key,
+      value: draft.value
+    };
+    this.save(context, resource);
+    return resource;
+  }
+  getWithContainerAndKey(context, container, key) {
+    const items = this._storage.all(
+      context.projectKey,
+      this.getTypeId()
+    );
+    return items.find((item) => item.container === container && item.key === key);
+  }
+};
+
+// src/services/custom-object.ts
+var CustomObjectService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new CustomObjectRepository(storage);
+  }
+  getBasePath() {
+    return "custom-objects";
+  }
+  extraRoutes(router) {
+    router.get("/:container/:key", this.getWithContainerAndKey.bind(this));
+    router.post("/:container/:key", this.createWithContainerAndKey.bind(this));
+    router.delete("/:container/:key", this.deleteWithContainerAndKey.bind(this));
+  }
+  getWithContainerAndKey(request, response) {
+    const result = this.repository.getWithContainerAndKey(
+      getRepositoryContext(request),
+      request.params.container,
+      request.params.key
+    );
+    if (!result) {
+      return response.status(404).send("Not Found");
+    }
+    return response.status(200).send(result);
+  }
+  createWithContainerAndKey(request, response) {
+    const draft = {
+      ...request.body,
+      key: request.params.key,
+      container: request.params.container
+    };
+    const result = this.repository.create(getRepositoryContext(request), draft);
+    return response.status(200).send(result);
+  }
+  deleteWithContainerAndKey(request, response) {
+    const current = this.repository.getWithContainerAndKey(
+      getRepositoryContext(request),
+      request.params.container,
+      request.params.key
+    );
+    if (!current) {
+      return response.status(404).send("Not Found");
+    }
+    const result = this.repository.delete(
+      getRepositoryContext(request),
+      current.id
+    );
+    return response.status(200).send(result);
+  }
+};
+
+// src/repositories/discount-code.ts
+var DiscountCodeRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      changeIsActive: (context, resource, { isActive }) => {
+        resource.isActive = isActive;
+      },
+      changeCartDiscounts: (context, resource, { cartDiscounts }) => {
+        resource.cartDiscounts = cartDiscounts.map(
+          (obj) => ({
+            typeId: "cart-discount",
+            id: obj.id
+          })
+        );
+      },
+      setDescription: (context, resource, { description }) => {
+        resource.description = description;
+      },
+      setCartPredicate: (context, resource, { cartPredicate }) => {
+        resource.cartPredicate = cartPredicate;
+      },
+      setName: (context, resource, { name }) => {
+        resource.name = name;
+      },
+      setMaxApplications: (context, resource, { maxApplications }) => {
+        resource.maxApplications = maxApplications;
+      },
+      setMaxApplicationsPerCustomer: (context, resource, {
+        maxApplicationsPerCustomer
+      }) => {
+        resource.maxApplicationsPerCustomer = maxApplicationsPerCustomer;
+      },
+      setValidFrom: (context, resource, { validFrom }) => {
+        resource.validFrom = validFrom;
+      },
+      setValidUntil: (context, resource, { validUntil }) => {
+        resource.validUntil = validUntil;
+      },
+      setValidFromAndUntil: (context, resource, { validFrom, validUntil }) => {
+        resource.validFrom = validFrom;
+        resource.validUntil = validUntil;
+      },
+      setCustomType: (context, resource, { type, fields }) => {
+        if (type) {
+          resource.custom = createCustomFields(
+            { type, fields },
+            context.projectKey,
+            this._storage
+          );
+        } else {
+          resource.custom = void 0;
+        }
+      },
+      setCustomField: (context, resource, { name, value }) => {
+        if (!resource.custom) {
+          return;
+        }
+        if (value === null) {
+          delete resource.custom.fields[name];
+        } else {
+          resource.custom.fields[name] = value;
+        }
+      }
+    };
+  }
+  getTypeId() {
+    return "cart-discount";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      applicationVersion: 1,
+      cartDiscounts: draft.cartDiscounts.map(
+        (obj) => ({
+          typeId: "cart-discount",
+          id: obj.id
+        })
+      ),
+      cartPredicate: draft.cartPredicate,
+      code: draft.code,
+      description: draft.description,
+      groups: draft.groups || [],
+      isActive: draft.isActive || true,
+      name: draft.name,
+      references: [],
+      validFrom: draft.validFrom,
+      validUntil: draft.validUntil,
+      maxApplications: draft.maxApplications,
+      maxApplicationsPerCustomer: draft.maxApplicationsPerCustomer,
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      )
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/discount-code.ts
+var DiscountCodeService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new DiscountCodeRepository(storage);
+  }
+  getBasePath() {
+    return "discount-codes";
+  }
+};
+
+// src/repositories/extension.ts
+var ExtensionRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      setKey: (context, resource, { key }) => {
+        resource.key = key;
+      },
+      setTimeoutInMs: (context, resource, { timeoutInMs }) => {
+        resource.timeoutInMs = timeoutInMs;
+      },
+      changeTriggers: (context, resource, { triggers }) => {
+        resource.triggers = triggers;
+      },
+      changeDestination: (context, resource, { destination }) => {
+        resource.destination = destination;
+      }
+    };
+  }
+  getTypeId() {
+    return "extension";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      timeoutInMs: draft.timeoutInMs,
+      destination: draft.destination,
+      triggers: draft.triggers
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/extension.ts
+var ExtensionServices = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new ExtensionRepository(storage);
+  }
+  getBasePath() {
+    return "extensions";
+  }
+};
+
+// src/repositories/inventory-entry.ts
+var InventoryEntryRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      changeQuantity: (context, resource, { quantity }) => {
+        resource.quantityOnStock = quantity;
+        resource.availableQuantity = quantity;
+      },
+      setExpectedDelivery: (context, resource, { expectedDelivery }) => {
+        resource.expectedDelivery = new Date(expectedDelivery).toISOString();
+      },
+      setCustomField: (context, resource, { name, value }) => {
+        if (!resource.custom) {
+          throw new Error("Resource has no custom field");
+        }
+        resource.custom.fields[name] = value;
+      },
+      setCustomType: (context, resource, { type, fields }) => {
+        if (!type) {
+          resource.custom = void 0;
+        } else {
+          const resolvedType = this._storage.getByResourceIdentifier(
+            context.projectKey,
+            type
+          );
+          if (!resolvedType) {
+            throw new Error(`Type ${type} not found`);
+          }
+          resource.custom = {
+            type: {
+              typeId: "type",
+              id: resolvedType.id
+            },
+            fields: fields || []
+          };
+        }
+      },
+      setRestockableInDays: (context, resource, { restockableInDays }) => {
+        resource.restockableInDays = restockableInDays;
+      }
+    };
+  }
+  getTypeId() {
+    return "inventory-entry";
+  }
+  create(context, draft) {
+    var _a;
+    const resource = {
+      ...getBaseResourceProperties(),
+      sku: draft.sku,
+      quantityOnStock: draft.quantityOnStock,
+      availableQuantity: draft.quantityOnStock,
+      expectedDelivery: draft.expectedDelivery,
+      restockableInDays: draft.restockableInDays,
+      supplyChannel: {
+        ...draft.supplyChannel,
+        typeId: "channel",
+        id: ((_a = draft.supplyChannel) == null ? void 0 : _a.id) ?? ""
+      },
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      )
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/inventory-entry.ts
+var InventoryEntryService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new InventoryEntryRepository(storage);
+  }
+  getBasePath() {
+    return "inventory";
+  }
+};
+
+// src/services/my-cart.ts
+var import_express3 = require("express");
+var MyCartService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new CartRepository(storage);
+  }
+  getBasePath() {
+    return "me";
+  }
+  registerRoutes(parent) {
+    const basePath = this.getBasePath();
+    const router = (0, import_express3.Router)({ mergeParams: true });
+    this.extraRoutes(router);
+    router.get("/active-cart", this.activeCart.bind(this));
+    router.get("/carts/", this.get.bind(this));
+    router.get("/carts/:id", this.getWithId.bind(this));
+    router.delete("/carts/:id", this.deletewithId.bind(this));
+    router.post("/carts/", this.post.bind(this));
+    router.post("/carts/:id", this.postWithId.bind(this));
+    parent.use(`/${basePath}`, router);
+  }
+  activeCart(request, response) {
+    const resource = this.repository.getActiveCart(request.params.projectKey);
+    if (!resource) {
+      return response.status(404).send("Not found");
+    }
+    return response.status(200).send(resource);
+  }
+};
+
+// src/repositories/payment.ts
+var import_uuid6 = require("uuid");
+var PaymentRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.transactionFromTransactionDraft = (draft, context) => ({
+      ...draft,
+      id: (0, import_uuid6.v4)(),
+      amount: createTypedMoney(draft.amount),
+      custom: createCustomFields(draft.custom, context.projectKey, this._storage)
+    });
+    this.actions = {
+      setCustomField: (context, resource, { name, value }) => {
+        if (!resource.custom) {
+          throw new Error("Resource has no custom field");
+        }
+        resource.custom.fields[name] = value;
+      },
+      setCustomType: (context, resource, { type, fields }) => {
+        if (!type) {
+          resource.custom = void 0;
+        } else {
+          const resolvedType = this._storage.getByResourceIdentifier(
+            context.projectKey,
+            type
+          );
+          if (!resolvedType) {
+            throw new Error(`Type ${type} not found`);
+          }
+          resource.custom = {
+            type: {
+              typeId: "type",
+              id: resolvedType.id
+            },
+            fields: fields || []
+          };
+        }
+      },
+      addTransaction: (context, resource, { transaction }) => {
+        resource.transactions = [
+          ...resource.transactions,
+          this.transactionFromTransactionDraft(transaction, context)
+        ];
+      },
+      changeTransactionState: (_context, resource, { transactionId, state }) => {
+        const index = resource.transactions.findIndex(
+          (e) => e.id === transactionId
+        );
+        const updatedTransaction = {
+          ...resource.transactions[index],
+          state
+        };
+        resource.transactions[index] = updatedTransaction;
+      },
+      transitionState: (context, resource, { state }) => {
+        const stateObj = this._storage.getByResourceIdentifier(
+          context.projectKey,
+          state
+        );
+        if (!stateObj) {
+          throw new Error(`State ${state} not found`);
+        }
+        resource.paymentStatus.state = {
+          typeId: "state",
+          id: stateObj.id,
+          obj: stateObj
+        };
+      }
+    };
+  }
+  getTypeId() {
+    return "payment";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      amountPlanned: createTypedMoney(draft.amountPlanned),
+      paymentMethodInfo: draft.paymentMethodInfo,
+      paymentStatus: draft.paymentStatus ? {
+        ...draft.paymentStatus,
+        state: draft.paymentStatus.state ? getReferenceFromResourceIdentifier(
+          draft.paymentStatus.state,
+          context.projectKey,
+          this._storage
+        ) : void 0
+      } : {},
+      transactions: (draft.transactions || []).map(
+        (t) => this.transactionFromTransactionDraft(t, context)
+      ),
+      interfaceInteractions: (draft.interfaceInteractions || []).map(
+        (interaction) => createCustomFields(interaction, context.projectKey, this._storage)
+      ),
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      )
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/my-payment.ts
+var MyPaymentService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new PaymentRepository(storage);
+  }
+  getBasePath() {
+    return "me/payments";
+  }
+};
+
+// src/services/order.ts
+var OrderService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new OrderRepository(storage);
+  }
+  getBasePath() {
+    return "orders";
+  }
+  extraRoutes(router) {
+    router.post("/import", this.import.bind(this));
+    router.get("/order-number=:orderNumber", this.getWithOrderNumber.bind(this));
+  }
+  import(request, response) {
+    const importDraft = request.body;
+    const resource = this.repository.import(
+      getRepositoryContext(request),
+      importDraft
+    );
+    return response.status(200).send(resource);
+  }
+  getWithOrderNumber(request, response) {
+    const resource = this.repository.getWithOrderNumber(
+      getRepositoryContext(request),
+      request.params.orderNumber,
+      request.query
+    );
+    if (resource) {
+      return response.status(200).send(resource);
+    }
+    return response.status(404).send("Not found");
+  }
+};
+
+// src/services/payment.ts
+var PaymentService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new PaymentRepository(storage);
+  }
+  getBasePath() {
+    return "payments";
+  }
+};
+
+// src/repositories/product-discount.ts
+var ProductDiscountRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      setKey: (context, resource, { key }) => {
+        resource.key = key;
+      },
+      setDescription: (context, resource, { description }) => {
+        if (description && Object.keys(description).length > 0) {
+          resource.description = description;
+        } else {
+          resource.description = void 0;
+        }
+      },
+      changeName: (context, resource, { name }) => {
+        resource.name = name;
+      },
+      changeValue: (context, resource, { value }) => {
+        resource.value = this.transformValueDraft(value);
+      },
+      changePredicate: (context, resource, { predicate }) => {
+        resource.predicate = predicate;
+      },
+      changeSortOrder: (context, resource, { sortOrder }) => {
+        resource.sortOrder = sortOrder;
+      },
+      changeIsActive: (context, resource, { isActive }) => {
+        resource.isActive = isActive;
+      },
+      setValidFrom: (context, resource, { validFrom }) => {
+        resource.validFrom = validFrom;
+      },
+      setValidUntil: (context, resource, { validUntil }) => {
+        resource.validUntil = validUntil;
+      },
+      setValidFromAndUntil: (context, resource, { validFrom, validUntil }) => {
+        resource.validFrom = validFrom;
+        resource.validUntil = validUntil;
+      }
+    };
+  }
+  getTypeId() {
+    return "product-discount";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      name: draft.name,
+      description: draft.description,
+      value: this.transformValueDraft(draft.value),
+      predicate: draft.predicate,
+      sortOrder: draft.sortOrder,
+      isActive: draft.isActive || false,
+      validFrom: draft.validFrom,
+      validUntil: draft.validUntil,
+      references: []
+    };
+    this.save(context, resource);
+    return resource;
+  }
+  transformValueDraft(value) {
+    switch (value.type) {
+      case "absolute": {
+        return {
+          type: "absolute",
+          money: value.money.map(createTypedMoney)
+        };
+      }
+      case "external": {
+        return {
+          type: "external"
+        };
+      }
+      case "relative": {
+        return {
+          ...value
+        };
+      }
+    }
+  }
+  getWithKey(context, key) {
+    const result = this._storage.query(context.projectKey, this.getTypeId(), {
+      where: [`key="${key}"`]
+    });
+    if (result.count === 1) {
+      return result.results[0];
+    }
+    if (result.count > 1) {
+      throw new Error("Duplicate product discount key");
+    }
+    return;
+  }
+};
+
+// src/services/product-discount.ts
+var ProductDiscountService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new ProductDiscountRepository(storage);
+  }
+  getBasePath() {
+    return "product-discounts";
+  }
+  extraRoutes(router) {
+    router.get("/key=:key", this.getWithKey.bind(this));
+  }
+  getWithKey(request, response) {
+    const resource = this.repository.getWithKey(
+      getRepositoryContext(request),
+      request.params.key
+    );
+    if (resource) {
+      return response.status(200).send(resource);
+    }
+    return response.status(404).send("Not found");
+  }
+};
+
+// src/lib/projectionSearchFilter.ts
+var import_perplex2 = __toESM(require("perplex"));
+var import_pratt2 = __toESM(require("pratt"));
+var parseFilterExpression = (filter, staged) => {
+  const exprFunc = generateMatchFunc2(filter);
+  const [source] = filter.split(":", 1);
+  if (source.startsWith("variants.")) {
+    return filterVariants(source, staged, exprFunc);
+  }
+  return filterProduct(source, exprFunc);
+};
+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 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 }) => {
+    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 {
+      source: left,
+      type: expressions[0].type,
+      children: expressions
+    };
+  }).nud("STRING", 20, (t) => {
+    return {
+      type: "Symbol",
+      kind: "string",
+      value: t.token.groups[1]
+    };
+  }).nud("INT", 5, (t) => {
+    return {
+      type: "Symbol",
+      kind: "int",
+      value: parseInt(t.token.match, 10)
+    };
+  }).nud("STAR", 5, (t) => {
+    return {
+      type: "Symbol",
+      kind: "any",
+      value: null
+    };
+  }).nud("EXISTS", 10, ({ bp }) => {
+    return {
+      type: "FilterExpression",
+      match: (obj) => {
+        return obj !== void 0;
+      }
+    };
+  }).nud("MISSING", 10, ({ bp }) => {
+    return {
+      type: "FilterExpression",
+      match: (obj) => {
+        return 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 = 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();
+  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}'.`);
+  }
+  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) => {
+    const value = nestedLookup(p, source);
+    return exprFunc(value);
+  };
+};
+var filterVariants = (source, staged, exprFunc) => {
+  return (p, markMatchingVariants) => {
+    const [, ...paths] = source.split(".");
+    const path = paths.join(".");
+    const variants = getVariants(p, staged);
+    for (const variant of variants) {
+      const value = resolveVariantValue(variant, path);
+      if (exprFunc(value)) {
+        if (markMatchingVariants) {
+          variants.forEach((v) => 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, staged) => {
+  var _a, _b, _c, _d;
+  return [
+    staged ? (_a = p.masterData.staged) == null ? void 0 : _a.masterVariant : (_b = p.masterData.current) == null ? void 0 : _b.masterVariant,
+    ...staged ? (_c = p.masterData.staged) == null ? void 0 : _c.variants : (_d = p.masterData.current) == null ? void 0 : _d.variants
+  ];
+};
+
+// src/priceSelector.ts
+var applyPriceSelector = (products, selector) => {
+  var _a, _b, _c, _d, _e;
+  validatePriceSelector(selector);
+  for (const product of products) {
+    const variants = [
+      (_a = product.masterData.staged) == null ? void 0 : _a.masterVariant,
+      ...((_b = product.masterData.staged) == null ? void 0 : _b.variants) || [],
+      (_c = product.masterData.current) == null ? void 0 : _c.masterVariant,
+      ...((_d = product.masterData.current) == null ? void 0 : _d.variants) || []
+    ].filter((x) => x != void 0);
+    for (const variant of variants) {
+      const scopedPrices = ((_e = variant.prices) == null ? void 0 : _e.filter((p) => priceSelectorFilter(p, selector))) ?? [];
+      if (scopedPrices.length > 0) {
+        const price = scopedPrices[0];
+        variant.scopedPriceDiscounted = false;
+        variant.scopedPrice = {
+          ...price,
+          currentValue: price.value
+        };
+      }
+    }
+  }
+};
+var validatePriceSelector = (selector) => {
+  if ((selector.country || selector.channel || selector.customerGroup) && !selector.currency) {
+    throw new CommercetoolsError(
+      {
+        code: "InvalidInput",
+        message: "The price selecting parameters country, channel and customerGroup cannot be used without the currency."
+      },
+      400
+    );
+  }
+};
+var priceSelectorFilter = (price, selector) => {
+  var _a, _b, _c, _d;
+  if ((selector.country || price.country) && selector.country !== price.country) {
+    return false;
+  }
+  if ((selector.currency || price.value.currencyCode) && selector.currency !== price.value.currencyCode) {
+    return false;
+  }
+  if ((selector.channel || ((_a = price.channel) == null ? void 0 : _a.id)) && selector.channel !== ((_b = price.channel) == null ? void 0 : _b.id)) {
+    return false;
+  }
+  if ((selector.customerGroup || ((_c = price.customerGroup) == null ? void 0 : _c.id)) && selector.customerGroup !== ((_d = price.customerGroup) == null ? void 0 : _d.id)) {
+    return false;
+  }
+  return true;
+};
+
+// src/product-projection-search.ts
+var ProductProjectionSearch = class {
+  constructor(storage) {
+    this._storage = storage;
+  }
+  search(projectKey, params) {
+    let resources = this._storage.all(projectKey, "product").map((r) => JSON.parse(JSON.stringify(r)));
+    let markMatchingVariant = params.markMatchingVariants ?? false;
+    applyPriceSelector(resources, {
+      country: params.priceCountry,
+      channel: params.priceChannel,
+      customerGroup: params.priceCustomerGroup,
+      currency: params.priceCurrency
+    });
+    if (params.filter) {
+      try {
+        const filters = params.filter.map(
+          (f) => parseFilterExpression(f, params.staged ?? false)
+        );
+        resources = resources.filter(
+          (resource) => filters.every((f) => f(resource, markMatchingVariant))
+        );
+      } catch (err) {
+        throw new CommercetoolsError(
+          {
+            code: "InvalidInput",
+            message: err.message
+          },
+          400
+        );
+      }
+    }
+    const facets = this.getFacets(params, resources);
+    if (params["filter.query"]) {
+      try {
+        const filters = params["filter.query"].map(
+          (f) => parseFilterExpression(f, params.staged ?? false)
+        );
+        resources = resources.filter(
+          (resource) => filters.every((f) => f(resource, markMatchingVariant))
+        );
+      } catch (err) {
+        throw new CommercetoolsError(
+          {
+            code: "InvalidInput",
+            message: err.message
+          },
+          400
+        );
+      }
+    }
+    const totalResources = resources.length;
+    const offset = params.offset || 0;
+    const limit = params.limit || 20;
+    resources = resources.slice(offset, offset + limit);
+    if (params.expand !== void 0) {
+      resources = resources.map((resource) => {
+        return this._storage.expand(projectKey, resource, params.expand);
+      });
+    }
+    return {
+      count: totalResources,
+      total: resources.length,
+      offset,
+      limit,
+      results: resources.map(this.transform),
+      facets
+    };
+  }
+  transform(product) {
+    const obj = product.masterData.current;
+    return {
+      id: product.id,
+      createdAt: product.createdAt,
+      lastModifiedAt: product.lastModifiedAt,
+      version: product.version,
+      name: obj.name,
+      slug: obj.slug,
+      categories: obj.categories,
+      masterVariant: obj.masterVariant,
+      variants: obj.variants,
+      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
+var ProductProjectionRepository = class extends AbstractResourceRepository {
+  constructor(storage) {
+    super(storage);
+    this.actions = {};
+    this._searchService = new ProductProjectionSearch(storage);
+  }
+  getTypeId() {
+    return "product-projection";
+  }
+  create(context, draft) {
+    throw new Error("No valid action");
+  }
+  query(context, params = {}) {
+    return this._storage.query(context.projectKey, "product", {
+      expand: params.expand,
+      where: params.where,
+      offset: params.offset,
+      limit: params.limit
+    });
+  }
+  search(context, query) {
+    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)
+    });
+    return results;
+  }
+};
+
+// src/services/product-projection.ts
+var ProductProjectionService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new ProductProjectionRepository(storage);
+  }
+  getBasePath() {
+    return "product-projections";
+  }
+  extraRoutes(router) {
+    router.get("/search", this.search.bind(this));
+  }
+  search(request, response) {
+    const resource = this.repository.search(
+      getRepositoryContext(request),
+      request.query
+    );
+    return response.status(200).send(resource);
+  }
+};
+
+// src/repositories/product.ts
+var import_uuid7 = require("uuid");
+var ProductRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      publish: (context, resource, { scope }) => {
+        if (resource.masterData.staged) {
+          resource.masterData.current = resource.masterData.staged;
+          resource.masterData.staged = void 0;
+        }
+        resource.masterData.hasStagedChanges = false;
+        resource.masterData.published = true;
+      },
+      setAttribute: (context, resource, { variantId, sku, name, value, staged }) => {
+        const isStaged = staged !== void 0 ? staged : false;
+        const productData = getProductData(resource, isStaged);
+        const { variant, isMasterVariant, variantIndex } = getVariant(
+          productData,
+          variantId,
+          sku
+        );
+        if (!variant) {
+          throw new Error(
+            `Variant with id ${variantId} or sku ${sku} not found on product ${resource.id}`
+          );
+        }
+        if (!variant.attributes) {
+          variant.attributes = [];
+        }
+        const existingAttr = variant.attributes.find((attr) => attr.name === name);
+        if (existingAttr) {
+          existingAttr.value = value;
+        } else {
+          variant.attributes.push({
+            name,
+            value
+          });
+        }
+        if (isStaged) {
+          resource.masterData.staged = productData;
+          if (isMasterVariant) {
+            resource.masterData.staged.masterVariant = variant;
+          } else {
+            resource.masterData.staged.variants[variantIndex] = variant;
+          }
+          resource.masterData.hasStagedChanges = true;
+        } else {
+          resource.masterData.current = productData;
+          if (isMasterVariant) {
+            resource.masterData.current.masterVariant = variant;
+          } else {
+            resource.masterData.current.variants[variantIndex] = variant;
+          }
+        }
+      }
+    };
+  }
+  getTypeId() {
+    return "product";
+  }
+  create(context, draft) {
+    var _a;
+    if (!draft.masterVariant) {
+      throw new Error("Missing master variant");
+    }
+    let productType = void 0;
+    try {
+      productType = getReferenceFromResourceIdentifier(
+        draft.productType,
+        context.projectKey,
+        this._storage
+      );
+    } catch (err) {
+      console.warn(
+        `Error resolving product-type '${draft.productType.id}'. This will be throw an error in later releases.`
+      );
+      productType = {
+        typeId: "product-type",
+        id: draft.productType.id || ""
+      };
+    }
+    const productData = {
+      name: draft.name,
+      slug: draft.slug,
+      categories: [],
+      masterVariant: variantFromDraft(1, draft.masterVariant),
+      variants: ((_a = draft.variants) == null ? void 0 : _a.map((variant, index) => {
+        return variantFromDraft(index + 2, variant);
+      })) ?? [],
+      searchKeywords: draft.searchKeywords
+    };
+    const resource = {
+      ...getBaseResourceProperties(),
+      productType,
+      masterData: {
+        current: draft.publish ? productData : void 0,
+        staged: draft.publish ? void 0 : productData,
+        hasStagedChanges: draft.publish ?? true,
+        published: draft.publish ?? false
+      }
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+var getProductData = (product, staged) => {
+  if (!staged && product.masterData.current) {
+    return product.masterData.current;
+  }
+  return product.masterData.staged;
+};
+var getVariant = (productData, variantId, sku) => {
+  const variants = [productData.masterVariant, ...productData.variants];
+  const foundVariant = variants.find((variant) => {
+    if (variantId) {
+      return variant.id === variantId;
+    }
+    if (sku) {
+      return variant.sku === sku;
+    }
+    return false;
+  });
+  const isMasterVariant = foundVariant === productData.masterVariant;
+  return {
+    variant: foundVariant,
+    isMasterVariant,
+    variantIndex: !isMasterVariant && foundVariant ? productData.variants.indexOf(foundVariant) : -1
+  };
+};
+var variantFromDraft = (variantId, variant) => {
+  var _a;
+  return {
+    id: variantId,
+    sku: variant == null ? void 0 : variant.sku,
+    attributes: (variant == null ? void 0 : variant.attributes) ?? [],
+    prices: (_a = variant == null ? void 0 : variant.prices) == null ? void 0 : _a.map(priceFromDraft),
+    assets: [],
+    images: []
+  };
+};
+var priceFromDraft = (draft) => {
+  return {
+    id: (0, import_uuid7.v4)(),
+    value: {
+      currencyCode: draft.value.currencyCode,
+      centAmount: draft.value.centAmount,
+      fractionDigits: 2,
+      type: "centPrecision"
+    }
+  };
+};
+
+// src/services/product.ts
+var ProductService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new ProductRepository(storage);
+  }
+  getBasePath() {
+    return "products";
+  }
+};
+
+// src/repositories/product-type.ts
+var ProductTypeRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.attributeDefinitionFromAttributeDefinitionDraft = (_context, draft) => {
+      return {
+        ...draft,
+        attributeConstraint: draft.attributeConstraint ?? "None",
+        inputHint: draft.inputHint ?? "SingleLine",
+        inputTip: draft.inputTip && Object.keys(draft.inputTip).length > 0 ? draft.inputTip : void 0,
+        isSearchable: draft.isSearchable ?? true
+      };
+    };
+    this.actions = {
+      changeLocalizedEnumValueLabel: (context, resource, {
+        attributeName,
+        newValue
+      }) => {
+        var _a;
+        const updateAttributeType = (type) => {
+          switch (type.name) {
+            case "lenum":
+              type.values.forEach((v) => {
+                if (v.key === newValue.key) {
+                  v.label = newValue.label;
+                }
+              });
+              return;
+            case "set":
+              updateAttributeType(type.elementType);
+              return;
+          }
+        };
+        (_a = resource.attributes) == null ? void 0 : _a.forEach((value) => {
+          if (value.name === attributeName) {
+            updateAttributeType(value.type);
+          }
+        });
+      },
+      changeLabel: (context, resource, { attributeName, label }) => {
+        var _a;
+        (_a = resource.attributes) == null ? void 0 : _a.forEach((value) => {
+          if (value.name === attributeName) {
+            value.label = label;
+          }
+        });
+      },
+      addAttributeDefinition: (context, resource, { attribute }) => {
+        var _a;
+        (_a = resource.attributes) == null ? void 0 : _a.push(
+          this.attributeDefinitionFromAttributeDefinitionDraft(context, attribute)
+        );
+      },
+      changeAttributeOrder: (context, resource, { attributes }) => {
+        var _a;
+        const attrs = new Map((_a = resource.attributes) == null ? void 0 : _a.map((item) => [item.name, item]));
+        const result = [];
+        let current = resource.attributes;
+        attributes.forEach((iAttr) => {
+          const attr = attrs.get(iAttr.name);
+          if (attr === void 0) {
+            throw new Error("New attr");
+          }
+          result.push(attr);
+          current = current == null ? void 0 : current.filter((f) => {
+            return f.name !== iAttr.name;
+          });
+        });
+        resource.attributes = result;
+        if (current) {
+          resource.attributes.push(...current);
+        }
+      },
+      removeAttributeDefinition: (context, resource, { name }) => {
+        var _a;
+        resource.attributes = (_a = resource.attributes) == null ? void 0 : _a.filter((f) => {
+          return f.name !== name;
+        });
+      },
+      removeEnumValues: (context, resource, { attributeName, keys }) => {
+        var _a;
+        (_a = resource.attributes) == null ? void 0 : _a.forEach((attr) => {
+          if (attr.name == attributeName) {
+            if (attr.type.name == "enum") {
+              attr.type.values = attr.type.values.filter((v) => {
+                return !keys.includes(v.key);
+              });
+            }
+            if (attr.type.name == "set") {
+              if (attr.type.elementType.name == "enum") {
+                attr.type.elementType.values = attr.type.elementType.values.filter(
+                  (v) => {
+                    return !keys.includes(v.key);
+                  }
+                );
+              }
+            }
+          }
+        });
+      }
+    };
+  }
+  getTypeId() {
+    return "product-type";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      name: draft.name,
+      description: draft.description,
+      attributes: (draft.attributes ?? []).map(
+        (a) => this.attributeDefinitionFromAttributeDefinitionDraft(context, a)
+      )
+    };
+    this.save(context, resource);
+    return resource;
+  }
+  getWithKey(context, key) {
+    const result = this._storage.query(context.projectKey, this.getTypeId(), {
+      where: [`key="${key}"`]
+    });
+    if (result.count === 1) {
+      return result.results[0];
+    }
+    if (result.count > 1) {
+      throw new Error("Duplicate product type key");
+    }
+    return;
+  }
+};
+
+// src/services/product-type.ts
+var ProductTypeService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new ProductTypeRepository(storage);
+  }
+  getBasePath() {
+    return "product-types";
+  }
+  extraRoutes(router) {
+    router.get("/key=:key", this.getWithKey.bind(this));
+  }
+  getWithKey(request, response) {
+    const resource = this.repository.getWithKey(
+      getRepositoryContext(request),
+      request.params.key
+    );
+    if (resource) {
+      return response.status(200).send(resource);
+    }
+    return response.status(404).send("Not found");
+  }
+};
+
+// 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() {
+    super(...arguments);
+    this.actions = {
+      changeName: (context, resource, { name }) => {
+        resource.name = name;
+      },
+      changeCurrencies: (context, resource, { currencies }) => {
+        resource.currencies = currencies;
+      },
+      changeCountries: (context, resource, { countries }) => {
+        resource.countries = countries;
+      },
+      changeLanguages: (context, resource, { languages }) => {
+        resource.languages = languages;
+      },
+      changeMessagesEnabled: (context, resource, { messagesEnabled }) => {
+        resource.messages.enabled = messagesEnabled;
+      },
+      changeProductSearchIndexingEnabled: (context, resource, { enabled }) => {
+        var _a;
+        if (!((_a = resource.searchIndexing) == null ? void 0 : _a.products)) {
+          throw new Error("Invalid project state");
+        }
+        resource.searchIndexing.products.status = enabled ? "Activated" : "Deactivated";
+        resource.searchIndexing.products.lastModifiedAt = new Date().toISOString();
+      },
+      changeOrderSearchStatus: (context, resource, { status }) => {
+        var _a;
+        if (!((_a = resource.searchIndexing) == null ? void 0 : _a.orders)) {
+          throw new Error("Invalid project state");
+        }
+        resource.searchIndexing.orders.status = status;
+        resource.searchIndexing.orders.lastModifiedAt = new Date().toISOString();
+      },
+      setShippingRateInputType: (context, resource, { shippingRateInputType }) => {
+        resource.shippingRateInputType = shippingRateInputType;
+      },
+      setExternalOAuth: (context, resource, { externalOAuth }) => {
+        resource.externalOAuth = externalOAuth;
+      },
+      changeCountryTaxRateFallbackEnabled: (context, resource, {
+        countryTaxRateFallbackEnabled
+      }) => {
+        resource.carts.countryTaxRateFallbackEnabled = countryTaxRateFallbackEnabled;
+      },
+      changeCartsConfiguration: (context, resource, { cartsConfiguration }) => {
+        resource.carts = cartsConfiguration || {
+          countryTaxRateFallbackEnabled: false,
+          deleteDaysAfterLastModification: 90
+        };
+      }
+    };
+  }
+  get(context) {
+    const resource = this._storage.getProject(context.projectKey);
+    const masked = maskSecretValue(
+      resource,
+      "externalOAuth.authorizationHeader"
+    );
+    return masked;
+  }
+  save(context, resource) {
+    const current = this.get(context);
+    if (current) {
+      checkConcurrentModification(current, resource.version);
+    } else {
+      if (resource.version !== 0) {
+        throw new CommercetoolsError(
+          {
+            code: "InvalidOperation",
+            message: "version on create must be 0"
+          },
+          400
+        );
+      }
+    }
+    resource.version += 1;
+    this._storage.saveProject(resource);
+  }
+};
+
+// src/services/project.ts
+var ProjectService = class {
+  constructor(parent, storage) {
+    this.repository = new ProjectRepository(storage);
+    this.registerRoutes(parent);
+  }
+  registerRoutes(parent) {
+    parent.get("", this.get.bind(this));
+    parent.post("", this.post.bind(this));
+  }
+  get(request, response) {
+    const project = this.repository.get(getRepositoryContext(request));
+    return response.status(200).send(project);
+  }
+  post(request, response) {
+    const updateRequest = request.body;
+    const project = this.repository.get(getRepositoryContext(request));
+    if (!project) {
+      return response.status(404).send({});
+    }
+    this.repository.processUpdateActions(
+      getRepositoryContext(request),
+      project,
+      updateRequest.actions
+    );
+    return response.status(200).send({});
+  }
+};
+
+// src/repositories/shipping-method.ts
+var import_deep_equal2 = __toESM(require("deep-equal"));
+var ShippingMethodRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this._transformZoneRateDraft = (context, draft) => {
+      var _a;
+      return {
+        ...draft,
+        zone: getReferenceFromResourceIdentifier(
+          draft.zone,
+          context.projectKey,
+          this._storage
+        ),
+        shippingRates: (_a = draft.shippingRates) == null ? void 0 : _a.map(this._transformShippingRate)
+      };
+    };
+    this._transformShippingRate = (rate) => {
+      return {
+        price: createTypedMoney(rate.price),
+        freeAbove: rate.freeAbove && createTypedMoney(rate.freeAbove),
+        tiers: rate.tiers || []
+      };
+    };
+    this.actions = {
+      addShippingRate: (_context, resource, { shippingRate, zone }) => {
+        const rate = this._transformShippingRate(shippingRate);
+        resource.zoneRates.forEach((zoneRate) => {
+          if (zoneRate.zone.id === zone.id) {
+            zoneRate.shippingRates.push(rate);
+            return;
+          }
+        });
+        resource.zoneRates.push({
+          zone: {
+            typeId: "zone",
+            id: zone.id
+          },
+          shippingRates: [rate]
+        });
+      },
+      removeShippingRate: (_context, resource, { shippingRate, zone }) => {
+        const rate = this._transformShippingRate(shippingRate);
+        resource.zoneRates.forEach((zoneRate) => {
+          if (zoneRate.zone.id === zone.id) {
+            zoneRate.shippingRates = zoneRate.shippingRates.filter((otherRate) => {
+              return !(0, import_deep_equal2.default)(rate, otherRate);
+            });
+          }
+        });
+      },
+      addZone: (context, resource, { zone }) => {
+        const zoneReference = getReferenceFromResourceIdentifier(
+          zone,
+          context.projectKey,
+          this._storage
+        );
+        if (resource.zoneRates === void 0) {
+          resource.zoneRates = [];
+        }
+        resource.zoneRates.push({
+          zone: zoneReference,
+          shippingRates: []
+        });
+      },
+      removeZone: (_context, resource, { zone }) => {
+        resource.zoneRates = resource.zoneRates.filter((zoneRate) => {
+          return zoneRate.zone.id !== zone.id;
+        });
+      },
+      setKey: (_context, resource, { key }) => {
+        resource.key = key;
+      },
+      setDescription: (_context, resource, { description }) => {
+        resource.description = description;
+      },
+      setLocalizedDescription: (_context, resource, { localizedDescription }) => {
+        resource.localizedDescription = localizedDescription;
+      },
+      setPredicate: (_context, resource, { predicate }) => {
+        resource.predicate = predicate;
+      },
+      changeIsDefault: (_context, resource, { isDefault }) => {
+        resource.isDefault = isDefault;
+      },
+      changeName: (_context, resource, { name }) => {
+        resource.name = name;
+      },
+      setCustomType: (context, resource, { type, fields }) => {
+        if (type) {
+          resource.custom = createCustomFields(
+            { type, fields },
+            context.projectKey,
+            this._storage
+          );
+        } else {
+          resource.custom = void 0;
+        }
+      },
+      setCustomField: (context, resource, { name, value }) => {
+        if (!resource.custom) {
+          return;
+        }
+        if (value === null) {
+          delete resource.custom.fields[name];
+        } else {
+          resource.custom.fields[name] = value;
+        }
+      }
+    };
+  }
+  getTypeId() {
+    return "shipping-method";
+  }
+  create(context, draft) {
+    var _a;
+    const resource = {
+      ...getBaseResourceProperties(),
+      ...draft,
+      taxCategory: getReferenceFromResourceIdentifier(
+        draft.taxCategory,
+        context.projectKey,
+        this._storage
+      ),
+      zoneRates: (_a = draft.zoneRates) == null ? void 0 : _a.map(
+        (z) => this._transformZoneRateDraft(context, z)
+      ),
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      )
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/shipping-method.ts
+var ShippingMethodService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new ShippingMethodRepository(storage);
+    this.registerRoutes(parent);
+  }
+  getBasePath() {
+    return "shipping-methods";
+  }
+  extraRoutes(parent) {
+    parent.get("/matching-cart", this.get.bind(this));
+  }
+};
+
+// src/repositories/shopping-list.ts
+var ShoppingListRepository = class extends AbstractResourceRepository {
+  getTypeId() {
+    return "shopping-list";
+  }
+  create(context, draft) {
+    var _a, _b;
+    const resource = {
+      ...getBaseResourceProperties(),
+      ...draft,
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      ),
+      textLineItems: [],
+      lineItems: (_a = draft.lineItems) == null ? void 0 : _a.map((e) => ({
+        ...getBaseResourceProperties(),
+        ...e,
+        addedAt: e.addedAt ?? "",
+        productId: e.productId ?? "",
+        name: {},
+        quantity: e.quantity ?? 1,
+        productType: { typeId: "product-type", id: "" },
+        custom: createCustomFields(e.custom, context.projectKey, this._storage)
+      })),
+      customer: draft.customer ? getReferenceFromResourceIdentifier(
+        draft.customer,
+        context.projectKey,
+        this._storage
+      ) : void 0,
+      store: ((_b = draft.store) == null ? void 0 : _b.key) ? { typeId: "store", key: draft.store.key } : void 0
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/shopping-list.ts
+var ShoppingListService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new ShoppingListRepository(storage);
+  }
+  getBasePath() {
+    return "shopping-lists";
+  }
+};
+
+// src/repositories/state.ts
+var StateRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      changeKey: (context, resource, { key }) => {
+        resource.key = key;
+      },
+      setDescription: (context, resource, { description }) => {
+        resource.description = description;
+      },
+      setName: (context, resource, { name }) => {
+        resource.name = name;
+      },
+      setRoles: (context, resource, { roles }) => {
+        resource.roles = roles;
+      }
+    };
+  }
+  getTypeId() {
+    return "state";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      ...draft,
+      builtIn: false,
+      initial: draft.initial || false,
+      transitions: (draft.transitions || []).map(
+        (t) => getReferenceFromResourceIdentifier(t, context.projectKey, this._storage)
+      )
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/state.ts
+var StateService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new StateRepository(storage);
+  }
+  getBasePath() {
+    return "states";
+  }
+};
+
+// src/repositories/store.ts
+var StoreRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      setName: (context, resource, { name }) => {
+        resource.name = name;
+      },
+      setDistributionChannels: (context, resource, { distributionChannels }) => {
+        resource.distributionChannels = this.transformChannels(
+          context,
+          distributionChannels
+        );
+      },
+      setLanguages: (context, resource, { languages }) => {
+        resource.languages = languages ?? [];
+      },
+      setCustomType: (context, resource, { type, fields }) => {
+        if (type) {
+          resource.custom = createCustomFields(
+            { type, fields },
+            context.projectKey,
+            this._storage
+          );
+        } else {
+          resource.custom = void 0;
+        }
+      },
+      setCustomField: (context, resource, { name, value }) => {
+        if (!resource.custom) {
+          return;
+        }
+        if (value === null) {
+          delete resource.custom.fields[name];
+        } else {
+          resource.custom.fields[name] = value;
+        }
+      }
+    };
+  }
+  getTypeId() {
+    return "store";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      name: draft.name,
+      languages: draft.languages ?? [],
+      distributionChannels: this.transformChannels(
+        context,
+        draft.distributionChannels
+      ),
+      supplyChannels: this.transformChannels(context, draft.supplyChannels),
+      productSelections: [],
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      )
+    };
+    this.save(context, resource);
+    return resource;
+  }
+  transformChannels(context, channels) {
+    if (!channels)
+      return [];
+    return channels.map(
+      (ref) => getReferenceFromResourceIdentifier(
+        ref,
+        context.projectKey,
+        this._storage
+      )
+    );
+  }
+  getWithKey(context, key) {
+    const result = this._storage.query(context.projectKey, this.getTypeId(), {
+      where: [`key="${key}"`]
+    });
+    if (result.count === 1) {
+      return result.results[0];
+    }
+    if (result.count > 1) {
+      throw new Error("Duplicate store key");
+    }
+    return;
+  }
+};
+
+// src/services/store.ts
+var StoreService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new StoreRepository(storage);
+  }
+  getBasePath() {
+    return "stores";
+  }
+  extraRoutes(router) {
+    router.get("/key=:key", this.getWithKey.bind(this));
+  }
+  getWithKey(request, response) {
+    const resource = this.repository.getWithKey(
+      getRepositoryContext(request),
+      request.params.key
+    );
+    if (resource) {
+      return response.status(200).send(resource);
+    }
+    return response.status(404).send("Not found");
+  }
+};
+
+// src/repositories/subscription.ts
+var SubscriptionRepository = class extends AbstractResourceRepository {
+  getTypeId() {
+    return "subscription";
+  }
+  create(context, draft) {
+    if (draft.destination.type === "SQS") {
+      const queueURL = new URL(draft.destination.queueUrl);
+      const accountId = queueURL.pathname.split("/")[1];
+      if (accountId === "0000000000") {
+        const dest = draft.destination;
+        throw new CommercetoolsError(
+          {
+            code: "InvalidInput",
+            message: `A test message could not be delivered to this destination: SQS ${dest.queueUrl} in ${dest.region} for ${dest.accessKey}. Please make sure your destination is correctly configured.`
+          },
+          400
+        );
+      }
+    }
+    const resource = {
+      ...getBaseResourceProperties(),
+      changes: draft.changes || [],
+      destination: draft.destination,
+      format: draft.format || {
+        type: "Platform"
+      },
+      key: draft.key,
+      messages: draft.messages || [],
+      status: "Healthy"
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/subscription.ts
+var SubscriptionService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new SubscriptionRepository(storage);
+  }
+  getBasePath() {
+    return "subscriptions";
+  }
+};
+
+// src/repositories/tax-category.ts
+var import_uuid8 = require("uuid");
+var TaxCategoryRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.taxRateFromTaxRateDraft = (draft) => ({
+      ...draft,
+      id: (0, import_uuid8.v4)(),
+      amount: draft.amount || 0
+    });
+    this.actions = {
+      addTaxRate: (context, resource, { taxRate }) => {
+        if (resource.rates === void 0) {
+          resource.rates = [];
+        }
+        resource.rates.push(this.taxRateFromTaxRateDraft(taxRate));
+      },
+      removeTaxRate: (context, resource, { taxRateId }) => {
+        if (resource.rates === void 0) {
+          resource.rates = [];
+        }
+        resource.rates = resource.rates.filter((taxRate) => {
+          return taxRate.id !== taxRateId;
+        });
+      },
+      replaceTaxRate: (context, resource, { taxRateId, taxRate }) => {
+        if (resource.rates === void 0) {
+          resource.rates = [];
+        }
+        const taxRateObj = this.taxRateFromTaxRateDraft(taxRate);
+        for (let i = 0; i < resource.rates.length; i++) {
+          const rate = resource.rates[i];
+          if (rate.id === taxRateId) {
+            resource.rates[i] = taxRateObj;
+          }
+        }
+      },
+      setDescription: (context, resource, { description }) => {
+        resource.description = description;
+      },
+      setKey: (context, resource, { key }) => {
+        resource.key = key;
+      },
+      changeName: (context, resource, { name }) => {
+        resource.name = name;
+      }
+    };
+  }
+  getTypeId() {
+    return "tax-category";
+  }
+  create(context, draft) {
+    var _a;
+    const resource = {
+      ...getBaseResourceProperties(),
+      ...draft,
+      rates: ((_a = draft.rates) == null ? void 0 : _a.map(this.taxRateFromTaxRateDraft)) || []
+    };
+    this.save(context, resource);
+    return resource;
+  }
+  getWithKey(context, key) {
+    const result = this._storage.query(context.projectKey, this.getTypeId(), {
+      where: [`key="${key}"`]
+    });
+    if (result.count === 1) {
+      return result.results[0];
+    }
+    if (result.count > 1) {
+      throw new Error("Duplicate tax category key");
+    }
+    return;
+  }
+};
+
+// src/services/tax-category.ts
+var TaxCategoryService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new TaxCategoryRepository(storage);
+  }
+  getBasePath() {
+    return "tax-categories";
+  }
+  extraRoutes(router) {
+    router.get("/key=:key", this.getWithKey.bind(this));
+  }
+  getWithKey(request, response) {
+    const resource = this.repository.getWithKey(
+      getRepositoryContext(request),
+      request.params.key
+    );
+    if (resource) {
+      return response.status(200).send(resource);
+    }
+    return response.status(404).send("Not found");
+  }
+};
+
+// src/repositories/type.ts
+var import_lodash = require("lodash");
+var TypeRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      addFieldDefinition: (context, resource, { fieldDefinition }) => {
+        resource.fieldDefinitions.push(fieldDefinition);
+      },
+      removeFieldDefinition: (context, resource, { fieldName }) => {
+        resource.fieldDefinitions = resource.fieldDefinitions.filter((f) => {
+          return f.name !== fieldName;
+        });
+      },
+      setDescription: (context, resource, { description }) => {
+        resource.description = description;
+      },
+      changeName: (context, resource, { name }) => {
+        resource.name = name;
+      },
+      changeFieldDefinitionOrder: (context, resource, { fieldNames }) => {
+        const fields = new Map(
+          resource.fieldDefinitions.map((item) => [item.name, item])
+        );
+        const result = [];
+        let current = resource.fieldDefinitions;
+        fieldNames.forEach((fieldName) => {
+          const field = fields.get(fieldName);
+          if (field === void 0) {
+            throw new Error("New field");
+          }
+          result.push(field);
+          current = current.filter((f) => {
+            return f.name !== fieldName;
+          });
+        });
+        if ((0, import_lodash.isEqual)(
+          fieldNames,
+          resource.fieldDefinitions.map((item) => item.name)
+        )) {
+          throw new CommercetoolsError({
+            code: "InvalidOperation",
+            message: "'fieldDefinitions' has no changes.",
+            action: {
+              action: "changeFieldDefinitionOrder",
+              fieldNames
+            }
+          });
+        }
+        resource.fieldDefinitions = result;
+        resource.fieldDefinitions.push(...current);
+      },
+      addEnumValue: (context, resource, { fieldName, value }) => {
+        resource.fieldDefinitions.forEach((field) => {
+          if (field.name === fieldName) {
+            if (field.type.name === "Enum") {
+              field.type.values.push(value);
+            } else if (field.type.name === "Set" && field.type.elementType.name === "Enum") {
+              field.type.elementType.values.push(value);
+            } else {
+              throw new Error("Type is not a Enum (or Set of Enum)");
+            }
+          }
+        });
+      },
+      changeEnumValueLabel: (context, resource, { fieldName, value }) => {
+        resource.fieldDefinitions.forEach((field) => {
+          if (field.name === fieldName) {
+            if (field.type.name === "Enum") {
+              field.type.values.forEach((v) => {
+                if (v.key === value.key) {
+                  v.label = value.label;
+                }
+              });
+            } else if (field.type.name === "Set" && field.type.elementType.name === "Enum") {
+              field.type.elementType.values.forEach((v) => {
+                if (v.key === value.key) {
+                  v.label = value.label;
+                }
+              });
+            } else {
+              throw new Error("Type is not a Enum (or Set of Enum)");
+            }
+          }
+        });
+      }
+    };
+  }
+  getTypeId() {
+    return "type";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      name: draft.name,
+      resourceTypeIds: draft.resourceTypeIds,
+      fieldDefinitions: draft.fieldDefinitions || [],
+      description: draft.description
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/type.ts
+var TypeService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new TypeRepository(storage);
+  }
+  getBasePath() {
+    return "types";
+  }
+};
+
+// src/repositories/zone.ts
+var ZoneRepository = class extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      addLocation: (context, resource, { location }) => {
+        resource.locations.push(location);
+      },
+      removeLocation: (context, resource, { location }) => {
+        resource.locations = resource.locations.filter((loc) => {
+          return !(loc.country === location.country && loc.state === location.state);
+        });
+      },
+      changeName: (context, resource, { name }) => {
+        resource.name = name;
+      },
+      setDescription: (context, resource, { description }) => {
+        resource.description = description;
+      },
+      setKey: (context, resource, { key }) => {
+        resource.key = key;
+      }
+    };
+  }
+  getTypeId() {
+    return "zone";
+  }
+  create(context, draft) {
+    const resource = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      locations: draft.locations || [],
+      name: draft.name,
+      description: draft.description
+    };
+    this.save(context, resource);
+    return resource;
+  }
+};
+
+// src/services/zone.ts
+var ZoneService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new ZoneRepository(storage);
+  }
+  getBasePath() {
+    return "zones";
+  }
+};
+
+// src/services/my-customer.ts
+var import_express4 = require("express");
+var MyCustomerService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new CustomerRepository(storage);
+  }
+  getBasePath() {
+    return "me";
+  }
+  registerRoutes(parent) {
+    const basePath = this.getBasePath();
+    const router = (0, import_express4.Router)({ mergeParams: true });
+    this.extraRoutes(router);
+    router.get("", this.getMe.bind(this));
+    router.post("/signup", this.signUp.bind(this));
+    router.post("/login", this.signIn.bind(this));
+    parent.use(`/${basePath}`, router);
+  }
+  getMe(request, response) {
+    const resource = this.repository.getMe(getRepositoryContext(request));
+    if (!resource) {
+      return response.status(404).send("Not found");
+    }
+    return response.status(200).send(resource);
+  }
+  signUp(request, response) {
+    const draft = request.body;
+    const resource = this.repository.create(
+      getRepositoryContext(request),
+      draft
+    );
+    const result = this._expandWithId(request, resource.id);
+    return response.status(this.createStatusCode).send({ customer: result });
+  }
+  signIn(request, response) {
+    const { email, password } = request.body;
+    const encodedPassword = Buffer.from(password).toString("base64");
+    const result = this.repository.query(getRepositoryContext(request), {
+      where: [`email = "${email}"`, `password = "${encodedPassword}"`]
+    });
+    if (result.count === 0) {
+      return response.status(400).send({
+        message: "Account with the given credentials not found.",
+        errors: [
+          {
+            code: "InvalidCredentials",
+            message: "Account with the given credentials not found."
+          }
+        ]
+      });
+    }
+    return response.status(200).send({ customer: result.results[0] });
+  }
+};
+
+// src/services/my-order.ts
+var import_express5 = require("express");
+
+// src/repositories/my-order.ts
+var import_assert3 = __toESM(require("assert"));
+var MyOrderRepository = class extends OrderRepository {
+  create(context, draft) {
+    (0, import_assert3.default)(draft.id, "draft.id is missing");
+    const cartIdentifier = {
+      id: draft.id,
+      typeId: "cart"
+    };
+    return this.createFromCart(context, cartIdentifier);
+  }
+};
+
+// src/services/my-order.ts
+var MyOrderService = class extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new MyOrderRepository(storage);
+  }
+  getBasePath() {
+    return "me";
+  }
+  registerRoutes(parent) {
+    const basePath = this.getBasePath();
+    const router = (0, import_express5.Router)({ mergeParams: true });
+    this.extraRoutes(router);
+    router.get("/orders/", this.get.bind(this));
+    router.get("/orders/:id", this.getWithId.bind(this));
+    router.delete("/orders/:id", this.deletewithId.bind(this));
+    router.post("/orders/", this.post.bind(this));
+    router.post("/orders/:id", this.postWithId.bind(this));
+    parent.use(`/${basePath}`, router);
+  }
+};
+
+// src/ctMock.ts
+var DEFAULT_OPTIONS = {
+  enableAuthentication: false,
+  validateCredentials: false,
+  defaultProjectKey: void 0,
+  apiHost: DEFAULT_API_HOSTNAME,
+  authHost: DEFAULT_AUTH_HOSTNAME,
+  silent: false
+};
+var CommercetoolsMock = class {
+  constructor(options = {}) {
+    this._nockScopes = { auth: void 0, api: void 0 };
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+    this._services = {};
+    this._projectService = void 0;
+    this._storage = new InMemoryStorage();
+    this._oauth2 = new OAuth2Server({
+      enabled: this.options.enableAuthentication,
+      validate: this.options.validateCredentials
+    });
+    this.app = this.createApp({ silent: this.options.silent });
+  }
+  start() {
+    this.mockAuthHost();
+    this.mockApiHost();
+  }
+  stop() {
+    var _a, _b;
+    (_a = this._nockScopes.auth) == null ? void 0 : _a.persist(false);
+    this._nockScopes.auth = void 0;
+    (_b = this._nockScopes.api) == null ? void 0 : _b.persist(false);
+    this._nockScopes.api = void 0;
+  }
+  clear() {
+    this._storage.clear();
+  }
+  project(projectKey) {
+    if (!projectKey && !this.options.defaultProjectKey) {
+      throw new Error("No projectKey passed and no default set");
+    }
+    return new ProjectAPI(
+      projectKey || this.options.defaultProjectKey,
+      this._services,
+      this._storage
+    );
+  }
+  runServer(port = 3e3, options) {
+    const app = this.createApp(options);
+    const server = app.listen(port, () => {
+      console.log(`Mock server listening at http://localhost:${port}`);
+    });
+    server.keepAliveTimeout = 60 * 1e3;
+  }
+  createApp(options) {
+    const app = (0, import_express6.default)();
+    const projectRouter = import_express6.default.Router({ mergeParams: true });
+    projectRouter.use(import_express6.default.json());
+    if (!(options == null ? void 0 : options.silent)) {
+      app.use((0, import_morgan.default)("tiny"));
+    }
+    app.use("/oauth", this._oauth2.createRouter());
+    if (this.options.enableAuthentication) {
+      app.use("/:projectKey", this._oauth2.createMiddleware(), projectRouter);
+      app.use(
+        "/:projectKey/in-store/key=:storeKey",
+        this._oauth2.createMiddleware(),
+        projectRouter
+      );
+    } else {
+      app.use("/:projectKey", projectRouter);
+      app.use("/:projectKey/in-store/key=:storeKey", projectRouter);
+    }
+    this._projectService = new ProjectService(projectRouter, this._storage);
+    this._services = {
+      category: new CategoryServices(projectRouter, this._storage),
+      cart: new CartService(projectRouter, this._storage),
+      "cart-discount": new CartDiscountService(projectRouter, this._storage),
+      customer: new CustomerService(projectRouter, this._storage),
+      channel: new ChannelService(projectRouter, this._storage),
+      "customer-group": new CustomerGroupService(projectRouter, this._storage),
+      "discount-code": new DiscountCodeService(projectRouter, this._storage),
+      extension: new ExtensionServices(projectRouter, this._storage),
+      "inventory-entry": new InventoryEntryService(
+        projectRouter,
+        this._storage
+      ),
+      "key-value-document": new CustomObjectService(
+        projectRouter,
+        this._storage
+      ),
+      order: new OrderService(projectRouter, this._storage),
+      payment: new PaymentService(projectRouter, this._storage),
+      "my-cart": new MyCartService(projectRouter, this._storage),
+      "my-order": new MyOrderService(projectRouter, this._storage),
+      "my-customer": new MyCustomerService(projectRouter, this._storage),
+      "my-payment": new MyPaymentService(projectRouter, this._storage),
+      "shipping-method": new ShippingMethodService(
+        projectRouter,
+        this._storage
+      ),
+      "product-type": new ProductTypeService(projectRouter, this._storage),
+      product: new ProductService(projectRouter, this._storage),
+      "product-discount": new ProductDiscountService(
+        projectRouter,
+        this._storage
+      ),
+      "product-projection": new ProductProjectionService(
+        projectRouter,
+        this._storage
+      ),
+      "shopping-list": new ShoppingListService(projectRouter, this._storage),
+      state: new StateService(projectRouter, this._storage),
+      store: new StoreService(projectRouter, this._storage),
+      subscription: new SubscriptionService(projectRouter, this._storage),
+      "tax-category": new TaxCategoryService(projectRouter, this._storage),
+      type: new TypeService(projectRouter, this._storage),
+      zone: new ZoneService(projectRouter, this._storage)
+    };
+    app.use((err, req, resp, next) => {
+      if (err instanceof CommercetoolsError) {
+        return resp.status(err.statusCode).send({
+          statusCode: err.statusCode,
+          message: err.message,
+          errors: [err.info]
+        });
+      } else {
+        console.error(err);
+        return resp.status(500).send({
+          error: err.message
+        });
+      }
+    });
+    return app;
+  }
+  mockApiHost() {
+    const app = this.app;
+    this._nockScopes.api = (0, import_nock.default)(this.options.apiHost).persist().get(/.*/).reply(async function(uri) {
+      const response = await (0, import_supertest.default)(app).get(uri).set(copyHeaders(this.req.headers));
+      return [response.status, response.body];
+    }).post(/.*/).reply(async function(uri, body) {
+      const response = await (0, import_supertest.default)(app).post(uri).set(copyHeaders(this.req.headers)).send(body);
+      return [response.status, response.body];
+    }).delete(/.*/).reply(async function(uri, body) {
+      const response = await (0, import_supertest.default)(app).delete(uri).set(copyHeaders(this.req.headers)).send(body);
+      return [response.status, response.body];
+    });
+  }
+  mockAuthHost() {
+    const app = this.app;
+    this._nockScopes.auth = (0, import_nock.default)(this.options.authHost).persist().post(/^\/oauth\/.*/).reply(async function(uri, body) {
+      const response = await (0, import_supertest.default)(app).post(uri + "?" + body).set(copyHeaders(this.req.headers)).send();
+      return [response.status, response.body];
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommercetoolsMock,
+  getBaseResourceProperties
+});
+//# sourceMappingURL=index.js.map