@reactionary/fake 0.6.3

package/capabilities/identity.capability.js

@@ -0,0 +1,89 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  IdentityMutationLoginSchema,
+  IdentityMutationLogoutSchema,
+  IdentityMutationRegisterSchema,
+  IdentityQuerySelfSchema,
+  IdentityCapability,
+  IdentitySchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import { base, en, Faker } from "@faker-js/faker";
+class FakeIdentityCapability extends IdentityCapability {
+  config;
+  factory;
+  currentIdentity = null;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.factory = factory;
+  }
+  async getSelf(_payload) {
+    if (!this.currentIdentity) {
+      this.currentIdentity = {
+        type: "Anonymous"
+      };
+    }
+    return success(this.factory.parseIdentity(this.context, this.currentIdentity));
+  }
+  async login(_payload) {
+    const generator = new Faker({
+      seed: 42,
+      locale: [en, base]
+    });
+    this.currentIdentity = {
+      type: "Registered",
+      id: {
+        userId: generator.string.alphanumeric(32)
+      }
+    };
+    return success(this.factory.parseIdentity(this.context, this.currentIdentity));
+  }
+  async logout(_payload) {
+    this.currentIdentity = {
+      type: "Anonymous"
+    };
+    return success(this.factory.parseIdentity(this.context, this.currentIdentity));
+  }
+  register(_payload) {
+    throw new Error("Method not implemented.");
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityQuerySelfSchema,
+    outputSchema: IdentitySchema
+  })
+], FakeIdentityCapability.prototype, "getSelf", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationLoginSchema,
+    outputSchema: IdentitySchema
+  })
+], FakeIdentityCapability.prototype, "login", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationLogoutSchema,
+    outputSchema: IdentitySchema
+  })
+], FakeIdentityCapability.prototype, "logout", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: IdentityMutationRegisterSchema,
+    outputSchema: IdentitySchema
+  })
+], FakeIdentityCapability.prototype, "register", 1);
+export {
+  FakeIdentityCapability
+};

package/capabilities/index.js

@@ -0,0 +1,15 @@
+export * from "./analytics.capability.js";
+export * from "./cart.capability.js";
+export * from "./category.capability.js";
+export * from "./checkout.capability.js";
+export * from "./identity.capability.js";
+export * from "./inventory.capability.js";
+export * from "./order-search.capability.js";
+export * from "./order.capability.js";
+export * from "./price.capability.js";
+export * from "./product.capability.js";
+export * from "./product-associations.capability.js";
+export * from "./product-reviews.capability.js";
+export * from "./product-search.capability.js";
+export * from "./profile.capability.js";
+export * from "./store.capability.js";

package/capabilities/inventory.capability.js

@@ -0,0 +1,59 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { base, en, Faker } from "@faker-js/faker";
+import {
+  InventoryCapability,
+  InventoryQueryBySKUSchema,
+  InventorySchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+class FakeInventoryCapability extends InventoryCapability {
+  config;
+  factory;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.factory = factory;
+  }
+  async getBySKU(payload) {
+    let hash = 0;
+    for (let i = 0; i < payload.variant.sku.length; i++) {
+      hash = (hash << 5) - hash + payload.variant.sku.charCodeAt(i);
+      hash &= hash;
+    }
+    const generator = new Faker({
+      seed: hash || 42,
+      locale: [en, base]
+    });
+    const quantity = generator.number.int({ min: 0, max: 100 });
+    const status = quantity > 0 ? "inStock" : "outOfStock";
+    const result = {
+      identifier: {
+        variant: payload.variant,
+        fulfillmentCenter: payload.fulfilmentCenter
+      },
+      quantity,
+      status
+    };
+    return success(this.factory.parseInventory(this.context, result));
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: InventoryQueryBySKUSchema,
+    outputSchema: InventorySchema
+  })
+], FakeInventoryCapability.prototype, "getBySKU", 1);
+export {
+  FakeInventoryCapability
+};

package/capabilities/order-search.capability.js

