@labdigital/commercetools-mock 2.8.0 → 2.10.0

package/README.md

@@ -42,9 +42,14 @@ const ctMock = new CommercetoolsMock({
 })
 
 describe('A module', () => {
+  const mswServer = setupServer()
+
   beforeAll(() => {
-    const server = setupServer()
-    ctMock.registerHandlers(server)
+    mswServer.listen({ onUnhandledRequest: "error" })
+  })
+
+  beforeEach(() => {
+    ctMock.registerHandlers(mswServer)
 
     ctMock.project().add('type', {
       ...getBaseResourceProperties()
@@ -54,11 +59,11 @@ describe('A module', () => {
   })
 
   afterAll(() => {
-    server.clearHandlers()
-    ctMock.stop()
+    mswServer.close()
   })
 
   afterEach(() => {
+    server.clearHandlers()
     ctMock.clear()
   })
 

package/dist/index.cjs

@@ -720,7 +720,7 @@ var resolveValue = (obj, val) => {
     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 void 0;
   }
   return obj[val.value];
 };
@@ -800,22 +800,43 @@ var generateMatchFunc = (predicate) => {
     const expr = parser.parse();
     lexer.expect(")");
     return (obj, vars) => {
-      const value = resolveValue(obj, left);
-      if (value) {
-        return expr(value, vars);
+      if (Array.isArray(obj)) {
+        return obj.some((item) => {
+          const value = resolveValue(item, left);
+          if (value) {
+            return expr(value, vars);
+          }
+          return false;
+        });
+      } else {
+        const value = resolveValue(obj, left);
+        if (value) {
+          return expr(value, vars);
+        }
+        return false;
       }
-      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);
+      if (Array.isArray(obj)) {
+        return obj.some((item) => {
+          const value = resolveValue(item, left);
+          const other = resolveSymbol(expr, vars);
+          if (Array.isArray(value)) {
+            return !!value.some((elem) => elem === other);
+          }
+          return value === other;
+        });
+      } else {
+        const resolvedValue = resolveValue(obj, left);
+        const resolvedSymbol = resolveSymbol(expr, vars);
+        if (Array.isArray(resolvedValue)) {
+          return !!resolvedValue.some((elem) => elem === resolvedSymbol);
+        }
+        return resolvedValue === resolvedSymbol;
       }
-      return resolvedValue === resolvedSymbol;
     };
   }).led("!=", 20, ({ left, bp }) => {
     const expr = parser.parse({ terminals: [bp - 1] });
@@ -883,10 +904,11 @@ var generateMatchFunc = (predicate) => {
       if (!Array.isArray(symbols)) {
         symbols = [expr];
       }
-      const inValues = symbols.map(
+      const inValues = symbols.flatMap(
         (item) => resolveSymbol(item, vars)
       );
-      return inValues.includes(resolveValue(obj, left));
+      const value = resolveValue(obj, left);
+      return inValues.includes(value);
     };
   }).led("MATCHES_IGNORE_CASE", 20, ({ left, bp }) => {
     const expr = parser.parse({ terminals: [bp - 1] });
@@ -1064,9 +1086,12 @@ var InMemoryStorage = class extends AbstractStorage {
     }
     let resources = this.all(projectKey, typeId);
     if (params.where) {
+      const vars = Object.fromEntries(
+        Object.entries(params).filter(([key]) => key.startsWith("var.")).map(([key, value]) => [key.slice(4), value])
+      );
       try {
         const filterFunc = parseQueryExpression(params.where);
-        resources = resources.filter((resource) => filterFunc(resource, {}));
+        resources = resources.filter((resource) => filterFunc(resource, vars));
       } catch (err) {
         throw new CommercetoolsError(
           {
@@ -1133,28 +1158,34 @@ var InMemoryStorage = class extends AbstractStorage {
       if (resource) {
         return resource;
       }
-      console.error(
-        `No resource found with typeId=${identifier.typeId}, id=${identifier.id}`
-      );
-      return null;
+      throw new CommercetoolsError({
+        code: "ReferencedResourceNotFound",
+        message: `The referenced object of type '${identifier.typeId}' with id '${identifier.id}' 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).`,
+        typeId: identifier.typeId,
+        id: identifier.id
+      });
     }
     if (identifier.key) {
-      const store = this.forProjectKey(projectKey)[identifier.typeId];
-      if (store) {
-        const resource = Array.from(store.values()).find(
-          // @ts-ignore
-          (r) => r.key === identifier.key
-        );
-        if (resource) {
-          return resource;
-        }
-      } else {
-        throw new Error(
-          `No storage found for resource type: ${identifier.typeId}`
-        );
+      const resource = this.getByKey(
+        projectKey,
+        identifier.typeId,
+        identifier.key
+      );
+      if (resource) {
+        return resource;
       }
+      throw new CommercetoolsError({
+        code: "ReferencedResourceNotFound",
+        message: `The referenced object of type '${identifier.typeId}' with key '${identifier.key}' 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).`,
+        typeId: identifier.typeId,
+        key: identifier.key
+      });
     }
-    return null;
+    throw new CommercetoolsError({
+      code: "InvalidJsonInput",
+      message: "Request body does not contain valid JSON.",
+      detailedErrorMessage: "ResourceIdentifier requires an 'id' xor a 'key'"
+    });
   }
   addProject = (projectKey) => {
     if (!this.projects[projectKey]) {
@@ -1308,11 +1339,12 @@ var hashPassword = (clearPassword) => Buffer.from(clearPassword).toString("base6
 
 // src/oauth/server.ts
 var OAuth2Server = class {
-  store;
-  customerRepository;
   constructor(options) {
+    this.options = options;
     this.store = new OAuth2Store(options.validate);
   }
+  store;
+  customerRepository;
   setCustomerRepository(repository) {
     this.customerRepository = repository;
   }
@@ -1336,6 +1368,11 @@ var OAuth2Server = class {
     return router;
   }
   createMiddleware() {
+    if (!this.options.validate) {
+      return async (request, response, next) => {
+        next();
+      };
+    }
     return async (request, response, next) => {
       const token = getBearerToken(request);
       if (!token) {
@@ -1873,10 +1910,7 @@ var AbstractResourceRepository = class extends AbstractRepository {
   }
   query(context, params = {}) {
     const result = this._storage.query(context.projectKey, this.getTypeId(), {
-      expand: params.expand,
-      where: params.where,
-      offset: params.offset,
-      limit: params.limit
+      ...params
     });
     result.results = result.results.map(this.postProcessResource);
     return result;
@@ -2196,6 +2230,11 @@ var CartRepository = class extends AbstractResourceRepository {
         fractionDigits: 0
       },
       shippingMode: "Single",
+      shippingAddress: createAddress(
+        draft.shippingAddress,
+        context.projectKey,
+        this._storage
+      ),
       shipping: [],
       origin: draft.origin ?? "Customer",
       refusedGifts: [],
@@ -2313,6 +2352,8 @@ var CartRepository = class extends AbstractResourceRepository {
       }
       resource.totalPrice.centAmount = calculateCartTotalPrice(resource);
     },
+    recalculate: () => {
+    },
     addItemShippingAddress: (context, resource, { action, address }) => {
       const newAddress = createAddress(
         address,
@@ -2397,9 +2438,6 @@ var CartRepository = class extends AbstractResourceRepository {
           context.projectKey,
           shippingMethod
         );
-        if (!method) {
-          throw new Error(`Type ${shippingMethod} not found`);
-        }
         resource.shippingInfo = {
           shippingMethod: {
             typeId: "shipping-method",
@@ -2423,6 +2461,33 @@ var CartRepository = class extends AbstractResourceRepository {
       }
       resource.custom.fields[name] = value;
     },
+    setCustomShippingMethod: (context, resource, {
+      shippingMethodName,
+      shippingRate,
+      taxCategory,
+      externalTaxRate
+    }) => {
+      if (externalTaxRate) {
+        throw new Error("External tax rate is not supported");
+      }
+      const tax = taxCategory ? this._storage.getByResourceIdentifier(
+        context.projectKey,
+        taxCategory
+      ) : void 0;
+      resource.shippingInfo = {
+        shippingMethodName,
+        price: createCentPrecisionMoney(shippingRate.price),
+        shippingRate: {
+          price: createTypedMoney(shippingRate.price),
+          tiers: []
+        },
+        taxCategory: tax ? {
+          typeId: "tax-category",
+          id: tax?.id
+        } : void 0,
+        shippingMethodState: "MatchesCart"
+      };
+    },
     setCustomType: (context, resource, { type, fields }) => {
       if (!type) {
         resource.custom = void 0;
@@ -2974,6 +3039,16 @@ var CustomObjectRepository = class extends AbstractResourceRepository {
       return resource;
     }
   }
+  queryWithContainer(context, container, params = {}) {
+    const whereClause = params.where || [];
+    whereClause.push(`container="${container}"`);
+    const result = this._storage.query(context.projectKey, this.getTypeId(), {
+      ...params,
+      where: whereClause
+    });
+    result.results = result.results.map(this.postProcessResource);
+    return result;
+  }
   getWithContainerAndKey(context, container, key) {
     const items = this._storage.all(context.projectKey, this.getTypeId());
     return items.find(
@@ -5502,6 +5577,50 @@ var ReviewRepository = class extends AbstractResourceRepository {
 
 // src/repositories/shipping-method.ts
 var import_deep_equal3 = __toESM(require("deep-equal"), 1);
+
+// src/shippingCalculator.ts
+var markMatchingShippingRate = (cart, shippingRate) => {
+  const isMatching = shippingRate.price.currencyCode === cart.totalPrice.currencyCode;
+  return {
+    ...shippingRate,
+    tiers: markMatchingShippingRatePriceTiers(cart, shippingRate.tiers),
+    isMatching
+  };
+};
+var markMatchingShippingRatePriceTiers = (cart, tiers) => {
+  if (tiers.length === 0) {
+    return [];
+  }
+  if (new Set(tiers.map((tier) => tier.type)).size > 1) {
+    throw new Error("Can't handle multiple types of tiers");
+  }
+  const tierType = tiers[0].type;
+  switch (tierType) {
+    case "CartValue":
+      return markMatchingCartValueTiers(cart, tiers);
+    default:
+      throw new Error(`Unsupported tier type: ${tierType}`);
+  }
+};
+var markMatchingCartValueTiers = (cart, tiers) => {
+  const sortedTiers = [...tiers].sort(
+    (a, b) => b.minimumCentAmount - a.minimumCentAmount
+  );
+  const result = {};
+  let hasMatchingTier = false;
+  for (const tier of sortedTiers) {
+    const isMatching = !hasMatchingTier && cart.totalPrice.currencyCode === tier.price.currencyCode && cart.totalPrice.centAmount >= tier.minimumCentAmount;
+    if (isMatching)
+      hasMatchingTier = true;
+    result[tier.minimumCentAmount] = {
+      ...tier,
+      isMatching
+    };
+  }
+  return tiers.map((tier) => result[tier.minimumCentAmount]);
+};
+
+// src/repositories/shipping-method.ts
 var ShippingMethodRepository = class extends AbstractResourceRepository {
   getTypeId() {
     return "shipping-method";
@@ -5541,6 +5660,53 @@ var ShippingMethodRepository = class extends AbstractResourceRepository {
     freeAbove: rate.freeAbove && createTypedMoney(rate.freeAbove),
     tiers: rate.tiers || []
   });
+  /*
+   * Retrieves all the ShippingMethods that can ship to the shipping address of
+   * the given Cart. Each ShippingMethod contains exactly one ShippingRate with
+   * the flag isMatching set to true. This ShippingRate is used when the
+   * ShippingMethod is added to the Cart.
+   */
+  matchingCart(context, cartId, params = {}) {
+    const cart = this._storage.get(context.projectKey, "cart", cartId);
+    if (!cart) {
+      return void 0;
+    }
+    if (!cart.shippingAddress?.country) {
+      throw new CommercetoolsError({
+        code: "InvalidOperation",
+        message: `The cart with ID '${cart.id}' does not have a shipping address set.`
+      });
+    }
+    const zones = this._storage.query(context.projectKey, "zone", {
+      where: [`locations(country="${cart.shippingAddress.country}"))`],
+      limit: 100
+    });
+    const zoneIds = zones.results.map((zone) => zone.id);
+    const shippingMethods = this.query(context, {
+      where: [
+        `zoneRates(zone(id in (:zoneIds)))`,
+        `zoneRates(shippingRates(price(currencyCode="${cart.totalPrice.currencyCode}")))`
+      ],
+      "var.zoneIds": zoneIds,
+      expand: params.expand
+    });
+    const results = shippingMethods.results.map((shippingMethod) => {
+      const rates = shippingMethod.zoneRates.map((zoneRate) => ({
+        zone: zoneRate.zone,
+        // Iterate through the shippingRates and mark the matching ones
+        // then we filter out the non-matching ones
+        shippingRates: zoneRate.shippingRates.map((rate) => markMatchingShippingRate(cart, rate)).filter((rate) => rate.isMatching)
+      })).filter((zoneRate) => zoneRate.shippingRates.length > 0);
+      return {
+        ...shippingMethod,
+        zoneRates: rates
+      };
+    }).filter((shippingMethod) => shippingMethod.zoneRates.length > 0);
+    return {
+      ...shippingMethods,
+      results
+    };
+  }
   actions = {
     addShippingRate: (_context, resource, { shippingRate, zone }) => {
       const rate = this._transformShippingRate(shippingRate);
@@ -6394,10 +6560,26 @@ var CustomObjectService = class extends AbstractService {
     return "custom-objects";
   }
   extraRoutes(router) {
+    router.get("/:container", this.getWithContainer.bind(this));
     router.get("/:container/:key", this.getWithContainerAndKey.bind(this));
     router.post("/:container/:key", this.createWithContainerAndKey.bind(this));
     router.delete("/:container/:key", this.deleteWithContainerAndKey.bind(this));
   }
+  getWithContainer(request, response) {
+    const limit = this._parseParam(request.query.limit);
+    const offset = this._parseParam(request.query.offset);
+    const result = this.repository.queryWithContainer(
+      getRepositoryContext(request),
+      request.params.container,
+      {
+        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);
+  }
   getWithContainerAndKey(request, response) {
     const result = this.repository.getWithContainerAndKey(
       getRepositoryContext(request),
@@ -6836,7 +7018,21 @@ var ShippingMethodService = class extends AbstractService {
     return "shipping-methods";
   }
   extraRoutes(parent) {
-    parent.get("/matching-cart", this.get.bind(this));
+    parent.get("/matching-cart", this.matchingCart.bind(this));
+  }
+  matchingCart(request, response) {
+    const cartId = queryParamsValue(request.query.cartId);
+    if (!cartId) {
+      return response.status(400).send();
+    }
+    const result = this.repository.matchingCart(
+      getRepositoryContext(request),
+      cartId,
+      {
+        expand: this._parseParam(request.query.expand)
+      }
+    );
+    return response.status(200).send(result);
   }
 };