@@ -0,0 +1,74 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  OrderSearchCapability,
+  OrderSearchQueryByTermSchema,
+  OrderSearchResultSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import { Faker, en, base } from "@faker-js/faker";
+class FakeOrderSearchCapability extends OrderSearchCapability {
+  config;
+  generator;
+  factory;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.generator = new Faker({
+      locale: [en, base],
+      seed: config.seeds.product
+    });
+    this.factory = factory;
+  }
+  async queryByTerm(payload) {
+    const items = [];
+    for (let i = 0; i < payload.search.paginationOptions.pageSize; i++) {
+      items.push({
+        customerName: this.generator.company.name(),
+        identifier: {
+          key: this.generator.string.uuid()
+        },
+        inventoryStatus: "Allocated",
+        orderDate: this.generator.date.past().toString(),
+        orderStatus: "Shipped",
+        totalAmount: {
+          currency: "USD",
+          value: this.generator.number.int({ multipleOf: 100 })
+        },
+        userId: {
+          userId: "1234"
+        }
+      });
+    }
+    const totalCount = this.generator.number.int({ min: items.length, max: 200 });
+    const totalPages = Math.ceil(totalCount / payload.search.paginationOptions.pageSize);
+    const result = {
+      identifier: payload.search,
+      items,
+      pageNumber: payload.search.paginationOptions.pageNumber,
+      pageSize: payload.search.paginationOptions.pageSize,
+      totalCount,
+      totalPages
+    };
+    return success(this.factory.parseOrderSearchResult(this.context, result, payload));
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema
+  })
+], FakeOrderSearchCapability.prototype, "queryByTerm", 1);
+export {
+  FakeOrderSearchCapability
+};

package/capabilities/order.capability.js

@@ -0,0 +1,81 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  OrderCapability,
+  OrderQueryByIdSchema,
+  OrderSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import { Faker, en, base } from "@faker-js/faker";
+class FakeOrderCapability extends OrderCapability {
+  config;
+  generator;
+  factory;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.generator = new Faker({
+      locale: [en, base],
+      seed: config.seeds.product
+    });
+    this.factory = factory;
+  }
+  async getById(payload) {
+    const order = {
+      identifier: payload.order,
+      inventoryStatus: "Allocated",
+      items: [],
+      orderStatus: "Shipped",
+      paymentInstructions: [],
+      userId: {
+        userId: "1234"
+      },
+      price: {
+        grandTotal: {
+          currency: "USD",
+          value: this.generator.number.float({ min: 100, max: 1e4, multipleOf: 25 })
+        },
+        totalDiscount: {
+          currency: "USD",
+          value: this.generator.number.float({ min: 100, max: 1e4, multipleOf: 25 })
+        },
+        totalProductPrice: {
+          currency: "USD",
+          value: this.generator.number.float({ min: 100, max: 1e4, multipleOf: 25 })
+        },
+        totalShipping: {
+          currency: "USD",
+          value: this.generator.number.float({ min: 100, max: 1e4, multipleOf: 25 })
+        },
+        totalSurcharge: {
+          currency: "USD",
+          value: this.generator.number.float({ min: 100, max: 1e4, multipleOf: 25 })
+        },
+        totalTax: {
+          currency: "USD",
+          value: this.generator.number.float({ min: 100, max: 1e4, multipleOf: 25 })
+        }
+      }
+    };
+    return success(this.factory.parseOrder(this.context, order));
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: OrderQueryByIdSchema,
+    outputSchema: OrderSchema
+  })
+], FakeOrderCapability.prototype, "getById", 1);
+export {
+  FakeOrderCapability
+};

package/capabilities/price.capability.js

@@ -0,0 +1,99 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  CustomerPriceQuerySchema,
+  ListPriceQuerySchema,
+  PriceCapability,
+  PriceSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import { base, en, Faker } from "@faker-js/faker";
+import { calcSeed } from "../utilities/seed.js";
+class FakePriceCapability extends PriceCapability {
+  config;
+  faker;
+  factory;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.faker = new Faker({
+      locale: [en, base]
+    });
+    this.factory = factory;
+  }
+  createPrice(variantSku, mode) {
+    const seed = calcSeed(variantSku);
+    this.faker.seed(seed);
+    let price = this.faker.number.int({ min: 300, max: 1e5 }) / 100;
+    let onSale = false;
+    if (mode === "customer") {
+      onSale = this.faker.datatype.boolean({ probability: 0.1 });
+      if (onSale) {
+        price = price * this.faker.number.float({ min: 0.5, max: 0.9 });
+      }
+    }
+    const tiers = [];
+    if (variantSku.includes("with-tiers")) {
+      tiers.push({
+        minimumQuantity: this.faker.number.int({ min: 2, max: 5 }),
+        price: {
+          value: price * 0.8,
+          currency: this.context.languageContext.currencyCode
+        }
+      });
+      tiers.push({
+        minimumQuantity: this.faker.number.int({ min: 6, max: 10 }),
+        price: {
+          value: price * 0.6,
+          currency: this.context.languageContext.currencyCode
+        }
+      });
+    }
+    return {
+      identifier: {
+        variant: {
+          sku: variantSku
+        }
+      },
+      unitPrice: {
+        value: price,
+        currency: this.context.languageContext.currencyCode
+      },
+      onSale,
+      tieredPrices: tiers
+    };
+  }
+  async getListPrice(payload) {
+    const base2 = payload.variant.sku === "unknown-sku" ? this.createEmptyPriceResult(payload.variant.sku) : this.createPrice(payload.variant.sku, "list");
+    return success(this.factory.parsePrice(this.context, base2));
+  }
+  async getCustomerPrice(payload) {
+    const base2 = payload.variant.sku === "unknown-sku" ? this.createEmptyPriceResult(payload.variant.sku) : this.createPrice(payload.variant.sku, "customer");
+    return success(this.factory.parsePrice(this.context, base2));
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ListPriceQuerySchema,
+    outputSchema: PriceSchema
+  })
+], FakePriceCapability.prototype, "getListPrice", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CustomerPriceQuerySchema,
+    outputSchema: PriceSchema
+  })
+], FakePriceCapability.prototype, "getCustomerPrice", 1);
+export {
+  FakePriceCapability
+};

package/capabilities/product-associations.capability.js

@@ -0,0 +1,121 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  ProductAssociationsCapability,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import { en, Faker } from "@faker-js/faker";
+import { calcSeed } from "../utilities/seed.js";
+class FakeProductAssociationsCapability extends ProductAssociationsCapability {
+  config;
+  factory;
+  faker;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.factory = factory;
+    this.faker = new Faker({ locale: [en] });
+  }
+  async getAccessories(query) {
+    const associatedProducts = this.generateFakeAssociatedProducts(query.forProduct.key, query.numberOfAccessories || 4, "accessory");
+    const result = associatedProducts.map((product) => ({
+      associationIdentifier: {
+        key: `${query.forProduct.key}-accessory-${product.identifier.key}`
+      },
+      associationReturnType: "productSearchResultItem",
+      product
+    }));
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
+  }
+  async getSpareparts(query) {
+    const associatedProducts = this.generateFakeAssociatedProducts(query.forProduct.key, query.numberOfSpareparts || 4, "sparepart");
+    const result = associatedProducts.map((product) => ({
+      associationIdentifier: {
+        key: `${query.forProduct.key}-sparepart-${product.identifier.key}`
+      },
+      associationReturnType: "productSearchResultItem",
+      product
+    }));
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
+  }
+  async getReplacements(query) {
+    const associatedProducts = this.generateFakeAssociatedProducts(query.forProduct.key, query.numberOfReplacements || 4, "replacement");
+    const result = associatedProducts.map((product) => ({
+      associationIdentifier: {
+        key: `${query.forProduct.key}-replacement-${product.identifier.key}`
+      },
+      associationReturnType: "productSearchResultItem",
+      product
+    }));
+    return success(result.map((x) => this.factory.parseAssociation(this.context, x)));
+  }
+  generateFakeAssociatedProducts(baseProductKey, count, type) {
+    const products = [];
+    const seed = calcSeed(baseProductKey);
+    this.faker.seed(seed);
+    if (baseProductKey.includes("unknown")) {
+      return [];
+    }
+    if (baseProductKey === "product_100201") {
+      return [];
+    }
+    const hasAnyAssociations = this.faker.datatype.boolean({ probability: 0.5 });
+    if (!hasAnyAssociations) {
+      return [];
+    }
+    const numberOfAssociations = Math.min(count, this.faker.number.int({ min: 2, max: 12 }));
+    for (let i = 0; i < numberOfAssociations; i++) {
+      const key = `${baseProductKey}-${type}-${i + 1}`;
+      products.push({
+        identifier: { key },
+        name: `Fake ${type} ${i + 1} for ${baseProductKey}`,
+        slug: key,
+        variants: [{
+          variant: { sku: `${key}-variant` },
+          image: {
+            sourceUrl: `https://via.placeholder.com/300x300?text=${type}+${i + 1}`,
+            altText: `Image for ${type} ${i + 1}`
+          }
+        }]
+      });
+    }
+    return products;
+  }
+}
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], FakeProductAssociationsCapability.prototype, "getAccessories", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], FakeProductAssociationsCapability.prototype, "getSpareparts", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], FakeProductAssociationsCapability.prototype, "getReplacements", 1);
+export {
+  FakeProductAssociationsCapability
+};

package/capabilities/product-reviews.capability.js

@@ -0,0 +1,154 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  ProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema,
+  ProductReviewSchema,
+  ProductReviewsCapability,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import { base, en, Faker } from "@faker-js/faker";
+import { calcSeed } from "../utilities/seed.js";
+class FakeProductReviewsCapability extends ProductReviewsCapability {
+  config;
+  factory;
+  faker;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.factory = factory;
+    this.faker = new Faker({ locale: [en, base] });
+  }
+  createReviewsForProduct(productIdentifier) {
+    const seed = calcSeed(productIdentifier.key);
+    this.faker.seed(seed);
+    const hasAnyReviews = this.faker.datatype.boolean({ probability: 0.5 });
+    if (!hasAnyReviews || productIdentifier.key === "unknown-product-id") {
+      return [];
+    }
+    const reviews = [];
+    const totalReviews = this.faker.number.int({ min: 1, max: 20 });
+    for (let i = 0; i < totalReviews; i++) {
+      const hasReply = this.faker.datatype.boolean({ probability: 0.3 });
+      reviews.push({
+        identifier: {
+          key: `fake-review-${productIdentifier.key}-${i}`
+        },
+        product: productIdentifier,
+        authorName: this.faker.person.fullName(),
+        authorId: this.faker.string.uuid(),
+        rating: this.faker.number.int({ min: 1, max: 5 }),
+        title: this.faker.lorem.sentence(),
+        content: this.faker.lorem.paragraphs({ min: 1, max: 5 }),
+        createdAt: this.faker.date.past({ years: 1 }).toISOString(),
+        updatedAt: this.faker.datatype.boolean() ? this.faker.date.recent({ days: 30 }).toISOString() : void 0,
+        verified: this.faker.datatype.boolean(),
+        reply: hasReply ? this.faker.lorem.sentences(2) : void 0,
+        repliedAt: hasReply ? this.faker.date.recent({ days: 7 }).toISOString() : void 0
+      });
+    }
+    return reviews.sort(
+      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    );
+  }
+  async getRatingSummary(query) {
+    const reviews = this.createReviewsForProduct(query.product);
+    if (reviews.length === 0) {
+      const emptySummary = this.createEmptyProductRatingSummary({ product: query.product });
+      return success(this.factory.parseRatingSummary(this.context, emptySummary));
+    }
+    const totalRatings = reviews.length;
+    const averageRating = reviews.reduce((sum, review) => sum + review.rating, 0) / totalRatings;
+    const summary = {
+      identifier: {
+        product: query.product
+      },
+      averageRating,
+      totalRatings,
+      ratingDistribution: {
+        "1": reviews.filter((x) => x.rating === 1).length,
+        "2": reviews.filter((x) => x.rating === 2).length,
+        "3": reviews.filter((x) => x.rating === 3).length,
+        "4": reviews.filter((x) => x.rating === 4).length,
+        "5": reviews.filter((x) => x.rating === 5).length
+      }
+    };
+    return success(this.factory.parseRatingSummary(this.context, summary));
+  }
+  async findReviews(query) {
+    const pageSize = query.paginationOptions?.pageSize ?? 20;
+    const pageNumber = query.paginationOptions?.pageNumber ?? 1;
+    const reviews = this.createReviewsForProduct(query.product);
+    const returnedReviews = reviews.slice((pageNumber - 1) * pageSize, pageNumber * pageSize);
+    const result = {
+      items: returnedReviews,
+      totalCount: reviews.length,
+      pageSize,
+      pageNumber,
+      totalPages: Math.ceil(reviews.length / Math.max(pageSize, 1))
+    };
+    return success(this.factory.parseReviewPaginatedResult(this.context, result));
+  }
+  async submitReview(mutation) {
+    if (this.context.session.identityContext.identity.type !== "Registered") {
+      return error({
+        type: "InvalidInput",
+        error: "Only registered users can submit reviews."
+      });
+    }
+    const review = {
+      identifier: {
+        key: this.faker.string.uuid()
+      },
+      product: mutation.product,
+      authorName: mutation.authorName,
+      rating: mutation.rating,
+      title: mutation.title,
+      content: mutation.content,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: this.faker.datatype.boolean()
+    };
+    return success(this.factory.parseReview(this.context, review));
+  }
+}
+__decorateClass([
+  Reactionary({
+    outputSchema: ProductRatingSummarySchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], FakeProductReviewsCapability.prototype, "getRatingSummary", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: ProductReviewPaginatedResultSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 60,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+], FakeProductReviewsCapability.prototype, "findReviews", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: ProductReviewSchema,
+    cache: false,
+    cacheTimeToLiveInSeconds: 0,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], FakeProductReviewsCapability.prototype, "submitReview", 1);
+export {
+  FakeProductReviewsCapability
+};